text
stringlengths 20
1.01M
| url
stringlengths 14
1.25k
| dump
stringlengths 9
15
⌀ | lang
stringclasses 4
values | source
stringclasses 4
values |
|---|---|---|---|---|
# Организация on-line платежей на сайте. Для тех, кто никогда этим не занимался, но боится, что придётся. Часть 2: архитектура
Вслед за [первой частью](http://habrahabr.ru/blogs/webdev/75191/), призванной в первую очередь показать, что «не так страшен чёрт, как его малюют»
Статья об архитектуре части проекта, которая занимается он-лайн платежами. Намеренно не хотелось бы сейчас подробно описывать API конкретного биллинга или процедуру регистрации в нём. Тонкости конкретных биллингов нужно обсуждать отдельно, иначе тему просто не раскрыть. Цель статьи: обсудить вариант архитектуры, позволяющий нанизывать новые виды биллингов и типы платежей, с наименьшей головной болью.
Итак, для начала, представьте, мы **немного** подумали и сделали у себя на сайте **очень простую** продажу товаров через одну из биллинговых систем.
1. У нас есть информация о товаре: ID товара, цена, <характеристики>.
2. Пользователи ходят по сайту и нажимают на кнопку «купить». Сохраняем информацию о покупке: ID покупки, ID товара, цена товара в тот момент, <информация о покупателе>;
3. Пользователь смотрит свои покупки, жмёт «оплатить» для одной из них. Сохраняем информацию о платеже: ID платежа, ID покупки, дата платежа, статус платежа (, сумма платежа), и отправляем пользователя к биллинговой системе;
4. Скрипт, обрабатывающий ответы биллинга, сохраняет данные об ответе: ID ответа, <всё, что прислал биллинг >, дата ответа, статус ответа. Проверяет валидность ответа, по результату проверки сохраняет статус ответа. Если всё ок, то выставляет нужной покупке статус «оплачено»
5. информация об оплаченной покупке отображается у модераторов с пометкой «необходимо доставить»
\**Информация о покупателе — это может быть номер пользователя, по которому вы сможете найти все необходимые данные, а могут быть непосредственно данные (адрес, телефон, …), если вы не хотите обременять своих пользователей регистрацией.*
Всё это мы отладили, и некоторое время даже были довольны своей работой. Но, всё чаще слышим: надо бы ещё биллинг такой-то прикрутить. К тому же мы хотим продавать не только товары, но и разные типы аккаунтов своим пользователям, а ещё пусть отдельно платят, если хотят поднять свой рейтинг на 10 пунктов, и так далее и так далее. Назовём это покупками, но будем иметь ввиду что покупки теперь разного типа.
Как известно, хорошая мысля приходит опосля. Только когда мне пришлось прикрутить пару биллингов и организовать несколько различных типов покупок, в моей системе отделились обработка покупки от обработки биллинга, выделились общие части в работе с разными биллингами, закономерности в обработке покупок разных типов.
Отделение обработки покупок от обработки биллинговых операций, даёт возможность
* подключать один раз и в одном месте новый биллинг, независимо от того сколько типов покупок существует в системе;
* подключать один раз и в одном месте новый тип покупки, независимо от того, сколько биллингов должно с ним работать;
При обработке разных типов покупок, можно заметить, что все их можно разбить на составляющие:
1. В системе доступна информация о конкретном товаре: ID (уникальный для этого типа), цена, <характеристики>. Это может быть описание товара в магазине, или описание типа аккаунта и периода его действия, или описание услуги увеличения рейтинга на N позиций;
2. Сохранение информации о выборе пользователя (какой пользователь, какой тип товара и какой номер товара выбрал);
3. Изменение статуса покупки (оплачена, удалена, …);
4. Реализация покупки, назовём это так. (например: доставка товара, или смена типа аккаунта на указанный период, или увеличение рейтинга на N позиций);
Сейчас видно, что принципиальные различия есть только в пунктах 1 и 4. При соблюдении интерфейса класса, описывающего тип покупки и действия при реализации покупки, схема обработки различных типов покупки становится единой.
Работу с биллинговой системой можно разбить на пункты:
1. Сохранение информации о платеже: ID платежа, тип биллинга, ID покупки, статус платежа, <прочие характеристики>;
2. Редирект пользователя на биллинговую систему, с указанием номера платежа и суммы покупки;
3. Проверка валидности ответа от биллинга;
4. Смена статуса платежа;
5. Если всё ок, вызов обработки покупки (смена статуса покупки, реализация покупки, …).
Пункты 2 и 3 для различных биллингов будут свои. Т.О. при соблюдении интерфейса класса, описывающего тип биллинга, реализующего функции 2 и 3, схема работы с различными биллингами тоже унифицируется.
Диаграмма классов, для визуального отображения описанной структуры:
Это общие принципы, которые я стараюсь соблюдать в своей работе. Думаю эту схему можно и нужно совершенствовать. Надеюсь на конструктивное обсуждение.
---
Помню, по первой части статьи, что от меня ждут не только общие слова, но и конкретные строки кода. Приблизительно, код этой конструкции приведён ниже. Реальный пример, выдернут из контекста и урезан по максимуму, чтоб выделить основную суть. К сожалению даже при этом получилось многовато кода :)
*Сразу оговорюсь, в другом языке, можно было обойтись абстрактным классом и его наследниками, но поскольку в PHP нельзя переопределить статическую функцию, предков разделили на интерфейс + базовый класс.*
Интерфейс покупок и пример для реализации платного мембершипа:
> `interface InterfacePurchase {
>
> public function getId();
>
>
>
> public function getItemId();
>
> public function setItemId ($val);
>
>
>
> public function getItemType();
>
> public function setItemType ($val);
>
>
>
> public function getPrice();
>
> public function setPrice ($val);
>
>
>
> public function getUserId();
>
> public function setUserId($val);
>
>
>
> public function getStatus();
>
> public function setStatus($val);
>
>
>
> public function save ();
>
>
>
> /\*\*
>
> \* действия после оплаты покупки
>
> \*/
>
> public function callbackPayment ();
>
>
>
> /\*\*
>
> \* возвращает объект-товар. для каждого типа покупки, свой тип товара
>
> \*/
>
> public function getItem ();
>
> }
>
>
>
> class CPurchase {
>
> protected $\_mPurchase = null;
>
>
>
> /\*\*
>
> \* @return InterfacePurchase
>
> \*\*/
>
> public static function createPurchaseByType ($type) {
>
> $purchase = null;
>
> switch($type){
>
> case PURCHASE\_SHOP: $purchase = new CPurchaseShop(); break;
>
> case PURCHASE\_ACCOUNT: $purchase = new CPurchaseAccount(); break;
>
> case PURCHASE\_RAIT: $purchase = new CPurchaseRait(); break;
>
> // ...
>
> default: throw new ExceptionUnknownPurchaseType (\_\_CLASS\_\_);
>
> }
>
> $purchase->\_mPurchase = new CPurchaseItem ();
>
> return $purchase;
>
> }
>
>
>
> /\*\*
>
> \* @return InterfacePurchase
>
> \*\*/
>
> public static function loadPurchaseById($id){
>
> $purchase\_item = CPurchaseItem::getById($id);
>
> $purchase = self::createPurchaseByType($purchase\_item->getType());
>
> $purchase->\_mPurchase = $purchase\_item;
>
> }
>
>
>
> public function getId() { return $this->\_mPurchase->getId(); }
>
>
>
> public function getItemId() { return $this->\_mPurchase->getItemId();}
>
> public function setItemId ($val) { return $this->\_mPurchase->setItemId( $val ); }
>
>
>
> public function getItemType() { return $this->\_mPurchase->getItemType(); }
>
> public function setItemType ($val) { return $this->\_mPurchase->setItemType( $val ); }
>
>
>
> public function getPrice() { return $this->\_mPurchase->getPrice (); }
>
> public function setPrice ($val) { return $this->\_mPurchase->setPrice ( $val ); }
>
>
>
> public function getUserId() { return $this->\_mPurchase->getUserId(); }
>
> public function setUserId($val) { return $this->\_mPurchase->setUserId($val); }
>
>
>
> public function getStatus() { return $this->\_mPurchase->getStatus(); }
>
> public function setStatus($val) { return $this->\_mPurchase->setStatus($val); }
>
>
>
> public function save () { $this->\_mPurchase->save(); }
>
>
>
> }
>
>
>
> Class CPurchaseAccount extends CPurchase implements InterfacePurchase {
>
>
>
> public function getItem (){
>
> $item = null;
>
> If ($item\_id = $this->getItemId()) {
>
> $item = CMembership::getById($item\_id);
>
> }
>
> return $item;
>
> }
>
> public function callbackPayment () {
>
> $this->setStatus(PURCHASE\_STATUS\_OK);
>
> ServiceAccount::setMembership($this->getUserId(), $this->getItemId());
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Интерфейс биллинга и пример для реализации работы с Robox:
> `interface InterfaceBilling {
>
> public function getId();
>
>
>
> public function getPurchaseId();
>
> public function setPurchaseId ($val);
>
>
>
> public function getBillingType();
>
> public function setBillingType ($val);
>
>
>
> public function getStatus();
>
> public function setStatus($val);
>
>
>
> public function save ();
>
>
>
> /\*\*
>
> \* по правилам конкретного биллинга перенаправляем юзера
>
> \*/
>
> public function redirectToBilling ();
>
>
>
> /\*\*
>
> \* по набору параметров, определяем, от какого биллинга пришёл ответ
>
> \*/
>
> public static function checkResponseFormat ($data);
>
>
>
> /\*\*
>
> \* проверяем валидность ответа от биллинга
>
> \*/
>
> public function checkResult ($data);
>
>
>
> /\*\*
>
> \* даём ответ биллингу по результатам проверок. В фрмате, который требует конкретный биллинг.
>
> \*/
>
> public function addResultInView ($view, $results);
>
> }
>
>
>
> class CBilling {
>
> protected $\_mBilling = null;
>
>
>
> /\*\*
>
> \* @return InterfaceBilling
>
> \*\*/
>
> public static function createBillingByType( $type ) {
>
> switch($type){
>
> case BILLING\_ROBOX: $billing = new CBillingRobox(); break;
>
> case BILLING\_WM: $billing = new CBillingWM(); break;
>
> // ...
>
> default: throw new ExceptionUnknownBillingType (\_\_CLASS\_\_);
>
> }
>
> $billing->\_mBilling = new CBillingItem();
>
> $this->setBillingType($type);
>
> }
>
>
>
> public static function getBillingTypeByRequest($response\_data) {
>
> $billing\_type = null;
>
> if(CBillingRobox::checkResponseFormat($response\_data)) {
>
> $billing\_type = self::BILLING\_ROBOX;
>
> }
>
> if(CBillingWM::checkResponseFormat($response\_data)) {
>
> $billing\_type = self::BILLING\_WM;
>
> }
>
>
>
> return $billing\_type;
>
> }
>
>
>
> public function getId() { return $this->\_mBilling->getId(); }
>
>
>
> public function getPurchaseId() { return $this->\_mBilling->getPurchaseId(); }
>
> public function setPurchaseId ($val) { return $this->\_mBilling->setPurchaseId($val); }
>
>
>
> public function getBillingType() { return $this->\_mBilling->getBillingType(); }
>
> public function setBillingType ($val) { return $this->\_mBilling->setBillingType($val); }
>
>
>
> public function getStatus() { return $this->\_mBilling->getStatus(); }
>
> public function setStatus($val) { return $this->\_mBilling->setStatus($val); }
>
>
>
> public function save () { $this->\_mBilling->save(); }
>
>
>
> public function checkSumm($summ) {
>
> $purchase = CPurchaseItem::getById($this->getPurchaseId());
>
> return intval($purchase->getPrice()) == intval($summ);
>
> }
>
>
>
> public function checkStatusNotFinish() {
>
> $purchase = CPurchaseItem::getById($this->getPurchaseId());
>
> return PURCHASE\_STATUS\_OK != $purchase->getStatus();
>
> }
>
> }
>
>
>
> class CBillingRobox extends CBilling implements InterfaceBilling {
>
> public function redirectToBilling () {
>
> $redirect\_uri = Config::getKey('pay\_uri', 'robox');
>
> $purchase = CPurchaseItem::getById($this->getPurchaseId());
>
> $hash = array(
>
> 'MrchLogin' => Config::getKey('merchant\_login', 'robox'),
>
> 'OutSum' => $purchase->getPrice(),
>
> 'InvId' => $this->getId(),
>
> 'SignatureValue' => $this->\_getSignatureValue()
>
> );
>
>
>
> MyApplication::redirect($redirect\_uri, $hash);
>
> }
>
>
>
> public static function checkResponseFormat ($data) {
>
> $is\_id = isset($data['InvId']);
>
> $is\_summ = isset($data['OutSum']);
>
> $is\_resp\_crc = isset($data['SignatureValue']);
>
> $result = $is\_id && $is\_summ && $is\_resp\_crc;
>
> return $result;
>
> }
>
>
>
> public function checkResult ($data) {
>
> $billing\_item\_id = isset($data['InvId'])? $data['InvId']:0;
>
> $summ = isset($data['OutSum'])? $data['OutSum']:0;
>
> $result = FALSE;
>
> $purchase = null;
>
> try {
>
> $this->\_mBilling = CBillingItem::sgetById($billing\_item\_id);
>
> $purchase = CPurchase::loadPurchaseById($this->getPurchaseId());
>
> } catch (ExObjectNotFound $e) {}
>
>
>
> if($this->\_mBilling && $purchase) {
>
>
>
> $is\_valid\_control\_summ = $this->\_checkControlSumm($data);
>
> $is\_valid\_summ = $this->\_checkSumm($summ);
>
> $is\_valid\_status = $this->\_checkStatusNotFinish();
>
>
>
> if($is\_valid\_control\_summ && $is\_valid\_summ && $is\_valid\_status) {
>
> $result = TRUE;
>
> $this->callbackPayment();
>
> $purchase->callbackPayment();
>
>
>
> }
>
> }
>
>
>
> return $result;
>
> }
>
> public function addResultInView ($view, $result) {
>
> if($result && $this->getId()) {
>
> $view->addText("OK");
>
> $view->addText($this->getId());
>
> } else {
>
> $view->addText("ERROR");
>
> }
>
> }
>
>
>
> private function \_getSignatureValue() {
>
> $purchase = CPurchaseItem::getById($this->getPurchaseId());
>
> $hash = array(
>
> Config::getKey('merchant\_login', 'robox') ,
>
> $purchase->getPrice(),
>
> $this->getId(),
>
> Config::getKey('merchant\_password1', 'robox')
>
> );
>
>
>
> return md5(join(':', $hash));
>
> }
>
> private function checkControlSumm($data) {
>
> $resp\_crc = isset($data['SignatureValue'])? $data['SignatureValue']:0;
>
> return strtoupper(self::getControlSumm($data)) == strtoupper($resp\_crc);
>
> }
>
> static public function getControlSumm($data) {
>
> $hash = array(
>
> isset($data['OutSum'])? $data['OutSum']:'',
>
> isset($data['InvId'])? $data['InvId']:'',
>
> Config::getKey('merchant\_password2', 'robox')
>
> );
>
> return md5(join(':', $hash));
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Пример использования данной архитектуры:
> `class ModuleBilling {
>
> private function \_createResponse(){
>
> //сохранить данные, пришедшие от биллинга
>
> }
>
> // страница, обрабатывающая запросы от биллинга:
>
> public function actionResultPage () {
>
> $response = $this->\_createResponse();
>
> $response\_data = $\_REQUEST;
>
> $view = new View();
>
>
>
> if( $billing\_type = CBilling::getBillingTypeByRequest( $response\_data ) ) {
>
>
>
> $billing = CBilling::createBillingByType($billing\_type);
>
> $result = $billing->checkResult($response\_data);
>
> if($result){
>
> $response->setStatus(CResponse::STATUS\_OK);
>
> }else{
>
> $response->setStatus(CResponse::STATUS\_ERROR);
>
> }
>
> $response->save();
>
> $billing->addResultInView($view, $result);
>
> }
>
> return $view;
>
> }
>
>
>
> // редирект пользователя на биллинговую систему:
>
> public function actionBilling($req = array()){
>
> $user = ServiceUser::checkAccess();
>
> $billing\_type = Request::getQueryVar('type');
>
> $purchase\_id = Request::getQueryVar('purchase');
>
> $purchase = CPurchase::loadPurchaseById($purchase\_id);
>
> $purchase->setStatus(PURCHASE\_STATUS\_WAITMONEY);
>
> $purchase->save();
>
>
>
> $billing = CBilling::createBillingByType($billing\_type);
>
> $billing->setPurchaseId($purchase\_id);
>
> $billing->setStatus(BILLING\_STATUS\_WAITMONEY);
>
> $billing->save();
>
> $billing->redirectToBilling();
>
> }
>
> }
>
>
>
> // где то там в системе:
>
> ...
>
> $action = new ModuleBilling ();
>
> $action->actionResultPage();
>
> ...
>
>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/76742/ | null | ru | null |
# Релиз NGINX 1.6 и 1.7. Особенности версионирования
Вчера, 24 апреля, был анонсирован релиз NGINX 1.6 и 1.7. Эта статья объясняет, как планируются релизы NGINX и значение этого изменения нумерации версий.
NGINX 1.6 отделился от текущей основной (mainline) ветки 1.5, а последняя была перенумерована в 1.7. Это ежегодное событие, когда берется текущая основная ветка с новой функциональностью и от нее ответвляется новая стабильная (stable) ветка. Разработка активно продолжается на уже перенумерованной основной ветке.
*Версия 1.4 более не поддерживается. Основная ветвь 1.5 была форкнута для создания стабильной 1.6 и перенумерована в 1.7.*
В терминологии NGINX «стабильная» означает, что новые возможности не будут добавляться. Иными словами, набор функций остается стабильным и только исправления серьезных багов попадают в эти версии.
Разработка новых фич и исправление всех багов происходит на основной ветке, но критические багфиксы при этом попадают в стабильную ветвь. Процесс выпуска релизов привязан ко времени, так что можно ожидать очередные релизы в основной ветке примерно раз в месяц, с исключениями, когда это необходимо. За последний год, в основной ветке появилась [поддержка SPDY 3.1](http://nginx.org/ru/docs/http/ngx_http_spdy_module.html), [аутентификация с помощью подзапросов](http://nginx.org/ru/docs/http/ngx_http_auth_request_module.html), [TLS session tickets](http://nginx.org/r/ssl_session_tickets/ru), [поддержка IPv6 в DNS-резолвере](http://nginx.org/r/resolver/ru), [поддержка протокола PROXY](http://nginx.org/r/listen/ru), а также была интегрирована поддержка SSL-соединений для протокола uwsgi. Помимо этого были расширены возможности по [логированию ошибок](http://nginx.org/r/error_log/ru), добавлена [ревалидация кэша](http://nginx.org/r/proxy_cache_revalidate/ru), поддержка SMTP pipelining, новые [опции буферизации для FastCGI](http://nginx.org/r/fastcgi_buffering/ru), улучшена поддержка [стриминга mp4](http://nginx.org/ru/docs/http/ngx_http_mp4_module.html), а также обработка byte-range запросов для стриминга и кэширования.
Стоит обратить внимание, что «стабильная» не означает бо́льшую надежность и меньшее количество багов. На самом деле основная ветка рассматривается как более надежная, поскольку только критические исправления попадают в стабильную ветвь. Изменения в стабильной ветке не должны затронуть сторонние модули, чего нельзя сказать об основной ветке, где новая функциональность может сказаться на работоспособности стороннего кода.
Так какую же версию выбрать?
----------------------------
Рекомендуется использовать основную ветку NGINX всё время. Но можно использовать стабильную, если вас беспокоят возможные проблемы от нововведений, такие как несовместимость со сторонними модулями или баги в новой функциональности.
Если вы подключили [официальный репозиторий NGINX](http://nginx.org/ru/linux_packages.html) (стабильную или основную ветку), то при следующем обновлении будет загружена последняя 1.6 или 1.7 сборка соответсвенно.
Если вы устанавливали NGINX из стороннего репозитория, то у вас (вероятно) нет контроля над тем, какая версия будет развернута, и репозиторий может не идти в ногу с выходом новых версий в одной из веток. По возможности, рекомендуется устанавливать NGINX из официального репозитория (на сайте nginx.org), где все сборки проходят внутренние тесты на регрессии и обновляются с выходом новых версий из официального источника.
Вы можете выполнить `nginx -V`, чтобы узнать номер версии вашей сборки:
```
user@host:~$ nginx -v
nginx version: nginx/1.5.12
```
А что там про NGINX Plus?
-------------------------
[NGINX Plus](http://nginx.com/products/) – это поддерживаемая на коммерческой основе версия NGINX с [расширенными возможностями](http://nginx.com/products/feature-matrix/) (многие из которых используют новую архитектуру в разделяемой памяти, специфичную для Plus-версии). NGINX Plus следует версиям в основной ветке NGINX и обычно имеет трехмесячный цикл релиза. Новая функциональность в основной ветке добавляется в Plus, затем выпускается после прохождения процесса интеграционного тестирования и проверки в бою в условиях NGINX F/OSS версий:
*NGINX Plus выпускается на основе mainline версий и обладает расширенной функциональностью*
Внутренняя нумерация версий NGINX Plus соответсвует релизу в основной ветке, с которой NGINX Plus был синхронизирован.
Официальный блог на английском языке: [nginx.com/blog](http://nginx.com/blog/)
---
> **Внимание!** Nginx Team проводит очередной опрос сообщества, чтобы лучше определить стратегию развития. Не упустите возможность высказать свое мнение: [mailman.nginx.org/pipermail/nginx/2014-April/043282.html](http://mailman.nginx.org/pipermail/nginx/2014-April/043282.html)
Upd: **Опрос завершен.** Всем, кто принял участие, огромное спасибо. | https://habr.com/ru/post/220807/ | null | ru | null |
# Объяснение Proof-of-History из документации Solana
От переводчика
--------------
Перевод [Solana whitepaper](https://solana.com/solana-whitepaper.pdf) осуществлён в рамках прикладного курса “Веб3-разработчик”, где мы рассматриваем и обсуждаем архитектуры различных блокчейн платформ и разработку смарт-контрактов под эти платформы.
Платформа Solana является одной из самых необычных. Чтобы понять Solana недостаточно прочитать белую книгу, нужно ещё понимать как работают распределенные системы, как они синхронизируются, как ведется учёт времени и многое другое.
В этой Белой Книге описывается основная концепция Solana - доказательство истори (Proof-of-History, PoH), кроме PoH в Solana есть другие концепции, которые полагаются на PoH. Про другие архитектурные решения будет рассказано в других статьях.
Данный перевод предназначен людям, которые понимают Ethereum и хотят дополнить свою копилку знаний новой архитектурой блокчейна. Перевод доработан через расширение пояснительной части, там где это показалось полезным
Вопросы принимаются в комментарии или личном сообщении.
**Юридическая оговорка**. Ничто в этой статье не является предложением о продаже или предложением о покупке каких-либо токенов. Solana публикует эту "Белую книгу" исключительно для получения отзывов и комментариев от общественности. Ничто в этой Белой книге не должно рассматриваться или считаться как гарантия или обещание того, как будет развиваться Solana. В данной Белой Книге изложены текущие планы, которые могут быть изменены по собственному усмотрению команды Solana, и успех которых будет зависеть от многих факторов, находящихся вне контроля Solana, включая рыночные факторы.
Аннотация
---------
В данной статье предлагается архитектура блокчейна, основанная на доказательстве истории (далее – PoH, Proof of History) - доказательствах необходимых для проверки порядка событий и прохождения времени между ними. PoH используется для кодирования достоверного хода времени в блокчейне. При использовании вместе с алгоритмом консенсуса, таким как Proof-of-Work (PoW) или Proof-of-Stake (PoS), PoH может уменьшить накладные расходы на передачу сообщений в византийско-отказоустойчивой машине состояний, что приводит к субсекундному времени завершения.
В данной работе также предлагаются два алгоритма, использующие свойства сохранения времени в блокчейне на основе PoH:
* алгоритм PoS, который может восстанавливаться после разделения сети;
* эффективное потоковое доказательство репликации (PoRep).
Комбинация PoRep и PoH обеспечивает защиту от подделки блокчейна в отношении времени (упорядочивания) и хранения.
Протокол изучен на сети со скоростью 1 гбит/с, достигнута пропускная способность до 710,000 транзакций в секунду.
Введение
--------
Блокчейн - это отказоустойчивая реплицируемая машина состояний. Современные блокчейны не опираются на точность общего времени или делают слабое предположение о способности участников поддерживать какое-то конкретное время. Каждый узел в сети обычно полагается на свои собственные локальные часы, не зная о часах других участников сети.
Отсутствие надежного источника времени означает, что если временная метка (timestamp) сообщения используется для решения принимать или отклонить сообщение, то нет гарантии, что все остальные участники сети сделают точно такой же выбор.
Представленный здесь PoH предназначен для создания блокчейна с проверяемым течением времени, т.е. длительностью между событиями и порядком следования сообщений. Предполагается, что каждый узел в сети сможет полагаться на криптографически записанный ход времени в недоверенном блокчейне.
Участники сети
--------------
Как показано на рисунке 1, в любой момент времени один из узлов системы является Лидером, который создаёт PoH-последовательность, обеспечивая в сети глобальную согласованность чтения и проверяемый ход времени.
**Лидер** упорядочивает пользовательские сообщения и упорядочивает их таким образом, чтобы они могли быть эффективно обработаны другими узлами системы, максимизируя пропускную способность. Он выполняет транзакции над текущим состоянием, которое хранится в оперативной памяти, и публикует транзакции и подпись конечного состояния на узлах повторителях, называемых **Проверяющими**.
**Проверяющие** выполняют те же транзакции на своих копиях состояния и публикуют вычисленные подписи состояния в качестве своих подтверждений. Опубликованные подтверждения служат в качестве **голосов** для алгоритма консенсуса.
Рисунок 1В неразветвленной сети в любой момент времени в сети есть один Лидер. Каждый Проверяющий узел имеет те же аппаратные возможности, что и лидер, и может быть избран лидером, что делается с помощью выборов на основе PoS.
Доказательства истории
----------------------
Доказательство истории (PoH) - это последовательность вычислений, которая может криптографически подтвердить факт прохождения некоторого количества времени между двумя событиями. Для этого используется криптографически защищенная функция (Функция проверяемой задержки, ФПЗ), написанная таким образом, что:
* выход не может быть предсказан по входу;
* эта функция должна быть полностью выполнена, чтобы создать выход.
Функция запускается последовательно на одном ядре, ее предыдущий выход используется в качестве текущего входа, периодически записывается текущий выход и сколько раз он был вызван. Затем выход может быть повторно вычислен и проверен внешними компьютерами параллельно путем проверки каждого сегмента последовательности на отдельном ядре.
Данные могут быть занесены в эту последовательность путем *добавления данных* (или хеша некоторых данных) в состояние функции.
Запись *состояния*, *порядка* и *данных* по мере их добавления в последовательность обеспечивает временную метку, которая может гарантировать, что данные были созданы за некоторое время до создания следующего хеша в последовательности. Такая конструкция также поддерживает горизонтальное масштабирование, поскольку несколько создателей могут синхронизироваться между собой, подмешивая свои состояния в последовательности друг друга.
### Описание
С помощью криптографической хеш-функции, выход которой невозможно предсказать без запуска функции (например, stribog, sha256, ripemd и т.д.). Пример:
1. запустите функцию от некоторого случайного начального значения - первый вход;
2. возьмите выход этой функции;
3. снова передайте его в качестве входа в ту же функцию;
4. запишите количество вызовов функции и её выход при каждом вызове.
В качестве начального случайного значения может быть выбрана любая строка, например, заголовок Российской газеты за текущий день.
Например:
| | | |
| --- | --- | --- |
| Порядок | Действие | Образ (hash) |
| 1 | streebog(“любая случайная строка”) | hash1 |
| 2 | streebog(hash1) | hash2 |
| 3 | streebog(hash2) | hash3 |
Где *hashN* представляет собой выход (выходное значение) хеш-функции.
Необходимо публиковать только подмножество хешей и их порядком в определенном интервале. Например:
| | | |
| --- | --- | --- |
| Порядок | Действие | Образ (hash) |
| 1 | streebog(“любая случайная строка”) | hash1 |
| 200 | streebog(hash199) | hash200 |
| 300 | streebog(hash299) | hash300 |
Пока выбранная хеш-функция устойчива к коллизиям, этот набор хешей может быть последовательно вычислен только одним вычислительным потоком. Потому что нет никакого способа предсказать, каким будет хеш-значение в индексе 300, не выполнив алгоритм с начальным значением 300 раз.
Таким образом, из структуры данных можно сделать вывод, что между индексом 0 и индексом 300 **прошло реальное время.**
На Рисунке 2 хеш **62f51643c1** был получен при счетчике **510144806912**, а хеш **c43d862d88** - при счетчике **510146904064**. Следуя ранее рассмотренным свойствам алгоритма PoH, мы можем считать, что между счётчиком **510144806912** и счётчиком **510146904064** прошло реальное время.
Рисунок 2### Временная метка для событий
Эта последовательность хешей также может быть использована для записи того, что некоторый фрагмент данных **был создан до того, как был создан определенный хеш-индекс**.
Можно использовать`объединение` фрагмента данных с текущим хешем по текущему индексу. При этом данными могут быть и хеши произвольных данных о событиях. Функция объединения может быть простым добавлением этих данных или любой другой операцией, устойчивой к коллизиям.
Пример.
1. Следующий созданный хеш представляет собой временную метку данных, поскольку он мог быть создан только после того, как был вставлен этот конкретный фрагмент данных.
| | | |
| --- | --- | --- |
| Порядок | Действие | Образ (хеш) |
| 1 | streebog(“любая случайная строка”) | hash1 |
| 200 | streebog(hash199) | hash200 |
| 300 | streebog(hash299) | hash300 |
2. Происходит какое-то внешнее событие, например, была сделана фотография или созданы произвольные цифровые данные:
| | | |
| --- | --- | --- |
| Порядок | Действие | Образ (hash) |
| 1 | streebog(“любая случайная строка”) | hash1 |
| 200 | streebog(hash199) | hash200 |
| 300 | streebog(hash299) | hash300 |
| 336 | streebog(append(hash335, photo\_streebog)) | hash336 |
**hash336** вычисляется из добавленных двоичных данных **hash335** и **photo\_streebog**. Порядок и **photo\_streebog** записываются как часть выхода (выходных данных) последовательности. Таким образом, любой, кто проверяет эту последовательность, может воссоздать это изменение в последовательности.
Поскольку начальный процесс все еще последовательный, мы можем сказать, что события, введенные в последовательность, должны были произойти когда-то до того, как было вычислено будущее хеш-значение.
| | | |
| --- | --- | --- |
| Порядок | Действие | Образ (hash) |
| 1 | streebog(“любая случайная строка”) | hash1 |
| 200 | streebog(hash199) | hash200 |
| 300 | streebog(hash299) | hash300 |
| 336 | streebog(append(hash335, **photo1\_streebog**)) | hash336 |
| 400 | streebog(hash399) | hash400 |
| 500 | streebog(hash499) | hash500 |
| 600 | streebog(append(hash599, **photo2\_streebog**)) | hash600 |
| 700 | streebog(hash699) | hash700 |
Таблица 1. PoH-последовательность с 2-мя событиями
В последовательности, представленной в Таблице 1, **photo2\_streebog** была создана до **hash600**, а **photo1\_streebog** - до **hash336**. Вставка данных в последовательность хешей приводит к изменению всех последующих значений в последовательности. До тех пор, пока используемая хеш-функция устойчива к коллизиям, а данные были добавлены, должно быть вычислительно невозможно предварительно вычислить любые будущие хеши-последовательности на основе предварительного знания о том, какие данные будут включены в последовательность.
Данные, которые включаются в последовательность, могут быть самими исходными данными или просто хешем данных с сопутствующими метаданными.
В примере на Рисунке 3 вход **cfd40df8**... был вставлен в PoH-последовательность. Счетчик, в который он был вставлен, равен **510145855488**, а состояние, в которое он был вставлен равно **3d039eef3**. Все будущие создаваемые хеши модифицируются этим изменением последовательности, это изменение обозначено изменением цвета на рисунке.
Рисунок 3. Вставление данных в PoHКаждый узел, наблюдающий эту последовательность, может определить порядок, в котором все события были вставлены, и оценить реальное время между вставками.
### Проверка
Правильность последовательности может быть проверена многоядерным компьютером за значительно меньшее время, чем потребовалось для ее создания.
Например:
| |
| --- |
| Ядро 1 |
| Порядок | Данные | Образ (хеш) |
| 200 | streebog(hash199) | hash200 |
| 300 | streebog(hash299) | hash300 |
| Ядро 2 |
| Порядок | Данные | Образ (хеш) |
| 300 | streebog(hash299) | hash300 |
| 400 | streebog(hash399) | hash400 |
Учитывая некоторое количество ядер, например, современный GPU с 4000 ядер, **Проверяющий** может разделить последовательность хешей и их порядков на 4000 фрагментов и параллельно убедиться, что каждый фрагмент правилен от начального хеша до последнего хеша в фрагменте. Если ожидаемое время создания последовательности составит:
Общее количество хешей / Количество хешей в секунду для 1 ядра.
Ожидаемое время проверки правильности последовательности будет:
Общее количество хешей / (Количество хешей в секунду на ядро \* Количество ядер, доступных для проверки)
В примере на Рисунке 4 каждое ядро способно параллельно проверять каждый фрагмент последовательности. Поскольку все **входные строки** записываются в **выходной файл** вместе со счетчиком и состоянием, к которому они добавляются, Проверяющие могут воспроизводить каждый фрагмент параллельно. Красным цветом выделены хеши, указывающие на то, что последовательность была изменена вставкой данных.
Рисунок 4: Проверка с использованием нескольких ядер ### Горизонтальное масштабирование
Можно синхронизировать несколько PoH-создателей, смешивая состояние последовательности от каждого создателя к каждому другому создателю, и таким образом добиться горизонтального масштабирования PoH-создателей. Это масштабирование выполняется без шардинга.
Выходы обоих создателей необходимы для восстановления полного порядка событий в системе.
| | |
| --- | --- |
| PoH-создатель А | PoH-создатель Б |
| Порядок | Хеш | Данные | Порядок | Хеш | Данные |
| 1 | hash1a | | 1 | hash1b | |
| 2 | hash2a | hash1b | 2 | hash2b | hash1a |
| 3 | hash3a | | 3 | hash3b | |
| 4 | hash4a | | 4 | hash4b | |
Здесь *Создатель A* получает пакет данных (**hash1b**) от *Создателя Б*, пакет содержит последнее состояние *Создателя Б* и последнее состояние, которое *Создатель Б* наблюдал от *Создателя А*.
Так как следующий хеш *Создателя А* зависит от хеша *Создателя Б*, мы можем вывести, что **hash1b** произошел за некоторое время до **hash3a**. Это свойство может быть [транзитивным](https://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%B0%D0%BD%D0%B7%D0%B8%D1%82%D0%B8%D0%B2%D0%BD%D0%BE%D1%81%D1%82%D1%8C), поэтому если три создателя синхронизированы через одного общего создателя A ↔ **Б** ↔ В, то мы можем проследить зависимость между A и В, даже если они не были синхронизированы напрямую.
Периодически синхронизируя создателей, каждый создатель может обрабатывать часть внешнего трафика, таким образом, общая система может обрабатывать большее количество событий для отслеживания ценой снижения точности времени из-за сетевых задержек между создателями. Глобальный порядок все еще может быть достигнут путем выбора некоторой детерминированной функции для упорядочивания любых событий, которые находятся в пределах окна синхронизации, например, по значению самого хеша.
На Рисунке 5 два создателя используют хеши друг друга как входные значения для функции и записывают эту операцию. Изменение цвета указывает на то, что полученные от другого создателя данные изменили последовательность. Созданные хеши, которые смешиваются в каждом потоке, выделены жирным шрифтом.
Рисунок 5. Синхронизация двух создателейСинхронизация является [транзитивной](https://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%B0%D0%BD%D0%B7%D0%B8%D1%82%D0%B8%D0%B2%D0%BD%D0%BE%D1%81%D1%82%D1%8C) A ↔ Б ↔ В. Существует доказуемый порядок событий между A и В через Б.
Масштабирование таким образом происходит за счет доступности. 10 × 1 гбит/с соединений с доступностью 0,999 будут иметь доступность 0,999^10 = 0,99.
### Согласованность
Ожидается, что пользователи смогут обеспечить согласованность созданной последовательности и сделать ее устойчивой к атакам, вставляя последний наблюдаемый выход последовательности, который они считают правильным, в свой вход.
| | |
| --- | --- |
| PoH-последовательность А | PoH-скрытая последовательность Б |
| Порядок | Данные | Образ(хеш) | Порядок | Данные | Образ(хеш) |
| 10 | | hash10a | 10 | | hash10b |
| 20 | Событие 1 | hash20a | 20 | Событие 3 | hash20b |
| 30 | Событие 2 | hash30a | 30 | Событие 2 | hash30b |
| 40 | Событие 3 | hash40a | 40 | Событие 1 | hash40b |
Вредоносный PoH-создатель может создать вторую скрытую последовательность с событиями в обратном порядке, если он имеет доступ ко всем событиям сразу или способен создать более быструю скрытую последовательность.
Чтобы предотвратить эту атаку, каждое создаваемое клиентом **Событие** должно содержать внутри себя последний хеш, который клиент наблюдал из того, что он считает действительной последовательностью. Таким образом, когда клиент создает данные "**Событие 1**", он должен добавить последний хеш, который он наблюдал.
| |
| --- |
| PoH-последовательность А |
| Порядок | Данные | Образ(хеш) |
| 10 | | hash10a |
| 20 | Событие 1 = совместить(данные События\_1, hash10a) | hash20a |
| 30 | Событие 2 = совместить(данные События\_2, hash20a) | hash30a |
| 40 | Событие 3 = совместить(данные События\_3, hash30a) | hash40a |
Когда последовательность публикуется, **Событие 3** ссылается на **hash30a**, и если его нет в последовательности до этого события, потребители последовательности знают, что это недействительная последовательность. Тогда атака частичного переупорядочивания будет ограничена количеством хешей, произведенных в то время, когда клиент наблюдал событие и когда событие было введено. Клиенты должны иметь возможность написать программное обеспечение, которое не будет предполагать, что порядок верен в течение короткого периода хешей между последним наблюдаемым и введенным хешем.
Чтобы предотвратить возможность злонамеренным PoH-создателем переписывать хеши клиентских событий, клиенты могут отправлять подпись данных события и последнего наблюдаемого хеша, а не только данные.
| |
| --- |
| PoH-последовательность А |
| Порядок | Данные | Хеш |
| 10 | | hash10a |
| 20 | Событие\_1 = **подпись**(**совместить**(Данные\_События\_1, hash10a), Закрытый\_ключ) | hash20a |
| 30 | Событие\_2 = **подпись**(**совместить**(Данные\_События\_2, hash20a), Закрытый\_ключ) | hash30a |
| 40 | Событие)\_3 = **подпись**(**совместить**(Данные\_События\_3, hash30a), Закрытый\_ключ) | hash40a |
Проверка этих данных требует проверки подписи и поиска хеша в последовательности хешей, предшествующих этому. Порядок проверки:
1. (Подпись, Открытый\_ключ, hash30a, Данные\_События\_3) = Событие\_3
2. Проверка(Подпись, Открытый\_ключ, Событие\_3)
3. Найти(hash30a, PoH-последовательность)
На Рисунке 6 входы предоставленные пользователем, зависят от хеша **0xdeadbeef**..., существующего в созданной последовательности за некоторое время до его вставки.
Синяя верхняя левая стрелка показывает, что клиент ссылается на ранее созданный хеш. Сообщение клиента действительно только в последовательности, содержащей хеш **0xdeadbeef**..... Красный цвет в последовательности указывает на то, что последовательность была изменена данными клиента.
### Накладные расходы
4000 хешей в секунду создают дополнительные 160 килобайт данных и потребуют доступа к GPU с 4000 ядрами и примерно 0,25-0,75 миллисекунд времени для проверки.
### Атаки
#### Обратный ход
Создание обратного порядка потребует от злоумышленника начать вредоносную последовательность после второго события. Эта задержка должна позволить любым не злонамеренным одноранговым узлам сообщить о первоначальном порядке.
#### Скорость
Наличие нескольких создателей может сделать развертывание более устойчивым к атакам. Один создатель может быть высокоскоростным и получать множество событий для смешивания в свою последовательность, другой создатель может быть высокоскоростным с низкой пропускной способностью, который периодически смешивается с высокоскоростным создателем.
Высокоскоростная последовательность создаст вторичную последовательность данных, которую злоумышленнику придется обратить.
#### Атаки на основе старых ключей
Атаки на основе старых ключ (или long-range attacks) включают в себя получение старых выброшенных закрытых ключей пользователей блокчейна и создание фальсифицированной версии блокчейна. PoH обеспечивает некоторую защиту от таких атак. Злонамеренный пользователь, получивший доступ к старым закрытым ключам, должен будет воссоздать историческую запись, которая займет столько же времени, сколько и оригинальная запись, которую он пытается подделать. Для этого потребуется доступ к более быстрому процессору, чем тот, который используется в сети в настоящее время, иначе злоумышленник никогда не сможет догнать его по длине истории.
Кроме того, единый источник времени позволяет построить более простое доказательство репликации (Proof of Replication, PoRe). Поскольку сеть спроектирована таким образом, что все участники сети будут полагаться на единую историчность запись событий.
PoRep и PoH вместе должны обеспечить защиту хранения данных и времени от подделки блокчейна.
Консенсус
---------
### Описание
Proof of Stake в Solana предназначен для:
* быстрого подтверждения текущей последовательности, созданной PoH-создателем;
* для голосования и выбора следующего PoH-создателя;
* для наказания любых недобросовестных Подтверждающих.
Этот алгоритм зависит от того, что сообщения в конечном итоге приходят на все участвующие узлы в течение определенного тайм-аута.
### Терминология
**Обязательство.** Обязательства эквивалентны затратам на оборудование и электроэнергию в Proof of Work. Майнер покупает оборудование и электроэнергию и передает их на одну ветвь в PoW-блокчейне. Обязательство - это монета, которую **Подтверждающий** передает в качестве залога на время подтверждения транзакций.
**Штрафы**. Используется для решения проблемы PoS-систем известной как "ничего на кону". Когда публикуется доказательство голосования за другую, дополнительную ветвь, эта ветвь может уничтожить обязательство Подтверждающего. Это экономический стимул, призванный отбить у Подтверждающих желание подтверждать несколько ветвей.
**Супербольшинство.** Это две трети Подтверждающих, взвешенных по их обязательствам. Супербольшинство голосов указывает на то, что сеть достигла консенсуса, и по крайней мере одна треть из сети должны были бы проголосовать злонамеренно, чтобы эта ветка была недействительной. Таким образом, экономическая стоимость атаки составит одну треть от рыночной стоимости монеты.
### Обязательства
Транзакция создающая Обязательство берет определенную сумму монет и переводит ее на счет-обязательство под личностью пользователя. Монеты на этом счету не могут быть потрачены и должны оставаться на счету до тех пор, пока пользователь не выведет их. Пользователь может вывести только **просроченные** монеты, у которых истек срок хранения. Обязательство становятся действительными после того, как супербольшинство участников подтвердит последовательность.
### Голосование
Предполагается, что PoH-создатель может публиковать подпись состояния в заранее определенный период времени. Каждая личность (разместившая обязательство) должна подтвердить эту подпись, опубликовав свою собственную подпись состояния. Голосование - это простое голосование "за", без "против".
Если супербольшинство личностей (разместившая обязательство) проголосовало в течение определенного срока, то эта ветвь будет принята как действительная.
### Закрытие обязательств
Отсутствие N количества голосов отмечает монеты в Обязательстве как "несвежие" и больше непригодные для голосования. Пользователь может отправить транзакцию разблокировки, чтобы вывести эти монеты.
N - это динамическое значение, основанное на соотношении числа несвежих и активных голосов. N увеличивается по мере роста числа "несвежих" голосов. В случае большого разделения сети это позволяет большей ветви восстанавливаться быстрее, чем меньшей.
### Выборы
Выборы нового PoH-создателя происходят при обнаружении отказа PoH-создателя. Подтверждающий с наибольшим количеством голосов (Обязательств) или наибольшим адресом открытого ключа, выбирается в качестве нового PoH-создателя.
Для выбора новой последовательности (нового лидера) требуется супербольшинство подтверждений. Если новый лидер терпит неудачу до получения супербольшинства подтверждений, выбирается следующий по силе **Подтверждающий**, и требуется новый набор подтверждений.
Чтобы переключить голоса, Подтверждающий должен проголосовать на более высоком счетчике PoH-последовательности, а новый голос должен содержать голоса, которые он хочет переключить. В противном случае второй голос будет **штрафоваться**. Ожидается, что переключение голосов будет разработано таким образом, чтобы оно могло происходить только на высоте, не имеющей супербольшинства.
После выбора **Первичного** PoH-создателя может быть избран **Вторичный**, который возьмет на себя обязанности по обработке транзакций. Если **Вторичный** PoH-создатель существует, он будет рассматриваться в качестве следующего Лидера во время сбоя **Первичного**. Платформа спроектирована таким образом, что **Вторичный** становится **Первичным**, а создатели более низкого ранга повышаются в случае обнаружения исключительной ситуации или по заранее определенному графику.
### Причины выборов
#### Разветвление PoH-создателя
PoH-создатели содержат идентификатор, который подписывает созданную PoH-последовательность. Если идентификатор скомпрометирован, то может произойти Разветвление. Разветвление обнаруживается, когда две разные PoH-записи были размещены одним и тем же PoH-идентификатором.
#### Исключения во время выполнения
Аппаратный сбой, ошибка или намеренная ошибка PoH-создателя может привести к тому, что он создаст недействительное состояние и опубликует подпись состояния, которая не совпадает с результатом Подтверждающих. Подтверждающие распространят правильную подпись через протокол сплетен, и это событие вызовет новый раунд выборов. Подтверждающие, которые примут недействительное состояние, будут лишены своих обязательств.
#### Сетевые задержки времени
Сетевая задержка вызовет выборы.
### Штрафование
Если Подтверждающий голосует по двум отдельным PoH-последовательностями, то происходит штрафование. Доказательство злонамеренного голосования изымает из обращения монеты Обязательства и добавляет их в майнинговый пул.
Голосование, включающее предыдущее голосование по конкурирующей последовательности, не может служить доказательством злонамеренного голосования. Вместо уничтожения Обязательств, это голосование удаляет текущий голос, отданный за конкурирующую последовательность.
Штрафование также происходит, если голос отдан за недействительный хеш, созданный PoH-создателем. Если создатель случайным образом создаёт недействительные состояния, то это вызовет обращение к **Вторичному** создателю.
### Выборы Вторичного
Могут быть предложены и утверждены Вторичные и более низкие по рангу PoH-создатели. Предложение вносится через последовательность первичных PoH-создателей. Предложение содержит срок, если предложение одобрено супербольшинством голосов до истечения срока, **Вторичный PoH-создатель** считается избранным и приступает к выполнению своих обязанностей в соответствии с графиком. **Первичный** может выполнить мягкую передачу ответственности на **Вторичного**, вставив сообщение в созданную последовательность, указывающее, что произойдет передача власти, или вставив недействительное состояние и заставив сеть обратиться к Вторичному.
### Доступность
[CAP-системы](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_CAP), работающие с разделением сети, должны выбирать Согласованность или Доступность. Наш подход в конечном итоге выбирает **Доступность**, но поскольку у нас есть объективная мера времени, Согласованность достигается за разумный человеческий срок.
Проверяющие в Proof of Stake блокируют некоторое количество монет в стейк, что позволяет им голосовать за определенный набор транзакций. Транзакция с блокировкой монет вводится в PoH-последовательность, как и любая другая транзакция. Чтобы проголосовать, PoS-проверяющий должен подписать хеш состояния, поскольку он был вычислен после обработки всех транзакций до определенной позиции в PoH-реестре. Это голосование также вводится в PoH-последовательность как транзакция. Просматривая PoH-реестр, мы можем сделать вывод о том, сколько времени прошло между каждым голосованием, а если произошло Разделение, то как долго каждый Проверяющий был недоступен.
Чтобы справиться с Разделением с разумными временными рамками, мы предлагаем динамический подход к снятию стейка недоступных Проверяющих. Когда число Проверяющих велико и превышает две трети, процесс снятия стейка может быть быстрым. Невелико количество хешей, которые должны быть созданы в блокчейне, прежде чем снимется стейка недоступных Проверяющих и они больше не будут учитываться при консенсусе. Когда число Проверяющих менее двух третей, но больше половины, время разблокировки работает медленнее, требуя большего числа хешей, которые должны быть созданы, прежде чем снимется стейк у недоступных Проверяющих. При большом разделении, например, при Разделении, в котором не хватает половины или более Проверяющих, процесс снятия стейка происходит очень медленно. Транзакции все еще могут быть введены в последовательность, и Проверяющие все еще могут голосовать, но полный консенсус не будет достигнут до тех пор, пока не будет создано очень большое количество хешей и не будут сняты стейки у недоступные Проверяющих. Разница во времени восстановления работоспособности сети позволяет нам, клиентам сети, выбрать Разделение, который мы хотим продолжать использовать.
### Восстановление
В предлагаемой нами системе блокчейн может быть полностью восстановлен после любого сбоя. Это означает, что любой человек в мире может выбрать любое случайное место в блокчейне и создать действительный ветку, добавив туда вновь созданные хеши и транзакции. Если в этой ветке отсутствуют все Проверяющие, то потребуется очень много времени, чтобы все дополнительные связи стали действительными и чтобы эта ветвь достигла консенсуса две трети супербольшинства. Таким образом, для полного восстановления при нулевом количестве доступных Подтверждающих потребуется очень большое количество хешей, которые будут добавлены в реестр, и только после того, как у всех недоступных Подтверждающих снимется стейк, любые новые Обязательства смогут подтвердить реестр.
### Окончательность
PoH позволяет Проверяющим сети наблюдать за тем, что произошло в прошлом, с некоторой степенью уверенностью делать утверждения по времени этих событий. Поскольку PoH-создатель производит поток сообщений, все Проверяющие должны представить свои подписи состояния в течение 500 мс. Это число может быть уменьшено в зависимости от условий сети. Поскольку каждая проверка вводится в поток, каждый в сети может проверить, что каждый Проверяющий представил свои голоса в течение требуемого срока, не наблюдая непосредственно за ходом голосования.
### Атаки
#### Трагедия общин
Проверяющие в PoS просто подтверждают созданный PoH-создателем хеш состояния. У них есть экономический стимул не делать никакой работы и просто подтверждать каждый созданный хеш состояния. Чтобы избежать этого условия, PoH-создатель должен вводить недействительный хеш через случайный интервал времени. Все проголосовавшие за этот хеш должны быть оштрафованы. Когда хеш создан, сеть должна немедленно продвинуть Вторично PoH-создателя.
Каждый Проверяющий должен ответить в течение небольшого срока, например, 500 мс. Срок должен быть достаточно маленьким, чтобы у злонамеренного Проверяющего была низкая вероятность заметить голосование другого Проверяющего и достаточно быстро передать свой голос в поток.
#### Сговор с PoH-создателем
Проверяющий, находящийся в сговоре с PoH-создателем, будет заранее знать, когда будет создан недействительный хеш, и не проголосует за него. Этот сценарий ничем не отличается от того, что PoH-личность имеет большую долю Проверяющего. PoH-создатель по-прежнему должен выполнять всю работу по созданию хеша состояния.
#### Цензурирование
Цензура или отказ в обслуживании могут возникнуть, если одна треть держателей обязательств откажется подтверждать любые последовательности новыми обязательствами. Протокол может защитить от этой формы атаки, динамически регулируя скорость устаревания обязательств. В случае отказа в обслуживании более крупное Разделение спроектировано таким образом, что оно будет цензурировать византийских держателей обязательств. Более крупная часть разделенной сети будет восстанавливаться по мере того, как византийские обязательства со временем будут становиться несвежими. Меньшая византийская часть разделенной сети не сможет развиваться в течение длительного периода времени.
Алгоритм будет работать следующим образом. Большинство участников сети выбирают нового **Лидера**. Затем **Лидер** отстраняет от участия держателей византийских обязательств. PoH-создатель должен будет продолжать создавать последовательность, чтобы доказать течение времени, пока достаточное количество византийских обязательств не станет несвежими, чтобы в сети было супербольшинство. Скорость, с которой обязательства становятся несвежими, будет динамически рассчитываться на основе того, какой процент обязательств активен. Таким образом, византийскую ветку меньшинства сети должен будет ждать гораздо дольше, чем ветку большинства, чтобы восстановить супербольшинство. После создания супербольшинства можно было бы использовать штрафование, чтобы навсегда наказать держателей византийских обязательств.
#### Атаки на основе старых ключей
PoH обеспечивает естественную защиту от атак на основе старых ключей. Пересборка блокчейна с любого момента в прошлом потребует от атакующего, достаточной скорости вычислений, чтобы перегнать PoH-создателя.
Протокол консенсуса обеспечивает второй уровень защиты, поскольку любая атака должна занять больше времени, чем время, необходимое для того, чтобы снять стейк со всех Подтверждающих. Это также создает пробел в истории блокчейна. При сравнении двух блокчейнов одинаковой высоты объективно достоверной может считаться та, которая имеет наименьшее максимальное разделение.
#### ASIC-атаки
В этом протоколе существуют две возможности для ASIC-атак - во время разделения и обман срока при Окончательности.
Для ASIC-атак во время Разделения, скорость, с которой снимаются обязательства, нелинеен, и для сетей с большими Разделением скорость на порядки медленнее, чем ожидаемая прибыль от ASIC-атаки.
Для ASIC-атак во время Окончательности уязвимость позволяет византийским Подтверждающим, имеющим ставку обязательства, дождаться подтверждений от других узлов и передать свои голоса сотрудничающему PoH-создателю. Затем PoH-создатель может использовать свой более быстрый ASIC для создания хешей за 500 мс за меньшее время и обеспечить сетевое взаимодействие между PoH-создателем и сотрудничающими узлами. Но если PoH-создатель также является византийским, нет причин, по которым византийский создатель не сообщил бы точный счетчик, когда он ожидает вставить сбой. Этот сценарий ничем не отличается от того, что PoH-создатель и все сотрудничающие узлы разделяют одну и ту же личность, имеют один общий пакет акций и используют только один набор оборудования.
Потоковое доказательство репликации
-----------------------------------
### Описание
Filecoin предложил консенсус Proof of Replication (далее – PoRep). Целью PoRep в Solana является быстрая и потоковая проверка Доказательства репликации данных, которая осуществляется благодаря отслеживанию времени в последовательности создаваемых PoH. PoRep не используется в качестве алгоритма консенсуса, но является полезным инструментом для учета затрат на хранение истории или состояния блокчейна для повышения доступности данных.
### Алгоритм
Как показано на Рисунке 7, [CBC](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D1%81%D1%86%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B1%D0%BB%D0%BE%D0%BA%D0%BE%D0%B2_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%B0)-шифрование шифрует каждый блок данных последовательно, используя ранее зашифрованный блок для XOR входных данных.
Рисунок 7Каждый идентификатор репликации создаёт ключ, подписывая хеш, который был создан PoH-последовательностью. Это привязывает ключ к идентификатору репликатора и к определенной PoH-последовательности. Могут быть выбраны только определенные хеши.
Набор данных полностью шифруется блок за блоком. Затем для создания доказательства ключ используется для запуска создания псевдослучайных чисел, из которых выбираются случайные 32 байта из каждого блока.
Вычисляется хеш дерева Меркла с выбранным PoH-хешем, добавляемым к каждому фрагменту.
Корень публикуется вместе с ключом и выбранным хешем, который был создан. Узел репликации должен опубликовать еще одно доказательство в виде N хешей по мере их создания PoH-создателем, где N равно примерно половине времени, необходимого для шифрования данных. PoH-создатель будет публиковать определенные хеши для доказательств репликации в заранее определенные периоды. Узел-репликатор должен выбрать следующий опубликованный хеш для создания доказательства. Опять же, хеш подписывается, и из блоков выбираются случайные фрагменты для создания корня Меркла.
После периода из N доказательств данные повторно шифруются с помощью нового ключа CBC.
### Проверка
При наличии N ядер каждое ядро может осуществлять потоковое шифрование для каждого идентификатора. Всего требуется *2\_блока ∗ N\_ядер*, так как предыдущий зашифрованный блок необходим для создания следующего. Затем каждое ядро может быть использовано для создания всех доказательств, вытекающих из текущего зашифрованного блока.
Ожидается, что общее время проверки доказательств будет равно времени, затрачиваемому на шифрование. Сами доказательства потребляют мало случайных байт из блока, поэтому объем данных для хеширования значительно меньше размера зашифрованного блока. Количество идентификаторов репликации, которые могут быть проверены одновременно, равно количеству доступных ядер. Современные графические процессоры имеют в своем распоряжении 3500+ ядер, хотя и с тактовой частотой на ½-⅓ меньше, чем у CPU.
### Ротация ключа
Без ротации ключей одна и та же зашифрованная репликация может создавать дешевые доказательства для нескольких PoH-последовательностей. Ключи периодически меняются, и каждая репликация заново шифруется новым ключом, который привязан к уникальной PoH-последовательности. Обращение должно быть достаточно медленным, чтобы можно было проверять доказательства репликации на аппаратном обеспечении GPU, которое работает медленнее, чем CPU, на каждое ядро.
### Выбор хеша
PoH-создатель публикует хеш, который будет использоваться всей сетью для шифрования доказательств репликации и для использования в качестве создателя псевдослучайных чисел для выбора байтов в быстрых доказательствах.
Хеш публикуется с периодичностью, примерно равной половине времени, необходимого для шифрования набора данных. Каждый идентификатор репликации должен использовать один и тот же хеш и использовать подписанный результат хеша в качестве семени (seed по-русски) для выбора байта или ключа шифрования.
Период, в течение которого каждый репликатор должен предоставить доказательство, должен быть меньше времени шифрования. В противном случае репликатор может отправлять шифр и удалять его для каждого доказательства. Вредоносный создатель может внедрить данные в последовательность до этого хеша, чтобы создать определенный хеш.
### Подтверждение доказательств
Ожидается, что PoH-узел не будет подтверждать представленные доказательства репликации. Предполагается, что он будет отслеживать количество ожидающих и проверенных доказательств, представленных идентификаторами репликаторов. Ожидается, что доказательство будет проверено, когда репликатор сможет подписать доказательство супербольшинством Подтверждающих в сети.
Проверки собираются репликатором через сеть одноранговых сплетен и представляются в виде одного пакета, который содержит супербольшинство Подтверждающих в сети. Этот пакет проверяет все доказательства до определенного хеша, созданых PoH-последовательностью, и может содержать сразу несколько идентификаторов репликаторов.
### Атаки
#### Спам
Злонамеренный пользователь может создать множество идентификаторов репликаторов и завалить сеть плохими доказательствами. Чтобы ускорить проверку, узлы должны предоставлять зашифрованные данные и все дерево Меркла остальной части сети, когда они запрашивают проверку.
PoRep, разработанное в данной работе, позволяет дешево проверять любые дополнительные доказательства, поскольку они не занимают дополнительного места. Но каждое доказательство будет потреблять 1 ядро времени шифрования. Цель репликации должна быть установлена на максимальный размер легкодоступных ядер. Современные графические процессоры поставляются с 3500+ ядрами.
#### Частичное стирание
Узел-репликатор может попытаться частично стереть часть данных, чтобы избежать сохранения всего состояния. Количество доказательств и случайность семени должны затруднить эту атаку.
Например, пользователь, хранящий 1 терабайт данных, стирает один байт из каждого 1-мегабайтного блока. Одно доказательство, которое выбирает 1 байт из каждого мегабайта, будет иметь вероятность столкновения с любым стертым байтом 1 - (1 - 1/1, 000, 0000)1,000,000 = 0.63. После 5 доказательств вероятность равна 0,99.
#### Сговор с PoH-создателем
Предполагается, что подписанный хеш будет использоваться для засева выборки. Если репликатор может заранее выбрать определенный хеш, то он может стереть все байты, которые не попадут в выборку.
Репликатор, находящийся в сговоре с PoH-создателем, может ввести определенную транзакцию в конце последовательности до того, как будет создан предопределенный хеш для случайного выбора байтов. Имея достаточное количество ядер, злоумышленник может создать хеш, предпочтительный для репликатора.
Эта атака может принести пользу только одному репликатору. Поскольку все идентификаторы должны использовать один и тот же точный хеш, криптографически подписанный с помощью ECDSA (или эквивалентного алгоритма), полученная подпись уникальна для каждого репликатора и устойчива к коллизиям. Это принесе незначительные выгоды только для одного репликатора.
#### Отказ в обслуживании
Стоимость добавления дополнительного репликатора, как ожидается, будет равна стоимости хранения. Стоимость добавления дополнительных вычислительных мощностей для проверки всех репликаторов, как ожидается, будет равна стоимости ядра CPU или GPU на каждый идентификатор репликации.
Это создает возможность для атаки “отказ в обслуживании” сети путем создания большого количества действительных идентификаторов репликаторов. Чтобы ограничить эту атаку, протокол консенсуса, выбранный для сети, может выбрать цель репликации и присудить доказательства репликации, которые отвечают желаемым характеристикам, таким как доступность в сети, пропускная способность, геолокация и т.д.
#### Трагедия общин
Проверяющие в PoS могут просто подтверждать PoRep, не выполняя никакой работы. Экономические стимулы должны быть направлены на то, чтобы Проверяюшие в PoS выполняли работу, например, путем разделения выплат за майнинг между Проверяющими в PoS и узлами репликации в PoRep.
Чтобы избежать этого сценария, Проверяющие в PoRep могут предоставлять ложные доказательства в небольшом проценте случаев. Они могут доказать, что доказательство является ложным, предоставив функцию, которая создала ложные данные. Любой Проверяющий в PoS, подтвердивший ложное доказательство, будет оштрафован.
Архитектура системы
-------------------
### Компоненты
#### Лидер, PoH-создатель
**Лидер** - это избранный PoH-создатель. Он собирает произвольные пользовательские транзакции и выдает PoH-последовательность всех транзакций, гарантирующую уникальный глобальный порядок в системе. После каждой партии транзакций **Лидер** создаёт подпись состояния, которое является результатом выполнения транзакций в этом порядке. Эта подпись подписывается идентификатором Лидера.
#### Состояние
Наивная хеш-таблица, индексированная по адресам пользователя. Каждая ячейка содержит полный адрес пользователя и память, необходимую для этого вычисления.
Таблица транзакций содержит:
| | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 31 | 63 | 95 | 127 | 159 | 191 | 233 | 255 |
| Открытый ключ пользователя | Счёт (Account) | Не используется |
В общей сложности 32 байта.
Таблица PoS-обязательств содержит:
| | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 31 | 63 | 95 | 127 | 159 | 191 | 233 | 255 |
| Открытый ключ пользователя | Обязательство | |
| Последний голос | |
| не используется | |
В общей сложности 64 байта.
#### Проверяющий, репликация состояний
Узлы Проверяющего реплицируют состояние блокчейна и обеспечивают высокую доступность состояния блокчейна. Цель репликации выбирается алгоритмом консенсуса, а Подтверждающие в алгоритме консенсуса выбирают и голосуют за одобренные ими PoRep-узлы на основе критериев, определенных вне цепи.
Сеть может быть сконфигурирована с минимальным размером PoS обязательства и требованием к одному идентификатору репликатору на обязательство.
#### Подтверждающие
Эти узлы потребляют пропускную способность от Проверяющих. Они являются виртуальными узлами и могут работать на тех же машинах, что и Проверяющие или Лидеры, или на отдельных машинах, которые специфичны для алгоритма консенсуса, настроенного для этой сети.
### Ограничения сети
Лидер должен уметь принимать входящие пакеты транзакций от пользователей, упорядочивать их наиболее эффективным способом и создавать PoH-последовательность, которая публикуется для последующих Проверяющих. Эффективность основана на шаблонах доступа транзакций к памяти, поэтому транзакции упорядочиваются так, чтобы минимизировать ошибки и максимизировать предварительную выборку.
Формат входящего пакета:
| | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 31 | 63 | 95 | 127 | 159 | 191 | 233 | 255 |
| Последний правильный хеш | Счётчик | U | S |
| Комиссия | |
| От |
| Подпись 1 из 2 |
| Подпись 2 из 2 |
Размер 20 + 8 + 16 + 8 + 32 + 3232 = 148 байт.
1 счет назначения - это минимальная полезная нагрузка, которая может поддерживаться.
С полезной нагрузкой:
| | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 31 | 63 | 95 | 127 | 159 | 191 | 233 | 255 |
| Последний правильный хеш | Счётчик | U | S |
| Кому | Размер | |
| Счётчик | Комиссия | |
| От |
| Подпись 1 из 2 |
| Подпись 2 из 2 |
С полезной нагрузкой минимальный размер: 176 байт
Пакет PoH-последовательности содержит:
* текущий хеш,
* счетчик,
* хеш всех новых сообщений, добавленных к PoH-последовательности,
* хеш-состояния после обработки всех сообщений.
Этот пакет отправляется раз в N сообщений. PoH-пакет:
| | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 31 | 63 | 95 | 127 | 159 | 191 | 233 | 255 |
| Текущий хеш | Счётчик | |
| Хеш сообщений | | |
| Хеш-состояния | |
| |
| Подпись 1 из 2 |
| Подпись 2 из 2 |
Минимальный размер выходного пакета составляет: 132 байта
При сетевом соединении 1 Гбит/с максимальное количество транзакций: 1 гигабит в секунду / 176 байт = 710,000 ТвС максимум. Ожидается некоторая потеря 1-4% из-за кадрирования Ethernet. Резервная емкость, превышающая целевой объем для сети, может быть использована для повышения доступности путем кодирования выходного сигнала [кодами Рида-Соломона](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%B4_%D0%A0%D0%B8%D0%B4%D0%B0_%E2%80%94_%D0%A1%D0%BE%D0%BB%D0%BE%D0%BC%D0%BE%D0%BD%D0%B0) и его отправки на доступные нижележащие Проверяющих.
### Вычислительные пределы
Каждая транзакция требует проверки дайджеста. Эта операция не использует никакой памяти за пределами самой транзакции и может быть распараллелена. Таким образом, ожидается, что пропускная способность будет ограничена количеством ядер, доступных в системе.
Серверы проверки ECDSA на базе GPU показали экспериментальные результаты в 900,000 операций в секунду.
### Пределы памяти
Наивная реализация состояния в виде заполненной на 50% хеш-таблицы с 32-байтовыми записями для каждого аккаунта теоретически позволит уместить 10 миллиардов аккаунтов в 640 ГБ. Случайный доступ к этой таблице в стабильном состоянии измеряется на уровне 1,1 ∗ 10^7 записей или чтений в секунду. Исходя из расчета 2 чтения и 2 записи на транзакцию, пропускная способность памяти позволяет обрабатывать 2,75 млн транзакций в секунду. Данные измерения проводились на экземпляре AWS 1 Tb x 1.16x.
### Высокоэффективные смарт-контракты
Смарт-контракты - это обобщенная форма транзакций. Это программы, которые выполняются на каждом узле и изменяют состояние. Solana использует расширенный байткод Berkeley Packet Filter как быстрый и простой для анализа и JIT-байткод для создания и выполнения смарт-контрактов.
Одним из его основных преимуществ является интерфейс внешних функций (FFI) с “нулевой стоимостью”. Встроенные функции (встройки), которые реализуются напрямую на платформе, могут вызываться программами. Вызов встройки приостанавливает работу этой программы и планируется выполнение этой встроенной функции на высокопроизводительном сервере. Встройки объединяются в группы для параллельного выполнения на GPU.
В приведенном ниже примере две разные пользовательские программы вызывают одну и ту же функцию. Каждая программа приостанавливается до завершения пакетного выполнения функции. Примером внутренной функции является проверка ECDSA. Пакетное выполнение этих вызовов на GPU может увеличить пропускную способность в тысячи раз.
Этот подход не требует переключения контекста потоков операционной системы, поскольку BPF-байткод имеет четко определенный контекст для всей памяти, которую он использует.
Бэкенд eBPF включен в LLVM с 2015 года, поэтому любой язык LLVM может быть использован для написания смарт-контрактов. В ядре Linux он присутствует с 2015 года, а первые итерации байткода существуют с 1992 года. За один проход можно проверить корректность eBPF, определить его требования к времени выполнения и памяти и преобразовать его в инструкции x86.
Выводы
------
Если вы прочитали Белую бумагу полностью, то поняли, что на многие вопросы не дано формальных ответов. Например: описания атак, ответы на которые не имеют формального обоснования.
В других хабр статьях обсудим другие концепции Solana (TowerBFT, Turbine, Sealevel, Gulf Stream), а также разработку смарт-контратков для Solana. А также сравним Solana с другими блокчейн платформами.
Если желаете подискутировать по принципам работы платформы Solana, то добро пожаловать в комментарии. Также, каждую среду в 15.00 проходит [стрим](https://discord.gg/WfRhsubw3P), где мы обсуждаем технологический вопрос работы блокчейна. Повестка стрима рассылается в понедельник.
Все, кто интересуется платформами отличными от Ethereum и прочими вопросами, которые редко обсуждаются, приглашаются на курс “**Веб3-разработчик**” (старт потока в декабре, доп.инфа тут [@druzhcom](https://t.me/druzhcom) "или в личных сообщениях [@didexBot](https://t.me/didexBot)). Где мы обсуждаем особые, узкие, специализированные темы в рамках блокчейн технологий. И конечно разрабатываем смарт-контракты для различных блокчейнов. Итоговым результатом обучающихся является создание проекта на актуальную рыночную тему и написание совместной Хабр-статьи по проблематике создаваемого проекта.
Вопрос для ответа в комментарии: про какую платформу вы хотели бы почитать хабр-статью?
UPD: после многих негативных (крайне "конструктивных" по содержательной части) комментариев о неправильном использовании перевода слова whitepaper, во втором абзаце исправлено с "Белая бумага" на "Белая книга". В других местах было и остаётся "Белая книга". Других претензий и возражений у страждущей аудитории нет. | https://habr.com/ru/post/700696/ | null | ru | null |
# Хитрые способы обмана адресной строки
Большинство массовых краж паролей с социальных сетей реализуются при помощи вирусов, которые лезут в hosts и подменяют страничку авторизации, но я недавно открыл для себя ещё более изощрённый метод обмана пользователей:
`yandex.ru@%68%61%62%72%61%68%61%62%72%2E%72%75` (сам «трюк» работает не везде, и не везде работает одинаково).
Например, я не всегда бы увидел, что это не адрес поисковой системы, а ссылка на хабр. Фактически мы просто использовали абсолютно правильный формат URL'а (который определён в [RFC 1728](http://labs.apache.org/webarch/uri/rfc/rfc1738.txt), см. раздел 3.1):
`//:@:/`
(те. надпись «yandex.ru» выступила в виде логина).
Сам же адрес настоящего логина легко поддаётся кодировке и когда он закодирован в шестнадцатеричном формате, то типичный пользователь вряд-ли будет переводить его в канонический вид. Ещё можно вместо адреса указать IP сервера в нетипичном для глаз виде ([уже обсуждалось на хабре](http://habrahabr.ru/blogs/sysadm/69587/)) и получить что-то в духе этого:
`vkontakte.ru*id@1297618184`
И, почему-то, я уверен, что можно подобрать какой-нибудь символ, который внешне будет похожий на знак вопроса…
UPD.: придумать красивый заголовок так и не получилось, писал ночью… =). | https://habr.com/ru/post/80219/ | null | ru | null |
# «Изменить настройки в голове гораздо сложнее, чем на сервере». Как мы ищем инженеров в Southbridge
Ещё в 2020 в Southbridge [не было специалиста по подбору персонала](https://habr.com/ru/company/southbridge/blog/523206/), а большинство наших инженеров устроились на работу без видеоинтервью. Мы даже не знали, как они выглядят.
Эта статья про то, как ищем новых инженеров сейчас, какие шаги нужно будет пройти после отклика на вакансию и на что обратить внимание на каждом из этих этапов.
Инженеры в Southbridge работают напрямую с клиентами, поэтому одной технической грамотности недостаточно. Надо ещё уметь ясно излагать мысли, быть вежливым и терпеливым. Работа полностью удалённая, а значит потребуется и уметь планировать время, расставлять приоритеты, эффективно общаться внутри распределённой команды.
Мы ищем в команду людей, которым изначально близки [наши ценности](https://habr.com/ru/company/southbridge/blog/523206/), подход к проектам, решению задач и взаимодействию. Потому что человеку будет комфортно работать в той компании, которая ему близка и понятна. Любые попытки подстроиться под что-то чужое, переделать себя под структуру и убеждения, которые внутренне не принимаешь, рано или поздно приведут к стрессу, выгоранию и увольнению.
В Southbridge текучки практически нет, и для нас важно, чтобы коллеги работали долго. Поэтому мы хотим приглашать в команду инженеров с подходящим бэкграундом, которым близки наши принципы и подходы к работе. Как говорит наш СТO Сергей Фомин: «Изменить настройки в голове куда сложнее, чем на сервере». Ниже рассказываем, что делаем для того, чтобы понять, совпадают ли «настройки» и будет ли в радость совместная работа как для инженера, так и для компании.
### Вы откликнулись на вакансию — что дальше?
Сначала перечислим все этапы между откликом на вакансию и получением оффера:
1. Резюме и сопроводительное письмо.
2. Приветственные вопросы.
3. Тестовые вопросы.
4. Практическое тестовое задание.
5. Вводное интервью (при необходимости).
6. Техническое интервью.
Теперь поподробнее о каждом этапе.
### Сопроводительное письмо и резюме
Сопроводительное письмо для нас так же важно, как и резюме. Это первое, что мы видим. Конечно, само наличие сопроводительного письма — уже плюс для кандидата (письма, состоящие из одной точки не считаются). Здорово, если в сопроводительном письме вы описали, почему вакансия интересна и как ваш опыт соотносится с перечисленными требованиями.
> *Очень важно написать развёрнутое сопроводительное письмо, если вакансия вам интересна, но вы понимаете, что ваш опыт не совсем соответствует тому, что написано в пожеланиях к кандидату. Напишите прямо, что вы, возможно, не подходите сейчас по требованиям, но имеете те или иные сильные стороны и мотивацию.*
>
>
>
> *Ольга Шабалдина, HR Southbridge*
Цель сопроводительного письма — заявить о себе. Это способ обратить на себя внимание. Если вы не будете использовать клише и напишете искренне, ваш отклик точно выделится среди других. Недавно мы даже получили сопроводительное письмо в стихах, но проза, конечно, тоже подойдёт.
В резюме мы смотрим на опыт последних 5-6 лет, стек технологий, с которым кандидат работал. Например, есть ли опыт с Docker, Kubernetes, CI/СD. Важно выделить в резюме основное: не рассказывать всю историю трудовой книжки, а написать про результаты, к которым вы пришли на предыдущих местах работы.
Большим плюсом для резюме будут ссылки на ваши соцсети и профиль на Гитхабе с проектами.
### Приветственные вопросы
Если сопроводительное письмо и резюме нам понравились, мы отправляем кандидату приветственные вопросы. Это первые вводные вопросы, чтобы познакомиться чуть лучше. Спрашиваем о том, почему вы решили сменить текущее место работы, какую зарплату хотите; про опыт с Linux, опыт в разработке, про высоконагруженные проекты.
В ответах смотрим не только на содержание, но и на форму, на то, как написан текст. Для нас важно, чтобы мысли были структурированы, о сложных вещах было написано просто и понятно, прослеживалась логика. Обращаем внимание на манеру общения.
К вопросу о зарплатных ожиданиях возвращаемся и потом, при проверке тестовых вопросов и практического задания. Если кандидат указал высокую зарплату, то и ответы должны быть на высоком уровне.
> *Лучше отвечать на вопросы так, как думаете на самом деле. Чтобы не строить иллюзий и не создавать неоправданных ожиданий. Если вам важнее деньги, так и напишите. Если писать шаблонные ожидаемые ответы, истинная мотивация потом всё равно станет понятной. Мы, конечно, платим инженерам достойные зарплаты. Но наша компания больше не про деньги, а про увлечённость выбранным делом. Ищите компанию, которая подходит для вашей мотивации.*
>
>
>
> *Ольга Шабалдина, HR Southbridge*
### Тестовые вопросы
Третий этап — тестовые вопросы. Они очень разные: есть про инструменты (стек наших технологий), есть на подумать. Ответы проверяет технический директор. Эти вопросы помогают понять, какой есть опыт и технические навыки, как мыслит кандидат, как общается. Чтобы ответить на тестовые вопросы, понадобится примерно 1–2 часа.
> *Тестовые вопросы нужны, чтобы раскрыть базовые (фундаментальные) знания кандидата, а также посмотреть на него со стороны личных качеств: как реагирует в разных ситуациях, как подходит к решению задач, как подаёт информацию. Ещё проверяем некоторые навыки, которые в двух словах не опишешь. Мы просто смотрим на кандидата в разрезе работы с нами и в 80% случаев уже на этом этапе складывается ощущение, подходит человек нам или нет, всё остальное — уточнения, которые не влияют существенно на решение.*
>
>
>
> *Сергей Фомин, CTO Southbridge*
Очень тяжело читать, если все ответы написаны сплошным текстом, без оформления и структуры. Если в будущем инженер напишет такое же письмо клиенту, это, конечно, минус для компании.
Невнимательность, неаккуратность в ответах заставляют задуматься — ведь инженер будет работать на серверах клиента, и очень важно быть максимально точным и внимательным.
Бывает, что кандидат технически недостаточно силен, но его структура мыслей и то, как он рассуждает, соответствует тому, что принято в нашей компании, мы можем допустить его до тестового задания.
### Практическое тестовое задание
Если кандидат переходит к тестовому заданию, мы даём ему описание задачи и доступ к тестовому серверу. По времени ограничений нет, в среднем выполненное задание мы получаем где-то через неделю, а вообще для его выполнения требуется в среднем от трёх до шести часов.
Чтобы ориентироваться в сроках, мы задаём вопрос: «Когда вы будете готовы сдать задание?». Далее смотрим, насколько указанный срок был соблюдён. Иногда кто-то пишет и предупреждает, что на работе аврал, с заданием будет задержка. Это вполне нормально, главное — быть на связи и сообщать, если что-то меняется.
> *Практическое задание показывает почерк кандидата (стиль работы, подход). Мы смотрим на то, как кандидат производит настройку и сверяем его опыт, который мы увидели при ответах на тестовые вопросы, с тем, что он делает, а также разбираем выполненное задание со стороны нашего клиента, при этом добавляя техническую экспертизу проведённых настроек и применяемых решений. Смотрим, будут ли проблемы в эксплуатации при подобных настройках. Если да — это плохой знак для кандидата.*
>
>
>
> *Сергей Фомин, CTO Southbridge*
Выполнить задание можно по-разному, используя разные инструменты и подходы. Проверяет его CTO по специальному чек-листу, который помогает не упустить важные детали.
### Вводное интервью
Предпоследний этап — вводное интервью с HR. Проводим его не всегда, только при необходимости, если после предыдущих этапов остались вопросы.
На интервью смотрим на софт-скиллы кандидата, насколько развиты коммуникативные навыки, как отзывается о своей прошлой команде. Важно, чтобы инженер умел дипломатично решать конфликты, планировать, работать не в одиночку, а совместно с коллегами.
Часто спрашиваем, например, как человек вышел бы из описанной сложной ситуации. Допустим, коллега ушёл в отпуск, а у вас сроки по проекту горят, а тут ещё и клиент звонит, говорит, что у него авария. Просим рассказать, что делали бы, какие были бы результаты и выводы.
### Техническое интервью
Следующий и последний этап — это интервью с техническим директором или встреча с командой инженеров. На интервью смотрим на технические навыки. Мы понимаем, что ответы на всё знать невозможно, поэтому основная цель — найти сильные стороны кандидата.
*Инженеры Southbridge на интенсиве Слёрма по Kubernetes*
Первое что нам очень важно — это базовые знания кандидата в области Linux, веб-проектов и навыков работы со скриптами автоматизации. Смотрим на это на всех этапах, включая интервью.
Хорошее, уверенное знание Linux систем — достаточно большая редкость сейчас, как оказалось.
> *Часто на собеседованиях ребята рассказывают, как важно знать какие-то технологии сейчас, а на вопрос: «А что ты сделал чтобы её изучить?» отвечают «ничего» или «попробовал на домашнем компе и забросил». Как будто что-то изменится, если они придут к нам.*
>
>
>
> *Для нас очень важно желание развиваться и навык восприятия новой информации, мы смотрим, насколько человек хочет учиться, как он мыслит, и в целом готовы поступиться первыми требованиями, если видим, что кандидат достаточно сообразительный и хочет развиваться. Поэтому тут всё, как писал Пелевин: «Если ваш ум с быстротой молнии проник в тайну зашифрованной в рисунке древней аллегории, то неужели для вас составят какую-нибудь проблему все эти прайс-листы и накладные».*
>
>
>
> *Сергей Фомин, CTO Southbridge*
На техническом интервью задаём базовые вопросы о том, как работает Linux (права доступа, диски, сеть и так далее), как работать с LVM, как понять причины перегрузки веб-сервера по выводу (top, atop, htop), как работать с grep/awk/sed, Nginx, MySQL или PostgreSQL на уровне администрирования и др. Базовые знания очень важны, даже если речь идет о вакансии DevOps-инженера.
Примеры технических вопросов, похожих на вопросы с нашего интервью:
```
1. Посмотрите на 6-ти строчный bash-скрипт и скажите, чему будет равно значение переменной?
2. Чем отличаются различные системы виртуализации и контейнеризации?
3. Что будет, если разработчик просит провести определённые действия на боевой БД. Как поступите, что предложите?
4. Пример архитектурного решения по запросу клиента. Какие проблемы видите тут, есть ли они?
5. Приходит разработчик с проблемой запуска приложения в Kubernetes (детали убраны). Как будете вести отладку?
```
### Что делать, если кандидат перспективный, но прямо сейчас принять в команду мы его не сможем?
У нас нет чётких рамок подбора и «сортировки» людей, как в больших компаниях. Если на каком-то этапе навыков не хватило, но по личным качествам кандидат нам хорошо подходит, мы не готовы сразу прощаться.
Если кандидат уже однажды откликался, но до оффера дело не дошло, это не значит, что мы никогда не будем готовы с ним работать. Были случаи, когда инженеры приходили во второй раз спустя время.
> *Когда я точно вижу, что человек будет вкладом для компании, что он крутой, хотя и не имеет всех знаний, описанных в вакансии, я могу написать CEO, показать ему резюме и сопроводительное письмо. У нас был такой случай: получили отклик на линукс-инженера, хард-скиллов было недостаточно, но сопроводительное письмо, стиль общения и передачи информации были настолько близки компании, что мы не смогли отказать. Предложили кандидату место ментора и преподавателя на образовательном проекте для подростков Слёрм Юнивёрс (хотя такую вакансию мы вообще не открывали).
>
> Может быть, кто-то не подходит на открытую вакансию прямо сейчас, но через три года это будет классный директор нового направления. Как мы можем упустить такие кадры!*
>
>
>
> *Ольга Шабалдина, HR Southbridge*
Кроме того, у нас есть [стажёрская программа](https://habr.com/ru/company/southbridge/news/t/557408/), сейчас приглашаем на поток, который стартует в июле. Мы ведем на эту программу отдельный набор, но некоторым кандидатам, которые откликаются на вакансии, тоже предлагаем поучаствовать. Если каких-то знаний и опыта не хватает, можно получить их во время стажировки, обменяться опытом с коллегами. Для стажёров это хорошая возможность поучиться на курсах Слёрма, обсудить технические вопросы с практикующими инженерами, а для Southbridge — время, чтобы узнать кандидатов ближе, понять, сработаемся ли. | https://habr.com/ru/post/564188/ | null | ru | null |
# Двусторонняя аналитика партнерского iframe-виджета с помощью Google Tag Manager
Виджеты сегодня являются неотъемлемой частью многих крупных порталов, поскольку позволяют использовать сложные партнерские разработки избегая долгие процедуры внедрения. Веб-аналитика виджетов при этом интересна всем сторонам, но в случае с iFrame возникают трудности в плане передачи 100% данных участникам партнерства. Какие это трудности и как нам удалось обойти их, хотелось бы рассказать в данной статье. Прежде всего она будет интересна всем, кто занимается разработкой и внедрением виджетов на iFrame, а также привлеченным аналитикам.
Для начала немного подоплеки. Мы занимаемся разработкой как собственных решений для автоматизации в сфере пассажирских перевозок, так и продуктов для использования на партнерских сайтах. Одним из них стал проект автоматизированного бронирования VIP и бизнес-залов в аэропортах мира и России, направленный на удовлетворение потребности бизнес и премиум клиентов различных авиакомпаний. Единая база данных тематических услуг в различных аэропортах интересна в первую очередь компаниям, связанным с пассажирскими авиаперевозками, онлайн-трэвел агентствам, а также туристическим компаниям с сайтами в интернете. Для таких компаний был создан виджет “VIP-зал”, позволяющий получить доступ к этой базе данных пользователю любого партнерского сайта.
Виджет устанавливается стандартным образом через iFrame, партнеру нужно лишь разместить код у себя на сайте и настроить параметры внешнего вида согласно общей дизайн-концепции. В результате на сайте появляется модуль подбора и бронирования VIP-залов в интересующем аэропорту с доступом к премиум-услугам аэропорта, таким как шаттл (индивидуальный трансфер от зала до самолета), встреча в зале с табличкой, сопровождение сотрудника и доступ на парковку для VIP-клиентов. Процесс бронирования осуществляется за несколько простых шагов, внутри которых пользователь может варьировать содержимое заказа (рис.1).
*Рисунок 1 — Внешний вид виджета на сайте*
Учитывая вариативность заполнения данных, конечно же встает вопрос отслеживания этого процесса с точки зрения аналитики. Причем веб-анализ интересен как **владельцу** виджета так и устанавливающему его **партнеру**, поэтому в ходе разработки появилась задача отслеживания событий внутри виджета и передача их одновременно по двум направлениям:
А. Со всех сайтов, на которых установлен виджет, в веб-аналитику владельца (разработчика).
Б. С сайта, на котором установлен конкретный виджет, в веб-аналитику партнера.
**В чем здесь сложность?** В основном в том, что партнер берет единый код виджета, который не настраивается под конкретный партнерский сайт, но при этом хочет видеть в аналитике информацию только по своему виджету. Вторая трудность заключается в том, что разработчик (владелец) виджета должен получать данные сразу со всех партнерских сайтов в один счетчик, что идет вразрез с желанием партнера видеть только собственную информацию. В конце концов нужно попросту разграничивать те данные, которые должен видеть партнер, и которые будет видеть владелец. Задачу удалось решить с помощью **Google Tag Manager** (далее — GTM).
Данный инструмент широко используется для веб-аналитики и управления тегами на сайтах, описывать подробно принцип его действия не имеет смысла, для понимания достаточно ознакомиться с концепцией работы GTM [из других статей](https://habr.com/search/?q=google+tag+manager#h). В данном случае важно понимать, что Google Tag Manager (рис.2) позволяет консолидировать данные с сайта внутри собственных контейнеров и раздавать их различным счетчикам веб-аналитики с помощью заданных правил.
*Рисунок 2 — Окно “Теги” Google Tag Manager с уже настроенными тегами для виджета*
Для начала опишем сам алгоритм решения этой задачи, чтобы сразу понимать каким путем мы двигались для достижения результата. Итак:
1. Партнер, как и владелец, хочет отслеживать работу виджета одним из двух способов или сразу двумя — с помощью Яндекс.Метрики или Google Analytics.
2. Удовлетворяющее решение должно передавать данные в 4 счетчика: Счетчик Метрики владельца, счетчик Google Analytics владельца, счетчик Метрики партнера и счетчик Google Analytics партнера.
3. Внутрь виджета устанавливается единый контейнер Google Tag Manager, который будет собирать все данные и распределять их таким образом, чтобы каждый участник получал только нужную ему информацию.
4. Идентификаторы счетчиков владельца задаются по умолчанию, идентификаторы партнера должны быть указаны им в момент генерации кода виджета в партнерском кабинете для дальнейшей установки на сайте.
5. Поскольку для партнера уже настроен партнерский кабинет, идентификаторы можно задать в нем и пробросить внутрь виджета, чтобы Tag Manager использовал их.
6. Внутри GTM происходит подстановка идентификаторов в коды срабатывания целевых событий, а также распределение передачи данных по счетчикам владельца и партнера.
7. При этом GTM отправляет все собранные данные в счетчики владельца, а данные по сайту партнера — только в счетчики партнера, т.к. при подстановке идентификаторов отслеживается только заданный партнером сайт.
Для удобства понимания приведем блок-схему процесса (рис.3):
*Рисунок 3 — Схема процесса передачи данных*
Для начала определимся, что кроме кода Google Tag Manager на сайте также присутствуют автоматически сгенерированные коды счетчиков Яндекс.Метрики и Google Analytics. В них при генерации кода для сайта пробрасываются заданные партнером идентификаторы счетчиков.
Эти коды в виджете можно и не задавать, поскольку возможности GTM позволяют автоматически генерировать их на сайте как соответствующие теги (тип — Пользовательский HTML — рис.4), но в данном случае жёсткое прописывание в код виджета было необходимо — некоторые события на сайте требуют, чтобы счетчик сразу устанавливался внутрь виджета. В основном это события загрузки, появления преролла. Если же у вас нет такого рода событий, то можно генерировать код счетчика через GTM:
*Рисунок 4 — Пример передачи кода Метрики на сайт через GTM*
Чтобы передавать данные сразу в два счетчика (партнера и владельца), требуется устанавливать не два разных кода Метрики или Analytics, а создавать **специальный сдвоенный код**. На момент написания статьи правильные коды выглядят так (рис.5):
*Рисунок 5 — Верный вариант использования сдвоенных кодов Метрики и GA*
Далее нужно передать внутрь кода счетчика идентификатор, заданный партнером. Сложность здесь в том, что код виджета генерируется автоматически для всех сайтов, при этом идентификаторы задаются уже в отдельном партнерском кабинете. Для правильного проброса программистом было реализовано следующее решение:
При инициализации виджета создается iFrame, в параметры которого передаются идентификаторы счетчиков партнера (счетчики передаются в src iFrame, после чего парсятся в виджете из location). iFrame открывает приложение виджета и в хуке created жизненного цикла виджета (SPA) до монтирования обрабатываются входные параметры номеров счетчиков, а в localStorage сохраняются номера (идентификаторы).
Для размещения кода Google Analytics в index.html используется следующая конструкция:
```
window.dataLayer = window.dataLayer || [];
function gtag() {
dataLayer.push(arguments);
}
gtag('js', new Date());
gtag('config', 'UA-15930803-13');
gtag('config', window[localStorage.getItem('partnerGA')] || 'UA-15930803-14');
```
Скрипты с переменным src вставляются динамически при инициализации счетчиков:
```
let script = document.createElement('script')
script.setAttribute('src', `https://www.googletagmanager.com/gtag/js?id=${ga || 'UA-15930803-14'}`)
document.head.insertBefore(script, document.head.firstChild)
```
Здесь UA-15930803-14 – «подставной» счетчик владельца, который используется в том случае если партнером его счетчик не задан. Данная ситуация может возникнуть если партнер не задал идентификаторы счетчиков в целом или задал лишь один идентификатор – всегда должен быть подменный код, чтобы на сайте не возникало ошибок JavaScript, связанных с отсутствием идентификатора для правильного срабатывания кода передачи какого-либо события. UA-15930803-13 в данном случае – основной идентификатор Владельца, в который данные приходят в любом случае и с любого сайта.
Аналогично GA формируется код Яндекс.Метрики, в котором используются заданный идентификатор Метрики владельца, подменный идентификатор счетчика владельца «по умолчанию» и конструкция для передачи идентификатора партнера. Код формируется по схеме, представленной на рис.5 с применением конструкций из примера выше.
Следом за кодами счетчиков нужно пробросить заданные партнером идентификаторы внутрь Google Tag Manager. Внутри контейнера они уже будут использоваться как внутренние переменные, чьи значения можно поставлять в генерируемые события.
Для GTM чаще всего используется методика переменных уровня данных (dataLayer). Уровень данных — это переменная JavaScript, инициализация которой описывается внутри контейнера Google Tag Manager автоматически. С помощью нее можно передавать как происходящие на сайте события типа event, так и задавать для GTM собственные переменные. Делается это с помощью конструкции
```
dataLayer.push(‘имя_переменной’: ’значение_переменной’);
```
Срабатывающей после объявления кода GTM на сайте. Однако в нашем случае переменная уровня данных не сработала, возможно дело в сложностях работы именно с iframe. Если задавать конструкцию push() автоматически, то контейнер не получает переменных, а в данном случае хотелось именно такой реализации задачи. Если же пробовать задавать переменную уровня данных вручную (например, по любому клику на сайте), то проброс переменной проходит нормально.
Чтобы не тратить время на разбор процесса, мы использовали альтернативное решение — создание глобальных переменных JavaScript через **localStorage**.
Свойство localStorage позволяет хранить переменные с заданными значениями не привязываясь к открытой странице сайта, а данные внутри этого хранилища не могут быть просто так удалены. Соответственно, идентификаторы партнерских счетчиков были проброшены путем использования следующих конструкций:
```
localStorage.setItem('partnerMetrika1', 'УУУУУУУУ');
localStorage.setItem('partnerMetrika2', 'yaCounterУУУУУУУУ');
localStorage.setItem('partnerGA', 'UA-УУУУУУУ-УУ');
```
Здесь первая конструкция передает сам номер партнерской Метрики, вторая конструкция передает сборное значение yaCounter для удобства создания тега “Событие” в Google Tag Manager (об этом далее), а третья — идентификатор Google Analytics.
На этом передача данных завершена и в дело вступает настройка самого GTM.
Во-первых, определимся с принципом работы Google Tag Manager. В нем представлены 3 уровня взаимодействия:
**Тег**. Это часть кода, которая может быть размещена на сайте с установленным GTM и может быть выполнена как любой другой код, изменяя содержание сайта или передавая данные в счетчики веб-аналитики.
Тег срабатывает, если на сайте выполняется некоторое условие.
**Триггер**. Это собственно условие, выполнение которого вызывает за собой срабатывание тега. Это может быть событие (event) на сайте, изменение значения переменных или стандартное действие — например клик или просмотр страницы.
**Переменная**. Содержит в себе некоторые значения, которые можно передавать различными способами, и используется как поставщик данных для тегов или маркер условия.
Содержание переменных влечет за собой срабатывание триггера, а триггер в свою очередь вызывает соответствующий тег. Идентификаторы партнерских счетчиков задаются именно как переменные, с этого стоит начать формирование данных в контейнере GTM.
Мы создали три основных переменных типа “Собственный код JavaScript” (рис.6):
*Рисунок 6 — Пример переменной, берущей партнерский идентификатор Метрики*
Здесь значение переменной = то значение, которое мы взяли из localStorage.
Теперь если GTM обратится к переменной, то получит ее значение — идентификатор партнерской Метрики. Точно также мы создали переменные под номер партнерской Метрики и идентификатор партнерского Google Analytics.
Для чего используются такие переменные? Они решают задачу отправки данных о срабатывании событий на сайте в партнерские счетчики. В Google Tag Manager есть стандартная процедура передачи целей в Google Analytics, где в качестве идентификатора счетчика можно использовать значение переменной. А для Метрики используется тег в виде пользовательского HTML-кода, содержащего стандартный JavaScript Метрики:
```
yaCounterXXXXXX.reachGoal('TARGET_NAME');
```
Здесь TARGET\_NAME — это внутреннее наименование целевого события для Метрики (такие цели создаются в настройках счетчика через тип “JavaScript-событие”), а ХХХХХХ — номер счетчика.
Таким образом, мы создаем для разного вида счетчиков соответствующие теги.
**Для Google Analytics:**
Тип тега — “Universal Analytics”, идентификатор отслеживания — из нашей переменной.
*Рисунок 7 — Пример настройки тега, передающего данные в Google Analytics.*
Здесь Категория и Действие — те значения, которые должен поймать Google Analytics в качестве параметров срабатывания цели. Идентификатор отслеживания — заданная ранее переменная, взявшая партнерский идентификатор из localStorage.
**Для Яндекс.Метрики:**
Тип тега — “Пользовательский HTML” с применением конструкций JavaScript.
*Рисунок 8 — Пример настройки тега, передающего данные в Яндекс.Метрику*
Здесь {{PartnerMetrikaCounter}} — внутреннее объявление переменной, берущей идентификатор партнерской Метрики из localStorage. С помощью объекта window мы подставляем значение переменной в исполняемый код, и на выходе получаем yaCounterXXXXXXХХ.reachGoal('widget\_loading');, где widget\_loading — значение, которое ловит Метрика в качестве параметра срабатывания цели.
Остается только задать триггеры, чтобы сработали соответствующие теги. Триггерами в нашем случае стали, к примеру:
* События успешной загрузки виджета;
* События успешного или неуспешного прохождения шага на виджете;
* Заполнение определенных полей;
* Выбор условий А или Б внутри виджета;
* Взаимодействие с формами, кнопками и ссылками.
Далее в настройках счетчиков Метрики и Google Analytics остается лишь создать соответствующие цели:
*Рисунок 9 — Пример настройки цели в Яндекс.Метрике*
*Рисунок 10 — Пример настройки цели в Google Analytics*
Задача решена. Сдвоенные коды счетчиков подставляют в идентификаторы Метрики и Analytics партнера заданные им значения, а значения идентификаторов владельца остаются неизменными. В то же время Google Tag Manager пробрасывает срабатывания соответствующих целей в счетчики партнера только в том случае если получает из переменных именно те идентификаторы, которые задал конкретный партнер на своем сайте. Параллельно с этим GTM отправляет владельцу все целевые события со всех сайтов.
Если же партнер не задал один или оба идентификатора, то используются значения по умолчанию — идентификаторы тестовых счетчиков, заданные владельцем заранее. | https://habr.com/ru/post/424799/ | null | ru | null |
# asp.net: gzip, несколько вариантов включения
Сжатие web-содержимого посредством gzip (GNU zip) – это довольно старая технология. Суть ее сводится к тому, что web-содержимое перед отправкой пользователю сжимается по известному всем алгоритму zip. Сама спецификация gzip описана в [RFC1952](http://tools.ietf.org/html/rfc1952), версия 4.2 которой датируется маем 1996 года. На сегодняшний день все популярные браузеры и веб-серверы поддерживают сжатие web-содержимого посредством gzip. В этой статье я постараюсь рассказать о нескольких способах включения в проекты asp.net поддержки gzip-сжатия.
Включение HTTP-compression на сервере IIS
=========================================
Первый способ самый простой. Вы просто нажимаете пару кнопок в настройках IIS, и вот уже web-сервер обеспечивает вам автоматическое сжатие для клиентов, которые gzip поддерживают.
> `Для тех, кто не знает, как в IIS включить сжатие, рассказываю: необходимо в диспетчере служб IIS зайти в свойства элемента «Веб узлы» и перейти во вкладку «Служба».`
>
>
Данный способ самый простой, но вместе с тем не самый гибкий.
Плюсы такого включения сжатия:
• простота;
• поддержка сжатия IIS статических файлов;
• поддержка кэширования сжатых файлов;
• не требует написания кода.
Минусы включения поддержки сжатия на сервере IIS:
• сервер решает: вы не будете знать что, когда и как сжимается;
• глобальное включение: сжатие включается для всей службы разом и будет влиять на все узлы или виртуальные каталоги вашего сервера (по крайне мере, через gui отключить сжатие у конкретного узла нельзя);
• проблемы: лично я столкнулся с проблемой, когда один из пользователей пожаловался на то, что у него стала отображаться пустая главная страница как раз после включения сжатия через IIS, после выключения все вернулось в норму. Данный момент скорее из разряда частных и к общему случаю не подходит, но я привел его, как пример того, почему глобальное включение сжатие в IIS может вас не устроить.
Application\_BeginRequest
==========================
Суть этого метода, описанного в интеренете во многих источниках, например, тут
[www.stardeveloper.com/articles/display.html?article=2007110401&page=1](http://www.stardeveloper.com/articles/display.html?article=2007110401&page=1)
состоит в том, что вы, используя, появившиеся в .net framework 2.0 классы System.IO.Compression.GZipStream и System.IO.Compression.DeflateStream определяете свой собственный фильтр содержимого http-запроса, который перед отправкой клиенту, сжимает данные посредством методов GZipStream. Особенность этого метода в том, что все действия по сжатию содержимого производятся в global.asax в методе Application\_BeginRequest, который вызывается перед запросом пользователя. Тем самым можно создать фильтр на любой запрос пользователя для отправки всего содержимого Response в сжатом виде. Вот как этот метод выглядит в исходном виде (взято с сайта указанного выше):
> <%@ Application Language=«C#» %>
>
> <%@ Import Namespace=«System.IO» %>
>
> <%@ Import Namespace=«System.IO.Compression» %>
>
>
>
> «server»</font>><br/>
> <font color="#0000ff">void</font> Application\_BeginRequest(<font color="#0000ff">object</font> sender, <font color="#2B91AF">EventArgs</font> e)<br/>
> {<br/>
> HttpApplication app = (HttpApplication)sender;<br/>
> <font color="#0000ff">string</font> acceptEncoding = app.Request.Headers[<font color="#A31515">«Accept-Encoding»</font>];<br/>
> <font color="#2B91AF">Stream</font> prevUncompressedStream = app.Response.Filter;<br/>
> <br/>
> <font color="#0000ff">if</font> (acceptEncoding == <font color="#0000ff">null</font> || acceptEncoding.Length == 0)<br/>
> <font color="#0000ff">return</font>;<br/>
> <br/>
> acceptEncoding = acceptEncoding.ToLower();<br/>
> <br/>
> <font color="#0000ff">if</font> (acceptEncoding.Contains(<font color="#A31515">«gzip»</font>))<br/>
> {<br/>
> <font color="#008000">// gzip</font><br/>
> app.Response.Filter = <font color="#0000ff">new</font> GZipStream(prevUncompressedStream,<br/>
> CompressionMode.Compress);<br/>
> app.Response.AppendHeader(<font color="#A31515">«Content-Encoding»</font>,<br/>
> <font color="#A31515">«gzip»</font>);<br/>
> }<br/>
> <font color="#0000ff">else</font> <font color="#0000ff">if</font> (acceptEncoding.Contains(<font color="#A31515">«deflate»</font>))<br/>
> {<br/>
> <font color="#008000">// defalte</font><br/>
> app.Response.Filter = <font color="#0000ff">new</font> DeflateStream(prevUncompressedStream,<br/>
> CompressionMode.Compress);<br/>
> app.Response.AppendHeader(<font color="#A31515">«Content-Encoding»</font>,<br/>
> <font color="#A31515">«deflate»</font>);<br/>
> }<br/>
> }<br/>
> \* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
Основные плюсы данного метода:
• расположение в global.asax позволяет решить проблему централизованно, разом разрешив сжатие для всего потока данных в контексте одного web-приложения asp.net;
• сжимается практически весь контент;
• немного переделав этот код, можно гибко фильтровать содержимое для сжатия.
Минусы данного метода:
• способ определяет правило для всего приложения, нет возможности отключить сжатие для ряда страниц;
• данный метод некорректно работает с ajax.net, что вообще не позволяет использовать его в ajax-ориентированном приложении;
• по сравнению с первым методом через IIS, здесь приходится писать код и сопровождать его.
Надо заметить, что проблема с ajax.net возможно имеет решение, но мне на момент написания статьи такое решение не известно. Я буду благодарен, если кто-нибудь опишет реализацию данного способа включения gzip в ajax.net проектах.
GZipEncodePage
==============
Отличный специалист Rick Strahl на своем блоге
[west-wind.com/WebLog/default.aspx](http://west-wind.com/WebLog/default.aspx)
приводит еще один, альтернативный способ сжатия web-страниц посредство gzip. Рассмотрим пару функций которые он написал, а я сделал статическими:
> public static bool IsGZipSupported()
>
> {
>
> string AcceptEncoding = HttpContext.Current.Request.Headers[«Accept-Encoding»];
>
> if (!string.IsNullOrEmpty(AcceptEncoding) &&
>
> (AcceptEncoding.Contains(«gzip») || AcceptEncoding.Contains(«deflate»)))
>
> return true;
>
> return false;
>
> }
>
>
>
> public static void GZipEncodePage()
>
> {
>
> if (IsGZipSupported())
>
> {
>
> HttpResponse Response = HttpContext.Current.Response;
>
>
>
> string AcceptEncoding = HttpContext.Current.Request.Headers[«Accept-Encoding»];
>
> if (AcceptEncoding.Contains(«gzip»))
>
> {
>
> Response.Filter = new System.IO.Compression.GZipStream(Response.Filter,
>
> System.IO.Compression.CompressionMode.Compress);
>
> Response.AppendHeader(«Content-Encoding», «gzip»);
>
> }
>
> else
>
> {
>
> Response.Filter = new System.IO.Compression.DeflateStream(Response.Filter,
>
> System.IO.Compression.CompressionMode.Compress);
>
> Response.AppendHeader(«Content-Encoding», «deflate»);
>
> }
>
> }
>
> }
>
> \* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
Первый метод просто проверяет поддержку клиентом технологии сжатия, а вот второй очевидно практически равносилен методу из примера о Application\_BeginRequest, только в данном случае вынесен в отдельную функцию. Что это дает? Ну, во-первых, рассмотрим использование:
> protected void Page\_Load(object sender, EventArgs e)
>
> {
>
> HtmlUtil.GZipEncodePage();
>
> }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
Очевидно, что данный метод работает на уровне пользовательских страниц. Работает только с телом страницы и не обрабатывает js,css и любые другие файлы.
Плюсы этого подхода:
• работает на уровне одной страницы, позволяет включать сжатие только на тех страницах, где это требуется;
• не сжимает ничего кроме тела страницы, тем самым не конфликтуя с ajax.net.
Минусы:
• нет возможности разом включить сжатие везде на сайте;
• не сжимает js, css и другие ресурсы;
• необходимо писать код и поддерживать его.
Очень важно, при использовании этого метода вызывать его до любой первой записи в Response.
Послесловие
===========
Лично я остановился на третьем варианте. Во-первых, часть моего проекта написана на ajax.net и второй вариант у меня не заработал. Во-вторых, я столкнулся с проблемой при включении централизованного сжатия на уровне IIS, следовательно, и первый вариант мне не подошел. В-третьих, третий подход лично мне кажется элегантным и гибким. Для сжатия js и css можно поискать и другие способы, а сжатие одних только aspx уже дает заметный выигрыш в размере трафика.
Приведу некоторые данные:
• по моим измерениям размер данных страниц передаваемых клиенту при сжатии через gzip уменьшился в среднем в шесть раз;
• размер ajax-ответов клиенту уменьшился в среднем в десять раз;
• увеличение нагрузки на процессор на сервере не берусь оценить, но в интернете ее оценивают как ~5%, что для себя считаю вполне допустимым.
Для себя делаю вывод, что сжатие одних только страниц позволяет значительно уменьшить размер передаваемых данных, а для ajax-ориентированного проекта бонусом пойдет еще и уменьшение размера всех ajax-данных передаваемых клиенту. | https://habr.com/ru/post/26260/ | null | ru | null |
# Запись данных в Teradata c помощью DML
> *Если идти всё прямо да прямо, далеко не уйдешь…
>
> (Маленький принц, Антуан де Сент-Экзюпери)*
>
>
Недавно ко мне обратился коллега с просьбой как-то помочь с Teradata. Eё сейчас активно внедряют и первым шагом этого внедрения является загрузка данных на ежедневной основе. Заливать приходится очень много и как можно быстрее. Меня попросили найти какие-нибудь альтернативные способы загрузки данных в Teradata, которые бы не сильно зависели от выделенных пользователю ресурсов. В процессе этой работы мне пришлось более близко познакомиться с .NET Data Provider for Teradata. Входе знакомства выяснились некоторые любопытные детали, знание которых, на мой взгляд, может быть очень полезным. Так как о Teradata знают не все, начну я с краткого её описания.
### Что такое Teradata
**С точки зрения программиста, который загружает и получает из неё данные:**
Teradata — это большое хранилище данных работу с которыми пытаются оптимизировать с помощью программно-аппаратной архитектуры. В архитектуре основной упор делается на параллелизм.
**Из [википедии](https://en.wikipedia.org/wiki/Teradata)**:
Teradata is a massively parallel processing system running a shared-nothing architecture. Its technology consists of hardware, software, database, and consulting. The system moves data to a data warehouse where it can be recalled and analyzed.
### Загрузка данных в Teradata
Загрузку/Выгрузку больших объемов данных в Teradata предлагается делать с помощью
[Teradata Load and Unload Utilities](https://en.wikipedia.org/wiki/Teradata). Существуют на данный момент следующие утилиты:
* Teradata TPump
* Teradata FastLoad
* Teradata MultiLoad
* Teradata FastExport
* BTEQ
У нас в компании пользуются в основном [Teradata FastLoad](http://www.teradatatech.com/?p=862). В качестве [ETL](https://ru.wikipedia.org/wiki/ETL) используем продукт фирмы
[Informatica](https://www.informatica.com/products/data-integration.html).
Утилиты загрузки/выгрузки в Teradata в сравнении с DML требуют более глубокого погружения в теорию Teradata. В частности:
* надо уметь их настраивать
* знать принцип работы
* учитывать их специфику и ограничения, которые они накладывают на таблицы в которые идёт запись
* администратор Teradata может наложить ряд ограничений на их работу
Отсюда, способ записи данные с помощью DML команды Insert по прежнему актуален. DML более распространен, менее требователен к настройкам и поддерживается Teradata. Я решил проверить насколько эффективно можно использовать эту команду. В целях эксперимента был создан тестовый проект, целью которого было разобраться в принципах работы Terdata провайдера. Первым делом, я попробовал решить задачу в лоб – читать одну строчку из Oracle и затем вставлять её в Teradata, но этот способ оказался очень медленным. С целью найти виновного, я модернизировал программу – теперь она читала из Oracle, создавая под каждую строку поток, который вставлял данные в Teradata. По стремительно растущему количеству потоков, стало понятно, что основным виновником низкого быстродействия были Insert операции в Teradata. Поняв что вставка одной строки занимает много времени попробовал вставлять разом несколько строк, разделяя ‘;’ команды Insert. Скорость ощутимо возросла. Увеличивая количество строк, вставляемых за один раз я пришёл к Exception:
```
[.NET Data Provider for Teradata][100056] Total size of parameters is greater than the max Data parcel size.
```
Порывшись в исходниках я нашёл место, где возникало данное исключение:
```
if (bodyLength > this._maxParamRowSpace || bodyLength - num > this._sessionContext[WpSessionContext.SessionLimits.MaxDataParcelSize])
throw UtlTrace.TraceException((Exception) new TdException("InvalidDataPclSize", new object[0]));
```
Вычислить точный размер Data parcel у меня так и не получилось, так как цифры, которые в теории были вроде как верными разбивались о практику, когда я просто менял число полей и их тип в операции Insert. Но по исходникам видно, что исключение появляется до момента обращения к Teradata, внутри провайдера, что позволяет в цикле увеличивать количество операций Insert до момента возникновения ошибки, так как нет никакого времени ожидания от Teradata.
```
do
{
numParamsInExec = _oneExec(ref com, numParamsInExec, ref err);
} while (err == Const.ERR_100056);
```
Таким образом, определяем максимальное количество операций Insert за один раз. Далее выполняем вставку данных пакетами, в случае возникновения Exception 100056, уменьшаем размер пакета. Данное решение существенно повысило скорость записи данных в Teradata, без использования специальных утилит. Отсюда, этот способ можно использовать в случае, если Вы ограниченны в ресурсах или же для записи сравнительно небольших объёмов данных в Teradata. | https://habr.com/ru/post/271735/ | null | ru | null |
# Очередной перл выданный индусами.
Попался мне код, писанный одним индусом, а если точнее то мне было лень проверять в C# является ли строка числом с помощью метода TryParse и я решил посмотреть есть ли более «короткий» способ. вот на что я наткнулся
> `for (int i=0; i<this.textbox1.text.length; i++)
>
> {
>
> if (char.IsDigit(this.textbox1.text[i])==false)
>
> // give any error
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Я конечно понимаю, что это «оптимизированный» метод на основе Replace, но всё равно забавно :). | https://habr.com/ru/post/47178/ | null | ru | null |
# Краткий обзор статьи: «Что лучше: предварительно обученные свертки или предварительно обученные трансформеры?»
В этой статье авторы из Google Research хотели исследовать вопрос, могут ли CNN-архитектуры конкурировать с трансформерами (Transformers) в задачах NLP. Оказывается, что предварительно обученные модели CNN (convolutional neural network — сверточная нейронная сеть) все-таки превосходят предварительно обученных трансформеров в некоторых задачах; они также обучаются быстрее и лучше масштабируются под длинные последовательности.
По словам авторов, ранее не публиковались серьезные работы с проведением научных экспериментов по предварительному обучению и настройке CNN для работы с текстами.
Возможные преимущества CNN:
* из-за отсутствия self-attention требуется меньше памяти;
* они работают локально и поэтому не нуждаются в positional embedding’ах.
С другой стороны, CNN не предполагают доступ к глобальной информации; например, они не способны на что-то вроде cross-attention между несколькими последовательностями.
#### Подход к моделированию
* Используются depthwise separable convolutions;
* Предварительное обучение Seq2Seq на основе диапазона (span-based): они маскируют диапазон длиной L, и модель пытается его предсказать;
* Потеря кросс-энтропии и усиление учителем;
#### Архитектура
Авторы не раскрывают нам точные архитектуры, но вот общее представление о них:
* Архитектура Seq2Seq, но вместо `multi-head attention` сверточные блоки;
* Проекции закрытого линейного блока (gated linear unit) вместо `query-key-value` трансформаций;
* В различных экспериментах испытываются легкие, динамические и расширенные свертки;
* Каждый подмодуль обернут остаточными связями (residual connections) и нормой слоя (layer norm);
#### Вопросы
Авторы исследования задают пять вопросов, на которые они собираются ответить:
* Вопрос 1: Польза сверток от предварительного обучения такая же, как и для трансформеров? [Да]
* Вопрос 2: Могут ли сверточные модели, предварительно обученные или нет, конкурировать с трансформер-моделями? В каких случаях они хорошо себя показывают? [Да; превосходят в шести задачах]
* Вопрос 3: Каковы преимущества (если таковые имеются) использования предварительно обученных моделей сверток по сравнению с предварительно обученными трансформерами? Являются ли свертки более быстрой альтернативой трансформерам с self-attention? [Да, они быстрее]
* Вопрос 4: Каковы типы отказов, подводные камни и причины не использовать предварительно обученные свертки?
* Вопрос 5: Какие варианты сверток лучше? [Расширенные и динамические лучше, чем легковесные]
#### Эксперименты
Авторы используют 8 наборов данных на различных задачах: двоичная и мультиклассовая классификация, генерация семантического представления.
Модели аналогичны базовому BERT: 12 слоев в кодировщике и декодере, размерность 3072 в слоях с прямой связью, размерность модели 768 и 12 голов. Они не настраивают параметры сверточных блоков; они используют размер окна 7 и 2 фильтра глубины. Для расширенных моделей размеры фильтров [4, 4, 7, 7, 15, 15, 15, 15, 31, 31, 31]. [Интересно, как они выбирали значения, если они не оптимизировали гиперпараметры]
Модель трансформера похожа на Т5.
**Предварительное обучение**
Авторы обучают как сверточные, так и модели-трансформеры за 524 тысячи шагов с размером батча 128. Цель предварительного обучения описана выше, размер диапазона (span size) - 3, уровень искажения - 15%. Они используют оптимизатор Adafactor [я никогда не слышал о нем раньше] с планировщиком скорости обучения с обратным квадратным корнем. Предварительное обучение проводилось на 16 TPU в течение 12 часов.
#### Результаты
* В моделях CNN отсутствует cross-attention, и поэтому они хуже работают с задачами, которые подразумевают моделирование отношений между последовательностями. Эксперименты с SQuAD и MultiNLI показывают, что трансформеры намного лучше справляются с этими задачами. Но если мы добавим перекрестное внимание (cross-attention) к моделям CNN, они достигают почти той же производительности, что и модели-трансформеры.
* Модели CNN имеют лучшую скорость обучения и лучше масштабируются для более длинных последовательностей.
* Модели CNN более эффективны с точки зрения FLOP
Авторы дополнительно указывают на следующий вывод: в NLP предварительное обучение обычно выполнялось только для моделей-трансформеров, но оказывается, что предварительное обучение может приносить пользу и для других архитектур. Они надеются, что эта статья поможет открыть новые возможности для исследователей.
---
> Материал подготовлен в рамках курса [«Deep Learning. Basic»](https://otus.pw/4zwB/).
>
> На практике дата саентисты часто сталкиваются с недостатком данных для обучения. Классический выход из положения — провести transfer learning при помощи finetuning — обладает досадным свойством катастрофического забывания. На открытом уроке [«Transfer learning при помощи перемежающейся тренировки»](https://otus.pw/icQ1/) рассмотрим метод перемежающейся тренировки, позволяющий избежать переобучения на маленьком датасете.
>
> [**→ РЕГИСТРАЦИЯ**](https://otus.pw/icQ1/)
>
> | https://habr.com/ru/post/572398/ | null | ru | null |
# Вышел Zabbix 3.4
Привет! Хотим поделиться новостью, что у нас появилась новая версия опенсорс системы мониторинга Zabbix 3.4, доступная для [скачивания](https://www.zabbix.com/download):
Из нового:
* Переработанные дэшборды (их много и их можно редактировать)
* Массовый, одновременный сбор элементов данных
* Парсинг полученных данных, включая Regexp, XPath, JSON Path
* Выполнение удаленных команд через прокси
* Шаблоны сетевых устройств из коробки
* Низкоуровневое обнаружение для JMX
* Новые возможности уведомлений
* Переработанный сбор данных по IPMI
и многое, многое другое.
Новые дэшборды
--------------
В 3.4 в Zabbix появились новые дэшборды вместо одного старого. С поддержкой drag-n-drop, ресайза, c улучшенной фильтрацией, они создаются из доступных в Zabbix основных графических элементов из других разделов (такие как графики, карты, списки проблем, а также все то, что было доступно в комплексных экранах). Пользователи могут создавать дэшборды для себя, но при этом можно и поделиться друг с другом. API для создания дэшбордов в комплекте.
Читайте подробнее в [документации](https://www.zabbix.com/documentation/3.4/manual/introduction/whatsnew340#new_dashboards).
Препроцесинг
------------
Помните тот случай, когда оборудование вендора XYZ отдает температуру текстом «25 С», а нам нужно число(уж очень любим графики и триггеры)?
Теперь не нужно лишних движений, в препроцессинге мы просто отрезаем лишнее, используя различные функции препроцессинга: начиная от простых Trim, Regular Expressions и заканчивая выделением нужных данных из JSON, XML используя JSON Path и XPath соответственно.
Подробнее в нашей [документации](https://www.zabbix.com/documentation/3.4/manual/config/items/item#item_value_preprocessing).
Одновременный сбор данных. Зависимые элементы данных
----------------------------------------------------
Предыдущая возможность препроцессинга отлично сочетается с [зависимыми элементами данных](https://www.zabbix.com/documentation/3.4/manual/config/items/itemtypes/dependent_items):
Собирайте данные одним мастер-элементом, а затем раскладывайте по множеству зависимых элементов, используя такие функции препроцессинга как regex, XPath или JSON Path, чтобы выделить нужный элемент. Все зависимые элементы обновятся одновременно, а удаленный сервис, который мы мониторим, будет опрошен лишь единожды.
Выполнение удаленных команд через прокси
----------------------------------------
Выполнять скрипты и удаленные команды теперь можно и на те узлы сети, которые мониторятся через Zabbix proxy. Команда может быть выполнена через Zabbix agent или на Zabbix proxy. По умолчанию, выполняются только команды IPMI, Telnet и SSH, а [разрешить](https://www.zabbix.com/documentation/3.4/manual/introduction/whatsnew340#remote_command_support_through_proxies) выполнение остальных команд достаточно легко, если требуется.
Управление интервалами сбора и хранения через макросы
-----------------------------------------------------
Управлять интервалами опроса элементов данных стало проще с поддержкой пользовательских макросов и суффиксов времени типа 30s, 5m, 2h, 1d, 1w.
Просто меняем значение макроса и интервал обновления, период хранения истории или трендов тут же изменится во всех элементах данных, где используется этот макрос. Кроме того, макросы низкоуровневого обнаружения могут быть использованы в интервалах опроса или хранения прототипов элементов данных. Контекстные макросы также поддерживаются в интервалах!
Небольшой пример, что можно сделать:
• Настраиваем рабочее время как макрос:
• Определяем сам макрос:
• Используем макрос вместе с суффиксом времени сразу в пользовательских интервалах, интервалах обновления и в периодах хранения:
Новые шаблоны сетевых устройств
-------------------------------
Для мониторинга «из коробки» начинаем наращивать [коллекцию шаблонов](https://www.zabbix.com/documentation/3.4/manual/config/templates_out_of_the_box/network_devices), реализующих мониторинг основных метрик. В 3.4 доступны шаблоны сетевых устройств от многих производителей, таких как Cisco, Juniper, Huawei, Mikrotik, Dell, Brocade, D-Link, HP и другие, в которых реализован мониторинг по SNMP за процессорами, памятью, сетевыми интерфейсами, температурой, блоками питания, вентиляторами. Собираются и базовые инвентарные данные.
Настраиваемые JMX endpoints и низкоуровневое обнаружение для JMX
----------------------------------------------------------------
Следующая новость придется по вкусу всем, кто мониторит Java-приложения, в том числе тем, кто до этого использовал различные трюки при мониторинге JMX. Для JMX мониторинга появился специальный параметр, который позволяет явно указать по какому URI обращаться за данными (должно помочь с JBoss последних версий, например). Все возможные макросы, начиная с {HOST.\*} поддерживаются. Гибкость.
Новое обнаружение **`jmx.discovery[*]`** позволяет указать, требуется ли обнаружение MBeanов или их атрибутов, а также по какому шаблону их искать. Читайте далее [здесь](https://www.zabbix.com/documentation/3.4/manual/discovery/low_level_discovery/jmx).
Различные улучшения сервера
---------------------------
Сам Zabbix-сервер тоже не остался в стороне и был улучшен. Большое количество ~~скучных~~ изменений:
• Увеличение размера файла SNMP траппера
• Оптимизация протокола обмена Zabbix-сервера и Zabbix-прокси.
• Более эффективная синхронизация конфигурационного кэша
… и многое [другое](https://www.zabbix.com/documentation/3.4/manual/introduction/whatsnew340#daemon_improvements).
Чтобы разговаривать более предметно, ниже график времени синхронизации конфигурационного кэша.
*В 13:35 мы перешли на Zabbix 3.4. Ну дальше сами видите. Больше никаких лишних тормозов.*
Различные улучшения веб-интерфейса
----------------------------------
[Продолжаем](https://www.zabbix.com/documentation/3.4/manual/introduction/whatsnew340#frontend_improvements) причесывать и делать фронтэнд удобнее и дружелюбнее:
• увеличили размер различных полей
• унифицировали стиль чекбоксов
А главное добавили функционал полного клонирования карт и комплексных экранов. Это пригодится.
При настройке прав доступа на группы узлов сети появилась возможность, которая позволяет применять права доступа и на все вложенные группы. Тоже пригодится.
А еще Internet Explorer 9 и 10 больше не поддерживаются. Такие дела.
Уведомления при подтверждении
-----------------------------
Теперь можно получать уведомления от Zabbix в тот момент, когда проблема была подтверждена кем-то, например оператором.
Также появилась интересная возможность, что если пользователь оставил комментарий в проблеме, то он сможет получать уведомления о всех последующих комментариях.
[www.zabbix.com/documentation/3.4/manual/config/notifications/action/acknowledgement\_operations](https://www.zabbix.com/documentation/3.4/manual/config/notifications/action/acknowledgement_operations)
Подробнее читайте по [ссылке](https://www.zabbix.com/documentation/3.4/manual/config/notifications/action/acknowledgement_operations).
Параллельная обработка оповещений
---------------------------------
Отправка оповещений в Zabbix 3.4 становится лучше — несколько параллельно работающих worker-процессов занимаются отправкой уведомлений под присмотром аlert-менеджера.
При этом для каждого способа оповещения, будь то SMS, почта или любимый мессенджер можно отдельно настраивать максимальное количество процессов, однако, важно знать, что максимальное количество сессий ограничено конфигурационным параметром [StartAlerters](https://www.zabbix.com/documentation/3.4/manual/appendix/config/zabbix_server) на Zabbix-сервере.
Проверка exit-кода
------------------
Еще одно [нововведение](https://www.zabbix.com/documentation/3.4/manual/appendix/command_execution#exit_code_checking), которое давно напрашивалось. Ошибки при сборе данных через UserParameters, при выполнении удаленных команд или при выполнении оповещений через скрипты доступны в веб-интерфейсе. Теперь работать с существующими скриптами или писать свои станет гораздо проще — ведь сразу будет понятно, что, например, уведомление не отправлено, а также почему.
Попробуйте Zabbix 3.4 уже сейчас
--------------------------------
Сама версия доступна для скачивания [здесь](https://www.zabbix.com/download), а более полную информацию о новых возможностях ищите в нашей документации в разделе [Whats new](https://www.zabbix.com/documentation/3.4/manual/introduction/whatsnew340), в том числе, об оптимизации IPMI или поддержке {HOST.\*} макросов в тегах событий.
Для тех, кто собирается обновляться с предыдущих версий на 3.4 предлагаем [инструкцию](https://www.zabbix.com/documentation/3.4/manual/installation/upgrade) по обновлению, или можете [обратиться](mailto:[email protected]) к нам за [помощью](http://www.zabbix.com/upgrade_services).
И приглашаем записываться на наши бесплатные [вебинары](http://www.zabbix.com/webinars) — хорошая возможность узнать про Zabbix больше и задать свои вопросы. | https://habr.com/ru/post/336084/ | null | ru | null |
# Selenium: Накачиваем Мышцы
Прошло довольно много времени с момента [нашей](https://aerokube.com/) [последней статьи](https://habrahabr.ru/post/334048/) об эффективной Selenium-инфраструктуре. Если вы находитесь в самом начале непростого пути Selenium — советую ознакомиться с нашими статьями про масштабируемый Selenium ([часть I](https://hackernoon.com/selenium-testing-a-new-hope-7fa87a501ee9), [часть II](https://habrahabr.ru/post/322742/)), [Selenoid](https://github.com/aerokube/selenoid) — универсальный инструмент для автоматизации тестов в браузерах ([раз](https://habrahabr.ru/post/327184/), [два](https://habrahabr.ru/post/333568/)), Selenium под Windows ([ссылка](https://habrahabr.ru/post/329256/)). Если вам больше нравятся мотивирующие рассказы — посмотрите видео [моего доклада](https://www.youtube.com/watch?v=TGjpc32my0Y) про масштабируемый Selenium на [SeleniumConf Berlin 2017](http://seleniumconf.de/).
С момента публикации последней статьи в нашем сообществе произошло много интересного. Сегодня я хочу рассказать о самых важных возможностях, добавленных в наши инструменты за последние месяцы.
### Ggr
Наш Selenium балансировщик получил несколько крутых улучшений.
1. Во-первых, было добавлено API для определения хоста с браузерами по ID сессии. Это можно сделать вот таким HTTP-запросом:
```
$ curl -s http://test:[email protected]:4444/host/8e82f31f408b4a906f715228b5176efb0528ce32-66db-417f-8fa7-b12d85ce1ab5
{"Name":"my-hub-1.example.com","Port":4444,"Count":5,"Username":"","Password":""}
```
1. Также была добавлена поддержка **гостевых квот**. Браузеры из гостевой квоты можно получить без указания имени пользователя и пароля. Оказывается удобным поддерживать небольшую песочницу, где новые пользователи могут пробовать запускать свои тесты, не изменяя их код. Включить гостевую квоту можно аргументами командной строки Ggr:
```
$ ./ggr -guests-allowed -guests-quota test <остальные флаги...>
```
При добавлении таких флагов любые браузеры из файла `test.xml` будут доступны без указания пароля.
1. Третья крутая штука — это возможность проксировать запросы во внешние сервисы наподобие [SauceLabs](http://saucelabs.com/), [BrowserStack](http://browserstack.com/) или [TestingBot](http://testingbot.com/). Некоторые задачи тестирования, такие как тестирование в мобильных браузерах или тестирование мобильных приложений на устройствах, являются сложными с точки зрения поддержания тестовой инфраструктуры. Вы можете принять решение поддерживать основную часть браузерной инфраструктуры самостоятельно и пользоваться платными сервисами только для таких сложных случаев. Для того, чтобы перенаправить запросы во внешнюю систему просто укажите имя пользователя и пароль в XML файле:
```
```
1. Все наши инструменты, включая Ggr теперь компилируются версией Golang 1.9. Эта версия имеет гораздо более производительные алгоритмы сборки мусора, что дает значительное уменьшение времени ответа. Ggr теперь, действительно, летает.
2. Самое важное изменение — это добавление поддержки **проксирования VNC-данных**. Если хосты из квот Ggr имеют запущенный на каком-то порту VNC-сервер (чтобы смотреть на экран браузера во время выполнения), то вы можете настроить Ggr так, чтобы иметь возможность получать доступ к VNC-данным по ID сессии. Без каких-либо изменений в квотах вы теперь можете использовать вот такие ссылки:
```
ws://test:[email protected]:4444/vnc/8e82f31f408b4a906f715228b5176efb0528ce32-66db-417f-8fa7-b12d85ce1ab5
```
Обратите внимание на протокол `ws://`, означающий [WebSocket](https://en.wikipedia.org/wiki/WebSocket). Используя VNC-клиента, поддерживающего передачу данных через веб-сокеты (например, [noVNC](https://github.com/novnc/noVNC)) вы можете увидеть экран браузера любой запущенной сессии. По-умолчанию Ggr ожидает, что VNC-сервер запущен на стандартном порту 5900, но это можно перенастроить.
Selenoid
--------
Наиболее многочисленные изменения были сделаны в нашем, как говорят, "флагманском" open-source продукте — [Selenoid](http://github.com/aerokube/selenoid/). Selenoid — это полноценная замена Selenium-хаба, запускающая браузеры в [Docker](http://docker.com/) контейнерах:
### Больше Возможностей Настройки
Теперь вы имеете гораздо больше возможностей по настройке окружения браузера. Например, в конфигурационном файле вы можете задавать любые переменные окружения, записи файла `/etc/hosts` и значение `shmSize` для операционной системы внутри контейнера, где будет запущен браузер:
```
{
"firefox": {
"default": "46.0",
"versions": {
"46.0": {
"image": "selenoid/firefox:46.0",
"port": "4444",
"env" : ["TZ=Europe/Moscow"],
"hosts" : ["example.com:192.168.0.1"],
"shmSize" : 268435456,
}
}
}
}
```
Это позволяет, например, переопределять для каждой версии браузера часовой пояс или добавлять хосты из внутренней сети без изменения настроек DNS. В дополнение к этим настройкам вы можете изменять некоторые параметры отдельно для каждой запущенной сессии при помощи capabilities.
### Новые Capabilities
**1.** Если вы запускаете несколько тестов параллельно, то, чтобы различить их в Selenoid UI, вы можете указать капабилити `name` с произвольной строкой внутри:
```
name: "MyCoolTestName"
```
Вот как это выглядит в UI:
**2.** Если тестируемое приложение также запускается в Docker контейнере — вы можете автоматически связать (link) контейнер с браузером с контейнером приложения, указав его имя:
```
applicationContainers: my-application-container
```
**3.** Иногда требуется переопределить содержимое `/etc/hosts` только для одного теста. Это можно сделать так:
```
hostsEntries: "some-host:192.168.0.1"
```
**4.** Наконец, чтобы переопределить часовой пояс для одной сессии — укажите:
```
timeZone: "Europe/Moscow"
```
### Улучшения в Логировании
Мы добавили два важных улучшения в логирование:
**1.** Если браузеры запускаются в контейнерах — любые логи, отправленные в централизованное хранилище логов (такое как Amazon CloudWatch или Google Cloud logging), могут теперь быть помечены произвольной меткой. Значение метки указывается при помощи capability `name`, о которой я писал в предыдущем разделе.
**2.** Если вы запускаете Selenoid без Docker — вы, наконец, можете включить логи веб-драйверов в логи Selenoid. Для того, чтобы это заработало, нужно добавить флаг `-capture-driver-logs` при старте Selenoid:
```
./selenoid -conf ~/.aerokube/selenoid/browsers.json -capture-driver-logs
```
### Образы с Браузерами
Мы пересобрали все [образы с браузерами](https://github.com/aerokube/selenoid-images), добавив поддержку всех UTF-8 локалей и дополнительные шрифты для правильного отображения таких символов как:
* Китайские иероглифы
* Японские иероглифы
* Корейские иероглифы
* Хинди (деванагари)
* Тайский алфавит
Все эти изменения позволяют использовать новые образы для тестирования сайтов, переведенных на множество языков.
### Selenoid UI
Мы полностью переделали внешний вид [Selenoid UI](https://github.com/aerokube/selenoid-ui) — графического веб-интерфейса для Selenoid.
Наиболее часто используемые возможности такие как статистика использования браузеров и кнопки для просмотра сессий теперь располагаются на главной странице. Реже используемый экран выбора capabilities был унесен на отдельную вкладку.
Экран запущенного браузера и логи сессии теперь показываются на одной экране рядом друг с другом.
### Configuration Manager
[Configuration Manager](https://github.com/aerokube/cm) — маленькое приложение, значительно упрощающее установку наших инструментов, стало еще более удобным. Теперь поддерживается возможность настройки Selenoid для работы с [Microsoft Edge](https://en.wikipedia.org/wiki/Microsoft_Edge) и [Safari](https://en.wikipedia.org/wiki/Safari_(web_browser)). Свежие версии CM работают без проблем на Windows 10. Вы также можете переопределить порт, на котором слушает Selenoid и Selenoid UI, например, чтобы одновременно запустить Selenium server и Selenoid.
Мы также сделали вывод CM приятным для глаза, раскрасив логи разными цветами.
### Запись Видео
Вишенкой на торте является недавно добавленная возможность записывать видео браузерных сессий. В дополнение к возможности смотреть на экран браузера в реальном времени в Selenoid UI теперь стало возможно записать видео с экрана браузера и сохранить его в файле формата [H264](https://en.wikipedia.org/wiki/H.264/MPEG-4_AVC). Видео выглядит примерно так:
Для того, чтобы записать видео, просто добавьте одну capability в тесты:
```
enableVideo: true
```
По-умолчанию все записанные видео называются `.mp4`, где — уникальный идентификатор браузерной сессии, который можно легко вытащить из логов теста. Если вы хотите использовать свое имя — добавьте capability `videoName`:
```
videoName: "my-cool-video.mp4"
```
Selenoid автоматически предоставляет доступ к каталогу с видео по HTTP. Чтобы открыть файл в браузере, используйте URL:
```
http://my-selenoid-host.example.com:4444/video/my-cool-video.mp4
```
Чтобы посмотреть весь список файлов — сотрите имя файла:
```
http://my-selenoid-host.example.com:4444/video/
```
Я надеюсь теперь у вас есть гораздо больше мотивации, чтобы настроить в своей команде действительно эффективную инфраструктуру Selenium. Поверьте, запуск тестов в браузерах может быть безболезненным! Если у вас есть какие-то вопросы — не стесняйтесь писать нам на [почту](mailto:[email protected]), в [Telegram-канал поддержки](https://telegram.me/aerokube) или отправляйте вопросы на StackOverflow [тег](https://stackoverflow.com/questions/tagged/selenoid). Если вы уже используете [Kubernetes](http://kubernetes.io/) в своих процессах — вас также может заинтересовать наш новый продукт — [Moon](http://aerokube.com/moon/latest/), который был специально разработан для развертывания эффективного кластера Selenium в Kubernetes и поддерживает все лучшее, что есть в Selenoid.
До новых встреч. | https://habr.com/ru/post/344340/ | null | ru | null |
# ROS2 vs ROS1.Установка ROS2 на Ubuntu 18.04
ROS (Robotic operation system) уверенно занимает лидирующие позиции в стандартах робототехники. Говоря словами известного политика, ею уже пользуются «не только лишь все».
В данной статье попробуем взглянуть на следующий этап развития ROS — систему ROS2, подходящую для более «рукастых» разработчиков. Сравним обе системы в общих чертах, а заодно установим ROS2 на систему Ubuntu 18.04.
\*изображение с [www.theconstructsim.com](https://www.theconstructsim.com/)
В качестве базовой конфигурации ПК будет использоваться слегка устаревшая модель — intel NUC (5i5RYK), 4GB RAM, SSD M.2 120Gb. Производительности NUC хватит «за глаза» для целей ROS, но одноплатники (raspberry, odroid, jetson) намеренно не рассматриваются, потому как каждый из них имеет свою специфику. Предполагается, что система Ubuntu 18.04 (рекомендуемая для целей использования с ROS) уже установлена.
### Вступление.
За последнее десятилетие ROS (ROS1) вырос и вырос в несколько раз. В настоящий момент
он имеет огромный список пакетов, где каждый пакет решает проблему либо частично, либо
полностью, что исключает концепцию изобретения колеса заново. Созданные сообществом пакеты привели к тому, что был создан совершенно новый подход к робототехнике и предложена интеллектуальная начинка для существующих систем.
### Ограничения ROS1.
Несмотря на то, что ROS1 дал определенную свободу общения со сложными аппаратными средствами и программными компонентами, имеются некоторые сложности, связанные с использованием ROS1 в конечном продукте. Данные сложности начинают появляться, когда существует целый парк разнородных роботов (мобильные роботы, роботы- манипуляторы и так далее).
Установить связь между ними довольно сложно из-за того, что существуют архитектурные ограничения ROS1.
Первое ограничение состоит в том, что ROS1 не поддерживает концепцию мультимастера.
Второе ограничение ROS1 заключается в том, что, несмотря на тот факт, что ноды могут без проблем общаться по сети между собой, нет безопасного пути в этом общении. Любой, кто имеет возможность подключиться к мастеру (master-node), может получить доступ к топикам и далее либо эксплуатировать или изменять их. Поэтому основное предназначение ROS1 — проверка концепции или прототипирование для научных целей.
И третье, пожалуй, основное ограничение ROS1 — данная система не является real-time системой. Что приводит к задержкам в получении данных и их потере.
Все вышеизложенные недостатки подтолкнули к созданию ROS2.
### Какие преимущества дает ROS2 ?
— позволяет устанавливать безопасные соединения между компонентами системы (нодами)
— взаимодействие осуществляется в режиме «real-time»
— соединение нескольких роботов в одну сеть упрощено
— улучшено «качество общения» между нодами
— реализуется уровень ROS архитектуры непосредственно на аппаратном обеспечении
— используются новейшие пакеты обновлений (ROS1 обновляется не так часто).
ROS2 следует индустриальному стандарту и реализует real-time взаимодействие через так называемую концепцию DDS (Data Distributed Services).
### Версии ROS2
.
Первая официальная стабильная версия ROS2 была выпущена в декабре 2017г. Дистрибутив назвали «Ardent Apalone». Далее был релиз в июне 2018, с именем «Bouncy Bolson». «Crystal Clemmys» появился в декабре 2018. «Dashing Diademata» (актуальная версия) в мае 2019 г. Как видно, дистрибутивы обновляются достаточно бодро, и, надеемся, алфавита хватит на первое время.
### Поддержка ОС
.
ROS2 поддерживает (если говорить об официальной поддержке) Linux, Windows, macOS, и Real-Time Operating Systems (RTOS) OS layers, ROS1 только Linux и macOS.
Более детально поддержка ОС:
### Итак, зачем нужен ROS2?
ROS2 использует те же принципы работы, что и ROS1. В то же время, ROS2 не является частью ROS1. ROS2 был создан, чтобы перешагнуть ограничения своего собрата путем использования более новых зависимостей и инструментов.
В отличие от ROS1, cтек которого написан на C++, а клиентские библиотеки на C++ и Python, в ROS-2 также используется язык C. Представлен независимый уровень, написанный на C, который взаимодействует с клиентскими библиотеками ROS2, такими как rclcpp, rclpy, and rcljava.
ROS2 лучше поддерживает сетевые конфигурации и реализует надежные соединения.
ROS2 также более не использует концепцию nodelets (http://wiki.ros.org/nodelet ) и поддерживает возможность инициализации нескольких нод одновременно (multinode initialization). В отличие от ROS1, еще одной отличительной чертой ROS2 является возможность отслеживать статус ноды и получать сообщения, если нода или топик добавились или были удалены. Это можно использовать для создания отказоустойчивых систем.
Изменения, которые произошли в ROS2 в сравнении с ROS1:
### Установка ROS2
.
Итак, установим из исходников актуальный дистрибутив Dashing Diademata (dashing) на Ubuntu 18.04
### Настроим окружение.
`$ sudo locale-gen en_US en_US.UTF-8
$ sudo update-locale LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8
$ export LANG=en_US.UTF-8`
### Добавим репозитории ROS2.
`$ sudo apt update && sudo apt install curl gnupg2 lsb-release
$ curl -s https://raw.githubusercontent.com/ros/rosdistro/master/ros.asc |
sudo apt-key add -
$ sudo sh -c 'echo "deb [arch=amd64,arm64] http://packages.ros.org/ros2/ubuntu `lsb_release -cs` main" > /etc/apt/sources.list.d/ros2-latest.list'`
### Установим инструменты разработчика ROS.
`$ sudo apt update && sudo apt install -y build-essential cmake git
python3-colcon-common-extensions python3-lark-parser python3-pip
python-rosdep python3-vcstool wget
$ python3 -m pip install -U argcomplete flake8 flake8-blind-except
flake8-builtins flake8-class-newline flake8-comprehensions flake8-
deprecated flake8-docstrings flake8-import-order flake8-quotes
pytest-repeat pytest-rerunfailures pytest pytest-cov pytest-runner
setuptools
$ sudo apt install --no-install-recommends -y libasio-dev libtinyxml2-dev`
### Создадим workspace ROS2.
`$ mkdir -p ~/ros2_ws/src
$ cd ~/ros2_ws
$ wget https://raw.githubusercontent.com/ros2/ros2/release-latest/ros2.repos
$ vcs import src < ros2.repos`
Это займет некоторое время.
### Установим зависимости, используя rosdep.
`$ sudo rosdep init
$ rosdep update
$ rosdep install --from-paths src --ignore-src --rosdistro dashing -y --skip-keys "console_bridge fastcdr fastrtps libopensplice67 libopensplice69
rti-connext-dds-5.3.1 urdfdom_headers"`
Если все прошло успешно и в терминале появилась запись «All required rosdeps installed successfully», можно переходить к следующему шагу.
### Собираем код, устанавливаем colcon.
В ROS1 пакеты собирались с помощью инструмента catkin. В ROS2 используется colcon (утилита, вобравшая в себя catkin\_make, catkin\_make\_isolated, catkin\_tools, и ament\_tools). colcon может собирать как пакеты ROS1 и пакеты ROS2.
`$ sudo apt install python3-colcon-common-extensions
$ cd ~/ros2_ws/
$ colcon build --symlink-install`
После последней команды, можно смело отправиться пить чай, т.к. установка может занять около часа времени.
По ее успешном завершении, в терминале появится примерно следующая информация об успешной установке:
### Настройка окружения для ROS2 (environment).
Чтобы каждый раз для инициации ROS в терминале не вводить длинную команду 'source ~/ros2\_ws/install/local\_setup.bash', добавим alias в bashrc:
`$ sudo gedit ~/.bashrc`
Далее необходимо в конец файла добавить строку:
`alias initros2='source ~/ros2_ws/install/local_setup.bash`
Сохранить, выйти из файла и перечитать его командой (чтобы не перезагружать систему):
`$ source ~/.bashrc`
### Проверим работу ROS2.
1-й терминал:
`$ initros2
$ ros2 run demo_nodes_cpp talker`
Эти команды запускают «говорящую» ноду.
2-й терминал:
`$ initros2
$ ros2 run demo_nodes_py listener`
Здесь, соответственно, запускается «слушающая» нода.
Наглядно обе ноды выглядят примерно так:
Можно посмотреть также генерируемые нодами топики в 3-м терминале:
Подведем итог. Была обзорно рассмотрена ROS2 в сравнении с ROS1, продемонстрирован порядок установки ROS2 (Dashing Diademata (dashing)) на Ubuntu 18.04. | https://habr.com/ru/post/492058/ | null | ru | null |
# Custom elements в бою
Добрый день!
История данной публикации довольно проста и, возможно, знакома многим. В компании разрабатывается множество продуктов — в нашем случае, в основном, для одного заказчика. В последнее время все решения разрабатываются под web, а существующие desktop-решения на web переносятся.
В связи с этим, при наличии желания увеличить скорость разработки и обеспечить единообразие продуктов, было решено разработать общую компонентную базу. О том, как создавался ui kit, и о долгих боях с дизайнерами мы умолчим, а вот о реализации данной задачи я и хочу поговорить.
На фронте у нас демократия или даже анархия. Люди вольны использовать те решения, с которыми им удобно работать. На данный момент в бою есть проекты на AngularJS, Angular, React, Vanilla, и есть также проекты на Vue для внутреннего использования. Вот на этом моменте наш взор и обратился на web components.
#### Web Components
Давайте кратко осмотрим концепцию web components. В основе лежит концепция custom elements, которая позволяет расширять класс HTMLElement, создавая свои собственные html тэги, со скрытой от пользователя бизнес логикой. Звучит круто, выглядит приятно. Давайте посмотрим, что мы можем сделать. Здесь и далее исходный код приведен на typescript.
Чтобы создать custom element, нам нужно сделать следующее. Описать класс и зарегистрировать компонент.
```
export class NewCustomElement extends HTMLElement {
constructor() {
super();
console.log('Here I am');
}
}
if (!customElements.get('new-custom-element')) {
/* Зарегистрируем компонент, если его еще нет */
customElements.define('new-custom-element', NewCustomElement);
}
```
Далее, подключив в любой html данный код (собрав его в JS), мы можем использовать компонент (к этому мы еще вернемся, на самом деле нет, если ваши клиенты смеют использовать не Chrome).
Еще custom elements дают нам несколько хуков для отслеживания жизни компонента.
```
export class NewCustomElement extends HTMLElement {
constructor() {
super();
console.log('I am created');
}
/* Вызывается каждый раз, когда элемент вставляется в DOM, согласно лучшим практикам, такие операции, как первый рендер компонента, стоит делать именно на данном шаге */
connectedCallback() {
console.log('Now I am in Dom');
this._render();
this._addEventListeners();
}
/* Вызывается каждый раз, когда элемент удаляется из DOM, хорошее место, чтобы произвести уборку */
disconnectedCallback() {
console.log('I am removed now');
this._removeEventListeners();
}
/* Так объявляется список отслеживаемых атрибутов */
static get observedAttributes() {
return ['date'];
}
/* Вызывается, когда изменен один из отслеживаемых атрибутов */
attributeChangedCallback(attrName, oldVal, newVal) {
switch (attrName) {
case 'date': {
/* Обрабатываем изменение атрибута, например перерендериваем соответствующую часть компонента */
break;
}
}
}
/* Элемент перенесен в новый документ */
adoptedCallback() {
/* Не знаю, что с этим делать, поделитесь в комментариях своими предложениями */
}
}
```
Также мы можем генерировать события в компонентах через метод dispatchEvent
```
export class NewCustomElement extends HTMLElement {
//////
_date: Date = new Date();
set date(val: Date) {
this._date = val;
this.dispatchEvent(new CustomEvent('dateChanged', {
bubbles: true,
cancelable: false,
detail: this._date
}));
}
//////
}
```
#### Будущее наступило, говорили они, пишешь код один раз и используешь его везде, говорили они
Мы немного познакомились с компонентами, теперь расскажу об ощущениях, которые остались после работы с данной технологией. В целом, в статье [Веб-компоненты в реальном мире](https://habr.com/ru/post/443032/) автор описал отношение к технологии, которое оказалось мне очень близко.
Посмотрим, какие мы получили плюсы.
* **Reusable**: мы получили действительно переиспользуемую библиотеку. На данный момент она работает в vanilla проекте, подключаясь как собранный Webpack bundle, и проекте angular 7, подключаясь исходниками typescript в AppModule
* **Понятное поведение**: если следовать [лучшим практикам](https://developers.google.com/web/fundamentals/web-components/best-practices), то мы получаем компоненты с понятным поведением, которые легко интегрируются в существующие фреймворки, например для angular, с помощью бананов в коробке, в нативных приложениях через атрибуты, или работу с property, отражающими атрибуты
* **Единый стиль**: это некоторое повторение пункта о реюзабельности, но все же. Теперь на всех проектах используются единые строительные блоки для конструирования UI.
* **Честно, не могу больше придумать плюсов**: расскажите, чем WebComponents помогли Вам.
Далее попробую описать вещи, которые мне скорее не понравились.
* **Трудозатраты**: затраты на разработку компонент несравнимо выше, нежели разработка под фреймворк.
* **Именование**: компоненты регаются глобально, поэтому и имена классов, и имена тэгов приходится префиксить. Учитывая, что у нас еще есть библиотеки компонент, реализованные под фреймворки, которые именовались как <**company**-component-name>, то вэб-компоненты пришлось префиксить дважды <**company-wc**-component-name>.
* **ShadowRoot**: согласно лучшим практикам, рекомендуется использовать shadowRoot. Однако, это не очень удобно, так как не остается возможности повлиять на внешний вид компонента извне. А такая необходимость часто встречается.
* **Render**: без фреймворков приходится забыть о data binding и реактивности (LitElement в помощь, но это еще одна зависимость).
* **Будущее не наступило**: Чтобы сохранить поддержку пользователей на старом уровне (у нас это ie11 и все, что посвежее), приходится прикручивать полифилы, es5 — целевой стандарт, что создает дополнительные проблемы.
* **Сами полифилы**: Чтобы завести все это добро под IE, пришлось немало помучиться, и принять несколько некрасивых решений, так как полифилы от webcomponent ломают что-то внутри ангуляра, вызывая переполнение call stack. В итоге пришлось полифилить полифилы, получив лишние зависимости.
Я не знаю, какой сделать из всего этого вывод. Если Microsoft-таки сделает браузер на базе chromium и прекратит поддержку IE и Edge — то да, станет проще дышать.
Есть одна странная польза: можно давать разработку чистых web components начинающим разработчикам — пускай посмотрят как оно, писать на JS без фреймворков. Один коллега долго не мог понять, почему изменение property в компоненте не отражалось сразу в DOM. Вот они — люди, выращенные на фреймворках. И я такой же. | https://habr.com/ru/post/444662/ | null | ru | null |
# Великий египетский фаерволл
В мире бушует пандемия, народ скупает туалетную бумагу и гречку в промышленных масштабах, а ИТ компании в большинстве своем переводят сотрудников на удаленку. Так поступил и мой работодатель — немецкая полугосударственная контора.
В основном проблем не возникло, но одна из наших сотрудниц с месяц назад, когда все выглядело еще не так страшно, поехала в отпуск к родне в Египет и благополучно застряла там из-за закрытия границ. Ну, сама-то здорова, рабочий ноут с ней — сидит себе на карантине и работает через VPN. Неделю работает, две… На третью неделю VPN перестал подключаться. Саппорт первой линии проверил банальности навроде перезагрузки — не помогло. Вторая линия стала диагностировать: соединение уходит в вечный таймаут на стадии TLS Handshake. Отключили локальный фаерволл — не помогло. Попробовали другую машину — не работает. Другого провайдера — не работает. На этом моменте саппорты сдались и радостно спихнули проблему на меня по старому доброму принципу «во всем виноват сетевик».
Смотрим в логи сервера: он вообще не видит попыток до него достучаться после ответа на initial packet. Забавно и довольно знакомо. Звоню сотруднице, интересуюсь, как у них там дела с правами человека вообще и свободой интернета в частности. Говорит, что дела хреново, интернеты же у них блокируют так, что верблюдам икается, а Роскомнадзор нервно курит в сторонке. Ага… Беглый гуглеж показывает кучу жалоб на аналогичные проблемы с VPN в Египте, начиная с 2017 года. Для завершения картины спрашиваю, бывала ли сотрудница на родине в последние годы дольше 2 недель — нет, говорит, не бывала. Пазл начинает складываться.
Поднимаем копию корпоративного VPN сервера на свободном белом IP — нет коннекта. Ожидаемо.
Меняем порт — нет коннекта. Это уже печальнее.
Меняем протокол — нет коннекта. Пазл сложился — перед нами DPI наподобие великого китайского фаерволла.
Сотрудница грустит, начальство жалобно просит «ты же русский хакер, сделай что-нибудь». Ну ладно… Расчехляем тяжелую артиллерию даркнета и вкорячиваем obfsproxy.
Для сервера (CentOS 7) это выглядит так:
```
~ sudo pip install virtualenv
~ cd /etc/openvpn && virtualenv venv && source venv/bin/activate
~ sudo pip install obfsproxy
~ sudo -u openvpn /etc/openvpn/venv/bin/python /etc/openvpn/venv/bin/obfsproxy obfs3 --dest=127.0.0.1:1194 server 1.2.3.4:49416
```
Для клиента (MacOS) так:
```
~ brew install pip
~ pip install pyopenssl obfsproxy
~ obfsproxy obfs3 socks 127.0.0.1:8443
```
В конфиг OpenVPN на клиенте добавляем:
```
socks-proxy-retry
socks-proxy 127.0.0.1 8443
```
Профит. OpenVPN в обертке obfsproxy не детектится местными алгоритмами определения сигнатур, сессия взлетает, пинги ходят, трафик бегает, сотрудница счастлива. Осталось только добавить клиентскую часть obfsproxy в автозагрузку [вот этим](https://medium.com/@fahimhossain_16989/adding-startup-scripts-to-launch-daemon-on-mac-os-x-sierra-10-12-6-7e0318c74de1) «очевидным» способом (ненавижу маки). Я облегченно прощаюсь с нашей узницей пустыни и пишу письмо саппортам в духе «эта проблема решается вот так, но стабильность не гарантирую, и юзать этот workaround можно только если совсем нет другого выхода».
Судя по всему, в Египте имеет место быть особо хитрозадый DPI, который первое время не блокирует связь новым абонентам и/или трафик на новые хосты, относя таковые к условной категории «туристы». А после истечения некоего таймаута относит пользователя к категории «своих» и радостно режет трафик в угоду местным царькам. | https://habr.com/ru/post/495380/ | null | ru | null |
# Как вырастить лес на Actionscript3/Flash в несколько* строк кода
Вот в этом [комменте](https://habr.com/company/pixonic/blog/429078/#comment_19339426) я похвастался, что в своё время написал программу, создающую рендер «пристойно выглядящего» леса в двести строк кода. К сожалению, реальность оказалась немного большей по размеру — раскопанные исходники содержат примерно 2100 строк кода, из которых где-то 700 — комментарии, мысли вслух, старый отброшенный код и попытки документации методов. Размер исполняемого файла SWF, впрочем, оказался 13112 байт.
Началось всё с того, что на форуме Kongregate.com, где я в то время активно тусил, один из участников предложил посостязаться в процедурной генерации чего-либо, первой темой стал [«Лес»](http://www.kongregate.com/forums/1021798-game-programming-subforum/topics/244475-pggc-1-forest).
Естественно, у каждого была своя идея, каким должен быть лес, который они будут выращивать. На тот момент я зачитывался книгами про всякую магию, как следствие, захотел вырастить именно лес. Лес состоит из деревьев — пишем class Tree {...}. Дерево состоит из веток и листьев — пишем class Branch {...} и думаем, а так ли нам нужно учитывать каждый листик на дереве? В итоге «ветка» обзавелась параметром «с листьями», а дерево — парой текстур, одной для веток и ствола, одной для листиков. Текстуру «под дерево» сделать было относительно просто — есть perlin noise, его можно растянуть, завернуть, раскрасить, считай готово, а с листиками пришлось повозиться.
Однако меня не устроил просто перлиновый шум на текстуре под дерево, вместо него я придумал сделать bumpmapping — т.е. создал карту высот, подправил её под полукруг ветки, видимой сбоку, потом залил основную текстуру коричневым и наложил карту высот с прилаженным сбоку-сприпёку освещением. Итоговый код получился таким:
```
private function generateBranch():void {
branchBitmap = new BitmapData(512, 512, true, 0xff8080ff);
//branchBitmap.perlinNoise(32, 256, 2, 100 + Math.round(Math.random() * 900), true, true, 7, true);
var hm:BitmapData = new BitmapData(512, 512, false, 0);
var seed:int = 1000 + Math.random() * 2000;
hm.perlinNoise(24,192, 2, seed, true, true, BitmapDataChannel.BLUE, false); // blue only. Is a heightmap
var i:int;
var j:int;
for (i = 0; i < 512; i++) {
if (Math.abs(i - 256) > 100) r = 0; else
r = 200 * Math.sqrt(1 - (i - 256) * (i - 256) / 10000);// square curve
//r = 200 * Math.sin(Math.PI * (i - 128) / 256); // sine curve
for (j = 0; j < 512; j++) hm.setPixel(i, j, Math.round(r*(500.0 + (hm.getPixel(i, j)-128))*0.002));
// now, r means position on the "log", and initial perlin noise is log's texture.
// perlinNoise median 128, highest offset taking as 100, the result offset needs to be ~0.2 in multiplier
}
var v:Vector. = new Vector.();
var vv:Vector. = new Vector.(3);
for (i = 1; i < 511; i++) {
v.length = 0;
v.push(hm.getPixel(0, i-1), hm.getPixel(1, i-1), hm.getPixel(2, i-1), hm.getPixel(0, i), hm.getPixel(1, i), hm.getPixel(2, i),
hm.getPixel(0, i+i), hm.getPixel(1, i+1), hm.getPixel(2, i+1));
for (j = 1; j < 510; j++) {
var g:int = -1 \* v[0] - 2 \* v[1] - 1 \* v[2] + 1 \* v[8] + 2 \* v[7] + 1 \* v[6]; // gradient by Y
var r:int = -1 \* v[0] - 2 \* v[3] - 1 \* v[6] + 1 \* v[2] + 2 \* v[5] + 1 \* v[8]; // gradient by X
//if ((i > 50) && (i < 55) && (j > 50) && (j < 55)) trace(g, r);
var b:int = v[5];
r += 128;
g += 128;
var p:uint = r \*0x10000 + g\*0x100 + b;
branchBitmap.setPixel(j, i, p);
v.shift();
v.push(hm.getPixel(j + 2, i + 1));
v[2] = hm.getPixel(j + 2, i - 1);
v[5] = hm.getPixel(j + 2, i);
}
}
var bf:BlurFilter = new BlurFilter(2,8); // \_\_\_
// bevelFilter is not what I need, it bevels a rectangle and just that [\_\_\_]
// dropShadowFilter requires empty alpha I believe
// convolution filter works best on self, while it can do what I need
branchBitmap.applyFilter(branchBitmap, branchBitmap.rect, P0, bf);
hm.copyPixels(branchBitmap, branchBitmap.rect, P0);
//branchBitmap.perlinNoise(32, 256, 0, seed, true, true, 7, true); // naked grayscale
// 0 octaves means 50% gray filling
branchBitmap.fillRect(branchBitmap.rect, 0xff808080); // it looks like I'll have enough details just by perlin-noising the heightmap
var inc:Number = Math.PI / 3;
var azi:Number = -Math.PI \* 1 / 4;
var cx:Number = Math.cos(inc) \* Math.cos(azi);
var cy:Number = Math.cos(inc) \* Math.sin(azi);
var cz:Number = Math.sin(inc);
azi = 1 - 2 \* cz;
inc = 1 / cz; // cos(lighting) to be normalized into (0..1) via cz
for (i = 0; i < 512; i++) for (j = 0; j < 512; j++) {
p = branchBitmap.getPixel(j, i);
var h:uint = hm.getPixel(j, i);
// give a vector here somewhere
vv[0]= (h >> 16)-128;
vv[1] = ((h >> 8) & 255)-128;
vv[2] = 26; // balance constant, a normal is always pointing upwards,
Basis.Normalize(vv);
var m:Number = inc\*(cx \* vv[0] + cy \* vv[1] + cz \* vv[2]); // cos(lightangle)
r = (p >> 16) & 255;
g = (p >> 8) & 255;
b = p & 255;
r = Math.max(0,Math.min(255, r \* m));
g = Math.max(0,Math.min(255, g \* m));
b = Math.max(0,Math.min(255, b \* m));
branchBitmap.setPixel(j, i, 0x10000 \* r + 0x100 \* g + b);
}
branchBitmap.applyFilter(branchBitmap, branchBitmap.rect, P0,bf); // should be here, without blurring it's liney
hm = new BitmapData(192, 512, false);
hm.copyPixels(branchBitmap, new Rectangle(160, 0, 192, 512), P0);
branchBitmap = hm;
}
```
«Basis» — вспомогательный класс для векторов а-ля Vector3D, но так как писался код тогда под Flash 10.1, там ещё не было таких векторов, или я предпочел сделать свой велосипед. Текстура под ветку с листьями рисовалась так: вначале делался один лист, затем определялось, будет ли у веток центральный лист, этим определялась длина куска ветки, к которой крепились листья, затем по вычисленной ширине листа они крепились (рисовались на текстуре) под углом к ветке. Форма листа задавалась как искаженный круг с несколькими опорными точками, смещенными относительно круга радиусом пол-листа, и отдельно задавалась длина черенка, всё это рисовалось на текстуре листика в черно-белом виде и сохранялось на будущее. (Точнее, текстур «ветка с листьями» было две, одна для концов, т.е. веток, у которых из «конца» ничего не растет, но они с листьями, на ней был нарисован лист в конце ветки, вторая для «середин» без концевого листа.)
Дальше самое сложное — как будет выглядеть дерево? Здесь я долго думал и экспериментировал. Я решил сделать так, что дерево в самом деле растет — ветки вытягиваются в длину (на самом деле наращиваются с конца), иногда порождают ветки вбок, ветки тянутся к солнцу (вверх) и ещё пара условий. Получилась страшная мешанина, лучший вариант, которым удалось поделиться, выглядел вот так:
*(Как ни странно, diary.ru — отличный фотохостинг, до сих пор ничего не протухло!)*
Я пришел к выводу, что нужно как-то уменьшать плотность веток. Вначале идея была ограничить их гравитационно — т.е. слишком «тяжелые» ветки просто обламываются и падают. Начал считать момент силы на изгиб, сопоставляя с прочностью дерева (откуда-то потащил значения, забил как константы и стал тестировать) — получилось плохо, иной раз ломался ствол, даже несмотря на то, что по факту не должен был, и дерево благополучно загибалось, иной раз ломалась вначале одна большая ветка, результат приводил к разбалансировке ствола и он опять ломался, на сей раз уже из-за потери вертикального баланса, а иной раз вполне нормальная по структуре ветка, вырастая в толщине, вначале прогиалась под своим весом, потом ломалась, даже если ничего на ней больше не вырастало. Забил, потому что у челленджа был дедлайн.
Второй попыткой было ограничивать как рост новых веток, так и выживаемость старых/предыдущих с помощью освещения. С третьей попытки реализации (первые две остались в виде закомментированных функций) получилось так: я строил трехмерную воксельную решетку со стороной 0.5 метра (угу, все величины там были в метрах и килограммах — я тогда очень хотел настоящую физику для настоящего леса), которая заполнялась вначале нулями, потом при обходе дерева каждая ветка давала вклад в заполнение решетки в виде своего объема, деленного на один или два вокселя. Дело в том, что все ветки (во всяком случае, почти все) как отдельные куски вычисляемого каркаса были короче 0.5м, что позволяло использовать грубое приближение. Помимо заполнения, каждая ветка «отбрасывала тень» на нижележащие воксели в виде дополнительного заполнения вокселей под и слегка вокруг вокселя с веткой (итоговая форма — квадратная пирамида, но маяться с кругом было влом, и так уже не освещение получалось а невесть что). Эта решетка использовалась в качестве ограничителя, если какая-то из веток затеет вырасти в середину дерева — ей там будет меньше света, она будет короче и может не вырасти вовсе или помереть от недостатка освещения. Мертвые ветки потом отваливались.
Такой вариант позволил получить относительно прозрачные при просмотре и относительно компактные с точки зрения размаха деревья, первый рабочий вариант выглядел вот так:
В этой версии я ещё отлаживал сам механизм роста дерева, и дерево можно было рассмотреть со всех сторон. Рисовалось дерево по одной ветке за раз, массив веток вначале сортировался по удалению от наблюдателя, как в старом добром ВМКшном курсе по трехмерной графике от 1996 года, цвета для прорисовки я в рамках косметических фишек выбирал из диапазона HSB на каждый вызов «нарисуй мне дерево», чтобы лес был не монотонным, также скелет дерева случайным образом поворачивался для прорисовки. Всего моделей деревьев за прорисовку было от шести до восьми, каждая вырастала под своим собственным RNG-влиянием, ландшафт земли задавал ещё один перлиновый шум, а место, где растить дерево, выбиралось случайным образом с помощью набора диапазонов разрешенных точек для роста на сдвигающейся в сторону наблюдателя дистанции. В случае, если дерево сажалось в точке А, а радиус у выбранного для «выращивания» дерева R, то значения (A-R, A+R) становились запрещенными для роста на текущей дистанции, при переходе к следующей (-0.05) этот интервал уменьшался на 0.1, и убирался, когда сокращался до нуля.
Последний (а по факту первый и сразу учтенный) нюанс всего этого алгоритма — он ОЧЕНЬ ДОЛГИЙ. Чтобы обойти «взрослое» дерево, требуется несколько секунд, чтоы нарисовать, ещё несколько, чтобы нарисовать текстуры одного дерева, уходит от полусекунды до двух, а Adobe Flash не рассчитан на настолько долгие промежутки вычислений без обновления экрана (точнее, без возврата управления движку). Следовательно, нужен был алгоритм, который умеет сохранять состояние между вызовами, продолжать работу с места, где прервался и контролировать своё время выполнения, и одновременно не паниковать сам и не давать паниковать движку флэша. Сохранение состояния было реализовано в виде пары свойств класса Main, разбиение на этапы — через выделение функций «расти дерево один раз», «нарисуй готовое дерево» и «нарисуй кусок земли» и замер затраченного времени, соответственно, как только очередной «один раз» для дерева занимал больше нескольких секунд, дерево считалось «готовым» и откладывалось в сторону. Получилось три больших фазы: создание текстур, «выращивание» деревьев, размещение готовых деревьев на экране.
Результат выглядит так:
Поиграться можно [вот здесь](http://www.fastswf.com/mBgfPJI). Оптимизировано (точнее, написано) под Flash 10.1, с учетом кучи обновлений флэша в части безопасности может ужасно тормозить — в этом случае советую скачать debug-версию Adobe Flash Player 11.5 и открывать в ней оффлайн. Вся прорисовка занимает 5-6 минут, после первых двух на экране начинает происходить некоторая движуха, за которой может оказаться интересным понаблюдать. После завершения прорисовки можно нажать Ctrl+click, чтобы сохранить результат как PNG-файл учетверенного по сравнению с окном размера. | https://habr.com/ru/post/429256/ | null | ru | null |
# Примеры утверждений JUnit 5
> Это продолжение туториала по JUnit 5. Введение опубликовано [здесь](https://habr.com/ru/post/590607/).
>
>
Утверждения (Assertions) JUnit 5 помогают сравнить ожидаемый результат с фактическим результатом теста. Для простоты все утверждения JUnit Jupiter являются статическими методами в классе [org.junit.jupiter.Assertions](https://junit.org/junit5/docs/current/api/org.junit.jupiter.api/org/junit/jupiter/api/Assertions.html).
*Не успешные* утверждения будет генерировать исключение `AssertionFailedError` или его подкласс.
**Оглавление**
1. assertEquals() и assertNotEquals()
2. assertArrayEquals()
3. assertIterableEquals()
4. assertLinesMatch()
5. assertNotNull() и assertNull()
6. assertNotSame() и assertSame()
7. assertTimeout() и assertTimeoutPreemptively()
8. assertTrue() и assertFalse)
9. assertThrows()
10. Пример fail()
### 1. assertEquals() и assertNotEquals()
Метод `Assertions.assertEquals()` используется для подтверждения того, что ожидаемое и фактическое значения равны. Метод `assertEquals()` ммеет много перегруженных методов для разных типов данных, например, int, short, float, char и т. д. Он также выдает сообщения об ошибках, которые будут напечатаны в случае если тест будет неуспешным. например
**Перегруженные методы**
```
public static void assertEquals(int expected, int actual)
public static void assertEquals(int expected, int actual, String message)
public static void assertEquals(int expected, int actual, Supplier
```
**Примеры**
```
void test()
{
//Тест пройдёт
Assertions.assertEquals(4, Calculator.add(2, 2));
//Тест не пройдёт
Assertions.assertEquals(3, Calculator.add(2, 2), "Calculator.add(2, 2) test failed");
//Тест не пройдёт
Supplier messageSupplier = () -> "Calculator.add(2, 2) test failed";
Assertions.assertEquals(3, Calculator.add(2, 2), messageSupplier);
}
```
Точно так же метод `Assertions.assertNotEquals()` используется для утверждения, что ожидаемое и фактическое значения НЕ равны. В отличие от метода `assertEquals()`, `assertNotEquals()` не содержит перегруженных методов для разных типов данных, а только параметр типа `Object` принимается.
**Перегруженные методы**
```
public static void assertNotEquals(Object expected, Object actual)
public static void assertNotEquals(Object expected, Object actual, String message)
public static void assertNotEquals(Object expected, Object actual, Supplier messageSupplier)
```
**Примеры**
```
void test()
{
//Тест пройдёт
Assertions.assertNotEquals(3, Calculator.add(2, 2));
//Тест не пройдёт
Assertions.assertNotEquals(4, Calculator.add(2, 2), "Calculator.add(2, 2) test failed");
//Тест не пройдёт
Supplier messageSupplier = () -> "Calculator.add(2, 2) test failed";
Assertions.assertNotEquals(4, Calculator.add(2, 2), messageSupplier);
}
```
### 2. assertArrayEquals()
Метод assertArrayEquals() утверждает, что ожидаемый и фактический массивы равны.
Он также имеет перегруженные методы для различных типов данных, например, boolean[], char[], int[] и т. д. Он также выдает сообщения об ошибках, которые будут напечатаны в случае сбоя теста. например
**Перегруженные методы**
```
public static void assertArrayEquals(int[] expected, int[] actual)
public static void assertArrayEquals(int[] expected, int[] actual, String message)
public static void assertArrayEquals(int[] expected, int[] actual, Supplier messageSupplier)
```
**Примеры**
```
void testCase()
{
//Тест пройдёт
Assertions.assertArrayEquals(new int[]{1,2,3}, new int[]{1,2,3}, "Array Equal Test");
//Тест не пройден, потому что порядок элементов отличается
Assertions.assertArrayEquals(new int[]{1,2,3}, new int[]{1,3,2}, "Array Equal Test");
//Тест не пройден, потому что количество элементов другое
Assertions.assertArrayEquals(new int[]{1,2,3}, new int[]{1,2,3,4}, "Array Equal Test");
}
```
### 3. assertIterableEquals()
Метод assertIterableEquals() утверждает,, что ожидаемые и фактические итерации полностью равны. «Глубокое равенство» означает, что количество и порядок элементов в коллекции должны быть одинаковыми, а повторяющиеся элементы должны быть одинаковыми.
У него также есть три перегруженных метода.
**Перегруженные методы**
```
public static void assertIterableEquals(Iterable expected, Iterable> actual)
public static void assertIterableEquals(Iterable expected, Iterable> actual, String message)
public static void assertIterableEquals(Iterable expected, Iterable> actual, Supplier messageSupplier)
```
**Примеры**
```
@Test
void testCase()
{
Iterable listOne = new ArrayList<>(Arrays.asList(1,2,3,4));
Iterable listTwo = new ArrayList<>(Arrays.asList(1,2,3,4));
Iterable listThree = new ArrayList<>(Arrays.asList(1,2,3));
Iterable listFour = new ArrayList<>(Arrays.asList(1,2,4,3));
//Тест пройдёт
Assertions.assertIterableEquals(listOne, listTwo);
//Тест не пройдёт
Assertions.assertIterableEquals(listOne, listThree);
//Тест не пройдёт
Assertions.assertIterableEquals(listOne, listFour);
}
```
### 4. assertLinesMatch()
Он утверждает, что ожидаемый список строк соответствует фактическому списку. Логика сопоставления строки с другой строкой:
1. проверьте, если `expected.equals(actual)` - если да, переходите к следующей паре
2. в противном случае рассматривать `expected`как регулярное выражение и проверять переход`String.matches(String)` - если да, переходить к следующей паре
3. в противном случае проверьте, является ли `expected` строка маркером быстрой перемотки вперед, если да, примените соответствующие строки быстрой перемотки вперед и перейдите к 1.
Допустимый маркер быстрой перемотки вперед - это строка, которая начинается и заканчивается `>>` и содержит не менее четырех символов. Любой символ между литералами быстрой перемотки вперед отбрасывается.
```
>>>>
>> stacktrace >>
>> single line, non Integer.parse()-able comment >>
```
### 5. assertNotNull() и assertNull()
AssertNotNull() утверждает, что фактическое значение НЕ равно нулю. Точно так же метод `assertNull()` утверждает, что это действительно так `null`. У обоих есть три перегруженных метода.
**Перегруженные методы**
```
public static void assertNotNull(Object actual)
public static void assertNotNull(Object actual, String message)
public static void assertNotNull(Object actual, Supplier messageSupplier)
public static void assertEquals(Object actual)
public static void assertEquals(Object actual, String message)
public static void assertEquals(Object actual, Supplier messageSupplier)
```
**Примеры**
```
@Test
void testCase()
{
String nullString = null;
String notNullString = "howtodoinjava.com";
//Test will pass
Assertions.assertNotNull(notNullString);
//Test will fail
Assertions.assertNotNull(nullString);
//Test will pass
Assertions.assertNull(nullString);
// Test will fail
Assertions.assertNull(notNullString);
}
```
### 6. assertNotSame() и assertSame()
`assertNotSame()` утверждает, что ожидаемый и фактический не относятся к одному объекту. Точно так же метод assertSame() утверждает, что *ожидаемый* и *фактический* относятся к одному и тому же объекту.
У обоих есть три перегруженных метода.
**Перегруженные методы**
```
public static void assertNotSame(Object expected, Object actual)
public static void assertNotSame(Object expected, Object actual, String message)
public static void assertNotSame(Object expected, Object actual, Supplier<> messageSupplier)
public static void assertSame(Object expected, Object actual)
public static void assertSame(Object expected, Object actual, String message)
public static void assertSame(Object expected, Object actual, Supplier messageSupplier)
```
**Примеры**
```
@Test
void testCase()
{
String originalObject = "howtodoinjava.com";
String cloneObject = originalObject;
String otherObject = "example.com";
//Test will pass
Assertions.assertNotSame(originalObject, otherObject);
//Test will fail
Assertions.assertNotSame(originalObject, cloneObject);
//Test will pass
Assertions.assertSame(originalObject, cloneObject);
// Test will fail
Assertions.assertSame(originalObject, otherObject);
}
```
### 7. assertTimeout() и assertTimeoutPreemptively()
Методы `assertTimeout()` и `assertTimeoutPreemptively()` используются для тестирования долго выполняющихся задач. Если заданная задача в тесте занимает больше указанной продолжительности, тест завершится неудачно.
Единственная разница между обоими методами заключается в том, что в `assertTimeoutPreemptively()` выполнение `Executable` или `ThrowingSupplier` будет прервано с упреждением при превышении тайм-аута. В случае `assertTimeout()`, `Executable` или `ThrowingSupplier`не будет прервана.
**Перегруженные методы**
```
public static void assertTimeout(Duration timeout, Executable executable)
public static void assertTimeout(Duration timeout, Executable executable, String message)
public static void assertTimeout(Duration timeout, Executable executable, Supplier messageSupplier)
public static void assertTimeout(Duration timeout, ThrowingSupplier supplier, String message)
public static void assertTimeout(Duration timeout, ThrowingSupplier supplier, Supplier messageSupplier)
```
**Примеры**
```
@Test
void testCase() {
//This will pass
Assertions.assertTimeout(Duration.ofMinutes(1), () -> {
return "result";
});
//This will fail
Assertions.assertTimeout(Duration.ofMillis(100), () -> {
Thread.sleep(200);
return "result";
});
//This will fail
Assertions.assertTimeoutPreemptively(Duration.ofMillis(100), () -> {
Thread.sleep(200);
return "result";
});
}
```
### 8. assertTrue() и assertFalse()
Метод `assertTrue()`утверждает, что *предоставленное условие истинно* или предоставленное логическое условие `BooleanSupplier` истинно.
Точно так же `assertFalse()` утверждает, что предоставленное условие *ложно*.
У обоих есть следующие перегруженные методы:
**Перегруженные методы**
```
public static void assertTrue(boolean condition)
public static void assertTrue(boolean condition, String message)
public static void assertTrue(boolean condition, Supplier messageSupplier)
public static void assertTrue(BooleanSupplier booleanSupplier)
public static void assertTrue(BooleanSupplier booleanSupplier, String message)
public static void assertTrue(BooleanSupplier booleanSupplier, Supplier messageSupplier)
public static void assertFalse(boolean condition)
public static void assertFalse(boolean condition, String message)
public static void assertFalse(boolean condition, Supplier messageSupplier)
public static void assertFalse(BooleanSupplier booleanSupplier)
public static void assertFalse(BooleanSupplier booleanSupplier, String message)
public static void assertFalse(BooleanSupplier booleanSupplier, Supplier messageSupplier)
```
**Примеры**
```
@Test
void testCase() {
boolean trueBool = true;
boolean falseBool = false;
Assertions.assertTrue(trueBool);
Assertions.assertTrue(falseBool, "test execution message");
Assertions.assertTrue(falseBool, AppTest::message);
Assertions.assertTrue(AppTest::getResult, AppTest::message);
Assertions.assertFalse(falseBool);
Assertions.assertFalse(trueBool, "test execution message");
Assertions.assertFalse(trueBool, AppTest::message);
Assertions.assertFalse(AppTest::getResult, AppTest::message);
}
private static String message () {
return "Test execution result";
}
private static boolean getResult () {
return true;
}
```
### 9. assertThrows()
`assetThrows()`утверждает, что исполнение подаваемы `Executable` генерирует исключение из `expectedType`и возвращает исключение.
**Перегруженные методы**
```
public static T assertThrows(Class expectedType,
Executable executable)
```
**Примеры**
```
@Test
void testCase() {
Throwable exception = Assertions.assertThrows(IllegalArgumentException.class, () -> {
throw new IllegalArgumentException("error message");
});
}
```
### 10. Пример fail()
Метод *fail()* делает тест *неуспешны*м. Он имеет следующие перегруженные методы:
**Перегруженные методы**
```
public static void fail(String message)
public static void fail(Throwable cause)
public static void fail(String message, Throwable cause)
public static void fail(Supplier messageSupplier)
```
**Примеры**
```
public class AppTest {
@Test
void testCase() {
Assertions.fail("not found good reason to pass");
Assertions.fail(AppTest::message);
}
private static String message () {
return "not found good reason to pass";
}
}
```
Хорошего изучения!!! | https://habr.com/ru/post/591587/ | null | ru | null |
# ColumnsGrid для WPF
Размещение элементов в контроле Grid может быть утомительным. Удобнее, когда они автоматом размещаются по ячейкам, как в UniformGrid.
ColumnsGrid добавляет к этому следующие возможности:
1. Колонки задаются одной строкой Columns=«Auto,\*,200,Shared1»
2. Задается интервал между колонками Spacing=«4»
3. Переход на следующую строку задается элементом
```
using System;
using System.Windows;
using System.Windows.Controls;
public class ColumnsGrid : Grid {
public ColumnsGrid() : base() {
ColumnDefinitions.Add(new ColumnDefinition() { Width = GridLength.Auto });
RowDefinitions.Add(new RowDefinition() { Height = GridLength.Auto });
}
```
**Свойство Spacing**
```
public double Spacing {
get { return (double)GetValue(SpacingProperty); }
set { SetValue(SpacingProperty, value); }
}
public static readonly DependencyProperty SpacingProperty =
DependencyProperty.Register("Spacing", typeof(double), typeof(ColumnsGrid),
new FrameworkPropertyMetadata(0.0, SpacingChangedCallback));
static void SpacingChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e) {
((ColumnsGrid)d).SpacingChanged((double)e.NewValue);
}
```
```
void SpacingChanged(double value) {
bool even = true;
var l = new GridLength(Spacing);
foreach (var cd in ColumnDefinitions) {
if (!even) cd.Width = l;
even = !even;
}
}
```
**Свойство Columns**
```
public string Columns{
get { return (string)GetValue(ColumnsProperty); }
set { SetValue(ColumnsProperty, value); }
}
public static readonly DependencyProperty ColumnsProperty =
DependencyProperty.Register("Columns", typeof(string), typeof(ColumnsGrid),
new FrameworkPropertyMetadata("Auto", ColumnsChangedCallback));
static void ColumnsChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e) {
((ColumnsGrid)d).ColumnsChanged((double)e.NewValue);
}
```
```
void ColumnsChanged(string value) {
var ss = value.Split(',');
ColumnDefinitions.Clear();
var cnv = new GridLengthConverter();
foreach (var s in ss) {
var cd = new ColumnDefinition();
try {
cd.Width = (GridLength)cnv.ConvertFromInvariantString(s.Trim());
} catch {
cd.Width = GridLength.Auto;
cd.SharedSizeGroup = s;
}
if (ColumnDefinitions.Count>0) ColumnDefinitions.Add(
new ColumnDefinition() { Width = new GridLength(Spacing) });
ColumnDefinitions.Add(cd);
}
if (ColumnDefinitions.Count==0) ColumnDefinitions.Add(
new ColumnDefinition() { Width = GridLength.Auto });
InvokeArrange();
}
protected override void OnVisualChildrenChanged(DependencyObject visualAdded, DependencyObject visualRemoved) {
base.OnVisualChildrenChanged(visualAdded, visualRemoved);
InvokeArrange();
}
bool ArrangeInvoked;
void InvokeArrange() {
if (ArrangeInvoked) return;
ArrangeInvoked = true;
Application.Current.Dispatcher.BeginInvoke(new Action(Arrange));
}
void Arrange() {
ArrangeInvoked = false;
RowDefinitions.Clear();
RowDefinitions.Add(new RowDefinition() { Height = GridLength.Auto });
int row = 0, col = 0;
foreach (UIElement child in InternalChildren) {
if (child is Separator) {
child.Visibility = Visibility.Hidden;
col = 0;
row++;
RowDefinitions.Add(new RowDefinition() { Height = GridLength.Auto });
SetColumn(child, 0);
SetRow(child, row);
row++;
RowDefinitions.Add(new RowDefinition() { Height = GridLength.Auto });
} else {
SetColumn(child, col);
SetRow(child, row);
col += 2;
}
}
}
}
```
Публикации на эту тему на Хабре:
→ [Фишки XAML-разработчика: динамический Grid](https://habrahabr.ru/post/276077/) | https://habr.com/ru/post/336440/ | null | ru | null |
# Инвентаризация компьютеров в домене. Лень-двигатель прогресса
Всех приветствую.
Недавно начальство попросило меня подумать над вопросом о сборе информации о комплектации компьютеров у нас в домене. Сначала просьба была только на счет процессоров памяти и жестких дисков. Первая мысль — хождение по отделам и просьба освободить компьютер на минутку. В случае с 1 компьютером не сложно, но если их 1500. Мысли были направленны в сторону PowerShell.
Для начала надо было извлечь список всех компьютеров в домене. В данном примере мой домен Test.lan. Импортируем весь этот список в файл AllComputers.csv.
Для этого не забываем добавить модуль АД для PS. У меня на рабочем месте он прописан в профиле, и вам советую сделать тоже самое:
`import-module activedirectory
get-ADcomputer -Filter * |
Where-Object {$a=$_.name; $_.DistinguishedName -ne "CN=$a,OU=Disable,DC=Test,DC=lan"} |
Sort-Object name | Select-Object name | Export-csv C:\Invent\AllComputers.csv -NoTypeInformation`
Здесь надо пояснить, что у меня в домене есть папка Disable, где располагаются учетные записи всех отключенных компьютеров. Если они отключены, то какой смысл к ним стучаться. По этому эту папку мы исключаем из поиска.
Всем понятно, что далеко не все компьютеры, которые находятся в домене, включены, работают или вообще имеют место быть. По этому перед тем, как перейти к проверке, мы проверяем связь с ним. Конечно можно этого не делать, если у вас 100 компьютеров. А если у вас 2000 компьютеров, потеря времени при количестве выключенных компьютеров порядка 800 съест у вас не мало времени. Так же стоит сразу вспомнить компьютеры, к которым у нас нет доступа. Так же смысла стучаться в их дверь нет.
`import-csv c:\Invent\AllComputers.csv | foreach {
$a=$_.name
if ((Test-connection $a -count 2 -quiet) -eq "True")
{
if ((Get-WmiObject -computername $a Win32_OperatingSystem) -eq $null)
{`
Многие могут возразить:
«Для чего такие сложности? Зачем сначала делать список а потом импортировать его. Не легче ли сразу?»
Согласен, легче. Но иметь перед глазами список компьютеров, согласитесь, приятно. К тому же, список пронумерован. И Вы всегда знаете сколько у вас компьютеров в АД.
Для теста соединения выбрал cmdlet Test-connection с параметром -quiet, дабы нам не выдавались строчки с разной информацией, а просто выдавался ответ: True or False. При чем мы сокращаем количество запросов с 2 до 4.
Если мы постучимся к компьютеру с WMI запросом, а прав на такое действие у нас нет, получим кучу строчек красного цвета с ошибками. Так что сразу отфильтровываем такие компьютеры пробным WMI запросом
Любую информацию (наверное, почти любую) можно узнать, если залезть в WMI объекты, а PS позволяет это делать просто на ура. Так что я сразу углубился в поиски нужных WMI объектов.
[Здесь](http://msdn.microsoft.com/en-us/library/aa394084(v=VS.85).aspx) можно поглядеть все классы с их атрибутами.
Убедившись, что компьютер в сети, что доступ у нас к нему есть, смотрим его внутренности:
`Write-Host "Проверка компьютера " -ForeGroundColor Green $a
"Компьютер" | out-file c:\Invent\Comp\$a.txt
Get-WmiObject -computername $a Win32_OperatingSystem |
select-object csname, caption, Serialnumber, csdVersion |
ft @{Label="Сетевое имя"; Expression={$_.CSname}},
@{label="Наименование"; Expression={$_.caption}},
@{label="Версия"; Expression={$_.csdVersion}},
@{label="Серийный номер"; Expression={$_.SerialNumber}} -auto -wrap |
out-file c:\Invent\Comp\$a.txt -append
Get-WmiObject -computername $a Win32_ComputerSystemProduct | select-object UUID |
ft UUID -autosize | out-file c:\Invent\Comp\$a.txt -append
"Процессор" | out-file c:\Invent\Comp\$a.txt -append
Get-WmiObject -computername $a Win32_Processor | select-object name, SocketDesignation, Description |
ft @{label="Имя"; Expression={$_.name}},
@{label="Разъем"; Expression={$_.SocketDesignation}},
@{label="Описание"; Expression={$_.Description}} -auto -wrap | out-file c:\Invent\Comp\$a.txt -append
"Материнская плата" | out-file c:\Invent\Comp\$a.txt -append
Get-WmiObject -computername $a Win32_BaseBoard | select-object Manufacturer, Product, SerialNumber |
ft @{label="Производитель"; Expression={$_.manufacturer}},
@{label="Модель"; Expression={$_.Product}},
@{label="Серийный номер"; Expression={$_.SerialNumber}} -auto -wrap |
out-file c:\Invent\Comp\$a.txt -append
"Жесткие диски" | out-file c:\Invent\Comp\$a.txt -append
Get-WmiObject -computername $a Win32_DiskDrive | select-object Model, Partitions, Size, interfacetype |
ft @{Label="Модель"; Expression={$_.Model}},
@{Label="Количество разделов"; Expression={$_.Partitions}},
@{Label="Размер (гб)"; Expression={($_.Size/1GB).tostring("F00")}},
@{Label="Интерфейс"; Expression={$_.interfaceType}} -auto -wrap |
out-file c:\Invent\Comp\$a.txt -append
"Логические диски" | out-file c:\Invent\Comp\$a.txt -append
Get-WmiObject -computername $a Win32_LogicalDisk -Filter "DriveType=3" | select-object DeviceID, FileSystem, Size, FreeSpace |
ft @{Label="Наименование"; Expression={$_.DeviceID}},
@{Label="Файловая система"; Expression={$_.FileSystem}},
@{Label="Размер (гб)"; Expression={($_.Size/1GB).tostring("F00")}},
@{Label="Свободное место (гб)"; Expression={($_.FreeSpace/1GB).tostring("F00")}} -auto -wrap |
out-file c:\Invent\Comp\$a.txt -append
"Оперативная память" | out-file c:\Invent\Comp\$a.txt -append
Get-WmiObject -computername $a Win32_Physicalmemory | Select-Object capacity, DeviceLocator |
ft @{Label="Размер (мб)"; Expression={($_.capacity/1MB).tostring("F00")}},
@{Label="Расположение"; Expression={$_.DeviceLocator}} -auto -wrap |
out-file c:\Invent\Comp\$a.txt -append
"Видеокарта" | out-file c:\Invent\Comp\$a.txt -append
Get-WmiObject -computername $a Win32_videoController |
Select-Object name, AdapterRAM, VideoProcessor |
ft @{Label="Наименование"; Expression={$_.name}},
@{Label="Объем памяти (мб)"; Expression={($_.AdapterRAM/1MB).tostring("F00")}},
@{Label="Видеопроцессор"; Expression={$_.VideoProcessor}} -auto -wrap |
out-file c:\Invent\Comp\$a.txt -append
"Сетевая карта" | out-file c:\Invent\Comp\$a.txt -append
$OS=Get-WmiObject -computername $a Win32_OperatingSystem | foreach {$_.caption}
if ($OS -eq "Microsoft Windows 2000 Professional")
{
Get-WmiObject -computername $a Win32_NetworkAdapterConfiguration -Filter "DHCPEnabled=True" |
Select-Object caption,MACaddress |
ft @{Label="Наименование"; Expression={$_.caption}},
@{Label="MAC адрес"; Expression={$_.MACAddress}} -auto -wrap |
out-file c:\Invent\Comp\$a.txt -append
}
else
{
Get-WmiObject -computername $a Win32_NetworkAdapter -Filter "NetConnectionStatus>0" |
Select-Object name, AdapterType, MACAddress |
ft @{Label="Наименование"; Expression={$_.name}},
@{Label="MAC адрес"; Expression={$_.MACAddress}},
@{Label="Тип"; Expression={$_.AdapterType}} -auto -wrap |
out-file c:\Invent\Comp\$a.txt -append
}
}`
Вся информация о компьютере падает в текстовый файл.
Здесь стоит остановить внимание на 2 моментах.
Во-первых, строчку `Write-Host "Проверка компьютера " -ForeGroundColor Green $a` я делал исключительно для себя, ибо приятно знать чем занимается в данный момент PowerShell.
Во-вторых, для чего мы перед проверкой сетевой карты проверяем ОС.
К сожалению, Windows 2000 не отвечает на запрос Win32\_NetworkAdapter, по этому к ней мы применяем запрос Win32\_NetworkAdapterConfiguration. Почему не оставить только последний? Можно оставить, но Win32\_NetworkAdapter выдает такой атрибут, как Name, когда в его аналоге только Caption. Мелочь, а приятно.
Так же можете видеть, что при проверки сетевой карты, мы проверяем ее на работоспособность, иначе мы получим список еще из нескольких карт, которые в данный момент Вас не интересуют. Вам это надо?
Вот в принципе и все.
Скрипт можно доработать до своих потребностей.
Так что теперь начальство вряд ли напугает вас инвентаризацией компьютеров. | https://habr.com/ru/post/124386/ | null | ru | null |
# Критерий выгодности подстановки и динамическая профилировка
Продолжаю тему межпроцедурных оптимизаций, введение в которую можно найти [в предыдущем посте](http://habrahabr.ru/company/intel/blog/199112/). Сегодня хочется немного порассуждать о подстановке функции (inlining) и о том, как подстановка влияет на производительность приложения.
Периодически приходится анализировать случаи, когда одно и тоже приложение, скомпилированное разными компиляторами, показывает различную производительность. Часто причиной является различие в подстановке, которая выполняется автоматически. Вдруг оказывается, что в одном случае подставляется один набор вызовов, а в другом несколько иной. В результате анализ конкурирующих компиляторов сильно осложняется, поскольку становится невозможным напрямую сравнивать какие-то горячие функции. Время их выполнения сильно зависит от того, какие вызовы были проинлайнены.
Подстановка — самая популярная межпроцедурная оптимизация, которая вместо вызова какой-либо функции вставляет ее тело в тело вызывающей функции. Какие задачи приходится решать компилятору при принятии решения о подстановке и как программист может улучшить производительность приложения с помощью этой оптимизации? Как решения об инлайнинге принимает компилятор Intel, я примерно знаю, но интересно проверить предлагаемые методы и на компиляторе gcc.
#### Почему подстановки улучшают производительность?
* Исчезают накладные расходы на вызов функции, т.е. не нужно выделять место на стеке для хранения аргументов вызова или записывать аргументы в регистры.
* Улучшается локальность кода. Вместо перехода на инструкции вызываемой процедуры, которые могут оказаться не в кэше, управление «плавно перетекает» на вставленные в результате подстановки строки кода.
* Большинство компиляторных оптимизаций связаны с обработкой графа потока управления (CFG). Поэтому такие оптимизации работают на уровне процедуры. Подстановка позволяет использовать для оптимизации тела подставленной процедуры весь контекст вызывающей процедуры. Благодаря этому после подстановки может быть получен выигрыш, например, от протяжки констант, от цикловых оптимизаций и т.п.
Может ли подстановка оказать негативное влияние на производительность? Легко. Благодаря подстановке может увеличиваться размер кода процедуры, количество локальных переменных, размещаемых на стеке. Оба эти фактора могут повлиять на принцип локальности кода. Т.е. из-за увеличения объема исполняемого кода нужные инструкции и данные реже оказываются в кэше и выполнение замедляется. К тому же разрастание кода негативно влияет на время компиляции и размеры получаемых исполняемых файлов (что может быть особенно критично для мобильных архитектур). Хорошим исключением для подстановки являются «маленькие» функции, т.е. такие, тело которых содержит меньше инструкций, чем затраты на вызовы таких функций. Таким образом, как и большинство оптимизаций подстановка – палка о двух концах. И компилятору, и программисту нужны критерии, определяющие, какие функции нужно стремиться подставлять в первую очередь, какие во вторую, а какие совсем не подставлять.
#### Автоподстановщики
Итак, можно улучшать производительности за счет подстановки. Естественно, такая благодатная область для улучшения производительности приложения не может не оказаться под пристальным вниманием оптимизирующих компиляторов. Компиляторы умеют делать подстановки автоматически. Пользователь добавляет одну опцию, а оптимизирующий компилятор сам выбирает какие вызовы оставить нетронутыми, а какие подставить.
Если посмотреть опции компилятора Intel (icc –help), то легко обнаружить кнопку включения этого механизма.
```
-inline-level=
control inline expansion:
n=0 disable inlining
n=1 inline functions declared with \_\_inline, and perform C++
inlining
n=2 inline any function, at the compiler's discretion
```
Из этого описания опций видно, что существует несколько режимов работы. Вообще запретить подстановку, использовать директивы для компилятора, выставленные программистом, дать возможность компилятору самому выбирать объекты для оптимизации. Т.е. опция *–inline-level=2* — это то, что нам нужно, и именно эта опция используется по умолчанию. Также в этом списке огромное кол-во опций вида:
```
inline-max-total-size=
maximum increase in size for inline function expansion
-no-inline-max-total-size
no size limit for inline function expansion
-inline-max-per-routine=
maximum number of inline instances in any function
-no-inline-max-per-routine
no maximum number of inline instances in any function
-inline-max-per-compile=
maximum number of inline instances in the current compilation
-no-inline-max-per-compile
no maximum number of inline instances in the current compilation
-inline-factor=
set inlining upper limits by n percentage
```
Отсюда понятно, что постановка задачи для автоматического подстановщика — осуществить подстановки функций так, чтобы добиться наилучшей производительности и уложиться в определенные рамки увеличения кода программы. Видно, что в списке есть опции, контролирующие разрастание кода программы в целом, так и разрастание каждой процедуры.
#### Критерий полезности подстановки
Давайте попытаемся оценить качество работы компилятора при выполнении автоматической подстановки. Для этого необходимо выработать какой-то очевидный критерий полезности подстановки и понять, можно ли обеспечить его использование.
На мой взгляд, можно сформулировать следующий приблизительный критерий выгодности подстановки. Каждая подстановка несет в себе некоторые издержки, которые ухудшают качество всей программы в целом, но при этом улучшается качество конкретного фрагмента кода, где выполнена подстановка.
Самый простой случай, когда подстановка невыгодна, на мой взгляд, выглядит так:
```
If (almost_always_false) {
Foo();
}
```
В этом случае мы получили все негативные последствия от подстановки функции Foo, «пригрели» на стеке вызывающей функции ее локальные переменные, увеличили размер кода вызывающей функции. Но функция практически никогда не вызывается и наш локально улучшенный фрагмент кода не используется, то есть издержки не окупаются. Таким образом, при принятии решения о подстановке хорошо бы знать, насколько горячим является тот или иной вызов. Предлагаемый критерий следующий: чем чаще при выполнении вызывается функция, тем выгоднее ее инлайнить. Вторым очевидным фактором является размер функции. Чем меньше размер функции, тем выгоднее ее подставлять, поскольку в этом случае нам удастся вместить больше подстановок в границы, определяемые порогом расширения программы.
Очевидно, что можно придумать еще много различных критериев полезности подстановки, например, считать, что выгоднее инлайнить вызовы внутри циклов, если инлайнинг поможет векторизации или выгоднее инлайнить вызов с константными аргументами и т.д. Не совсем понятно только, как может компилятор получить эти знания до принятия решения об инлайнинге без усложнения анализа и увеличения времени компиляции. Некоторые случаи, когда подстановка выгодна, являются не очевидными до того момента, пока эта выгода будет получена. Например, при межпроцедурном анализе нам вряд ли удастся понять, что благодаря подстановке мы гарантировано получим выгоду от векторизации. Поскольку для этого нужно сделать почти всю ту работу, которая делается при оптимизации процедуры, перед принятием решения об инлайнинге.
При наличии ограничений на разрастание кода очень важным становится порядок, в котором принимается решение об инлайнинге. Компилятор обходит в каком-то порядке все вызовы и принимает решение о подстановке. При этом он изменяет размер вызывающей функции и проверяет, не превышен ли лимит разрастания кода. Если сначала были сделаны какие-то подстановки внутри вызываемой функции, то размер ее кода уже не равен оригинальному в момент принятия решения об подстановке. Можно манипулировать эвристиками, принимающими решение о выгодности, но если в момент принятия решения лимиты разрастания кода уже превышены, то компилятор такую функцию инлайнить не будет. Для достаточно больших проектов ситуация достижения лимитов разрастания кода очень обыденна.
Подсчитать размер кода подставляемой функции легко, хотя после подстановки или каких-то оптимизаций он может сильно измениться, но компилятор во время компиляции не обладает знанием, какие части кода вызывающей функции являются «горячими», а какие нет. В компиляторе есть профилировщик, который «глубокомысленно взирая» на код процедуры пытается оценить вероятность того или иного перехода, и, благодаря его работе, каждому непрерывному фрагменту обрабатываемой процедуры присваивается какой-то вес. К сожалению, оценки профилировщика очень приблизительны и вызывают аналогию с известным анекдотом про блондинку, которую спросили о вероятности встретиться с динозавром. «50 на 50, или встречу или нет» — ответила блондинка. И была абсолютно права с точки зрения логики и оптимизирующего компилятора! Авторы анекдота предполагают, что блондинка должна что-то знать о динозаврах. Но если знаний нет, то и ответ вполне логичен. Практически все переходы if получают вероятность 50%. Ну еще можно погадать на кофейной гуще на тему, сколько итераций имеет среднестатистический цикл for c неконстантными нижней и верхней границами.
В общем, задача определения веса кода сложна уже на уровне одной функции. А что же можно сказать о весе того или иного вызова в рамках всей программы? Может оказаться, что функция имеет внутри себя очень «горячий» вызов. Да только может случиться так, что сама функция страшно «холодная» и практически никогда не получает управления. Получается, что по-хорошему нужно иметь метод оценки важности каждого вызова внутри программы, который бы анализировал и граф вызовов, и граф потока управления для каждой функции, и выставлял бы на основе такого анализа вес для каждой дуги в графе вызовов. Но такие оценки могут оказаться совсем неточными. Реальный же вес каждого вызова очень сильно зависит, например, от набора входных данных.
Собственно, эту идею иллюстрирует рисунок к моему посту. Здесь на основе анализа CFG я попытался выделить цветами холодные и горячие вызовы (грани графа вызовов). Красный цвет обозначает «горячие» участки внутри процедуры, ну а красные стрелки горячие вызовы. К сожалению, как уже подчеркивалось, вся эта раскраска может быть различна для разных входных наборов данных. Расставить правдоподобно веса при компиляции очень трудно.
#### Тестирование критерия
Тем не менее, предложенный критерий достаточно прост и в соответствии с ним можно сказать, что при прочих равных выгоднее подставлять вызовы, встречающиеся в циклах. Менее выгодно подставлять вызовы встречающиеся после проверки различных условий. Кажется что это очевидно? Давайте проверим, используют ли компиляторы такое соображение? Напишем что-то предельно очевидное. В данном примере подставляется одна и та же функция, поэтому с точки зрения размера вызываемой функции все вызовы одинаковы. Частота использования вызовов зависит от того, какие константы введет пользователь.
```
Cat main.c
#include
static void inline foo(int i) {
printf("foo %d\n",i);
}
int main() {
int n,k,m;
printf("Enter 3 integer numbers\n");
scanf("%d",&n);
scanf("%d",&k);
scanf("%d",&m);
foo(1);
for(int i=0; i
```
Интересно посмотреть, в каком порядке компилятор Intel будет эти вызовы инлайнить. Это легко исследовать, добавив в строку компиляции опцию *–inline-max-total-size=XX* и постепенно меняя значение этой переменной от 0 в сторону увеличения.
```
icc -std=c99 -inline-max-total-size=XX -ip main.c init.c
```
Выясняется, что порядок подстановок в main будет следующий: foo(7), foo(9), foo(8), foo(6), foo(3), foo(5), foo(2), foo(4), foo(1).
Видно, что в данном случае соображения о «весе» каждого вызова не используются. Компилятор не пытается угадать, какие вызовы происходят чаще.
Примерно аналогичную процедуру я проделал и с gcc.
Строка компиляции была следующая:
```
gcc –O2 --param large-function-insns=40 --param large-function-growth=XX -std=c99 main.c init.c -o aout_gcc
```
Опция *–O2* включает в себя *-finline-small-functions*, и в этом случае gcc подставляет «маленькие» функции, подстановка которых, по идее, не сильно влияет на размер вызывающей функции.
Опция *–O3* включает в себя *-finline-functions*, когда все функции рассматриваются как кандидаты для подстановки.
Я установил параметр *large-function-insns* так, чтобы моя функция main стала «большой» и ее расширение контролировалось параметром *large-function-growth*. Увеличивая числовое значение, начиная с нуля, получаем, в каком порядке делает подстановки gcc для \_O2: foo(9), foo(8), foo(7), foo(6), foo(5), foo(4), foo(3), foo(2), foo(1). Т.е. gcc делает подстановки строго по порядку. С –O3 порядок такой: foo(3), foo(9), foo(2), foo(8), foo(7), foo(6), foo(5), foo(4), foo(1). Мне этот порядок нравится больше. По крайней мере, gcc проявил уважение по отношению к вызовам внутри циклов.
#### Результаты тестирования. Можно ли помочь компилятору?
Этот эксперимент показал, что порядок, в котором компиляторы осуществляют подстановку, может быть не оптимальным. Компилятор может подставить «невыгодные» вызовы, после этого достичь порога расширения обрабатываемой функции и прекратить свою с ней работу. В итоге пострадает производительность. Если, анализируя свое приложение, вы видите в горячем месте какие-то незаинлайненные функции небольшого размера, то возможны две причины такой ситуации: компилятор не счел конкретный вызов выгодным для подстановки или решение о подстановке не было принято из-за превышения порога расширения кода. Повлиять на это можно, изменяя пороговые значения или навешивая на функцию атрибуты типа *inline*. Поскольку изменения пороговых величин невозможно сделать для конкретной функции, то такое изменение вызовет увеличение размера всего приложения. То же самое можно сказать о атрибуте *inline*. Аттрибут будет воздействовать как на «горячие», так и на «холодные» вызовы. При этом inline не гарантирует подстановку, если уже превышены пороги расширения кода. Более мощным аттрибутом является always\_inline. В этом случае функция всегда будет заинлайнена.
Более адресно на подстановки можно влиять с помощью прагм. Прагмы воздействуют на конкретный вызов, и с их помощью можно добиться более точного целеуказания, что именно нужно инлайнить. Существуют *#pragma inline, #pragma noinline, #pragma forceinline*. *#pragma inline* воздействует на решение компилятора и помогает, если еще не превышен порог расрастания кода, но компилятор не считает подстановку выгодной. *#pragma forceinline* – обязует компилятор сделать подстановку.
Возращаясь к нашему примеру. Подстановка аттрибута *inline* никак не поможет в рассматриваемом примере. Можно попросить компилятор сделать подстановку более настойчиво и подставить в код определение функции foo с аттрибутом *always\_inline*:
*static void inline foo(int) \_\_attribute\_\_((always\_inline));*
Это приведет к тому, что все вызовы будут подставлены (несмотря на нарушения порогов расширения). У этого метода очевидный недостаток – будут подставлены и «холодные» и «горячие» вызовы. Более оптимальным является использование прагм. Переписываю код функции main в таком виде:
```
int main() {
int n,k,m;
printf("Enter 3 integer numbers\n");
scanf("%d",&n);
scanf("%d",&k);
scanf("%d",&m);
foo(1);
for(int i=0; i
```
Т.е. получился рабочий алгоритм улучшения производительности приложения:
* Построить приложение.
* Собрать информацию о горячих участках приложения с помощью, например, Vtune Amplifier.
* Проверить, есть ли на этих участках неподставленные вызовы и заинлайнить их с помощью прагм.
* Проверить, как это сказалось на производительности приложения.
#### Критерий выгодности подстановки и динамический профилировщик
Понятно, что такой метод является ресурсно-затратным, особенно из-за использования Amplifier'а и необходимости исследовать что-то глазами. К счастью, есть достаточно надежное средство оптимизации подстановок – динамический профилировщик. Динамический профилировщик используется для того, чтобы получить представление о горячих участках программы и для того, чтобы оценить частоту вызовов тех или иных функций.
Провожу следующий эксперимент с первоначальным текстом моей минипрограмки:
```
icc -std=c99 init.c main.c -prof_gen -o prof_a
./prof_a < 345.txt >& prof_out
```
Здесь с помощью опции *–prof\_gen* было создано инструментированное приложение. Затем это приложение было запущено, в результате его работы появился файл с расширением dyn, содержащий собранную статистику о работе приложения. Запуск компилятора с опцией *–prof\_use* позволяет использовать эту статистику для оптимизации приложения. Файл 345.txt содержит ввод констант 3,4,5. Манипулируя опцией *–inline-max-total-size* получаю порядок, в котором компилятор подставляет функции.
```
icc -std=c99 -prof-use -inline-max-total-size=XX -ip main.c init.c
```
Порядок получается такой: foo(3), foo(2), foo(7), foo(9), foo(8), foo(7), foo(6), foo(5), foo(4), foo(1). Если посмотреть на вывод приложения, то понятно, что большинство вызовов были сделаны 1 раз и только foo(3) и foo(2) вызывались чаще. Благодаря динамическому профилировщику компилятору удалось более качественно определить порядок функций для подстановки.
Теперь поменяем входные данные для констант (n=5, k=4, m=3). В этом случае foo(6) и foo(7) не вызываются. Удалим (!) предыдущий файл со статистиками и, повторив эксперимент, получим новый порядок: foo(3), foo(2), foo(9), foo(8), foo(5), foo(4), foo(1). Вызовы foo(6) и foo(7) не были подставлены даже при большом пороге расширения кода. (Что безусловно радует).
Если не удалять файл со статистиками, то получим файл, отражающий статистику двух запусков.
Ну и аналогично сделаем такое же исследование для gcc 4.9.
```
gcc -O2 -fprofile-generate -std=c99 main.c -o aout_gcc_prof
./aout_gcc_prof < 543.txt
```
Появились файл со статистиками c расширением gdca.
```
gcc -O2 -fprofile-use --param max-unrolled-insns=0 --param large-function-insns=40 --param large-function-growth=XX -std=c99 main.c -o aout_gcc
```
Манипулируя c XX можно увидеть, что после получения информации от динамического профилировщика, компиляторы gcc и icc ведут себя одинаково, т.е. делают подстановку в соответствии с реальным весом каждого вызова.
Рассматривание кода при различных опциях и тем более в случаях различных компиляторов бывает достаточно интересно. Вот, например, в момент, когда компилятор gcc уже подставил foo(3), но порог расширения кода не позволил подставить foo(2), gcc сделал клонирование функции foo для вызова с 2. То есть создал новую функцию без аргументов с затянутой внутрь константой 2. При этом оба компилятора попытались улучшить локальность кода и вынесли «холодный код» в отдельную локацию. Icc в конец процедуры main, а gcc создал для этого отдельную секцию main.cold. При запуске инструментированного компилятора с входными данными 543.txt в эти секции попали вызовы foo(6) и foo(7).
#### Выводы
Конечно, описанный здесь эксперимент не является полным, и его можно было бы расширить, проанализировав, учитывает ли компилятор, формируя очередь вызовов для подстановки, другие факторы, например, размер функции для подстановки. Можно было бы попытаться понять в каком порядке обходится граф вызовов и т.д. Но в целом получился следующий вывод. Без динамического профилировщика компиляторы не пытаются угадать возможный «вес» или возможную частоту выполнения того или иного вызова. Соответственно, порядок подстановок выглядит достаточно случайным. В случае использования динамической профилировки, когда вес каждого вызова определяется экспериментально, оба компилятора используют эту информацию, и в результате порядок подстановок вполне соответствует предложенному здесь критерию. Т.е. наилучшую пользу от подстановок можно получить с использованием динамического профилировщика.
Ну а разработчики могут эффективно использовать при своей работе прагмы, чтобы подсказать компилятору какие вызовы следует инлайнить в первую очередь. Если программисту ясно, что какие-то вычисления будут выполняться редко, то имеет смысл выносить их в отдельные функции и запрещать их подставлять директивно. Это улучшит локальность выполняемого кода и, скорее всего, приведет к небольшому выигрышу в производительности за счет более оптимального использования подсистемы кешей.
*Прекрасная блондинка и динозавр заимствованы из общедоступных ресурсов интернета, не содержащих указаний на авторов этих материалов и каких-либо ограничений для их заимствования:
1. [www.pinterest.com](http://www.pinterest.com/)
2. [solnushki.ru](http://solnushki.ru/)* | https://habr.com/ru/post/240203/ | null | ru | null |
# Автоматическая генерация программного кода микроконтроллера на основе событийно-ориентированной модели
**Постановка задачи**:
Создание сложной автоматизированной системы на основе контроллера для управления различной периферией (электронные замки, двигатели, светодиодные ленты и прочая электроника).
Создание данной системы потребовалась для **квест** комнаты, подобной [**этой**](http://geektimes.ru/post/264776/), но в городе **Хабаровск**.
Наш квест в ином [сеттинге](https://ru.wikipedia.org/wiki/Сеттинг), но в целом имеет примерно тот же набор исполнительных механизмов: реле, замки, ленты, герконы и т.д.
**Основные требования к системе:**
* **Надежность** — при разработке сложных систем высока вероятность допустить трудно уловимые ошибки, чем больше код тем больше шанс пропустить ошибку и тем больше времени нужно на отладку, необходимо свести к минимуму вероятность некорректной работы.
* **Гибкость** — возможность с минимальными временными затратами изменить логику работы
* **Функциональность** — управление любым оборудованием и подключение любых сенсоров
В нашем квесте требовался достаточно сложный сценарий, в особенности:
* **Нелинейность сюжетной линии**-игроки могут найти несколько различных путей решения головоломок,
* **Связанность** — некоторые события должны происходить только после свершения ряда других игровых событий
Решение всех проблем было найдено во многом благодаря статье о [«Парадигме ситуационно-ориентированного программирования»](http://habrahabr.ru/post/266829), применив данный подход я получаю «из коробки»:
* **Гибкость** — достаточно правильно построить архитектуру событий
* **Надежность** — т.к. все события однотипны они могут быть реализованы схожим образом, используя простой код, надежность которого можно гарантировать
* **Функциональность** — события вызывают действия, которые могут быть реализованы любым образом
Таким образом архитектуру системы можно построить на основе 3 видов базовых конструкций:
* **Событие**,
* **Триггер**,
* **Действие**
При такой архитектуре можно заметить так же, что если задать в **шаблоне** кода **триггера** факт сохранения состояния (активирован\не активирован) то получаем в качестве бонуса возможность использовать **состояние триггера** в качестве **события**, таким образом можно построить сколь угодно сложную систему взаимосвязей событий и нелинейность алгоритма.
Благодаря выделения **действий** в отдельный функциональный блок получаем возможность еще на этапе разработки провести тестирование программного кода каждого действия по отдельности, отладку такого кода произвести намного легче, чем при отладке всего проекта. На отлаженный код уже будут ссылаться триггеры.
**Триггеры** в качестве условия срабатывания могут использовать любое сочетание событий или состояний триггеров (и\или\не).
События могут быть любыми (состояния портов, сообщения в serial и тд), в текущей реализации достаточно было состояния портов, поэтому пока оставлен только этот вариант, расширения функционала не займет много времени.
При создании системы было решено использовать доступное на местном рынке оборудование, таковыми оказались только платы Arduino, учитывая проблемы с доставкой почтой из других регионов факт наличия на рынке запасных частей имеет значение.
Приложение настроено на генерации кода скетча для данной платформы, но при желании адаптация под любой другой язык программирования займет лишь пару минут.
Таким образом шаблоны для скетча Arduino будут выглядеть в простейшем виде например так:
**Основной код программы**
```
@init
void setup() {
@runonce
}
void loop() {
@loopcode
}
@triggers
@sensors
@actions
```
**Шаблон кода действия**
```
//@description
void @name()
{
bool debug=true;
//@id
@code
//@id
if (debug) {
Serial.println("DoAction @name");
}
}
```
**Шаблон кода триггера**
```
//@description
bool @nameActivated=false;
bool @name(){
if (@nameActivated){
return true;
}else
{
if (@event){
@nameActivated=true;
Serial.println("@name Activated");
@nameDoAction();
return true;
}
return false;
}
return false;
}
void @nameDoAction(){
@nameActivated=true;
//******************************************
@actions
//******************************************
}
```
**Шаблон кода сенсора**
```
//@description
bool @name()
{
int @namePin=@pinNumber;
pinMode(@namePin, INPUT_PULLUP);
int sensorVal = digitalRead(@namePin);
if (sensorVal == @trueval) {return true;}else{return false;}
}
```
**Пример шаблона инициализации**В данном шаблоне можно подключить библиотеки и объявить глобальные для всего проекта переменные и функции.
```
#include
#include
#include
static uint8\_t mac[6] = {0x54, 0x55, 0x58, 0x10, 0x10, 0x24};
static uint8\_t ip[4] = {192, 168, 137, 15};
static uint16\_t port = 80;
ETHER\_28J60 ethernet;
bool started=false;
```
На основе данных шаблонов в окне приложения можно задать все параметры сценария.
После экспорта прошивки мы можем получить подобный код:
**Очень много букв скетча**
[Пример кода скетча](http://neurowareblog.blogspot.ru/2015/10/blog-post_31.html)
Плюс такого подхода в том, что все блоки действий на момент экспорта прошивки уже отлажены еще на этапе их разработки, все блоки триггеров, сенсоров и обертки кода действий отлажены и код компилируется без ошибок и будет работать корректно **сразу**, **без этапа отладки**.
На практике при разработке квест комнаты много раз приходилось изменять сценарий, благодаря приложению **изменять код прошивки не требовалось**, **достаточно изменить параметры триггеров в интерфейсе программы**.
Фотографий с самого квеста пока не прикладываю, если будет желание могу приложить. На данный момент оборудование с прошивкой созданной по данной схеме отработало уже более 50 игровых циклов без единого сбоя.
Исходные коды приложения [открыты и доступны всем желающим](https://github.com/vpuhoff/PROGen-Arduino-Sketch-Generator/).
Тестовое приложение с типовыми настройками шаблонов можно найти на [github](https://github.com/vpuhoff/PROGen-Arduino-Sketch-Generator/blob/master/Example.zip?raw=true).
Надеюсь, данная статья поможет тем, кто решит создать систему для автоматизации различных процессов, будь то умный дом, охранная система или что либо другое. | https://habr.com/ru/post/269897/ | null | ru | null |
# AndroidAnnotations — упрощаем и укорачиваем код без вреда для здоровья проекта (I часть)
Уже несколько лет существует и совершенствуется открытая библиотека для Android — [Android Annotations](https://github.com/excilys/androidannotations/wiki)
Она похожа на [RoboJuice](http://habrahabr.ru/post/116945/) по возможностям, но если изучить ее тщательнее, то станет ясно — она гораздо обильнее по возможностям и реализована более удобным для использования в проекте способом.
Об этой библиотеке [уже писали на Хабре](http://habrahabr.ru/post/123966/), но кратко, да и она сама обновилась.
Что ж, пройдемся по AndroidAnnotations подробно, тем более она вошла в [джентельменский набор разработки под Android.](http://habrahabr.ru/post/154827/)
#### Преимущества
Первое — это сокращение кода, вам больше не нужно искать по id вьюшки и отдельно определять для них слушателей.
Второе — это реализованная, как в самых [эротических снах](http://planshetnyj.net/wp-content/uploads/android-apple-1.jpg) разработчиков под Android, работа с потоками.
Третье — удобное и лаконичное храние состояния активити/фрагмента
Четвертое — простое обращение с адаптерами ListView.
[И еще много разных вкусностей...](https://github.com/excilys/androidannotations/wiki/Cookbook)
#### Что внутри и как работает
Работает это великолепно! Вам не нужно наследоваться от RoboGreendroidOrmliteActionBarFragmentActivity и добавлять в проект тяжеловесные библиотеки. Аннотации обрабатываются на одном из шагов во время компиляции, в собранный проект добавляется лишь 50кб jar, остальное лежит и не лезет в собранный apk.
После аннотации Activity, во время компиляции AndroidAnnotations создаст наследника от него, в котором будут реализованы стандартные методы Android. А остальной код, который мы написали будет вызываться из предка. Из-за этого нам нужно в манифесе декларировать, a MyActivity\_ — класс наследник MyActivity, автоматически генерируемый AndroidAnnotations.
[Звучит страшно](https://github.com/excilys/androidannotations/wiki/HowItWorks#StartingAnAnnotatedActivity), но самом деле благодаря такому подходу мы как разработчики только выигрываем.
Производительность не падает — используются стандартные методы. А удобство написания растет во много раз.
И еще одна важная особенность: нам не нужно переписывать весь проект — достаточно аннотировать наши Activity/Fragment/View и использовать внутри только, те аннотации, которые нам нужны. А остальное писать, как мы привыкли это делать ранее, и как нам говорит официальная документация. К примеру, нужны в проекте только аннотации для потоков — их и аннотацию Activity/Fragment добавляем, а остальное пишем через стандартные методы.
#### Имлементация в проект
Здесь и далее всё описано для версии 2.6. Об изменениях в следующих версиях читайте [чейнжлог](https://github.com/excilys/androidannotations/wiki/ReleaseNotes)
##### Настройки проекта
* Скачиваем [архив с библиотекой](https://github.com/excilys/androidannotations/wiki/Download)
* androidannotations-2.6-api.jar — помещаем в папку «libs» нашего проекта.
* androidannotations-2.6.jar — поместим в новую папку внутри проекта с названием «ext-libs».
* Затем зайдем в «Project/Properties/Java compiler/Annotation Processing».
* Ставим галочки «Enable project specific settings», «Enable annotations processing», «Enable processing in editor».
* Заходим в подвкладку «Factory path»: ставим галочку «Enable project specific settings» и жмем «Add jar». Добавляем из папки «ext-libs» «androidannotations-2.6.jar». Жмем «apply» и «yes».
* Во вкладке «Java Compiler» убеждаемся, что у нас «1.6» версия компилятора.
* Во вкладке «Java Build Path/Source» жмем «Add Folder» и добавляем новую папку ".apt\_generated".
* Жмем ОК
Самое нудное закончилось, дальше начинается песня.
##### Простая Activity
Для начала аннотируем MainActivity — в манифесте:
```
```
заменим .MainActivity на .MainActivity\_
Аннотируем класс:
```
@EActivity(R.layout.main_activity)
public class MainActivity extends Activity {
```
Теперь перегрузку onCreate можно смело удалить и попробовать скомпилировать.
##### Запуск последующих Activity
В обычном Activity всегда выполняется метод инициализации элементов интерфейса, и только после его выполнения мы можем вызывать свои методы, обращающиеся к различным View. Для аннотированных Activity метод, который обращается к элементам интерфейса мы аннотируем вот так: `@AfterViews`
Далее попробуем запустить следующую аннотированную Activity, над которой и будем производить различные эксперименты:
```
@AfterViews
protected void afterViews(){
TestActivity_.intent(this).start();
}
```
Вот таким простым способом запускаются аннотированные Activity
Для запуска с передачей экстры: `TestActivity_.intent(context).myDateExtra(someDate).start();`
где myDateExtra — аннотированное `@ Extra` сериализуемое protected-поле в TestActivity
Для запуска с флагами: `TestActivity_.intent(context).flags(FLAG_ACTIVITY_CLEAR_TOP).start();`
##### Аннотируем Activity по полной
Поиск View:
```
@ViewById
protected EditText testactivity_first_edittext;
@ViewById(R.id.testactivity_second_textview)
protected TextView secondTextView;
```
Для сохранения состояния не нужно вынимать сохраненные объекты instance state вручную, достаточно:
```
@InstanceState
String stateToSave;
```
И при измененнии состояния, например при повороте экрана — это поле не будет пересоздано, а сохранит свое значение.
Получение ресурсов, например строк:
```
@StringRes(R.string.hello_world)
String myHelloString;
```
Вешаем onClickListener:
```
@Click(R.id.testactivity_first_button)
void myButtonWasClicked() {
secondTextView.setText("first button was clicked");
}
```
Слушаем изменения текста:
```
@TextChange(R.id.testactivity_second_edittext)
void onTextChangesOnSomeTextViews(TextView tv, CharSequence text) {
Toast.makeText(this, "second textview was changed", Toast.LENGTH_SHORT).show();
}
```
##### Наиудобнейшая работа с потоками
В основном эту библиотеку в своих проектах я использую для работы с потоками.
Для этого используются две аннотации:
`@ Background` — аннотированный так метод выполнится в фоне
`@ UiThread` — так должен аннотироваться метод, вызываемый в фоновом потоке, но выполняющийся в [потоке UI](http://habrahabr.ru/post/142256/)
Вот код примера:
```
@Click(R.id.testactivity_second_button)
protected void secondButtonWasClicked() {
backgroundWork();
}
@Background
protected void backgroundWork() {
publishProgress(0);
publishProgress(10);
publishProgress(100);
onBGTaskFinish("bg task finished");
}
@UiThread
void publishProgress(int progress) {
testactivity_first_edittext.setText("Background task progress: "+ progress);
}
@UiThread
void onBGTaskFinish(String resultText){
secondTextView.setText(resultText);
}
```
На клик кнопки запускается фоновый поток, который во время своего выполнения публикует прогресс и в итоге передает результат выполнения.
На этом сегодня все, продолжение следует…
[Библиотека](https://github.com/excilys/androidannotations/)
[Описание всех аннотаций библиотеки](https://github.com/excilys/androidannotations/wiki/Cookbook)
[Быстрое внедрение библиотеки в новый проект](http://habrahabr.ru/post/154827/)
[Проект-пример из статьи](https://github.com/nekdenis/AndroidAnnotationsSample) | https://habr.com/ru/post/154851/ | null | ru | null |
# Что нового в Visual Studio 2015 для энтузиастов C#, Visual Basic и Linux
Всем доброго дня!
На прошлой неделе завершилась конференция [Build 2016](https://channel9.msdn.com/Events/Build/2016), на которой были представлены главные новости для разработчиков от компании Microsoft.
В их числе и выпуск **Visual Studio 2015 Update 2**, который уже можно скачать и установить себе на компьютер, а также превью следующей версии инструмента:
* [Ссылка на Visual Studio Update 2](http://go.microsoft.com/fwlink/?LinkId=691129)
* [Ссылка на Visual Studio “15” Preview](https://www.visualstudio.com/downloads/visual-studio-next-downloads-vs)
Разберемся, какие нововведения ожидают разработчиков с Visual Studio 2015 Update 2. Начнем с новостей для разработки на C# и Visual Basic.
##### Интерактивная работа
Interactive Window для С# и командная строка REPL, csi, были представлены в Visual Studio Update 1. В Update 2, мы объединили интерактивное взаимодействие с редактором, позволив разработчикам отправлять сниппеты кода из редактора для выполнения их в Interactive Window. Мы также позволили разработчикам инициализировать Interactive Window в контексте проекта.
Как попробовать:
* Выделите сниппет в редакторе, нажмите на правую кнопку мыши и выберите **Execute in Interactive** (или Ctrl+E, Ctrl+E), как показано на рисунке.
* Правой кнопкой мыши нажмите на проект в Solution Explorer и выберите **Initialize Interactive**.
[](https://habrastorage.org/getpro/habr/post_images/278/f89/461/278f894615871403629142aa51c88c99.png)
##### Using/Imports
Мы усовершенствовали подсказки для выражений Using/Imports: предложение подходящего типа для неверного указанного в коде и поиска такого по текущему решению и метаданным, а также добавление using/imports команд и любых ссылок метаданных или проекта одновременно, если это необходимо.
На рисунке ниже показан пример с неправильно указанным типом “WebCleint”. Введенный тип необходимо исправить и подключить пространство имен System.Net.
[](https://habrastorage.org/getpro/habr/post_images/a26/0c8/88c/a260c888c93e9fb762d33c5625c24c5f.png)
##### Рефакторинг
Парочка новых типов рефакторинга:
* Make method synchronous
* Use null-conditional for delegate invocation
[](https://habrastorage.org/getpro/habr/post_images/501/b1b/d0f/501b1bd0f31a8b285c91dde73f9af30a.png)
##### Новое в Roslyn
Мы добавили два новых флага компилятора в [Roslyn](https://github.com/dotnet/roslyn):
* **deterministic**: эта настройка обеспечит побайтную идентичность сборок с одинаковыми входными данными. Раньше PE записи такие, как MVID, PDB ID и Timestamp, изменялись в каждой сборке, но теперь могут быть вычислены детерминистически на основе входных данных.
* **publicSign**: поддерживает новый метод подписи, который напоминает подпись с задержкой. Бинарники могут быть открыто подписаны только public key и загружены в среду необходимую для разработки и тестирования. Это так же известно, как [OSS подпись](https://github.com/dotnet/corefx/blob/master/Documentation/project-docs/oss-signing.md).
#### Visual C++ для разработки под Linux
Мы также подготовили [новое расширение](http://aka.ms/vslinuxext), которое позволит разрабатывать под Linux в Visual Studio на языке С++. С этим расширением вы можете создавать С++ код для серверных, настольных версий Linux и различных устройств. Вы можете управлять вашими покдлючениями к этим машинам с помощью Visual Studio. VS автоматически копирует и удаленно собирает ваш код, а также может запустить ваше приложение с отладчиком. Наша система проектов поддерживает выбор специфической архитектуры, включая ARM.
Сегодня мы поддерживаем только удаленную сборку на машине с Linux. Мы не ограничены различиями Linux дистрибутивов, но все-таки имеем зависимости по наличию некоторых инструментов. В частности, нам необходим openssh-server, g++, gdb и gdbserver.
Используйте любой пакетный менеджер для того, чтобы установить их, например на Debian системах:
```
sudo apt-get install openssh-server g++ gdb gdbserver
```
Скачайте расширение [Visual C++ for Linux Development](http://aka.ms/vslinuxext) или установите через менеджер расширений в Visual Studio. Приступить к работе можно, выбрав Templates > Visual C++ > Cross Platform > Linux.
Подробнее про возможности расширения **Visual C++ for Linux Development** по [ссылке](https://blogs.msdn.microsoft.com/vcblog/2016/03/30/visual-c-for-linux-development/).
#### Xamarin для всех
Не обойти стороной и главную новость для кроссплатформенных разработчиков на С# — инструмент [Xamarin становится доступным для всех](https://blog.xamarin.com/xamarin-for-all/) разработчиков, использующих Visual Studio 2015 Update 2, в том числе бесплатной версии Community. Подробнее об этой новости, мы напишем в отдельной статье, посвященной исключительно анонсу инструментов для кроссплафторменной разработки на Build 2016.
#### Что есть в превью Visual Studio “15”
Мы также с удовольствием представляем вам [первый обзор](http://blogs.msdn.microsoft.com/visualstudio/2016/04/01/visual-studio-15-take-on-dependencies-stay-productive) превью версии Visual Studio “15”. Некоторые возможности, описанные в статье уже доступны и будут совершенствоваться, другие же только ожидаются. [Скачать](https://www.visualstudio.com/en-us/downloads/update2-prereleases) и установить превью Visual Studio “15” отдельным инструментом можно уже сейчас, даже если у вас установлена Visual Studio 2015 Update 2.
#### Полезные ссылки
* Visual Studio 2015: [бесплатные предложения для разработчиков](https://www.visualstudio.com/ru-ru/products/free-developer-offers-vs.aspx)
* Дополнительные и бесплатные инструменты и службы в программе [Visual Studio Dev Essentials](https://www.visualstudio.com/ru-ru/products/visual-studio-dev-essentials-vs.aspx)
* [Лабораторные работы](https://msdn.microsoft.com/ru-ru/mt627843.aspx) по разработке, тестированию и управлению жизненым циклом ПО для Visual Studio 2015
* [Лабораторные работы](https://channel9.msdn.com/Events/Windows-Camp/Window-Camp-Labs-2015-Russia) по разработке универсальных приложений на Windows 10 | https://habr.com/ru/post/280956/ | null | ru | null |
# How PVS-Studio prevents rash code changes, example N3
Let's continue with a series of small notes illustrating the PVS-Studio's ability to quickly find new errors in the code. If the analyzer is regularly used, of course :). Today we have another bug in the Blender project.
I monitor the [Blender](https://github.com/blender/blender) project for fun. Every day I get a [PVS-Studio](https://pvs-studio.com/en/pvs-studio/) report with warnings related to the new code. Sometimes an error catches my attention and I write a note about it. That's what I'm doing right now :).
I won't give you links to the previous articles, since they are of the same type. With these articles I want to show you that regular use of the static analyzer helps quickly find errors. The earlier the error is found, the lower the cost of fixing it.
This time my attention was caught by two PVS-Studio warnings. The analyzer was triggered by one code line:
* [CWE-480] [V616](https://pvs-studio.com/en/docs/warnings/v616/): The 'OB\_MODE\_OBJECT' named constant with the value of 0 is used in the bitwise operation. transform\_snap\_object.c [480](https://github.com/blender/blender/commit/52be06301257a82a1b4a5746e91ff60daa637ded)
* [CWE-571] [V560](https://pvs-studio.com/en/docs/warnings/v560/): A part of conditional expression is always true: !(base->object->mode & OB\_MODE\_OBJECT). transform\_snap\_object.c [480](https://github.com/blender/blender/commit/52be06301257a82a1b4a5746e91ff60daa637ded)
This is OK. One code bug can be suspicious for several diagnostic rules. We have just the case here:
```
if (is_object_active && !(base->object->mode & OB_MODE_OBJECT)) {
```
If you've read the analyzer warnings, you already know what's going on. However, if you look at the code without these warnings, it seems completely normal. This code line can go unnoticed during code review.
To understand that the code is incorrect, you need to look at how the named constant is declared in the *eObjectMode* enumeration:
```
typedef enum eObjectMode {
OB_MODE_OBJECT = 0,
OB_MODE_EDIT = 1 << 0,
OB_MODE_SCULPT = 1 << 1,
OB_MODE_VERTEX_PAINT = 1 << 2,
OB_MODE_WEIGHT_PAINT = 1 << 3,
OB_MODE_TEXTURE_PAINT = 1 << 4,
OB_MODE_PARTICLE_EDIT = 1 << 5,
OB_MODE_POSE = 1 << 6,
OB_MODE_EDIT_GPENCIL = 1 << 7,
OB_MODE_PAINT_GPENCIL = 1 << 8,
OB_MODE_SCULPT_GPENCIL = 1 << 9,
OB_MODE_WEIGHT_GPENCIL = 1 << 10,
OB_MODE_VERTEX_GPENCIL = 1 << 11,
} eObjectMode;
```
The *OB\_MODE\_OBJECT* constant is zero! Let's look at the condition once again:
```
if (is_object_active && !(base->object->mode & OB_MODE_OBJECT)) {
```
Thus, the result of the bitwise AND (&) operation is always zero. The first analyzer's message warns us about this.
If we apply the "!" operator to 0, we get the following expression:
```
if (is_object_active && true) {
```
The second analyzer message tells us that the part of the expression is always true.
Most likely, the correct option would look like this:
```
if (is_object_active && base->object->mode != OB_MODE_OBJECT) {
```
I'm not sure though, I don't understand the Blender's source code well. The analyzer's task is to point out an error. It's up to the developer to decide what to do with it.
Hope you enjoyed this note. Subscribe to my Twitter: [@Code\_Analysis](https://twitter.com/Code_Analysis).
**Additional links:**
1. [Ways to get a free PVS-Studio license](https://pvs-studio.com/en/blog/posts/0614/).
2. [How to introduce a static code analyzer in a legacy project and not to discourage the team](https://pvs-studio.com/en/blog/posts/0743/).
3. [C++ tools evolution: static code analyzers](https://pvs-studio.com/en/blog/posts/cpp/0873/). | https://habr.com/ru/post/651937/ | null | en | null |
# Затухающие полоски на CSS3 без изображений
Хочу поделиться с вами моим способом создания затухающих полосок без использования изображений. Дальше под катом описан метод создания таких элементов с комментариями и примером.
В первую очередь надо подготовить html-вёрстку. Я буду работать со следующим кодом:
```
* First list item
* Second list item
* Third list item, etc.
```
Для создания полосок мы будем использовать css3-свойство: linear-gradient. Оно поддерживается во всех последних стабильных версиях браузеров, кроме IE. В IE10 есть поддержка градиентов, но IE10, к сожалению, работает только под Windows 8, поэтому в данной статье о поддержке IE говорить не будем.
Простой тёмный градиент с затуханием выглядит так: background-image: linear-gradient(rgba(0,0,0,0), rgba(0,0,0,0.1), rgba(0,0,0,0));
Для построения одной полоски мы «сплющим» этот градиент до 1 пикселя по высоте, а поможет нам в этом свойство background-size. Зададим в нём параметры background-size: 100% 1px; и получим градиент во всю ширину блока и в 1 пиксель по высоте. В итоге получится такой код:
```
.container li
{
background-image: linear-gradient(0deg, rgba(0,0,0,0), rgba(0,0,0,0.1) 50%, rgba(0,0,0,0)); /* указываем угол 0deg для того чтобы градиент начинался от левого края, иначе градиент пойдёт сверху */
background-repeat: no-repeat; /* убираем повторение градиента, необходимо для работы background-size */
background-position: 50% 100%;
background-size: 100% 1px;
}
```
Но мы пойдём дальше и добавим ещё одну полоску для создания эффекта объёма. Она у нас будет, соответственно, белого цвета.
Но вот незадача, мы не можем разместить её там же где и светлый градиент, иначе они наложатся друг на друга. Использование 2px полоски тоже не пройдёт, так как на разном фоне они будут негармонично выглядеть.
В таком случае нам пригодится ещё одно css3 свойство: background-origin. Оно может принимать три значения: content-box, padding-box, border-box. Это свойство позволяет позиционировать фон относительно разметки блока.
Чтобы добавить нашу светлую полосу под тёмной мы сначала добавим прозрачную рамку снизу (border: 1px solid transparent;), а затем выставим для градиента background-origin: border-box;
И в итоге после комбинации градиентов наш код будет выглядеть вот так:
```
.container li
{
background-image: linear-gradient(0deg, rgba(0,0,0,0), rgba(0,0,0,0.1) 50%, rgba(0,0,0,0)), linear-gradient(0deg, rgba(255,255,255,0), rgba(255,255,255,0.25) 50%, rgba(255,255,255,0.25));
background-repeat: no-repeat, no-repeat;
background-position: 50% 100%, 50% 100%;
background-size: 100% 1px, 100% 1px;
background-origin: padding-box, border-box;
border-bottom: 1px solid transparent;
}
```
И напоследок можно добавить радиальный градиент такого вида:
radial-gradient(50% 100%, ellipse cover, rgba(0,0,0, 0.05), rgba(0,0,0,0) 50%);
Окончательный вариант можно посмотреть на [jsfiddle демке](http://jsfiddle.net/CyberAP/zvgPq/). | https://habr.com/ru/post/140215/ | null | ru | null |
# Распределенный крон и планировщик пакетных задач в кластере Prun
#### Вводная часть
Часто возникает необходимость управления задачами на множестве вычислительных узлов. Если выполнение задачи можно автоматизировать, написав скрипт, тогда все еще остается необходимость запуска, контроля за исполнением, остановкой этого скрипта в кластере. Задача может быть какой угодно: получить файл через wget, создать дамп локальной БД, запустить нагрузочный тест, выполнить архивацию старых файлов и т.д.
Существует множество автоматизированных систем управления исполнением задач в кластере. К таким системам можно отнести централизованные планировщики пакетных задач в распределенных вычислительных системах, такие как: [htcondor](https://research.cs.wisc.edu/htcondor/), [torque](http://www.adaptivecomputing.com/products/open-source/torque/), [slurm](http://slurm.schedmd.com/) и другие. Централизованные планировщики обычно состоят из одного или нескольких процессов мастера, который управляет множеством процессов воркеров (worker), запущенных на каждом из хостов кластера, на которых и происходит запуск задач. Такие системы прижились в области [high-throughput computing (HTC)](https://en.wikipedia.org/wiki/High-throughput_computing), [high-performance computing (HPC)](https://en.wikipedia.org/wiki/High-performance_computing), но редко используются в ежедневных задачах серверного администрирования и в относительно небольших кластерах во многом из-за возникающей сложности в установке, использовании и поддержке таких систем.
#### Общее описание планировщика Prun
[Prun](https://github.com/abudnik/prun) предоставляет контроль за распределенным исполнением пакетных задач в UNIX-подобных ОС. Prun можно отнести к централизованным планировщикам, однако он имеет упрощенный интерфейс для описания и управления исполнением задач. Мастер prun предоставляет механизм очередей задач, планирования исполнения с учетом приоритетов задач и вычислительных ресурсов (CPU, RAM), механизм обеспечения отказоустойчивости исполняемых задач, а также планирование задач по расписанию (аналог cron). Процесс мастера (**pmaster**) запускается на одной из машин в кластере.
Весь процесс управления мастером происходит с использованием утилиты для администрирования (**prun**). На каждом из хостов должен быть запущен экземпляр воркера. Воркер состоит из двух процессов: собственно процесс воркера (**pworker**), который принимает команды мастера, отвечает на периодические heartbeat сигналы, сохраняет статус выполненной задачи; процесс prexec, который всегда исполняется под непривилегированным пользователем и запускает задачи (используя fork+exec для порождения процесса), одновременно отслеживая статус исполнения процесса.
#### Создание и запуск «Hello, world!» задачи
Для запуска задачи с помощью prun нужно создать файл скрипта на одном из поддерживаемых ЯП (shell, python, ruby, js, java) и .job файл с описанием этой задачи. Вот примеры простейшего shell-скрипта hello\_world.sh и файла с описанием задачи hello\_world.job:
```
#!/bin/sh
echo "Hello, Shell!"
echo "taskId="$taskId", numTasks="$numTasks, "jobId="$jobId
```
```
{
"script" : "/home/nobody/jobs/hello_world.sh",
"language" : "shell",
"send_script" : true,
"priority" : 4,
"job_timeout" : 120,
"queue_timeout" : 60,
"task_timeout" : 15,
"max_failed_nodes" : 10,
"num_execution" : -1,
"exec_unit_type" : "host"
"max_cluster_instances" : -1,
"max_worker_instances" : 1,
"exclusive" : false,
"no_reschedule" : false
}
```
Job файл представляет собой множество пар ключ-значение в формате JSON. Описание некоторых из свойств задачи:
* script — путь к файлу скрипта. Если файл находится в файловой системе мастера, тогда при установленном значении «send\_script» файл скрипта будет отправляться каждому из воркеров на исполнение.
* language — язык скрипта. Определяет, какой интерпретатор (python, ruby, js, java, shell) использовать для выполнения скрипта.
* priority — целочисленное значение приоритета задачи. Чем меньше значение, тем выше приоритет задачи.
* job\_timeout — значение таймаута для выполнения задачи на всем кластере от момента первого исполнения на одном из воркеров до последнего запланированного исполнения.
* queue\_timeout — максимально допустимое время ожидания в очереди задач.
* task\_timeout — значение таймаута для одной запущенной задачи на воркере.
* max\_failed\_nodes — максимальное количество задач, исполнение которых может завершиться с ошибкой и/или машин воркеров, ставших недоступными во время исполнения этой задачи. При достижении этого лимита мастер останавливает исполнение всех экземпляров этой задачи на кластере.
* num\_execution — число запланированных запусков экземпляров задачи (тасков). Если значение отрицательное и значение exec\_unit\_type==host, тогда число тасков будет равняться числу всех доступных воркеров в кластере.
* max\_cluster\_instances — лимит одновременно запущенного числа тасков на всем кластере.
* max\_worker\_instances — лимит одновременно запущенного числа тасков на одной машине воркера.
* exclusive — если установлено в true, то на время исполнения таска на воркере другие задачи не будут планироваться к исполнению на том же воркере одновременно с этой задачей.
Есть и другие свойства в описании задачи: расписание как в crontab, уникальное имя задачи, черный и белый список воркеров и другие.
В терминологии prun задача (**job**) условно разбивается на множество тасков (**task**), где количество тасков определяет количество запусков скрипта этой задачи в кластере. Каждый таск однозначно определяется парой (job\_id, task\_id), при этом у каждой задачи свой уникальный job\_id, а значение task\_id лежит в полуинтервале [0, num\_execution). Последнее свойство можно использовать, чтобы понять какую часть задачи нужно выполнять, что аналогично [рангу](http://www.mpich.org/static/docs/v3.1/www3/MPI_Comm_rank.html) [процесса](http://skif.bas-net.by/bsuir/mpi-1-std/node104.html) в терминах [MPI](https://en.wikipedia.org/wiki/Message_Passing_Interface).
Запуск задачи, а точнее постановка задачи в очередь, можно произвести командой:
```
./prun -c "run /home/nobody/jobs/hello_world.job"
```
Если воркер запущен в терминале не в режиме демона, тогда в результате запуска задачи в стандартный вывод напечатается:
```
Hello, shell!
taskId=0 numTasks=1 jobId=0
```
#### Конфигурация мастера
Каждый воркер относится к одной и только одной группе воркеров. Файл groups (/etc/pmaster/groups) содержит список групп воркеров, где название группы должно совпадать с именем файла, который содержит список адресов хостов, на которых запущены воркеры.
К примеру, если имеется 8 машин, которые нужно разместить в две различные группы, тогда следует создать 2 файла (my\_group1 и my\_group2) и записать в них названия хостов (или ip'шники). Затем записать в файл groups две строчки my\_group1 и my\_group2.
Также группы можно создавать, удалять, а также добавлять и удалять воркеры из группы в любой момент после запуска мастера.
Конфиги мастера и воркера находятся в файлах master.cfg (/etc/pmaster/master.cfg) и worker.cfg (/etc/pworker/worker.cfg) соответственно.
#### Пример создания cron задачи
Процесс создания задачи с исполнением по расписанию не отличается от описанного выше примера «Hello, world!». Для этого обязательно нужно добавить параметры name и cron. Имя задачи должно быть уникальным, поскольку служит идентификатором cron задачи. Формат описания расписания соответствует формату из crontab (man 5 crontab). К примеру, чтобы задача запускалась каждое воскресенье в 3 часа после полуночи, значением ключа cron должно быть "\* 3 \* \* 0".
Пример задачи с расписанием можно посмотреть в jobs/cron.job в репозитории проекта. Из описания этой задачи следует, что она будет запускаться на каждом воркере кластера ровно один раз каждую минуту.
#### Пример создания метазадачи, представленной DAG-графом зависимостей между задачами
Иногда возникает требование выполнять некоторую задачу A только после выполнения одной или нескольких других задач (скажем, B и C). Такие зависимости образуют [ориентированный граф без циклов](https://en.wikipedia.org/wiki/Directed_acyclic_graph). В терминологии prun такие задачи называются метазадачами или группой задач, а граф зависимостей между задачами описывается в .meta файле. Зависимости между задачами описываются в .meta файле списком смежности. Пример метазадачи, которая должна выполняться каждую минуту по расписанию, можно посмотреть в jobs/cron.meta в репозитории проекта.
#### Управление исполнением задач
Кроме добавления задачи с помощью команды run, есть следующий набор команд:
* stop — остановка задачи с уникальным идентификатором job\_id.
* stop — остановка задачи по ее уникальному имени.
* stopg — остановка группы задач (метазадачи).
* stopall — остановка всех задач в кластере и очистка очередей ожидающих задач.
* add [ ]\* — добавление воркера к группе воркеров.
* delete — удаление воркера с принудительным завершением всех запущенных на нем задач.
* addg — добавление группы воркеров.
* deleteg — удаление группы воркеров.
* info — отображает статистику исполнения по конкретной задаче.
* stat — общая статистика по всему кластеру.
* ls — краткая статистика по каждому из воркеров.
* cron — показывает запланированные cron задачи.
#### Отказоустойчивость
Мастер периодически рассылает heartbeat сообщения всем воркерам. Если воркер не ответил на сообщение определенное количество раз, то он считается недоступным, и все выполняемые на нем задачи планируются на другие доступные воркеры. Аналогично задачи, которые вернули код ошибки или аварийно завершились, планируются на другие доступные воркеры.
Мастер может сохранять свое состояние по выполняемым и поставленным в очередь задачам во внешнюю БД. Сейчас существует возможность сохранять состояние в одну из следующих БД: [LevelDB](https://github.com/abudnik/prun-leveldb), [Cassandra](https://github.com/abudnik/prun-cassandra), [Elliptics](https://github.com/abudnik/prun-elliptics). В случае перезапуска мастера, мастер восстанавливает все поставленные в очередь задачи и задачи, которые не успели полностью завершиться на момент предыдущей остановки мастера, а также останавливает все ранее запущенные задачи на воркерах.
#### Заключение
Основными требованиями на этапе разработки prun были: высокая производительность, минимальное количество зависимостей от внешних библиотек, удобство для ежедневного использования и надежность всех компонент. Prun написан на C++ и единственной необходимой зависимостью является библиотека [Boost](http://www.boost.org/).
Должен упомянуть об использовании prun в реальных задачах. Сейчас prun используется в организации нагрузочного тестирования на небольшом кластере из 20 хостов. Суть задачи нагрузочного тестирования заключается в развертывании приложения нагрузочного тестирования, его настройке и запуске тестов по расписанию одновременно на всем кластере.
Максимальный кластер, на котором проверялась работа планировщика, состоял из 140 хостов в AWS, причем хосты были различной мощности (несколько large инстансов, остальные — micro).
В дальнейшем планируется вести статистику загруженности воркеров по многим параметрам в реальном времени для оптимизации планирования задач мастером, поскольку на данный момент используется всего 2 статистики: отношение количества запущенных задач к числу ядер/процессоров и общий объем RAM. Есть множество направлений для дальнейшего развития планировщика.
Напоминаю, что предоставленный в этой статье проект открыт и расположен на GitHub: [github.com/abudnik/prun](https://github.com/abudnik/prun) | https://habr.com/ru/post/265327/ | null | ru | null |
# Решение проблем с установкой .NET Framework 3.5 на Windows 8 в сети с WSUS
Иногда случаются ситуации, когда пользователю Windows 8 необходимо установить .NET Framework 3.5 — чаще всего, это необходимо для обеспечения работоспособности некоторых, относительно старых, программ. В большинстве случаев все проходит без проблем. Однако, недавно возникла ситуация — данный фреймворк отказался устанавливаться на компьютер, находящийся в доменной сети AD с настроенным локальным сервером обновлений WSUS.
#### Описание проблемы
В обычном случае, установка вышеупомянутого фреймворка осуществляется силами ОС и, по сути, представляет из себя лишь включение компонента, отключенного по умолчанию.
После чего ОС подключается к серверу обновлений, скачивает необходимые файлы, и устанавливает компонент.
В ряде случаев ОС не может скачать нужные файлы, а именно:
1. Отсутствует подключение к интернету;
2. На сервере обновлений отсутствуют необходимые файлы.
Я столкнулся, как раз, со вторым случаем. Причем, Microsoft в этом случае советует отключить использование локального сервера обновлений WSUS, установить .NET Framework 3.5, после чего опять включить использование локального WSUS. В моем случае этот вариант был малоприемлем, так как для этого нужно было либо вывести ПК из домена, либо изменить групповую политику. Сконфигурировать WSUS должным образом мне не удалось, он скачивает обновления к .NET Framework 3.5 и версиям ниже, однако установка через него все равно не проходит.
#### Решение проблемы
Решением проблемы является установка вышеобозначенного компонента из локальных источников. Для начала необходимо определиться с локальным хранилищем пакетов. Вообще-то, оно находится на установочном диске Windows 8, в директории **\sources\sxs**, но, во-первых, не всегда под рукой есть диск (или iso), во-вторых, установка с первого же попавшегося диска почему-то не прошла, но прошла с другого. Чтобы избежать этих проблем, я подготовил архив со всеми необходимыми файлами. Итак приступим.
1. Скачиваем архив с файлами, необходимыми для установки компонента: [Sources.zip](https://mega.co.nz/#!HI8g3A7Q!c9LnQXNTL_NC01Yj-S36B356ktMuoTv3LRovub0Axbk) (102.5 MB)
2. Распаковываем архив, для наглядности я распаковал его в корень диска C:\
3. Запускаем командную строку **с правами администратора**
4. Выполняем код, с учетом пути к распакованным файлам из архива:
`DISM /Online /Enable-Feature /FeatureName:NetFx3 /All /LimitAccess /Source:C:\Sources\sxs`
Это займет несколько минут, но в результате получаем успешный результат!
Этот способ можно также применять для установки .NET Framework 3.5 на компьютеры, ограниченные в подключении к интернету.
**Update от 01.02.2019**
Спустя годы ситуация изменилась, подробное обсуждение [доступно на форуме Microsoft](https://social.technet.microsoft.com/Forums/ie/ru-RU/ef10f8eb-fee0-4cde-bb01-52d1db2ea347/win10-1709-add-feature-fails-with-error-0x800f0954?forum=win10itprogeneral).
Теперь никаких локальных установок не нужно. Достаточно поставить одну галочку в GPO.
`Computer Configuration > Administrative Templates > System, "Specify settings for optional component installation and component repair"`
Или по-русски:
`Конфигурация компьютера - Политики - Административные шаблоны - Система - Укажите параметры для установки необязательных компонентов и восстановления компонентов.`
Галка `"Скачайте содержимое для восстановления и дополнительные компоненты непосредственно из Центра обновлений Windows..."` | https://habr.com/ru/post/438226/ | null | ru | null |
# Загрузка ленивых полей
Привет, хабр! Сегодняшняя статья навеяна довольно стандартной ситуацией – существует некий «большой» объект, но для работы приложения далеко не всегда требуется загружать его полностью в память. Для решения такой проблемы существует *ленивая загрузка полей.* Суть её состоит в том, чтозагрузка поля объекта откладывается до того момента, как оно [поле] понадобится.
Объекты могут храниться в локальном хранилище, или же они могут находиться под управлением отдельного микросервиса. В рамках текущей статьи мы рассмотрим и первый, и второй вариант.
Разберем следующий пример: объекты хранятся в локальном хранилище, для работы с которым используем Spring Data.
Существует база данных со следующими таблицами: Организация, Сотрудник, Коды организации (*да, коды организации могли бы быть встраиваемой сущностью, но для наглядности выделены в отдельную таблицу*). Они [таблицы] представляются следующими сущностями:
Организация
```
@Data
@Accessors(chain = true)
@Entity
@NoArgsConstructor
@Table(name = "org")
public class Organization {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@OneToOne(targetEntity = Employee.class, fetch = FetchType.LAZY)
@JoinColumn(name = "head_id")
private Employee head;
@OneToMany(targetEntity = Employee.class, mappedBy = "organization", fetch = FetchType.LAZY)
private Set employees = new HashSet();
@OneToOne(targetEntity = OrganizationCodes.class, fetch = FetchType.LAZY)
@JoinColumn(name = "code\_id")
private OrganizationCodes codes;
}
```
Сотрудник
```
@Data
@Accessors(chain = true)
@Entity
@NoArgsConstructor
@Table(name = "employee")
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "first_name", nullable = false)
private String firstName;
@Column(name = "last_name", nullable = false)
private String lastName;
@ManyToOne(targetEntity = Organization.class, fetch = FetchType.LAZY)
@JoinColumn(name = "org_id")
private Organization organization;
}
```
Коды организации
```
@Data
@Accessors(chain = true)
@Entity
@NoArgsConstructor
@Table(name = "employee")
public class OrganizationCodes {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "inn", nullable = false)
private String inn;
@Column(name = "kpp", nullable = false)
private String kpp;
@Column(name = "ogrn", nullable = false)
private String ogrn;
}
```
Как можно заметить, все поля организации (кроме идентификатора) являются «ленивыми».
Для каждой сущности написаны простые репозитории и сервисные классы.
Репозитории
```
@Repository
public interface OrganizationRepository extends JpaRepository {
}
```
```
@Repository
public interface EmployeeRepository extends JpaRepository {
Set findByOrganization(Organization organization);
}
```
```
@Repository
public interface OrganizationCodesRepository extends JpaRepository {
}
```
Сервисные классы
```
@Service
public class OrganizationServiceImpl implements OrganizationService {
private final OrganizationRepository repository;
@Autowired
public OrganizationServiceImpl(OrganizationRepository repository){
this.repository = repository;
}
@Override
public Organization getById(long orgId) {
return repository.getById(orgId);
}
}
```
Реализация остальных сервисов не важна в рамках статьи, поэтому приведу только интерфейсы
```
public interface EmployeeService {
Employee getById(long employeeId);
Set getByOrgId(long orgId);
}
```
```
public interface OrganizationCodesService {
OrganizationCodes getById(long id);
}
```
Итак, если мы загрузим организацию и попробуем что то сделать, например, с полем head
```
private String getHeadNameFromOrg(long orgId) {
Employee head = organizationService.getById(orgId).getHead();
return head.getFirstName();
}
```
то увидим ошибку:`org.hibernate.LazyInitializationException: could not initialize proxy [ru.brutforcer.org.service.entity.Organization#1] - no Session`. Это потому, что данное поле является «ленивым», и просто так с ним не поработать.
Загрузить ленивое поле в Spring Data (да и вообще в Hibernate) можно следующим образом:
1) Указать аннотацию *@Transactional* на методе, и работать с полем в пределах одной транзакции:
```
@Transactional
public String getHeadNameFromOrg(long orgId) {
Employee head = organizationService.getById(orgId).getHead();
return head.getFirstName();
}
```
2) Указать необходимость загрузки поля непосредственно в методе репозитория
```
@Repository
public interface OrganizationRepository extends JpaRepository {
@Query("SELECT org FROM Organization org join fetch org.head where org.id = :orgId")
Organization getByIdFetchHead(@Param("orgId") long orgId);
}
```
И, добавив соответствующий метод в сервис, использовать уже новый метод
```
public String getHeadNameFromOrg(long orgId) {
Employee head = organizationService.getByIdFetchHead(orgId).getHead();
return head.getFirstName();
}
```
Первый вариант довольно прост, но может создать длительную транзакцию. Это не всегда хорошо - как минимум, могут появиться проблемы с ее [транзакции] изоляцией. А еще в этом случае происходит несколько запросов в базу данных (хоть и в пределах одной транзакции).
Второй вариант лично мне нравится больше, но имеет другую проблему: что, если у нас будет не 2 ленивых поля, а десять? И нужно будет загружать их в разных комбинациях? Тогда наш репозиторий будет разрастаться огромным количеством методов.
Интерфейс сервисного классаВот так будет выглядеть интерфейс сервисного класса со всеми комбинациями загрузки ленивых полей, если их количество 3шт. И это только загрузка сущности по идентификатору.
```
public interface OrganizationService {
Organization getById(long orgId);
Organization getByIdFetchHead(long orgId);
Organization getByIdFetchCodes(long orgId);
Organization getByIdFetchEmployees(long orgId);
Organization getByIdFetchHeadFetchCodes(long orgId);
Organization getByIdFetchCodesFetchEmployees(long orgId);
Organization getByIdFetchEmployeesFetchHead(long orgId);
Organization getByIdFetchAllProperties(long orgId);
}
```
Если в кратце, количество сочетаний будет 2^n, где n - количество ленивых полей: для 4х полей 16, для 5 полей 32 и т.д.
Рассмотрим другую ситуацию – данные находятся под управлением другого микросервиса, общение с которым происходит посредством HTTP запросов в формате REST. Тут магия Hibernate уже не поможет.
Приведу некоторые уточнения.
* Имеется возможность запросить каждое из «ленивых полей» отдельно.
* При загрузке у «ленивых» объектов-полей обязательно заполнено поле id.
* Полную реализацию методов загрузки сущностей для данного примера приводить не буду: ограничусь интерфейсами и некоторыми общими моментами.
Появляется вопрос: можно ли в запросе указать, какие поля загружать, а какие нет? Если да, то есть вариант создать кучу методов, как во втором варианте решения первого примера.
В противном случае, получается, сервис предоставляет возможность или вытянуть объект полностью «лениво» , или полностью загруженный.
Что можно в этом случае сделать? Очевидно, написать метод, который будет кидать запрос и подгружать конкретное поле. Получится примерно то же самое, что и в первом варианте, только немного (совсем чуть-чуть) сложнее.
```
@Service
public class OrganizationServiceImpl implements OrganizationService {
private final OrganizationRepository repository;
private final EmployeeService employeeService;
@Autowired
public OrganizationServiceImpl(OrganizationRepository repository,
EmployeeService employeeService) {
this.repository = repository;
this.employeeService = employeeService;
}
@Override
public Organization getByIdFetchHead(long orgId) {
Organization org = repository.getById(orgId);
Employee head = employeeService.getById(org.getHead().getId());
org.setHead(head);
return org;
}
}
```
Теперь загрузка происходит в 2 запроса вместо одного, и тут придется подумать – загружать ли объект жадно, но за один запрос, или только необходимое, но за два. Например, может быть такое, что два мелких запроса будут обрабатываться быстрее одного большого.
Особенно сильно в данном вопросе будет решать наличие реализованного кэша при загрузке ленивых полей: если его использование будет уместным, то вместо второго запроса значение можно брать из кэша.
Однако, у нас остается проблема: куча методов с разными комбинациями загрузки полей. Это очень неудобно, и решение может быть следующим.
Добавим в основную сущность методы для загрузки ленивых полей (*в целом, они копируют поведение обычных геттеров, однако, например, если в проекте используется Project Reactor, они могут возвращать соответствующие Mono или Flux*) и копирующий конструктор (*т.к. мы говорим о загрузке данных из другого микросервиса, все аннотации, связанные с JPA я убрал*):
```
@Data
@Accessors(chain = true)
@NoArgsConstructor
public class Organization {
private Long id;
private Employee head;
private Set employees;
private OrganizationCodes codes;
public Employee loadHead(){
return this.head;
}
public Set loadEmployees(){
return this.employees;
}
public OrganizationCodes loadCodes(){
return this.codes;
}
public Organization(Organization org) {
this.id = org.getId();
this.head = org.getHead();
this.codes = org.getCodes();
this.employees = org.getEmployees();
}
}
```
Далее в сервисном классе перед возвратом результата переопределяем поведение методов загрузки:
```
@Service
public class OrganizationServiceImpl implements OrganizationService {
private final OrganizationRepository repository;
private final EmployeeService employeeService;
private final OrganizationCodesService organizationCodesService;
@Autowired
public OrganizationServiceImpl(OrganizationRepository repository,
EmployeeService employeeService,
OrganizationCodesService organizationCodesService) {
this.repository = repository;
this.employeeService = employeeService;
this.organizationCodesService = organizationCodesService;
}
@Override
public Organization getById(long orgId) {
Organization org = repository.getById(orgId);
return delegate(org);
}
private Organization delegate(Organization org) {
return new Organization(org){
@Override
public Employee loadHead() {
if (super.getHead() != null && super.getHead().getFirstName() != null) {
return super.getHead();
} else if (super.getHead() != null && super.getHead().getId() != null) {
Employee head = employeeService.getById(org.getHead().getId());
super.setHead(head);
return head;
} else {
return null;
}
}
@Override
public Set loadEmployees() {
if (super.getEmployees() != null)
return super.getEmployees();
else {
Set employees = employeeService.getByOrgId(org.getId());
super.setEmployees(employees);
return employees;
}
}
@Override
public OrganizationCodes loadCodes() {
if (super.getCodes() != null && super.getCodes().getInn() != null) {
return super.getCodes();
} else if (super.getCodes() != null && super.getCodes().getId() != null) {
OrganizationCodes codes = organizationCodesService.getById(super.getCodes().getId());
super.setCodes(codes);
return codes;
} else {
return null;
}
}
};
}
}
```
*(Примечание: проверка загруженности полей head и codes, помимо обычной проверки на null, содержит проверку еще внутренних полей объектов. Это сделано, потому что по условию у данных объектов обязательно должен быть заполнен id сущности. Соответственно, вероятность того, что эти поля при ленивой загрузке равны null, стремится к нулю. Однако, если уже обязательные поля не загружены, то и объект является лениво загруженным. Так же добавлю, что проверки могут быть иными, а в каких то случаях стоит применить синхронизацию при проверке и загрузке полей таким образом).*
В результате проделанных манипуляций, в любой точке кода всегда можно вызвать загрузочный метод и получить необходимое поле. Предложенное решение работает не только с данными, получаемыми из удаленных сервисов – его можно адаптировать и к работе с локальной бд.
Проблемой же является необходимость отправки нескольких запросов. Частично эту проблему сглаживает наличие кэша, однако когда данный подход стоит применять, а когда нет – зависит от конкретной ситуации. | https://habr.com/ru/post/681678/ | null | ru | null |
# Первое, что нужно сделать, запуская проект на Django
Приветствую сообщество, встала передо мной задача написать социальную сеть. А коль скоро язык программирования, которым я более-менее владею — это Python, я выбрал фреймворк Django для реализации проекта. Чтобы не тратить время на написание HTML шаблонов и CSS стилей, эти файлы я беру в интернете с пометкой Free. В основном это шаблоны от [Colorlib](https://colorlib.com/).
Поехали.
Сразу оговорюсь, что использую PyCharm, поэтому могу не знать все команды из файла manage.py.
После создания проекта в среде, как и в любом Django проекте, первое, что необходимо сделать — внести изменения в файле settings.py а именно:
1. Меняем две переменные на
```
LANGUAGE_CODE = 'ru-ru'
TIME_ZONE = 'Ваш часовой пояс/Ваш город' #Например: Europe/Moscow
```
2. Добавить папку для статических и медиа файлов
```
# Static files
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static')
# Media files
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
```
Далее создаём своё приложение командой
```
python manage.py startapp my_app
```
Насколько мне известно, хорошим тоном написания приложений на Django является разбиение проекта на отдельные приложения, и уже в них мы описываем функционал, который нам нужен. Такой подход обеспечивает лёгкий перенос приложений из одного проекта в другой, что очень удобно. Поехали дальше.
Как только приложение создано, нам нужно его зарегистрировать для того, чтобы начать его использовать. Добавим приложение в список используемых.
```
INSTALLED_APPS = [
'django.contrib.admin',
...
'django.contrib.staticfiles',
'my_app',#наше приложение
]
```
Далее необходимо определить url адрес для нашего приложения, что тоже является хорошим тоном разработки. В папке приложения (не путать с папкой проекта) нужно предварительно создать файл urls.py. А затем в папке проекта в файле urls.py импортируем функцию include и прописываем адрес. Об этом также написано в комментариях в самом файле.
```
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('account.urls'))
]
```
Если на этом этапе мы запустим сервер командой
```
python manage.py runserver
```
в командной строке (в PyCharm кнопка «Запуск» или «Debug»), то получим ошибку, ведь в папке приложения файл urls.py (далее — account/urls.py) пустой.
Заполним его следующим кодом.
```
from django.urls import path
from . import views
urlpatterns = [
path('', views.index, name='login'),# при обращении к адресу ''(главная страница), будем использовать представление (термин Django) log
]
```
Теперь выйдет ошибка, потому что account/views.py пустой. Исправим.
```
from django.shortcuts import render #импорт функции
# Create your views here.
def index(request):#создаем свою функцию
context = {}#с помощью словаря можем передать модель и форму в шаблон HTML
return render(request, 'my_app/index.html', context)#собственно вызываем шаблон HTML
```
Почти готово. Что уже сделано:
1. Создано приложение в проекте.
2. Внесены изменения в настройках.
3. Прописан адрес в главном urls.py проекта.
4. В приложении создан файл urls.py и в нем прописано представление (views).
5. В представлении (views) создана функция обработки url адреса и HTML шаблона.
Пора создать шаблон.
При создании проекта у нас автоматически создаётся папка 'templates', в ней нужно создать папку my\_app, внутри my\_app создать файл index.html. Для проверки в теге body можно записать:
```
Заголовок
Сайт работает.
--------------
```
и можно запускать сервер.
В итоге мы должны увидеть вот это (изображение):
Если на сайте используются какие-либо CSS стили или JavaScript файлы, а это 10 из 10 случаев, то нужно их подгрузить перед строкой DOCTYPE командой
```
{%load staticfiles%}
```
При этом в папке приложения создать папку «static», внутри держать CSS, JS и тд. А в HTML шаблоне в теге link параметре href указать абсолютный путь к файлу, например:
Итого, файл будет выглядеть вот так:
```
{%load staticfiles%}
Заголовок
Сайт работает.
--------------
```
В общем-то нам этом введение и заканчивается. Дальше все действия будут похожи, только суть будет разной. Будут разные формы (тег form в HTML) в файле forms.py приложения (нужно предварительно создать этот файл), будет разная логика приложений, описанная в views.py, ну и модели в базе данных, описанные в models.py. Но сам алгоритм действий тот же самый
1. Создаём адрес.
2. Создаём представление (логику).
3. Создаём HTML шаблон.
4. Связываем всё вместе.
+ — пара промежуточных действий в виде форм и моделей.
В блоге Metanit (ссылка внизу) хорошо описана суть Модель — Шаблон — Представление, копипастить не собираюсь, там же есть теория и про формы, и про модели.
В «Руководство Django Girls» (ссылка внизу) можно узнать подробней о расширении шаблонов HTML (крайне полезная фишка Django), о создании учётной записи администратора, о добавлении данных в созданные модели.
А я на этом заканчиваю. В следующей части будет код создания формы регистрации на сайте, а чтобы не мусорить на Хабре, дам ссылку на гитхаб. Успехов в главном, товарищи.
Ссылки на полезные ресурсы:
[Блог про Django — Metanit](https://metanit.com/python/django/)
[Руководство Django Girls](https://tutorial.djangogirls.org/ru/)
[Django в примерах](https://pocoz.gitbooks.io/django-v-primerah/) | https://habr.com/ru/post/463021/ | null | ru | null |
# Приручаем ZoG (Часть 1: Волки и Козленок)
 В [предыдущей](http://habrahabr.ru/post/210468/) статье я рассказывал об уникальном, на мой взгляд, проекте [Zillions of Games](http://www.zillions-of-games.com/). Как я и обещал, я начинаю небольшой цикл учебных статей по описанию возможностей декларативного языка, предназначенного для разработки новых (и описания уже существующих) игр, в рамках этого проекта.
Для того чтобы не загромождать изложение излишними (на этом этапе) подробностями, я выбрал для реализации очень простую игру. Я играл в нее в детстве. Она называется «Волки и Козленок». Правила следующие: Волки (черные фигуры) — ходят на одну клетку по диагонали, только вперед. Козленок (белая фигура) — также ходит на одну клетку по диагонали, но в любую сторону. Задача белых — пройти на любую из четырех клеток своего цвета последней горизонтали. Задача черных — лишить белых возможности хода.
Поскольку на стандартной шахматной доске 8x8 черные побеждают элементарно, используем для игры доску 9x9 клеток. Эта игра очень простая (и нравится детям). При правильной игре, белые всегда побеждают.
Язык описания правил (ZRF) очень напоминает [LISP](http://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D1%81%D0%BF). Как и в LISP-е, очень важно следить за балансом открывающихся и закрывающихся скобок (в противном случае, игра просто не загрузится). Также как и в LISP-е, комментарии начинаются с символа точки с запятой и продолжаются до конца строки.
```
; *****************************************************************
; *** Волки и Козленок
; *****************************************************************
(version "2.0")
```
Здесь, в комментарии, мы кратко описываем игру и указываем версию Zillions of Games, на которой она должна работать. На более младшей версии «движка» игра не запустится.
В ZRF, активно используются макросы. Они довольно просты, но могут использовать параметры. Следующая запись, представляет собой макрос, описывающий единственно возможный в нашей игре ход — на одну клетку в указанном направлении:
```
(define checker-shift ($1 (verify empty?) add))
```
При использовании в коде записи:
```
(checker-shift ???)
```
Макрос раскрывается следующим образом:
```
(??? (verify empty?) add)
```
Смысл передаваемого параметра и всей этой записи я объясню ниже. Пока, нам важно понимать, что макросы спасают нас от большого количества писанины и связанной с ней возможностью ошибок в описании.
Далее описывается доска. Ее описание также принято выносить в макрос:
```
(define board-defs
(image "images\gluk\Board.bmp")
(grid
(start-rectangle 2 2 48 48)
(dimensions
("a/b/c/d/e/f/g/h/i" (48 0)) ; files
("9/8/7/6/5/4/3/2/1" (0 48)) ; ranks
)
(directions (nw -1 -1) (ne 1 -1) (se 1 1) (sw -1 1))
)
(symmetry Black (ne sw) (sw ne) (nw se) (se nw))
(zone (name goals) (players White) (positions b9 d9 f9 h9) )
)
```
Смысл описания image понятен — это имя файла рисунка, загружаемого для отображения доски. Далее следует описание квадратной доски (grid). Следует заметить, что возможности ZRF не ограничиваются описанием прямоугольных досок. Используя этот язык, можно описывать треугольные и шестиугольные доски, можно описывать многомерные доски, вплоть до 5-ти измерений, можно «склеивать» края доски, определяя ее топологию и т.д. Мы не будем сейчас на этом останавливаться. Подробности таких описаний можно найти в chm-файле, описывающем язык ZRF (поставляемом вместе с игрой), а также в огромном количестве уже реализованных игр на всевозможных досках.
Для нашей игры важны три ключевые фразы описания grid: start-rectangle описывает каким образом доска «накладывается» на загруженный рисунок. Фраза dimensions — описывает измерения (у нас их два). Строки в начале описания каждого измерения важны — они описывают порядок нумерации клеток (определяя, таким образом, систему координат). Следующий далее параметр определяет, каким образом «линейка» измерения накладывается на доску. Следует сказать, что при использовании изображения доски, разработанного самостоятельно, могут возникнуть сложности с подбором этих числовых значений, а также значений, указанных в start-rectangle. Может потребоваться множество попыток, для того, чтобы изображения фигур попадали в нужные места на изображении доски.
Следующая, очень важная фраза (directions) определяет направления, в которых могут двигаться фигуры. Мы определяем четыре направления — северо-запад (nw), северо-восток (ne), юго-запад (sw) и юго-восток (se). Фразой symmetry, мы определяем правила, по которым эти направления преобразуются для черного игрока.
Последняя строка (zone) — определяет набор клеток, который мы будет использовать далее, при определении условия победы Белых.
```
(define game-defs
(board
(board-defs)
)
(board-setup
(White (WC e2) )
(Black (BC b9 d9 f9 h9) )
)
(win-condition (White) (absolute-config WC (goals)))
(loss-condition (White Black) stalemated)
)
```
В этом макросе, мы определяем условия игры. Фразой board задается ранее определенная нами доска (макрос board-defs раскрывается). В board-setup определяются начальные позиции игроков, после чего, фразами win-condition и loss-condition определяются условия победы и поражения для игроков. Условием победы для Белых мы определяем прохождение в ранее определенную нами зону, а условием поражения, для обеих сторон, отсутствие возможности сделать очередной ход.
Осталось определить игру:
```
(game
(title "Волки и Козленок")
(description "Провести белую фишку на последнюю горизонталь")
(players White Black)
(turn-order White Black)
(game-defs)
(piece
(name WC)
(image White "images\gluk\W.bmp")
(description "Козленок")
(help "Ходит на 1 клетку по диагонали вперед и назад")
(moves
(checker-shift ne)
(checker-shift nw)
(checker-shift se)
(checker-shift sw)
)
)
(piece
(name BC)
(image Black "images\gluk\B.bmp")
(description "Волк")
(help "Ходит на 1 клетку по диагонали только вперед")
(moves
(checker-shift ne)
(checker-shift nw)
)
)
)
```
Большинство из определений здесь интуитивно понятны. Стоит остановиться лишь на нескольких моментах. Фраза players описывает тех самых игроков White и Black, которых мы уже использовали ранее. Игроков может быть больше двух, а в головоломках может быть определен один игрок (имеется даже возможность определить игрока делающего случайные ходы, но это тема для отдельного разговора). Фраза turn-order определяет порядок очередности хода для игроков (он также может отличаться от простого чередования хода двух игроков).
Далее, после описания настроек игры (game-defs), следует описание фигур, используемых в игре (piece). Большинство описаний в них также понятны. В разделе moves перечисляются все возможные для фигуры ходы. Именно здесь мы используем макрос checker-shift, о котором говорили в самом начале. Как легко видеть, в качестве параметра, ему передается возможное направление движения фигуры. В результате развертывания макроса, получается что-то наподобие следующего:
```
( ne
(verify empty?)
add
)
```
Мы выполняем три шага — двигаемся в указанном направлении, проверяем, пуста ли клетка и ставим фигуру (здесь имеется сложный для понимания момент. Для себя, я считаю, что в начале хода фигура снимается с доски, а в конце хода возвращается на доску). Подробнее, о возможностях описания правил ходов я планирую рассказать в следующих статьях, на примере более сложных игр.
Новая игра готова. Желающие могут загрузить ее из репозитория на [GitHub](https://github.com/GlukKazan/ZoG/blob/master/Rules/01.Wolfs.zrf).
**Важная ремарка****Внимание:** для того, чтобы запустить этот код, вам потребуется, каким либо образом, разлочить ядро Zillions of Games (например — купить серийный номер) | https://habr.com/ru/post/211100/ | null | ru | null |
# Протокольно-ориентированное программирование в Swift 5.1
**Протоколы** — фундаментальное свойство Swift. Они играют важную роль в стандартных библиотеках Swift и являются обычным способом абстракции кода. Во многом они похожи на **интерфейсы** в других языках программирования.
В этом руководстве мы представим вам подход к разработке приложений, называемый «протокольно-ориентированным программированием», который стал практически основным в Swift. Это действительно то, что вам необходимо уяснить при изучении Swift!
В этом руководстве вы:
* поймёте разницу между объектно-ориентированным и протокольно-ориентированным программированием;
* разберётесь со стандартной реализаций протоколов;
* научитесь расширять функционал стандартной библиотеки Swift;
* узнаете, как расширять протоколы при помощи дженериков.
Начинаем
--------
Представьте, что вы разрабатываете игру — гонки. Ваши игроки могут гонять на машинах, мотоциклах и на самолётах. И даже летать на птицах, это же ведь игра, верно? Основное здесь то, что есть дофига всяких «штук», на которых можно гонять, летать и т.п.
Обычный подход при разработке подобных приложений состоит в объектно-ориентированном программировании. В этом случае мы заключаем всю логику в неких базовых классах, от которых в дальнейшем наследуемся. Базовые классы, таким образом, должны содержать внутри логику «вести» и «пилотировать».
Мы начинаем разработку с создания классов для каждого средства передвижения. «Птиц» отложим пока на потом, к ним мы вернёмся чуть позже.
Мы видим, что **Car** и **Motorcycle** весьма похожи по функционалу, так что мы создаём базовый класс **MotorVehicle**. Car и Motorcycle будут наследоваться из MotorVehicle. Таким же образом мы создаем базовый класс **Aircraft**, от которого создадим класс **Plane**.
Вы думаете, что всё прекрасно, но — бац! — действие вашей игры происходит в XXX столетии, и некоторые машины уже могут **летать**.
Итак, у нас случился затык. У Swift нет множественного наследования. Каким образом ваши летающие автомобили смогут наследоваться и от MotorVehicle и от Aircraft? Создавать еще один базовый класс, в котором соединятся обе функциональности? Скорее всего, нет, так как нет ясного и простого способа добиться этого.
И что же спасёт нашу игру в этой ужасной ситуации? На помощь спешит протокольно-ориентированное программирование!
Что такого в протокольно-ориентированном программировании?
----------------------------------------------------------
Протоколы позволяют группировать похожие методы, функции и свойства применительно к классам, структурам и перечислениям. При этом только классы позволяют использовать наследование от базового класса.
**Преимущество протоколов в Swift состоит в том, что объект может соответствовать нескольким протоколам.**
Ваш код при при использовании такого метода становиться более модульным. Думайте о протоколах как о строительных блоках функционала. Когда вы добавляете новую функциональность объекту, делая его соответствующим некоему протоколу, вы не делаете совершенно новый объект «с нуля», это было бы слишком долго. Вместо этого, вы добавляете разные строительные блоки до тех пор, пока объект не будет готов.
Переход от базового класса к протоколам решит нашу проблему. С протоколами мы можем создать класс FlyingCar, который соответствует и MotorVehicle и Aircraft. Миленько, да?
Займёмся кодом
--------------
Запускаем Xcode, создаём playground, сохраняем как SwiftProtocols.playground, добавляем этот код:
```
protocol Bird {
var name: String { get }
var canFly: Bool { get }
}
protocol Flyable {
var airspeedVelocity: Double { get }
}
```
Скомпилируем при помощи **Command-Shift-Return**, чтобы быть уверенным, что все в порядке.
Здесь мы определяем простой протокол **Bird**, со свойствами **name** и **canFly**. Затем определяем протокол **Flyable** со свойством **airspeedVelocity**.
В «допротокольную эпоху» разработчик начал бы с класса Flyable в качестве базового, а затем, используя наследование, определил бы Bird и всё прочее, что может летать.
Но в протокольно-ориентированном программировании всё начинается с протокола. Эта техника позволяет нам инкапсулировать набросок функционала без базового класса.
Как вы сейчас увидите, это делает процесс проектирования типов гораздо гибче.
Определяем тип, соответствующий протоколу
-----------------------------------------
Добавьте этот код внизу playground:
```
struct FlappyBird: Bird, Flyable {
let name: String
let flappyAmplitude: Double
let flappyFrequency: Double
let canFly = true
var airspeedVelocity: Double {
3 * flappyFrequency * flappyAmplitude
}
}
```
Этот код определяет новую структуру **FlappyBird**, которая соответствует и протоколу Bird и протоколу Flyable. Её свойство airspeedVelocity — произведение flappyFrequency and flappyAmplitude. Свойство canFly возвращает true.
Теперь добавьте определения еще двух структур:
```
struct Penguin: Bird {
let name: String
let canFly = false
}
struct SwiftBird: Bird, Flyable {
var name: String { "Swift \(version)" }
let canFly = true
let version: Double
private var speedFactor = 1000.0
init(version: Double) {
self.version = version
}
// Swift is FASTER with each version!
var airspeedVelocity: Double {
version * speedFactor
}
}
```
**Penguin** это птица, но не может летать. Хорошо, что мы не пользуемся наследованием и не сделали всех птиц **Flyable**!
При использовании протоколов вы определяете компоненты функционала и делаете все подходящие объекты соответствующими протоколу
Затем мы определяем **SwiftBird**, но в нашей игре есть несколько разных её версий. Чем больше номер версии, тем больше её **airspeedVelocity**, которая определена как вычисляемое свойство.
Однако, здесь есть некоторая избыточность. Каждый тип Bird должен определить явно определить свойство canFly, хотя у нас есть определение протокола Flyable. Похоже, что нам нужен способ определить реализацию методов протокола по умолчанию. Что ж, для этого существуют расширения протоколов (protocol extensions).
Расширяем протокол поведением по умолчанию
------------------------------------------
Расширения протокола позволяют задать поведение протокола по умолчанию. Напишите этот код сразу за определением протокола Bird:
```
extension Bird {
// Flyable birds can fly!
var canFly: Bool { self is Flyable }
}
```
Этот код определяет расширение протокола **Bird**. В этом расширении определяется, что свойство **canFly** вернёт true в случае, когда тип соответствует протоколу **Flyable**. Другими словам, всякой Flyable-птице больше не нужно явно задавать canFly.
Теперь удалим **let canFly = ...** из определений FlappyBird, Penguin и SwiftBird. Скомпилируйте код и убедитесь, что всё в порядке.
Займёмся перечислениями
-----------------------
Перечисления в Swift могут соответствовать протоколам. Добавьте следующее определение перечисления:
```
enum UnladenSwallow: Bird, Flyable {
case african
case european
case unknown
var name: String {
switch self {
case .african:
return "African"
case .european:
return "European"
case .unknown:
return "What do you mean? African or European?"
}
}
var airspeedVelocity: Double {
switch self {
case .african:
return 10.0
case .european:
return 9.9
case .unknown:
fatalError("You are thrown from the bridge of death!")
}
}
}
```
Определяя соответствующие свойства, **UnladenSwallow** соответствует двум протоколам — Bird и Flyable. Такими образом, реализуется определение по умолчанию для canFly.
Переопределяем поведение по умолчанию
-------------------------------------
Наш тип **UnladenSwallow**, соответствуя протоколу **Bird**, автоматически получил реализацию для **canFly**. Нам, однако, нужно, чтобы **UnladenSwallow.unknown** возвращала **false** для canFly.
Добавьте внизу следующий код:
```
extension UnladenSwallow {
var canFly: Bool {
self != .unknown
}
}
```
Теперь только .african и .european возвратят true для canFly. Проверьте! Добавьте следующий код внизу нашего playground:
```
UnladenSwallow.unknown.canFly // false
UnladenSwallow.african.canFly // true
Penguin(name: "King Penguin").canFly // false
```
Скомпилируйте playground и проверьте полученные значения с указанными в комментариях выше.
Таким образом мы переопределяем свойства и методы почти так же, как используя виртуальные методы в объектно-ориентированном программировании.
Расширяем протокол
------------------
Вы также можете сделать свой собственный протокол соответствующим другому протоколу из стандартной библиотеки Swift и определить поведение по умолчанию. Замените объявление протокола Bird следующим кодом:
```
protocol Bird: CustomStringConvertible {
var name: String { get }
var canFly: Bool { get }
}
extension CustomStringConvertible where Self: Bird {
var description: String {
canFly ? "I can fly" : "Guess I'll just sit here :["
}
}
```
Соответствие протоколу CustomStringConvertible означает, что у вашего типа должно быть свойство description. Вместо того, чтобы добавлять это свойство в типе Bird и во всех производных от него, мы определяем расширение протокола CustomStringConvertible, которое будет ассоциировано только с типом Bird.
Наберите **UnladenSwallow.african** внизу playground. Скомпилируйте и вы увидите “I can fly”.
Протоколы в стандартных библиотеках Swift
-----------------------------------------
Как видите, протоколы — эффективный способ расширять и настраивать типы. В стандартной библиотеке Swift это их свойство также широко применяется.
Добавьте этот код в playground:
```
let numbers = [10, 20, 30, 40, 50, 60]
let slice = numbers[1...3]
let reversedSlice = slice.reversed()
let answer = reversedSlice.map { $0 * 10 }
print(answer)
```
Вы наверняка знаете, что выведет этот код, но, возможно, удивитесь использованным здесь типам.
Например, slice — не Array, а ArraySlice. Это специальная «обёртка», которая обеспечивает эффективный способ работы с частями массива. Соответственно, reversedSlice — это ReversedCollection.
К счастью, функция map определена как расширение к протоколу Sequence, которому соответствуют все типы-коллекции. Это позволяет нам применять функцию map как к Array, так и к ReversedCollection и не замечать разницы. Скоро вы воспользуетесь этим полезным приёмом.
На старт
--------
Пока что мы определили несколько типов, соответствующих протоколу Bird. Сейчас же мы добавим нечто совсем другое:
```
class Motorcycle {
init(name: String) {
self.name = name
speed = 200.0
}
var name: String
var speed: Double
}
```
У этого типа нет ничего общего с птицами и полётами. Мы хотим устроить гонку мотоциклистов с пингвинами. Пора выводить эту странную компашку на старт.
Соединяем всё вместе
--------------------
Чтобы как-то объединить столь разных гонщиков, нам нужен общий протокол для гонок. Мы сможем все это сделать, даже не трогая все созданные нами до этого типы, при помощи замечательной вещи, которая называется ретроактивное моделирование. Просто добавьте это в playground:
```
// 1
protocol Racer {
var speed: Double { get } // speed is the only thing racers care about
}
// 2
extension FlappyBird: Racer {
var speed: Double {
airspeedVelocity
}
}
extension SwiftBird: Racer {
var speed: Double {
airspeedVelocity
}
}
extension Penguin: Racer {
var speed: Double {
42 // full waddle speed
}
}
extension UnladenSwallow: Racer {
var speed: Double {
canFly ? airspeedVelocity : 0.0
}
}
extension Motorcycle: Racer {}
// 3
let racers: [Racer] =
[UnladenSwallow.african,
UnladenSwallow.european,
UnladenSwallow.unknown,
Penguin(name: "King Penguin"),
SwiftBird(version: 5.1),
FlappyBird(name: "Felipe", flappyAmplitude: 3.0, flappyFrequency: 20.0),
Motorcycle(name: "Giacomo")]
```
Вот что мы тут делаем: сначала определяем протокол Racer. Это всё то, что может участвовать в гонках. Затем мы приводим все наши созданные до этого типы к протоколу Racer. И, наконец, мы создаём Array, который содержит в себе экземпляры каждого нашего типа.
Скомпилируйте playground, чтобы все было в порядке.
Максимальная скорость
---------------------
Напишем функцию для определения максимальной скорости гонщиков. Добавьте этот код в конце playground:
```
func topSpeed(of racers: [Racer]) -> Double {
racers.max(by: { $0.speed < $1.speed })?.speed ?? 0.0
}
topSpeed(of: racers) // 5100
```
Здесь мы используем функцию max чтобы найти гонщика с максимальной скоростью и возвращаем её. Если массив пуст, то возвращается 0.0.
Делаем функцию более обобщенной
-------------------------------
Предположим, что массив Racers достаточно велик, а нам нужно найти максимальную скорость не во всем массиве, а в какой-то его части. Решение состоит в том, чтобы изменить topSpeed(of:) таким образом, чтобы она принимала в качестве аргумента не конкретно массив, а всё, что соответствует протоколу Sequence.
Заменим нашу реализацию topSpeed(of:) следующим образом:
```
// 1
func topSpeed(of racers: RacersType) -> Double
/\*2\*/ where RacersType.Iterator.Element == Racer {
// 3
racers.max(by: { $0.speed < $1.speed })?.speed ?? 0.0
}
```
1. RacersType — это generic-тип аргумента нашей функции. Он может быть любым, соответствующим протоколу Sequence.
2. where определяет, что содержимое Sequence должно соответствовать протоколу Racer.
3. Тело самой функции осталось без изменений.
Проверим, добавив это в конце нашего playground:
```
topSpeed(of: racers[1...3]) // 42
```
Теперь наша функция работает с любым типом, отвечающим протоколу Sequence, в том числе и с ArraySlice.
Делаем функцию более «свифтовой»
--------------------------------
По секрету: можно сделать ещё лучше. Добавим это в самом низу:
```
extension Sequence where Iterator.Element == Racer {
func topSpeed() -> Double {
self.max(by: { $0.speed < $1.speed })?.speed ?? 0.0
}
}
racers.topSpeed() // 5100
racers[1...3].topSpeed() // 42
```
А вот теперь мы расширили сам протокол Sequence функцией topSpeed(). Она применима только в случае, когда Sequence содержит тип Racer.
Компараторы протоколов
----------------------
Другая особенность протоколов Swift — это то, как вы определяете операторы равенства объектов или их сравнения. Напишем следующее:
```
protocol Score {
var value: Int { get }
}
struct RacingScore: Score {
let value: Int
}
```
Имея протокол Score можно писать код, который обращается со всеми элементами этого типа одним образом. Но если завести вполне определенный тип, такой как RacingScore, то вы не спутаете его с другими производными от протокола Score.
Мы хотим, чтобы очки (scores) можно было сравнивать, чтобы понять, у кого максимальный результат. До Swift 3 разработчикам было нужно писать глобальные функции для определения оператора к протоколу. Теперь же мы можем определить эти статические методы в самой модели. Сделаем это, заменив определения Score и RacingScore следующим образом:
```
protocol Score: Comparable {
var value: Int { get }
}
struct RacingScore: Score {
let value: Int
static func <(lhs: RacingScore, rhs: RacingScore) -> Bool {
lhs.value < rhs.value
}
}
```
Мы заключили всю логику для RacingScore в одном месте. Протокол Comparable требует опеределить реализацию только для функции «меньше, чем». Все остальные функции сравнения будут реализованы автоматически, на основании созданной нами реализации функции «меньше, чем».
Протестируем:
```
RacingScore(value: 150) >= RacingScore(value: 130) // true
```
Вносим изменения в объект
-------------------------
До сих пор каждый пример демонстрировал, как **добавить** функционал. Но что, если мы хотим сделать протокол, который что-то **изменяет** в объекте? Это можно сделать при помощи **mutating** методов в нашем протоколе.
Добавьте новый протокол:
```
protocol Cheat {
mutating func boost(_ power: Double)
}
```
Здесь мы определяем протокол, который дает нам возможность жульничать (cheat). Каким образом? Произвольно изменяя содержимое boost.
Теперь создадим расширение SwiftBird, которое соответствует протоколу Cheat:
```
extension SwiftBird: Cheat {
mutating func boost(_ power: Double) {
speedFactor += power
}
}
```
Здесь мы реализуем функцию boost(\_:), увеличивая speedFactor на передаваемую величину. Ключевое слово **mutating** даёт структуре понять, что одно из её значений будет изменено этой функцией.
Проверим!
```
var swiftBird = SwiftBird(version: 5.0)
swiftBird.boost(3.0)
swiftBird.airspeedVelocity // 5015
swiftBird.boost(3.0)
swiftBird.airspeedVelocity // 5030
```
Заключение
----------
[Здесь](https://koenig-media.raywenderlich.com/uploads/2019/12/Protocol_Oriented_Programming_Materials-1.zip) вы можете загрузить полный исходный код playground.
Вы узнали о возможностях протокольно-ориентированного программирования, создавая простые протоколы и увеличивая их возможности их при помощи расширений. Используя реализацию по умолчанию, вы даете протоколам соответсвующее «поведение». Почти как с базовыми классами, но только лучше, так как все это применимо также к структурам и перечислениям.
Вы также увидели, что расширение протоколов применимо и к базовым протоколам Swift.
Здесь вы найдёте [официальное руководство по протоколам](https://docs.swift.org/swift-book/LanguageGuide/Protocols.html).
Вы можете также посмотреть прекрасную [лекцию на WWDC](https://developer.apple.com/videos/wwdc/2015/?id=408), посвященную протокольно-ориентированному программированию.
Как и с любой парадигмой программирования, есть опасность увлечься и начать использовать протоколы налево и направо. [Здесь интересная заметка](http://chris.eidhof.nl/post/protocol-oriented-programming/) о том, что стоит опасаться решений в стиле «серебряная пуля». | https://habr.com/ru/post/486902/ | null | ru | null |
# Индексирование и поиск с помощью Xapian в .NET
Если слово Xapian вам незнакомо, рекомендую ознакомиться с небольшой [статьей](http://www.developers.org.ua/lenta/articles/full-text-search-engines-overview-sphinx-apache-lucene-xapian/).
Вкратце же, Xapian — представляет собой написанный на с++ набор инструментов для индексирования текстовой информации, с возможностью поиска по базе индексированной информации. Для работы не требует установленного сервера, достаточно наличия его библиотек. Может обрабатывать огромные массивы информации(проверено до 1.5Тб), измеряемой миллионами документов. Является конкурирующим продуктом Sphinx и Apache Lucene.
Мной он был выбран из этих трех продуктов за возможность использования из .Net.
Прежде всего нужно [скачать](http://www.flax.co.uk/xapian/1023/xapian-1.0.23-bindings-csharp.zip) dll' ки Xapian под .Net.
Затем еще одну вспомогательную dll — [Zlib1.dll](http://zlib.net/zlib125-dll.zip), без нее будут выкидываться исключения при попытке обращения оберточной dll к скомпиленной на C++.
Собственно для работы это все что требовалось. Можно создавать проект. XapianCSharp.dll сразу добавляем в Reference. \_XapianSharp.dll и zlib1.dll добавляем в проект(просто как контент), и помечаем Copy to Output Directory как Copy always.
Делаем две функции для тестирования работы:
```
....
using Xapian;
....
//Путь указываем куда хотим, если базы по нему не окажется
//она будет создана автоматически
string xapianBase="H:\\XapianDB\\xap.db";
....
//Индексирование файлов указанного каталога
//без рекурсии
private void IndexFolder(string path)
{
try
{
if (Directory.Exists(path))
{
string[] files=Directory.GetFiles(tbIndexFolder.Text);
using (WritableDatabase database=new WritableDatabase(xapianBase, Xapian.Xapian.DB_CREATE_OR_OPEN))
{
using (TermGenerator indexer=new TermGenerator())
{
using (Stem stemmer=new Xapian.Stem("russian"))
{
indexer.SetStemmer(stemmer);
foreach (string file in files)
{
using (Document doc=new Document())
{
//Имя файла используется как ключ, оно и будет выдаваться при поиске
doc.SetData(file);
indexer.SetDocument(doc);
//Не забываем указывать кодировку ваших документов
indexer.IndexText(File.ReadAllText(file, Encoding.GetEncoding(1251)));
//Пишем в базу
database.AddDocument(doc);
}
}
}
}
}
}
}
catch (Exception ex)
{
Write("Exception: "+ex.ToString());
}
}
private void Search(string searchText)
{
try
{
// Открываем базу для поиска
using (Database database=new Database(xapianBase))
{
using (Enquire enquire=new Enquire(database))
{
using (QueryParser qp=new QueryParser())
{
using (Stem stemmer=new Stem("russian"))
{
Write(stemmer.GetDescription());
qp.SetStemmer(stemmer);
qp.SetDatabase(database);
qp.SetStemmingStrategy(QueryParser.stem_strategy.STEM_SOME);
using (Query query=qp.ParseQuery(searchText))
{
Write("Parsed query is: "+query.GetDescription());
enquire.SetQuery(query);
//Тут указываем с какого по какой результат хотим получить
//в данном случае получим первые 100 совпадений
MSet matches=enquire.GetMSet(0, 100);
Write(String.Format("{0} results found.", matches.GetMatchesEstimated()));
Write(String.Format("Matches 1-{0}:", matches.Size()));
//Выполняем поиск
MSetIterator m=matches.Begin();
//Выводим результат поиска
while (m!=matches.End())
{
Write(String.Format("{0}: {1}% docid={2} [{3}]\n",
m.GetRank()+1,
m.GetPercent(),
m.GetDocId(),
m.GetDocument().GetData()));
++m;
}
}
}
}
}
}
}
catch (Exception ex)
{
Write("Exception: "+ex.ToString());
}
}
```
Функцию Write напишите на свой вкус.
Теперь создаем каталог с текстовыми файлами, или используем имеющийся, вызываем IndexFolder(имя\_каталога), ждем пока файлы проиндексируются. И можем вызывать Search, передавая строку с ключевыми словами для поиска, разделенных пробелом.
##### Тестирование.
Конфигурация железа:
Intel Pentium III 996Mhz
Ram 256Mb
Количество индексируемых файлов: 641489
Объем индексируемых файлов: 2,38Gb
Время индексирования файлов: больше недели(помним о железе, на 4x Core операция займет, скорее всего, несколько часов, своп соответственно тоже снижает производительность в разы).
Нагрузка во время индексирования
Таблица среднего времени поиска
| | | |
| --- | --- | --- |
| Количество слов | Поиск | Время |
| 1 | 1 | 1883 мс. |
| 1 | 2 | 28 мс. |
| 1 | 3 | 31 мс. |
| 2 | 1 | 175 мс. |
| 2 | 2 | 36 мс. |
| 2 | 3 | 41 мс. |
| 3 | 1 | 1074 мс. |
| 3 | 2 | 35 мс. |
| 3 | 3 | 37 мс. |
Показатели весьма оптимистичные, особенно для такой слабой машины.
Источники:
[Статья на codeproject'е](http://www.codeproject.com/KB/library/XapianUnderWindows.aspx)
[Официальный сайт](http://xapian.org/) | https://habr.com/ru/post/113381/ | null | ru | null |
# По просьбе читателей, проверяем код LDAP-сервера ReOpenLDAP
В этой статье я хочу рассказать о проверке проекта ReOpenLDAP. Этот проект был реализован для решения проблем, возникших при эксплуатации OpenLDAP в инфраструктуре ПАО МегаФон — крупнейшего в России оператора мобильной связи. Сейчас ReOpenLDAP успешно работает в филиалах МегаФон по всей России, поэтому было бы интересно проверить столь высоконагруженный проект при помощи статического анализатора PVS-Studio.
Введение
--------
[ReOpenLDAP](https://github.com/reopen/reopenldap), также известный как «TelcoLDAP» — это форк проекта [OpenLDAP](http://www.openldap.org/), созданный российскими разработчиками для применения в телекоммуникационной индустрии, с исправлением массы ошибок и работающей репликацией в мульти-мастер топологии. ReOpenLDAP является открытой реализацией сервера протокола [LDAP](https://en.wikipedia.org/wiki/lightweight_directory_access_protocol) на языке C.
ReOpenLDAP обеспечивает высокий уровень производительности:
* Более 50 тысяч LDAP-изменений в секунду
* Более 100 тысяч LDAP-запросов в секунду
Стоит отметить, что в наследство от OpenLDAP проект ReOpenLDAP получил 3185 операторов *goto*, которые в значительной мере затрудняют анализ, но даже несмотря на это было найдено некоторое количество ошибок.
Прошу записываться на тестирование Beta-версии PVS-Studio под Linux
-------------------------------------------------------------------
Написание этой статьи стало возможным благодаря началу работ над созданием PVS-Studio for Linux. Именно в Linux мы проверяли проект ReOpenLDAP. Однако есть угроза, что Linux-версия закончит своё существование ещё до своего выхода в свет. Причина — мало практического интереса. Когда идёт какое-то обсуждение на форуме, то кажется, что самая большая проблема продукта PVS-Studio — это отсутствие версии для Linux. Но когда дело дошло до сбора контактов людей, готовых поучаствовать в тестировании Beta-версии, то оказалось, что их совсем мало. Примечание: мы писали о поиске энтузиастов в статье "[PVS-Studio признаётся в любви к Linux](http://www.viva64.com/ru/b/0415/)".
Хочу отметить: мы не переживаем о тестировании PVS-Studio. Некоторые почему-то решили, что мы задумали всё это, чтобы программисты бесплатно поработали для нас как тестировщики. Конечно, дело совсем не в этом: организовать тестирование мы способны собственными силами. Однако, если откликнется всего несколько человек, то, возможно, вообще стоит снизить темп или даже приостановить работу в этом направлении. И, к сожалению, откликнувшихся действительно очень мало. Поэтому у нашего единорога просьба ко всем Linux-программистам.
Просим вступить вас в ряды Beta-тестеров PVS-Studio для Linux. Это покажет, что к инструменту есть практический интерес. Ещё раз напишу, как можно вступить в ряды энтузиастов.
Если вы хотите помочь нам проверить работу PVS-Studio для Linux, прошу написать нам. Чтобы письма можно было проще обрабатывать, просим указать в теме письма строчку «PVS-Studio for Linux, Beta». Письма отправляйте по адресу *[email protected]*. Просим писать письма с корпоративных ящиков и кратко представиться. Мы будем благодарны всем, кто откликнется, но в первую очередь мы будем учитывать пожелания и рекомендации тех людей, которые потенциально со временем могут стать нашими клиентами.
Также прошу в письме дать ответы на следующие вопросы:
* Под какой операционной системой планируется запускать анализатор?
* Какую среду разработки вы используете?
* Какой компилятор используется для сборки проекта?
* Какую сборочную систему вы используете?
Когда появится версия, которую можно будет попробовать, мы напишем всем откликнувшимся письма. Заранее всем спасибо.
Результаты проверки
-------------------
### Ошибка в приоритете операций
**Предупреждение PVS-Studio:** [V593](http://www.viva64.com/ru/d/0197/) Consider reviewing the expression of the 'A = B == C' kind. The expression is calculated as following: 'A = (B == C)'. mdb\_dump.c 150
```
static int dumpit(....)
{
....
while ((rc = mdb_cursor_get(...) == MDB_SUCCESS)) {
....
}
....
}
```
Автор ошибся с расположением закрывающейся круглой скобки в условии цикла *while*, что привело к ошибке в приоритете операций. В результате сначала выполняется сравнение, а затем результат этого сравнения записывается в переменную *rc*.
Данный код следует исправить так:
```
while ((rc = mdb_cursor_get(...)) == MDB_SUCCESS) {
....
}
```
### Работа с нулевым указателем
**Предупреждение PVS-Studio:** [V595](http://www.viva64.com/ru/d/0205/) The 'key' pointer was utilized before it was verified against nullptr. Check lines: 1324, 1327. mdb.c 1324
```
char *
mdb_dkey(MDB_val *key, char *buf)
{
....
unsigned char *c = key->mv_data; // <=
....
if (!key) // <=
return "";
....
}
```
В блоке *if* происходит проверка указателя *key* на *NULL*, следовательно, автором допускается возможность равенства этого указателя нулю, однако выше указатель уже используется без проверки. Чтобы избежать ошибки, следует проверить значение указателя *key* до того, как его использовать.
Аналогичное предупреждение:
* V595 The 'key' pointer was utilized before it was verified against nullptr. Check lines: 7282, 7291. mdb.c 7282
### Подозрительный тернарный оператор
**Предупреждение PVS-Studio:** [V583](http://www.viva64.com/ru/d/0186/) The '?:' operator, regardless of its conditional expression, always returns one and the same value: «vlvResult». common.c 2119
```
static int
print_vlv(....)
{
....
tool_write_ldif( ldif ? LDIF_PUT_COMMENT : LDIF_PUT_VALUE,
ldif ? "vlvResult" : "vlvResult", buf, rc ); // <=
}
....
}
```
При использовании указанного тернарного оператора будет возвращено одно и то же значение, вне зависимости от условия. Судя по аналогичным местам в исходниках, имеет место опечатка, и данный код следовало бы переписать так:
```
....
tool_write_ldif( ldif ? LDIF_PUT_COMMENT : LDIF_PUT_VALUE,
ldif ? "vlvResult: " : "vlvResult", buf, rc );
....
```
### Вероятная опечатка в имени поля
**Предупреждение PVS-Studio:** [V571](http://www.viva64.com/ru/d/0169/) Recurring check. The 'if (s->state.r == 0)' condition was already verified in line 147. rurwl.c 148
```
void rurw_r_unlock(....) {
....
if (s->state.r == 0) { // <=
if (s->state.r == 0) // <=
s->thr = 0;
p->rurw_readers -= 1;
}
....
}
```
Здесь производится проверка одного и того же условия дважды. Если обратить внимание на аналогичные места в исходниках, например:
```
void rurw_w_unlock(....) {
....
if (s->state.w == 0) {
if (s->state.r == 0)
s->thr = 0;
p->rurw_writer = 0;
}
....
}
```
то можно предположить, что в одном из условий имелась в виду проверка s->state.w == 0. Однако, это лишь предположение, но в любом случае, разработчикам следует проверить этот участок кода, и либо скорректировать одно из условий, либо удалить дублирующую проверку.
Аналогичное место:
* V571 Recurring check. The 'def->mrd\_usage & 0x0100U' condition was already verified in line 319. mr.c 322
### Перезапись параметра
**Предупреждение PVS-Studio:** [V763](http://www.viva64.com/ru/d/0520/print/) Parameter 'rc' is always rewritten in function body before being used. tls\_o.c 426
```
static char *
tlso_session_errmsg(...., int rc, ....)
{
char err[256] = "";
const char *certerr=NULL;
tlso_session *s = (tlso_session *)sess;
rc = ERR_peek_error(); // <=
....
}
```
В данной функции значение параметра *rc* всегда перезаписывается, прежде чем параметр используется. Вероятно, стоит убрать *rc* из списка параметров.
### Неверный спецификатор форматирования
**Предупреждение PVS-Studio:** [V576](http://www.viva64.com/ru/d/0176/) Incorrect format. Consider checking the fourth actual argument of the 'snprintf' function. The SIGNED argument of memsize type is expected. conn.c 309
```
struct Connection {
....
unsigned long c_connid;
....
}
....
static int
conn_create(....)
{
....
bv.bv_len = snprintf( buf, sizeof( buf ),
"cn=Connection %ld", // <=
c->c_connid );
....
}
```
Спецификатор форматирования "%ld" не соответствует передаваемому в *snprintf* аргументу *c->c\_connid*. Правильным спецификатором для *unsigned long* является "%lu". Использование "%ld" вместо "%lu" приведет к выводу неверных значений, при достаточно больших аргументах.
Аналогичные предупреждения:
* V576 Incorrect format. Consider checking the third actual argument of the 'fprintf' function. The SIGNED integer type argument is expected. ure.c 1865
* V576 Incorrect format. Consider checking the third actual argument of the 'fprintf' function. The SIGNED argument of memsize type is expected. tools.c 211
* V576 Incorrect format. Consider checking the fourth actual argument of the 'fprintf' function. The UNSIGNED integer type argument is expected. mdb.c 1253
### Неразыменованный указатель
**Предупреждение PVS-Studio:** [V528](http://www.viva64.com/ru/d/0117/) It is odd that pointer to 'char' type is compared with the '\0' value. Probably meant: \*ludp->lud\_filter != '\0'. backend.c 1525
```
int
fe_acl_group(....)
{
....
if ( ludp->lud_filter != NULL &&
ludp->lud_filter != '\0') // <=
{
....
}
}
```
Автор кода хотел выявить ситуацию, когда указатель нулевой или строка пустая. Но забыл разыменовать указатель *ludp->lud\_filter*, поэтому указатель просто дважды проверится на равенство *NULL*.
Следует разыменовать указатель:
```
....
if ( ludp->lud_filter != NULL &&
*ludp->lud_filter != '\0')
....
```
Аналогичные неразыменованные указатели:
* V528 It is odd that pointer to 'char' type is compared with the '\0' value. Probably meant: \*(\* lsei)->lsei\_values[0] == '\0'. syntax.c 240
* V528 It is odd that pointer to 'char' type is compared with the '\0' value. Probably meant: \*(\* lsei)->lsei\_values[1] != '\0'. syntax.c 241
### Лишняя проверка
**Предупреждение PVS-Studio:** [V560](http://www.viva64.com/ru/d/0153/) A part of conditional expression is always true: !saveit. syncprov.c 1510
```
static void
syncprov_matchops( Operation *op, opcookie *opc, int saveit )
{
....
if ( saveit || op->o_tag == LDAP_REQ_ADD ) {
....
} else if ( op->o_tag == LDAP_REQ_MODRDN && !saveit ) {
....
}
....
}
```
В ветке *else* нет смысла проверять *saveit* на равенство нулю, т.к. это уже было сделано в первом условии. Это ухудшает читабельность. И, возможно, это даже ошибка, так как предполагалось проверить что-то ещё.
Но скорее всего код достаточно упростить:
```
if ( saveit || op->o_tag == LDAP_REQ_ADD ) {
....
} else if ( op->o_tag == LDAP_REQ_MODRDN ) {
....
}
```
### Опасное использование realloc
**Предупреждение PVS-Studio:** [V701](http://www.viva64.com/ru/d/0340/) realloc() possible leak: when realloc() fails in allocating memory, original pointer 'lud.lud\_exts' is lost. Consider assigning realloc() to a temporary pointer. ldapurl.c 306
```
int
main( int argc, char *argv[])
{
....
lud.lud_exts = (char **)realloc( lud.lud_exts,
sizeof( char * ) * ( nexts + 2 ) );
....
}
```
Выражение вида *foo = realloc(foo, ....)* является потенциально опасным. При невозможности выделения памяти *realloc* вернет нулевой указатель, перезаписав предыдущее значение указателя. Чтобы предотвратить это, рекомендуется сохранять значение указателя в дополнительной переменной перед использованием *realloc*.
### Перезапись значения
**Предупреждение PVS-Studio:** [V519](http://www.viva64.com/ru/d/0108/) The 'ca.argv' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 7774, 7776. bconfig.c 7776
```
int
config_back_initialize( BackendInfo *bi )
{
....
ca.argv = argv; // <=
argv[ 0 ] = "slapd";
ca.argv = argv; // <=
ca.argc = 3;
ca.fname = argv[0];
....
}
```
Если данный код корректен, то следует удалить первое лишнее присваивание.
Заключение
----------
ReOpenLDAP является проектом, призванным обеспечить стабильную работу под высокой нагрузкой. Поэтому разработчики ответственно подходят к тестированию и используют специализированные инструменты такие как [ThreadSanitizer](http://clang.llvm.org/docs/threadsanitizer.html) и [Valgrind](http://valgrind.org/). Однако, как мы видим, этого не всегда достаточно, так как при помощи PVS-Studio был выявлен ряд ошибок, хотя их и мало.
Статический анализ помогает находить ошибки еще до этапа тестирования — на самых ранних этапах, сэкономив тем самым много времени. Поэтому анализаторы следует использовать регулярно, а не как мы, от случая к случаю, демонстрируя возможности нашего инструмента PVS-Studio.
Предлагаю [скачать](http://www.viva64.com/ru/pvs-studio-download/) и попробовать статический анализатор PVS-Studio на своем собственном проекте.
[](http://www.viva64.com/en/b/0422/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Egor Bredikhin. [Checking the Code of LDAP-Server ReOpenLDAP on Our Readers' Request](http://www.viva64.com/en/b/0422/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/308212/ | null | ru | null |
# Свой сервис отложенного постинга и почти без кода
Если вы владеете Telegram-каналом (или несколькими), раскрученным аккаунтом в Instagram или любой другой социальной сети, то уже наверняка задавались вопросом: **А как мне планировать посты заранее?** Существует очень много разных сервисов, которые решают эту задачу. Но по тем или иным причинам они могут не подходить: где-то цена большая, где-то функционал беден, а где-то вообще страшно оставлять логин-пароль от своего раскрученного аккаунта. Сегодня я расскажу и покажу как на основе нашей платформы для разработки бизнес приложений с открытым кодом [Orienteer](https://orienteer.org) сделать свой собственный сервис буквально за 60 минут! Заинтересовал? Проваливаемся под кат.
Для простоты мы сделаем отложенный постинг в Telegram, но полученные навыки помогут вам расширить функционал и на другие социальные сети, а так же адаптировать планирование и публикацию именно под себя, например, добавить возможность поста одного и того же сообщения в разные каналы, или удалять посты после какого-то времени и т.д. Если будут вопросы: обращайтесь в личку!
Шаг 1: Запускаем Orienteer
--------------------------
Нам понадобится docker, а еще лучше вместе с docker-compose. Можно его использовать как на локальном компьютере, так и на любом доступном хостинге, включая AWS или DigitalOcean. Если не знакомы с docker, то крайне рекомендую потратить 3-5 часов своей жизни и изучить основы. Хабр, medium или даже первоисточник вам в помощь.
Запускаем сам Orienteer, например вот так:
```
docker run -p 8080:8080 orienteer/orienteer
```
Но чтобы не потерять базу данных при обновлении контейнера и обезопасить от проникновения под стандартными паролями можно усложнить запуск следующим образом:
```
docker run -p 8080:8080 -v :/app/runtime -e ORIENTDB\_ADMIN\_PASSWORD= -e ORIENTDB\_GUEST\_PASSWORD= orienteer/orienteer
```
Если же вы любите docker-compose, то вот вам шаблон для старта:
```
version: '2.1'
services:
orienteer:
image: orienteer/orienteer:latest
container_name: my_posting_service
network_mode: 'bridge'
ports:
- "8080:8080"
volumes:
- ./runtime:/app/runtime
- ./maven-repository:/app/repository
environment:
- ORIENTDB_ADMIN_PASSWORD=
- ORIENTDB\_GUEST\_PASSWORD=
- JAVA\_TOOL\_OPTIONS= -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/app/runtime/heapdump.bin
```
Если вы всё сделали правильно, то при открытии [localhost](http://localhost):8080 вы должны увидеть что-то вроде снимка ниже. Да, по умолчанию вы попадаете в Orienteer как пользователь `reader`, который умеет всё читать, но не изменять. Права у reader'а можно позже отнять, чтобы backend могли видеть только пользователи, вошедшие в систему.
Кликаем на правый верхний угол и входим в систему как `admin` (по умолчанию пароль тоже `admin`).
Шаг 2: Подключаем необходимые модули и зависимости
--------------------------------------------------
Для того чтобы превратить Orienteer в сервис по отложенному постингу нам понадобится:
* [**java-telegram-bot-api**](https://github.com/pengrad/java-telegram-bot-api) — простая java библиотека для работы с Telegram
* **orienteer-architect** — модуль для проектирования предметной области
* **orienteer-devutils** — модуль для удобного отлаживания скриптов
После разработки, последние 2 модуля, кстати, можно будет отключить.
Идем на страницу **Schema**, затем на вкладку **Artifacts**. Нажимаем **Add**. Для добавления библиотеки **java-telegram-bot-api** вводим все так же, как если бы подключали обычную Java библиотеку:
```
com.github.pengrad
java-telegram-bot-api
5.0.0
```
Должно получиться вот так:
А чтобы добавить 2 последних модуля, нажимаем вновь **Add**, а затем на кнопку **Available Orienteer Modules**. После загрузки списка выбираем нужный модуль и нажимаем **Install as Trusted**. После добавления всех нужных зависимостей жмем оранжевую кнопку **Reload Orienteer**. После перезагрузки можем двигаться дальше.
Шаг 3: Моделируем нашу предметную область
-----------------------------------------
Считаю, что лучший способ разработки — это разработка по спирали. И первая спираль — это наиболее простое решение, которое дает нужный нам эффект. А на следующих спиралях можно усложнять разработанное решение так как нужно, добавляя гибкости и т.д.
Давайте так и сделаем. В простом варианте нам нужно будет лишь 3 вида сущностей:
* **Контент *(или пост)*** — то что мы собираемся послать в нужный канал в определенное время
* **Канал** — то куда мы собираемся послать наш контент
* **Бот** — сущность, осуществляющая посылку контента
Прошу обратить внимание, что в этой предметной области нет специфики Telegram. Под каналом может подразумеваться аккаунт Instagram или Вконтакте. Вся специфика будет скрываться под **Ботом**, — сущностью осуществляющей саму посылку: а именно, в скриптах, которые мы проассоциируем с сущностью **Бот**.
Для моделирования предметной области рекомендую использовать модуль **orienteer-architect**. Идем в **ODataModel** по кнопке **Browse**, нажимаем **Create**, вписываем `Scheduler Data Model` в поле **Name** и нажимаем **Save**. А дальше чистое творчество! Но думаю, в конце у вас должно получиться что-то вроде данной картинки:
Рекомендую после сохранения и применения вашей предметной области (кнопки **Save Data Model** и **Apply Changes**) пройтись по созданным классам и их полям и доконфигурировать для большего комфорта такие вещи, как:
* Поле определяющее имя документа (Document Name Property)
* Поле определяющее ссылку на документ более высокого уровня (Parent Document Property) — влияет на строчку навигации
* Тип визуализации (Visualization) — как именно отображать значения
Шаг 4: Оживляем наш сервис скриптами
------------------------------------
Нам понадобится всего 2 скрипта.
1. Scheduler — скрипт, который по запуску каждую минуту будет искать следующую порцию сообщений на отправку, находить по ссылке конкретный скрипт по отправке сообщения и вызывать его, передавая сообщение, которое надо отправить, как аргумент
2. SendToTelegram — скрипт, который получает сообщение как аргумент и, используя Telegram API, отправляет его в нужный канал или чат
Скрипты в Orienteer (и OrientDb) — это объекты класса OFunction. Соответственно, вам надо будет создать объект данного класса с нужным именем, кодом и языком, на котором последний написан. Я рекомендую указывать **nashorn** — это Java реализация языка JavaScript.
Не буду сильно томить объяснениями: Лучше один раз увидеть код, чем 100 раз его обсудить.
#### Scheduler
```
var db = orient.getDatabase(); //Получаем базу данных OrientDB
var resultSet = db.query("select from SContent where published!=true and when < sysdate()"); //Запрашиваем все сообщения, которые еще не опубликованы, но ожидаемая дата публикации уже в прошлом
for(var i in resultSet) { //Итерируемся по результатам
var content = resultSet[i]; //Очередное сообщение на отправку
var sendFunction = content.field("channel.bot.sendFunction.name"); //Через цепочку ссылок получаем имя скрипта, который ответстеннен за отправку
if(sendFunction) {
db.getMetadata().getFunctionLibrary().getFunction(sendFunction).execute(content); //Вызываем функцию по имени и передаем наше сообщение на отправку как аргумент
content.field("published", true); //Помечаем наше сообщение как отправленное
content.save(); //Сохраняем
}
}
```
Как видно, скрипт очень простой, и в нем нет никакой специфики Telegram: все скрыто в скрипте, который мы указываем при конфигурации бота.
#### SendToTelegram
Помните, мы раньше подключили библиотеку [**java-telegram-bot-api**](https://github.com/pengrad/java-telegram-bot-api)? Теперь самое время её задействовать для посылки сообщения в Telegram!
```
var content = orient.getDatabase().load(content); //На случай, если в качестве аргумента пришла ссылка, а не сам объект, подгружаем объект из базы
var channel = content.field("channel"); //Получаем наш канал (или чат), куда будем отправлять сообщение
var botDoc = channel.field("bot");//Получаем документ с конфигурацией бота. Именно с этого документа ранее мы считали "sendFunction" - скрипт по отсылке сообщения
var botKey = "Bot"+botDoc.getIdentity(); //Генерируем уникальный ключ для сохранения в окружении TelegramBot
var app = org.orienteer.core.OrienteerWebApplication.lookupApplication(); //Находим Orienteer Web Application как Java объект
var bot = app.getMetaData(botKey); //Пытаемся получить бота по ключу
if(!bot) { //Если бот не найдет - инициализируем его
bot = new com.pengrad.telegrambot.TelegramBot(botDoc.field("token")); //Создаем объект TelegramBot и передаем ему token нужный для работы
app.setMetaData(botKey, bot); //Сохраняем бота под Orienteer Web Application, чтобы следующий раз не создавать его заново
}
bot.execute(new com.pengrad.telegrambot.request.SendMessage(channel.field("chatId"), content.field("content"))); //Отсылаем сообщение, передавая в API само сообщение и chatId
```
Но как же нам вызывать скрипт **Scheduler** каждую минуту? Для этого в Orienteer (и OrientDB) используются объекты класса **OSchedule**. Создаем объект данного класса, указываем произвольное имя, выбираем наш скрипт **Scheduler** в поле **Function**, а затем указываем следующее значние в поле Rule: `0 \* \* \* \* ?`. Данная запись означает вызов скрипта в нулевую секунду каждой минуты, каждого часа и т.д.
Шаг 5: Тестируем наше творение
------------------------------
А теперь самое интересное! Приступаем к тестам.
### Создаем бота
Нам надо создать самого бота в Telegram, а затем сконфигурировать объект бота с его конфигурацией в Orienteer.
Как создать бота в Telegram и получить token для него можно почитать [здесь](https://core.telegram.org/bots#6-botfather). Если коротко:
1. Связываемся с [BotFather](https://t.me/botfather)
2. Посылаем команду /newbot
3. Указываем отображаемое имя для бота
4. Указываем имя пользователя для бота
Как результат мы получаем **token**. Рекомендую добавить созданного бота к себе в список контактов, так как нам надо будет добавить его в нужные каналы и группы.
Далее идем в наш Orienteer и создаем документ класса **SBot**, который мы смоделировали прежде в шаге №3. Указываем имя, ссылку на наш скрипт **SendToTelegram** и непосредственно **token**, который мы получили из общения с **BotFather** прежде.
### Создаем канал
Я предполагаю, что в Telegram у вас уже создан канал или чат. Если нет, то уверен, что вы с легкостью справитесь с этим. Для того чтобы правильно сконфигурировать канал в Orienteer, нам понадобится так называемый **chatId**. Проще всего это сделать с помощью бота [GetIDs Bot](https://t.me/getidsbot). Если вы настраиваете своего бота для канала, то просто перешлите ему любое сообщение из канала. А если для группы, то добавьте данного бота в группу и первым сообщением он вам выдаст **ChatId**, затем его можно из группы удалить.
Если вы всё сделали правильно, то у вас есть **ChatId**, и всё, что осталось сделать, это пойти в Orienteer, создать объект из нашей предметной области **SChannel**, указать имя и данный **ChatId**. Ну и не забываем добавить Telegram бота в канал или чат, а так же указать ссылку на бота в Orienteer, который мы уже сконфигурировали.
### Создаем сообщения
А теперь момент истины: создаём сообщения и тестируем их появление в канале или группе. Для сообщений мы уже создали класс **SContent**. В объекте этого класса указываем название (не публикуется в Telegram), ссылку на желаемый канал или чат, время публикации, ну и, собственно, само сообщение.
Если все сделали правильно, то в обозначенное время сообщение будет послано.
Ура! Нашим сервисом можно пользоваться!
На этом на сегодня всё!
Если вам нравятся наши статьи, то дайте, пожалуйста, нам знать об этом плюсом или комментарием.
P.S. Если что-то не получилось по данной инструкции или же хотите воспользоваться уже сконфигуренным Orienteer'ом, то пишите нам: либо здесь, либо в [Telegram](https://telegram.me/OrienteerBAP).
P.P.S. Нам в проект [Orienteer](https://orienteer.org) нужны люди! Даже если вы только учитесь и еще толком не погрузились в Java или JavaScript, но хотели бы поучаствовать — то ничего страшного — пишите! А мы научим! | https://habr.com/ru/post/530388/ | null | ru | null |
# Как увеличить скорость реакции Kubernetes на отказ узлов кластера?
Kubernetes спроектирован так, чтобы быть надежным и устойчивым к сбоям, а также иметь возможность автоматически восстанавливаться. И он отлично справляется со всем этим! Однако рабочие узлы могут по разным причинам терять подключение к кластеру или выходить из строя. В этих случаях необходимо, чтобы Kubernetes быстро среагировал на инцидент.
Когда узел выходит из строя, pods сломанного узла все еще работают в течение некоторого времени. При этом они продолжают получать запросы, и эти запросы фейлятся. Скорее всего, совсем не то поведение, которое вы ожидали от Kubernetes, верно?
Чтобы разобраться, как Kubernetes реагирует на выход узла из строя, сначала рассмотрим взаимодействие между Kubelet и Controller Manager:
1. *Kubelet* периодически уведомляет *kube-apiserver* о своём статусе с интервалом, заданным в параметре `--node-status-update-frequency`. Значение по умолчанию **10 секунд**.
2. *Controller manager* проверяет статус Kubelet каждые `–-node-monitor-period`. Значение по умолчанию **5 секунд**.
3. Если от *Kubelet* получена информация в пределах `--node-monitor-grace-period`, *Controller manager* считает *Kubelet* исправным. Значение [по умолчанию](https://github.com/kubernetes/kubernetes/blob/release-1.21/pkg/controller/nodelifecycle/config/v1alpha1/defaults.go#L42) **40 секунд**.
В случае отказа узла кластера происходит следующий алгоритм:
1. *Kubelet* отправляет свой статус *kube-apiserver*, используя - `node-status-update-frequency` = **10 сек**.
2. Узел выходит из строя.
3. *Controller manager* будет пытаться проверять статус узла, сообщаемый *Kubelet*, каждые `--node-monitor-period` = **5 сек**.
4. *Controller manager* увидит, что узел не отвечает, и даст ему тайм-аут `--node-monitor-grace-period` в **40 сек**. Если за это время *Controller manager* не сочтет узел исправным, он установит статус NotReady.
5. *Kube Proxy* удалит *endpoints*, указывающие на *pods* внутри этого узла из всех сервисов, поэтому *pods* сбойного узла больше не будут доступны.
В этом сценарии будет возможны ошибки при обращении в pods, работающим на этом узле, потому что модули будут продолжать получать трафик до тех пор, пока узел не будет считаться неработающим (*NotReady)* через **45** сек.
Есть множество параметров для настройки в Kubelet и Controller Manager.
Быстрое обновление и быстрая реакция
------------------------------------
Чтобы увеличить скорость реакции Kubernetes на отказ узлов кластера, вы можете изменить эти параметры:
`-–node-status-update-frequency` установить значение **1 сек** (по умолчанию **10 сек**)
`--node-monitor-period` установить значение **1 сек** (по умолчанию **5 сек** )
`--node-monitor-grace-period` установить значение **4 сек** (по умолчанию **40 сек**)
Протестируем изменения
----------------------
Чтобы проверить изменения в тестовой среде, мы можем создать кластер Kubernetes с помощью [Kind](https://kind.sigs.k8s.io/) или любого другого инструмента. Мы создали конфигурационный файл для Kind Cluster с параметрами, указанными в предыдущем разделе, чтобы протестировать поведение кластера.
```
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
kubeadmConfigPatches:
- |
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
nodeStatusUpdateFrequency: 1s
nodes:
- role: control-plane
kubeadmConfigPatches:
- |
kind: ClusterConfiguration
controllerManager:
extraArgs:
node-monitor-period: 1s
node-monitor-grace-period: 4s
- role: worker
```
Затем мы устанавливаем deployment с двумя репликами Nginx, размещенными в *control-plane* и на *worker*. Также мы дополнительно создали на *control-plane* *pod* с Ubuntu, чтобы проверить доступность Nginx, когда *worker* станет недоступен.
```
#!/bin/bash
# create a K8S cluster with Kind
kind create cluster --config kind.yaml
# create a Ubuntu pod in control-plane Node
kubectl run ubuntu --wait=true --image ubuntu --overrides='{"spec": { "nodeName": "kind-control-plane"}}' sleep 30d
# untaint control-plane node in order to schedule pods on it
kubectl taint node kind-control-plane node-role.kubernetes.io/master-
# create Nginx deployment with 2 replicas, one on each node
kubectl create deploy ng --image nginx
sleep 30
kubectl scale deployment ng --replicas 2
# expose Nginx deployment so that is reachable on port 80
kubectl expose deploy ng --port 80 --type ClusterIP
# install curl in Ubuntu pod
kubectl exec ubuntu -- bash -c "apt update && apt install -y curl"
```
Чтобы проверить доступность Nginx, мы обратились к сервису с помощью curl из *pod* с Ubuntu, размещенного в *control-plane*, а также наблюдали за *endpoints*, принадлежащими сервису Nginx из терминала.
```
# test Nginx service access from Ubuntu pod
kubectl exec ubuntu -- bash -c 'while true ; do echo "$(date +"%T.%3N") - Status: $(curl -s -o /dev/null -w "%{http_code}" -m 0.2 -i ng)" ; done'
# show Nginx service endpoints
while true; do gdate +"%T.%3N"; kubectl get endpoints ng -o json | jq '.subsets' | jq '.[] | .addresses' | jq '.[] | .nodeName'; echo "------";done
```
Наконец, чтобы смоделировать сбой узла, мы остановили контейнер Kind, в котором запущен рабочий узел. Мы также добавили отметки времени, чтобы узнать когда узел был отключен и когда узел был обнаружен как *NotReady*.
```
#!/bin/bash
# kill Kind worker node
echo "Worker down at $(gdate +"%T.%3N")"
docker stop kind-worker > /dev/null
sleep 15
# show when the node was detected to be down
echo "Worker detected in down state by Control Plane at "
kubectl get event --field-selector reason=NodeNotReady --sort-by='.lastTimestamp' -oyaml | grep time | tail -n1
# start worker node again
docker start kind-worker > /dev/null
```
После запуска теста мы заметили, что узел отключился в 12:50:22, а *Controller manager* обнаружил, что он отключился в 12:50:26, что и следовало ожидать через 4 секунды.
```
Worker down at 12:50:22.285
Worker detected in down state by Control Plane at
time: "12:50:26Z"
```
Аналогичный результат при тестировании с терминала. Служба начала возвращать сообщения об ошибках в 12:50:23, потому что трафик был направлен на отказавший узел. А в 12:50:26.744 *Kube Proxy* удалил *endpoint*, указывающую на отказавший узел, и доступность службы была полностью восстановлена.
```
...
12:50:23.115 - Status: 200
12:50:23.141 - Status: 200
12:50:23.161 - Status: 200
12:50:23.190 - Status: 000
12:50:23.245 - Status: 200
12:50:23.269 - Status: 200
12:50:23.291 - Status: 000
12:50:23.503 - Status: 200
12:50:23.520 - Status: 000
12:50:23.738 - Status: 000
12:50:23.954 - Status: 000
12:50:24.166 - Status: 000
12:50:24.385 - Status: 200
12:50:24.407 - Status: 000
12:50:24.623 - Status: 000
12:50:24.839 - Status: 000
12:50:25.053 - Status: 000
12:50:25.276 - Status: 200
12:50:25.294 - Status: 000
12:50:25.509 - Status: 200
12:50:25.525 - Status: 200
12:50:25.541 - Status: 200
12:50:25.556 - Status: 200
12:50:25.575 - Status: 000
12:50:25.793 - Status: 200
12:50:25.809 - Status: 200
12:50:25.826 - Status: 200
12:50:25.847 - Status: 200
12:50:25.867 - Status: 200
12:50:25.890 - Status: 000
12:50:26.110 - Status: 000
12:50:26.325 - Status: 000
12:50:26.549 - Status: 000
12:50:26.604 - Status: 200
12:50:26.669 - Status: 000
12:50:27.108 - Status: 200
12:50:27.135 - Status: 200
12:50:27.162 - Status: 200
12:50:27.188 - Status: 200
...
...
------
12:50:26.523
"kind-control-plane"
"kind-worker"
------
12:50:26.618
"kind-control-plane"
"kind-worker"
------
12:50:26.744
"kind-control-plane"
------
12:50:26.878
"kind-control-plane"
------
...
```
Заключение
----------
Мы убедились, что скорость реакции Kubernetes на инцидент значительно возросла. Возможны разные комбинации параметров для конкретных случаев, и у вас может возникнуть соблазн снизить значения, чтобы система Kubernetes реагировала быстрее, но примите во внимание, что этот сценарий создает накладные расходы на *etcd*, поскольку каждый узел будет постоянно пытаться обновлять свой статус через 1 секунду. Например, если в кластере 1000 узлов, будет происходить 60000 обновлений узлов в минуту, что может потребовать увеличения ресурсов контейнеров *etcd* или даже выделенных узлов для *etcd*.
Кроме того, если вы установите значения параметров слишком маленькими, возникнут некоторые риски. Например, временный сбой сети на короткий период может привести к ложному срабатыванию. | https://habr.com/ru/post/561084/ | null | ru | null |
# Про аналитику и серебряные пули или «При чем здесь Рамблер/топ-100?»
Всем привет! Я тимлид проекта Рамблер/топ-100. Это лонгрид о том, как мы проектировали архитектуру обновлённого сервиса веб-аналитики, с какими сложностями столкнулись по пути и как с ними боролись. Если вам интересны такие базворды как [Clickhouse](https://clickhouse.yandex/), [Aerospike](http://www.aerospike.com/russian/), [Spark](http://spark.apache.org/), добро пожаловать под кат.
В прошлом году Рамблеру и Топ-100 исполнилось 20 лет – достаточно большой срок, за который на сервисе было несколько крупных обновлений и последнее из них случилось достаточно давно. Предыдущая версия Рамблер/топ-100 морально устарела, с точки зрения интерфейсов, кода и архитектуры. Планируя перезапуск, мы отдавали себе отчёт в том, что косметическим ремонтом не обойтись – нам надо было выстроить новый сервис практически с нуля.
### Поиски решения
Вернёмся ненадолго в прошлое, в начало 2016 года, когда были определены состав перезапуска Рамблер/топ-100 и намечена дата релиза. К перезапуску мы должны были повторить функционал предыдущей версии Топ-100, а также дополнить сервис несколькими новыми отчётами о поведении посетителей, нужных для решения аналитических задач сервисов Rambler&Co.
На тот момент у нас было понимание, как выстроить архитектуру с батч-обсчётами раз в сутки. Архитектура была простая как три копейки: ночью запускается набор Hive-скриптов, читает сырые логи, генерирует по ним предопределенный набор агрегатов за предыдущий день и заливает это все в HBase.
Прекрасно понимая, что статистика на утро следующего дня, это буквально вчерашний день, мы искали и исследовали различные варианты систем, которые позволят обеспечить доступность данных для аналитики с небольшим интервалом (5-10 минут и меньше). Чтобы достичь этого, необходимо было решить целый ряд проблем:
* обсчёт постоянно дополняющихся данных в близком к реальному времени;
* склеивание целевых событий с просмотрами страниц и сессиями;
* обработка запросов с произвольной сегментацией данных;
* все вышеперечисленное нужно делать быстро и держать много одновременных запросов.
Давайте подробнее рассмотрим каждую проблему.
Данные от пользователей приходят постоянно, и они должны быть доступны как можно быстрее. Значит, движок базы данных должен быстро вставлять данные, и они должны быть сразу доступны для запросов. Есть необходимость считать сессии пользователей, которые сильно выходят за временные рамки одного [микро-батча](https://databricks.com/blog/2015/07/30/diving-into-apache-spark-streamings-execution-model.html). То есть нам нужен механизм хранения сессий, а сами данные должны заливаться в базу не в конце пользовательской сессии, а по мере поступления событий. При этом база должна уметь группировать эти данные по сессиям и просмотрам страниц. Важно также, чтобы движок базы данных обеспечивал возможность склейки и изменения сущностей после записи (например, в рамках сессии произошло целевое событие, пользователь кликнул на какой-то блок).
Бывают ситуации, в которых необходимо быстро делать агрегирующие запросы с заданной пользователем сегментацией. Например, пользователь аналитики хочет узнать, сколько людей заходят с IE6 из Удмуртии, мы должны это посчитать и показать. Это значит, что база должна позволять хранение достаточно слабоагрегированных или вовсе не агрегированных сущностей, а отчёты по ним должны строиться на лету. Учитывая общий объём данных, необходим механизм сэмплирования (построения выборки и обсчёта данных из этой выборки вместо обсчёта по всей совокупности).
При этом нельзя забывать о росте объёма данных в будущем: архитектура должна держать нашу нагрузку на старте и горизонтально масштабироваться. Нагрузка на момент проектирования архитектуры – 1.5-2TB сырых логов и 700 млн — 1 млрд событий в день. Дополнительно очень важно, чтобы база хорошо сжимала данные.
Просмотрев кучу статей, документации, поговорив с ушлыми продажниками и пересмотрев пару десятков докладов с разных BigData конференций, мы пришли к не слишком радостному выводу. На тот момент на рынке были три удовлетворяющие нашим требованиям системы: Druid, HP Vertica и Kudu + Impala.
Druid был opensource’ный и по отзывам достаточно шустрый, но очень сырой. Vertica подходила по всем параметрам и была гораздо круче друида в плане функционала, но стоимость базы на наших объемах данных была неподъемная. Про Kudu + Impala нашли очень мало информации, использовать в продакшене проект с таким кол-вом документации страшновато.
Ещё один ограничивающий фактор – время. Мы не могли позволить себе несколько лет разрабатывать новую систему: нас бы не дождались существующие пользователи Топ-100. Действовать надо было быстро.
Приняв во внимание все вводные, приняли решение делать перезапуск сервиса в два этапа. Сначала реализуем функционал старых отчетов на батч-архитектуре, стараемся по максимуму избежать деградации функционала и добавляем несколько критичных для внутренних заказчиков новых возможностей. Параллельно активно ищем решения, которые позволят обсчитывать данные и показывать их в интерфейсе в близком к реальному времени.
### Новая архитектура или «вот это поворот!»
Время шло, дата перезапуска приближалась, Druid и Kudu медленно обзаводились документацией, Vertica не собиралась дешеветь. Мы практически решились делать монстра из комбинации Druid'а и батч-обсчета, когда ВНЕЗАПНО Яндекс выложил в opensource Сlickhouse.
Естественно, мы обратили внимание на новую возможность – на первый взгляд она идеально решала нашу задачу. Внимательно изучив документацию, поговорив со знакомыми из Яндекса и проведя нагрузочные тесты, мы пришли к выводу, что будем рассматривать Clickhouse в качестве основного варианта для второго этапа обновления Топ-100.
В итоге у нас получилась следующая архитектура:
По порядку.
**Nginx** – принимает события от посетителей веб-страниц, передаваемые счётчиком, записывает их в очередь событий.
**Kafka** – очень быстрая очередь событий, с репликацией, умеющая работать сразу с несколькими клиентами.
**Spark-streaming** – выполняет обработку потоковых данных, python-реализация.
**Aerospike** - выступает качестве хранилища сессий выбрали именно Aerospike потому, что данных достаточно много (в среднем отметка держится на 250-300гб хранимых сессий), а у Aerospike достаточно хорошее соотношение стоимости железа к объему хранимых данных.
Почему именно Aerospike, ведь у Spark есть checkpoint (встроенный вариант хранения состояний объектов)? Дело в том, что документация по checkpoint’ам в Spark достаточно сырая и неинформативная. Например, не до конца понятно, как следить за истечением времени жизни сессий, а также количеством используемой памяти и диска для хранения чекпойнтов. Aerospike же из коробки умеет автоматически удалять истекшие сессии, его относительно легко мониторить и масштабировать.
**ClickHouse** – колоночная база данных и механизм построения отчетов в одном флаконе.
Немного подробнее о связке Spark + Aerospike + Clickhouse, чтобы не получилось, как на старой картинке.
События от посетителей читаются Spark’ом из Kafka, микро-батч включает 5 минут данных. Данные группируются по проектам и уникальным посетителям (кукам) внутри проектов. Для каждого посетителя проверяется, есть ли активная сессия в рамках данного проекта и, если есть, из этой сессии берутся данные для склейки с новыми данными. Сессии и данные сессий хранятся в Aerospike с некоторым временем жизни. После склейки сессий нам нужно сохранить их в Clickhouse. В этом нам идеально подходит движок [CollapsingMergeTree](https://clickhouse.yandex/docs/ru/single/#CollapsingMergeTree): когда к нам приходят новые данные, мы делаем в Clickhouse две записи – старую, если она есть, со знаком (-) и новую со знаком (+).
С посетителями разобрались, теперь подробнее про сессии. Для первого встреченного события от посетителя мы генерируем session\_id, сохраняем этот id и время последнего события в Aerospike. Всем дальнейшим событиям в рамках этой сессии присваивается этот id. Если промежуток времени между последним событием сессии из Aerospike и новым событием больше 30 минут, считаем это событие началом новой сессии, и всё начинается заново.
Такая архитектура решает все проблемы, описанные в начале статьи, достаточно легко масштабируется и тестируется.
Для проверки, что эта архитектура будет работать в реальности, держать нашу предполагаемую нагрузку и отвечать достаточно быстро, мы провели три теста:
* нагрузочное тестирование Clickhouse с сэмплом данных и предолагаемой схемой таблиц;
* нагрузочное тестирование связки Kafka-Aerospike-ClickHouse;
* проверили работающий прототип связки под продакшн нагрузкой.
Все тесты закончились успешно, мы обрадовались и приступили к реализации.
### Преодолевая трудности
В ходе реализации придуманной схемы мы, естественно, встретили некоторое количество граблей.
**Spark**
Иногда не слишком информативные логи, приходится копаться в исходниках и трейсбэках Spark на Scala. Нет восстановления с offset’ов в Kafka из коробки, пришлось писать свой велосипед. К тому же мы не нашли нормальный механизм graceful shutdown’а реалтайм обсчета, тоже пришлось писать свой велосипед (немного [информации](http://mkuthan.github.io/blog/2016/09/30/spark-streaming-on-yarn/) об этой проблеме).
**Aerospike**
Пока не было проблем, разве что для тестового неймспейса нужен отдельный раздел на жестком диске.
**Clickhouse**
Почти нет автоматизации DDL для кластера (например, чтобы сделать alter table на distributed таблице нужно зайти на все ноды и сделать на каждой ноде alter table). Много недокументированных функций — нужно лезть в код и разбираться или спрашивать напрямую у разработчиков CH. Слабо автомазизирована работа с репликами и шардами, партиционирование только по месяцам.
### It's alive, ALIVE!
Что получилось в результате. Схема базы.
```
CREATE TABLE IF NOT EXISTS page_views_shard(
project_id Uint32,
page_view_id String,
session_id String,
user_id String,
ts_start Float64,
ts_end Float64,
ua String,
page_url String,
referer String,
first_page_url String,
first_page_referrer String,
referer String,
dt Date,
sign Int8
) ENGINE=CollapsingMergeTree(
dt,
sipHash64(user_id),
(project_id, dt, sipHash64(user_id), sipHash64(session_id), page_view_id),
8192,
sign
);
```
Строкой в схеме базы данных является просмотр страницы со всеми ассоциированными с ним параметрами. (Схема намеренно упрощена, нет большого количества дополнительных параметров).
Разберем по порядку:
• dt – дата, обязательное требование для MergeTree таблиц;
• sipHash64(user\_id) – для поддержки сэмплирования;
• (project\_id, dt, sipHash64(user\_id), sipHash64(session\_id), page\_view\_id) – первичный ключ, по которому отсортированы данные и по которому производится схлопывание значений с разным sign;
• 8192 – гранулярность индекса;
• sign – описывал выше.
Примеры запросов для одного из проектов:
Количество просмотров страниц и сессий за месяц с группировкой по датам.
```
SELECT SUM(sign) as page_views, uniqCombined(session_id) as sessions, dt
FROM page_views
WHERE project_id = 1
GROUP BY dt
ORDER BY dt
WHERE dt >= '2017-02-01' AND dt <= '2017-02-28'
FORMAT JSON;
```
2-5 секунд на полных данных (127кк строк)
0.5 секунды на сэмпле 0.1
0.1 секунды на сэмпле 0.01
Посчитать все page\_views, visits с группировкой по части урл.
```
SELECT SUM(sign) as page_views, uniqCombined(session_id) as sessions, URLHierarchy(page)[1]
FROM page_views
GROUP BY URLHierarchy(page)[1]
ORDER BY page_views DESC
WHERE dt >= '2017-02-01' AND dt <= '2017-02-28' and project_id = 1
LIMIT 50
FORMAT JSON;
```
10 секунд на полных данных
3-5 секунд на сэмпле 0.1
1.5 секунд на сэмпле 0.01
**Kafka**
Даже не напрягается.
**Spark**
Работает достаточно быстро, на пиковых нагрузках отстает, потом постепенно догоняет очередь.
**ClickHouse, Сжатие данных**
1.5-2ТБ данных сжимаются до 110-150 ГБ.
**ClickHouse, Нагрузка на запись**
1-4 RPS батчами по 10000 записей.
**ClickHouse, Нагрузка на чтение**
В данный момент сильно зависит от запрашиваемых проектов и типа отчета, от 5 до 30 RPS.
Эту проблему должно решить сэмплирование в зависимости от размера проекта и квоты.
### Результаты и впечатления
M-m-m-magic. Мы выкатили в продакшен первый отчет, работающий с ClickHouse – [«Сегодня детально»](https://stat.top100.rambler.ru/projects/208383/report/today_detailed?date_start=2017-07-05&date_end=2017-07-05&groupBy=hour&orderBy=-title&indicators=page_views%2Cvisits%2Cvisitors&graphs=page_views%3Astacked). Пожелания и конструктивная критика приветствуются.
To be continued. Буду рад, если напишете в комментах, о чем было бы интересно почитать в будущем: тонкости эксплуатации, бенчмарки, типовые проблемы и способы их решения, ваш вариант. | https://habr.com/ru/post/332202/ | null | ru | null |
# Аналог ip unnumbered в Linux системах или экономим IP адреса
Не так давно я столкнулся с проблемой аналога ip unnumbered на Linux, которая с легкостью реализовывается на оборудование Cisco.
При использование такого вида маршрутизации, не придется делить сеть глобально маршрутизируемых ip адресов на небольшие с маской /30 или /31. Достаточно присвоить, например, интерфейсу loopback сеть класса C ( /24 ), а клиентским интерфейсам указать на то, что вся обработка IP пакетов будет осуществляется с адресом присвоенным loopback interface. Тем самым вы получаете рациональное использование IP адресов.
Рассмотрим теперь выше сказанное на практике.
##### Входные данные
* Публичная сеть ip адресов класса C — 195.131.195.0/24 (маска подсети 255.255.255.0)
* Cisco router 2811 series, с двумя Fast Ethernet интерфейсами.
* Управляемый коммутатор L2, cisco catalyst 2950
* Router на базе Debian 2.6.18
* На Debian router, установлен пакет vconfig, который отвечает за создание VLAN. В качестве интерфейса, на котором будут создаватся VLAN выступает eth1
##### Постановка задачи
Необходимо создать 3 VLAN-а, для обслуживания трех абонентов и предоставить каждому по публичному IP адресу из сети 195.131.195.0/24.
##### Часть первая. Что бы вы сделали без ip unnumbered?
Чтобы мы сделали в таком случае, если бы не использовали ip unnumbered? Мы бы поделили нашу сеть на более мелкие, например, на сети с размерностью /30, тоесть маской подсети 255.255.255.252. И так, три клиента, три сети:
**Сеть номер один:** 195.131.195.0/30
Где: 195.131.195.0 – индификатор сети, 195.131.195.1 – IP, который выступает в роли шлюза для клиента, 195.131.195.2 – клиентский IP адрес и 195.131.195.3 – broadcast. По этой же аналогии разбиваем оставшиеся две сетки и получаем:
**Сеть номер два:** 195.131.195.4/30
**Сеть номер три:** 195.131.195.8/30
Теперь создаем конфиг на cisco router:
`interface FastEthernet0/1.200
description Client-1 // описание интерфейса для первого клиента
encapsulation dot1Q 200 // используем dot1Q выставляя таким образом VID для VLAN
ip address 195.131.195.1 255.255.255.252 // присваиваем IP
!
interface FastEthernet0/1.201
description Client-2 // описание интерфейса для воторого клиента
encapsulation dot1Q 201
ip address 195.131.195.5 255.255.255.252 // присваиваем IP
!
interface FastEthernet0/1.202
description Client-3 // описание интерфейса для первого клиента
encapsulation dot1Q 202 // используем dot1Q выставляя таким образом VID для VLAN
ip address 195.131.195.9 255.255.255.252 // присваиваем IP
!`
Конфиг для Cisco готов. Создадим похожую схему только уже на **Debian** router, для этого отредактируем файл */etc/network/interfaces*
`## Client 1
auto vlan200
iface vlan200 inet static
address 195.131.195.1
netmask 255.255.255.252
vlan_raw_device eth1
## Client 2
auto vlan201
iface vlan201 inet static
address 195.131.195.5
netmask 255.255.255.252
vlan_raw_device eth1
## Client 3
auto vlan202
iface vlan202 inet static
address 195.131.195.9
netmask 255.255.255.252
vlan_raw_device eth1`
Подготовим коммутатор, к которому будут подключены наши виртуальные клиенты:
1 порт на коуммутаторе будет стоять в режиме switchport access vlan 200
2 порт — switchport access vlan 201
3 порт — switchport access vlan 202
Все работает.
##### Часть вторая. Переводим нашу схему на ip unnumbered.
Для этого сделаем следующие изменения на cisco router. Повесим нашу публичную сеть на loopback 200, следующим образом:
`interface Loopback200
ip address 195.131.195.1 255.255.255.0
no ip redirects`
Теперь поправим клиентские интерфейсы
`interface FastEthernet0/1.200
description Client-1
encapsulation dot1Q 200
ip unnumbered Loopback200 // указываем на loopback 200, где висит наша сеть
ip virtual-reassembly // сбор фрагментов
!
interface FastEthernet0/1.201
description Client-2
encapsulation dot1Q 201
ip unnumbered Loopback200 // указываем на loopback 200, где висит наша сеть
ip virtual-reassembly // сбор фрагментов
!
interface FastEthernet0/1.202
description Client-3
encapsulation dot1Q 202
ip unnumbered Loopback200 // указываем на loopback 200, где висит наша сеть
ip virtual-reassembly // сбор фрагментов`
И заключительный этап. Нам необходимо выдернуть всего один IP из нашей большой сети и предоставить клиенту. Сделаем это с помошью ip route:
`ip route 195.131.195.2 255.255.255.255 FastEthernet0/1.200 // для клиента номер 1
ip route 195.131.195.3 255.255.255.255 FastEthernet0/1.201 // для клиента номер 2
ip route 195.131.195.4 255.255.255.255 FastEthernet0/1.202 //для клиента номер 3`
Теперь для клиентов, необходимы настройки выходна в Internet: IP: 195.131.195.X, MASK: 255.255.255.0, а основной шлюз 195.131.195.1.
Почувствовали разницу? =)
А что же делать с нашим Debian router? Все просто. Изменим наш конфиг следующим образом. А вот что.
Создадим lo1 и повесим на него нашу публичную сеть.
`auto lo1
allow-hotplug lo1
iface lo1 inet static
address 195.131.195.1
netmask 255.255.255.0
network 195.131.195.0`
Теперь поправим клиентские VLAN сделующим образом:
`## Client 1
auto vlan200
iface vlan200 inet static
address 0.0.0.0
netmask 0.0.0.0
vlan_raw_device eth1
## Client 2
auto vlan201
iface vlan201 inet static
address 0.0.0.0
netmask 0.0.0.0
vlan_raw_device eth1
## Client 2
auto vlan202
iface vlan202 inet static
address 0.0.0.0
netmask 0.0.0.0
vlan_raw_device eth1`
И воспользуемся ip route:
`ip ro add 195.131.195.2 dev vlan200 src 195.131.195.1 // Клиент номер 1
ip ro add 195.131.195.3 dev vlan200 src 195.131.195.1 // Клиент номер 2
ip ro add 195.131.195.4 dev vlan200 src 195.131.195.1 // Клиент номер 3`
Вот и все. | https://habr.com/ru/post/71689/ | null | ru | null |
# Бот для VK на Python с MySQL за час ч.2
### Предисловие
Прошу извинения за то, что в первой статье не написал про работу с базой данных, но именно эта часть направлена на работу с MySQL.
3 часть будет неким дополнением, где мы рассмотрим работу с клавиатурой для бота и на этом цикл статей завершиться.
### Подготовка
После прошлой статьи на руках мы должны иметь такой код:
```
import vk_api
from vk_api.utils import get_random_id
from vk_api.bot_longpoll import VkBotLongPoll, VkBotEventType
import pymysql.cursors
import requests
def get_connection():
connection = pymysql.connect(host='you_host',
user='you_user',
password='you_password',
db='you_db'
charset='utf8mb4',
cursorclass=pymysql.cursors.DictCursor)
return connection
habracut
vk_session = vk_api.VkApi(token="a6f87v8c9a9sa87a7af9a0f9f9v8a6s6c5b5m6n8bds09asc8d7b87d87bd87n")
vk = vk_session.get_api()
longpoll = VkBotLongPoll(vk_session, "637182735")
#Проверка действий
for event in longpoll.listen():
if event.type == VkBotEventType.MESSAGE_NEW:
#Проверяем не пустое ли сообщение нам пришло
if event.obj.text != '':
#Проверяем пришло сообщение от пользователя или нет
if event.from_user:
#Отправляем сообщение
vk.messages.send(
user_id=event.obj.from_id,
random_id=get_random_id(),
message=event.obj.text)
```
Создадим бота, который будет возвращать нам результат положительный или отрицательный. Например «Life» и «Dead». Потом заносить его в базу данных и в будущем отправлять этот результат нам.
Для начала мы должны иметь свою базу данных с уже готовой таблицей.
Если кто то не умеет создавать таблицы, то вот код, который необходимо вставить будучи в mysql консоли:
```
CREATE DATABASE `firstbot`;
CREATE TABLE `mode`(Id_User INT(11), Mode VARCHAR(6) DEFAULT("NOT"), PRIMARY KEY(Id_User));
```
На этом каркас нашей таблицы будет готов. Подробнее о создании и изменении таблиц можно найти на офф. сайте(ссылка будет ниже).
Создадим функцию, которая будет рандомно возвращать Dead или Live:
```
#Подключим новый модуль random
import random
def random_mode():
#Получаем рандомное число в районе от 1 до 200
return random.choice(["Live","Dead"])
```
Теперь мы должны сделать функцию, которая отправит в базу данных наши значения.
```
def add_to_database(function_mode, x):
#Создаем новую сессию
connection = getConnection()
#Будем получать информацию от сюда
cursor = connection.cursor()
#Наш запрос
sql = "INSERT INTO mode (Id_User, Mode) VALUES (%s, %s) ON DUPLICATE KEY UPDATE Mode = %s"
#Выполняем наш запрос и вставляем свои значения
cursor.execute(sql, (x, function_mode, function_mode))
#Делаем коммит
connection.commit()
#Закрываем подключение
connection.close()
#Возвращаем результат
return function_mode
```
Мы создали функцию, которая будет добавлять человека в базу данных или заканчивать свою работу, если он уже там есть. В нашем случае все до ON DUPLICATE KEY UPDATE заносит наши результаты в базу данных. Если в базе данных есть уже колонка с id нашего юзера, то в базу данных не заносится новое значение, а обновляется за что и отвечает ON DUPLICATE KEY UPDATE.
Но помимо того, что мы заносим значения в базу данных, нам надо их получать. Для этого создадим такую функцию.
```
def select_from_database(x):
connection = get_connection()
cursor = connection.cursor()
sql = "SELECT Mode FROM mode WHERE Id_User = %s"
cursor.execute(sql, (x,))
#Получаем запрашиваемые данных и заносим их в переменные
for i in cursor:
mode_send = i['Mode']
#Проверяем точно ли есть такая запись
if cursor.fetchall() == ():
mode_send = 'Вы еще не пробовали'
connection.close()
return mode_send
```
cursor.fetchall() распаковывает получаемый нами запрос и отображает его. При помощи условия мы проверяем точно ли запись в базе данных есть. Если ее нет, то мы присваиваем ей желаемое значение-предупреждение
Все что нам осталось это собрать код полностью и добавить пару строк, что бы все работало так как мы хотим.
```
if event.obj.text == 'Попытка':
if event.from_user:
id_user = event.obj.from_id
vk.messages.send(
user_id=event.obj.from_id,
random_id=get_random_id(),
message="Ваш результат: " + add_to_database(random_mode(), id_user))
if event.obj.text == 'Прошлый результат':
if event.from_user:
idUser = event.obj.from_id
vk.messages.send(
user_id=event.obj.from_id,
random_id=get_random_id(),
message="Ваш последний: " + select_from_database(id_user)
```
И таким образом мы получим ответ от нашего бота
### Итог
С помощью проделанной работы мы создали бота умеющего работать с MySQL. На этом его функционал не заканчивается. Он намного шире и больше, а ограничен только вашей фантазией.
Код не идеале и писал я его только, что бы показать как работает MySQL. Если вы знаете способы лучше, смело применяйте их. Так же приму любую помощь по усовершенствованию текущего кода.
### Полезные ссылки
[Официальная страница PyMySQL](https://pymysql.readthedocs.io/en/latest/index.html)
[Официальная страница MySQL](https://www.mysql.com)
[Документация PyMySQL на русском](https://o7planning.org/ru/11463/connecting-mysql-database-in-python-using-pymysql)
[Документация vk\_api](https://vk-api.readthedocs.io/en/latest/)
[Документая API Вконтакте](https://vk.com/dev/manuals)
[Код самого бота](https://github.com/owl345/article-pythonbot-mysql) | https://habr.com/ru/post/452210/ | null | ru | null |
# Многоядерная JIT-компиляция в .NET 4.5
Исторически разработчики .NET использовали генератор образов в машинном коде Ngen. Это отлично работает, если у вас есть инсталлятор, и вы можете сгенерировать эти образы во время установки приложения. Но в других случаях, например когда у вас нет установщика или вы не имеете доступ к Ngen, ваше приложение будет производить JIT-компиляцию по мере необходимости, что замедлит его загрузку. Разработчики CLR предоставили решение в новой версии .NET – многоядерная JIT-компиляция с возможностью создавать профили оптимизации.
При многоядерной JIT-компиляции код компилируется на двух ядрах параллельно. Чем больше кода вы выполняете во время загрузки, тем более заметным будет ускорение от многоядерного JIT. Вы можете получить уменьшение времени загрузки на 20-50%, что является хорошей новостью для тех, кто разрабатывает большие приложения и не имеют возможности использовать Ngen. Для этого потребуется добавить в ваш код всего пару строчек кода.
#### **Как это работает**
В общем случае вам понадобится вызвать всего два метода в своём приложении:
* Указать место, где будут храниться профили многоядерного JIT,
* И начать профайлинг, вызвав метод StartProfile.
.NET runtime создаст профиль исходя из последовательностей вызванных методов во время работы вашего приложения. Этот профиль будет сохранён на диск. Проще говоря, при первом запуске произойдёт «запись» профиля (картинки взяты [отсюда](http://blogs.msdn.com/b/dotnet/archive/2012/10/18/an-easy-solution-for-improving-app-launch-performance.aspx)):
Когда приложение будет запущено в следующий раз, .NET runtime проверит на наличие готового профиля и, найдя его, начнёт JIT-компиляцию в той последовательности, в которой они были сохранены в профиле.
#### **Используем многоядерную JIT-компиляцию**
Использовать многоядерную JIT-компиляцию просто. В .NET 4.5 присутствует класс [System.Runtime.ProfileOptimization](http://msdn.microsoft.com/en-us/library/system.runtime.profileoptimization.aspx), который мы можем использовать для того, чтобы начать запись профиля во время старта приложения. Этот код выглядит примерно так:
```
ProfileOptimization.SetProfileRoot(@"C:\MyApp");
ProfileOptimization.StartProfile("LaunchProfile");
```
**SetProfileRoot** — включает оптимизацию для текущего AppDomain и устанавливает директорию, куда будет сохраняться профиль оптимизации. Этот метод игнорируется на одноядерных комрьютерах.
**StartProfile** – начинает профайлинг и just-in-time компиляцию для тех методов, которые были записаны в профиль (если он уже есть).
ASP.NET 4.5 включает многоядерную JIT-компиляцию по умолчанию. Если вы хотите выключить эту оптимизацию, добавьте атрибут к `compilation` в ваш web.config:
```
```
Если вы не можете перейти на .NET 4.5, и хотите использовать эту функциональность в приложении, скопмилированным для .NET 4.0, существует [способ включить оптимизацию на компьютерах, которые имеют установленный .NET 4.5](http://blog.getpaint.net/2012/09/08/using-multi-core-jit-from-net-4-0-if-net-4-5-is-installed/).
Если ваше приложение имеет многоступенчатую логику запуска, вы можете вызывать `StartProfile` в нескольких местах. Например, если после начального запуска у пользователя есть выбор (например в меню) в какую часть программы перейти дальше, вы можете использовать разные профили для разных частей кода. Таким образом вы оптимизируете JIT-компиляцию в зависимости от действий пользователя.
#### **Эффективность**
Для больших приложений уменьшение времени загрузки может составить около 50%. Чтобы продемонстрировать это, команда разработчиков взяла редактор Paint.NET, удалила предварительно сгенерированные Ngen образы, и сравнила время и загрузгу процессора в двух случаях:
Это определённо довольно простой и эффективный способ уменьшить время загрузки .NET приложений, которые не используют Ngen.
Больше информации об улучшениях производительности в .NET 4.5 доступно в статье на MSDN:
[msdn.microsoft.com/en-us/magazine/hh882452.aspx](http://msdn.microsoft.com/en-us/magazine/hh882452.aspx) | https://habr.com/ru/post/163725/ | null | ru | null |
# Запускаем “десктопное” ПО на микроконтроллере
[Embox](http://embox.github.io) принимал участие в IT фестивале [TechTrain](https://techtrain.ru/?utm_source=partner&utm_medium=Embox&utm_campaign=techtrain2019&utm_content=common). Мы как и в [первый раз](https://habr.com/ru/company/embox/blog/423935/) привезли железки и вживую показали наши достижения. О некоторых мы уже писали на хабре, но мало ли кто не поверил :). Были показаны [VoIP телефон](https://habr.com/ru/company/embox/blog/431134/), [Qt](https://habr.com/ru/company/embox/blog/459730/) и [OpenCV](https://habr.com/ru/company/embox/blog/457724/), все на базе STM32F7-Discovery. Кроме стенда мы сделали три доклада. Идеи первого про открытый проект я уже описывал на [хабре](https://habr.com/ru/company/embox/blog/464189/). В данной статье хочу рассказать идеи еще одного нашего доклада, который назывался [“Запускаем “десктопное” ПО на микроконтроллерах”](https://techtrain.ru/2019/talks/cvcndzoq1n46u0uucqfrz/). Ну и пользуясь случаем, немного расскажу про свои ощущения о фестивале.
TechTrain
---------
Вначале позволю себе немного рассказать о самом фестивале. Кому не интересно можно сразу перемотать на раздел “Запускаем “Десктопное” ПО на микроконтроллере”
Первое что бросалось в глаза на фестивале — очень много народу. Мы устали стоять на стенде, выступать, проводить квест, общаться. С другой стороны, это было очень весело и интересно, а главное мы получили массу положительных эмоций, например, нам несколько человек сказали, что у нас хороший блог на хабре :). Участники фестиваля были из самых разных сфер деятельности, причем были даже не из IT, ведь лозунг фестиваля “большой фестиваль для разработчиков, инженеров и им сочувствующих.”. Было много детей, один мальчик под конец фестиваля утащил со стенда машинку робота и с ним игрался. Ни мальчик ни робот не пострадали.
Чтобы было более понятна широта аудитории, проиллюстрирую ее по другому. На фестивале проводили множество активностей, одна из них квест. Участникам квеста нужно было подходить на стенды, выполнять придуманные задания и получать печать. За это кто-то даже получил целый квадрокоптер. Но сейчас не об этом. Мы тоже были одним из мест где можно было получить печать. У нас были подготовлены задания, в том числе и вопросы. Вопросы были простыми, касались СПО и встроенных систем. Но контингент был настолько разный, что одни обижались на простоту вопроса, а другие входили в ступор. Последним мы естественно помогали, рассказывали (или предлагали погуглить) про такие вещи как: “кто является создателями языка Си”, “чем знаменит Линус Торвальдс”, “чем отличается микропроцессор от микроконтроллера” или “что такое кросс-компилятор”. В итоге без печати никто не ушел. Кстати, было немного странно, но подозрительно многие легко расшифровывали “GNU — GNU is not Unix”. Наверное к Столлману подготовились. :)
Второе вытекает из первого. Были развлечения для очень широкой аудитории. Например, Хабр привез песочницу. Правда это была не местная песочница, где можно получить инвайт за статью, но в ней можно было на славу поваляться. Про инвайты в песочнице я не догадался спросить, может и давали как в настоящей песочнице. Был клуб [старых компов](https://retrotechsquad.ru), на них можно было поиграть, что многие и делали. Были игровые автоматы из [Музея советских игровых автоматов](http://www.15kop.ru/). Сбербанк, предлагал зону релаксации, в ней также можно было поиграть уже в play station. Были традиционные да IT кикеры и множество других развлекух. К сожалению, нам нужно было работать поэтому говорю только про то что было видно с нашего стенда.
Третьим и наверное главным было то, что организаторам удалось собрать представителей фактически всех it направлений от веб разработки и распределенных систем до embedded. От разработчиков и других технарей, до human resources и просто интересующихся it, например геймеров (ведь можно было зарубиться с самим [Ромеро](https://techtrain.ru/speakers/4s8zoez2nbf8kvtpd5crfd/)) или DIY энтузиастов. Были QA из [COMAQA](https://comaqa.by/) были тим-лиды из [Burning Lead](https://t.me/BurningLead). Были сообщества разных городов (Ростов, Тверь, Краснодар). В итоге получились доклады и стенды очень разные по тематике. Для примера наш стенд находился между сообществом тим лидов Burning Lead и стендом [“Санкт-Петербургского клуба IT-директоров”](https://www.spbcioclub.ru/).
В результате к нашему стенду подходили люди с сильно различающимся бекграундом, были и веб разработчики и DotNet-чики, были JS и плюсовики. Кто-то вспоминал, что он что то делал на AVR еще в универе, кто то рассказывал, что он развлекается с RaPi или Arduino. Поразительно много было DotNet-чиков, многие интересовались нет ли у нас [.NET Micro Framework](https://ru.wikipedia.org/wiki/.NET_Micro_Framework). Мы даже сильно задумались не затащить ли нам еще и его. Ожидаемо было много вопросов про Rust. Короче, на мой взгляд, организаторам удалось достаточно хорошо воплотить в жизнь идею фестиваля “Узнай, чем живут другие!”. Ведь как и на любом фестивале, тут главное других посмотреть и себя показать :).
Да фоток здесь не приводим. [Немного фоток](https://vk.com/embox?w=wall-54669112_183), в том числе и с живым мальчиком Володей, можно [посмотреть](https://vk.com/embox?w=wall-54669112_184) у нас в группе. Ну и естественно в [группе techtrain](https://vk.com/techtrain) куча качественных фоток, обещали еще выложить.
Запускаем Десктопное ПО на микроконтроллере
-------------------------------------------
Мой доклад являлся своего рода подведением итогов по результатам нескольких наших работ о запуске десктопного ПО ([Qt](https://habr.com/ru/company/embox/blog/459730/), [OpenCV](https://habr.com/ru/company/embox/blog/457724/), [pjsip](https://habr.com/ru/company/embox/blog/431134/)). Доклад ориентирован на широкую публику. Для хабра я постараюсь сократить многие детали, а для необходимых вещей дам ссылку или ключевые слова для поиска.
Для начала я приведу своего рода агенду. По сути дела будет 3 части. Во-первых, я объясню трудности переноса десктопного ПО на микроконтроллеры, попутно объясню разницу между микроконтроллером и микропроцессором. Еще я отвечу на ключевой вопрос ~~нафига козе баян~~, зачем запускать десктопное ПО на микроконтроллере, ну и наконец расскажу как нам удалось сильно снизить затраты на процесс переноса на микроконтроллеры этого самого “десктопного” ПО.
### Чем отличаются микроконтроллеры от микропроцессоров
Так звучал один из наших вопросов на квесте и может быть под влиянием этого появилась [статья на Типичном программисте](https://tproger.ru/explain/difference-between-mc-and-mpu/), рассказывающая чем они отличаются. Со всем в статье согласен, но попробуем объяснить своими словами и сделаем несколько другие акценты.
Что такое микроконтроллер (Micro Controller Unit, MCU)? Если взглянуть в [википедию](https://ru.wikipedia.org/wiki/%D0%9C%D0%B8%D0%BA%D1%80%D0%BE%D0%BA%D0%BE%D0%BD%D1%82%D1%80%D0%BE%D0%BB%D0%BB%D0%B5%D1%80), то можно понять, что микроконтроллер это система на кристалле, то есть в одном чипе располагается и процессор и периферия.
[Термин система на кристалле (System-on-a-Chip, SoC )](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D0%BD%D0%B0_%D0%BA%D1%80%D0%B8%D1%81%D1%82%D0%B0%D0%BB%D0%BB%D0%B5) является более широким понятием чем микроконтроллер. Это такая интегрированная в один чип электронная схема, которая содержит микропроцессор (CPU) и периферию. В любом мобильнике есть чип, в котором кроме нескольких процессорных ядер, есть куча периферии. Даже x86 процессоры сейчас включают в себя функции мостов и даже gpu. Но я хочу заострить внимание не на четкой классификации, а на особенностях. Все знают, что системы на кристалле:
* Меньше потребляют
* Дешевле стоят
* Менее производительные
Не все знают, что они еще и более надежны за счет уменьшения числа контактов и могут иметь больший температурный диапазон.
Микроконтроллер имеет еще большую интеграцию и включает в себя еще и память (ОЗУ и ПЗУ), которую тоже относят к периферии. Соответственно, свойства сохраняются, еще меньше потребляют, еще дешевле стоят, еще менее производительные, еще надежнее.
Об “еще менее производительные” хочу поговорить подробнее. Дело в том, что с одной стороны это правда, взять любой современный CPU или SoC общего назначения и увидим существенно большую производительность в так называемых [DMIPS](https://ru.wikipedia.org/wiki/Dhrystone). Но если задуматься, зачем такая производительность? Для примера приведу игры Quake и Doom (создатель которых Джон Ромеро был на фестивале), они прекрасно работали на Pentium MMX. Но производительность систем на базе этого CPU уже перекрывают топовые микроконтроллеры. Я имею в виду [STM32F7](https://www.st.com/en/microcontrollers-microprocessors/stm32f7-series.html) или даже [STM32H7](https://www.st.com/en/microcontrollers-microprocessors/stm32h7-series.html). То есть на базе этих MCU вполне можно выполнять приложения уровня Doom и Quake, что согласитесь вполне не плохо.
Поговорим еще об одной особенности MCU — внутренняя память. Она, как я уже сказал, находится прямо на кристалле, и соответственно, очень быстрая. Но ее, естественно, мало. Но насколько мало? Микроконтроллер STM32F769 содержит 2 mb flash (ПЗУ) и 512 + 16 + 4 кб SRAM (ОЗУ). Кроме того например на плате [STM32F769i-disco](https://www.st.com/en/evaluation-tools/32f769idiscovery.html) есть еще внешняя память (128-Mbit SDRAM и 512-Mbit Quad-SPI Flash memory), которая адресуется напрямую. Я даже не говорю о возможности подключить sd-карточку или usb. Ну а если вспомнить известную фразу “640 кб должно хватить каждому”, то возникает резонный вопрос — почему же современное десктопное ПО такое прожорливое? Например, калькулятор в windows 10 в режиме простоя потребляет аж 16 Мб памяти.
Перейдем к следующей особенности MCU, наличию ПЗУ. На самом деле, системы с CPU тоже содержат ПЗУ из нее начинается выполнение, и стартует BIOS, но остальное ПО загружается в оперативную память и из нее исполняется. В embedded системах принято выполнять код напрямую, то что называется eXecute-In-Place (XIP), Linux, кстати, тоже поддерживает этот режим, но основным все же является загрузка всего в основную память и уже тогда выполнение. Возможность выполнения напрямую из ПЗУ важна по двум причинам: первая — гарвардская архитектура разделение на шину команд и шину данных позволяет увеличить скорость выполнения программ; вторая — ну естественно, тратится меньше памяти, ведь как минимум сегмент кода не нужно никуда дополнительно копировать.
Еще одной ключевой особенностью MCU является отсутствие такого модуля как [MMU](https://ru.wikipedia.org/wiki/%D0%91%D0%BB%D0%BE%D0%BA_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D1%8C%D1%8E), то есть, у микроконтроллеров нет аппаратной поддержки управления [виртуальной памятью](https://habr.com/ru/company/embox/blog/256191/). В MCU и то не во всех есть [MPU](https://ru.bmstu.wiki/MPU_(Memory_Protection_Unit)), а код выполняется в одном адресном пространстве, поэтому трудно организовать [полноценный fork()](https://habr.com/ru/company/embox/blog/347542/). Но сам fork() как мы писали в статье [«fork() vs. vfork()»](https://habr.com/ru/company/embox/blog/232605/) довольно тяжелый системный вызов, причем по функциональности он, во многих случаях, может быть заменен на vfork() или posix\_spawn().
Подводя итог, чем же отличаются микроконтроллеры от микропроцессоров, можно сказать следующее:
С точки зрения аппаратной части:
* Микроконтроллеры имеют всю необходимую периферию в том числе и память
* Микроконтроллеры имеют существенно меньше памяти
* Микроконтроллеры не имеют аппаратного блока управления памятью MMU
* Микроконтроллеры имеют более низкую тактовую частоту и могут иметь другую процессорную архитектуры (подархитектуру)
С точки зрения потребительских свойств:
* Микроконтроллеры меньше потребляют энергии, могут работать от батарейки
* Микроконтроллеры дешевле
* Микроконтроллеры надежнее
* Микроконтроллеры менее производительные
### Зачем запускать десктопное ПО на микроконтроллере
Итак, MCU менее производительные и изначально предназначались ( и предназначаются) для задач управления. Так зачем же запускать на них ПО предназначенное для другого класса систем? Ну пусть даже их мощности уже хватает для подобных задач, но ведь эти задачи можно решать и традиционным для микроконтроллеров образом. То есть использовать различные маленькие RTOS или писать код с нуля, то что называется bare-metal. Существует очевидный ответ, изначально задачи управления были очень простыми, сейчас требования к функциональности сильно растут. Даже от какой нибудь захудалой лампочке ожидают управление через интернет, я уже не говорю о чайнике, они наверное скоро будут подбирать состав чая по настроению владельца и подогревать оптимальное количество воды до оптимальной температуры в целях улучшения экологической обстановки. :)
Поэтому ничего удивительного, что постоянно идут попытки использовать уже разработанное ПО в микроконтроллерах. Например, одной из первых и широко известных попыток запускать Linux на маленьких платформах является ucLinux, сейчас это режим NOMMU в основном Linux. Идея была запускать Linux на аппаратных платформах без MMU, а ведь мы выяснили что это одно из ключевых отличий CPU от MCU.
Коротко преимущества использования готового ПО:
* Сокращение расходов на разработку
* Сокращение времени выхода на рынок
* Сокращение ошибок в коде. Готовое ПО более надежнее.
### Как мы это делаем в Embox
Тут сами понимаете, можно рассказывать очень долго, но я постараюсь опять же тезисно и доступно обозначить основные моменты.
Первое. Embox использует систему сборки Mybuild с собственным языком описания модулей и системы, мы писали о ней в статье [«Mybuild — система сборки для модульных приложений»](https://habr.com/ru/company/embox/blog/144935/). Данная система сборки позволяет не включать в образ ничего лишнего, точнее включать только то что требуется. Можно действительно очень тонко задавать характеристики системы, например для запуска PJSIP на STM32F7 мы ограничили количество ethernet пакетов 16 просто написав строчку в конфигурационном файле для системы
```
include embox.net.skbuff(amount_skb=16)
```
Mybuild анализирует зависимости и генерирует различные артефакты, в том числе заголовочные файлы, линкер скрипты и Makefile -ы. Все это позволяет существенно уменьшить количество требуемой памяти и вообще не включать те части которые не используются.
Второе. Очевидно, что Embox должен поддерживать POSIX и он поддерживается. Причем у нас реализована собственная стандартная библиотека, ведь она тоже должна перестраиваться в зависимости от конфигурации системы.
Третье. Статическая линковка. Для того чтобы избежать проблем с единым адресным пространством, уменьшить размер образа и включать только требуемые части мы используем статическую линковку. На разных стадиях собираются разные части системы, но окончательно все (ядро, все подсистемы, библиотеки и приложения) линкуется в единый образ. В нем есть вся информация обо всех символах в образе. И хотя на первый взгляд мы имеем много приложений со стандартными точками входа int main(..), но в результирующем образе, это будут разные символы, которые будут доступны в системе из командной строки.
Четвертое. Нам пришлось реализовать рантайм для C++, поскольку многие популярные приложения и библиотеки используют плюсы.
Пятое. Мы в систему сборки добавили возможность использовать
```
./configure; make; make install
```
Предварительно скачав откуда-то исходники и наложив необходимые патчи.
### Заключение
На сегодняшний день функциональные требования к системам, которые раньше делались на микроконтроллерах, сильно выросли. От систем управления ожидают сопоставимой с универсальными системами функциональности. Характеристики микроконтроллеров тоже сильно выросли, что позволяет запускать на них ПО с соответствующей функциональностью. Исторически ПО для микроконтроллеров в целях оптимизации писалось под конкретную задачу, но с увеличением функциональных требований необходимо применять подходы из мира универсальных систем, которые позволяют сильно увеличить надежность ПО, а именно, переиспользование модулей, распределенная разработка. Универсальное ПО хоть и не учитывает особенности встроенных систем, но имеет существенно больший и хорошо отлаженный функционал. Поэтому применение десктопного ПО на микроконтроллерах дает выигрыш. Ведь с одной стороны, можно использовать более дешевую, надежную и менее потребляющую аппаратную платформу, а с другой стороны, существенно снижаются затраты на разработку подобных систем. | https://habr.com/ru/post/466379/ | null | ru | null |
# Логическая репликация в PostgreSQL 10
*[**PG Day’17**](https://pgday.ru/ru/2017/request/registration?utm_source=habrahabr&utm_medium=blog&utm_campaign=varanio2) продолжает радовать вас авторскими статьями. Сегодня, наш старый друг и бессменный автор провокационных статей о Web-разработке [varanio](https://habrahabr.ru/users/varanio/) расскажет о логической репликации.*
Сначала я хотел назвать статью "Гарри Поттер и философский камень", потому что много лет при сравнении PostgreSQL с MySQL кто-нибудь всегда появлялся и замечал, что в Посгресе нет логической репликации (можно реплицировать только всю базу целиком, причем реплика read only), а в MySQL их целых два вида: statement based и row based.
И если statement based — это бомба замедленного действия с лазерным прицелом в ногу, то row based действительно очень не хватало в PG. Т.е. вопрос репликации — как философский камень у любителей баз.
Точнее, в посгресе всегда можно было использовать [slony](http://www.slony.info/) для того, чтобы, например, реплицировать только одну-две нужных таблицы. Но slony — это хитрое поделие на триггерах, которое работает по принципу: работает — не трогай. Т.е. например, нельзя просто взять и сделать ALTER TABLE ADD COLUMN, это надо делать через специальные механизмы. Если же всё-таки кто-то случайно это сделал, а потом, что еще хуже, через какое-то время в панике вернул как было, то быстро разрулить эту ситуацию может только чёрный маг 80lvl. Помимо slony, начиная с 9.4 стало возможно писать свои расширения для логической репликации через wal, вроде бы, пример такого расширения — pglogical.
**Но это всё не то!**
Когда я узнал, что в dev-ветку PostgreSQL 10 упал коммит, который позволяет из коробки, без экстеншенов и плагинов, логически реплицировать отдельные таблицы, я решил посмотреть, а как оно там работает.
Ставим PostgreSQL из исходников на убунту
=========================================
Это оказалось совсем не сложно. Ставим всякие полупонятные слова, необходимые для сборки:
~~sudo apt-get install avada kedavra expelliarmus~~
`sudo apt-get install -y build-essential libreadline-dev zlib1g-dev flex bison libxml2-dev libxslt-dev libssl-dev`
Качаем исходники:
`git clone git://git.postgresql.org/git/postgresql.git`
Собираем все это дело:
```
cd postgresql
./configure
make
make install
```
Я написал make install, это безвозвратно загадит ваш /usr/local, так что лучше это делайте в вируалке или докер-контейнере, или же спросите настоящего сварщика, как это сделать аккуратно. Я совершенно не админ, так что извините.
Запускаем тестовые демоны
=========================
Зайдем под юзером postgres. Если у вас его еще нет, то создайте. Если есть, но не залогиниться под ним, то наверно просто не задан пароль, тогда надо сделать sudo passwd postgres. Итак, зайдем под юзером postgres:
`su - postgres`
Создадим где-нибудь папки master и slave и проинитим там бд:
```
/usr/local/pgsql/bin/initdb -D ~/master
/usr/local/pgsql/bin/initdb -D ~/slave
```
Т.е. у нас будет два локальных демона pg, которые будут друг другу реплицировать отдельные таблицы. Пусть один будет работать на порту 5433, другой — на 5434.
Для этого надо вписать в `~/master/postgresql.conf` строку `port = 5433`, в `~/slave/postgresql.conf` — строку `port = 5434`, соответственно.
В обоих конфигах `postgresql.conf` надо указать:
```
wal_level = logical
```
Кроме того, чтобы репликация работала, надо раскомментировать строчку в `pg_hba.conf`:
```
local replication postgres trust
```
Запускаем оба демона:
```
/usr/local/pgsql/bin/pg_ctl start -D ~/master -l ~/master.log
/usr/local/pgsql/bin/pg_ctl start -D ~/slave -l ~/slave.log
```
Настраиваем репликацию
======================
К сожалению, никакой (вообще никакой) документации пока что еще нет. Поэтому пришлось немного прошерстить тесты к исходному коду, чтобы хоть что-то узнать, как настраивать и пользоваться этим видом репликации.
Всё будем делать прямо во встроенной базе postgres, чтобы не захламлять деталями. Заходим в мастер:
```
/usr/local/pgsql/bin/psql -p 5433
```
Cоздадим таблицу и "публикацию":
```
CREATE TABLE repl (
id int,
name text,
primary key(id)
);
CREATE PUBLICATION testpub;
```
Добавляем к публикации все необходимые таблицы (в данном случае — одну):
```
ALTER PUBLICATION testpub ADD TABLE repl;
```
Теперь на стороне слейва:
```
/usr/local/pgsql/bin/psql -p 5434
```
Тоже создадим таблицу:
```
CREATE TABLE repl (
id int,
name text,
primary key(id)
);
```
Теперь надо создать подписку на публикацию, в которой указываем строку коннекта до другой базы и имя PUBLICATION:
```
CREATE SUBSCRIPTION testsub CONNECTION 'port=5433 dbname=postgres' PUBLICATION testpub;
```
Проверяем
=========
Вставляем на мастере:
```
INSERT INTO repl (id, name) VALUES (1, 'Вася');
```
Читаем на реплике:
```
postgres=# select * from repl;
id | name
----+------
1 | Вася
(1 row)
```
It works!
Теперь остановим реплику:
```
/usr/local/pgsql/bin/pg_ctl stop -D ~/slave
```
На мастере сделаем:
```
delete from repl;
insert into repl (id, name) values (10, 'test');
```
Запускаем слейв и проверяем:
```
/usr/local/pgsql/bin/pg_ctl start -D ~/slave -l ~/slave.log
```
```
postgres=# select * from repl;
id | name
----+------
10 | test
(1 row)
```
Всё сработало.
Более того, я добавил новую колонку на мастер и на слейв, вставил записи, и это тоже сработало.
Если вы хотите узнать больше примеров использования, посмотрите в исходниках файл `src/test/subscription/t/001_rep_changes.pl`. Он на перле, но там всё понятно.
**src/test/subscription/t/001\_rep\_changes.pl**
```
# Basic logical replication test
use strict;
use warnings;
use PostgresNode;
use TestLib;
use Test::More tests => 11;
# Initialize publisher node
my $node_publisher = get_new_node('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
# Create subscriber node
my $node_subscriber = get_new_node('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# Create some preexisting content on publisher
$node_publisher->safe_psql('postgres',
"CREATE TABLE tab_notrep AS SELECT generate_series(1,10) AS a");
$node_publisher->safe_psql('postgres',
"CREATE TABLE tab_ins (a int)");
$node_publisher->safe_psql('postgres',
"CREATE TABLE tab_full AS SELECT generate_series(1,10) AS a");
$node_publisher->safe_psql('postgres',
"CREATE TABLE tab_rep (a int primary key)");
# Setup structure on subscriber
$node_subscriber->safe_psql('postgres',
"CREATE TABLE tab_notrep (a int)");
$node_subscriber->safe_psql('postgres',
"CREATE TABLE tab_ins (a int)");
$node_subscriber->safe_psql('postgres',
"CREATE TABLE tab_full (a int)");
$node_subscriber->safe_psql('postgres',
"CREATE TABLE tab_rep (a int primary key)");
# Setup logical replication
my $publisher_connstr = $node_publisher->connstr . ' dbname=postgres';
$node_publisher->safe_psql('postgres',
"CREATE PUBLICATION tap_pub");
$node_publisher->safe_psql('postgres',
"CREATE PUBLICATION tap_pub_ins_only WITH (nopublish delete, nopublish update)");
$node_publisher->safe_psql('postgres',
"ALTER PUBLICATION tap_pub ADD TABLE tab_rep, tab_full");
$node_publisher->safe_psql('postgres',
"ALTER PUBLICATION tap_pub_ins_only ADD TABLE tab_ins");
my $appname = 'tap_sub';
$node_subscriber->safe_psql('postgres',
"CREATE SUBSCRIPTION tap_sub CONNECTION '$publisher_connstr application_name=$appname' PUBLICATION tap_pub, tap_pub_ins_only");
# Wait for subscriber to finish initialization
my $caughtup_query =
"SELECT pg_current_xlog_location() <= replay_location FROM pg_stat_replication WHERE application_name = '$appname';";
$node_publisher->poll_query_until('postgres', $caughtup_query)
or die "Timed out while waiting for subscriber to catch up";
my $result =
$node_subscriber->safe_psql('postgres', "SELECT count(*) FROM tab_notrep");
is($result, qq(0), 'check non-replicated table is empty on subscriber');
$node_publisher->safe_psql('postgres',
"INSERT INTO tab_ins SELECT generate_series(1,50)");
$node_publisher->safe_psql('postgres',
"DELETE FROM tab_ins WHERE a > 20");
$node_publisher->safe_psql('postgres',
"UPDATE tab_ins SET a = -a");
$node_publisher->safe_psql('postgres',
"INSERT INTO tab_rep SELECT generate_series(1,50)");
$node_publisher->safe_psql('postgres',
"DELETE FROM tab_rep WHERE a > 20");
$node_publisher->safe_psql('postgres',
"UPDATE tab_rep SET a = -a");
$node_publisher->poll_query_until('postgres', $caughtup_query)
or die "Timed out while waiting for subscriber to catch up";
$result =
$node_subscriber->safe_psql('postgres', "SELECT count(*), min(a), max(a) FROM tab_ins");
is($result, qq(50|1|50), 'check replicated inserts on subscriber');
$result =
$node_subscriber->safe_psql('postgres', "SELECT count(*), min(a), max(a) FROM tab_rep");
is($result, qq(20|-20|-1), 'check replicated changes on subscriber');
# insert some duplicate rows
$node_publisher->safe_psql('postgres',
"INSERT INTO tab_full SELECT generate_series(1,10)");
# add REPLICA IDENTITY FULL so we can update
$node_publisher->safe_psql('postgres',
"ALTER TABLE tab_full REPLICA IDENTITY FULL");
$node_subscriber->safe_psql('postgres',
"ALTER TABLE tab_full REPLICA IDENTITY FULL");
$node_publisher->safe_psql('postgres',
"ALTER TABLE tab_ins REPLICA IDENTITY FULL");
$node_subscriber->safe_psql('postgres',
"ALTER TABLE tab_ins REPLICA IDENTITY FULL");
# and do the update
$node_publisher->safe_psql('postgres',
"UPDATE tab_full SET a = a * a");
# Wait for subscription to catch up
$node_publisher->poll_query_until('postgres', $caughtup_query)
or die "Timed out while waiting for subscriber to catch up";
$result =
$node_subscriber->safe_psql('postgres', "SELECT count(*), min(a), max(a) FROM tab_full");
is($result, qq(10|1|100), 'update works with REPLICA IDENTITY FULL and duplicate tuples');
# check that change of connection string and/or publication list causes
# restart of subscription workers. Not all of these are registered as tests
# as we need to poll for a change but the test suite will fail none the less
# when something goes wrong.
my $oldpid = $node_publisher->safe_psql('postgres',
"SELECT pid FROM pg_stat_replication WHERE application_name = '$appname';");
$node_subscriber->safe_psql('postgres',
"ALTER SUBSCRIPTION tap_sub CONNECTION 'application_name=$appname $publisher_connstr'");
$node_publisher->poll_query_until('postgres',
"SELECT pid != $oldpid FROM pg_stat_replication WHERE application_name = '$appname';")
or die "Timed out while waiting for apply to restart";
$oldpid = $node_publisher->safe_psql('postgres',
"SELECT pid FROM pg_stat_replication WHERE application_name = '$appname';");
$node_subscriber->safe_psql('postgres',
"ALTER SUBSCRIPTION tap_sub SET PUBLICATION tap_pub_ins_only");
$node_publisher->poll_query_until('postgres',
"SELECT pid != $oldpid FROM pg_stat_replication WHERE application_name = '$appname';")
or die "Timed out while waiting for apply to restart";
$node_publisher->safe_psql('postgres',
"INSERT INTO tab_ins SELECT generate_series(1001,1100)");
$node_publisher->safe_psql('postgres',
"DELETE FROM tab_rep");
$node_publisher->poll_query_until('postgres', $caughtup_query)
or die "Timed out while waiting for subscriber to catch up";
$result =
$node_subscriber->safe_psql('postgres', "SELECT count(*), min(a), max(a) FROM tab_ins");
is($result, qq(150|1|1100), 'check replicated inserts after subscription publication change');
$result =
$node_subscriber->safe_psql('postgres', "SELECT count(*), min(a), max(a) FROM tab_rep");
is($result, qq(20|-20|-1), 'check changes skipped after subscription publication change');
# check alter publication (relcache invalidation etc)
$node_publisher->safe_psql('postgres',
"ALTER PUBLICATION tap_pub_ins_only WITH (publish delete)");
$node_publisher->safe_psql('postgres',
"ALTER PUBLICATION tap_pub_ins_only ADD TABLE tab_full");
$node_publisher->safe_psql('postgres',
"DELETE FROM tab_ins WHERE a > 0");
$node_publisher->safe_psql('postgres',
"INSERT INTO tab_full VALUES(0)");
$node_publisher->poll_query_until('postgres', $caughtup_query)
or die "Timed out while waiting for subscriber to catch up";
# note that data are different on provider and subscriber
$result =
$node_subscriber->safe_psql('postgres', "SELECT count(*), min(a), max(a) FROM tab_ins");
is($result, qq(50|1|50), 'check replicated deletes after alter publication');
$result =
$node_subscriber->safe_psql('postgres', "SELECT count(*), min(a), max(a) FROM tab_full");
is($result, qq(11|0|100), 'check replicated insert after alter publication');
# check all the cleanup
$node_subscriber->safe_psql('postgres', "DROP SUBSCRIPTION tap_sub");
$result =
$node_subscriber->safe_psql('postgres', "SELECT count(*) FROM pg_subscription");
is($result, qq(0), 'check subscription was dropped on subscriber');
$result =
$node_publisher->safe_psql('postgres', "SELECT count(*) FROM pg_replication_slots");
is($result, qq(0), 'check replication slot was dropped on publisher');
$result =
$node_subscriber->safe_psql('postgres', "SELECT count(*) FROM pg_replication_origin");
is($result, qq(0), 'check replication origin was dropped on subscriber');
$node_subscriber->stop('fast');
$node_publisher->stop('fast');
```
В частности, если создать таблицу без primary key, то, чтобы удалять из нее значения, надо написать:
```
ALTER TABLE tablename REPLICA IDENTITY FULL
```
Я не знаю, как это работает, видимо генерятся какие-то id на лету. Если у кого-то есть больше информации по логической репликации, поделитесь плиз в коментах.
Выводы
======
Вывод очень прост: я очень жду PostgreSQL 10 в состоянии production-ready, так как это решит целый пласт организационных проблем (можно будет выкинуть slony). Для кого-то, возможно, это будет последней каплей для перехода с MySQL на Postgres.
С другой стороны, как это будет работать на практике, пока что никто не знает. Будет ли это достаточно быстро, удобно в обслуживании и так далее. Если у кого-то есть больше информации по теме, поделитесь плиз в коментах.
А пока мы ждем PostgreSQL 10, наверняка, у вас много вопросов по дрессировке текущих методов репликации. На [**PG Day'17**](https://pgday.ru/ru/2017/request/registration?utm_source=habrahabr&utm_medium=blog&utm_campaign=varanio2) вас ждет большое количество интересных докладов и мастер-классов по PostgreSQL. Например, **Илья Космодемьянский** расскажет все о настройке ПГ, обработке транзакций, автовакууме и, конечно, подскажет, как избежать распространенных ошибок. Спешите [**зарегистрироваться**](https://pgday.ru/ru/2017/request/registration?utm_source=habrahabr&utm_medium=blog&utm_campaign=varanio2)! | https://habr.com/ru/post/326996/ | null | ru | null |
# Как я написал свой ChatOps: опыт выпускника курса по Python
Меня зовут Константин Кулишов, я работаю DevOps-инженером в компании, которая предоставляет комплексное сопровождение клиента от разработки до поддержки и продвижения.
В этой статье я кратко опишу ChatOps и расскажу, как вдохновился и написал приложение <https://github.com/KKulishov/chatops>.
Почему нам понадобился ChatOps
------------------------------
Наша компания практикует современный стек в разработке и в поддержке. Мы используем оркестрацию контейнеров Kubernetes для крупных клиентов, в работе с которыми оправдана эта технология. Также мы используем облачные платформы, по согласованию с клиентом. В моем примере рассмотрим Yandex.Cloud.
Так как мы используем Yandex.Cloud, оплата почасовая и держать runner постоянно включенным финансово не оправдано. Его можно выключать с 20:00 до 9:00 и на субботу и воскресенье. Это неудобно, если разработчик хочет поработать в выходной или ему, как Менделееву, среди ночи пришло просветление. Ведь он захочет не только запушить свои изменения, но и увидеть результат своей работы на stage-ветке. Для таких целей и было реализовано приложение.
Нужен ли команде ChatOps — вопрос спорный. Каждая команда сама решает, насколько для них это ценная фича. В моем примере errbot используется с интеграцией в телеграм, чтобы перехватывать команды и выполнять их. Выбрал телеграм, потому что у нас в компании в нем все общение.
Мое приложение было создано для того, чтобы облегчить жизнь отделу разработки. Приложение может выводить логи миграции в БД. Вы можете сказать, что надо смотреть в Grafana, но у нас собираются логи через Fluent Bint и складываются в Elasticsearch, но когда приходит «failed» от job по миграции, разработчикам проще посмотреть через телеграм.
Вот часть примеров ситуаций, в которых нам помогает ChatOps. Напишите в комментариях, что вы решаете с помощью него.
Как я писал свое приложение
---------------------------
Знания по Kubernetes я черпал из книг, официальной документации и курсов. Последним, который я прошел, был [курс от Слёрм по Python для devops-инженеров](https://slurm.io/course-python-for-ops). Моей основной целью было систематизировать фундаментальные знания, и увидеть, как на практике взаимодействуют Python и Kubernetes.
Я решил чтобы что-то понять, нужно написать самому. Поэтому я решил использовать errbot, Kubernetes Client, Yandex API, Python-Gitlab.
Errbot используется для интерактивного взаимодействия в телеграме. С помощью Kubernetes Client я получаю логи миграции БД по namespace. Вызывается довольно просто:
```
/logs_migrated --namespace work
```
Логи берутся с отдельного пода, который выполняет задачи миграции, отбирается по (^pre-migrate-db-(.\*) , где pre-migrate-db-xxxx имя пода), можно переопределить в plugins/err-prod/rights.py.
Yandex API использовал для запуска build\_runner и поднятия его ресурсов. Пример ввода команд: /list build vm. Здесь выводиться список машин и их имена которые участвуют в build и их статус и описание тех. характеристик.
```
/start vm --name_vm buildfront (старт машины по указанному имени buildfront)
/stop vm --name_vm buildfront (стоп машины)
/upgrade vm --name_vm buildfront --core 4 --mem 8 (тут мы даем команду на увелечения до 4 ядер и 8 ГБ ОЗУ для машины под именем buildfront)
```
Нужно уточнить, что выборка машин из списка при вызове list build vm выбирает машины только те, которые начинаются со слова build, но это можно скорректировать в коде plugins/err-prod/mylib.py. Тут нужно уточнить, что выборка машин из списка при вызове list build vm выбирает машины только те которые начинаются со слова build , (отрабатывает след. регулярка ^build(.\*)) ,но это можно скорректировать в коде plugins/err-prod/mylib.py.
Чтобы запустить приложение, надо установить зависимости. Первое — это python 3.8 и выше. Потом установите:
```
pip3 install errbot errbot[telegram] paramiko kubernetes requests python-gitlab
```
```
git clone [email protected]:KKulishov/chatops.git && cd chatops
```
Дальше экспортировать переменные. Поскольку у меня и дома, и на работе Linux, я делаю так:
```
export ERRBOT_ENV="DEV"
```
Используется для отладки приложения, не запуская телеграм, просто в текстовом режиме консоли. Если нужен сразу telegram, вводим:
```
export ERRBOT_ENV="PROD"
```
API токен вашего бота:
```
export BOT_TOKEN="xxxxxxxxxxxxxxxxxxx"
```
Затем понадобятся данные по Яндекс API:
```
export CI_folderId="xxxxxxxxxxxxx" (переменная — ваш ID каталога в Яндекс.Облаке)
```
```
export CI_IAM_TOKEN="xxxxxxxxxxxx"
```
Если вы запускаете в режиме PROD, ID указывать не нужно, он сам возьмет, при условии, что приложение запускается на виртуальных машинах Yandex.Cloud и к машине привязан service account с полномочиями compute.admin. IAM\_TOKEN выдаются не навсегда, а только на временной интервал. Токен для отладки можно получить через утилиту yc: iam create-token. Офф. доки по iam token API Yandex.Cloud в конце статьи.
Для взаимодействия с Kubernetes нужно создать service account, получить токен и сертификат. Прошу учесть, что кластерная роль view уже была создана.
```
kubectl create serviceaccount chatbot
kubectl create clusterrolebinding chatbot-cluster-view --clusterrole=view --serviceaccount=default:chatbot
```
значение вывод нужно указать в переменную тут указывается токен (где chatbot-token-xxxx имя Ваша секрета)
```
export KUBER_TOKEN_VIEWER=$(kubectl get secret chatbot-token-xxxx -o jsonpath="{['data']['token']}" | base64 -d)
а вот сертификат пришлось указать как физический файл
kubectl get secret chatbot-token-xj54b -o jsonpath="{['data']['ca\.crt']}" | base64 -d > plugins/err-prod/ca.crt
```
Тут можно было привязать его к service account в описании манифеста, когда приложение внутри кластера Kubernetes. Но вот для отладки (когда приложение еще не в кубере) мне показалось более наглядным.Тем более для локальной отладки можно использовать k3s или minikube.
Затем можно вызвать бота , командой:
```
errbot
```
В зависимости от того что вы выбрали: если DEV, то в качестве клиента будет использована командная строка (тут вызовы идут через знак !потом\_команда):
А если PROD , тогда взаимодействия будет через Ваш telegarm bot, вот пример (через telegram вызовы команд идут через /) :
Вывод
-----
Теперь разработчики могут быть не привязаны к рабочим и будним дням, и пушить изменения, с возможность сразу видеть результат своей работы на stage-ветке. Мы сэкономили на расходах в облаке и упрощаем жизнь команды разработки.
**Весь код приложения с кратким описанием**:
<https://github.com/KKulishov/chatops>
**Официальные документы, которые использовал:**
<https://errbot.readthedocs.io/en/latest/>
<https://github.com/kubernetes-client/python>
<https://cloud.yandex.ru/docs/compute/api-ref/>
<https://python-gitlab.readthedocs.io/en/stable/>
<https://cloud.yandex.ru/docs/iam/operations/iam-token/create-for-sa><https://cloud.yandex.ru/docs/compute/api-ref/Instance/>
**Курс, который я проходил:**
[«Python для инженеров» от Слёрма.](https://slurm.io/course-python-for-ops)
Курс очень помог. Для меня официальный инструмент взаимодействия с Kubernetes через Python запутанный, а в доках <https://github.com/kubernetes-client/python/tree/master/kubernetes/docs> хоть и много примеров, но разобраться сложно. А на курсе можно писать преподавателю, он может не сразу ответить, зато разберет все нюансы. Темы насыщены полезными примерами, которые можно адаптировать под свои задачи. Хорошо описано взаимодействие с api через библиотеку requests, работа с errbot с реализацией управления ssh через paramiko, написание prometheus exporter.
Были и минусы: курсовые далеки от реалий, долгие стримы (там их было 3 по ansible,kubernetes и errbot), а я привык получать от Слёрма короткую и четкую информацию. Про Kubernetes была только одна неделя, это печально (хотелось бы больше выделенного времени по взаимодействию с api kubernetes). Надеюсь, авторы учтут мои замечания, потому что кроме них, курс один из немногих стоящих.
**Книги, которые посоветовали во время прохождения курса:**
«Изучаем Python», Марк Лутц том 1 и 2. Тоже очень помогли.
На этом все. Если статья будет интересна, могу добавить в Git репу описания dockerfile сборки и Kubernetes Chat описания ChatOps. | https://habr.com/ru/post/577662/ | null | ru | null |
# Консольный UI и отказ от асинхронного кода в idewave-cli
С выходом версии 1.0.1 я решил осветить некоторые аспекты технической стороны [моего проекта](https://github.com/idewave/idewave-cli). В этой статье я расскажу про использование библиотеки *tui-rs* и про нюансы использования библиотеки *tokio-rs*, а так же постараюсь рассказать, что же было исправлено и почему так, как было раньше делать не надо. Добро пожаловать в статью - возможно, кому-то она поможет на тернистом пути погружения (или восхождения) в Rust.
---
Мой проект представляет из себя консольный клиент для игры World of Warcraft (но служит для других целей и вообще это - не то же самое). После недавнего обновления он обзавелся текстовым интерфейсом и вообще стал гораздо юзабельнее.
Отображение опкодов пакетов, отправленных с сервераНо подключение интерфейса оказалось довольно объемной задачей. Начну с того, что я изначально решил выполнять генерацию интерфейса в виде отдельного таска для того, чтобы максимально инкапсулировать код, относящийся к UI. На текущий момент мои таски вызываются вот так:
```
join_all(vec![
self.handle_ui_render(),
self.handle_ui_input(),
self.handle_ui_output(),
self.handle_ai(),
self.handle_queue(),
self.handle_read(),
self.handle_write(),
]).await;
```
таски, относящиеся к UI - их пока всего три. Помимо, собственно, таска для рендера я создаю отдельный таск для обработки событий с клавиатуры и отдельный таск для обработки отклика от интерфейса.
Типичный пример, как это работает: в процессе соединения с сервером может понадобиться сделать выбор. Например, выбор рилма (*realm*) или персонажа для входа в мир. Для этого необходимо показать какое-нибудь модальное окно.
Выбор рилма из списка в модальном окнеЗдесь вступает в силу следующий сценарий:
1. я замораживаю обработку последующих пакетов (хотя, по прежнему их принимаю и сохраняю в очередь)
2. отрисовываю модальное окно со списком персонажей или рилмов
3. ожидаю, пока будет отправлено событие с клавиатуры (в нашем случае - нажатие стрелки вниз/вверх)
4. перерисовываю интерфейс, но уже с выбранным элементом в списке
5. в конце-концов, выбор сделан, требуется нажатие Enter, после чего происходит оповещение остальной части приложения о сделанном выборе
6. и, наконец, я размораживаю обработку последующих пакетов
В коде это выглядит примерно так:
```
// события с клавиатуры принимаются здесь (см пункт 3 и 5)
fn handle_ui_input(&mut self) -> JoinHandle<()> {
let income_pipe = self._income_message_pipe.lock().unwrap();
// сюда приходят все входящие события с клавиатуры
let event_income = income_pipe.event_income.clone();
tokio::task::spawn_blocking(move || {
let mut ui_input = UIInput::new(event_income);
loop {
ui_input.handle();
}
})
}
// отрисовка элементов интерфейса происходит здесь (см пункт 2 и 4)
fn handle_ui_render(&mut self) -> JoinHandle<()> {
// ...
let outcome_message_pipe = self._outcome_message_pipe.lock().unwrap();
// отклик от UI от модальных окон
let dialog_outcome = pipe.dialog_outcome.clone();
// ...
tokio::task::spawn_blocking(move || {
// UI renderer, отвечающий за отрисовку интерфейса
let mut ui = UI::new(
CrosstermBackend::new(std::io::stdout()),
UIOutputOptions {
dialog_outcome,
// ...
},
);
loop {
// ...
ui.render(UIRenderOptions {
// все входящие события принимаются здесь
message: income_message_pipe.lock().unwrap().recv(),
client_flags,
});
}
})
}
fn handle_ui_output(&mut self) -> JoinHandle<()> {
let outcome_message_pipe = Arc::clone(&self._outcome_message_pipe);
// ...
tokio::task::spawn_blocking(move || {
loop {
// принимаем исходящий отклик от UI и обрабатываем, если он имеется
if let Ok(message) = outcome_message_pipe.lock().unwrap().recv() {
// ...
let mut ui_output = UIOutput::new(Arc::clone(&session), client_flags);
// эту строку подробнее рассмотрим чуть ниже
ui_output.handle(message);
}
}
})
}
```
В `ui_output.handle(message)` на строке 57 выше происходит общение с остальной частью приложения через элементы межпроцессного взаимодействия (IPC) - в данном случае, это `session` , а так же через флаги приложения (созданные с помощью макроса `bitflags!` из одноименной библиотеки):
```
pub fn handle(&mut self, message: OutcomeMessageType) {
match message {
// получили отклик, что персонаж выбран по нажатию Enter
OutcomeMessageType::CharacterSelected(character) => {
// сохраняем персонажа в объект сессии
self.session.lock().unwrap().me = Some(Player::from(character));
// меняем флаг приложения для разморозки обработки пакетов (см пункт 6)
self.client_flags.set(ClientFlags::IN_FROZEN_MODE, false);
},
// получили отклик, что рилм выбран по нажатию Enter
OutcomeMessageType::RealmSelected(realm) => {
// сохраняем выбранный рилм в объект сессии
self.session.lock().unwrap().selected_realm = Some(realm);
// меняем флаг приложения для разморозки обработки пакетов (см пункт 6)
self.client_flags.set(ClientFlags::IN_FROZEN_MODE, false);
},
// ...
};
}
```
Осталось рассмотреть, где происходит *заморозка* обработки пакетов (пункт 1).
```
fn handle_queue(&mut self) -> JoinHandle<()> {
// все переменные, которые я клонирую через Arc::clone()
// имеют тип Arc>
let input\_queue = Arc::clone(&self.\_input\_queue);
let output\_queue = Arc::clone(&self.\_output\_queue);
let session = Arc::clone(&self.session);
let reader = Arc::clone(&self.\_reader);
let writer = Arc::clone(&self.\_writer);
let warden\_crypt = Arc::clone(&self.\_warden\_crypt);
let client\_flags = Arc::clone(&self.client\_flags);
let data\_storage = Arc::clone(&self.data\_storage);
let income\_pipe = self.\_income\_message\_pipe.lock().unwrap();
// все входящие сообщения, которые мы хотим отобразить в debug panel
let mut message\_income = income\_pipe.message\_income.clone();
// для отправки запроса на показ модального окна
let dialog\_income = income\_pipe.dialog\_income.clone();
tokio::spawn(async move {
loop {
let connected\_to\_realm = client\_flags.lock().unwrap().contains(
ClientFlags::IS\_CONNECTED\_TO\_REALM
);
let packets = input\_queue.lock().unwrap().pop\_front();
if packets.is\_some() {
for packet in packets.unwrap() {
let processors = match connected\_to\_realm {
true => Self::get\_realm\_processors(),
false => Self::get\_login\_processors(),
};
let mut handler\_input = HandlerInput {
session: Arc::clone(&session),
data: Some(&packet),
data\_storage: Arc::clone(&data\_storage),
message\_income: message\_income.clone(),
dialog\_income: dialog\_income.clone(),
};
// каждый процессор возвращает список хэндлеров для
// определенного опкода, который мы извлекам из приходящего
// с сервера пакета
let handler\_list = processors
.iter()
.map(|processor| processor(&mut handler\_input))
.flatten()
.collect::>();
for mut handler in handler\_list {
// каждый хэндлер выполняет одно действие и возвращает HandlerOutput
match handler(&mut handler\_input) {
Ok(output) => {
match output {
HandlerOutput::Data((opcode, header, body)) => {
// ...
},
HandlerOutput::ConnectionRequest(host, port) => {
// ...
},
HandlerOutput::UpdateState(state) => {
// ...
},
// этот тип ответа позволяет заморозить обработку
// последующих пакетов (см. пункт 1)
HandlerOutput::Freeze => {
client\_flags.lock().unwrap().set(
ClientFlags::IN\_FROZEN\_MODE,
true
);
loop {
let frozen\_mode = client\_flags
.lock()
.unwrap()
.contains(ClientFlags::IN\_FROZEN\_MODE);
// для отмены нужно переключить флаг где-то извне
// в нашем случае - это таск handle\_ui\_output (см. пункт 6)
if !frozen\_mode {
break;
}
sleep(Duration::from\_millis(WRITE\_TIMEOUT)).await;
}
},
HandlerOutput::Void => {},
};
},
Err(err) => {
message\_income.send\_error\_message(err.to\_string());
},
};
sleep(Duration::from\_millis(WRITE\_TIMEOUT)).await;
}
}
} else {
sleep(Duration::from\_millis(WRITE\_TIMEOUT)).await;
}
}
})
}
```
На чем еще хотелось бы остановиться, так это на нюансах создания UI тасков. Вы наверняка заметили, что я их создаю через `tokio::task::spawn_blocking()` - и это не просто так. Эта функция гарантирует, что таск будет создан **в отдельном потоке**, таким образом, он не будет блокировать другие таски и не будет блокироваться ими. Или, в моем случае, такая функция гарантирует мгновенный отклик интерфейса, поскольку перехват событий/отрисовка будут выполняться независимо от остального приложения.
Про асинхронный код
-------------------
Когда я только начинал свой путь в Rust на стезе мультипоточности, мне порекомендовали перейти на *tokio-rs.* Тогда я еще не вдавался в детали и решил, что это хороший повод изучить новую библиотеку. Но, оказалось, что нет. Потому что я, наверное, допустил все ошибки, которые можно было допустить при использовании *tokio-rs*.
Начнем с того, что tokio-rs - это такой рантайм (*runtime*) для запуска асинхронного кода. Можно использовать и другие рантаймы или вообще написать свой, если вы видите в этом нужду. По умолчанию все таски в tokio выполняются в одном потоке, но вы можете настроить мультипоточность, подключив фичу (feature) под названием "rt-multi-thread", после чего, **при необходимости**, таски будут создаваться в отдельных потоках.
**Первой** моей ошибкой было использование async везде. Даже там, где это не нужно. Все мои таски стали асинхронными, новые таски по умолчанию записывались в асинхронные. Типичный таск выглядел примерно так:
```
async fn handle_ai(&mut self) -> JoinHandle<()> {
let session = Arc::clone(&self.session);
let data_storage = Arc::clone(&self.data_storage);
let output_queue = Arc::clone(&self._output_queue);
let mut movement_ai = MovementAI::new();
tokio::spawn(async move {
loop {
movement_ai.manage(AIManagerInput {
session: Arc::clone(&session),
data_storage: Arc::clone(&data_storage),
output_queue: Arc::clone(&output_queue),
}).await;
sleep(Duration::from_millis(WRITE_TIMEOUT)).await;
}
})
}
// далее таски вызывались примерно так
join_all(vec![
self.handle_ui_render().await,
self.handle_ui_input().await,
self.handle_ui_output().await,
self.handle_ai().await,
self.handle_queue().await,
self.handle_read().await,
self.handle_write().await,
]).await;
```
Постарайтесь самостоятельно определить, какие в коде выше ошибки.
Вот какие`async` в определении функции - не нужен, так как асинхронный код присутствует только в теле блока async, которое передается в `tokio::spawn`, соответственно, вызов функций в join\_all должен быть без await, т.к. там нечего эвэйтить.
Т.е., грубо говоря, код выше - избыточен.
**Вторая** ошибка была серьезнее - и привела к дэдлокам (deadlock). В погоне за необходимостью использовать mutex для обеспечения *совместного доступа* (Shared Ownership) к внешним переменным я стал использовать `tokio::sync::mutex` . В результате (из-за гонки ака race condition) попал в несколько ситуаций, когда какой-нибудь `client_flags` блокируется в одном из тасков и не дает выполняться другому таску, который зависит от искомого. Типичный дэдлок может выглядеть вот так:
```
async fn handle_queue(&mut self) -> JoinHandle<()> {
// ...
tokio::spawn(async move {
loop {
let connected_to_realm = client_flags.lock().unwrap().contains(
ClientFlags::IS_CONNECTED_TO_REALM
);
// дэдлок здесь
if let Some(packets) = input_queue.lock().await.pop_front() {
for packet in packets.unwrap() {
// ...
for mut handler in handler_list {
match handler(&mut handler_input) {
Ok(output) => {
match output {
HandlerOutput::Data((opcode, header, body)) => {},
HandlerOutput::ConnectionRequest(host, port) => {},
HandlerOutput::UpdateState(state) => {},
HandlerOutput::Freeze => {},
HandlerOutput::Void => {},
};
},
Err(err) => {},
};
sleep(Duration::from_millis(WRITE_TIMEOUT)).await;
}
}
} else {
sleep(Duration::from_millis(WRITE_TIMEOUT)).await;
}
}
})
}
```
Детали здесьДэдлок на строке 10. `input_queue` блокируется на время существования блока if. Вариант решения - вынести `input_queue.lock().await.pop_front()` в переменную.
Но лучше - не использовать (по возможности) `tokio::sync::mutex`вообще. В самой документации tokio-rs [рекомендуется](https://docs.rs/tokio/latest/tokio/sync/struct.Mutex.html#which-kind-of-mutex-should-you-use) использовать асинхронный mutex с умом (например, для соединений с базой данных), а в большинстве случаев - использовать std::sync::mutex (т.е. синхронный mutex из стандартной библиотеки).
Вобщем, классический пример, когда сначала ~~прочитал документации и сделал как надо~~ понаставил везде асинхронных mutex, нахватал дэдлоков, после чего по ссылке со stackoverflow прочитал документацию и, наконец, ~~героически пофиксил~~ сделал как надо.
Отдельно хотелось бы рассмотреть такую структуру как Reader. До недавнего обновления он выглядел примерно так:
```
pub struct Reader {
stream: OwnedReadHalf,
decryptor: Option,
warden\_crypt: Arc>>
}
impl Reader {
pub fn new(reader: OwnedReadHalf) -> Self {
Self {
stream: reader,
decryptor: None,
warden\_crypt: Arc::new(Mutex::new(None))
}
}
pub fn init(&mut self, session\_key: &[u8], warden\_crypt: Arc>>) {
self.decryptor = Some(Decryptor::new(session\_key));
self.warden\_crypt = warden\_crypt;
}
pub async fn read(&mut self) -> Result>, Error> {
let mut buffer = [0u8; 65536];
// здесь проблема, используется блокирующий read
match self.stream.read(&mut buffer).await {
Ok(bytes\_count) => {
let result = match self.decryptor.as\_mut() {
Some(decryptor) => {
let warden\_crypt = &mut \*self.warden\_crypt.lock().await;
Self::parse\_packets(
buffer[..bytes\_count].to\_vec(),
decryptor,
warden\_crypt.as\_mut().unwrap(),
)
},
\_ => {
vec![buffer[..bytes\_count].to\_vec()]
},
};
Ok(result)
},
Err(err) => {},
}
}
}
```
Асинхронный `.read()` на строке 24 выше стал тоже своего рода блокером, когда в зависимости от сервера мне приходилось играться с значением `READ_TIMEOUT` , чтобы код работал. Я думал, что причина - в пинге, пока не отрефакторил приложение и заменил, наконец, блокирующий `.read()` на неблокирующий `.try_read()` :
```
pub fn read(&mut self) -> Result>, Error> {
let mut buffer = [0u8; 65536];
match self.stream.try\_read(&mut buffer) {
Ok(bytes\_count) => {
let result = match self.decryptor.as\_mut() {
// ...
};
Ok(result)
},
Err(err) => {
// ...
},
}
}
```
после этого фикса приложение стало работать быстрее (с учетом, что на некоторых серверах READ\_TIMEOUT был равен 250-300).
Итого
-----
После избавления от избыточного async/await приложение стало работать быстрее и предсказуемее. С позиции своего опыта я бы рекомендовал использовать async/await с умом, в частности, внимательно подходить к выбору mutex (tokio-rs или стандартная библиотека).
Одна из сложностей, с которой я столкнулся на этапе разработки - отсутствие местами качественной документации. Взять тот же tui-rs, было непонятно, что Layout можно дробить и использовать части в другом Layout, пока я не нашел кусок кода с примером в другом проекте github. Или было непонятно, как создать модальное окно, чтобы оно перекрывало часть уже отрисованного интерфейса (нужно рендерить виджет [Clear](https://docs.rs/tui/latest/tui/widgets/struct.Clear.html)).
Поэтому, я бы хотел, чтобы [мой проект](https://github.com/idewave/idewave-cli), в частности, мог быть использован в качестве примеров: [работы со сложными Layout](https://github.com/idewave/idewave-cli/blob/primary/src/ui/mod.rs#L137), [нюансов отрисовки модалок](https://github.com/idewave/idewave-cli/blob/primary/src/ui/realm_modal.rs#L131) или примера, как можно использовать [ввод с клавиатуры](https://github.com/idewave/idewave-cli/blob/primary/src/client/mod.rs#L184) в полноценном приложении.
Так же я надеюсь, что эта статья поможет вам избежать дэдлоков.
И, конечно, я буду рад всем, кто захочет сделать свой вклад в мой проект: <https://github.com/idewave/idewave-cli> | https://habr.com/ru/post/681556/ | null | ru | null |
# Работа с форматом конфигураций 1С: Предприятие
Решил опубликовать исходный код C# для работы с форматом конфигураций 1С: Предприятие.
**<https://github.com/elisy/MdInternals>**
MdInternals понимает формат cf, cfu, epf, erf, распаковывает содержимое в удобочитаемые Xml и текстовые файлы и загружает обратно. Позволяет программно обращаться к внутренним файлам и свойствам объектов.
Проект состоит из частей:
* MdInternals программно обращается к объектам и свойствам конфигурации
* CfProject отвечает за сериализацию и десериализацию объектов MdInternals
* MdInternals.Cil декомпилирует байт-код (OpCode) 1С
* MdInternals.Serialization работает с внутренним полу-JSON форматом 1С вида "{ 19 { "", 2 } }"
Выгрузка файлов cf, cfu, epf, erf на диск
-----------------------------------------
```
var cf = new CfPackage();
//или var cf = new EpfPackage();
//или var cf = new ErfPackage();
//или var cf = new CfuPackage();
cf.Open(@"D:\config.cf");
var project = new CfProject();
project.Save(epf, @"D:\Config\Xml\Config.cfproj", ProjectType.Xml);
```
Распознанные файлы записываются в дерево каталогов по видам объектов. Нераспознанные помещаются в каталог Unresolved:
Распознанные файлы выгружаются в XML-формате. Формат XML позволяет контролировать логическую целостность файлов и обрабатывать файлы сторонними программами. Известные свойства перемещаются в соответствующие разделы (атрибуты или тэги) XML-структуры:
Чтение из MSSQL-таблицы
-----------------------
```
var image = ImageReader.ReadImageFromConfig(@"data source=192.168.1.2\SQL2005;user=login;pwd=password;database=Database1C");
```
Обращение к внутренним файлам
-----------------------------
```
var mp = new EpfPackage();
mp.Open(file);
var root = mp.MetadataObjects.Where(m => m.ImageRow.FileName == "root").FirstOrDefault();
var rp = new RootPointer(root.ImageRow);
var part = mp.MetadataObjects.Where(m => m.ImageRow.FileName == rp.MetadataPackageFileName.ToString()).FirstOrDefault();
```
Создание файла из выгруженного xml-формата
------------------------------------------
```
var project = new CfProject();
var mp = project.Load(@"D:\Config\Xml\Config.cfproj");
mp.Save(@"D:\config.cf");
```
Описание Cf-Формата
-------------------
Cf-файл состоит из заголовка образа (ImageHeader) и следующими за ним страницами (ImagePage1-ImagePageN). Заголовок образа состоит из 4х байт сигнатуры, которая равна 0xFF 0xFF 0xFF 0x7F, 4х байт размера страницы и 8 зарезервированных байт. После заголовка файла идут по порядку страницы с данными. Каждая предыдущая страница ссылается на последующую.
Каждая страница (ImagePage) состоит из заголовка страницы (ImagePageHeader), группы указателей на записи ImageRowPointers и области ImageRows.
Заголовок страницы ImagePageHeader содержит в себе: зарезервированные 2 байта 0x0D 0x0A, 27 байт текстовой информации и еще зарезервированные 2 байта 0x0D 0x0A. Текстовая информация содержит 3 шестнадцатеричных числа: общий размер данных всех страниц (FullSize), размер текущей страницы (PageSize) и адрес следующей страницы в файле (NextPageAddress). FullSize проставляется только для первой страницы цепочки страниц. Для остальных страниц цепочки это значение 0. Для последней страницы цепочки NextPageAddress принимается равным 0xFF 0xFF 0xFF 0x7F.
Блок указателей ImageRowPointers занимает размер, указанный в значении PageSize страницы. Каждый указатель состоит из 4х байт адреса заголовка HeaderAddress и 4х байт адреса тела BodyAddress. В конце каждого указателя помещается сигнатура 0xFF 0xFF 0xFF 0x7F. Адреса указывают на расположения внутри текущей страницы на область ImageRows.
Заголовок ImageRowHeader начинается с блока заголовка страницы ImagePageHeader, который сообщает, сколько байт отведено под заголовок. Далее идут 20 зарезервированных байт, UTF-16 строка идентификатора данных (Id) и 4 зарезервированных байт.
Тело ImageRowBody начинается с блока заголовка страницы ImagePageHeader, который сообщает, сколько байт отведено под тело данных. Если тело данных начинается на 0xEF 0xBB 0xBF (сигнатура UTF8), то тело содержит UTF-8 строку. Иначе тело данных содержит упакованные данные. Если распакованные данные начинаются на 0xFF 0xFF 0xFF 0x7F, то содержимое – последовательность объектов, и они записаны в CF-формате. Иначе содержимое – это строка сериализации.
Что не реализовано
------------------
* Утилита распознает только объекты конфигурации 1го уровня, помещая по подкаталогам. Не распознает остальное: формы, макеты, помещая в каталог Unresolved
* В каталоге Unresolved не распаковываются составные объекты с расширением img
* MdInternals распознает ограниченное числа свойств объектов | https://habr.com/ru/post/434974/ | null | ru | null |
# Как развернуть Minishift на своем ноутбуке и начать жить
Minishift – это инструмент, который позволяет вам запустить OpenShift локально как кластер OpenShift из одного узла внутри виртуальной машины.
Технологии развиваются, и вместе с ними меняются и процессы разработки и развертывания приложений. Если раньше это были достаточно стандартные вещи со строго ограниченным набором задействованных компонентов, то в последние годы с появлением новых инструментов и фреймворков в этой области произошли резкие перемены. Установка пакета ПО на личный компьютер сегодня выглядит тривиальной, но поставьте себя на место ИТ-отдела, и сразу возникнет масса вопросов. Откуда взялся тот или иной программный компонент? Зачем он нужен? Как он обновляется? Кто осуществляет его поддержку? Эти действительно важные и неизбежные вопросы, если организация придерживается передовых методик обеспечения безопасности и должна соответствовать политикам и правилам безопасности.
Развертывать полноценную среду OpenShift на машине типового разработчика, как правило, не очень практично. В то же время локальный Minishift позволяет разработчику реализовать все плюсы управления контейнеризованными рабочими нагрузками, повышая его производительность и устраняя сложности операционной поддержки.
С переходом на OpenShift организации понимают, что наличие у разработчика локальной контейнерной платформы дает ряд преимуществ: например, независимость разработчика от корпоративной среды OpenShift и, как следствие, снижение нагрузки на последнюю. Иначе говоря, это помогает сократить затраты и реализовать дополнительные сервисы.
### Итак, вы хотите локальный OpenShift
Опираясь на наш опыт, можно сказать, что прежде, чем использовать Minishift, необходимо сделать следующее:
* Описать системные требования
* Сформулировать список зависимостей
Эта информация поможет сисадминам, ребятам из десктопной поддержки и людям, отвечающим за соответствие политикам и правилам безопасности, понять с чем им придется иметь дело. Системные требования и зависимости напрямую коррелируют с тем, какой вариант развертывания будет использоваться.
Поскольку здесь мы привычно рассматриваем корпоративный сценарий, то сосредоточимся на [Container Development Kit (CDK)](https://developers.redhat.com/products/cdk/overview/), ветви проекта Minishift, доведенной до стадии готового программного продукта.
Есть два варианта установки CDK:
* С помощью автономного исполняемого файла
* В составе пакета [Red Hat Development Suite](https://developers.redhat.com/products/devsuite/overview/), куда входят различные инструменты контейнерной разработки, включая OpenJDK, Red Hat JBoss Developer Studio, VirtualBox и Container Development Kit
Большинство организаций, как показывает опыт, предпочитают использовать автономный исполняемый файл, а не пакет Red Hat Development Suite, просто чтобы не плодить лишние инструменты. С другой стороны, пакет Red Hat отлично подходит для разработчиков, находящихся вне корпоративного контекста, поскольку обеспечивает простую и понятную пошаговую установку CDK. Кроме того, в организации уже могут использоваться инструменты схожие с теми, что входят в состав Red Hat Development Suite.
Вне зависимости от выбранного способа установки CDK, понадобится один из поддерживаемых гипервизоров, поскольку CDK работает в качестве виртуальной машины (ВМ).
Здесь может быть несколько вариантов:
* [VirtualBox](https://www.virtualbox.org/)
* [Hyper-V](https://docs.microsoft.com/en-us/virtualization/)
* [KVM](https://www.linux-kvm.org/)
* [Xhyve](https://github.com/mist64/xhyve)
Какой именно гипервизор – зависит от операционной системы на девелоперской машине, и в большинстве организаций это либо Windows, либо OS X, ведь большинство разработчиков очень редко используют Linux в качестве основной ОС по работе.
Необходимость иметь ВМ на машинах разработчиков нравится далеко не всем, поскольку для этого требуются дополнительные процессорные ресурсы и ОЗУ. Специалисты по безопасности тоже не в восторге, поскольку это может скомпрометировать безопасность на уровне сети и ПК. Кроме того, для установки, а иногда и для использования гипервизора требуются права администратора.
К счастью, с распространением новых подходов к разработке, когда ВМ используются вместе с инструментами автоматизированной настройки среды, такими как Vagrant, во многих организациях на девелоперских машинах уже есть гипервизоры, и они могут пропустить это этап, что устраняет ряд серьезных препятствий на пути к использованию Minishift в корпоративных средах.
### Установка и настройка
Рано или поздно препятствия будут преодолены, и придет черед установки и настройки CDK. Обычно организации блокируют загрузку исполняемых файлов в целях безопасности, поэтому придется использовать другие механизмы. Например, это может быть каталог одобренного ПО, либо можно разместить установщик CDK в репозитории, типа [Sonatype Nexus](https://www.sonatype.com/nexus-repository-sonatype) или [JFrog Artifactory](https://jfrog.com/artifactory/), откуда его смогут загружать пользователи.
Если установка выполняется вручную, без применения имеющихся в организации средств централизованного развертывания и настройки, пользователь может либо напрямую запустить исполняемый файл-установщик, либо положить его в каталог, прописанный в переменной PATH, где этот файл будет доступен из любого терминального сеанса. В случае Windows у пользователя обычно нет прав изменять системную переменную PATH, поскольку она действует для всех учетных записей на машине. Но пользователь может редактировать свою, личную переменную PATH, которая действует только для его учетной записи
Следующий шаг – это собственно установка самого CDK с помощью соответствующей команды:
`minishift setup-cdk`
Эта команда извлекает ISO-файл, используемый для загрузки ВМ, и подготавливает систему к использованию. При этом все файлы копируются в папку .minishift в домашнем (HOME) каталоге пользователя ($HOME/.minishift). Эту папку можно изменить либо с помощью флага –minishift-home, любо с помощью переменной окружения MINISHIFT\_HOME. В корпоративных средах домашний каталог зачастую расположен в сетевой папке, чтобы пользователь при необходимости мог пересесть за другой компьютер и спокойно работать дальше. Однако такой вариант плохо сказывается на производительности CDK, поскольку чтение и запись будут выполняться по сети, а не с локального диска. Кроме того, без подключения к корпоративной сети пользователь теряет доступ к файлам, необходимым для работы CDK. При выборе альтернативного местоположения для CDK пользователь должен иметь права на запись в выбранную папку назначения.
И, наконец, последний шаг, который надо выполнить перед запуском CDK – указать учетные данные для регистрации входящей в состав CDK копии Red Hat Enterprise Linux (RHEL) на сайте Red Hat Network (RHN). Регистрация нужна для того, чтобы контейнеры, работающие в среде OpenShift, могли использовать yum-пакеты, поскольку yum задействует подписку нижележащего хоста. Девелопперскую подписку можно бесплатно получить на сайте [developers.redhat.com](https://developers.redhat.com/), либо она может входить в уже имеющуюся корпоративную лицензию. Впрочем, CDK может работать и без подписки машины, с ограниченной функциональностью.
Учетные данные можно либо прописать в переменных среды MINISHIFT\_USERNAME и MINISHIFT\_PASSWORD, либо указать в параметрах запуска -username и -password, либо задать в качестве одного из параметров конфигурации с помощью команды config minishift. Помимо учетных данных команда config minishift позволяет задать и целый ряд других параметров, таких как драйвер гипервизора, количество ЦП и ОЗУ для ВМ. Например, вот как задается драйвер ВМ:
```
minishift config set vm-driver virtualbox
```
После этого остается только запустить CDK (при необходимости с дополнительными параметрами):
```
minishift start
```
После чего Container Development Kit создаст новую ВМ, зарегистрирует ее и выполнит прочие необходимые операции, а именно:
* Загрузит контейнеризованную версию OpenShift
* Выделит набор томов Persistent Volumes для организации постоянного хранилища
* Задействует ряд дополнительных модулей для расширения базовой функциональности OpenShift
* Создаст учетные записи администратора и разработчика для взаимодействия с платформой
После запуска CDK предоставит URL для доступа к веб-консоли, а также учетные данные для входа в аккаунт разработчика.
В общем, при выполнении всех предварительных условий базовая установка Container Development Kit не должна вызывать затруднений.
**А 16 июня на [DevOpsDays Moscow 2018](http://devopsdays.ru/) мы проведем мастер-класс/воркшоп/живую демонстрацию сценария использования платформы OpenShift, развернутой в публичном облаке Azure.**
Покажем все три варианта деплоя – из исходного кода, из образа контейнера, из шаблона. Покажем как просто настроить вебхуки, чтобы наше приложение автоматически пересобиралось по наступлению определенного события, например после коммита. Покажем сценарий A/B теста, расскажем про концепцию service account и запустим супер-легаси приложение в контейнере.
Потратим всего час вашего времени, чтобы показать как (по нашему скромному мнению) быстро и просто решаются ваши ежедневные CI/CD задачи с помощью OpenShift Container Platform на Microsoft Azure. Приходите!
**БОНУС:** Хотите промо-код на скидку? Пишите нам в личные сообщения. | https://habr.com/ru/post/413441/ | null | ru | null |
# Is Grounded в 2D платформере: как узнать, стоит ли персонаж?
Буду краток. Бился над этой задачей достаточно долгое время, посему решил поделиться решением. Движок — Unity3D.
#### Постановка задачи
Есть персонаж, есть платформы. Само собой, на персонаже коллайдер и ригидбоди, всё двадэ. На платформах тоже коллайдеры. На платформах — эффекторы, ибо платформы должны быть твердые только сверху. То есть, если перснаж упал на платформу, он на ней стоит. Но если персонаж идет мимо платформы или прыгает под ней — он свободно проходит через нее.
Персонаж может прыгать, только если стоит на платформе. Нужно знать, стоим ли мы.
Условия:
1) Форма платформы произвольная.
2) Персонаж может стоять на самом краю платформы.
3) Платформы могут быть наклонными.
4) Платформы могут двигаться.
#### Популярное решение и почему оно не подходит
В стандартном примере из ассет-стора предлагается использовать дополнительный геймобжект под персонажем, кидать из персонажа рэйкасты в геймобжект и следить, нет ли пересечения с землей.
1) Если мы «идем мимо» или «запрыгиваем на», то рэйкаст вполне поймает «землю», хотя персонаж не стоит.
2) Рэйкаст работает по конкретной точке, а не по площади. А значит, если платформа не будет находиться именно под точкой рэйкаста — например, мы стоим на краю платформы, или на маленьком камушке — проверка ее не заметит.
#### Решение
Решение нельзя получить логически, только опытным путем. Ибо оно проистекает из особенностей работы физики движка. Вам нужны:
using System.Linq — вообще удобная штука, рекомендую ознакомиться, если еще не. Использую для поиска по коллекциям, уничтожает 90% форычей с вложенными ифами.
GetComponent().bounds.min.y — низ вашего коллайдера, то бишь минимальная ордината
OnCollisionStay2D [docs.unity3d.com/ScriptReference/Collider2D.OnCollisionStay2D.html](http://docs.unity3d.com/ScriptReference/Collider2D.OnCollisionStay2D.html)
OnCollisionExit2D
CollisionContacts [docs.unity3d.com/ScriptReference/Collision-contacts.html](http://docs.unity3d.com/ScriptReference/Collision-contacts.html) [docs.unity3d.com/ScriptReference/ContactPoint-point.html](http://docs.unity3d.com/ScriptReference/ContactPoint-point.html)
OnCollisionStay2D срабатывает, когда персонаж и платформа движутся друг относительно друга. При попадании персонажа на платформу т.е. при OnCollisionEnter2D вышеуказанное событие тоже сработает.
Так вот, оказывается, если персонаж стоит на платформе, то геометрически его коллайдер и коллайдер платформы не пересекаются. А значит, «низ персонажа» должен быть ВНЕЗАПНО выше точки контакта. ВСЁ!
1) Создаем список:
```
List GroundColliders = new List();
```
2) По событию OnCollisionStay2D проверяем и при необходимости добавляем коллайдеры:
```
void OnCollisionStay2D(Collision2D coll)
{
if (!GroundColliders.Contains(coll.collider))
foreach (var p in coll.contacts)
if (p.point.y < myCollider.bounds.min.y)
{
GroundColliders.Add(coll.collider);
break;
}
}
```
3) Если больше не пересекаемся с платформой — удаляем ее из списка:
```
void OnCollisionExit2D(Collision2D coll)
{
if (GroundColliders.Contains(coll.collider))
GroundColliders.Remove(coll.collider);
}
```
4) Угадайте, что проверяем:
```
bool IsGrounded
{
get
{
return GroundColliders.Count > 0;
}
}
```
Просто, понятно, достаточно универсально, безо всяких тегов, рэйкастов, дополнительных геймобжектов. Пользуйтесь на здоровье. | https://habr.com/ru/post/279407/ | null | ru | null |
# Уязвимость скриптов инициализации Cryptsetup в Debian: достаточно просто зажать Enter
В безопасности Debian и ряда других дистрибутивов Linux обнаружилась огромная брешь, которая оставалась незамеченной с версии 2.6. Все интернет-издания ссылаются на [отчет](http://hmarco.org/bugs/CVE-2016-4484/CVE-2016-4484_cryptsetup_initrd_shell.html) авторства Гектора Марко и Исмаила Риполла из компании Cybersecurity Group.
Уязвимость находится в скриптах, которые дают доступ к разбивке системы на разделы, при условии, что процедура защищена с помощью Linux Unified Key Setup (LUKS). Сведения о «слабом месте» были обнародованы 11 ноября во время конференции по безопасности [DeepSec 2016](https://deepsec.net/) в Вене. Название доклада, прозвучавшего со сцены, — «Злоупотребление LUKS для взлома системы».
### Спать с открытой входной дверью
Уязвимость в системе дает доступ к оболочке корневых файлов initramfs. Проблема стабильна и не зависит от особенностей системы или конфигурации. Взломщики могут скопировать, внести изменения или разрушить жесткий диск и еще настроить сеть на неавторизованную передачу данных.
Чтобы активировать уязвимость, надо загрузить систему, нажать «Enter», подержать и подождать около полутора минут. После этого система приведет вас в корневую оболочку BusyBox. Эту проблему в первую очередь нужно решать в системах библиотек, банкоматах, аэропортах — везде, где весь процесс загрузки защищен всего лишь паролем в BIOS, а из устройств ввода есть мышка, клавиатура. Уязвимы могут быть и облачные окружения без физического доступа.
### Какие системы подвержены уязвимости
Debian и Ubuntu с зашифрованными системными разделами — скорее всего, все дистрибутивы, но авторы отчета это не проверяли. Также все системы с Dracut вместо initramfs — это Fedora, Red Hat Enterpise Linux, и SUSE Linux Enterprise Server.
### Защита разделения дискового пространства
Происходит во время инсталляции системы, когда предлагается поделить диск, если есть необходимость, и отформатировать его части. После этого пользователь может выбрать опцию шифрования из соображений безопасности.
### Пример
Ниже показано, как выглядит классическая структура уязвимой системы, защищенной всего одним паролем.
Видно, что `/dev/sda5` зашифровано и использовано как физический диск в группе `lubuntu-vg`, которая состоит из двух логических дисков `lubuntu--vg-root` и `lubuntu--vg-swap_1`.
### Чем чревато
С доступом к консоли и опцией перезагрузки системы хакер способен запустить оболочку без корневых разрешений в окружении initrd. Пароль разблокирует системный раздел. Если один раздел запаролен, это не значит, что и остальные тоже защищены. Злоумышленник может многое: от расширения прав локального пользователя до полного удаления всей информации на диске.
### Как так получилось
Брешь образовалась в некорректной процедуре обработки проверки пароля. После трех неудачных попыток система позволяет пробовать еще и еще.
Корень ошибки скрывается в файле `/scripts/local-top/cryptroot`. Как только вы превысили максимальное количество попыток обвала переходных аппаратных средств, вы получаете права доступа к корневому уровню.
### Таблетка от невнимательности
Остановите последовательность загрузки, когда количество попыток введения пароля заканчивается. Этот патч откладывает выполнение навсегда. Чтобы выйти — перезагрузите компьютер.
### Что делать
Разработчики дистрибутивов выпустят фикс проблемы, но заботливым администраторам ждать не стоит — пропатчите систему сами.
В комментариях к посту пользователь [demfloro](https://habrahabr.ru/users/demfloro/) указал на возможный обход проблемы до исправления: нужно добавить параметр `panic` к строке загрузки. Подробнее можно посмотреть у авторов [отчета](http://hmarco.org/bugs/CVE-2016-4484/CVE-2016-4484_cryptsetup_initrd_shell.html) в разделе «Workaround». | https://habr.com/ru/post/315376/ | null | ru | null |
# Пилим данные с комфортом
Доброго времени дня.
В реальной практике довольно часто сталкиваешься с задачами, далекими от сложных ML алгоритмов, но при этом являющихся не менее важными и насущными для бизнеса.
Поговорим об одной из них.
Задача сводится к тому что бы распределить (распилить, рассплитовать — жаргон бизнеса неиссякаем) данные какой-нибудь целевой таблицы с агрегатами (совокупные значения) на таблицу более детальной гранулярности.
Например коммерческому департаменту надо разбить годовой план, согласованный на уровне брендов — детально до продукции, маркетологам разбить годовой бюджет маркетинга по территориям страны, планово-экономическому департаменту разбить общехозяйственные издержки по центрам финансовой ответственности, и т.д. и т.п.
Если вы почувствовали что задачи подобные этой уже маячат перед вами на горизонте или уже относитесь к пострадавшим от таких задач, то прошу под кат.
Рассмотрим реальный пример:
Спускают в качестве задачи план продаж как на картинке ниже (я намеренно сделал пример упрощенным, в реальности — полотнище в экселе на 100-200 мгб).
Пояснение по заголовкам:
* pos\_terr-территория(область) торговой точки
* pos\_fo — федеральный округ торговой точки (например ЦФО-Центральный федеральный округ)
* product\_brend — бренд продукции
* product\_class- класс продукции
* plan.sales- план продаж в чем-либо.
И просят к примеру разбить свою мега-таблицу (в рамках нашего детского примера она конечно поскромнее) — до канала продаж. На вопрос — по какой логике разбивать получаю ответ: «а возьмите статистику фактических продаж за 4-й квартал такого-то года, получите фактические доли каналов в % для каждой строки плана и по этим долям строки плана и разбивайте».
На самом деле это самый частый ответ в таких задачах…
Пока все кажется достаточно простым.
Получаю этот факт (см.картинку ниже):
* pos\_channell — канал продаж (целевой атрибут для плана)
* fact.sales — фактические продажи чего-то.
Исходя из полученного подхода к «распиливанию» на примере первой строчки плана мы ее разобьем на основе факта как-то так:
Однако если сопоставить факт с планом для всей таблички для того чтобы понять — все ли строки плана получится адекватно «распилить» по долям то получим следующую картину: (зеленый цвет — все атрибуты строки плана совпали с фактом, желтые ячейки — не совпали).
* В 1й строке плана все поля полностью найдены в факте.
* Во 2й строке плана не найдена в факте соответствующая территория
* В 3й строке плана не хватает в факте бренда
* В 4й строке плана не хватает в факте территории и федерального округа
* В 5й строке плана не хватает в факте бренда и класса.
Как говорил Паниковский: «Пилите Шура, пилите--они золотые...»
Иду к бизнес-заказчику и уточняюсь на примере 2й строки, какой он видит подход для таких ситуаций?
Получаю ответ: «для случаев когда не получается посчитать долю каналов для бренда № 2 в Смоленской области (с учетом того что Смоленская область у нас в Центральном федеральном округе-ЦФО) — разбейте тогда эту строку по структуре каналов внутри всего ЦФО!»
То есть для {Смоленской области+бренд\_2} агрегируем факт на уровне ЦФО и разбиваем Смоленскую область как-то так:
Возвращаюсь и переваривая услышанное пытаюсь обобщить в более универсальную эвристику:
Если данных нет на текущем уровне детализации таблицы фактов то перед расчетом долей для целевого поля (канал продаж) агрегируем таблицу фактов до атрибута иерархии выше.
То есть если нет для территории то агрегируем факт на уровень иерархии выше — доли для того же ЦФО что и в плане. Если нет для бренда то по иерархии выше есть класс продукта — соответственно пересчитываем доли на тот же класс и так далее.
Т.е. мы объединяем план и факт по полям сцепки для которых считаем доли в факте и на каждой итерации по оставшемуся нераспрделенному плану последовательно уменьшаем состав полей сцепки.
Тут уже вырисовывается определенный шаблон распределения данных:
1. Распределяем план по факту на основе полного совпадения соответствующих полей
2. Получаем разбитый план (его накапливаем в промежуточный результат) и неразбитый план (не все строки совпали)
3. Берем неразбитый план и разбиваем его по факту на уровень иерархии выше (т.е. отказываемся от определенного поля сцепки этих 2-х таблиц и агрегируем факт без этого поля для расчета долей)
4. Получаем разбитый план (его добавляем в промежуточный результат) и неразбитый план (не все строки совпали)
5. И те же шаги повторяем пока не останется «нераспиленного» плана.
Вообще нас никто не обязывает последовательно удалять поля сцепки только в рамках иерархии. Например мы уже удалили из полей сцепки бренд и территорию и оставшийся план распределили по: класс\_продукции (иерархия выше бренда)+Фед.округ (иерархия выше территории). И все равно получили какой-то не распределенный остаток плана.
Далее мы можем удалить из полей сцепки либо класс продукции либо федеральный округ т.к. они уже не вкладываются в иерархию друг-друга.
Учитывая что полей в таких таблицах десятки и строк — до миллиона делать руками такие манипуляции — задача не самая приятная.
А если учесть что задачи такого рода прилетают ко мне регулярно в конце каждого года (утверждение бюджетов след.года на совете директоров) — то пришлось переводить этот процесс на какой-то гибкий универсальный шаблон.
А так как большую часть времени я работаю с данными через R — реализация соответственно то же на нем.
Для начала нам понадобится написать универсальную магическую функцию, которая будет принимать базовую таблицу(basetab) с данными для разбивки (в нашем примере-план) и таблицу для расчета долей (sharetab) на основе которых и будем «пилить» данные (в нашем примере-факт). Но функция должна еще понимать что с этими объектами надо делать, поэтому функция будет еще принимать вектор имен полей сцепки (merge.vrs) — т.е. те поля которые одинаково называются в обеих таблицах и позволят нам по этим полям соединить одну таблицу с другой там где это получится (т.е. right join). Так же функция должна понимать-какой столбец базовой таблицы надо брать в распределение (basetab.value) и на основе какого поля считать доли (sharetab.value). Ну и самая главное — что брать за результирующее поле (sharetab.targetvars), в нашем случае мы хотим план детализировать по каналу продаж из факта.
Кстати эта переменная sharetab.targetvars не случайно у меня во множественном числе — это может быть не одно поле а векктор имен полей, для случаев когда надо в базовую таблицу добавить из таблицы долей не одно поле а сразу несколько (например на основе факта разбить план не только по каналу продаж но и по наименованию продукции, входящей в бренд).
Да, и еще одно условие:) моя функция должна быть максимально локоничной и удобочитаемой, без всякой многоэтажности на 2 экрана (очень не люблю большие функции).
В последнее условие максимально комфортно вписался популярный пакет dplyr а учитывая что его pipeline операторы должны понимать спущенные в функцию текстовые названия полей — не обошлось без [Standart evaluation](https://dplyr.tidyverse.org/articles/programming).
Вот эта крошка (не считая внутренних комментов):
```
fn_distr <- function(sharetab, sharetab.value, sharetab.targetvars, basetab, basetab.value, merge.vrs,level.txt=NA) {
# sharetab - объект=таблица драйвер распределения
# sharetab.value - название поля с числами по которому будет пересчет в доли из таблицы-драйвер
# sharetab.targetvars - название целевого текстового поля из таблицы-драйвер по которому будет дробится базовая таблица на основе долей
# basetab - объект=таблица с базовыми показателями к распределению
# basetab.value - название поля с числами которые должны быть распределены
# merge.vrs - название полей объединения 2-х таблиц
# level.txt - примечание пользователя для тек.итерации чтобы можно было обосновать строку результата (если пользователь не указал то merge.vrs)
require(dplyr)
sharetab.value <- as.name(sharetab.value)
basetab.value <- as.name(basetab.value)
if(is.na(level.txt )){level.txt <- paste0(merge.vrs,collapse = ",")}
result <- sharetab %>% group_by_at(.vars = c(merge.vrs, sharetab.targetvars)) %>% summarise(sharetab.sum = sum(!!sharetab.value),.groups = 'drop') %>%
group_by_at(.vars = merge.vrs) %>% mutate(sharetab.share = sharetab.sum / sum(sharetab.sum)) %>% ungroup %>%
right_join(y = basetab, by = merge.vrs) %>% mutate(distributed.result = !!basetab.value * sharetab.share, level = level.txt) %>%
select(-sharetab.sum,-sharetab.share)
return(result)
}
```
На выходе функция должна возвращать data.frame объединения двух таблиц с теми строками плана+факта где удалось разбить на текущей версии полей сцепки, и с оригинальными строками плана (и пустым фактом) в строках, где на текущей итерации разбить план не удалось.
Т.е результат возвращаемый функцией после первой итерации (разбивка первой строки плана для ярославской области) будет выглядеть так:
Далее этот результат можно забрать по непустым distributed.result в накопительный результат а по пустым (NA) distributed.result — отправить на следующую такую же типовую итерацию но с разбивкой по долям на более высоком уровне иерархии.
Вся прелесть и все удобство в том что работа идет однотипными блоками и одной универсальной функцией, все что надо на каждом шаге (итерации) — это подкорректировать вектор merge.vrs и наблюдать как магия делает всю эту нудную работу за тебя:
Да, чуть не забыл маленький нюанс: если что-то пойдет не так и в самом конце мы получим разбитый план который суммарно не будет равен плану до разбивки — будет сложно отследить на какой итерации все пошло не так.
Поэтому каждую итерацию снабжаем контрольной суммой:
```
Сумма(План_изначальный)-Сумма(План_распределенный_в_накопленном результате)-Сумма(План_нераспределенный_после_тек.итерации)=0
```
Теперь попробуем прогнать наш пример через шаблон распрделения и посмотреть что получим на выходе.
Для начала получим исходные данные:
```
library(dplyr)
plan <- data_frame(pos_terr = c("ярославская область", "смоленская область",
"краснодарский край", "свердловская область", "томская область"),
pos_fo = c("ЦФО", "ЦФО", "ЮФО", "УФО", "СФО"),
product_brend = c("brend_1", "brend_2", "brend_3", "brend_4", "brend_5"),
product_class = c("class_1", "class_1", "class_2", "class_2", "class_3"),
plan.sales = c(100, 200, 300, 400, 500))
fact <- data_frame(pos_terr = c("ярославская область", "ярославская область",
"калужская область", "тверская область", "тверская область","краснодарский край", "краснодарский край",
"томская область", "томская область", "томская область"),
pos_fo = c("ЦФО", "ЦФО","ЦФО","ЦФО", "ЦФО", "ЮФО", "ЮФО", "СФО", "СФО", "СФО"),
product_brend = c("brend_1", "brend_1", "brend_2", "brend_2","brend_2", "brend_4", "brend_4", "brend_1", "brend_2", "brend_4"),
product_class = c("class_1", "class_1", "class_1","class_1","class_1", "class_2", "class_2", "class_1", "class_1", "class_2"),
pos_channell = c("розница", "опт", "хорека","опт", "хорека", "розница", "опт", "хорека", "розница", "хорека"),
fact.sales = c(16.38, 11.64, 30.73,60, 20, 6.40, 26.49, 46.63, 65.96, 98.81))
Затем зарезервируем остаток нераспрделенного плана (пока что равен исходному) и пустой фрейм для результата.
plan.remain <- plan
result.total <- data_frame()
```
**1. Распределяем по терр, фо (фед.округу), бренд, класс**
```
merge.fields <- c("pos_terr","pos_fo","product_brend", "product_class")
result.current <- fn_distr(sharetab = fact,sharetab.value = "fact.sales",sharetab.targetvars = "pos_channell",
basetab = plan.remain,basetab.value = "plan.sales",merge.vrs = merge.fields)
result.total <- result.current %>% filter(!is.na(distributed.result)) %>% select(-plan.sales) %>% bind_rows(result.total)
# ниже получаем остаток плана - нераспределенные записи для следующих итераций
plan.remain <- result.current %>% filter(is.na(distributed.result)) %>% select(colnames(plan))
# на каждой итерации проверяем что сумма оставшегося плана и накопительное распрделение = сумме исходного плана
cat("Расхождение :",sum(plan.remain$plan.sales)+sum(result.total$distributed.result)-sum(plan$plan.sales),"\n",
"Осталось распределить:",nrow(plan.remain)," записей")
```
**2. Распределяем по фо, бренд, класс (т.е. отказываемся от территории в факте)**
Единственное отличие от первого блока — слегка укоротили merge.fields удалив в нем pos\_terr
```
merge.fields <- c("pos_fo","product_brend", "product_class")
result.current <- fn_distr(sharetab = fact,sharetab.value = "fact.sales",sharetab.targetvars = "pos_channell",
basetab = plan.remain,basetab.value = "plan.sales",merge.vrs = merge.fields)
result.total <- result.current %>% filter(!is.na(distributed.result)) %>% select(-plan.sales) %>% bind_rows(result.total)
plan.remain <- result.current %>% filter(is.na(distributed.result)) %>% select(colnames(plan))
cat("Расхождение :",sum(plan.remain$plan.sales)+sum(result.total$distributed.result)-sum(plan$plan.sales),"\n",
"Осталось распределить:",nrow(plan.remain)," записей")
```
**3. Распределяем по фо, класс**
```
merge.fields <- c("pos_fo", "product_class")
result.current <- fn_distr(sharetab = fact,sharetab.value = "fact.sales",sharetab.targetvars = "pos_channell",
basetab = plan.remain,basetab.value = "plan.sales",merge.vrs = merge.fields)
result.total <- result.current %>% filter(!is.na(distributed.result)) %>% select(-plan.sales) %>% bind_rows(result.total)
plan.remain <- result.current %>% filter(is.na(distributed.result)) %>% select(colnames(plan))
cat("Расхождение :",sum(plan.remain$plan.sales)+sum(result.total$distributed.result)-sum(plan$plan.sales),"\n",
"Осталось распределить:",nrow(plan.remain)," записей")
```
**4. Распределяем по класс**
```
merge.fields <- c( "product_class")
result.current <- fn_distr(sharetab = fact,sharetab.value = "fact.sales",sharetab.targetvars = "pos_channell",
basetab = plan.remain,basetab.value = "plan.sales",merge.vrs = merge.fields)
result.total <- result.current %>% filter(!is.na(distributed.result)) %>% select(-plan.sales) %>% bind_rows(result.total)
plan.remain <- result.current %>% filter(is.na(distributed.result)) %>% select(colnames(plan))
cat("Расхождение :",sum(plan.remain$plan.sales)+sum(result.total$distributed.result)-sum(plan$plan.sales),"\n",
"Осталось распределить:",nrow(plan.remain)," записей")
```
**5. Распределяем по ФО**
```
merge.fields <- c( "pos_fo")
result.current <- fn_distr(sharetab = fact,sharetab.value = "fact.sales",sharetab.targetvars = "pos_channell",
basetab = plan.remain,basetab.value = "plan.sales",merge.vrs = merge.fields)
result.total <- result.current %>% filter(!is.na(distributed.result)) %>% select(-plan.sales) %>% bind_rows(result.total)
plan.remain <- result.current %>% filter(is.na(distributed.result)) %>% select(colnames(plan))
cat("Расхождение :",sum(plan.remain$plan.sales)+sum(result.total$distributed.result)-sum(plan$plan.sales),"\n",
"Осталось распределить:",nrow(plan.remain)," записей")
```
Как видим «нераспиленного» плана не осталось и арифметика распрделенного плана равна исходному.
А вот и результат c каналами продаж (в правом столбце функция выводит -по каким полям шла сцепка/агрегация что бы потом понять откуда такое распределение):
Вот собственно и все. Статья получилась не очень маленькая, но тут больше поясняющего текста чем самого кода.
Надеюсь этот гибкий подход будет экономить время и нервы не только мне :-)
Спасибо за внимание. | https://habr.com/ru/post/438556/ | null | ru | null |
# Распознавание речи на python с помощью pocketsphinx или как я пытался сделать голосового ассистента
Это туториал по использованию библиотеки pocketsphinx на Python. Надеюсь он поможет вам
побыстрее разобраться с этой библиотекой и не наступать на мои грабли.
Началось все с того, что захотел я сделать себе голосового ассистента на python. Изначально для распознавания решено было использовать библиотеку [speech\_recognition](https://pypi.python.org/pypi/SpeechRecognition). Как оказалось, я [не один](http://pythono.ru/speech-ai/) такой. Для распознавания я использовал Google Speech Recognition, так как он единственный не требовал никаких ключей, паролей и т.д. Для синтеза речи был взят gTTS. В общем получился почти клон [этого](http://pythono.ru/speech-ai/) ассистента, из-за чего я не мог успокоиться.
Правда, успокоиться я не мог не только из-за этого: ответа приходилось ждать долго (запись заканчивалась не сразу, отправка речи на сервер для распознавания и текста для синтеза занимала немало времени), речь не всегда распознавалась правильно, дальше полуметра от микрофона приходилось кричать, говорить нужно было четко, синтезированная гуглом речь звучала ужасно, не было активационной фразы, то есть звуки постоянно записывались и передавались на сервер.
Первым усовершенствованием был синтез речи при помощи yandex speechkit cloud:
```
URL = 'https://tts.voicetech.yandex.net/generate?text='+text+'&format=wav⟨=ru-RU&speaker=ermil&key='+key+'&speed=1&emotion=good'
response=requests.get(URL)
if response.status_code==200:
with open(speech_file_name,'wb') as file:
file.write(response.content)
```
Затем настала очередь распознавания. Меня сразу заинтересовала надпись "CMU Sphinx (works offline)" на [странице библиотеки](https://pypi.python.org/pypi/SpeechRecognition). Я не буду рассказывать об основных понятиях pocketsphinx, т.к. до меня это сделал [chubakur](https://habrahabr.ru/users/chubakur/)(за что ему большое спасибо) в [этом](https://habrahabr.ru/post/267539/) посте.
### Установка Pocketsphinx
~~Сразу скажу, так просто pocketsphinx установить не получится(по крайней мере у меня не получилось), поэтому `pip install pocketsphinx` не сработает, упадет с ошибкой, будет ругаться на wheel.~~ Установка через pip будет работать только если у вас стоит swig. В противном случае чтобы установить pocketsphinx нужно перейти [вот сюда](https://pypi.python.org/pypi/pocketsphinx#downloads) и скачать установщик(msi). **Обратите внимание: установщик есть только для версии 3.5!**
### Распознавание речи при помощи pocketsphinx
Pocketsphinx может распознавать речь как с микрофона, так и из файла. Также он может искать горячие фразы(у меня не очень получилось, почему-то код, который должен выполняться когда находится горячее слово выполняется несколько раз, хотя произносил его я только один). От облачных решений pocketsphinx отличается тем, что работает оффлайн и может работать по ограниченному словарю, вследствие чего повышается точность. Если интересно, на [странице библиотеки](https://pypi.python.org/pypi/pocketsphinx) есть примеры. Обратите внимание на пункт "Default config".
#### Русская языковая и акустическая модель
Изначально pocketsphinx идет с английской языковой и акустической моделями и словарем. Скачать русские можно по [этой ссылке](https://sourceforge.net/projects/cmusphinx/files/Acoustic%20and%20Language%20Models/Russian/zero_ru_cont_8k_v3.tar.gz/download). Архив нужно распаковать. Затем надо папку `/zero\_ru\_cont\_8k\_v3/zero\_ru.cd\_cont\_4000` переместить в папку `C:/Users/tutam/AppData/Local/Programs/Python/Python35-32/Lib/site-packages/pocketsphinx/model`, где это папка в которую вы распаковали архив. Перемещенная папка — это акустическая модель. Такую же процедуру надо проделать с файлами `ru.lm` и `ru.dic` из папки `/zero\_ru\_cont\_8k\_v3/`. Файл `ru.lm` это языковая модель, а `ru.dic` это словарь. Если вы все сделали правильно, то следующий код должен работать.
```
import os
from pocketsphinx import LiveSpeech, get_model_path
model_path = get_model_path()
speech = LiveSpeech(
verbose=False,
sampling_rate=16000,
buffer_size=2048,
no_search=False,
full_utt=False,
hmm=os.path.join(model_path, 'zero_ru.cd_cont_4000'),
lm=os.path.join(model_path, 'ru.lm'),
dic=os.path.join(model_path, 'ru.dic')
)
print("Say something!")
for phrase in speech:
print(phrase)
```
Предварительно проверьте чтобы микрофон был подключен и работал. Если долго не появляется надпись `Say something!` — это нормально. Большую часть этого времени занимает создание экземпляра `LiveSpeech`, который создается так долго потому, что русская языковая модель весит более 500(!) мб. У меня экземпляр `LiveSpeech` создается около 2 минут.
Этот код должен распознавать почти любые произнесенные вами фразы. Согласитесь, точность отвратительная. Но это можно исправить. И увеличить скорость создания `LiveSpeech` тоже можно.
#### JSGF
Вместо языковой модели можно заставить pocketsphinx работать по упрощенной грамматике. Для этого используется `jsgf` файл. Его использование ускоряет создание экземпляра `LiveSpeech`. О том как создавать файлы граматики написано [здесь](https://habrahabr.ru/post/267539/). Если языковая модель есть, то `jsgf` файл будет игнорироваться, поэтому если вы хотите использовать собственный файл грамматики, то нужно писать так:
```
speech = LiveSpeech(
verbose=False,
sampling_rate=16000,
buffer_size=2048,
no_search=False,
full_utt=False,
hmm=os.path.join(model_path, 'zero_ru.cd_cont_4000'),
lm=False,
jsgf=os.path.join(model_path, 'grammar.jsgf'),
dic=os.path.join(model_path, 'ru.dic')
)
```
Естественно файл с грамматикой надо создать в папке `C:/Users/tutam/AppData/Local/Programs/Python/Python35-32/Lib/site-packages/pocketsphinx/model`. И еще: при использовании `jsgf` придется четче говорить и разделять слова.
#### Создаем свой словарь
Словарь — это набор слов и их транскрипций, чем он меньше, тем выше точность распознавания. Для создания словаря с русскими словами нужно воспользоваться проектом [ru4sphinx](https://github.com/zamiron/ru4sphinx). Качаем, распаковываем. Затем открываем блокнот и пишем слова, которые должны быть в словаре, каждое с новой строки, затем сохраняем файл как `my_dictionary.txt` в папке `text2dict`, в кодировке **UTF-8**. Затем открываем консоль и пишем: `C:\Users\tutam\Downloads\ru4sphinx-master\ru4sphinx-master\text2dict> perl dict2transcript.pl my_dictionary.txt my_dictionary_out.txt`. Открываем `my_dictionary_out.txt`, копируем содержимое. Открываем блокнот, вставляем скопированный текст и сохраняем файл как `my_dict.dic` (вместо "текстовый файл" выберите "все файлы"), в кодировке **UTF-8**.
```
speech = LiveSpeech(
verbose=False,
sampling_rate=16000,
buffer_size=2048,
no_search=False,
full_utt=False,
hmm=os.path.join(model_path, 'zero_ru.cd_cont_4000'),
lm=os.path.join(model_path, 'ru.lm'),
dic=os.path.join(model_path, 'my_dict.dic')
)
```
Некоторые транскрипции может быть нужно подправить.
### Использование pocketsphinx через speech\_recognition
Использовать pocketsphinx через speech\_recognition имеет смысл только если вы распознаете английскую речь. В speech\_recognition нельзя указать пустую языковую модель и использовать jsgf, а следовательно для распознавания каждого фрагмента придется ждать 2 минуты. Проверенно.
### Итог
Угробив несколько вечеров я понял, что потратил время впустую. В словаре из двух слов(да и нет) сфинкс умудряется ошибаться, причем часто. Отъедает 30-40% celeron'а, а с языковой моделью еще и жирный кусок памяти. А Яндекс почти любую речь распознает безошибочно, при том не ест память и процессор. Так что думайте сами, стоит ли за это браться вообще.
**P.S.**: это мой первый пост, так что жду советы по оформлению и содержанию статьи. | https://habr.com/ru/post/351376/ | null | ru | null |
# Плагин для всплывающих подсказок Simpletip
Минусы jQuery Tools Tooltip, плюсы SimpleTip, а так же немного о том, как решить некоторые проблемы его использования.
До недавнего времени пользовался удобным и маленьким плагином [jQuery Tools Tooltip](http://flowplayer.org/tools/demos/tooltip/index.html), который всем меня устраивал.
И вот решил найти другой потому что:
1. Отображается в подсказке текст, который содержится в атрибуте **title** элемента, для которого нужна подсказка. Можно еще передавать через атрибут **tip** в конструкторе, но передавать нужно **jQuery selector**, а не просто текст. В общем не очень удобно и не очень гибко;
2. После создания подсказки невозможно поменять текст и вообще содержимое подсказки (ни простая смена атрибута **title**, ни последующий вызов конструктора `$('#email').tooltip();` не помогает). В общем, нет штатного средства, это огорчает.
Решил поискать альтернативу, так как мне нужно было именно обновлять текст подсказки (так как взаимодействие с сервером через ajax и страница не перегружается).
Нагуглил вот такой плагин [SimpleTip](http://craigsworks.com/projects/simpletip/)
Из приятностей:
1. упакованный файл весит 3.3 кБ против 3.4 у Tools Tooltip;
2. передача текста в конструкторе `$('#email').simpletip({content: 'hello world'});`, туда же можно передавать html, тоесть отображать вообще что душе угодно;
3. возможность обновить содержимое подсказки через `update('new content');`, да и вообще динамически можно подгружать из разных источников;
4. больше, больше настроек и возможности управлять поведением всплывающих подсказок.
Неприятным было лишь то, что, несмотря на заверение автора *«it allows you to create tooltips with ease on any element „*, подсказки для **input[type=text]** элементов не отображались. После просмотра фаербагом страницы оказалось, что плагин создает скрытый **div** внутри элемента, для которого нужна подсказка:
> 1. var tooltip = jQuery(document.createElement('div'))
> 2. ...
> 3. .appendTo(elem);
>
(26 строка в коде).
Ну и понятное дело, что **div** внутри **input** — ход не верный. Поэтому меняем **appendTo** на **insertAfter**, и подсказки начинают весело отображаться и для **input**ов.
Так же есть небольшая проблема с отображением в диалоговых окнах **jqueryui**. для корректного отображения в них нужно помимо стандартного класса **.tooltip** создать класс, допустим **tooltipForDialogBox**, где убрать **position: absolute;** и тултип будет отображаться и в диалоговых окнах.
И напоследок, если нужно поменять текст сообщения, то нужно использовать уже метод **update**, так как тултип уже создан. Чтобы определить существует ли он уже, я использовал такую конструкцию:
> 1. if ($('#edit').next().hasClass('tooltipForDialogBox'))
> 2. {
> 3. var tip = $('#edit').eq(0).simpletip();
> 4. tip.update('New content');
> 5. }
> 6. else
> 7. {
> 8. $('#edit')
> 9. .simpletip({
> 10. content: 'first content',
> 11. baseClass: 'tooltipForDialogBox'
> 12. });
> 13. }
>
[На странице плагина](http://craigsworks.com/projects/simpletip/) имеется хорошее API и demo.
Надеюсь, кому то окажется полезен пост и сохранит ему время, чтобы не жалко было моего потраченного) | https://habr.com/ru/post/103242/ | null | ru | null |
# Рисуем анимированную сцену с помощью css
Передохнём от верстки всяких пользовательских интерфейсов и просто порисуем на CSS. Рисовать будем такую вот сцену:
[Смотреть на jsfiddle.](http://jsfiddle.net/AlexanderN/onjsw3kv/2/)
В статье я попробую описать пошаговое создание этой сцены.
Описанный код работает на webkit браузерах (Chrome, Safari, Opera последних версий). Для работы в других браузерах вместо префиксв -webkit нужно воспользоваться соответствующими префиксами (-moz, -ms, -o).
Создаем сцену и небо
```
```
```
.scene {
position: relative;
width: 800px;
height: 600px;
margin: 50px auto;
overflow: hidden;
background-image: -webkit-linear-gradient(top, #011428, #032a54);
}
```
с помощью linear-gradient(top, #011428, #032a54) мы заполнили сцену градиентом от темноватого (#011428) до более светлого (#032a54) оттенка синего начиная сверху (top)
Рисуем сугробы. За основу возьмем элипсы которые можно создать из div'ов задав им border-radius: 50%
```
.ground {
position: absolute;
width: 770px;
height: 200px;
border-radius: 50%;
background-color: #99a;
}
```
Позиционируем 4 эллипса внизу сцены
```
```
```
.ground {
width: 400px;
background-color: #f5f5f5;
border-radius: 50%;
width: 770px;
height: 200px;
position: absolute;
bottom: 0;
margin-bottom: -80px;
right: 140px;
background-color: #99a;
}
.ground.back-1 {left: 180px;}
.ground.front {margin-bottom: -124px;left: -27px;}
.ground.front-2 {margin-bottom: -109px;right: -508px;}
```
Делаем сугробы объемными добавив к классу .ground внутренню тень
```
box-shadow: 0 0 100px #457eb2 inset;
```
Рисуем луну и звезды
```
```
```
.moon {
position: absolute;
width: 60px;
height: 60px;
top: 100px;
left: 100px;
background-color: #ffffaa;
border-radius: 50%;
}
.stars {
position: absolute;
width: 100%;
height: 100%;
}
.star {
position: absolute;
border-radius: 50%;
width: 1px;
height: 1px;
background-color: #ffffff;
}
.star:nth-child(1) {top: 100px;left: 685px;}
.star:nth-child(2) {top: 37px;left: 537px;}
.star:nth-child(3) {top: 150px;left: 350px;}
.star:nth-child(4) {top: 50px;left: 320px;}
.star:nth-child(5) {top: 30px;left: 755px;}
.star:nth-child(6) {top: 70px;left: 483px;}
.star:nth-child(7) {top: 18px;left: 80px;}
```
Добавляем луне эффект свечения
```
box-shadow: 0 0 40px #ffffaa;
```
И звездам тоже:
```
box-shadow: 0 0 10px 2px white;
```
Теперь приступаем к дому. Дом будет состоять из крыши, стены, окна и дымохода. Описываем все это версткой:
```
```
```
.house {
position: absolute;
width: 300px;
height: 365px;
bottom: 50px;
right: 110px;
}
```
Рисуем стену. Эффект бревенчатого сруба можно получить с помощью повторяющегося градиента:
```
.house .wall {
width: 100%;
height: 200px;
position: absolute;
bottom: 0;
background-color: #180c00;
background: repeating-linear-gradient(to bottom, #573808 0%,#3a1e12 15%);
}
```
Делаем окошко. Это будет div с желтым фоном и с коричневой рамкой
```
.house .window {
position: absolute;
height: 70px;
width: 65px;
background-color: #cccc00;
border: 5px solid #3a1e12;
bottom: 53px;
left: 110px;
box-shadow: 0 0 5px black;
}
```
Добавляем к нему еще раму и эффект свечения с помощью box-shadow
```
```
```
.house .window .frame:nth-child(1) {
position: absolute;
height: 100%;
left: 50%;
margin-left: -3px;
width: 7px;
background-color: #3a1e12;
}
.house .window .frame:nth-child(2) {
position: absolute;
width: 100%;
top: 30%;
height: 7px;
background-color: #3a1e12;
}
.house .window .light {
width: 100%;
height: 100%;
background-color: #ffff00;
opacity: 0.5;
box-shadow: 0 0 100px yellow;
}
```
Создаем крышу. Это будет div бордер которого послужит кровлей.
```
.house .roof .roof-wall {
position: absolute;
width: 280px;
height: 280px;
background-color: #573808;
left: 25px;
top:60px;
border: 5px solid #3a1e12;
box-shadow: 0 0 30px black inset;
}
```
Для создания эффекта вагонки снова воспользуемся повторяющимся градиентом, который повернем на 45 градусов
```
background: repeating-linear-gradient(45deg, #573808 0%,#573808 5%,#3a1e12 5%,#3a1e12 5%,#3a1e12 5%,#573808 5%,#3a1e12 6%)
```
Крыша готова, ставим ее на дом повернув на 45 градусов с помощью transform: rotate(45deg) и отрезав половину с помощью overflow: hidden у контейнера
```
.house .roof {
width: 340px;
height: 170px;
right: -20px;
position: absolute;
overflow: hidden;
}
.house .roof .roof-wall {
position: absolute;
width: 280px;
height: 280px;
background-color: #573808;
-webkit-transform: rotate(45deg);
left: 25px;
top:60px;
border: 5px solid #3a1e12;
box-shadow: 0 0 30px black inset;
background: repeating-linear-gradient(45deg, #573808 0%,#573808 5%,#3a1e12 5%,#3a1e12 5%,#3a1e12 5%,#573808 5%,#3a1e12 6%);
}
```
Приделываем трубу, нарисованную с помощью градиента
```
.house .chimney {
position: absolute;
height: 80px;
width: 30px;
top: 58px;
left: 20px;
background: linear-gradient(to right, rgba(42,41,45,1) 0%,rgba(80,84,91,1) 36%,rgba(22,27,33,1) 100%);
}
```
И добавляем шероховатости бревнам, наложив на них пару повторяющихся коричневых градиентов переходящих в прозрачность
```
```
```
.house .wall .crack {
position: absolute;
width: 100%;
height: 100%;
opacity: 0.5;
background: repeating-linear-gradient(3deg, rgba(0,0,0,0) 0%, rgba(0,0,0,0) 2%, rgba(0,0,0,0) 2%,#3a1e12 2%,#3a1e12 2%,#573808 2%,#3a1e12 3%);
}
.house .wall .crack:nth-child(2) {
opacity: 0.3;
background: repeating-linear-gradient(-4deg, rgba(0,0,0,0) 0%, rgba(0,0,0,0) 2%, rgba(0,0,0,0) 2%,#3a1e12 2%,#3a1e12 2%,#573808 2%,#3a1e12 3%);
}
```
Ну вот, у нас получилась уже вполне миленькая картинка
Настало время оживить нашу статичную картинку анимациями. Для начала сделаем чтобы из дымохода появлялись клубы дыма.
Пока что нарисуем одно облако дыма. Это будет полупрозрачный овал со светлым box-shadow ввокруг и радиальным градиентом.
```
```
```
.smoke-area .smoke {
position: absolute;
width: 30px;
height: 30px;
border-radius: 50%;
box-shadow: 0 0 20px lightgray;
background: radial-gradient(ellipse at center, rgba(206,220,231,1) 33%,rgba(89,106,114,0) 100%);
top: 120px;
left: 20px;
}
```
С помощью ключевых кадров опишем траекторию движения и трансформацию этого облака. Оно будет постепенно увеличиваться и становиться прозрачным
```
@-webkit-keyframes smoke-move {
0% {top: 120px; left: 20px}
20% {top: 107px; left: 25px}
30% {top: 95px; left: 35px; opacity: 0.9}
40% {top: 80px; left: 40px; }
50% {top: 65px; left: 50px; }
60% {top: 50px; left: 62px; }
70% {top: 35px; left: 75px; }
80% {top: 25px; left: 90px; }
90% {top: 15px; left: 117px; }
100% {top: 7px; left: 127px; opacity: 0; width: 90px; height: 60px}
}
```
Теперь назначим только что описанную анимацию к нашему облаку, добавив к классу .smoke свойство
```
-webkit-animation: smoke-move 2.3s linear infinite
```
Отлично у нас уже есть рабочий дымоход, но в полноценном виде он должен непрерывно ипускать много клубов дыма, так что добавим еще нескколько штук в верстку.
```
```
Теперь облаков дыма несколько, но пока что толку от этого мало, так как все они движутся одновременно по одной траектории и все это выглядит как одно облако. Описывать новую анимацию для каждого облака слишком топорно и утомительно. Тут хочется какой-то случайности в их движении, например применить что-нибудь типа Math.random() с помощью javascript, но поскольку цель сделать сцену используя только css, прийдется выкручиваться подругому. В нашем случае можно просто заново использовать для каждого элемента уже описанную анимацию *smoke-move*, но с разным временем проигрывания:
```
.smoke-area .smoke:nth-child(2) {
-webkit-animation: smoke-move 2.5s linear infinite
}
.smoke-area .smoke:nth-child(3) {
-webkit-animation: smoke-move 2.7s linear infinite
}
.smoke-area .smoke:nth-child(4) {
-webkit-animation: smoke-move 2.2s linear infinite
}
.smoke-area .smoke:nth-child(5) {
-webkit-animation: smoke-move 2.1s linear infinite
}
.smoke-area .smoke:nth-child(6) {
-webkit-animation: smoke-move 2s linear infinite
}
.smoke-area .smoke:nth-child(7) {
-webkit-animation: smoke-move 2.9s linear infinite
}
```
Теперь клубы дыма движутся по той-же траектории но за различное время что дает видимость их случайного движения:
Через какое-то время цикл анимации движения облаков дыма начнет повторяться, но при достаточно большом количестве циклов этого будет не сильно заментно. Чтобы подобрать наибольший цикл движения в качестве времени анимации нужно указывать [взаимно простые числа.](https://ru.wikipedia.org/wiki/%D0%92%D0%B7%D0%B0%D0%B8%D0%BC%D0%BD%D0%BE_%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%8B%D0%B5_%D1%87%D0%B8%D1%81%D0%BB%D0%B0)
И в качестве изюминки добавим несколько падающих звездочек. Как и раньше начнем с одной, добавим ее как *.meteor* в *div.meteors*
```
```
```
.meteors {
position: absolute;
width: 100%;
height: 100%;
}
```
Описание css начнем с хвоста нашего метеора. Это будет белая линия переходящая в прозрачность.
```
.meteor {
position: absolute;
top: 50px;
left: 280px;
width: 300px;
height: 1px;
-webkit-transform: rotate(-45deg);
background-image: -webkit-linear-gradient(left, white, rgba(255,255,255,0));
}
```
Теперь нарисуем звездочку на конце этого хвоста:
```
.meteor:before {
content: ' ';
position: absolute;
width: 4px;
height: 5px;
background-color: white;
border-radius: 50%;
box-shadow: 0 0 14px 4px white;
margin-top: -2px;
}
```
Опишем анимацию для метеора, будем его двигать меняя отступы создавая эффект полета под наклоном 45 градусов. Метеор будет падать и постепенно исчезать.
```
@-webkit-keyframes meteor {
0% {margin-top: -300px; margin-right: -300px; opacity: 1}
8% {opacity: 0}
10% {margin-top: 300px; margin-left: -600px; opacity: 0}
100% {opacity: 0}
}
```
Запускаем метеор в полет:
```
.meteor {top: 100px;left: 480px;-webkit-animation: meteor 10s linear infinite;}
```
Нужно больше метеоров!
```
```
```
.meteor:nth-child(1) {top: 100px;left: 480px;-webkit-animation: meteor 10s linear infinite;}
.meteor:nth-child(2) {top: 200px;left: 280px;-webkit-animation: meteor 10s linear infinite;}
.meteor:nth-child(3) {top: 250px;left: 790px;-webkit-animation: meteor 9s linear infinite;}
```
Ну вот, сцена готова! | https://habr.com/ru/post/247731/ | null | ru | null |
# SageMathCloud — мечта для любителей Python, математики и Linux
[SageMathCloud](https://cloud.sagemath.com) (сокращённо SMC) — это онлайновый сервис, в котором можно написать математический или любой другой расчёт в Sage или IPython Notebook. Расчёт можно комбинировать с HTML, CSS, JavaScript, CoffeeScript, Go, Fortran, Julia, Gap, Axiom, R, Ruby, Perl, Maxima, Maple, Markdown, Wiki (и это неполный список!). При редактировании поддерживается мультикурсорность, можно включить биндинги Vim или Sublime Text. Пользователю также доступна консоль Ubuntu и доступ к проекту по ssh. Можно создавать документы LaTeX и встраивать в них код на Python, который **не** будет отображаться в итоговом pdf. Широкие возможности позволяют написать не просто расчёт с 2D и 3D графикой, а целое интерактивное приложение или собственный веб-сервер на Flask. Можно расшарить расчёт пользователям на редактирование, и Вы будете видеть, что они меняют и даже где стоит их курсор! При этом великолепии SageMathCloud имеет открытый исходный код, который выложен на Github.
[](http://http:https://habrastorage.org/files/47a/eab/72d/47aeab72d9d44816bda9261e2135ddfc.png)
Краткие сведения о проекте
--------------------------
Идея создания SMC принадлежит профессору математики университета Вашингтона [William Stein](https://plus.google.com/115360165819500279592/posts). Кроме него над SMC работают [Harald Schilly](https://plus.google.com/+HaraldSchilly/posts) (маркетинг и тестирование), Keith Clawson (оборудование), а также Jon Lee, Andy Huchala и Nicholas Ruhland (веб-разработка).
SMC разрабатывается за счёт грантов National Science Foundation и [образовательной грантовой программы от Google](https://research.google.com/university/relations/appengine/index.html).
В настоящее время SMC находится в стадии бета-тестирования. Изредка глючит, но должен отметить, что стабильность и удобство работы приложения многократно выросла за два года моей работы в нём.
Большинство серверов расположено в США на территории университета Вашингтона. Есть несколько серверов в Европе. На серверах стоит Ubuntu 14.04.1 LTS (Trusty) c математической программой [Sage](http://sagemath.org/). Также используется [Google App Engine](http://ru.wikipedia.org/wiki/Google_App_Engine).
Основным источником информации и ресурсом для общения является [форум пользователей SMC](https://groups.google.com/forum/#!forum/sage-cloud). Недавно открылся [форум для разработчиков](https://groups.google.com/forum/#!forum/sage-cloud-devel) после окончательного перехода SMC в разряд открытых проектов. Активное общение идёт в [чате Gitter](https://gitter.im/sagemath/cloud); есть очень информативное [FAQ](https://github.com/sagemath/cloud/wiki/FAQ) на Github.
Каждый месяц количество пользователей неуклонно растёт. На сегодняшний день на SMC более 68 тыс. аккаунтов. Подробные статистические сведения об использовании SMC можно посмотреть на [этой странице](http://boxen.math.washington.edu/home/schilly/salvus/stats/stats.html).
Обзор функционала и интерфейса SMC
----------------------------------
### Вход на сайт
Чтобы начать использовать SageMathCloud, перейдите на страницу <https://cloud.sagemath.com>, зарегистрируйтесь или залогиньтесь. К сожалению, изредка может появляться ошибка входа на сайт (обычно из-за нехватки памяти для баз данных). В этом случае Вы можете обратиться напрямую к европейским серверам SMC по следующим ip: [146.148.26.36](https://146.148.26.36) и [192.158.29.251](http://192.158.29.251).
### Элементы интерфейса
Зайдя на сайт, Вы попадёте на страницу со списком проектов. Элементы интерфейса этой страницы представлены на скриншоте ниже (все скриншоты кликабельны).
[](http://http:https://habrastorage.org/files/d8f/622/7ef/d8f6227ef8004274abe4045a85e1cda0.png)
Кликните по кнопке Create New Project для создания нового проекта, а потом по названию проекта, чтобы войти в него. При этом вы попадёте в файловый менеджер и увидите в верхней части страницы панель инструментов, представленную на скриншоте ниже.
[](http://http:https://habrastorage.org/files/9b4/a7f/cfa/9b4a7fcfa6974e1c864cbe9304ce156b.png)
### Файловый менеджер
Ниже на скриншоте представлен интерфейс файлового менеджера:
[](http://http:https://habrastorage.org/files/409/c5b/95d/409c5b95d0a3472dae3b6c7544b9797c.png)
Хотелось бы отметить несколько важных моментов:
1. Файловый менедежер SMC умеет фильтровать файлы. Например, введя в фильтр строку pyparsing, я увижу только файлы, которые содержат в своём имени слово pyparsing.
2. В файловом менеджере есть доступ к командной строке Linux. Я обычно использую эту строку, чтобы создать архив или распаковать его. Обратите внимание, что root заблокирован и в этой строке нет автодополнения по Tab. Ниже мы увидим 2ой способ доступа к терминалу с работающим автодополнением.
3. SMC регулярно делает снимки проекта (кнопка Snapshots). Года два назад из-за сбоя я потерял было один файл, но через Snapshots восстановил его. После этого случая я больше таких сбоев не видел.
### Настройки проектов: хештеги, совместное редактирование, ssh доступ, темы, биндинги Sublime Text и Vim.
Множество фишек SMC спрятаны в его настройках, поэтому в них обязательно нужно заглянуть! Вначале перейдём в настройки текущего проекта, кликнув по вкладке Settings. Ниже представлен скриншот страницы настроек с пояснениям.
[](http://http:https://habrastorage.org/files/a5e/e21/472/a5ee214728ce47b1b75e18fc29e896c3.png)
Чтобы получить остальные фишки, перейдите к общим настройкам для всех проектов, кликнув по своему e-mail. Ниже скриншот с пояснениями.
[](http://http:https://habrastorage.org/files/52d/3f2/367/52d3f23671a94d4881de544709a6cabe.png)
### Документы в SMC: Sage Worksheet, Ipython Notebook, LaTeX document, Terminal, Task list и Course.
SMC позволяет работать с обширным типом документов. Перейдём во вкладку New.
[](http://http:https://habrastorage.org/files/f8e/725/faa/f8e725faa54144c2a995311c2a8fc7d5.png)
Несколько слов про «From Internet». Изначально эта кнопка работала для любых файлов с других сайтов. Увы, так получилось, что появилось много людей, которые злоупотребляли этим. Также в одно время часто пытались использовать сервера SMC для майнинга криптовалют. В итоге William Stein написал специальный антимайнинговый скрипт. Длительно выполняющиеся процессы этот скрипт может убить (сейчас, возможно, эта проблема решена). По этой же причине большинство сайтов заблокировано. Я точно помню, что работает копирование с GitHub и ряда ресурсов университетов Европы и США. В принципе можно скачать файл самому на компьютер и загрузить его на SMC. Если всё же нужна связь с конкретным сайтом, то нужно попросить William Stein открыть доступ к этому сайту (это бесплатно). Для этого [напишите ему письмо](mailto://[email protected]) или просто создайте сообщение с Вашей просьбой на [форуме SMC](https://groups.google.com/forum/#!forum/sage-cloud).
В будущем в SMC появятся платные функции (планируется использовать Freemium). При их появлении можно будет разблокировать доступ к другим сайтам за денежку.
Работа в Sage Worksheet
-----------------------
### Первый взгляд на Sage Worksheet
Sage Worksheet является наиболее напичканым различными возможностями. Создадим тестовый файл sage worksheet. Зайдя на чистый лист sage worksheet, вы увидите ещё одну панель инструментов, скриншот которой представлен ниже.
[](http://http:https://habrastorage.org/files/ebd/860/df7/ebd860df720843098aba19d02b617586.png)
Из кнопок я обычно использую Run (вычислить), А (увеличить шрифт) и Save (Сохранить). Особенно интересна кнопка History (История). Она даёт пользователю ползунок — «шкалу времени». Перемещая ползунок, Вы увидите, как выглядела Ваша страница с расчётами раньше. Ничего более завораживающего я ещё не видел! Просто взгляните на видео ниже (оно без звука).
### Информационные полоски
Давайте напишем любой код и вычислим его, нажав кнопку Run или комбинацию клавиш shift-enter. Ниже представлен скриншот с примером python-кода. Обратите внимание на информационные полоски.
[](http://http:https://habrastorage.org/files/154/d42/448/154d42448c754ef2a79bfe90b69b8949.png)
Двойной клик на выводе (результате расчётов) скрывает код, повторный двойной клик отображает код.
### Магические команды. Вставка html, css, js, пр.
Добавление html, css, js, coffescript, markdown, wiki и других вкусностей осуществляется через использование магических команд. Для получения полного списка из 56 магических команд вычислите:
```
%magics
```
**Полный список магических команд в SMC:**
```
%auto
%axiom
%capture
%coffeescript
%command
%cython
%default
%default_mode
%exercise
%file
%fork
%fortran
%fricas
%gap
%gap3
%giac
%go
%gp
%hide
%hideall
%html
%javascript
%julia
%kash
%lie
%lisp
%load
%macaulay2
%magics
%magma
%maple
%mathematica
%matlab
%maxima
%md
%mupad
%mwrank
%octave
%pandoc
%perl
%prun
%python
%r
%reset
%ruby
%runfile
%sage0
%scilab
%script
%sh
%singular
%time
%timeit
%typeset_mode
%var
%wiki
```
Рассмотрим к примеру использование html и css:
[](http://http:https://habrastorage.org/files/911/7e7/f1e/9117e7f1e6934919b82f6a3468186d81.png)
**HTML и CSS код**
```
%html(hide=False)
a.hlink {
cursor: pointer;
}
a.hlink:hover {
background-color: yellow;
}
###
Мои избранные сайты:
1. Хабрахабр
2. Opennet
3. SageMathCloud
```
Совсем короткий пример для Julia:
```
%julia
println("Привет, Хабр!")
```
[](http://http:https://habrastorage.org/files/024/0db/2ff/0240db2ff5ed4e2d89473223360a2493.png)
Для остальных случаев (markdown, wiki, R, go, пр.) полностью аналогично.
Код можно загружать с помощью функции `load()`. Пример простенькой графической формы на HTML, CSS и JavaScript в SMC:
[](http://http:https://habrastorage.org/files/a80/39c/93a/a8039c93a18b401794b84a2de7477140.png)
Современные веб-технологии позволяют встраивать 3D графику в страницу без использования flash и других плагинов. В SMC можно создавать двухмерную и трёхмерную графику, используя js фреймворки, например, three.js. Что интересно, если убрать курсор с 3D области, она преобразуется в картинку. Этот подход сделал работу с 3D графикой заметно удобнее (страница перестала дёргаться, повысилась производительность). Трёхмерный объект можно:
* масштабировать (вращение колёсика мыши или левый клик + shift + перемещение курсора)
* поворачивать (левый клик + перемещение курсора)
* перемещать (ctrl + левый клик + перемещение курсора)
Видео ниже демонстрирует работу с 3D графикой (видео без звука).
Работа с терминалом
-------------------
Выше я обещал показать вариант работы с терминалом, в котором работает автодополнение. Для этого необходимо нажать кнопку New, написать название файла, в котором будет запускаться терминал (например, Console) и нажать кнопку Terminal. Работа в терминале практически неотличима от работы в обычном терминале Linux. Главное отличие в том, что заблокирован root и копирование-вставка работают по ctrl+c и ctrl+v (а не ctrl+shift+c и ctrl+shift+v, как в обычной консоли). Ниже скриншот демонстрирует работу в терминале в SMC:
[](http://http:https://habrastorage.org/files/774/60f/73b/77460f73b6ae44fcbf76004ea371c508.png)
Кстати, я в одно время использовал в этой консоли git. Работало хорошо.
Про возможности Sage и SMC можно рассказывать ещё очень долго. В следующих статьях я буду стараться подробно освещать различные фишки и недокументированные возможности.
Вместо заключения
-----------------
Дорогие пользователи Хабра! Видя, какие возможности для математических (и не только) расчётов предоставляет пользователю свободное ПО, в частности SageMathCloud, мне грустно видеть, что школьники и студенты зачастую даже и не знают о нём и используют проприетарные программы типа Mathcad и Matlab. Я считаю, что свободное ПО должно быть первым выбором!
Если мы объединимся, мы можем изменить это положение вещей. На мой взгляд необходимо сделать 3 вещи:
1. Русифицировать интерфейс SMC,
2. Написать справку и учебные пособия на русском языке,
3. Рассказать про SMC своим друзьям и детям.
Я знаю, что такой подход работает. Например, САПР Компас популярен на отечественном рынке потому, что в рамках одной государственной программы Аскон почти каждой школе дала лицензии на использование этого продукта. Таким образом, необходимо максимально снизить порог входа пользователя в этот программный продукт.
Основной объём работ- написание документации по SMC на русском языке. В прошлом году я начал собирать эту информацию на своём ресурсе [wikisage.ru](http://www.wikisage.ru) (пожалуйста, не сочтите за рекламу). Я собирал материал по работе в Python и Sage (SMC). В планах — информация на русском про Pyparsing, Numpy, Matplotlib и другие пакеты Python. При желании Вы можете помочь проекту советом или помощью, написав в личку, в [ВК](https://vk.com/im?sel=87466231) или на [почту](mailto:[email protected]). Моя мечта — чтобы большинство школьников, студентов, учёных и инженеров использовало Sage и Python для своих расчётов, а этот ресурс стал главным источником информации в рунете. | https://habr.com/ru/post/247277/ | null | ru | null |
# Бекап баз данных через SQL VDI
Хочу рассказать о том, как мы захотели сделать собственный бекап баз данных для Microsoft SQL Server, и что из этого получилось.
Проблема
--------
Мы в компании используем Microsoft SQL Server, и вполне ожидаемо, что нам надо делать бекапы баз данных для него, что мы успешно делаем. Делается это следующим образом:
* Первый скрипт делает бекапы нужных баз данных
* Второй скрипт проходит по папкам с бекапами и архивирует их в 7zip
* Третий скрипт уносит эти бекапы на внешнее хранилище
Вроде всё логично на мой взгляд, но есть некая странность во всём этом. Так как некоторое время на сервере находятся файлы, которые активно занимают место, а потом данные файлы удаляются за ненадобностью. Хотелось всё это оптимизировать. Кроме того, у нас в комании есть продукт, одной из задач которого является синхронизация базы данных, и ему подобный код, оптимизирующий задачу, тоже очень пригодился бы.
Варианты решения
----------------
### Бекап со сжатием средствами SQL
Хорошая идея, но [не каждая](https://msdn.microsoft.com/en-us/library/cc645993(v=sql.120).aspx) версия SQL поддерживает его, к тому же размер данного бекапа выходит всё равно не самый мелкий. А с учётом того, что в большинстве случаев, бекапы никогда не пригождаются, хотелось бы более сильного сжатия. Зато отличный вариант в плане удобства.
### Бекап в Azure
SQL Server, начиная с 2012 поддерживает [бекап в Azure](https://msdn.microsoft.com/en-us/library/jj919148.aspx). Была идея в качестве URL указать собственный сервис и в нём всё делать. Но уж очень сложная и грязная технология выходила. Да и версия SQL должна быть достаточно свежей.
### Бекап в pipe
Отличнейшая идея, но с 2005-ого SQL уже не поддерживается.
### Бекап через VDI
Секретная технология от Microsoft, которая пришла на смену pipe. Почему секретная? А попробуйте найти документацию на неё. Это тот ещё квест. Есть [документация на сайте Microsoft](https://technet.microsoft.com/en-us/library/cc966520.aspx), которая вроде понятная, но ничего не понятно. Потому что вроде про VDI, а вроде про VSS. Есть её перепечатки и плюшевые примеры использования на различных сайтах.
По факту, самая понятная документация находится в chm-файле по [данной ссылке](https://www.microsoft.com/en-us/download/details.aspx?id=17282)
После всей этой документации возникло ощущение какой-то сугубо служебной технологии, но т.к. ничего другого не нашлось, остановились на ней. К тому же она работает на всех SQL с 2005-ой версии (даже с 2000, но с некоторыми ограничениями), на любой редакции.
Используем VDI
--------------
Делать нечего, взяли документацию, взяли Аню, выдали документацию, гугл и отправили изучать эту технологию.
*Аня изучает документацию*
Если бы я придумывал эту технологию, я бы сделал так:
* Зарегистрировал виртуальное устройство в SQL
* Сделал бы команду бекапа в данное устройство с параметрами
* Написал бы инструкцию пользователю, как использовать
* ?????
* PROFIT!
Это было бы логично, но Microsoft не ищет лёгких путей. Они придумали следующую схему
* Регистрируем **одноразовое** устройство в SQL со случайным именем (обычно все используют гуиды)
* Ждём данных от SQL
* В то же самое время, другим потоком делаем бекап в это устройство (имя мы сами придумали, так что только мы и можем вызвать)
* Получаем данные от SQL кусочками
* Всё получили, закрываем устройство и заканчиваем команду бекапа базы
Конечно же, всё написано на «замечательном» COM'е, чтобы жизнь мёдом не казалось и приправлено следующими ограничениями:
* SQL и приложение должны быть на одном и том же сервере (слава богу, поддерживаются разные инстансы SQL)
* Пользователь SQL должен быть sysadmin (скромненько)
* Пользователь, от которого запущено приложение должен быть администратором или пользователем с волшебными правами *Create Global Objects*
По последнему пункту подробнее: в документации есть такая шедевральная фраза:
*The CreateEx (and Create) calls will modify the security DACL on the process handle in the client process. Because of this, any other modification of the process handle must be serialized with invocation of CreateEx. CreateEx will serialize with other calls to CreateEx, but is unable to serialize with external processing. Access is granted to the account running the SQL Server service.*
Типичная фраза вида: *почувствуй себя лузером*. Т.е. все слова понятны, а смысла нет. По факту, как я уже написал выше, нужно право *Create Global Objects*, которое по умолчанию доступно администраторам, Network Service и Local Service. Т.е. в принципе, из сервиса запускать всё можно, а не администратором (пользователь, который делает бекапы, обычно не администратор), нельзя. Но можно выдать право ручками, через групповую политику (мы просто сделали команду в утилите, которая выдаёт права указанному пользователю, т.е. раз выдал под админом, дальше можно работать). К сожалению, так и не смогли разобраться с UAC. Если забыть запустить программу явно под администратором, то права не получить никаким боком. Можно было в манифесте явно указать, что нужны админские права, но тогда в принципе не получится использовать программу не администратором. А хочется.
С этим разобрались, идём дальше. Я не буду писать куски кода и расписывать детально что делать, ибо это никому не интересно, а кому интересно, те сами разберутся. :) В целом, там обычный цикл вида GetCommand, CompleteCommand, в середине которого обработка результатов. Я просто расскажу некоторые нюансы, которые вылезли при использовании данного COM в .NET
**Лирическое отступление**Совсем забыл рассказать, что же за утилиту мы хотели сделать (и сделали в итоге). Мы хотели делать бекап базы сразу в архив. Обычный, zip. Ну и восстановление из него, конечно же. Т.е. никаких своих особых форматов файлов. Можно распаковать и восстановить бекап без этой утилиты, или запаковать существующий бекап и потом его восстановить утилитой. Конечно же, первая итерация столкнулась с проблемой: не все библиотеки для сжатия нормально переваривают файлы больше 2Гб, в результате остановились на 7zip и обёртке для неё [SevenZipLib](https://sevenziplib.codeplex.com/). В результате получили возможность архивировать в 7z, zip, bz2, xz, gz. Правда 7zip в таком режиме тоже работает через COM… что доставило нам дополнительной радости.
COM Великий и ужасный
---------------------
Да, мы решили писать всё на .NEТ. Собственно, маршаллинг в COM там вполне сносный (половина системных библиотек по сути обёртки над COM'ом), и казалось, что проблем не будет. Но они возникали буквально на каждом шагу.
Данная часть будет, наверное, очевидной, для тех, кто уже сталкивался с этим, но тем, кто не сталкивался, может быть интересная.
### При декларации объектов, названия методов не имеют значения
Важен только порядок (в этом отличие от WinAPI методов с атрибутом DllImport). Т.е. если вы случайно перепутали два метода местами (особенно похожих, типа Create и CreateEx), можете ловить замечательные ошибки, когда всё вроде бы работает, но как-то не совсем так, как надо.
Следите за этим.
### .NET за вас будет кидать эксепшены
В COM методы обычно возвращают HRESULT, т.е. код ошибки. Ну или 0-ой код, если всё хорошо. .NET пользуется этим и в случае ненулевого кода кидает COMException, в котором уже можно посмотреть на код и обработать его. Вроде удобно, но не совсем. К тому же, на одном из серверов со старым .NET обнаружилось замечательная бага. При возникновении данного эксепшена (например, когда обращаемся к закрытому устройству, что в общем-то по документации нормальная ситуация), вылезало ExecutionEngineException с фатальным крешем приложения. Гугл в качестве решения предлагал устанавливать апдейты, но в целом, это не решение для утилиты, поэтому обошли проблему следующим образом: Добавили к каждому COM-методу атрибут PreserveSig, который в случае ошибки не будет кидать эксепшен а просто вернёт код ошибки. В этом случае, никаких страшных проблем не возникало. Ну и код стал логичнее.
### STAThread и MTAThread
Для разработчиков на .NET, это некий магический атрибут, который студия добавляет к методу Main. Если кто-то попытается понять, что это, он получит следующий шикарный в своей простоте текст:
*STAThreadAttribute indicates that the COM threading model for the application is single-threaded apartment. This attribute must be present on the entry point of any application that uses Windows Forms; if it is omitted, the Windows components might not work correctly. If the attribute is not present, the application uses the multithreaded apartment model, which is not supported for Windows Forms.*
Который в переводе означает: чувак, так надо.
Ну, естественно, так, конечно надо, и когда наше приложение архивировало в zip, всё было нормально, а при попытке использовать 7z, всё эпично зависало. В чём же проблема, и что на самом деле значат эти атрибуты?
Вкратце, смысл в следующем. COM из коробки многопоточный. Т.е. разные объекты получают и возвращают данные в разных потоках. Но криворукий код (или Windows Forms), не могут осилить такую сложную концепцию, поэтому они все COM-вызовы заворачивают во внутреннюю очередь и выполняют в одном потоке. Никаких проблем с многопоточностью! Зато мы эпично встряли в Dead Lock. Сколько стоило понять, что это дедлок, и дедлок где-то в кишках .NET… ууух…
Но нам повезло, у нас консольное приложение, мы просто повесили атрибут MTAThread и успокоились. Если вам это не подойдёт… что же страдайте. Есть пути обхода.
### Создание объектов может быть странным
.NET создаёт удобные врапперы, так что инстанциирование объектов выглядит простым и очевидным:
```
var obj = new ClientVirtualDeviceSet();
```
И всё у нас работало, пока не попробовали запустить всё на 32х-битной винде. И при создании объекта вылез эксепшен. Логично было предположить, что проблема с типами данных и маршаллингом (не тот размер), но всё было в порядке. В чём конкретно проблема, так и не выяснили, просто создали объект как в старые добрые времена, через [CoCreateInstance](https://msdn.microsoft.com/en-us/library/windows/desktop/ms686615(v=vs.85).aspx).
```
object comObject;
var errorCode = CoCreateInstance(
CLSID_MSSQL_ClientVirtualDeviceSet,
IntPtr.Zero,
CLSCTX_INPROC_SERVER,
CLSID_MSSQL_ClientVirtualDeviceSet,
out comObject);
```
### Прочее
Всякие мелочёвки с маршаллингом, правильным лейаутом структур расписывать не буду, в принципе, они один раз доводятся до ума и больше не трогаются. Просто совет, если тяжело разобраться с указателями, отдавайте IntPtr и ручками конвертите его в нужный тип. Может быть проще, чем подбирать правильные атрибуты для .NET
Немного про 7z
--------------
Точнее про SevenZipSharp, но т.к. это в целом обёртка (очень хорошая), то и про него тоже.
Первое, что может смутить, так это то, что библиотека заточена прод работу с файлами (а не со стримами), поэтому логика там наизнанку. Т.е. в .NET компрессор обычно из себя представляет из себя обёртку над writeable-стримом, вы в него пишите, он сжимает и передаёт сжатые данные во внутренний поток. В SevenZipSharp наоборот, он читает из вашего стрима данные и записывает их в свой внутренний стрим. Что с учётом того, что из SQL мы в целом тоже читаем, доставило Ане много приятных минут разбирательств с асинхронными стримами, блокировками, эвентами… В общем на любителя :)
Второе, опять же связанное с файлами, это то, что библиотека очень любит бегать по потоку в разные стороны, что в целом неплохо, но если поток не позволяет это сделать (например, stdout), начинаются проблемы. В принципе, мы сумели это обойти (тоже отдельный квест, после которого Аня стала меня ненавидеть) для gzip, xz, gzip, 7z, а вот с zip'ом возникли сложности. Структура потока не позволяет это сделать. С чтением из stdin всё ещё хуже, библиотека в принципе не может это сделать. Нам пришлось пока отказаться от этой возможности, и оставить только возможность читать из stdin только несжатые бекапы.
Итоги
-----
После всего этого увлекательного квеста у нас получилась утилита с оригинальным названием PackDb, которая может делать бекапы баз данных сразу в архив, восстанавливать их оттуда, и бонусом, ещё одна увлекательная фича: копирование базы данных без создания временных файлов. Зачем это надо? Для тестовых баз данных, когда нужно скопировать эталонную базу в новую и протестировать на данной базе, не трогая основную. Ну и всякие мелочи вида выдачи прав, валидации корректности бекапа или возможности не использовать архивы, если не надо а просто брать bak файлы.
Стоит ли вам проходить данный квест, если хочется делать необычные бекапы, решать вам самим. Но на мой взгляд, это уж очень неблагодарное дело. Слишком много нюансов, чтобы сделать всё красиво. | https://habr.com/ru/post/303768/ | null | ru | null |
# Как переписать SQL-запросы на Python с помощью Pandas
В этой статье June Tao Ching рассказал, как с помощью Pandas добиться на Python такого же результата, как в SQL-запросах. Перед вами — перевод, а [оригинал](https://towardsdatascience.com/how-to-rewrite-your-sql-queries-in-python-with-pandas-8d5b01ab8e31) вы можете найти в блоге towardsdatascience.com.
*Фото с сайта [Unsplash](https://unsplash.com/s/photos/python-programming?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText). Автор: [Hitesh Choudhary](https://unsplash.com/@hiteshchoudhary?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)*
### *Получение такого же результата на Python, как и при SQL-запросе*
Часто при работе над одним проектом нам приходится переключаться между SQL и Python. При этом некоторые из нас знакомы с управлением данными в SQL-запросах, но не на Python, что мешает нашей эффективности и производительности. На самом деле, используя Pandas, можно добиться на Python такого же результата, как в SQL-запросах.
### Начало работы
Нужно установить пакет Pandas, если его нет.
```
conda install pandas
```
Мы будем использовать знаменитый [Датасет Титаник от Kaggle](https://www.kaggle.com/c/titanic/data?select=test.csv).
После установки пакета и загрузки данных нам необходимо импортировать их в наше окружение Python.
Для хранения данных мы будем использовать DataFrame. Управлять этой структурой данных нам помогут различные функции Pandas.
### SELECT, DISTINCT, COUNT, LIMIT
Начнем с простых SQL-запросов, которые мы часто используем.
`titanic_df["age"].unique()` вернет массив уникальных значений, поэтому нам придется использовать `len()`, чтобы посчитать их количество.
### SELECT, WHERE, OR, AND, IN (SELECT с условиями)
После первой части вы узнали, как простыми способами исследовать DataFrame. Теперь попробуем сделать это с некоторыми условиями (это оператор `WHERE` в SQL).
Если мы хотим выбрать только определенные столбцы из DataFrame, мы можем сделать это с помощью дополнительной пары квадратных скобок.
*Примечание: если вы выбираете несколько столбцов, вам нужно поместить массив `["name","age"]` внутри квадратных скобок.*
`isin()` работает точно так же, как `IN` в SQL-запросах. Чтобы использовать `NOT IN`, на Python нам нужно использовать отрицание `(~)`.
### GROUP BY, ORDER BY, COUNT
`GROUP BY` и `ORDER BY` также являются популярными SQL-операторами при исследовании данных. А теперь давайте попробуем использовать их на Python.
Если мы хотим отсортировать только один столбец COUNT, то можем просто передать булево значение в метод `sort_values`. Если мы собираемся сортировать несколько столбцов, то должны передать массив булевых значений в метод `sort_values`.
Метод `sum()` выдаст суммы для каждого из столбцов в DataFrame, которые могут быть численно агрегированы. Если нам нужен только определенный столбец, то нужно указать имя столбца, используя квадратные скобки.
### MIN, MAX, MEAN, MEDIAN
И наконец, давайте попробуем некоторые стандартные статистические функции, которые важны при исследовании данных.
SQL не содержит операторов, возвращающих медианное значение, поэтому для получения медианного значения столбца с информацией о возрасте мы используем BigQuery `APPROX_QUANTILES`
В Pandas метод агрегации `.agg()` также поддерживает другие функции, например `sum`.
Теперь вы научились **переписывать SQL-запросы на Python с помощью Pandas**. Надеюсь, эта статья будет вам полезна.
Весь код можно найти в моем репозитории [Github](https://github.com/chingjunetao/medium-article/tree/master/rewrite-sql-with-python).
Спасибо за внимание! | https://habr.com/ru/post/513316/ | null | ru | null |
# Запускаем Skype без надоедливой Главной страницы
Поводом к написанию заметки послужил [недавний вопрос](http://habrahabr.ru/qa/10944/). Меня тоже очень раздражает окно Skype Home, появляющееся при каждом запуске, однако с помощью простой программы на C мне удалось от него избавиться. Получилось нечто вроде Hello World Tutorial по использованию Windows API. Программу можно скачать [тут](http://and.su/misc/runskype.zip), а исходник с описанием найдете под катом.
##### Алгоритм на словах
1. Узнаем из реестра путь, куда установлен Skype.
Он прописан в HKEY\_CURRENT\_USER\Software\Skype\Phone\SkypePath.
2. Запустим Skype.exe в новом процессе.
3. С момента запуска Skype будем в течение 30 секунд искать окно с заголовком «Skype Home» или «Главная страница Skype». Получим хэндл окна и дождемся, пока оно станет видимым.
4. Отправим этому окну сообщение WM\_CLOSE, чтобы автоматически его закрыть.
##### Текст программы runskype.c
```
#include
BOOL RunSkype() {
STARTUPINFO si;
PROCESS\_INFORMATION pi;
HKEY key;
BYTE appPath[512];
DWORD pathSize = sizeof(appPath);
BOOL result = FALSE;
// В реестре по ключу HKEY\_CURRENT\_USER\Software\Skype\Phone\SkypePath найдем полный путь к Skype
if (RegOpenKeyEx(HKEY\_CURRENT\_USER, "Software\\Skype\\Phone", 0, KEY\_READ, &key)==ERROR\_SUCCESS) {
if (RegQueryValueEx(key, "SkypePath", NULL, NULL, appPath, &pathSize)==ERROR\_SUCCESS) {
// Используем полученный путь для запуска Skype.exe в новом процессе
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
result = CreateProcess(appPath, NULL, NULL, NULL, FALSE, 0, NULL, NULL, &si, π);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
}
RegCloseKey(key);
}
return result;
}
int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
if (RunSkype()) {
// В течение 30 секунд с момента запуска Skype будем искать окно с заголовком Skype Home
int i;
for (i = 0; i < 3000; i++) {
// Класс окна THomeForm подсмотрели с помощью программы Inspect Objects из Windows SDK
// Если не нашли "Skype Home", пробуем русскоязычный вариант "Главная страница Skype"
HWND wnd = FindWindow("THomeForm", "Skype Home");
if (!wnd) {
wnd = FindWindow("THomeForm", "Главная страница Skype");
}
// Окно обязательно должно быть видимым, прежде чем его можно будет закрыть
if (wnd && IsWindowVisible(wnd)) {
SendMessage(wnd, WM\_CLOSE, 0, 0);
return 0;
}
// Если окно не найдено, повторяем попытку через 10 мс
Sleep(10);
}
}
return 1;
}
```
##### Компиляция
С помощью Visual Studio:
`cl user32.lib advapi32.lib runskype.c`
С помощью GCC (MinGW):
`gcc -o runskype.exe runskype.c`
*Примечание:*
В Скайпе должен быть выбран вид Compact View.
Проверено на Windows 7 и Skype 5.5.0.
Разумеется, описанный механизм применим и к другим программам. | https://habr.com/ru/post/127558/ | null | ru | null |
# Тюним меню Translate в Opera
Наверно всем знакомо контекстное меню оперы.
Я хочу рассказать как настроить это меню для более удобного перевода.
Сам я пользуюсь 2-я сервисами для перевода в интернете — это [Яндекс.Словари](http://slovari.yandex.ru/) и [Google.Translate](http://translate.google.com/) их и будем интегрировать =) Хотя вы сможете прикрутить любой другой онлайн переводчик.
Для начала нам надо создать наше персональное меню.
Идем в **Tools -> Preferences -> Advanced -> Toolbars** в **Menu Setup** выделяем **Opera Standart** и жмем на кнопку **Duplicate**.
После этого должен появиться еще один пункт меню **Opera Standart Copy**.
Теперь нам надо отредактировать пункты только что созданного меню, для этого открываем файл **\AppData\Roaming\Opera\Opera\menu\standard\_menu (1).ini**
и в нем ищем следующую строку "[Translate menu]". Удаляем все до "[Image Popup Menu]". *Мне не нужны переводчики предоставляемые оперой, т.к. они не работают с русским языком.*
Осталось прикрутить переводчик от гугла. Добавляем следущие строки после "[Translate menu]":
`Item, English to Russian = Go to page, "javascript:void(inivar='%t')",,, "l_russian" & Go to Page,"javascript:if(typeof google_translate=='function'){google_translate('auto|ru')}else{void(window.open('http://translate.google.com/translate'+(document.selection.createRange().text?'_t?text='+document.selection.createRange().text:'?u='+escape(location.href))+'&hl=ru&langpair=auto|ru&tbb=1'+(document.characterSet?'&ie='+document.characterSet:'')));}"
Item, Russian to English = Go to page, "javascript:void(inivar='%t')",,, "l_english" & Go to Page,"javascript:if(typeof google_translate=='function'){google_translate('auto|en')}else{void(window.open('http://translate.google.com/translate'+(document.selection.createRange().text?'_t?text='+document.selection.createRange().text:'?u='+escape(location.href))+'&hl=ru&langpair=auto|en&tbb=1'+(document.characterSet?'&ie='+document.characterSet:'')));}"
--------------------1
Item, Яндекс словари = Go to page,"http://slovari.yandex.ru/search.xml?text=%t&st_translate=1"`
Еще хотелось бы изменить поведение меню **Dictionary**, хочу чтобы при выборе этого пункта у меня открывались Яндекс.Словари.
Что же, это сделать не сложно.
Заменяем строку
`Item, MI_IDM_SELDICTIONARY=Hotclick search, 50"`
на
`Item, MI_IDM_SELDICTIONARY=Go to page,"http://slovari.yandex.ru/search.xml?text=%t&st_translate=1"`
Теперь осталось указать опере, использовать наше меню. Идем **Tools -> Preferences -> Advanced -> Toolbars** в **Menu Setup**,
выбираем **Opera Standart Copy** и жмем Ок.
По мотивам: [линк](http://forum.myopera.net/showflat.php?Cat=&Board=opera7&Number=38931)
Мое меню: [my\_menu.ini](http://files.getdropbox.com/u/145751/habr/my_menu.ini) думаю может быть полезно как пример. Но только не используйте его в Opera 9, т.к. это модифицированное меню 10 версии. | https://habr.com/ru/post/63425/ | null | ru | null |
# Нужен ли C#-у «state»?
Ребята, это скорее приглашение к конструктивному обсуждению, чем статья. Столкнулся с тем, что в C# как таковом нет понятия «состояния», а точнее — нет встроенной удобной возможности запомнить состояние сложного объекта в определенный момент, чтобы потом легко сравнивать, или другие объекты такого же типа находятся в таком же состоянии? Ниже я предлагаю пример — как бы это могло выглядеть.
**Какой-нибудь пользовательский класс**
```
class Test
{
[StateAtt(StateCompareOption.AnyButNotThis)] // любое значение, кроме указанного
public double somefiled;
public double anothersomefiled; // этому полю атрибут не присвоен - оно в сравнении не участвует
[StateAtt(StateCompareOption.ExactlyLikeThis)] // только такое значение
public string StringProp { get; set; }
public int IntProp { get; set; } // этому свойству атрибут не присвоен - оно тоже игнорируется
public Test(string StringProp, int IntProp, double somefiled, double anothersomefield)
{
this.StringProp = StringProp;
this.IntProp = IntProp;
this.somefiled = somefiled;
this.anothersomefiled = anothersomefield;
}
}
```
```
Test a1 = new Test("text", 1, 50.4251, 34);
State state = State.CreateState(a1);
Test a2 = new Test("text", 1, 50.4252, 34);
state.IsInTheSameState(a2).ToString().ToConsole(); // вернет true
```
Ребята, хочу спросить ваше мнение. Как считаете, будет ли такой инструмент полезен в разработке? | https://habr.com/ru/post/270099/ | null | ru | null |
# О ценности карт в игре «Пьяница»
В последнее время я много играю со своим 5-летним сыном в карточную игру «Пьяница». И он, и я радуемся, когда побеждаем, и огорчаемся, когда проигрываем.
В какой-то момент я задался вопросом: какова «финансовая» ценность каждой из карт в «Пьянице»? Так как Шестерка бьет Туза (см. вариант правил под катом), то система ценностей в «Пьянице» циклична, и ответ неочевиден. Например, ценнее ли Семерка Шестерки? Семерка бьет Шестерку — значит да! Но с другой стороны, каждая из них бьет только одну другую карту в игре (Семерка — Шестерку, а Шестерка — Туза) — значит они равны по ценности? Но Туз, побитый Шестеркой, сам по себе гораздо ценнее чем Шестерка, побитая Семеркой — значит Шестерка ценнее?!
Я решил подвести математическую модель под анализ ценности карт в «Пьянице». Результаты получились самые неожиданные.
Для начала, вот правила нашего варианта этой игры:
* В игре участвуют 2 игрока.
* 36 карт (от шестерок до тузов) раздаются поровну.
* Каждый игрок снимает верхнюю карту своей колоды и кладет ее лицом вверх — происходит «сражение». Победивший в сражении игрок кладет все карты сражения под низ своей колоды.
* Победитель в сражении определяется по обычному старшинству карт (сверху вниз): Туз, Король, Дама, Валет, Десятка, Девятка, Восьмерка, Семерка, Шестерка. Есть только одно очень важное исключение: Шестерка побеждает Туза.
* Если в сражении участвуют одинаковые карты (например, две десятки), то происходит «спор»: поверх «спорящих» карт лицом вниз кладутся еще по карте (они являются пассивными заложниками спора), и потом лицом вверх еще две карты которые вступают в сражение. Победитель забирает себе все карты спора.
Как понятно из правил, победа в этой игре зависит исключительно от везения — победитель определяется раздачей карт, так как от игроков вообще ничего не зависит.
Итак, как мы можем определить «ценность» карты в «Пьянице»? Я решил определить ценность карты через ожидаемое количество карт которые эта карта принесет если игра будет продолжаться бесконечно долго.
Начнем с простой задачи: определения ожидаемого количества карт только для Шестерки и только одного сражения. В колоде 36 карт, значит, если мы ходим Шестеркой, она вступает в сражение с другой (случайно выбранной) картой из оставшихся 35ти. Что может произойти? С вероятностью в 4/35 выпадет Туз, и тогда мы получим и Шестерку, и Туза. С вероятностью в 3/35 выпадет еще одна Шестерка, и произойдет спор — а так как мы предполагаем абсолютно случайный расклад, то мы с равной вероятностью либо выиграем, либо проиграем его, а значит, что в среднем ожидается, что наша Шестерка останется у нас. Во всех остальных случаях мы теряем шестерку. Итого, ожидаемое кол-во карт для Шестерки после одного сражения: 7/35 Шестерки + 4/35 Туза.
Теперь, заполним матрицу для ожидаемых кол-в всех карт для одного сражения (ряд Шестерки — это ожидаемое кол-во карт получаемое после одного сражения с участием нашей Шестерки).
| | Шестерка | Семерка | Восьмерка | Девятка | Десятка | Валет | Дама | Король | Туз |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Шестерка | 7/35 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 4/35 |
| Семерка | 4/35 | 7/35 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| Восьмерка | 4/35 | 4/35 | 11/35 | 0 | 0 | 0 | 0 | 0 | 0 |
| Девятка | 4/35 | 4/35 | 4/35 | 15/35 | 0 | 0 | 0 | 0 | 0 |
| Десятка | 4/35 | 4/35 | 4/35 | 4/35 | 19/35 | 0 | 0 | 0 | 0 |
| Валет | 4/35 | 4/35 | 4/35 | 4/35 | 4/35 | 23/35 | 0 | 0 | 0 |
| Дама | 4/35 | 4/35 | 4/35 | 4/35 | 4/35 | 4/35 | 27/35 | 0 | 0 |
| Король | 4/35 | 4/35 | 4/35 | 4/35 | 4/35 | 4/35 | 4/35 | 31/35 | 0 |
| Туз | 0 | 4/35 | 4/35 | 4/35 | 4/35 | 4/35 | 4/35 | 4/35 | 31/35 |
Очевидно, что недостаточно учесть одно сражение, чтобы определить ценность карты. Например, у Шестерки есть шанс выиграть Туза, который сыграет в какой-то момент в будущем и, в свою очередь, имеет шанс выиграть другие карты. Как получить подобную матрицу, но с ожидаемыми кол-вами карт через два сражения? Ответ оказывается до изумления простым — надо просто [умножить эту матрицу](https://ru.wikipedia.org/wiki/%D0%A3%D0%BC%D0%BD%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86) на саму себя! (Основы матричного умножения: чтобы получить элемент (X, Y) результата умножения, надо скалярно умножить ряд Х первой матрицы на колонку Y второй, то есть попарно перемножить соответствующие элементы этих двух векторов и результаты сложить).
Например, вероятность начать с Шестерки и через 2 сражения держать на руках Шестерку — (7/35)^2, так как Туз, потенциально выигранный в первом сражении никак не увеличивать шансов получить Шестерку во втором. Однако, тот же Туз увеличивает шансы получить каждую из остальных карт во втором сражении — но ожидаемые кол-ва карт для Туза во втором сражении умножаются на вероятность получить Туза в первом сражении (4/35). И т.д.
Здесь можно вполне резонно возразить, что к моменту второго сражения вероятности уже не будут такими, как на момент первого, так как мы предполагаем определенные результаты первого сражения. Действительно, в идеале мы просчитали бы все пути этого сада расходящихся тропок. Но сделать это непросто, поэтому мы предположим, что изменяющееся вероятности одинаковы для всех карт и ошибки каким-то образом усредняются.
Итак, совсем немного руби кода:
```
require 'matrix'
# Матрица ожидаемых кол-в для одного сражения
m1 = Matrix[
[7.0/35, 0, 0, 0, 0, 0, 0, 0, 4.0/35],
[4.0/35, 7.0/35, 0, 0, 0, 0, 0, 0, 0],
[4.0/35, 4.0/35, 11.0/35, 0, 0, 0, 0, 0, 0],
[4.0/35, 4.0/35, 4.0/35, 15.0/35, 0, 0, 0, 0, 0],
[4.0/35, 4.0/35, 4.0/35, 4.0/35, 19.0/35, 0, 0, 0, 0],
[4.0/35, 4.0/35, 4.0/35, 4.0/35, 4.0/35, 23.0/35, 0, 0, 0],
[4.0/35, 4.0/35, 4.0/35, 4.0/35, 4.0/35, 4.0/35, 27.0/35, 0, 0],
[4.0/35, 4.0/35, 4.0/35, 4.0/35, 4.0/35, 4.0/35, 4.0/35, 31.0/35, 0],
[0, 4.0/35, 4.0/35, 4.0/35, 4.0/35, 4.0/35, 4.0/35, 4.0/35, 31.0/35]
]
# Матрица ожидаемых кол-в после 1000 сражений (m1 в степени 1000)
m1000 = m1 ** 1000
# (значения округлены) => Matrix[[0.0667, 0.0667, 0.0667, 0.0667, 0.0667, 0.0667, 0.0667, 0.0667, 0.0667], [0.0095, 0.0095, 0.0095, 0.0095, 0.0095, 0.0095, 0.0095, 0.0095, 0.0095], [0.0127, 0.0127, 0.0127, 0.0127, 0.0127, 0.0127, 0.0127, 0.0127, 0.0127], [0.0178, 0.0178, 0.0178, 0.0178, 0.0178, 0.0178, 0.0178, 0.0178, 0.0178], [0.0267, 0.0267, 0.0267, 0.0267, 0.0267, 0.0267, 0.0267, 0.0267, 0.0267], [0.0444, 0.0444, 0.0444, 0.0444, 0.0444, 0.0444, 0.0444, 0.0444, 0.0444], [0.0889, 0.0889, 0.0889, 0.0889, 0.0889, 0.0889, 0.0889, 0.0889, 0.0889], [0.2667, 0.2667, 0.2667, 0.2667, 0.2667, 0.2667, 0.2667, 0.2667, 0.2667], [0.4667, 0.4667, 0.4667, 0.4667, 0.4667, 0.4667, 0.4667, 0.4667, 0.4667]]
```
Обратите внимание, как через некоторое кол-во сражений все ожидаемые кол-ва карт для одной карты становятся одинаковыми — так как (из-за циркулярной системы ценностей) в конце концов мы можем выиграть **все** карты, то ожидаемые кол-ва для всех карт сходятся к одному числу. Теперь осталось совсем немного — складываем все числа в каждом ряду чтобы узнать «ценность» каждой из карт (т.е., ожидаемое число карт после 1000 сражений):
```
m1000.row_vectors.map {|row| row.reduce(&:+).round(3)}
# [0.6, 0.086, 0.114, 0.16, 0.24, 0.4, 0.8, 2.4, 4.2]
```
Для наглядности:
| | Шестерка | Семерка | Восьмерка | Девятка | Десятка | Валет | Дама | Король | Туз |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Ценность | 0.6 | 0.086 | 0.114 | 0.16 | 0.24 | 0.4 | 0.8 | 2.4 | 4.2 |
Неожиданные выводы:
* Ценность Шестерки лежит между Валетом и Дамой!
* Только у Короля и Туза ожидаемое конечное кол-во карт превышает 1 (то есть, ожидается позитивный ROI). | https://habr.com/ru/post/280312/ | null | ru | null |
# Запрограммируем вакансию
Неожиданно оригинальный подход я увидел тут в описании одной вакансии.
Дабы не сочли рекламой — всю инфу о работодателе выпилил.
Но за описание вакансии средствами ООП — однозначный респект!
```
public class JediJob extends GameDevJob implements IRemoteJob {
...
```
Полный исходник не влез до ката.
```
public class JediJob extends GameDevJob implements IRemoteJob {
public var company:ICompany = new XXXXXGames();
public var url:String = "http://xxxxxgames.com/xxxxxx.html";
public var email:String = "[email protected]";
public function apply():IGame {
var currentGame:IGame = new GameNameXXXX();
currentGame.mmorgp = true;
currentGame.engine3d = Engine.ALTERNATIVA_3D;
currentGame.protocols = ["xml", "json", "amf3"];
currentGame.platforms = ["facebook", "kongregate", "ownSite"];
return currentGame;
}
public function isAvailable(skills:Skills):Boolean {
var as3Skill:ISkill = skills.getSkill("as3");
return as3Skill.oop && as3Skill.years >= 3
&& as3Skill.level >= DevLevel.MIDDLE;
}
public function getSalary():uint {
return company.getInterview().result + company.getBonus();
}
}
``` | https://habr.com/ru/post/144603/ | null | ru | null |
# Yeoman Express Stack
*Прим. перев.: вместо короткой новости <https://plus.google.com/115133653231679625609/posts/YDNbxVxi4er> решил перевести доку по этому форку.*
**Yeoman Express Stack** — это форк [Yeoman](http://yeoman.io/) (*прим. перев.: [статья на хабре](http://habrahabr.ru/post/146829/)*).
Форк создан в доказательство возможности вести разработку полного стека (клиент-сервер) при помощи Yeoman 0.9.6, Express и AngularJS. Примечание: это экспериментальная ветка и (пока) пригодна только для тестирования и обкатки концепции.
Включает:
* Специализированную версию Yeoman server.js с поддержкой Express-миддлваре
* Из коробки поддерживается LiveReload
* Генератор для Express и CRUD—генератор для AngularJS
Предполагается, что вы будете распологать код и клиентской, и серверной частей приложения в одной директории. После установки можно посмотреть структуру встроенного тестового приложения: директория `server` для серверной части приложения и директория `app` для клиентской части.
##### Компоненты
* `yeoman-custom` — Спецсборка Yeoman 0.9.6 с поддержкой Express-миддлваре
* `generators` — генераторы для Express и AngularJS (CRUD)
* `demo` — приложение-пример
##### Установка (предполагается, что [email protected] уже установлен)
Склонировать репозиторий
```
git clone git://github.com/yeoman/yeoman.git
cd yeoman
git checkout express-stack
```
Установить [email protected] и Grunt
```
npm install -g yeoman
npm install -g grunt
```
Затем из директории `express-stack` выполнить:
1. `npm install`
2. `grunt install`
3. следуйте подсказкам из п.2 и обновите [системные пути](http://hathaway.cc/2008/06/how-to-edit-your-path-environment-variables-on-mac-os-x/)
4. теперь вам доступна новая команда `yeomen` (заметили **e** вместо **a** в слове `yeoman`? — **e** значит **express**); эта команда может запускать отдельную копию **yeoman** для использования новых генераторов, перечисленных ниже
##### Начнём
После завершения процесса установки у вас есть два варианта — можно начать новое приложение, используя перечисленные ниже команды, или перейти к демо, в котором уже есть небольшой пример кода, чтобы можно было попробовать готовый проект.
```
yeomen init angularcrud # Обычное приложение Angular
yeomen init angularcrud:crud post # Angular CRUD routes/views
yeomen init express post # Express CRUD
yeomen server
# теперь можно перейти по ссылке #/api/post/index чтобы проверить
# что маршрутизация корректно работает с Express
```
Примечание: если будут сыпаться ошибки о том, что Express не установлен, выполните `npm install express`.
##### Демо
Теперь можно перейти в директорию **demo** и выполнить команду `yeomen server`, чтобы запустить это приложение. Если у вас локально установлено несколько версий yeoman, то можно использовать `yeoman-custom` напрямую, но в целом должно работать и так.
И наконец генераторы. Поддерживаются следующие:
```
Angularcrud:
angularcrud:all
angularcrud:app
angularcrud:common
angularcrud:controller
angularcrud:crud
angularcrud:crud-controller
angularcrud:crud-route
angularcrud:crud-view
angularcrud:directive
angularcrud:filter
angularcrud:route
angularcrud:service
angularcrud:view
Express:
express:all
express:crud
```
Подробнее о каждом можно прочитать в **USAGE**.
##### Авторы
@addyosmani, @blai, @jacobmumm, @mklabs
*Прим. перев.
Мнение о том, насколько удобно использовать Yeoman для разработки приложений на AngularJS, можно составить по видео (видео длинное, но интересное; показан процесс создания простенького магазина):
(**смотреть с 13:40**)
<http://youtu.be/XOmwZopzcTA?t=13m40s>.
На всякий случай подчеркну, что в видео используется обычная сборка Yeoman, и разрабатывается только клиентская часть.* | https://habr.com/ru/post/166835/ | null | ru | null |
# Визуальный брутфорс на примере решения 3D-головоломки
Когда-то давно друзья подарили вот такую головоломку:
Собрать её самостоятельно я так и не смог (всегда оставался один фрагмент). Посему было решено написать программу.
Для тех, кто не любит читать, решение доступно по [ссылке](http://jsfiddle.net/CnapoB/ufxohsab/) (внимание, сильно нагружает процессор).
Итак, имеем головоломку, состоящую из 25 одинаковых элементов, которые необходимо уложить в куб 5х5х5, где за единицу измерения взято наименьшее ребро элемента.
Выбор языка пал на JavaScript. Принеся в жертву производительность ради визуализации (очень уж хотелось сделать визуализированный брутфорс, как в кино), благо процесс перебора не обещался быть слишком продолжительным (почему, будет написано ниже).
**Разделим элементы головоломки на кубики с единичной стороной**
Основной процесс сборки будет происходить в трехмерном целочисленном массиве (5х5х5), назовем его «коробок», где неотрицательным значением будем обозначать ячейку, занятую кубиком элемента. Для большей информативности этим значением будет порядковый номер положения элемента в трехмерном пространстве. Всего существует 24 положения элемента в трехмерном пространстве, если угол поворота вокруг каждой оси кратен 90°. Для простоты подсчета числа положений я представил кубик ~~рубика~~, у которого грани окрашены разными цветами. Каждый раз он обращается к нам новой гранью и поворачивается четыре раза по часовой стрелке на 90° таким образом, чтобы эта грань всегда смотрела на нас. Итого 6 граней х 4 поворота = 24 положения в пространстве, где наши глаза неподвижны.
Зная число положений объекта в трехмерном пространстве и дополнив его отражением каждого состояния (другие два отражения как совместно так и по отдельности дадут либо тот же куб либо его первое отражение после кручения), получим, что на каждое уникальное решение головоломки, которых может быть больше одного, приходится еще 47 его вариаций, а следовательно, время, требуемое для решения, будет меньше времени полного перебора. *К сожалению, формулу расчета числа ходов для нахождения решения вывести не смогу, поэтому если кто-нибудь может, напишите, пожалуйста, в комментариях, добавлю в статью.*
Положение элемента в пространстве будет представлять собой относительные координаты пяти единичных кубиков, из которых состоит элемент: координаты будут браться относительно базовой точки (ее координаты [0,0,0], соответственно). Основным условием расположения базовой точки является ее обязательное нахождение на элементе таким образом, что при заполнении этим элементом куба, базовая точка располагалась на базовом уровне куба. Под базовым уровнем будем понимать уровень по оси Z, на котором в данный момент происходит сборка (уровни ниже заполнены полностью). Таким образом мы упростили себе (и не только) дальнейшие расчеты.
**24 положения**
```
//x,y,z
var elems=[
[[0,0,0],[1,0,0],[1,1,0],[2,1,0],[3,1,0]],//0
[[0,0,0],[1,0,0],[2,0,0],[0,0,1],[-1,0,1]],//1
[[0,0,0],[1,0,0],[1,-1,0],[2,-1,0],[3,-1,0]],//2
[[0,0,0],[1,0,0],[1,0,1],[2,0,1],[3,0,1]],//3
[[0,0,0],[1,0,0],[2,0,0],[2,-1,0],[3,-1,0]],//4
[[0,0,0],[1,0,0],[2,0,0],[2,0,1],[3,0,1]],//5
[[0,0,0],[1,0,0],[2,0,0],[2,1,0],[3,1,0]],//6
[[0,0,0],[1,0,0],[0,0,1],[-1,0,1],[-2,0,1]],//7
[[0,0,0],[0,1,0],[1,1,0],[1,2,0],[1,3,0]],//8
[[0,0,0],[0,1,0],[0,1,1],[0,2,1],[0,3,1]],//9
[[0,0,0],[0,1,0],[-1,1,0],[-1,2,0],[-1,3,0]],//10
[[0,0,0],[0,1,0],[0,2,0],[0,0,1],[0,-1,1]],//11
[[0,0,0],[0,1,0],[0,2,0],[-1,2,0],[-1,3,0]],//12
[[0,0,0],[0,1,0],[0,0,1],[0,-1,1],[0,-2,1]],//13
[[0,0,0],[0,1,0],[0,2,0],[1,2,0],[1,3,0]],//14
[[0,0,0],[0,1,0],[0,2,0],[0,2,1],[0,3,1]],//15
[[0,0,0],[0,0,1],[0,0,2],[0,1,2],[0,1,3]],//16
[[0,0,0],[0,0,1],[0,0,2],[-1,0,2],[-1,0,3]],//17
[[0,0,0],[0,0,1],[0,0,2],[0,-1,2],[0,-1,3]],//18
[[0,0,0],[0,0,1],[0,0,2],[1,0,2],[1,0,3]],//19
[[0,0,0],[0,0,1],[0,1,1],[0,1,2],[0,1,3]],//20
[[0,0,0],[0,0,1],[-1,0,1],[-1,0,2],[-1,0,3]],//21
[[0,0,0],[0,0,1],[0,-1,1],[0,-1,2],[0,-1,3]],//22
[[0,0,0],[0,0,1],[1,0,1],[1,0,2],[1,0,3]]//23
];
```
Порядок сборки определяется самой головоломкой: собираем снизу вверх, как только уровень заполняется полностью, переходим к следующему. Порядок брутфорса определяется массивом положений элементов в пространстве. Если после частичного заполнения уровня для какой-то свободной точки невозможно подобрать положение, предыдущий найденный элемент считается неверным, удаляется из массива текущего состояния и «коробка», продолжается поиск.
Что касается визуализации, трехмерное представление куба выполним в виде пяти срезов по оси Z, по срезу на каждый уровень.
Срезы представляют собой таблицы 5х5, заполненные ячейками с неотрицательными номерами из «коробка». Ячейки дополнительно окрашены разными цветами для отделения элементов головоломки друг от друга. Для снижения нагрузки состояние массива будем отображать раз в секунду или в критические моменты: запуск, пауза, остановка при нахождении ответа. Дополнительно для работы будем использовать «строку сохранения», с помощью которой можно ставить на паузу, вносить изменения в код и продолжать поиск с места паузы, а не с начала. Так же, отобразим число циклов (за момент окончания цикла примем момент отображения текущего состояния массива), число «переборов» за последний цикл и общее число «переборов».
Из особенностей стоит отметить, что в предстартовой подготовке в начале создается массив возможных положений для каждой координаты «коробка», чтобы заранее отсечь положения, которые не могут располагаться в этой точке. Так же для универсальности добавил возможность менять значения размера «коробка» по все трем координатам. Для увеличения скорости визуализации добавил массив ячеек таблиц срезов.
Полный код с комментариями:
— [GitHub](https://github.com/CnapoB/Cube)
— [JSFiddle](http://jsfiddle.net/CnapoB/ufxohsab/)
Запускаем, ждем (у меня ушло 114 циклов на Google Chrome, перебрав 96969659 вариантов), смотрим ответ и собираем уже в реальной жизни.
**Ответ**
**Строка сохранения для тех, кто хочет сделать проверку отражения**[[5,0,0,0],[5,0,4,0],[12,3,0,0],[12,4,1,0]]
**UPD** По совету [Serator](http://habrahabr.ru/users/serator/) добавил возможность использования web worker'ов, однако распараллелить расчеты не представляется возможным, так как следующий расчет зависит от результатов предыдущего, поэтому в web worker отдельно вынесены сами расчеты, а визуализация была оставлена в основном потоке.
Результаты работы приведены ниже в таблицах\*. Через дробь указано время расчета при активной вкладке расчета/при неактивной вкладке расчета. Все дополнения и расширения на время расчета были отключены.
С использованием web worker'а\*\*:
| | |
| --- | --- |
| Google Chrome 40.0.2214.115 (без аппаратного ускорения) | 168.08 сек./160.932 сек. |
| Google Chrome 40.0.2214.115 (с аппаратным ускорением) | 175.644 сек./168.802 сек. |
| Яндекс.Браузер 14.12.2125.10034 | 163.975 сек./202.875 сек. |
| Internet Explorer 11 | 243.778 сек./246.766 сек. |
| Mozilla Firefox 35.0.1 | 731.949 сек./707.266 сек. |
| Opera 27.0.1689.69 | 213.088 сек./189.991 сек. |
Без web worker'а:
| | |
| --- | --- |
| Google Chrome 40.0.2214.115 (без аппаратного ускорения) | 139.894 сек./1769.311 сек. |
| Google Chrome 40.0.2214.115 (с аппаратным ускорением) | 112.115 сек./1738.033 сек. |
| Яндекс.Браузер 14.12.2125.10034 | 137.854 сек./1901.142 сек. |
| Internet Explorer 11 | 240.888 сек./227.489 сек. |
| Mozilla Firefox 35.0.1 | 173.205 сек./2056.301 сек. |
| Opera 27.0.1689.69 | 130.07 сек./1904.973 сек. |
*\* — Результаты работы зависят от общей загруженности машины, поэтому в таблицах приведены усредненные значения. Погрешность при измерениях составляла порядка 5%.*
*\*\* — Приведен результат работы при отправке значений на визуализацию каждые 50 тыс. переборов, для остальных значений результат укладывался в погрешность.*
Можете проверить самостоятельно, запустив [скрипт](https://github.com/CnapoB/Cube) на локальном веб-сервере.
По сути распараллеливания процесса самого расчета не произошло, поэтому время на расчет с web worker'ом ушло больше, чем без него, однако его использование может оказаться полезным для проведения расчета на заднем фоне (когда вкладка расчета неактивна). Кроме того, Firefox оказался самым медленным для проведения расчета с web worker'ом, и сопоставим по времени при проведении расчетов без него. Отдельно стоит отметить, что благодаря web worker'у визуализацию можно чаще перерисовывать, что выглядит намного красивее, чем без него. | https://habr.com/ru/post/250807/ | null | ru | null |
# Погода и маршруты в MajorDoMo
Это вторая статья в которой я попытаюсь рассказать как настроить погоду и маршруты в системе умного дома **MajorDoMo** и сделаем для них отдельные сцены. А также настроим вывод данных о погоде на главной сцене.
**Оглавление**Часть 1: [Установка и настройка главной сцены в MajorDoMo](https://habrahabr.ru/post/336310/)
Часть 2: [Погода и маршруты в MajorDoMo](https://habrahabr.ru/post/336386/#first_unread)
Введение
--------
В [первой](https://habrahabr.ru/post/336310/) статье мы подробно разобрали как установить и настроить главную сцену в MajorDoMo. Теперь, используя полученные знания, настроим еще две сцены. Для начала нам нужно скачать шаблоны наших сцен для [погоды](https://drive.google.com/open?id=0ByA4-Qy4DiPYTXFlSmVoOHgwLXc) и [маршрутов](http://majordomo.smartliving.ru/forum/download/file.php?id=3324). Скачали? Отлично, давайте же их установим и настроим.
Настройка погоды
----------------
Как и в предыдущей статье, запускаем MajorDoMo переходим по нужной нам ссылке (если это компьютер за которым вы сидите, то [127.0.0.1](http://127.0.0.1/), если нет, то IP того устройства, где установлено MajorDoMo). Заходим в *Панель управления* -> *Сцены* и жмем *Добавить новую сцену*. Называем её weather и жмём *Добавить* (*Фоновое изображение* можно не ставить), сделаем, чтоб фон менялся автоматически, в зависимости от времени года. Далее переходим на вкладку *Элементы* и тут выбираем скачанный и разархивированный файл для погоды и жмем *Импортировать*. Как и в прошлый раз, нам нужно чтоб наша сцена была анимированной, для этого нам нужно изменить индексы что есть у меня, на те, что у вас. Вкратце напомню.
На панели *Элементы* есть элемент **general\_CSS (only CSS)**, заходим в него и в коде находим **.element\_\***, где \* это id элемента (для каждого такого элемента есть комментарий, в котором указано к какому элементу он относится). Ориентируясь на комментарии снова переходим на вкладку *Элементы*, клацаем по нужному нам и смотрим в адресной строке id данного элемента и в **general\_CSS (only CSS)** меняем то что там есть, на то, что мы узнали только что.
Давайте теперь сделаем так, чтоб фон менялся в зависимости от времени года. Идем в интернет и скачиваем четыре картинки времени года с нужным вам расширением (в моём случае 1024х600). Кладем скачанные картинки в папку \htdocs\cms\scenes\backgrounds.
После нужно добавить новый сценарий, *Панель управления* → *Сценарии* жмем *Добавить новый сценарий*, называем его getSceneImage и жмем *Добавить*.
Теперь в поле *Код* вставляем:
**Сценарий**
```
if($params['scene'] == "weather") {
$winter = array("cms/scenes/backgrounds/winter.jpg");
$spring = array("cms/scenes/backgrounds/spring.jpg");
$summer = array("cms/scenes/backgrounds/summer.jpg");
$autumn = array("cms/scenes/backgrounds/autumn.jpg");
$seasons = array(0 => $winter,
1 => $spring,
2 => $summer,
3 => $autumn);
$season = $seasons[floor(date('n') / 3) % 4];
$img = $season[rand(0, count($season) - 1)];
if (file_exists($img)) {
header("Content-type: image/jpg");
readfile($img);
}
} else {
$images = array("cms/scenes/backgrounds/weather_1067x640.jpg",
"cms/scenes/backgrounds/city_1067x640.jpg",
"cms/scenes/backgrounds/plants_1067x640.jpg");
$img = $images[rand(0, 2)];
if (file_exists($img)) {
header("Content-type: image/jpg");
readfile($img);
}
}
```
Если вы назвали сцену как-то иначе, то в первой строке измените слово weather на то, которое вы написали у себя. Во 2-5 строках вместо моих названий картинок напишите свои.
Сценарий готов. Теперь снова возвращаемся к нашей сцене *Панель управления* -> *Сцены* находим созданную сцену и жмем напротив сцены на карандашик, после появится знакомое окно редактирования. В поле *Фоновое изображение* пишем следующий код(если вы назвали сцену не weather, то пишем своё название):
```
/objects/?script=getSceneImage&scene=weather
```
Это, конечно, можно настроить и в элементе fon, но таким способом можно менять картинку от погодных условий (дождь, снег, гроза) или можно сделать несколько картинок на одно время года.
### Откуда взять данные о погоде?
Чтоб выводить погоду, нам её нужно откуда-нибудь взять. Для этого есть разные сервисы (погода Yandex, OpenWeatherMap и др.). Я остановился на OpenWeatherMap, его мы и будем настраивать. В системе MajorDoMo есть готовый модуль для OpenWeatherMap. Заходим в *Панель управления* -> *Маркет дополнений* во вкладке *Информация* находим модуль **Open Weather (by nick7zmail)** и жмем *Добавить*. После добавления в разделе *Приложения* находим и клацаем на **Погода от OpenWeatherMap**. На вкладке *Настройки* выбираем нужный вам город, ставим галочку **Использовать кешированные иконки**, настраиваем на сколько дней вам нужен прогноз и период обновлений. Чтоб заполнить поле **Ключ API**. Идем на сайт [OpenWeatherMap](https://openweathermap.org/) регистрируемся и получаем API ключ. Как его получить я описывать тут не буду, в интернете есть информация по этому поводу.
Картинки погоды, которые есть на сайте не очень красивые, можно их заменить на свои, например [эти](https://drive.google.com/file/d/0BxLihxCmD14jZ0J0aE5PUTVBVW8/view). Разархивируйте их с заменой в папку \htdocs\cached\openweather\image.
### График погоды
Чтобы выводить график фактической температуры, нам нужно сохранять историю. Чтоб сохранять историю заходим в *Панель управления* -> *Объекты* и находим там **openweather** *Погода Open Weather Map*. Напротив него жмем на карандашик и переходим на вкладку *Свойства* и создаем новое свойство с именем temperature в поле *Хранить историю (дней):* ставим столько дней, сколько вам нужно. Всё, история для температуры сохраняется, если нужно сохранять историю для чего-нибудь еще, то нужно просто посмотреть как называется свойство для нужного вам параметра.
**Несколько скринов для закрепления**
Видно, что те свойства, которые вы создали выделены жирным и возле этого свойства стоит **H**, это говорит о том, что сохраняется история для данного свойства.
Идем в нашу сцену, открываем элемент cont1 → chart и заменяем тот код, что там есть на наш
```
```
Теперь для остальных элементов в cont1 -> chart нам нужно немного изменить тот код, что там есть. Выберем, например, panel-now. В коде находим %ow\_fact.image%, %ow\_fact.weather\_type% и др. нам нужно все изменить. Их нужно взять из свойств объекта (на скринах выше они видны). Для panel-now это фактическая температура, соответственно заходим в нужное нам свойство объекта, копируем и заменяем его в panel-now. Не забываем и изменить ссылку на картинку.
**Что у нас должно получиться в элементе panel-now**
```
%ow\_fact.wind\_speed% м/с
%ow\_fact.wind\_direction%
%ow\_fact.humidity% %
%ow\_fact.pressure\_mmhg% мм рт.ст.
```
Думаю принцип понятен, тоже самое, но уже для других свойств проделываем с остальными элементами.
Если хотите, чтоб у вас возле названия города крутился компас, то вам нужно кое что изменить в элементе panel-location. Можете заменить на мой код и поставить свой город.
```
Тирасполь
```
Если с этим немного поиграться, то в итоге у вас получится что-то вроде этого
**Сцена погоды**
### Погода на главной сцене
Чтоб на главной сцене в окошке где находится погода выводилась ваша фактическая температура, достаточно сделать несколько простых действий. Заходим в настройки главной сцены и находим там элемент panel-weather. И редактируем тот код, как делали выше
**Скрытый текст**
```
Тирасполь
%ow\_fact.temperature%°C
%ow\_fact.weather\_type% /div>
```
Маршруты
--------
Для маршрутов в MajorDoMo также есть хороший модуль. Заходим в *Маркет дополнений* и во вкладке *Информация* находим модуль **GPS tracker** (by SergeJey). Добавляем его и видим в разделе *Приложения* появился *GPS-трекер*. Находим вкладку *Устройства* и жмем *Добавить новую запись*. У вас по умолчанию в разделе *Настройки* -> *Пользователи* есть один пользователь admin. Можно конечно зайти туда и изменить на своё усмотрение(например изменить имя). Пишем какое-то название, выбираем пользователя (в списке будет то имя, которое указано в *Пользователи*), а чтоб заполнить поле *Устройство*, нужно установить на телефон программку, у меня Big Brothr GPS (хотя есть и другие, ими не пользовался). В настройках программы находим URL и вписываем туда такую строчку [192.168.20.161/gps.php](http://192.168.20.161/gps.php) (у вас свой адрес, естественно); можно поставить все галочки, чтоб телефон отправлял данные на этот адрес, что вы указали в URL. Нас сейчас интересует галочка Send device id. Если включен GPS на телефоне и вы всё сделали правильно, то в GPS-трекер во вкладке *Лог событий* у вас появится строчка. Из неё мы и узнаем то ID, которое нам нужно вписать.
**Скрытый текст**
На вкладке *Настройки* нужно поставить *Yandex* в разделе *Сервис карт:* потому что для Google требуется API ключ.
У нас еще есть вкладка *Места*. Мы можем добавить какое-то место на карту и нарисовать окружность заданного вами радиуса вокруг этого места. Если вы войдете/выйдете из радиуса этой окружности, то можно настроить, чтоб выполнилось какое-либо действие. Но на этом в этой статье мы подробно останавливаться не будем, а то и так уже статья затянулась. Так вот, добавляем новое место, узнаем координаты широты и долготы из яндекс или гугл карт и вписываем их, радиус действие на ваше усмотрение, в поле *Виртуальный пользователь:* ставим 0. Готово, если вы отсылаете свои координаты с помощью телефона, то все должно работать и показываться ваш маршрут.
Не забываем предварительно открыть 1883 порт, чтоб ваше устройство на котором установлено MajorDoMo было видно из вне.
### Настройка сцены для GPS
Действуем по старой схеме. Создаем новую сцену, в поле *Фоновое изображение* ставите свою картинку (которую сохранили в папку \htdocs\cms\scenes\backgrounds с необходимым расширением). Редактируем id элементов, как делали ранее, чтоб ваши элементы были анимированными.
Чтобы ваши новые и настроенные сцены отображались на главной сцене. Т.е., чтоб при клике по кнопкам на главной сцене (погода и маршруты) открывались ваши сцены. Нужно зайти в настройки главной сцены и для элементов function\_1 и function\_2 в строчках кода поставить пути на ваши новые сцены.
**Скрытый текст**
Заключение
----------
В этой статье мы научились устанавливать и настраивать две сцены, одна для погоды, вторая для маршрутов. Также мы отслеживаем наш телефон и показываем наш маршрут движения. Теперь на главной сцене у нас показывается наша фактическая температура. На сцене погоды показывается прогноз и строится график температуры. Хотелось бы отдельно поблагодарить пользователя Vovix за то, что он сделал такие замечательные сцены. А также самого разработчика MajorDoMo — Сергея. Надеюсь эта статья будет кому-то полезна. | https://habr.com/ru/post/336386/ | null | ru | null |
# Еще одна история про домашний сервер, или операция «silence»
Добрый день, хабраюзеры!
Наверняка каждый разработчик, рано или поздно, сталкивается с проблемой тестового окружения. Не очень удобно держать ПК включенным 24х7, да еще и заваливать его софтом для экспериментов под завязку. С другой стороны найти хостинг по собственному вкусу, да еще и не дорогой — тоже задача не из легких. Что же делать? Выход есть — развернуть песочницу дома. Как я убедился, об этом детальнее ниже, это не дорого, это удобно и очень увлекательно.
**Disclaimer:** *пост публикуется по просьбе [icepro](https://habrahabr.ru/users/icepro/), поэтому не спешите менять карму мне, а лучше помогите хорошему человеку с инвайтом. Вы не найдете тут откровений или неожиданных решений, но проходя подобный путь сможете найти все необходимое в одном месте.*
Заранее предупрежу: статья первая, сильно не бейте.
А теперь к деталям. Заранее прошу бородатых админов и всех компетентных в данной теме людей, не хвататься за сердце, фукать и спешить ставить минусы, ведь я только учусь и администрированием плотно не занимался. Зато надеюсь начинающим смогу сократить путь в Linux на пару шагов и пройти быстрое знакомство действительно быстро :)
Краткое содержание
==================
1. [Начинка](#1)
2. [OS](#2)
3. [Dev Environment](#3)
4. [Резервное копирование](#4)
Начинка
=======
---
Итак, идея есть, начнем воплощать. Самым главным критерием для меня при выборе железа были — цена, низкое энергопотребление и отсутствие шума (иначе был риск что жена отправит мою песочницу на балкон, да еще может и со мной вместе:) ). Все это указывало на то, что целевым будет формфактор — MiniITX.
| | |
| --- | --- |
| image | image |
Побродив по интернет магазинам я нашел вот такую материнскую плату: **Intel BOXD2500HN**.
Базируется она на процессоре **Intel Atom D2500 (1.86 ГГц)**. Для меня этой мощности было предостаточно. Потребляет энергии — 10 Ватт. Цена — около $70. Охлаждение пассивное — шума нету. Так же дома валялась SO-DIMM память на 2 ГБ и полутерабайтный винт.
Теперь о корпусе. Опять таки хотелось меньше шума, и поэтому выбор пал на корпус со внешним БП — **DELUX E-2012 Black Mini-ITX**
Итого единственный кулер — 40 мм, размещенный над жестким диском (ну было штатное место, вот и решил укомплектовать полностью).
OS
==
---
Выбор операционки был не долгим. Ранее приходилось работать с Ubuntu, поэтому выбор пал на ее фундамент — Debian. На момент написания статьи последней версией (которую я и установил) была 7.0 — Wheezy. Скачать ее можно на оффсайте, там она представлена в нескольких вариациях в зависимости от графической оболочки. Голую консоль я ставить не решился, и поэтому среди представленных вариантов выбрал самую легковесную — LXDE.
Сразу оговорюсь — Debian поразила меня богатством софтового репозитория. В нем можно найти все что угодно. Для того что бы поискать по имени интересующую программу воспользуемся командой:
```
sudo apt-cache search <название программы, или его часть>
```
для установки выполняем
```
sudo apt-get install <название программы>
```
Далее по тексту я буду упоминать об установке софта, но вы уже будете знать как это делать.
Ставить Debian не сложно. Скачиваем образ и делаем загрузочную USB флешку (сделать ее поможет [LinuxLive USB Creator](http://www.linuxliveusb.com/)). Далее загружаемся с нее и включаем графический установщик (так будет проще). В основном установка похожа на установку windows: жмем Далее, Далее, Далее. Но некоторые моменты все же есть:
— на шаге выбора разметки выбираем отдельные разделы
— после того как мастер авторазбивки диска покажет вам предполагаемую структуру — не соглашайтесь, увеличьте RootFS (она же "/") хотя бы до пары гигабайт (у меня сейчас 512 Мб и за разделом приходится очень пристально следить)
— выбор программного обеспечения оставляем как есть (галки на «Окружение рабочего стола» и «Стандартная система», остальное поставим позже)
Если все же нужна пошаговая помощь при установке то рекомендую на просторах интернета найти маунал «Web-сервер на Debian GNU\_Linux для начинающих».
Далее было произведено несколько мелких твиков системы:
1. ### sudo
Для того что бы иметь возможность вашему пользователю исполнять команды от имени суперпользователя, его нужно добавить в sudoer list. Детали настройки можно найти в документе который я уже упоминал выше, в разделе «1.2.1 Базовая настройка sudo»
2. ### Удаленный доступ
Дабы иметь возможность удаленного доступа, я сейчас говорю не про ssh, а как раз рабочий стол, был установлен VNC сервер — x11vnc.
Настройка довольно легкая, сначала генерируем авторизационный файл:
```
x11vnc -storepasswd
```
а потом добавим VNC сервер в автозагрузку (/etc/xdg/lxsession/LXDE/autostart)
```
@/usr/bin/x11vnc -dontdisconnect -display :0 -notruecolor -noxfixes -shared -forever -rfbport 5900 -bg -o /var/log/x11vnc.log -rfbauth /home/ice/.vnc/passwd
```
3. ### Autologin
Материнская плата умеет восстанавливать свое состояние после того как электричество было прервано и возобновлено. Но если к серверу не подключен монитор и не видно состояния системы, то после перебоев в электросети графическая среда так и будет висеть на странице Login после перезагрузки. Для того что бы устранить это неудобство добавим возможность автовхода для нашего пользователя, для этого в файл /etc/lightdm/lightdm.conf добавим строки:
```
autologin-user=ice
autologin-user-timeout=0
```
4. ### Hardware монитор
Следить за оборудованием поможет
```
lshw
lshw-gtk
```
Для мониторинга температуры я доставил lm-sensors и hddtemp.
Команда
```
sensors
```
показывает информацию о МП с доступных датчиков.
*Перед использованием утилиты нужно что бы она обнаружила все датчики, для этого требуется запустить:*
```
/usr/sbin/sensors-detect
```
А команда
```
hddtemp /dev/sda
```
подсказывает до какой температуры нагрелся жесткий диск.
Первое время у меня была мания проверять температуру и другие датчики, поэтому я написал кратенький скрипт для сбора и логирования данных:
```
#!/bin/bash
echo '################## TIME ##################'
date
echo '################# UP TIME ################'
uptime
echo '################# MB TEMP ################'
sensors
echo '################ HDD TEMP ################'
sudo hddtemp /dev/sda
echo
echo
```
Теперь создадим расписание запуска скрипта, но предварительно выдадим ему права на выполнение:
```
visudo
ice ALL=NOPASSWD: /home/ice/scripts/monitoring/temp.sh
```
а теперь Cron:
```
sudo crontab -e -u ice
*/10 * * * * sudo /home/ice/scripts/monitoring/temp.sh >> /home/ice/scripts/monitoring/temp.log 2>&1
```
Проверить что запуски происходят можно командой:
```
grep CRON /var/log/syslog
```
И еще одно — что бы логи не накапливались я настроил их ротацию. Что бы это сделать установим Logrotate
```
sudo apt-get install logrotate
```
А далее создадим в папке /etc/logrotate.d/ файл конфигурации. Мой выглядит так:
```
/home/ice/scripts/monitoring/temp.log { # путь к логам
daily # ротировать ежедневно
missingok # отсутствие файла не является ошибкой
rotate 30 # сохраняется последние 30 ротированных файлов
compress # сжимать ротируемый файл
delaycompress # сжимать предыдущий файл при следующей ротации (т.е. файл *.log.1 будет не сжат, а *.log.2 и далее сжатыми)
notifempty # не обрабатывать пустые файлы
create 640 ice ice # сразу после ротации создать пустой файл с заданными правами и пользователем
}
```
5. ### Другие мелочи
* htop — продвинутый монитор процессов
* пакет для измерения производительности системы, детали тут [sysstat](http://packages.debian.org/ru/squeeze/sysstat), а настройка тут — [Permanent link to How to configure sysstat/sar on Ubuntu/Debian](http://www.leonardoborda.com/blog/how-to-configure-sysstatsar-on-ubuntudebian/)
* lynis — утилита, помогающая побороть желание «нужно больше контроля и мониторинга над системой», описание — [lynis](http://www.rootkit.nl/projects/lynis.html)
* rtorrent — консольный торрент-клиент (я кстати еще и web-морду к нему пристроил, очень удобно), детали настройки можно найти тут — [Установка rtorent+rutorrent на Debian/Ubuntu](http://blog.itradius.ru/?p=15)
* exim4 — почтовый сервер, конфигурация с использованием GMail SMTP описана тут — [Configuring exim4 in Ubuntu to use GMail for SMTP](http://www.manu-j.com/blog/wordpress-exim4-ubuntu-gmail-smtp/75/)
* proftpd — FTP сервер (настройку подсмотрел тут [Настройка домашнего сервера на базе Debian](http://habrahabr.ru/post/48619/))
* samba — сетевая файловая система (попробовать хотелось всего, вот и поставил), настройку можно найти тут — [Установка и настройка Samba в Debian GNU/Linux и Ubuntu Linux](http://debiania.blogspot.com/2009/05/samba-debian-gnulinux-ubuntu-linux.html)
Для доступа samba использует системных пользователей, добавить их в базу данных SMB можно командой
```
smbpasswd -a ice
```
* mc — полезный файловый менеджер
* ssh — тут без комментариев
* в опции монтирования (/etc/fstab) добавил commit=60 для борьбы с излишним журналированием которое постоянно мучило жесткий диск (процесс jbd2)
Dev Environment
===============
---
Итак, теперь самое интересное, что же мне удалось впихать в эту маленькую коробочку.
[LAMP](#lamp) | [nginx](#nginx) | [Node.js](#node) | [MongoDB](#mongo) | [GIT](#git) | [Java](#java) | [Python](#python) | [Ruby](#ruby) | [.NET](#net) | [Jenkins](#jenkins)
LAMP
----
Да, я активный web-разработчик и без этой платформы как без рук. Ставится все элементарно:
```
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install apache2 apache2-doc php5 libapache2-mod-php5 php-pear
sudo apt-get install mysql-server mysql-client php5-mysql
sudo apt-get install php5-curl php5-gd php5-imagick php5-ldap php5-imap php5-memcache php5-common php5-mysql php5-ps php5-tidy imagemagick php5-xcache php5-xdebug php5-xmlrpc php5-xsl
```
Но сразу после установки меня постигла неудача — php файлы никак не хотели обрабатываться apache'м. Для того что бы это исправить я произвел следующие манипуляции:
```
/etc/apache2$ sudo gedit apache2.con
# перед секцией инклудов добавил
AddHandler application/x-httpd-php .php .php4 .php3 .html
AddType application/x-httpd-php .html
```
Для удобного дебага php я поставил и настроил **xdebug**. Установка детально описана по следующим ссылкам:
— [Configuring Xdebug for PHP development/Linux](http://docs.joomla.org/Configuring_Xdebug_for_PHP_development/Linux)
— [Remote Xdebug на PhpStorm](http://www.seocoder.org/2011/02/05/remote-xdebug-na-phpstorm/)
**При создании виртуальных хостов не забываем прописывать их в hosts**
nginx
-----
Для повышение производительности апача рекомендуют использовать его в связке с nginx со следующим распределением ролей: apache — backend, nginx — frontend. О том как выполнить такую конфигурацию повествует статья — [Установка и настройка Nginx. Nginx frontend + Apache backend.](http://cname.org.ua/2010/04/%D1%83%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B0-%D0%B8-%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-nginx-nginx-frontend-apache-backend-%D1%83%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2/)
Node.js
-------
Прекрасная платформа, особенно для создания небольших клиент-серверных приложений. Одни только web-sockets чего стоят. Ну да ладно, вернемся к установке. Ставить node.js немного не тривиально, но не сложно — true'шным образом, то есть из исходников:
```
sudo apt-get install python g++ make checkinstall
mkdir ~/src && cd $_
wget -N http://nodejs.org/dist/node-latest.tar.gz
tar xzvf node-latest.tar.gz && cd node-v* # убираем "v" из номера версии в окне диалога
./configure
checkinstall
sudo dpkg -i node_*
```
Чуть более подробно установка расписана тут — [Installing Node.js](https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager)
MongoDB
-------
А почему бы еще и не приобщиться к NoSQL сообществу? Вот и я задался этим вопросом. Ну может плотно NoSQL использовать я и не планировал, но пощупать — почему нет?
Устанавливаем!
```
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv 7F0CEB10
echo 'deb http://downloads-distro.mongodb.org/repo/debian-sysvinit dist 10gen' | sudo tee /etc/apt/sources.list.d/mongodb.list
sudo apt-get update
sudo apt-get install mongodb-10gen
```
… и запускаем
```
sudo /etc/init.d/mongodb start
```
GIT
---
Давно уже хотелось съехать с публичных репозиториев на github. И вот пришло время. Git поставить не сложно, он в репозитории пакетов так и зовется — git, но сконфигурировать его для удобной работы немного сложнее, нам нужно:
— создать отдельного пользователя — git
— установить giolite для администрирования репозиториев
*Вот это видео помогло побороть ситуацию когда мои ключи сгенерированные в putty игнорировались — [How To Fix «Server Refused Our Key» Error That Caused By RSA Public Key Generated By Puttygen](http://www.youtube.com/watch?v=Bmpj-WdXllQ)*
Далее клонируем giolite репозиторий — ssh://[email protected]:/gitolite-admin.git и вуаля, управляем репами.
Настроить git+gitolite помогли следующие ссылки:
— [Настройка сервера. Gitolite — хостинг git-репозиториев](http://klen.github.io/gitolite-setup-ru.html)
— [Собственный git-сервер с нуля](http://blog.publicfields.net/2010/09/git.html)
Для удобного обзора репозиториев из браузера существует — gitweb. Как его установить описано здесь — [Setting up Gitweb on Debian](http://blog.gauner.org/blog/2010/02/03/setting-up-gitweb-on-debian/).
От себя добавлю:
```
usermod -a -G gitolite www-data
```
для того что бы apach и gitolite подружились.
**А вот настройка виртуального хоста (по крупицам собирал из разных источников пока не заработало)**
```
ServerAdmin webmaster@localhost
ServerName git-web.loc
SetEnv GITWEB\_CONFIG /etc/gitweb.conf
DocumentRoot /home/git/repositories
Alias /static/gitweb.css /usr/share/gitweb/static/gitweb.css
Alias /static/git-logo.png /usr/share/gitweb/static/git-logo.png
Alias /static/git-favicon.png /usr/share/gitweb/static/git-favicon.png
Alias /static/gitweb.js /usr/share/gitweb/static/gitweb.js
Alias /git /home/git/repositories
ScriptAlias /gitweb.cgi /usr/lib/cgi-bin/gitweb.cgi
DirectoryIndex gitweb.cgi
Allow from All
Options +ExecCGI
AllowOverride All
AuthType Basic
AuthName "Private Repository"
AuthUserFile /home/ice/stuff/keys/.htpasswd-gitweb
Require valid-user
AddHandler cgi-script .cgi
DirectoryIndex gitweb.cgi
RewriteEngine On
RewriteCond %{REQUEST\_FILENAME} !-f
RewriteRule ^.\* /gitweb.cgi/$0 [L,PT]
SetEnv GIT\_PROJECT\_ROOT /home/git/repositories
SetEnv GIT\_HTTP\_EXPORT\_ALL
ErrorLog ${APACHE\_LOG\_DIR}/git\_web\_error.log
LogLevel warn
CustomLog ${APACHE\_LOG\_DIR}/git\_web\_access.log combined
```
Basic авторизация по вкусу, можно отключить.
Java
----
Перейдем к java платформе. Первым делом удалим openjdk и поставим Java 7
```
sudo apt-get remove openjdk*
su -
# добавим репозитории java
echo "deb http://ppa.launchpad.net/webupd8team/java/ubuntu precise main" | tee -a /etc/apt/sources.list
echo "deb-src http://ppa.launchpad.net/webupd8team/java/ubuntu precise main" | tee -a /etc/apt/sources.list
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys EEA14886
apt-get update
# принимаем лицензию Oracle software license
echo oracle-java7-installer shared/accepted-oracle-license-v1-1 select true | /usr/bin/debconf-set-selections
# ставим Oracle JDK7
apt-get install oracle-java7-installer
# выходим из под root
exit
# убедимся что java поставилась
java -version
```
Сверху я прибавил следующее ПО:
— scala (как раз изучаю, почему бы не потренироваться на своем сервере)
— glassfish — один из самых активно разрабатываемых (если не самый) серверов приложений
\* если glassfish не запускается из-за того что занят порт 8080 (как это получилось у меня), то давайте сменим дефолтный порт. Для этого в GlassFish\_Server\glassfish\domains\domain1\config находим наш порт и ставим другой:
Python
------
Следующим пожаловал питон вместе с django. Ставятся из репозитория довольно легко. Вот тут можно посмотреть на простоту использования — [Writing your first Django app](https://docs.djangoproject.com/en/dev/intro/tutorial01/)
Ruby
----
Как и питон, руби я поставил тоже со своим фреймворком — Rails. Ставить чуть сложнее, поэтому приводу инструкцию:
```
apt-get install build-essential libapache2-mod-passenger ruby rdoc ruby-dev libopenssl-ruby rubygems
gem install fastthread
gem install rails --version 3.0.4
```
А так же не забудьте добавить rails в $PATH:
`PATH=".../var/lib/gems/VERSION/bin"`
Ну а использовать все так же легко — [Getting Started with Rails](http://guides.rubyonrails.org/getting_started.html)
Для внутренних нужд так же было решено развернуть баг-трекер, и им стал -**Redmine**.
Ставить вот так:
```
# доставляем нужные библиотеки
aptitude install libmagickcode-dev
aptitude install libmagickwand-dev
aptitude install ruby1.9.1-dev
aptitude install libmysqlclient-dev
# скачиваем и распаковываем redmine
cd /opt
wget http://files.rubyforge.vm.bytemark.co.uk/redmine/redmine-2.3.1.tar.gz
tar -zxvf redmine-2.3.1.tar.gz
cd /var/www
ln -s /redmine-2.3.1/public redmine
chown -R www-data:www-data /opt/redmine-2.3.1
```
Заходим в mysql клиент и создаем базу и пользователя:
```
CREATE DATABASE redmine_default CHARACTER SET utf8;
CREATE USER 'redmine'@'localhost' IDENTIFIED BY 'my-password';
GRANT ALL PRIVILEGES ON redmine_default.* TO 'redmine'@'localhost';
```
Создаем конфигурацию базы
```
cd /redmine-2.3.1/config
cp database.yml.example database.yml
vi database.yml
```
и заполняем ее
```
production:
adapter: mysql2
database: redmine_default
host: localhost
username: redmine
password: my-password
encoding: utf8
```
Создаем файл настроек:
```
cd /redmine-2.3.1/config
cp configuration.yml.example configuration.yml
vi configuration.yml
```
и настраиваемся (благо в конфиге полно комментариев).
Теперь ставим ruby bundle
```
gem install bundler
bundle install --without development test postgresql sqlite
rake generate_secret_token
bundle install
```
и готовим базу данных:
```
RAILS_ENV=production rake db:migrate
RAILS_ENV=production rake redmine:load_default_data
```
После всего этого нужно настроить виртуальных хост в апаче и можно пользоваться.
Настройка (получение информации о комитах из репозитория) описана тут — [Redmine Settings](http://www.redmine.org/projects/redmine/wiki/RedmineSettings#Repositories). С выбрал вариант в котором с помощью Cron настраивается автоматический опрос репозиториев.
.NET
----
Не забываем про .NET платформу. Основные компоненты это собственно mono платформа и XSP (ASP.NET сервер) ставятся вот так:
```
sudo apt-get install mono-common mono-xsp4
```
Все, теперь почти все прелести .NET нам доступны.
Деталей можно почерпнуть тут: [Mono for Debian](http://mono-project.com/DistroPackages/Debian) .
Jenkins
-------
А венчает все это — CI сервер. Давайте рассмотрим как его поставить и настроить например для… PHP:
Ставим Jenkins
```
sudo apt-get update
sudo apt-get install php5-cli php5-xdebug php-pear ant git
php -r 'echo "Xdebug loaded? "; echo (extension_loaded("xdebug")) ? "yes" : "no"; echo chr(10);'
wget -q -O - http://pkg.jenkins-ci.org/debian/jenkins-ci.org.key | sudo apt-key add -
sudo bash -c "echo 'deb http://pkg.jenkins-ci.org/debian binary/' > /etc/apt/sources.list.d/jenkins.list"
sudo apt-get update
sudo apt-get install jenkins
```
**Добавляем плагины**
```
wget http://localhost:8080/jnlpJars/jenkins-cli.jar
java -jar jenkins-cli.jar -s http://localhost:8080 install-plugin checkstyle
java -jar jenkins-cli.jar -s http://localhost:8080 install-plugin cloverphp
java -jar jenkins-cli.jar -s http://localhost:8080 install-plugin dry
java -jar jenkins-cli.jar -s http://localhost:8080 install-plugin htmlpublisher
java -jar jenkins-cli.jar -s http://localhost:8080 install-plugin jdepend
java -jar jenkins-cli.jar -s http://localhost:8080 install-plugin plot
java -jar jenkins-cli.jar -s http://localhost:8080 install-plugin pmd
java -jar jenkins-cli.jar -s http://localhost:8080 install-plugin violations
java -jar jenkins-cli.jar -s http://localhost:8080 install-plugin xunit
java -jar jenkins-cli.jar -s http://localhost:8080 install-plugin git
java -jar jenkins-cli.jar -s http://localhost:8080 safe-restart
```
**Устанавливаем PHPUnit и дополнительные инструменты**
```
sudo pear upgrade PEAR
sudo pear channel-discover pear.pdepend.org
sudo pear channel-discover pear.phpmd.org
sudo pear channel-discover pear.phpunit.de
sudo pear channel-discover components.ez.no
sudo pear channel-discover pear.symfony-project.com
sudo pear install pdepend/PHP_Depend
sudo pear install phpmd/PHP_PMD
sudo pear install phpunit/phpcpd
sudo pear install phpunit/phploc
sudo pear install PHPDocumentor
sudo pear install PHP_CodeSniffer
sudo pear install --alldeps phpunit/PHP_CodeBrowser
sudo pear install --alldeps phpunit/PHPUnit
```
Конфигурируем:
— скачиваем /build.xml из <http://jenkins-php.org/> и редактируем под свой проект
— качаем PMD правила [http://phpmd.org/](http://phpmd.org/documentation/creating-a-ruleset.html) и кладем как /build/phpmd.xml в проект
— опционально можно добавить ее правил [http://pear.php.net/](http://pear.php.net/manual/en/package.php.php-codesniffer.annotated-ruleset.php) и ложим как /build/phpcs.xml в проект
— конфигурируем PHPUnit в /tests/phpunit.xml
— скачиваем шаблон задания
```
cd /var/lib/jenkins/jobs/
sudo git clone git://github.com/sebastianbergmann/php-jenkins-template.git php-template
sudo chown -R jenkins:nogroup php-template/
sudo /etc/init.d/jenkins stop
sudo /etc/init.d/jenkins start
```
— создаем новое задание из шаблона, привязываем к репозиторию (возможно придется добавить плагин под свою систему контроля версий) и радуемся.
Резервное копирование
=====================
---
Понятное дело что избежать поломок оборудования нельзя, но совсем другие ощущения возникают при этой мысли когда у тебя есть резервная копия данных (да еще и свежая).
Сам процесс разделен на 2 вида:
— полное (делаю выборочно, когда чувствую что в системе прошло много изменений и нужно бы сохраниться)
— частичное (все узлы системы которые подвержены ежедневным изменениям: базы, исходники и т.д.)
Сбор полного дампа произвожу с помощью remastersys скриптом.
**Посмотреть скрипт**
```
#!/bin/bash
# замеряем сколько идет резервирование
start=`date +%s`
echo '[FULL BACK UP Start]'
DATE_NOW=`date +%F`
echo '[FULL BACK UP Dump Creation]'
# запускаем резервирование
sudo remastersys backup install-$DATE_NOW.iso
echo '[FULL BACK UP Dump Saving]'
# перемещаем в основную папку хранения
sudo cp /home/remastersys/remastersys/install-$DATE_NOW.iso /home/backups/system-iso/install-$DATE_NOW.iso
sudo cp /home/remastersys/remastersys/install-$DATE_NOW.iso.md5 /home/backups/system-iso/install-$DATE_NOW.iso.md5
echo '[FULL BACK UP Clean up]'
# чистим tmp
sudo remastersys clean
echo '[FULL BACK UP End]'
end=`date +%s`
runtime=$((end-start))
echo 'Backup time =' $runtime 'sec(s)'
```
Частичное выполняется скрпитом в cron еженощно.
**Посмотреть скрипт**
```
#!/bin/bash
start=`date +%s`
echo '[BACK UP Start]'
DATE_PREF=`date +%F`
echo '[BACK UP Config]'
# настраиваем пути к папкам
BACKUP_MYSQL_DIR=/home/backups/mysql/$DATE_PREF
BACKUP_WWW_DIR=/home/backups/www/$DATE_PREF
BACKUP_GIT_DIR=/home/backups/git/$DATE_PREF
echo '[BACK UP Clean up]'
# чистим все что лежит дольше недели
find /home/backups/mysql/ -mtime +7 -print -mindepth 1 -delete >/dev/null 2>&1
find /home/backups/www/ -mtime +7 -print -mindepth 1 -delete >/dev/null 2>&1
find /home/backups/git/ -mtime +7 -print -mindepth 1 -delete >/dev/null 2>&1
echo '[BACK UP Not Clened Items]'
ls /home/backups/mysql/
ls /home/backups/www/
ls /home/backups/git/
echo '[BACK UP Back Up Hosts]'
# резервируем хосты
tar cpzf $BACKUP_WWW_DIR\-www.tgz /home/www/ >/dev/null 2>&1
echo '[BACK UP Back Up Repositories]'
# резервируем репозитории
tar cpzf $BACKUP_GIT_DIR\-git.tgz /home/git/ >/dev/null 2>&1
echo '[BACK UP Back Up MySQL]'
# резервируем базы данных
mysqldump -q -u root -p -h localhost tt\_rss | gzip -c > $BACKUP\_MYSQL\_DIR\-tt\_rss.sql.gz
mysqldump -q -u root -p -h localhost test | gzip -c > $BACKUP\_MYSQL\_DIR\-test.sql.gz
mysqldump -q -u root -p -h localhost redmine | gzip -c > $BACKUP\_MYSQL\_DIR\-redmine.sql.gz
mysqldump -q -u root -p -h localhost phpmyadmin | gzip -c > $BACKUP\_MYSQL\_DIR\-phpmyadmin.sql.gz
mysqldump -q -u root -p --skip-lock-tables -h localhost performance\_schema | gzip -c > $BACKUP\_MYSQL\_DIR\-performance\_schema.sql.gz
mysqldump -q -u root -p --skip-lock-tables -h localhost information\_schema | gzip -c > $BACKUP\_MYSQL\_DIR\-information\_schema.sql.gz
mysqldump -q -u root -p --events -h localhost mysql | gzip -c > $BACKUP\_MYSQL\_DIR\-mysql.sql.gz
echo '[BACK UP New Items]'
ls /home/backups/mysql/ | grep $DATE\_PREF
ls /home/backups/www/ | grep $DATE\_PREF
ls /home/backups/git/ | grep $DATE\_PREF
echo '[BACK UP End]'
end=`date +%s`
runtime=$((end-start))
echo 'Backup time =' $runtime 'sec(s)'
echo '========================================================='
```
Как видно — храню последние 7 копий.
Спасибо! Надеюсь было интересно!
**P.S.** В случае возникновения вопросов — буду рад помочь.
**P.P.S.** Дайте, инвайт, пожалуйста. | https://habr.com/ru/post/205120/ | null | ru | null |
# Периоды звездных суток и звездный год в радиоактивном распаде
Здесь будет рассказано о алгоритме сравнения функций плотности вероятности радиоактивного распада, проявляющих периодичность в звездные сутки и звездный год.
\*сидерический год — период орбитального движения Земли вокруг Солнца в инерциальной системе отсчёта (относительно «неподвижных звёзд»);
Эта статья массивное продолжение [вводной статьи 2014 года по периодам в радиоактивности](https://habrahabr.ru/post/225661/)
Выводы:
— Форма вероятностей неслучайна и зависит от космофизических причин
— Форма вероятностей с высокой вероятностью повторяется с периодичностью в солнечные и звездные сутки, солнечный и звездный год
— Форма вероятностей сходна в ближайшие промежутки времени
— Формы вероятностей часто бывают хирально симметричными
[Академия](http://video.yandex.ru/users/virusme/view/124/)
Более подробно об этом исследовании написано в [книге](http://shnoll.ptep-online.com/publications/shnoll2009ru.pdf)
И статьях на Успехах физических наук: [раз](http://ufn.ru/ru/articles/1998/10/e/) и [два](http://ufn.ru/ru/articles/2000/2/o/).
А теперь сам алгоритм и подробнее про задачу!
Задача стояла так: есть двухнедельный ряд частоты радиоактивного распада в секунду (всего 1639763 секунд {пример 5 секунд: 310 311 299 312 305}). Уже установлено экспертным методом, что паттерны функций плотности вероятности {пример 2 похожих функций вверху абзаца} (по 60 секунд в каждой гистограмме) с хорошей точностью напоминают друг друга каждые **1436 минут** {те самые звездные сутки — 23ч 56м}. Требуется подтвердить находку математически.
Продолжение функции pikmatch (из дальнего угла статьи) самое важное — комбинаторное сравнение критических точек.
*ret=(ab1/ab2)/(nb1/nb2);* — Соотношение высоты (y ось) критических точек внутри одной функции к такому же соотношению внутри другой функции
*re=(ac1/ac2)/(nc1/nc2)* — То же что и в предыдущем случае но теперь по оси x длины между точками
*red=(φ°/ξ°)/(θ°/τ°)* — В заключении меряем углы
*rme=(ab1+1)\*(ab2+1)\*(nb1+1)\*(nb2+1);* — коэффициент важности отношения
Теперь финальная формула *res=re\*red\*ret\*rme*
*res* — это показатель похожести функции *1* на функцию *2*
Вторая часть функции pikmatch()
```
for e in range(len(p)+len(p1)):
for l in range(len(p)+len(p1)):
if e>=len(p): me=minx[e-len(p)];pe=p1[e-len(p)];nme=nm1[e-len(p)];
else: me=maxx[e];pe=p[e];nme=nm[e];
if l>=len(p): ml=minx[l-len(p)];pl=p1[l-len(p)];nml=nm1[l-len(p)];
else: ml=maxx[l];pl=p[l];nml=nm[l];
red1=1;red=1;ab=y[pl]-y[pe];ac=pe-pl;au=x[ml]-x[me];ao=me-ml;hip=math.sqrt(ab**2+ac**2);hipe=math.sqrt(ao**2+au**2);
if (hip!=0)and(hipe!=0):
if math.asin(abs(au)/hipe)!=0:
red=abs(abs(math.asin(abs(ab)/hip)/math.asin(abs(au)/hipe))); # меряем углы
ret=abs(1-abs((0.00+abs((y[pl]+0.01)/(y[pe]+0.01)))/(0.00+abs((x[ml]+0.01)/(x[me]+0.01)))));uj=uj+1;
re=0+abs(1-abs(float(abs(pe-pl)+1))/float(abs(me-ml)+1));rme=(y[pe]+1)*(y[pl]+1)*(x[me]+1)*(x[ml]+1);rmu+=rme;
res+=abs(re*rme*red*ret);
return len(pi)*len(pi),res/uj,p,p1; # или /uj? rmu
```
Перед тем как сравнивать, мы алгоритмом DTW выравниваем одну функцию относительно другой и находим соотвествующие вершины:
Пример евклидова расстояния
И dynamic time warping
Загружаем журнал примеров похожих изображений и создаем функцию бегущего среднего для сглаживания гистограмм до функций плотности вероятности.
```
ma0=[];ma0.append([line.strip() for line in open('/users/andrejeremcuk/downloads/0505.jnl')]);
massa=[];m=[[0] for e in range(len(ma0[0]))];massamyfile=[];
import re
t=3;summa=[];
for e in range(3,len(ma0[0])/2): #len(ma0[0])
disguise=re.findall(r":(.+?) ", ma0[0][t]);disguise1=re.findall(r"- #1:(.*)", ma0[0][t]);
summa.append(int(disguise[0]));summa.append(int(disguise1[0]));t=t+2;
k=0;summ=[];sum1=[];
for e in range(len(summa)/2):
summ.append(summa[k]);sum1.append(summa[k+1]);k=k+2;
import random
import numpy as np
from collections import defaultdict
import math
import matplotlib.pyplot as plt
def movingaverage(interval, window_size):
window = np.ones(int(window_size))/float(window_size)
return np.convolve(interval, window, 'same')
```
Евклидова дистанция, для выравнивание картинки со смещением по горизонтали:
```
def euclid(x,y):
re=0.0;res=0;a=1
for i in range(len(x)):
re=re+abs(x[i]-y[i])**1
return abs((re)/len(x))#,math.sqrt(abs(res));
```
Нахождение пиков:
```
def pik(x,y):
pikx=[];piky=[];c=0;v=0;cy=0;vy=0;minx=[];miny=[];maxx=[];maxy=[];minmaxx=[];minmaxy=[];#x=x.tolist();y=y.tolist();
for e in range(1,len(x)-2):
if (x[e-1]x[e+1])or((x[e-1]x[e+2])): maxx.append(e);minmaxx.append(e);c+=1;
if (x[e-1]>x[e]x[e]==x[e+1])and(x[e]<=x[e+2])): minx.append(e);minmaxx.append(e);v+=1;
if (len(maxx)>1)and(minmaxx[c+v-2]==maxx[c-2])and(minmaxx[c+v-1]==maxx[c-1]): del maxx[c-2];del minmaxx[c+v-2];c-=1;
if (len(minx)>1)and(minmaxx[c+v-2]==minx[v-2])and(minmaxx[c+v-1]==minx[v-1]): del minx[v-2];del minmaxx[c+v-2];v-=1;
for e in range(1,len(y)-2):
if (y[e-1]y[e+1])or((y[e-1]y[e+2])): maxy.append(e);minmaxy.append(e);cy+=1;
if (y[e-1]>y[e]y[e]==y[e+1])and(y[e]<=y[e+2])): miny.append(e);minmaxy.append(e);vy+=1;
if (len(maxy)>1)and(minmaxy[cy+vy-2]==maxy[cy-2])and(minmaxy[cy+vy-1]==maxy[cy-1]): del maxy[cy-2];del minmaxy[cy+vy-2];cy-=1;
if (len(miny)>1)and(minmaxy[cy+vy-2]==miny[vy-2])and(minmaxy[cy+vy-1]==miny[vy-1]): del miny[vy-2];del minmaxy[cy+vy-2];vy-=1;
return maxx,maxy,minx,miny,pikx,piky,minmaxx,minmaxy;
```
Метод Dynamic Time Warping для точного соотношения вершин 1 функции вероятности с вершинами 2 функции вероятности:
```
import numpy
import numpy as np
from numpy.fft import fft, fftfreq
import matplotlib.pyplot as plt
from numpy import linspace, loadtxt, ones, convolve
from numpy import array, zeros, argmin, inf
from numpy.linalg import norm
def _trackeback(D):
i, j = array(D.shape) - 1
p, q = [i], [j]
while (i > 0 and j > 0):
tb = argmin((D[i-1, j-1], D[i-1, j], D[i, j-1]))
if (tb == 0):
i = i - 1
j = j - 1
elif (tb == 1):
i = i - 1
elif (tb == 2):
j = j - 1
p.insert(0, i)
q.insert(0, j)
p.insert(0, 0)
q.insert(0, 0)
return (array(p), array(q))
def dtw(dr):
r, c = len(dr), len(dr[0]);
D = zeros((r + 1, c + 1));
D[0, 1:] = inf
D[1:, 0] = inf
for i in range(r):
for j in range(c):
D[i+1, j+1] = dr[i][j];
for i in range(r):
for j in range(c):
D[i+1, j+1] += min(D[i, j], D[i, j+1], D[i+1, j])
D = D[1:, 1:];
dist = D[-1, -1] / sum(D.shape);
return dist, D, _trackeback(D)
```
Теперь применим метод DTW для поиска соответствия вершин одной кривой к другой и если найдена лишняя вершина у одной из функций записываем в вершину пологую точку на кривой с тем же отступом, как будто бы у нас на самом деле там критическая точка.
```
def pikmatch(x,y,maxx,maxy,optimal,minmaxx,miny,minx):
uj=0;pikk=[[float("inf") for m in range(len(maxy))] for t in range(len(maxx))];pi=[0 for m in range(len(maxx))];ret=1;p=[];nad=0;wax=[];way=[];re=1;
for e in range(len(maxx)):
for l in range(len(maxy)):
pikk[e][l]=(((abs(x[maxx[e]]-y[maxy[l]])+0.001)**1)*(abs(maxx[e]-maxy[l]+optimal)+1));
pi[e]=min(pikk[e]);p.append(pikk[e].index(min(pikk[e])));p[e]=maxy[p[e]];nad=nad+pi[e];
if len(minx)==0: minx=[];minx.append(1)
if len(miny)==0: miny=[];miny.append(1)
dob=1;res=0;pikk1=[[float("inf") for m in range(len(miny))] for t in range(len(minx))];p1=[];pi1=[0 for m in range(len(minx))];
for e in range(len(minx)):
for l in range(len(miny)):
pikk1[e][l]=(((abs(x[minx[e]]-y[miny[l]])+0.001)**1)*(abs(minx[e]-miny[l]-optimal)+1));
pi1[e]=min(pikk1[e]);p1.append(pikk1[e].index(min(pikk1[e])));p1[e]=miny[p1[e]];nad=nad+pi1[e];
dt1=dtw(pikk);dt=dt1[2];dt2=dtw(pikk1);dt3=dt2[2];
for v in range(len(dt[1])):
p[dt[0][v]]=maxy[dt[1][v]];pi[dt[0][v]]=pikk[dt[0][v]][dt[1][v]];
if (v>0)and(dt[0][v]==dt[0][v-1])and(pikk[dt[0][v-1]][dt[1][v-1]]0)and(dt3[0][v]==dt3[0][v-1])and(pikk1[dt3[0][v-1]][dt3[1][v-1]]1};D1 = {k:v for k,v in D1.items() if len(v)>1}
for v in range(len(D.keys())):
mah=inf;
for e in range(len(D[D.keys()[v]])): mah=pi[D[D.keys()[v]][e]] if pi[D[D.keys()[v]][e]]-1: perem1=minx.index(minmaxx[minmaxx.index(maxx[k])-1])
for e in range(len(D[D.keys()[v]])):
if D[D.keys()[v]][e]!=k:
ms=D[D.keys()[v]][e];p[ms]=p[k]-(maxx[k]-maxx[ms]);
if ((maxx[k]-maxx[ms])<0)and(pp1.count(pp1[perem])==1): p1[perem]=p[ms]-(maxx[ms]-minx[perem]);
if ((maxx[k]-maxx[ms])>0)and(pp1.count(pp1[perem1])==1): p1[perem1]=p[ms]-(maxx[ms]-minx[perem1]);
for v in range(len(D1.keys())):
mah=inf;
for e in range(len(D1[D1.keys()[v]])): mah=pi1[D1[D1.keys()[v]][e]] if pi1[D1[D1.keys()[v]][e]]-1: perem1=maxx.index(minmaxx[minmaxx.index(minx[k])-1])
for e in range(len(D1[D1.keys()[v]])):
if D1[D1.keys()[v]][e]!=k:
ms=D1[D1.keys()[v]][e];p1[ms]=p1[k]-(minx[k]-minx[ms]);
if ((minx[k]-minx[ms])<0)and(pp.count(pp[perem])==1): p[perem]=p[ms]-(minx[ms]-maxx[perem]);
if ((minx[k]-minx[ms])>0)and(pp.count(pp[perem1])==1): p[perem1]=p[ms]-(minx[ms]-maxx[perem1]);
for i in range(len(p1)):
if p1[i]>59: p1[i]=59;
if p1[i]<0: p1[i]=0;
for i in range(len(p)):
if p[i]>59: p[i]=59;
if p[i]<0: p[i]=0;
```
Заключительная часть кода, где выполняется выравнивание и сравнение 1440 подряд картинок для поиска звездного года. Он найден в +368 минут как и указано в справочнике звездный год = 365.2564 суток
0.2564\*1440 минут в сутках = 369.216
1440-1072=368 минут добавляется к году
Так как в python отсчет идет от 0 элемента, то звездные сутки считаются от -3 минут (+1436 минута) от 1440 (+1440 начало нового периода), а звездный год от 1440-1072 минуты.
```
def stat_distanc(counter):
koeff=60;ex=20;ko=60;b=[0 for e in range(ko+ex)];bb=[0 for e in range(ko+ex)];#C:\\28-08-2004.txt /usr/local/28-08-2004.txt
matrix = [line.strip() for line in open('/users/andrejeremcuk/downloads/0505.txt')]; #days.dat
matri = [line.strip() for line in open('/users/andrejeremcuk/downloads/0506.txt')]; #days.dat
arra=[[ 0 for e in range(koeff)] for t in range(int(len(matrix)/koeff))];harra=[0 for t in range(int(len(matrix)/koeff))];
arrab=[[ 0 for e in range(koeff)] for t in range(int(len(matrix)/koeff))];harrab=[0 for t in range(int(len(matrix)/koeff))];z=0;resume=1;resum=0;
arr=[[ 0 for e in range(koeff)] for t in range(int(len(matri)/koeff))];
for i in range(len(matrix)): matrix[i]=int(matrix[i]);matri[i]=int(matri[i]);
for jk in range(2880): #int(len(matrix)/koeff)
for mk in range(koeff): arra[jk][mk]=matrix[z];arr[jk][mk]=matri[z];z=z+1;
for jk in range(2880):
harra[jk]=np.histogram(arra[jk], bins=ko, density=False);harrab[jk]=np.histogram(arr[jk], bins=ko, density=False);harra[jk]=harra[jk][0];harrab[jk]=harrab[jk][0]
for u in range(5): harra[jk] = movingaverage(harra[jk], 4);harrab[jk]=movingaverage(harrab[jk], 4);
for mk in range(1440):# 24000
mi=[];mis=[];mis1=[];mii=[];ei=[];ti=[];dots=[];dots1=[];
if counter=='l': rn=random.randint(0,1439);x=harra[mk];y=harrab[random.randint(0,1439)];#print rn; #y=harra[random.randint(0,1439)];
elif counter=='o': x=harra[summ[mk]-1];y=harra[sum1[mk]-1];
else: x=harra[mk+1440-counter];y=harrab[mk];
x=x.tolist();y=y.tolist();
for kl in range(ko): b[kl+ex/2]=y[kl];
for m in range(ex):
ct=[0 for e in range(ko+ex)];
for l in range(ko): ct[l+m]=x[l];
mis.append(euclid(ct,b));mis1.append(euclid(ct[::-1],b));
optimal=mis.index(min(mis))-ex/2;ret=pik(x,y);minmaxx=ret[6];minmaxy=ret[7];maxx=ret[0];maxy=ret[1];minx=ret[2];miny=ret[3]
optimal1=mis1.index(min(mis1))-ex/2;#print mk;
for k in range(len(minmaxx)): dots.append(x[minmaxx[k]]);#minmaxx[k]=59-minmaxx[k];
for k in range(len(minmaxy)): dots1.append(y[minmaxy[k]]);#minmaxy[k]=59-minmaxy[k]
outputs=pikmatch(x,y,maxx,maxy,-optimal,minmaxx,miny,minx);
outputs1=pikmatch(y,x,maxy,maxx,optimal,minmaxy,minx,miny);
plt.plot(minmaxx,dots,'go', alpha=0.5, ms=10);plt.plot(minmaxy,dots1,'bo', alpha=0.5, ms=10);
plt.plot(y,linewidth=4, alpha=0.5);plt.plot(x,linewidth=4, alpha=0.5);#plt.show();
mx1=minmaxx[:];my1=minmaxy[:];mxx1=maxx[:];mxx2=minx[:]
for k in range(len(minmaxx)): dots.append(x[minmaxx[k]]);minmaxx[k]=59-minmaxx[k];
for k in range(len(maxx)): maxx[k]=59-maxx[k];
for k in range(len(minx)): minx[k]=59-minx[k];
minmaxx=minmaxx[::-1];maxx=maxx[::-1];minx=minx[::-1];
output=pikmatch(x[::-1],y,maxx,maxy,-optimal1,minmaxx,miny,minx);minmaxx=minmaxx[::-1];mx2=minmaxx[:]; #
for k in range(len(minmaxy)): dots1.append(y[minmaxy[k]]);#minmaxy[k]=59-minmaxy[k]
minmaxx=mx1[:];
output1=pikmatch(y,x[::-1],maxy,maxx,optimal1,minmaxy,minx,miny);
resume+=min(outputs1[1]+outputs[1],output[1]+output1[1]);
#minmaxx=mx2[:];plt.plot(minmaxx,dots,'go');plt.plot(my1,dots1,'bo');plt.plot(y);plt.plot(x[::-1]);plt.show(); #plt.plot(x);
return resume/10000;
stat_distanc('o')
stat_distanc(1072)
```
Примеры похожих картинок:
Несмотря на то что эффект Шноля заявляет о нахождении солнечных суток и солнечного года, таких периодов не было обнаружено.
Звездные сутки были обнаружены в окрестностях +1440 — i минут +1436 минута:
```
199.892665349 -10 i
203.488567732 -9 i
209.135017031 -8
196.712944345 -7
201.306389699 -6
209.494707844 -5
213.761404735 -4
220.989501281 -3
214.488889148 -2
207.859987762 -1
221.399812849 0
208.188622006 1
202.261474872 2
195.414598182 3 период!
203.675784045 4
210.319165323 5
210.090229703 6
223.712227452 7
231.477304378 8
204.582579082 9
```
Звездный год — было подсчитаны все сутки от 365 до 366 суток нового года:
```
bas=[];
for i in range(1440): bas.append(stat_distanc(i));print i;
min(bas) - 1072
```
1440-1072, 368 то есть +369 дополнительная минута нового года. Точно звездный год 365 дней и 369 минута [365.2564]! (надо учитывать что отсчет начинается с 0 минуты)
Для тех кто решит все сам проверить и возможно улучшить распознавание образов [весь код и данные доступны на Github](https://github.com/a-nai/radioactivity)
Спасибо за внимание! | https://habr.com/ru/post/339078/ | null | ru | null |
# OpenStack, Docker и веб-терминал, или как мы делаем интерактивные упражнения для обучения Linux
В [статье](http://habrahabr.ru/company/spbau/blog/243473/) об онлайн-курсе «Введение в Linux» на образовательной платформе Stepic мы обещали рассказать о технической реализации нового типа интерактивных задач, который был впервые применен в этом курсе. Этот тип задач позволяет создавать на лету виртуальные серверы с Linux для работы через веб-терминал прямо в окне браузера. Автоматическая проверяющая система следит за корректностью выполнения заданий.
Пример [задания из курса](https://stepic.org/lesson/Terminal-основы-4758/step/14):
---
---
В этой статье я хочу рассказать о проекте, который лег в основу нового типа заданий на Stepic. Я также расскажу о том, из каких компонентов состоит система, и как они взаимодействуют между собой, как и где создаются удаленные сервера, как работает веб-терминал и автоматическая проверяющая система.
Вдохновение
===========
Я один из тех многих, кто при поиске работы не любит составлять резюме и писать десятки мотивационных писем IT-компаниям, чтобы пробиться через фильтр HR-специалистов и наконец получить от них заветное приглашение на собеседование. Куда более естественно, вместо того, чтобы писать о себе похвальные слова, показать свой реальный опыт и навыки на примере решения ежедневных задач.
Еще в 2012 году, будучи студентом Матмеха СПбГУ, я вдохновился проектом [InterviewStreet](https://interviewstreet.com/), позже эволюционировавшим в проект [HackerRank](https://www.hackerrank.com/domains). Ребята разработали платформу, на которой IT-компании могут проводить онлайн-соревнования по программированию. По результатам таких соревнований компании приглашают лучших участников пройти собеседование. В дополнение к рекрутингу целью проекта HackerRank стало создание сайта, на котором любой желающий может развивать навыки программирования через решение задач из разных областей Computer Science, таких как теория алгоритмов, искусственный интеллект, машинное обучение и другие. Уже тогда существовало большое количество других платформ, на которых проводились соревнования для программистов. Активно набирали популярность интерактивные онлайн-платформы для обучения программированию, такие как [Codecademy](http://www.codecademy.com/) и [Code School](https://www.codeschool.com/). К тому моменту я имел достаточный опыт работы системным администратором Linux и хотел видеть подобные ресурсы для упрощения процесса трудоустройства системных инженеров, проведения соревнований по администрированию Linux, ресурсы для обучения системному администрированию путем решения реальных задач в этой области.
После упорного поиска из похожих проектов нашелся только [LinuxZoo](http://linuxzoo.net/), разработанный для академических целей в Эдинбургском университете им. Непера (Edinburgh Napier University). Мне также попался на глаза [промо-ролик](https://www.youtube.com/watch?v=13GaYDoRwOg) весьма успешного и амбициозного проекта Coderloop, уже тогда заброшенного после [покупки](https://www.gild.com/2012/06/gild-acquires-coderloop/) компанией Gild. В этом ролике я увидел именно то, о чем тогда мечтал. К сожалению, разработанная в Coderloop технология для создания интерактивных упражнений по системному администрированию так и не увидела свет. Во время переписки с одним из основателей проекта Coderloop я получил много теплых слов и пожеланий по разработке и дальнейшему развитию этой идеи. Моему вдохновению не было предела. Так я начал разработку платформы Root’n'Roll, которой стал посвящать практически все свое свободное время.
Цели Root’n’Roll
================
Основной целью проекта стало не создание конкретного ресурса для обучения, проведения соревнований или рекрутинга системных инженеров, а нечто большее — создание базовой технической платформы, на которой можно было бы строить и развивать любое из этих направлений.
Ключевыми требованиями базовой платформы стали следующие:
* Иметь возможность максимально быстро и дешево запускать одновременно сотни или даже тысячи виртуальных машин с минимальной Linux-системой, которые можно безопасно вместе с root-правами отдать на растерзание пользователям. Дешево — значит минимизировать количество потребляемых системных ресурсов на одну виртуальную машину. Отсутствие какого-либо существенного бюджета подразумевает отказ от использования облачного хостинга вроде Amazon EC2 или Rackspace по принципу «одна виртуальная машина» = «один облачный инстенс».
* Позволять работать с виртуальной машиной через веб-терминал прямо в окне браузера. Никакие внешние программы для этого не требуются, только веб-браузер.
* Наконец, иметь интерфейс для тестирования конфигурации любой виртуальной машины. Тестирование конфигурации может включать в себя как проверку состояния файловой системы (лежат ли нужные файлы на своих местах, корректно ли их содержимое), так и проверки сервисов и сетевой активности (запущены ли какие-то сервисы, правильно ли они настроены, корректно ли отвечают на определенные сетевые запросы и т.д.).
Все перечисленные требования в какой-то мере уже удалось реализовать. Обо всем по порядку.
Запуск виртуальных машин
========================
Для запуска виртуальных машин сначала нужно было определиться с технологией виртуализации. Варианты с гипервизорной виртуализацией: аппаратной (KVM, VMware ESXi) и паравиртуализацией (Xen) — отпали довольно быстро. Эти подходы имеют довольно большие накладные расходы на системные ресурсы, в частности память, т.к. для каждой машины запускается свое отдельное ядро, и стартуют различные подсистемы ОС. Виртуализации такого типа также требуют наличия выделенного физического сервера, к тому же, при заявленном желании запускать сотни виртуалок, с весьма неплохим «железом». Для наглядности можно посмотреть на [технические характеристики](http://linuxzoo.net/page/tech.html) серверной инфраструктуры, используемой в проекте LinuxZoo.
Далее фокус пал на системы виртуализации уровня операционной системы (OpenVZ и Linux Containers (LXC)). Контейнерную виртуализацию можно очень грубо сравнить с запуском процессов в изолированном chroot окружении. Про сравнение и технические характеристики различных систем виртуализации написано уже огромное количество статей, в том числе на хабре, поэтому не останавливаюсь на подробностях их реализации. Контейнеризация не имеет таких накладных расходов, как полноценная виртуализации, потому что все контейнеры разделяют одно ядро хостовой системы.
Как раз к моменту моего выбора виртуализации успел выйти в Open Source и нашуметь о себе проект [Docker](https://www.docker.com/), предоставляющий инструменты и среду для создания и управления LXC-контейнерами. Запуск LXC-контейнера под управлением Docker (далее docker-контейнер или просто контейнер) сравним с запуском процесса в Linux. Как и обычному linux-процессу, контейнеру не нужно заранее резервировать оперативную память. Память выделяется и очищается по мере использования. Если нужно, можно установить гибкие ограничения на максимальный объем используемой памяти в контейнере. Огромное преимущество контейнеров в том, что для контроля их памятью используется общая хостовая подсистема управления страницами памяти (в том числе механизм copy-on-write и разделяемые страницы). Это позволяет увеличить плотность размещения контейнеров, то есть можно запускать гораздо больше экземпляров linux-машин, чем при использовании гипервизорных систем виртуализации. Благодаря этому достигается эффективная утилизация ресурсов сервера. С запуском нескольких сотен docker-контейнеров с процессом bash внутри запросто справится даже micro-инстенс в облаке Amazon EC2. Еще один приятный бонус — сам процесс запуска контейнера занимает миллисекунды.
Таким образом, на первый взгляд Docker дешево решал задачу запуска большого количества машин (контейнеров), поэтому для первого proof-of-concept решения я решил остановиться именно на нем. Вопрос о безопасности достоин отдельного обсуждения, пока опустим. Кстати, ребята из Coderloop для создания виртуальных окружений в своих упражнениях также использовали LXC-контейнеры.
Управление контейнерами
=======================
Docker предоставляет программный REST-интерфейс для создания и запуска контейнеров. Через этот интерфейс можно управлять только контейнерами, находящимися на том же сервере, на котором запущен сервис docker.
Если заглянуть на один шаг вперед, то хорошо было бы иметь возможность горизонтально масштабироваться, то есть запускать все контейнеры не на одном сервере, а распределить их на несколько серверов. Для этого необходимо иметь централизованное управление docker-хостами и планировщик, позволяющий балансировать нагрузку между несколькими серверами. Наличие планировщика может быть очень полезно во время технического обслуживания сервера, например, установки обновлений, требующих перезагрузку. В таком случае сервер помечается как «в обслуживании», в результате чего новые контейнеры на нем не создаются.
Дополнительные требования к централизованной системе управления — настройка сети в контейнерах и управление квотами системных ресурсов (процессор, память, диск). А ведь эти все требования — это не что иное, как задачи, которые успешно решаются облаками ([IaaS](http://en.wikipedia.org/wiki/Cloud_computing#Infrastructure_as_a_service_.28IaaS.29)). Своевременно летом 2013 вышел [пост](https://blog.docker.com/2013/06/openstack-docker-manage-linux-containers-with-nova/) от разработчиков Docker об интеграции Docker с облачной платформой [OpenStack](http://www.openstack.org/). Новый [nova-docker](https://github.com/stackforge/nova-docker) драйвер позволяет с помощью openstack-облака управлять парком docker-хостов: запускать контейнеры, поднимать сеть, контролировать и балансировать потребление системных ресурсов — именно то, что нам нужно!
К сожалению, даже на сегодняшний день nova-docker драйвер все еще довольно «сырой». Часто появляются изменения, несовместимые даже с последней стабильной версией openstack’а. Приходится самостоятельно поддерживать отдельную стабильную ветку драйвера. Пришлось также написать несколько патчей, улучшающих производительность. К примеру, для получения статуса одного docker-контейнера драйвер запрашивал статусы всех запущенных контейнеров (посылал N http-запросов к docker-хосту, где N — число всех контейнеров). В случае запуска нескольких сотен контейнеров создавалась ненужная нагрузка на docker-хосты.
Несмотря на определенные неудобства, выбор OpenStack'а в качестве оркестратора контейнеров в моем случае все же того стоит: появилась централизованная система управления виртуальными машинами (контейнерами) и вычислительными ресурсами с единым [API](http://developer.openstack.org/api-ref.html). Большой бонус единого интерфейса заключается еще в том, что добавление в Root’n’Roll поддержки полноценных виртуальных машин на базе [KVM](http://www.linux-kvm.org/) не потребует никаких существенных изменений в архитектуре и коде самой платформы.
Из недостатков OpenStack можно отметить лишь довольно высокую сложность разворачивания и администрирования приватного облака. Совсем недавно заявил о себе достойный внимания проект [Virtkick](https://www.virtkick.io/) — этакая упрощенная альтернатива OpenStack. С нетерпением жду его успешного развития.
Выбор веб-терминала
===================
Еще на начальном этапе составления требований к платформе Root’n’Roll основной фичей, которую я хотел видеть в первую очередь, была возможность работы с удаленным linux-сервером через окно веб-терминала прямо у себя в браузере. Именно с выбора терминала и началась разработка, а точнее изучение и выбор технических решений для платформы. Веб-терминал является едва ли не единственной точкой входа пользователя во всю систему. Это именно то, что он в первую очередь видит и с чем работает.
Одним из немногих в то время онлайн-проектов, в которых активно использовался веб-терминал был [PythonAnywhere](https://www.pythonanywhere.com/). Он стал эталоном, на который я периодически посматривал. Это сейчас уже появилось огромное количество веб-проектов и облачных сред разработки, в которых можно увидеть терминалы: [Koding](https://koding.com/), [Nitrous](https://www.nitrous.io/), [Codebox](https://www.codebox.io/), [Runnable](http://runnable.com/) и др.
Любой веб-терминал состоит из двух основных частей:
* Клиентской: динамическое JavaScript приложение, занимающееся перехватом нажатий клавиш и отсылкой их серверной части, приемом данных от серверной части и их отрисовкой в веб-браузере пользователя.
* Серверной: веб-сервис, который принимает сообщения о нажатиях клавиш от клиента и отправляет их в управляющее терминальное устройство ([pseudo terminal](http://en.wikipedia.org/wiki/Pseudo_terminal) или PTY) связанного с терминалом процесса, например bash. Сырой вывод терминала из pty-устройства пересылается неизменным в клиентскую часть или обрабатывается на стороне сервера, в этом случае в клиентскую часть передается уже преобразованным, например, в формате HTML.
Было рассмотрено множество эмуляторов терминала: [Anyterm](http://anyterm.org/), [Ajaxterm](http://antony.lesuisse.org/software/ajaxterm/HEADER.html), [Shellinabox](https://code.google.com/p/shellinabox/) (используется в PythonAnywhere), [Secure Shell](https://chrome.google.com/webstore/detail/secure-shell/pnhechapfaindjhompbnflcldabbghjo), [GateOne](http://liftoffsoftware.com/Products/GateOne) и [tty.js](https://github.com/chjj/tty.js/). Последние два оказались наиболее функциональными и активно развивающимися. Из-за распространения под более свободной лицензией MIT выбор остановился на tty.js. Tty.js является client-side эмулятором терминала (разбор сырого вывода терминала, в том числе управляющих последовательностей, выполняется на клиенте с помощью JavaScript).
Серверная часть tty.js, написанная на Node.js, была беспощадно отломана и переписана на Python. Транспорт Socket.IO был заменен на SockJS, о подобном удачном опыте уже писали в [блоге](https://blog.pythonanywhere.com/27/) PythonAnywhere.
Полет «Светлячка»
=================
Наконец дошли до движка платформы Root’n’Roll. Проект построен по принципам [микросервисной архитектуры](http://martinfowler.com/articles/microservices.html). Основной язык разработки серверной части — Python.
Диаграмма связей сервисов платформы Root’n’Roll:
Микросервисы носят имена основных героев научно-фантастического телесериала «Светлячок» ([Firefly](http://en.wikipedia.org/wiki/Firefly_(TV_series))). Основные герои фильма — экипаж межпланетного космического корабля «Серенити» класса Светлячок. Назначение и место персонажа на корабле в некоторой степени отражает предназначение и функционал соответствующего его имени сервиса.
Mal – backend API
=================
Mal — владелец и капитан корабля. На нашем корабле Mal является ключевым сервисом, координирующим работу всех остальных сервисов. Это приложение на Django, которое реализует бизнес-логику платформы Root’n’Roll. Mal выполняет роль API-клиента приватного OpenStack-облака и в свою очередь предоставляет высокоуровневый REST интерфейс для выполнения следующих действий:
* Создание/удаление виртуальной машины (контейнера). Запрос преобразовывается и делегируется облаку.
* Создание и подключение терминала к контейнеру.
* Запуск тестового сценария для проверки конфигурации виртуальной машины. Запрос делегируется микросервису проверяющей системы.
* Получение результатов проверки конфигурации.
* Аутентификация клиентов и авторизация различных действий.
Kaylee – мультиплексор терминалов
=================================
Kaylee — механик корабля. Сервис Kaylee является двигателем процесса коммуникации веб-терминала с удаленной виртуальной машиной. Это асинхронный веб-сервер на Python и Tornado, реализующий серверную часть tty.js.
С одной стороны, клиентская часть tty.js (терминальное окно) устанавливает соединение с Kaylee по протоколу SockJS. С другой стороны, Kaylee устанавливает соединение с терминальным устройством виртуальной машины. В случае с docker-контейнерами соединение устанавливается по протоколу HTTPS с управляющим pty-устройством работающего в контейнере процесса, как правило, это процесс bash. После чего Kaylee выполняет простую функцию прокси-сервера между двумя установленными соединениями.
Для аутентификации клиента и получения данных о виртуальной машине Kaylee общается с Mal по REST API.
Zoe – check-система
===================
Zoe — помощник капитана на борту, во всем ему безоговорочно доверяет. Zoe является автоматической проверяющей системой, выполняющей тестирование конфигураций виртуальных машин. Сервис Zoe в виде celery-таски получает от Mal’а задание на запуск тестового сценария. По окончанию проверки сообщает по REST API обратно Mal’у результаты тестирования. Как правило, Zoe ошибок не прощает (многие участники курса по Linux на Stepic’е уже успели в этом убедиться).
Тестовый сценарий представляет из себя не что иное, как Python-скрипт с набором тестов, написанных с использованием фреймворка для тестирования [py.test](http://pytest.org/). Для py.test был разработан специальный плагин, который обрабатывает результаты запуска тестов и посылает их Mal'у по REST API.
Пример сценария для упражнения, в котором нужно написать и запустить простой одностраничный сайт на веб-фреймворке Django:
```
import re
import requests
def test_connection(s):
assert s.run('true').succeeded, "Could not connect to server"
def test_is_django_installed(s):
assert s.run('python -c "import django"').succeeded, "Django is not installed"
def test_is_project_created(s):
assert s.run('[ -x /home/quiz/llama/manage.py ]').succeeded, "Project is not created"
def test_hello_lama(s):
try:
r = requests.get("http://%s:8080/" % s.ip)
except:
assert False, "Service is not running"
if r.status_code != 200 or not re.match(".*Hello, lama.*", r.text):
assert False, "Incorrect response"
```
Для удаленного выполнения команд на тестируемой виртуальной машине Zoe использует библиотеку [Fabric](http://www.fabfile.org/).
Заключение
==========
Вскоре на платформе [Stepic](https://stepic.org/) любой желающий сможет создавать свои курсы и интерактивные упражнения по работе в Linux с использованием всех тех технологий, о которых я рассказал в статье.
В следующей статье я напишу о своем успешном участии в [JetBrains EdTech](http://jetbrains.timepad.ru/event/114248/) хакатоне, об особенностях и проблемах интеграции Root’n’Roll в Stepic и, по вашему желанию, раскрою глубже любую из затронутых тем. | https://habr.com/ru/post/246099/ | null | ru | null |
# Что Chrome сделал с JPEG XL и почему делать этого не стоило
Аргументы в защиту формата в лонгриде под катом — к [старту курса по Fullstack-разработке на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_111122&utm_term=lead).
[](https://habr.com/ru/company/skillfactory/blog/697756/)
Разработчики Chrome недавно анонсировали своё решение [о прекращении поддержки формата JPEG XL, который ранее был «убран за флажок»](https://bugs.chromium.org/p/chromium/issues/detail?id=1178058#c84). Это решение объясняется так:
* *Экспериментальные флаги и код не могут существовать неограниченный срок*
* *Сообщество в целом не проявило достаточного интереса, который оправдал бы продолжение экспериментов с JPEG XL*.
* *У нового формата изображений недостаточно дополнительных преимуществ по сравнению с существующими форматами, которые могли бы гарантировать его использование по умолчанию*
* *Удаление флага и кода в M110 снижает бремя обслуживания и позволит сосредоточить усилия на улучшении существующих в Chrome форматов.*
---
[](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_111122&utm_term=banner)
---
Первое утверждение звучит разумно, но многие ожидали, что вопрос разрешится *активацией* по умолчанию, а не полным *удалением* этого свойства. Это вовсе не оправдывает такие меры.
Вопрос ко второму утверждению: как измерялся интерес сообщества и измерялся ли он вообще? Поскольку свойство было закрыто за флагом, очевидно, что это блокировало любое физическое распространение — скрытые по умолчанию функции можно использовать для экспериментов, но не для широкого распространения. Поэтому они не могли собрать по этому вопросу никакой значимой статистики.
Основная часть стандарта JPEG XL (ISO/IEC 18181-1) опубликована в марте 2022 года, и с тех пор до момента написания этой статьи прошло около полугода. Часть, посвящённая описанию базовой реализации (ISO/IEC 18181-4), опубликована в августе 2022 года, приблизительно три месяца назад. На столь раннем этапе делать какие-либо выводы об «интересе сообщества» довольно преждевременно.
Однако если энтузиасты из [Adobe](https://bugs.chromium.org/p/chromium/issues/detail?id=1178058#c61), [Intel & VESA](https://bugs.chromium.org/p/chromium/issues/detail?id=1178058#c64), [Krita](https://bugs.chromium.org/p/chromium/issues/detail?id=1178058#c66), [libvips](https://bugs.chromium.org/p/chromium/issues/detail?id=1178058#c69), [Cloudinary](https://bugs.chromium.org/p/chromium/issues/detail?id=1178058#c70) и [Shopify](https://bugs.chromium.org/p/chromium/issues/detail?id=1178058#c79) поддержали Chromium в баг-трекере, то вывод о недостаточной заинтересованности сообщества кажется странным.
Так мы приходим к третьму и, возможно, самому интересному пункту: «*Имеет недостаточно дополнительных преимуществ по сравнению с существующими форматами*».
Конечно же, «недостаточность» — довольно размытый критерий. Порог «достаточности» нигде не описывается. Мы подробно рассмотрим преимущества, а вы уже сами рассудите, являются ли они «достаточными».
Относительно четвёртого пункта очевидно, что каждая новая строка кода создаёт «бремя обслуживания», но это достаточно общий аргумент, и он применим к любой новой функции. Но в данном конкретном случае это бремя, наверное, довольно скромное.
Фактическая реализация JPEG XL в Chrome основана на интеграции libjxl, которая сама по себе не поддерживается Chrome, хотя им приходится оценивать и, возможно, даже устранять — если разработчики libjxl не предоставят своевременный ответ — потенциальные ошибки безопасности, которые могут быть обнаружены в ней, как и в любой «сторонней» библиотеке, интегрированной в Chrome. Вся работа по интеграции уже проделана, включая работу, необходимую для предоставления альфа-прозрачности, анимации, управления цветом, включая расширенный динамический диапазон, и прогрессивное декодирование. Всё остальное «бремя», о котором идёт речь, по сути, сводится к периодическому повышению номера версии в сценарии сборки на случай, если появится новая версия libjxl, которая привнесёт полезные для Chrome улучшения. Команда Chrome не работала над улучшением libjxl в прошлом (и вряд ли будет это делать в будущем), поэтому неясно, как удаление флага связано с их способностью сосредоточить усилия на других вещах.
[Повторное сжатие JPEG без потерь](https://cloudinary.com/blog/the-case-for-jpeg-xl#lossless_jpeg_recompression)
----------------------------------------------------------------------------------------------------------------
Уникальной особенностью JPEG XL является возможность повторного сжатия существующих JPEG (которых существует **очень много**!) в файл JPEG XL, который в среднем на 20% меньше, без потерь. Фактически из файла JPEG XL можно восстановить точно такой же файл JPEG.
Такого свойства нет ни у одного другого формата изображений, то есть удовлетворительного решения для переноса изображений из JPEG у них просто нет: существующие файлы JPEG должны либо храниться в JPEG — с использованием нового форматов только для *новых* изображений, либо перекодироваться в новый формат. Однако перекодирование — операция довольно проблемная. В любом случае она добавляет потери и артефакты сжатия к файлу JPEG, который формировался уже с потерями. Перекодирование может быть даже контрпродуктивной: при выборе высокого качества можно свести к минимуму дополнительные потери, но итоговый файл может стать больше начального JPEG (то же произошло бы при конверсии из JPEG в PNG). Если же при перекодировке выбрано достаточно низкое качество, уменьшить размер файла удастся, но ценой внесения новых артефактов сжатия. Такое преобразование плохо поддаётся автоматизации с точки зрения описанных проблем.
[Прогрессивное декодирование](https://cloudinary.com/blog/the-case-for-jpeg-xl#progressive_decoding)
----------------------------------------------------------------------------------------------------
Старый формат JPEG поддерживает прогрессивное декодирование: после передачи всего 15% данных изображения возможен его предварительный просмотр в низком качестве, которое улучшается по мере получения данных. Это свойство появилось уже во времена «колёсного» интернета по телефонной линии, но осталось полезным и в наши дни, когда возросли не только скорость соединения, но и разрешение изображений и вариативность сетевых условий. При быстром кабельном соединении или 5G прогрессивное декодирование лишь создаёт ощущение загрузки «шустрее», а вот на более слабом 3G-соединении, которым все мы нередко пользуемся вне дома, разница состоит уже в том, увидите ли вы *что-то* или не увидите *ничего*.
Отчасти благодаря популярности MozJPEG в качестве JPEG-кодера «progressive JPEG» стал развиваться быстрее других форматов онлайн-изображений в минувшее десятилетие, если рассматривать его отдельно от базового последовательного режима JPEG.
Ни один из форматов изображений, возникших из видеоформатов (WebP, HEIC, AVIF) не поддерживает прогрессивное декодирование на уровне кодека, так как это свойство характерно именно для неподвижных изображений. В видеоформатах предварительный просмотр одного кадра малополезен — если не хватает пропускной способности для буферизации видеоданных на много кадров, воспроизвести видео бесполезно даже пытаться. Видеоформаты имеют собственные решения для работы с различными сетевыми условиями (например, HLS).
Чтобы преодолеть этот недостаток «новых» форматов изображений (WebP и AVIF), web-разработчики прибегают к различным уловкам для создания прогрессивной загрузки, например, используют [«заглушки» низкого качества](https://www.guypo.com/introducing-lqip-low-quality-image-placeholders).
Для сравнения: JPEG XL не только поддерживает прогрессивное декодирование, но и выходит за рамки возможностей старого JPEG, например, предоставляет [*прогрессирование по значимости (saliency-based progression)*](https://opensource.googleblog.com/2021/09/using-saliency-in-progressive-jpeg-xl-images.html). Это довольно интересно и полезно как для разработчика (отпадает необходимость в сложных «ритуалах с заглушками»), так и для конечного пользователя.
[Параметры сжатия без потерь](https://cloudinary.com/blog/the-case-for-jpeg-xl#lossless_compression_performance)
----------------------------------------------------------------------------------------------------------------
JPEG XL позволяет сжимать изображения без потерь лучше, чем это умеют существующие форматы (в частности PNG). Причём лучше по всем параметрам: он быстрее кодируется, создаёт меньшие по размеру файлы и даёт больше возможностей (например, CMYK, слои и 32-битные образцы с плавающей точкой). Поскольку это в основном относится к рабочим процессам авторов, а не к случаю передачи через сеть, я не буду останавливаться на этой теме слишком подробно, но это, конечно, довольно важное преимущество JPEG XL как формата в целом.
Но и для передачи через сеть сжатие без потерь во многом очень желательно. Для некоторых типов изображений (например, скриншотов или пиксельной графики) сжатие без потерь может, как это ни парадоксально, уменьшать размер файла сильнее, чем сжатие с потерями. PNG и WebP без потерь действительно имеют своё применение в сети — но не для фотографий, а для некоторых видов графики.
[Параметры сжатия с потерями](https://cloudinary.com/blog/the-case-for-jpeg-xl#lossy_compression_performance)
-------------------------------------------------------------------------------------------------------------
Качество такого сжатия — это, конечно, критический аспект любого формата изображения, используемого для передачи по сети.
Сложно ответить, насколько хорошо изображение сожмётся с потерями. В отличие от сжатия без потерь (когда можно просто посмотреть на размер файла), сжатие с потерями — это всегда компромисс между сжатием и качеством. С появлением последних, более сложных и многогранных кодеков к этому компромиссу следует добавить скорость кодирования — затрачивая больше времени на кодирование, можно получить лучший результат, но то, какое время кодирования будет приемлемым, зависит от конкретного применения: для изображения главного героя на целевой странице, которая получит миллионы просмотров, можно потратить несколько минут на кодирование, а вот для изображения в социальных сетях требования к задержке и затратам процессора будут гораздо более жёсткими.
Измерить степень сжатия (в битах на пиксель) и скорость кодирования (в мегапикселях в секунду) достаточно просто, ведь это лишь цифры. Однако измерить качество изображения значительно сложнее.
Есть два подхода к оценке качества изображения: субъективный эксперимент и объективные метрики. Субъективные эксперименты, при условии их правильного проведения, остаются единственным надёжным способом оценки качества изображения, но они требуют участия людей для оценки или сравнения изображений, поэтому это не самый удобный и дешёвый способ оценки работы кодеров изображений. По этой причине на практике часто используют объективные метрики: это алгоритмы, которые на входе получают исходное несжатое изображение и изображение со сжатием с потерями, а затем подсчитывают балл, который предположительно указывает на качество изображения.
«Объективные» метрики всегда следует воспринимать критически, ведь их связь с человеческим мнением не идеальна и даже может быть довольно низкой для ряда старых метрик. Метрика со временем становится не столь полезной, поскольку, когда она используется широко, кодеры стремятся «обмануть» её, а не повышать качество изображения. В качестве примера того, как метрики могут ошибаться, я сделал галерею изображений [«Зал позора»](https://jon-cld.s3.amazonaws.com/test/ahall_of_fshame_SSIMULACRA_2_modelD.html), показывающую три изображения в ряд (сжатое A, оригинал, сжатое B), где многие метрики (все, кроме [одной, которую я недавно разработал](https://github.com/cloudinary/ssimulacra2)) говорят, что изображение B справа обладает качеством выше, чем изображение A слева, хотя люди, оценивающие качество изображений, вероятнее всего, скажут обратное.
В Cloudinary мы недавно провели масштабный эксперимент по субъективной оценке изображений, в котором приняли участие более 40000 человек. Было проведено 1,4 миллиона оценок. В настоящее время мы всё ещё готовим публикацию о подробных результатах, но в качестве общего резюме: [в диапазоне качества, актуальном для интернета](https://discuss.httparchive.org/t/what-compression-ratio-ranges-are-used-for-lossy-formats/2464), JPEG XL позволяет получить на 10–15% лучшее сжатие, чем AVIF, при настройках скорости кодера, при том, что JPEG XL кодирует примерно в три раза быстрее, чем AVIF. Конечно, выигрыш в сжатии выше при сравнении с WebP (около 20–25%) и MozJPEG (около 30–35% — обратите внимание, что сам MozJPEG имеет на 10–15% лучшее сжатие в диапазоне качества для сети, чем типичные кодеры JPEG, такие как libjpeg-turbo или кодеры, используемые камерами).
На следующей диаграмме с обобщенными результатами по 250 изображениям показан рейтинг 10-го худшего перцентиля для каждой настройки кодирования — оценивать по наихудшим показателям, пожалуй, логичнее, чем по усреднённым.
Если рассматривать отдельные типы изображений, например фотопортреты, разрыв между JPEG XL и существующими форматами может быть ещё больше:
На уровне отдельных изображений есть случаи, когда разница между JPEG XL и следующим по качеству форматом достигает 30% и даже больше:
При оценке качества с помощью объективных метрик результат в значительной степени зависит от используемой метрики, настроек кодера и способа обобщения данных по нескольким изображениям. В настоящее время лучшими доступными метриками для оценки восприятия — в соответствии с результатами их статистической корреляции с субъективными результатами — являются [Butteraugli](https://jon-cld.s3.amazonaws.com/test/atradeoff-relative-Butteraugli_3-norm.html), [DSSIM](https://jon-cld.s3.amazonaws.com/test/atradeoff-relative-DSSIM.html) и [SSIMULACRA 2](https://jon-cld.s3.amazonaws.com/test/atradeoff-relative-SSIMULACRA_2_modelD.html). Они в основном согласуются друг с другом и с субъективными результатами: JPEG XL превосходит существующие форматы достаточно явно, с разницей в 10–15%. Кодерам AVIF требуется приблизительно в 100 раз больше времени для достижения сжатия, сопоставимого с JPEG XL; при более практичной скорости кодирования (скажем, в 2–3 раза медленнее, чем JPEG XL при усилиях по умолчанию) AVIF обеспечивает сжатие на 10–15% хуже, чем JPEG XL; при той же скорости кодирования AVIF не лучше или даже несколько хуже MozJPEG, в то время как JPEG XL лучше на 20–40%.
Можно ли назвать это «достаточными дополнительными преимуществами»? Здесь всё очень субъективно. На сколько процентов нужно улучшить сжатие, чтобы это оправдывало добавление нового формата в браузеры? С какого момента экономия на пропускной способности (а также хранении и стоимости процессора) начинает оправдывать увеличение двоичного файла, риска ошибок, а также бремени безопасности и обслуживания, вносимого дополнительным кодом? Это не тривиальное решение.
В любом случае, если рассматривать конкретно улучшение сжатия: с доступными в настоящее время кодерами — в случае JPEG XL и AVIF кодеры продолжают совершенствоваться, поэтому ситуация может измениться — и при разумных и более или менее сравнимых скоростях кодирования общее улучшение при переходе от (Moz)JPEG к WebP приблизительно такое же, как улучшение при переходе от WebP к AVIF, а улучшение при переходе от AVIF к JPEG XL больше этого и приблизительно сравнимо с улучшением при переходе от JPEG к AVIF.
[Развёртываемый кодер](https://cloudinary.com/blog/the-case-for-jpeg-xl#deployable_encoder)
-------------------------------------------------------------------------------------------
Эталонная реализация JPEG XL, libjxl, содержит кодер, который можно использовать как есть в производственных средах: он относительно быстр и даёт стабильное графическое качество при заданной точности. Понять и измерить скорость кодирования относительно просто, а вот «стабильность» (consistency) требует разъяснений.
Кодеры изображений (и видео) обычно можно настроить с помощью параметра «качество» (quality), например, по шкале от 0 до 100, который управляет точностью кодирования. Тем не менее одна из настроек качества, применяемая к разным изображениям, не обязательно приведёт к одинаковому качеству изображения. Хотя алгоритм кодека может выполнять аналогичные действия, реально воспринимаемое качество изображения зависит от характера конкретного изображения. Это явление — результат относительной нестабильности кодеков — является причиной, по которой [мы ввели метод автоматизированного выбора качества в Cloudinary](https://cloudinary.com/blog/introducing_smart_cropping_intelligent_quality_selection_and_automated_responsive_images) (`"q_auto"`) ещё в 2016 году.
Один из способов оценить стабильность кодера — сравнить средний показатель визуального результата при заданных настройках качества с наихудшим результатом — скажем, с оценкой в 1 или 10 перцентиле. В нашем теоретическом эксперименте мы оценили мнения о множестве разных изображений (225 фотографий и 25 образцов графики). Таким образом, можно посмотреть на разброс между наихудшим случаем и среднестатистической оценкой:
Например, чтобы достичь средней оценки качества изображения 60 (умеренно высокое качество/medium-high quality) в 99% случаев, при использовании JPEG XL необходимо использовать настройки, которые нацелены на значение чуть менее 70 (высокое качество/high quality), в то время как при использовании существующих форматов (JPEG, WebP, AVIF) необходимо нацелиться на значение 72 или более.
На практике это значит, что фактический результат сжатия JPEG XL выше, чем предполагаемое при рассмотрении средних показателей. Это объясняется тем, что настройки кодера обычно выбираются с таким расчётом, чтобы 99% (или даже 99,9%), а не 50% изображений имели приемлемое визуальное качество. Лучшее качество кодера подразумевает более прогнозируемые, надёжные результаты — поэтому нет причин «целиться слишком высоко», чтобы учесть вариации, которые зависят от характера изображения.
[Работа со всей последовательностью выполняемых действий](https://cloudinary.com/blog/the-case-for-jpeg-xl#works_across_the_workflow)
-------------------------------------------------------------------------------------------------------------------------------------
И последнее значимое преимущество JPEG XL — широкая сфера применения: формат отлично подходит для доставки по сети, но он разработан не только для этого. JPEG XL можно использовать как исходный формат захвата изображений, где он может играть роль, аналогичную современным raw-форматам для камер. Для этого у него есть всё: высокое разрешение, расширенный динамический диапазон, сжатие без потерь или с минимальными потерями. JPEG XL также мог бы сталь форматом для создания изображений благодаря поддержке слоёв с разными именами, масок выделения и множества альфа-каналов. Благодаря поддержке CMYK и специальных цветов формат во многих случаях можно использовать для печати. Его можно также использовать для медицинских и научных целей благодаря поддержке компрессии без потерь и с высоким разрешением и мультиспектрального отображения. И так далее. Таким образом, это универсальный формат, подходящий для самых разных задач по работе с цифровыми изображениями.
Разумеется, передача изображений через сеть всегда была основным вариантом применения при разработке JPEG XL. Но это был не единственный вариант. Мы не предполагали, что он будет использоваться только в сети — в отличие, например, от WebP, который, как видно из названия, разрабатывался *исключительно для сети*. WebP разрабатывался как специальный формат изображений специально для интернета, поэтому он имеет разные ограничения, например в отношении качества (принудительная субдискретизация цветности в ТВ-диапазоне 4:2:0, что не позволяет осуществлять сжатие с потерями с высокой точностью), размера изображения (не более 16383 пикселей в любом измерении, что подходит для интернета, но недостаточно для многих других вариантов применения), битовой глубины (только 8 бит) и цветового пространства (только RGB). Все эти ограничения разумны для сети, но не для формата изображений общего назначения.
JPEG XL — наш первый серьёзный кандидат на звание универсального формата изображений, который работает «со всей последовательностью выполняемых действий» от захвата и создания до обмена, архивирования и передачи. Веб-разработчиков это избавляет от многих проблем совместимости и преобразования при управлении цифровыми данными. Конечным пользователям это даёт возможность сохранять изображения с веб-страниц, которые могут «просто работать» в других приложениях за пределами браузера. Очевидно, что JPEG XL ещё не получил широкого распространения, но по крайней мере есть основания полагать, что он может получить распространение шире, чем форматы, которые ограничивают свою сферу применения только передачей по сети и не дают значительных преимуществ в других случаях.
[Заключение](https://cloudinary.com/blog/the-case-for-jpeg-xl#conclusion)
-------------------------------------------------------------------------
В прошлом появилось много «новых» форматов изображений. Одни характеристики в них были улучшены за счёт других. Например, PNG намного превосходит GIF, но не поддерживает анимацию. WebP показывает себя лучше JPEG при сжатии в диапазоне низкой и средней точности (low to medium fidelity), но достигается это ценой потери прогрессивного декодирования и кодирования 4:4:4 с высокой точностью (high fidelity). AVIF ещё больше увеличил качество сжатия, но ценой утраты прогрессивного декодирования и развёртываемых кодеров.
Мы рассмотрели 6 аспектов, в которых JPEG XL показывает себя значительно лучше других форматов:
* Повторное сжатие JPEG без потерь.
* Прогрессивное декодирование.
* Параметры сжатия без потерь.
* Параметры сжатия с потерями.
* Развёртываемый кодер.
* Работа со всей последовательностью выполняемых действий.
Насколько эти преимущества «достаточны», пусть каждый рассудит сам. На мой взгляд, уже одного из них было бы достаточно. Но самое главное — JPEG XL вносит эти дополнительные преимущества не в ущерб другим характеристикам, по крайней мере не в ущерб основным техническим преимуществам. Разумеется, с точки зрения совместимости и признания каждый формат должен пройти долгий путь, чтобы догнать JPEG и PNG, существующие дольше. Нам же остаётся лишь надеяться, что разработчики Chrome пересмотрят своё решение и помогут JPEG XL догнать старые форматы в плане программной поддержки, чтобы мы все могли снова порадоваться преимуществам этого формата.
Научим вас аккуратно работать с данными, чтобы вы прокачали карьеру и стали востребованным IT-специалистом. Новогодняя акция — скидки до 50% по промокоду **HABR**:
[](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_111122&utm_term=conc)
* [Профессия Fullstack-разработчик на Python (16 месяцев)](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_111122&utm_term=conc)
* [Профессия Data Scientist (24 месяца)](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_111122&utm_term=conc)
**Краткий каталог курсов**
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_111122&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_111122&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_111122&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_111122&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_111122&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_111122&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_111122&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_111122&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_111122&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_111122&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_111122&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_111122&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_111122&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_111122&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_111122&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_111122&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_111122&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_111122&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_111122&utm_term=cat)
* [Профессия «Белый хакер»](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_111122&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_111122&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_111122&utm_term=cat) | https://habr.com/ru/post/697756/ | null | ru | null |
# Тултипы на CSS3 и HTML5
В связи с тем, что на Хабрахабре не нашёл я описания данного простого и в то же время удобного способа создания простых «тултипов» — всплывающих подсказок, я решил о нём написать.
В данном методе не будет использоваться JS, мы довольствуемся лишь CSS3 и HTML5.
#### Дисклеймер
На самом деле, css attr() для свойства псевдоэлемента content появился в CSS2 и в данном способе, в общем-то, нет ничего нового.
#### Простой способ
Этот способ сгодится там, где нужны небольшие «тултипчики» — всплывающие подсказки.
Для начала покажу код:
```
Hover me!
```
```
.tooltip {
border-bottom: 1px dotted #0077AA;
cursor: help;
}
.tooltip::after {
background: rgba(0, 0, 0, 0.8);
border-radius: 8px 8px 8px 0px;
box-shadow: 1px 1px 10px rgba(0, 0, 0, 0.5);
color: #FFF;
content: attr(data-tooltip); /* Главная часть кода, определяющая содержимое всплывающей подсказки */
margin-top: -24px;
opacity: 0; /* Наш элемент прозрачен... */
padding: 3px 7px;
position: absolute;
visibility: hidden; /* ...и скрыт. */
transition: all 0.4s ease-in-out; /* Добавить плавности по вкусу */
}
.tooltip:hover::after {
opacity: 1; /* Показываем его */
visibility: visible;
}
```
Мы берём некий элемент (В нашем случае span), добавляем к нему атрибут с текстом, который будет показан и берём псевдоэлемент ::after. В content этого псевдоэлемента мы, пользуясь замечательнейшим свойством **attr()**, присваиваем нашей всплывающей подсказке текст и потом по :hover показываем его.
Думаю, остальные свойства понятны по комментариям в коде.
Отдельно хочу отметить, как ведёт себя анимация в Chrome и Opera (Возможно и в IE, за его отсутствием проверить я не имею никакой возможности).
Её нет. Связано это с тем, что WebKit и Opera не применяют transitions и animation к псевдоэлементам ::before и ::after.
По этому поводу в багтрекере WebKit зарегистрирован [баг](https://bugs.webkit.org/show_bug.cgi?id=68128).
#### Способ для более сложных тултипов
Иногда в тултипе должен быть не просто текст, но и некое форматирование или изображение, которое в предыдущий способ не вставишь.
Далее я рассмотрю лишь **пример** того, что можно сделать этим способом.
И снова код:
```
[qutIM
qutIM — Свободный многопротокольный клиент. Он портирован под множество операционных систем. ](http://habrahabr.ru/)
```
```
.htooltip span { /* Внешний вид нашего тултипа */
background-color: rgba(0,0,0, 0.8);
border-radius: 15px 15px 15px 0px;
box-shadow: 1px 1px 10px rgba(0, 0, 0, 0.5);
color: #fff;
margin-left: 2px;
margin-top: -75px;
opacity: 0; /* Делаем его прозрачным */
padding: 10px 10px 10px 40px;
position: absolute;
text-decoration: none;
visibility: hidden; /* И прячем */
width: 350px;
z-index: 10;
}
.htooltip:hover span { /* По hover отображаем тултип */
opacity: 1;
visibility: visible;
}
.htooltip span img { /* Изображение для примера */
border: 0 none;
float: left;
margin: -71px 0 0 -234px;
opacity: 0;
position: absolute;
visibility: hidden;
z-index: -1;
}
.htooltip:hover span img { /* Показываем изображение */
opacity: 1;
visibility: visible;
}
```
Всё просто. Данные примеры можно лицезреть на [этой](http://nico-izo.github.com/css-tooltips.html) страничке.
P.S. Некоторые спросят: А где же HTML5? В статье упомянуты data-\* атрибуты, являющиеся [частью](http://www.w3.org/TR/html5/elements.html#embedding-custom-non-visible-data-with-the-data-attributes) спецификации HTML5. | https://habr.com/ru/post/132283/ | null | ru | null |
# Как различать британскую и американскую литературу с помощью машинного обучения
Однажды мне стало интересно, отличается ли британская и американская литература с точки зрения выбора слов, и если отличается, удастся ли мне обучить классификатор, который бы различал литературные тексты с точки зрения частоты использованных слов. Различать тексты, написанные на разных языках, довольно легко, мощность пересечения множества слов небольшая относительно множества слов в выборке. Классификация текста по категориям «наука», «христианство», «компьютерная графика», «атеизм», — всем известный [hello world](http://scikit-learn.org/stable/tutorial/text_analytics/working_with_text_data.html) среди задач по работе с частотностью текста. Передо мной стояла более сложная задача, так как я сравнивала два диалекта одного языка, а тексты не имели общей смысловой направленности.
Самый долгий этап машинного обучения — это извлечение данных. Для обучающей выборки я использовала тексты с [Project Gutenberg](http://www.gutenberg.org), их можно свободно скачивать. Список американских и британских авторов я выкачала из википедии. Сложность заключалась в том, чтобы найти соответствие по имени автора. На сайте проекта реализован хороший поиск по именам, но парсить сайт запрещено, вместо этого предлагается использовать архив с метаданными. Это означало, что мне нужно решать нетривиальную задачу совпадения имен (Sir Arthur Ignatius Conan Doyle и Doyle, C. — одни и те же люди, а Doyle, M. E. уже нет) и делать это с очень высокой точностью. Вместо этого я, пожертвовав размером выборки в пользу точности и экономии своего времени, выбрала в качестве уникального идентификатора ссылку на википедию автора, которая была включена в некоторые файлы метаданных. Так я получила около 1600 британских текстов и 2500 американских и принялась обучать классификатор.
При всех операциях я использовала пакет sklearn. Первый шаг после сбора и анализа данных — это препроцессинг, для которого я взяла CountVectorizer. Он принимает на вход массив текстовых данных и возвращает вектор признаков. Далее требуется представить признаки в числовом формате, так как классификатор работает с числовыми данными. Для этого нужно вычислить tf-idf, [term frequency — inverted document frequency](https://ru.wikipedia.org/wiki/TF-IDF), используя TfidfTransformer.
Короткий пример о том, как это делается и зачем:
Возьмем слово “the” и посчитаем количество вхождений этого слова в тексте А. Пусть у нас будет 100 вхождений, а общее количество слов в документе 1000,
```
tf(“the”) = 100/1000 = 0.1
```
Далее возьмем слово “sepal” (чашелистик), которое встретилось 50 раз,
```
tf(“sepal”) = 50/1000 = 0.05
```
Чтобы посчитать inverted document frequency для этих слов, нужно взять логарифм от отношения количества текстов, в которых есть хоть одно вхождение этого слова, к общему количеству текстов. Если всего текстов 10000, и в каждом есть слово “the”,
```
idf(“the”) = log(10000/10000) = 0
```
```
tf-idf(“the”) = idf(“the”) * tf(“the”) = 0 * 0.1 = 0
```
Слово “sepal” гораздо более редкое, и встретилось только в 5 текстах, поэтому
```
idf(“sepal”) = log(10000/5) = 7.6
```
```
tf-idf(“sepal”) = 7.6 * 0.05 = 0.38
```
Таким образом, частые слова имеют минимальный вес, и специфичные редкие — большой, и по большому вхождению слова “sepal” в текст можно предположить, что он как-то связан с ботаникой.
Теперь, когда данные представлены как набор признаков, нужно обучить классификатор. Я работаю с текстом, который представлен как разреженные данные, поэтому оптимальным вариантом стал линейный классификатор, хорошо справляющийся с задачами классификации с большим количеством признаков. И CountVectorizer, и TF-IDFTransformer, и SGD я обучала с параметрами по умолчанию. Можно отдельно работать с каждым этапом, но удобнее использовать pipeline:
```
pipeline = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', SGDClassifier()),
])
```
Проанализировав график точности от размера выборки, я заметила сильные колебания точности даже на больших объемах выборки, что свидетельствовало о том, что классификатор очень сильно зависим от конкретной выборки, а значит мало эффективен, и требуются существенные улучшения. Получив список весов классификатора, я заметила часть проблемы: алгоритм переобучался на частых словах типа “of” и “he”, которые по сути являются шумом. Эта проблема легко решается удалением подобных слов из признаков, и задается параметром CountVectorizer stop\_words = 'english' или вашим собственным списком слов. Еще немного улучшило точность, удаление некоторых популярных общеупотребимых слов. Убрав стоп-слова, я получила улучшение точности до 0.85.
Далее я занялась настройкой параметров c помощью GridSearchCV. Этот способ выявляет лучшую комбинацию параметров для CountVectorizer, TfidfTransformer и SGDClassifier, поэтому это очень долгий процесс, у меня он считался около суток. В итоге получила такой pipeline:
```
pipeline = Pipeline([
('vect', CountVectorizer(stop_words = modifyStopWords(), ngram_range = (1, 1))),
('tfidf', TfidfTransformer(use_idf = True, norm = 'l2', smooth_idf = True)),
('clf', SGDClassifier(alpha=0.001, fit_intercept = True, n_iter = 10, penalty = 'l2', loss = 'epsilon_insensitive')),
])
```
Итоговая точность — 0.89.
Теперь самое интересное для меня: какие слова указывают на происхождение текста. Вот список слов, отсортированный по убыванию модуля веса в классификаторе:
**Американский текст**: dollars, new, york, girl, gray, american, carvel, color, city, ain, long, just, parlor, boston, honor, washington, home, labor, got, finally, maybe, hodder, forever, dorothy, dr
**Британский текст**: round, sir, lady, london, quite, mr, shall, lord, grey, dear, honour, having, philip, poor, pounds, scrooge, soames, things, sea, man, end, come, colour, illustration, english, learnt
Развлекаясь с классификатором, я получила самых «британских» авторов из числа американцев и самых «американских» британцев (изящный способ рассказать о том, как сильно может ошибаться мой классификатор):
**Cамые «британские» американцы:**
* Бёрнетт, Фрэнсис Элиза (родилась в Англии, в возрасте 17 лет переехала в США, поэтому отношу ее к американцам)
* Генри Джеймс (родился в США, в 33 года эмигрировал в Великобританию)
* Уистер, Оуэн
* Мэри Робертс Рейнхарт (как видим, называемая американской Агатой Кристи не без причины)
* Уильям Мак-Фи (как и Бёрнетт, переехал в США в юном возрасте)
**Cамые «американские» британцы:**
* Ридьярд Киплинг (прожил несколько лет в США, попал в список благодаря “American Notes”)
* Энтони Троллоп (опять же виноваты американские топонимы в его “North America”)
* Фредерик Марриет (возможно, одного бы названия “Narrative of the Travels and Adventures of Monsieur Violet in California, Sonara, and Western Texas” хватило бы, чтобы запутать классификатор)
* Арнольд Беннетт (спасибо его “Your United States: Impressions of a first visit”)
* Филлипс Оппенхейм
А также самых «британских» британцев и «американских» американцев (потому что классификатор все же хорош).
**Aмериканцы:**
* Франсис Хопкинсон Смит
* Гэмлин Гарленд
* Джордж Эйд
* Чарльз Дадли Уорнер
* Марк Твен
**Британцы:**
* Джордж Мередит
* Сэмюэл Ричардсон
* Джон Голсуорси
* Гилберт Кит Честертон
* Энтони Троллоп
На попытку сделать такой классификатор меня подтолкнул [твит](https://twitter.com/TragicAllyHere/status/779403865099599872?ref_src=twsrc%5Etfw) @TragicAllyHere:
> I would love to be British. Drinking my leaf water and staring at a huge clock from my red phone booth, adding extra letters to wourds.
Код можно взять [здесь](https://github.com/SonechkaGodovykh/BritishAmericanClassifier), там же доступен уже обученный классификатор. | https://habr.com/ru/post/319826/ | null | ru | null |
# Touchscreen от Nintendo DS и Arduino
Внезапно заказал себе [маленький тачскринчик от Nintendo DS](http://www.dealextreme.com/details.dx/sku.3245~r.87955465) и захотелось его подключить к Arduino, о том что же получилось…
#### Проблема
Первая же проблема — как подключить, так как разъема нет, выковырять такой неоткуда, а покупать дорого (около 4-5$, при цене экрана 2-3$). Итак, берем скальпель, лезвие или маленькие ножнички и аккуратно режем шлейф вдоль, после чего довольно легко можно подпаять проводки, главное изолировать их, например сделав так:
#### Подключение и программирование
Вольный перевод с [форума Arduino](http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1243499684):
Смотрим на экран так, чтобы шлейф был снизу справа, тогда контакты идут в следующем порядке:
`TOP | LEFT | BOTTOM | RIGHT`
##### Подсоединяем к Arduino
`LEFT к цифровому выходу 2
BOTTOM к цифровому выходу 3
RIGHT к цифровому выходу 4
TOP к цифровому выходу 5`
а так же подсоединяем 2 проводка к аналоговым входам:
`TOP к аналоговому входу 3 (проводок от цифрового 5)
RIGHT к аналоговому входу 4 (проводок от цифрового 4)`
##### Скетч
Модифицированный код от [Robin Whitfield и Marco Nicolato (код самого тачскрина)](http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1243499684)
`#define Lo 2 // LEFT к цифровому выходу 2
#define Bo 3 // BOTTOM к цифровому выходу 3
#define Ro 4 // RIGHT к цифровому выходу 4
#define To 5 // TOP к цифровому выходу 5
#define Ti 3 // TOP к аналоговому входу 3 (проводок от цифрового 5)
#define Ri 4 // RIGHT к аналоговому входу 4 (проводок от цифрового 4)
// установим координаты прикосновения
int touchX = 0;
int touchY = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
if (touched()) {
// выводим координаты в порт/консоль
Serial.print(touchX);
Serial.print(",");
Serial.print(touchY);
Serial.println();
delay(100);
}
}
boolean touched() {
boolean touch = false;
pinMode(Lo, OUTPUT);
digitalWrite(Lo, LOW);
pinMode(Ro, OUTPUT);
digitalWrite(Ro, HIGH);
pinMode(To, INPUT);
pinMode(Bo, INPUT);
delay(10);
touchX = analogRead(Ti);
pinMode(Bo, OUTPUT);
digitalWrite(Bo, LOW);
pinMode(To, OUTPUT);
digitalWrite(To, HIGH);
pinMode(Ro, INPUT);
pinMode(Lo, INPUT);
delay(10);
touchY = analogRead(Ri);
if(touchX < 1000 and touchX > 0 and touchY < 1000 and touchY > 0)
touch = true;
return touch;
}`
#### Итог
В итоге после запуска в консоль/терминал/ваш\_обработчик вываливаются координаты точки нажатия, погрешность +-2 точки, по обоим осям значение от 100 до 900, но видимо зависит от модельки экрана, на форумах пишут и от 0 до 1000, и от 200 до 500
UPD: [tronixstuff.wordpress.com/2010/12/29/tutorial-arduino-and-the-ds-touch-screen](http://tronixstuff.wordpress.com/2010/12/29/tutorial-arduino-and-the-ds-touch-screen/) — еще более простой вариант подключения | https://habr.com/ru/post/108972/ | null | ru | null |
# Выкладка нетрадиционной ориентации
Все, кому приходится иметь дело с вёрсткой, знают что гриды и flexbox давно захватили CSS, позволяют очень удобно организовать классическую выкладку хедер-контент-сайдбар-футер, списки карточек, masonry и так далее. Но их настоящая крутизна не в удобстве использования, а в бескрайних возможностях, которые они открывают. Я покажу и объясню мой любимый трюк, который позволяет верстать за рамками привычной вертикально-горизонтальной прямоугольной сетки, и выглядит это очень круто.
Разминка
--------
На закуску разберём пример с КДПВ. Сетка на нём всё же прямоугольная, но очевидно, что поворотом на 45 градусов такого эффекта не добиться. Вот рабочий пример:
Разберём его строение. Структура HTML не содержит подвохов:
```
* 
* 
```
В CSS же мы обнаружим, что каждый ромб занимает две столбца сетки, а всего столбцов используется 2n+1, где n — число ромбов:
```
/*
Сначала задаётся дефолтное значение для самых узких экранов
3 столбца = 1 ромб в строке
*/
:root {
--columns: 3;
}
/*
Благодаря значению span 2 каждый ромб занимает два столбца
в ширину, но не в высоту.
*/
li {
grid-column-end: span 2;
}
/*
Медиа-запрос для 4 ромбов в строке определяет уже 9 столбцов
*/
@media (min-width: 1200px) {
:root {
--columns: 9;
}
}
```
Теперь понятно, что имея в запасе лишнюю «половинку» в каждой строке, мы можем сдвигать чётные строки на половину ширины ромба, чтобы получить шахматный порядок:
```
/* Двигаем каждый второй элемент при одном столбце */
li:nth-child(2n) {
grid-column-start: 2;
}
/* В других случаях подсчёт тоже простой */
@media (min-width: 1200px) {
li:nth-child(6n-2) {
grid-column-start: auto;
}
li:nth-child(8n-3) {
grid-column-start: 2;
}
}
```
Таким образом, мы получаем следующую картинку (пунктиром выделены границы строк и столбцов сетки):
Нам осталось только «склеить» строки, избавившись от пустого места между ними, для этого подойдёт простой советский `margin-top: -50%`. Загадка выкладки на этом заканчивается, а если вам интересно, как обложки книги выныривают из ромбов, то пожалуйста — наглядный пример:
Здесь используются `li:before` и `li:after`, форма достигается с помощью clip-path, а полосатая раскраска — с помощью крутого трюка с двойным применением бэкграунда:
```
background-size: 50% 100%;
background-position: left, right;
background-image: linear-gradient(45deg, var(--pink) 40%, var(--green) 40%),
linear-gradient(-45deg, var(--pink) 40%, var(--green) 40%);
```
Посмотреть на эту фишку и многие другие безумные трюки можно на [A Single Div](https://a.singlediv.com/) ([репо](https://github.com/lynnandtonic/a-single-div)).
Гексагональные миры
-------------------
Этот заголовок — подкол в сторону недавней статьи [про шестиугольные поля в играх](https://habr.com/ru/post/557496/). Статья классная, но если представить себе перенос тех схем в CSS, станет страшно и захочется плакать:
Плакать мы не будем, лучше сделаем выводы из предыдущего примера и попробуем сделать сетку из шестиугольников по-умному. Во время реализации мы задействуем сразу несколько трюков, поэтому этот способ красив не только снаружи, но и изнутри. Зацените рабочий пример и начнём:
Структура HTML почти не изменилась:
```
```
Задавать форму шестиугольников будем через clip-path:
Исходные стили у нас простые:
```
.main {
display: flex;
--s: 100px; /* size */
--m: 4px; /* margin */
}
.container {
font-size: 0; /* убирает пробелы между элементами inline-block */
}
.container div {
width: var(--s);
margin: var(--m);
height: calc(var(--s) * 1.1547);
display: inline-block;
font-size: initial; /* we reset the font-size if we want to add some content */
clip-path: polygon(0% 25%, 0% 75%, 50% 100%, 100% 75%, 100% 25%, 50% 0%);
}
```
Для выкладки мы используем inline-block, в котором, чтобы избежать лишних пробелов, используем трюк с `font-size: 0`. Отступы между элементами контролирует переменная --m (от margin). Теперь добавим отрицательный отступ, чтобы элементы приняли нужную высоту:
```
.container div {
...
margin-bottom: calc(var(--m) - var(--s) * 0.2886);
}
```
Элементы выстраиваются в обычную сетку и накладываются друг на друга, пора заняться смещением. Слева мы разместим `container::before` с высотой контейнера и шириной половины элемента плюс отступа:
Теперь прибегнем к крутейшему свойству shape-outside, которое позволяет тексту обтекать произвольные формы (а не только прямоугольные по модели margin-box). Крутизна в том, что это работает не только с текстом, но и с любыми inline-элементами. Чтобы создать нужную нам форму обтекания (не затрагивает нечётные ряды, чётные сдвигает на определённое расстояние), воспользуемся второй мощной фишкой — shape-outside принимает градиенты, что позволяет создать повторяющийся паттерн:
```
shape-outside: repeating-linear-gradient(#0000 0 A, #000 0 B);
```
Осталось определить A и B. B будет равняться высоте двух рядов, потому что нам нужно, чтобы паттерн повторялся каждые два ряда, это аналогично высоте двух шестиугольников с отступами, минус удвоенная высота их пересечения:
```
calc(1.732 * var(--s) + 4 * var(--m))
```
Запишем это выражение в новую переменную --f. По сути, A равно B, только нам нужно вычесть несколько пикселей, чтобы появилось несколько прозрачных пикселей, которые и сдвинут весь ряд направо. В итоге получаем:
```
shape-outside: repeating-linear-gradient(#0000 0 calc(var(--f) - 3px),#000 0 var(--f));
```
Круто? Круто. Подведём итог:
```
.main {
display:flex;
--s: 100px; /* size */
--m: 4px; /* margin */
/* Дополнительно вычитаем 1px, чтобы сгладить ошибки округления */
--f: calc(var(--s) * 1.732 + 4 * var(--m) - 1px);
}
.container {
font-size: 0; /* disable white space between inline block element */
}
.container div {
width: var(--s);
margin: var(--m);
height: calc(var(--s) * 1.1547);
display: inline-block;
font-size:initial;
clip-path: polygon(0% 25%, 0% 75%, 50% 100%, 100% 75%, 100% 25%, 50% 0%);
margin-bottom: calc(var(--m) - var(--s) * 0.2885);
}
.container::before {
content: "";
width: calc(var(--s) / 2 + var(--m));
float: left;
height: 120%;
shape-outside: repeating-linear-gradient(#0000 0 calc(var(--f) - 3px), #000 0 var(--f));
}
```
Немного CSS-магии, и мы получаем рабочую, адаптивную **шестиугольную** выкладку! Вообще CSS всех бесит, но иногда он бывает удивительно красив.
---
#### На правах рекламы
**Эпичные серверы** — это [VDS для размещения сайтов](https://vdsina.ru/cloud-servers?partner=habr421) от маленького интернет-магазина на Opencart до серьёзных проектов с огромной аудиторией. Создавайте собственные конфигурации серверов в пару кликов!
Присоединяйтесь к [нашему чату в Telegram](https://t.me/vdsina).
[](https://vdsina.ru/cloud-servers?partner=habr421) | https://habr.com/ru/post/561486/ | null | ru | null |
# BonBon — Sweet CSS3 Buttons
Привет, всем!
:before
=======
Пытливость ума (да и не только) заставляет искать новые и лучшее решения в том или ином направлении. Это и привело меня на страницы блога некого [@simurai](http://simurai.com/). Возможно, кто-то уже знаком с наработками товарища «[Самурая](http://lab.simurai.com/)», с остальными же хочу просто поделиться интересными идеями [псевдо-японского](http://simurai.com/about) гуру. В этой статье хочу рассмотреть один из его проектов: [BonBon — Sweet CSS3 Buttons](http://lab.simurai.com/buttons/) (по желанию читателей, другие работы автора будут преданы вниманию в последующих статьях). Начальная цель: создание CSS-кнопок, которые приятно смотрятся, имеют гибкую настройку, и в это же время будут иметь максимально простую разметку.
Разметка:
---------
Автор старался вложить в идею максимальную простоту в использовании, без «многабукав»; элементарный пример финальной реализации ([Demo](http://lab.simurai.com/buttons/#markup)):
```
[Label](#)
```
Также Вы можете изменить внешний вид за счет добавления к кнопке парочки классов, например: оранжевую окраску и глянцевый блеск ([Demo](http://lab.simurai.com/buttons/#markup)):
```
[Label](#)
```
Иконки:
-------
Если вы хотите добавить иконку, для большей ассоциативности веб-элемента, вы можете использовать HTML5-атрибут, наподобие этого: data-icon=«S». Это позволяет использовать [Unicode-символы](http://panmental.de/symbols/info.htm), [иконочные шрифты](http://fontello.com/) и многие др.
```
.button:before {
content: attr(data-icon);
}
```
Данный CSS-код добавляет иконку перед содержимым кнопки, что позволяет сохранить семантическую разметку и изменять иконки, без редактирования CSS-стилей ([Demo](http://lab.simurai.com/buttons/#icons)):
```
Label
```
Доступность:
------------
Если добавить к нашим кнопкам атрибут role=”button” и использовать TabIndex, мы можем делать их активными и выделять поочередно. Или же — если вы используете тег ````
, вы можете применять атрибут "disabled" для блокирования кнопки от нажатий (Demo).
Внешний вид:
------------
Автор пытался избежать использования каких-либо изображений при верстке, но как он сам пишет - «не удержался» и добавил PNG-картинку - для шума. Остальное же все - представляет собой сочетание элементов CSS3: **text-shadows**, **box-shadows**, **gradients** и **borders**. Это позволяет легко изменять размеры кнопок, сохраняя их начальный вид, пропорции и четкость, при этом не теряя возможности изменять их форму: **morphing** (Demo).
Border-radius – не всегда должен быть круглым, мы его может выгнуть в более овальную форму, используя дополнительный набор точек, прописывая его через "/"
border-radius: 5em / 2em;
border-radius: .4em .4em 2em 2em / .4em .4em 3em 3em;
```
Я пытался имитировать различные материалы: "**матовые**", "**глянцевые**" и "**стекло**". Результаты вы можете оценить сами ([Demo](http://lab.simurai.com/buttons/#material)):
Глянцевая форма создается с помощью селектора **:after** с градиентом фона на вершине
Ради фокуса, можно попробовать применить HTML5-атрибут **contenteditable="true"**, в результате чего получаем забавную редактируемую кнопку ([Demo](http://lab.simurai.com/buttons/#material)):
Гибкость:
---------
Все выше описанные эксперименты, можно представить в виде такого вот "мануального" списка (здесь все дополнительные имена классов, с которыми вы можете поиграть самостоятельно, использую Firebug или другую оснастку):
* Color: **orange**, **pink**, **blue**, **green**, **transparent**
* Font: **serif**
* Material: **glossy**, **glass**
* Size: **xs**, **xl**
* Shape: **round**, **oval**, **brackets**, **skew**, **back**, **knife**, **shield**, **drop**, **morph**
* Icon only: **icon**
* Disabled: **disabled**
:after
======
> Данный материал - это всего лишь демо-версия, которая не предназначена для использования на рабочих проектах. Не все браузеры поддерживают данное решение. Целью разработки было - показать пару методов по использованию некоторые из новых функций CSS3/HTML5
**(c) simurai**
**Demo**: [lab.simurai.com/buttons/](http://lab.simurai.com/buttons/)
**Source**: [github.com/simurai](https://github.com/simurai/lab/tree/gh-pages/buttons)
Как итог предлагаю обсудить концепт в принципе: предложения по улучшению, замечания по недостаткам, конструктивная критика (без "а чем bootstrap не угодил ....").
Также, прошу голосовать... Спасибо.` | https://habr.com/ru/post/168117/ | null | ru | null |
# Разработчик в стране Serverless: готовим чемоданчик serverless разработчика (Часть 5 Заключительная)
В предыдущих частях я сделал приложения, которое работает с БД, GitHub API. Все компоненты разворачиваются при помощи AWS SAM. Можно запускать реализованные функции локально. Все функции собраны воедино в одно API:
* [Первые шаги. Первая лямбда (Часть 1)](https://habr.com/ru/company/lineate/blog/655523/)
* [Разворачиваем БД (Часть 2)](https://habr.com/ru/company/lineate/blog/656695/)
* [Как подружиться с БД (Часть 3)](https://habr.com/ru/company/lineate/blog/657171/)
* [Создаем REST API (Часть 4)](https://habr.com/ru/company/lineate/blog/659579/)
В этой, последней части, я рассмотрю вопросы, без ответов на которые опытная эксплуатация вряд ли будет похожа на прогулку в парке.
Уже изучено достаточно много, чтобы начинать собирать свой чемоданчик must have инструментов для serverless разработки. В этой части я соберу свой чемоданчик, а вы оставляйте в комментариях свои, будет интересно.
На основании предыдущих частей первым и одним из самых значимых инструментов в моем чемоданчике будет SAM framework. Этот инструмент позволил мне все вышеперечисленное построить, благодаря ему мое приложение успешно запускается как в облаке, так и локально.
Реализация CI/CD
----------------
Для развертывания приложения используются команды **sam build** и **sam deploy**. В каждом приложение должна быть возможность автоматически развернуть новый (по коммиту или по требованию).
Я хочу реализовать полноценный CI/CD pipeline для моего приложения на базе Jenkins CI. Не так давно компания AWS добавила в SAM framework ряд команд, призванных облегчить задачу организации полноценного CI/CD подхода - речь о командах:
```
sam pipeline bootstrap
sam pipeline init
```
Данные команды упрощают создание CI/CD pipeline-файлов для ряда популярных CI/CD-инструментов.
Команда **sam pipeline bootstrap** используется, чтобы подготовить необходимые для работы CI/CD ресурсы в AWS, то есть это подготовительная команда, которая в интерактивном режиме запросит ряд данных(количество стадий, AWS-аккаунты и т.д.) и на их основе создаст необходимые ресурсы в AWS. В качестве результата работы данной команды в AWS-аккаунте будет развернут Cloud Formation стек, который создаст необходимые для полноценного pipeline ресурсы: IAM роли/политики, S3-бакет.
В свою очередь, команда **sam pipeline init** используется для создания непосредственно конфигурационного pipeline-файла в формате используемого вами CI/CD-сервиса, то есть данная команда - на основе уже созданных ресурсов для развертывания и в зависимости от выбранного из поддерживаемого списка CI/CD-сервиса - сгенерирует соответствующий pipeline-файл.
На данный момент поддерживаются следующие сервисы:
* Jenkins
* GitLab CI/CD
* GitHub Actions
* Bitbucket Pipelines
* AWS CodePipeline
Результатом работы данной команды будет конфигурационный pipeline-файл для выбранного CI/CD-инструмента. Ниже фрагмент кода для Jenkins CI:
```
...
stage('deploy-prod') {
when {
branch env.MAIN_BRANCH
}
agent {
docker {
image 'public.ecr.aws/sam/build-provided'
}
}
steps {
withAWS(
credentials: env.PIPELINE_USER_CREDENTIAL_ID,
region: env.PROD_REGION,
role: env.PROD_PIPELINE_EXECUTION_ROLE,
roleSessionName: 'prod-deployment') {
sh '''
cd global-resources/
sam deploy --stack-name ${PROD_STACK_NAME} \
--template template.yaml \
--capabilities CAPABILITY_IAM \
--region ${PROD_REGION} \
--s3-bucket ${PROD_ARTIFACTS_BUCKET} \
--no-fail-on-empty-changeset \
--role-arn ${PROD_CLOUDFORMATION_EXECUTION_ROLE}
'''
}
}
}
...
```
В данном случае можно заметить, что фактически в созданном pipeline-файле используются обычные shell-команды, доступные при установке утилит SAM cli, то есть ничего не мешает самостоятельно сделать конфигурационный pipeline-файл, используя команды **sam build** и **sam deploy**. Для того, чтобы вышеприведенный вариант корректно работал, нужен Jenkins плагин [*Pipeline: AWS Steps*](https://www.jenkins.io/doc/pipeline/steps/pipeline-aws/).
Запуск команды происходит в докер инстансе, который содержит все необходимые для сборки и развертывания приложения компоненты. Код в блоке *withAWS* выполняется в контексте указанного AWS профиля, с соответствующими правами. Переменная *MAIN\_BRANCH*, как несложно догадаться, определяет основную ветку репозитория и в данном случае стадия *deploy-prod* будет запущена, только если используется основная ветка.
Таким образом, команда **sam pipeline** позволяет достаточно быстро развернуть первую версию CI/CD pipeline для serverless приложения. Этот инструмент пригодится для быстрого старта или для создания прототипов и отлично впишется в мой вышеупомянутый чемоданчик.
Настройка CPU и размера диска
-----------------------------
У меня уже есть 4 функции. Работая с лямбда функциями, я напрямую не работаю с инфраструктурой. Если бы это были EC2 инстансы, то я бы мог выбрать размер диска, тип инстанса (который бы влиял непосредственно на производительность виртуальных ядер и объем доступной оперативной памяти). А что есть у лямбда функций? Что делать, если моя лямбда умеет эффективно использовать потоки, как мне использовать более продвинутые виртуальные ядра?
В AWS есть только одна настройка, которая может влиять на производительность окружения лямбда функции - MemorySize (В [прошлой части](https://habr.com/ru/company/lineate/blog/659579) я добавил настройку выделять разное количество памяти для разных окружений). С одной стороны, все сильно упрощается, с другой стороны, существует прямая и неочевидная зависимость CPU от объема оперативной памяти.
На момент написания данной статьи максимальное количество памяти для функции - 10ГБ, минимальное - 128 МБ. За каждые 1769МБ AWS к окружению “добавляет” 1 vCPU. Таким образом, я могу иметь от 1 до 6 виртуальных ядер. Производительность ядра также зависит от объема памяти, так, 1 ядро окружения со 128 МБ памяти в 2 раза “слабее” 1 ядра окружения с 256 МБ памяти.
С увеличением памяти лямбда ускоряется, но увеличивается и плата за работу. Найти золотую середину поможет инструмент [AWS Lambda Power Tuning](https://github.com/alexcasalboni/aws-lambda-power-tuning). Эта утилита запускает лямбда функцию в разных конфигурациях, замеряет время и стоимость работы и показывает это на графике.
Если в приложении обрабатывается достаточно много запросов, то этот инструмент позволит определить оптимальную конфигурацию лямбда функции, которая бы выдавала приемлемую производительность при минимальной стоимости. Этот инструмент однозначно следует взять в свой чемоданчик.
Помимо оперативной памяти можно настраивать объем /tmp директории, которая доступна функции. Настройка осуществляется при помощи свойства EphemeralStorage. Минимальный размер (и по умолчанию) 512 МБ, максимальный размер - 10 ГБ.
Настройка логов
---------------
Предположим, произойдет ошибка. Как о ней узнать? Где можно найти причины? В классическом приложении у меня есть логи. Логи отображаются в каком-то сервисе (например в kibana), где можно фильтровать результаты, искать по ключевым словам.
Пришло время разобраться с логами в моем приложении. У меня есть лямбда функции, которые содержат бизнес логику приложения, есть ApiGateway, принимающий запросы. Нужны способы работы с логами этих компонентов.
### Логи лямбда функций
Начнем с функций. В AWS есть сервис [Cloudwatch Logs](https://aws.amazon.com/ru/cloudwatch/), который используется для хранения и анализа логов приложений. Для каждой лямбда функции SAM создает отдельную лог группу в этом сервисе. Каждая лог группа состоит из нескольких log stream. Каждый такой поток относится к одному экземпляру лямбда функции. Все данные из stdout и stderr попадают туда. Если зайти в AWS Console в Cloudwatch сервис, то мои логи там выглядят так:
Первое, что можно заметить: в логах содержатся записи, начинающиеся со START, END, REPORT. Эти вспомогательные записи, создаваемые AWS, дают представление о том, когда лямбда начала выполнять запрос, когда закончила и результирующие метрики — время выполнения, оплачиваемое время, используемый объем памяти, выделенная память и т.д.
Второе, на что стоит обратить внимание: у каждого запроса есть свой уникальный RequestId. Благодаря ему я могу найти все логи для определенного запроса, посмотреть всю цепочку выполнения.
Пользоваться просмотром стримов в лог группе неудобно. За день может быть создано и убито несколько десятков экземпляров функций, искать ошибки в таком случае очень трудоемко. На помощь приходит другой инструмент в том же сервисе — Logs Insights. Он инструмент позволяет искать логи сразу по всем потокам разных лог групп с фильтрацией и сортировкой. Язык запросов, конечно, потребует некоторого привыкания, не один раз придется заглянуть в документацию, но ситуацию немного облегчает автодополнение.
Попробую отфильтровать все логи с уровнем INFO. Оказывается, в лог записи нет никакого поля, по которому я могу отфильтровать такие логи. Логи не структурированы и представляют собой просто текстовую строку. Строка INFO находится в поле @message:
```
fields @timestamp, @message
| filter @message like 'INFO'
| sort @timestamp desc
| limit 100
```
Logs Insights гораздо удобнее в работе, чем возможность просматривать “сырые” лог записи. Да, по функционалу он проигрывает Kibana и ElasticSearch. Но минимального набора вполне хватит, чтобы исследовать проблемы и находить решения. Для тех случаев, где требуется более продвинутый язык запросов, можно поднять ELK в облаке и пересылать логи от функций туда.
Logs Insights или его аналог должен быть в арсенале любого serverless разработчика. Если требуются логи только определенной функции, то в этом также может помочь sam. Команда sam logs позволяет получить логи конкретной лямбда функции. Есть возможность фильтровать записи по дате и тексту:
```
D:\serverless-bugtracker> sam logs -n GetProjectByIdFunction --stack-name serverless-bugtracker-ch5 -s '10days ago'
```
Можно настроить непрерывное получение логов:
```
D:\serverless-bugtracker> sam logs -n GetProjectByIdFunction --stack-name serverless-bugtracker-ch5 --tail
```
Неструктурированные логи неудобны в работе, сложно делать фильтрацию. Например, я бы хотел иметь возможность искать все логи, относящиеся в определенному projectId. В текущей реализации сделать это будет затруднительно.
С Cloudwatch структурированные логи можно реализовать на уровне кода. Если в console.log() передать объект, то AWS автоматически разобьет этот объект на части и позволит осуществлять поиск по полям этого объекта. Если не хочется делать самостоятельно такие костыли (каждую строку оборачивать в объект с полем), то можно использовать специальные библиотеки для логов.
Например, есть *winston-cloudwatch*, но там используется Cloudwatch API для публикации логов с любых внешних ресурсов. Придется явно задавать имя лог группы, настраивать параметры AWS аккаунта. Вариант отпадает, не мой случай.
В идеале нужна просто обертка вокруг console.log (info,warn, error), которая поможет завернуть текст и теги в объекты. С этой ролью отлично, к примеру, справляется библиотека *lambda-log*, никаких настроек аккаунтов, просто удобная обертка для вывода логов в консоль, логи на выходе получаются структурированные. Также эта библиотека позволяет работать с контекстом лог записей:
```
const log = require('lambda-log');
exports.lambdaHandler = async (event, context) => {
const projectId = event.pathParameters.projectId;
log.options.tags.push(projectId);
log.info("Incoming event", event);
//code here...
};
```
В логах будет следующий объект:
```
{
"_logLevel": "info",
"msg": "Incoming event",
"body": null,
"headers": {
...
},
"httpMethod": "GET",
"isBase64Encoded": false,
"multiValueHeaders": {
...
},
"multiValueQueryStringParameters": null,
"path": "/projects/1",
"pathParameters": {
"projectId": "1"
},
"queryStringParameters": null,
"requestContext": {
...
},
"resource": "/projects/{projectId}",
"stageVariables": null,
"version": "1.0",
"_tags": ["1"]
}
```
Мой идентификатор проекта попал в секцию tags, теперь я смогу искать по этому полю в Cloudwatch. В будущем, если в тегах будет храниться множество данных, то можно каждое значение оснастить префиксом.
### Логи в ApiGateway
Иногда бывают ситуации, когда запросы не доходят до функций. В такой ситуации помогут логи, настроенные в ApiGateway.
В ApiGateway есть 2 типа логов:
* execution логи;
* access логи.
В первом типе логов можно найти информацию о запросе/ответе, о том, какие способы аутентификации используются. Эти логи получаются очень объемными, на один запрос я могу получить 10 строк ответа. Но это может быть полезным для глубоких исследований каких-то проблем, потому что дает информацию о том, как запрос обрабатывается в самом сервисе.
Включить execution логи можно следующим образом:
```
# template.yaml
BugTrackerApi:
Type: AWS::Serverless::Api
Properties:
MethodSettings:
- LoggingLevel: INFO
ResourcePath: '/*' # allows for logging on any resource
DataTraceEnabled: false #true if request/response needs
HttpMethod: '*' # allows for logging on any method
```
AWS для каждого ApiGateway автоматически создает отдельную лог группу для execution логов. Пример логов для одного запроса:
Мне хватит просто одной строки, которая содержит информацию о запросе, статусе ответа и другие дополнительные параметры. Настрою access логи, AWS дает возможность настраивать формат этих логов. Помимо формата ([Common Log Format](https://httpd.apache.org/docs/current/logs.html#common), CSV,XML,JSON) можно настраивать список полей для отображения. В контексте лог события содержится большое количество данных, существует несколько десятков разных полей, которые можно выводить в логах. Я остановлюсь на стандартных:
```
# template.yaml
BugTrackerApi:
Type: AWS::Serverless::Api
Properties:
...
AccessLogSetting:
DestinationArn: !GetAtt AccessLogGroup.Arn
Format: '{"requestTime":"$context.requestTime","requestId":"$context.requestId","httpMethod":"$context.httpMethod","path":"$context.path","resourcePath":"$context.resourcePath","status":$context.status,"responseLatency":$context.responseLatency}'
AccessLogGroup:
Type: AWS::Logs::LogGroup
Properties:
RetentionInDays: 14
```
Теперь я могу обновить и остальные лямбда функции: добавить логи, интегрировать с новым форматом событий.
Трассировка
-----------
Готовое serverless приложение, как правило, состоит из множества функций. Эти функции вызывают другие сервисы, другие функции. Результирующая цепочка вызовов от получения запроса до возвращения результата может быть довольно сложной. В такой распределенной среде, помимо логов, нужны инструменты,помогающие оценить производительность приложения, обнаружить узлы, которые приводят к ошибкам. Конечно, всю эту информацию можно достать из логов, но удобство пользования этими данными оставляет желать лучшего, потому что строить цепочку вызовов придется каждый раз самостоятельно в голове. На помощь приходит сервис для трассировки в лице AWS X-Ray.
Он позволяет строить карты сервисов, отслеживать логику выполнения для входящих запросов, показывает ошибки и отказы в приложении. Этот сервис отмечает часть запросов специальным идентификатором TraceId. Если в процессе обработки запроса происходят вызовы других сервисов, то порожденные запроса тоже отмечаются этим идентификатором. Таким образом это позволяет построить цепочку вызовов, отслеживать выполнение конкретного запроса, профилировать приложение.
Для того, чтобы начать пользоваться этим сервисом, необходимо включить xray трассировку в ApiGateway и лямбда функциях:
```
Resources:
BugTrackerApi:
Type: AWS::Serverless::Api
Properties:
TracingEnabled: true
...
GetProjectByIdFunction:
Type: AWS::Serverless::Function
Properties:
Tracing: Active
...
```
Теперь сделаю пару вызовов моего API и зайду в AWS Console в раздел X-Ray. AWS построил вот такую карту:
Помимо карты, X-Ray предоставляет информацию о длительности шагов. Моя карта очень простая, можно только увидеть время инициализации и работы лямбда функции:
Тут нет ни БД, ни гитхаба, для более детальной профилировки они необходимы. Исправлю эту неточность. Для добавления этих сервисов придется использовать aws-xray-sdk в коде функций. Для профилирования работы с БД:
```
// src/handlers/get-project-by-id/app.js
const captureMySQL = require('aws-xray-sdk-mysql');
const mysql = captureMySQL(require('mysql2/promise'));
```
После этих изменений в X-Ray автоматически будет попадать информация о запросах в MySQL. При желании можно добавить в контекст сам SQL запрос.
Github API не является стандартным сервисом для sdk, так что эти запросы не будут отображаться ни на карте, ни в цепочках трассировки. Чтобы улучшить трассировку для GitHub API, я воспользуюсь тем, что X-Ray может отслеживать http/https запросы.
```
// src/handlers/get-project-by-id/app.js
const AWSXRay = require('aws-xray-sdk-core');
AWSXRay.captureHTTPsGlobal(require('https'));
```
Теперь запросы в GitHub API появятся на карте.
Еще одна полезная функциональность в X-Ray sdk - это создание своих сегментов. Они не отображаются на карте сервисов, зато для них считается длительность и с помощью этого можно делать профилирование важных частей кода. Я сделаю сегмент, который включает запрос в GitHub API и его обработку:
```
// src/handlers/get-project-by-id/app.js
const xraySegment = AWSXRay.getSegment();
var subsegment = xraySegment.addNewSubsegment(get-pull-requests');
const { data: prInfo } = await listPullRequests(owner, project['github_repo']);
subsegment.close();
```
SSM интегрировать с sdk можно, но не нужно в моем случае. Все потому, что запрос в SSM происходит один раз за все время жизни экземпляра в момент инициализации. Трассировка же работает, только когда происходит фаза обработки события.
После всех изменений карта вызовов получается такой:
А вот и обновленный список сегментов:
Как видно, инструмент полезный и нужный в распределенных системах. Но есть своя ложка дегтя. Теперь мой код не работает локально. Все-таки локально запускается не настоящая лямбда функция и X-Ray контекст не создается, как следует. Из-за этого происходит ошибка и лямбда функция не запускается: *'Missing AWS Lambda trace data for X-Ray. Ensure Active Tracing is enabled and no subsegments are created outside the function handler'*.
Для локального запуска можно скрыть эти ошибки. Для определения локального запуска Amazon предоставляет специальную переменную **AWS\_SAM\_LOCAL**. Чтобы игнорировать эти ошибки, я воспользуюсь специальным режимом в X-Ray клиенте:
```
if (process.env.AWS_SAM_LOCAL) {
AWSXRay.setContextMissingStrategy("IGNORE_ERROR");
}
```
Развернутое приложение будет работать с трассировкой, а в локальном режиме трассировка будет игнорироваться.
Сервисы трассировки играют важную в роль в мониторинге и отладке распределенных систем. И эта роль увеличивается с увеличением числа компонентов приложения. Такой инструмент обязательно должен быть в чемоданчике serverless разработчика.
Параллелизм лямбда функций
--------------------------
Как уже было сказано ранее, на каждое событие от ApiGateway AWS будет искать готовый к обработке экземпляр функции. Если готового экземпляра нет, то AWS начнет его создавать. Таким образом, если нет готовых экземпляров и прилетит 10 событий разом, то будет создаваться 10 экземпляров лямбда функций. Это очень удобно, провайдер сможет обрабатывать пиковые нагрузки и масштабироваться автоматически. Но что будет с моей БД?
Очевидно что такое бесконтрольное “размножение” в конце концов приведет к отказу БД или очень большим задержкам. Аналогичная проблема может быть с любым ресурсом, доступ к которому ограничен какими-то квотами. Что тут можно сделать?
Для каждой функции можно задать максимальное количество экземпляров, которые могут одновременно работать. Я задам этот параметр через глобальные настройки для всех функций:
```
# template.yaml
Globals:
Function:
ReservedConcurrentExecutions: 5
```
Введя это ограничение, я заблокирую создание новых экземпляров сверх этого лимита. События, которым не будет хватать обработчика останутся необработанными. В случае с API Gateway пользователь получит ошибку. Этот механизм позволяет контролировать скорость обработки событий для приложений. Правильно ли так обрабатывать такие нагрузки - это другой вопрос, и решается он по-разному в каждом отдельном случае.
Если установить ReservedConcurrentExecutions в значение 0, то моя лямбда совсем перестанет обрабатывать события, поскольку провайдер не сможет создавать новые экземпляры. Это может быть полезно в ситуациях, когда необходимо отключить часть функционала без обновления всего приложения. Например баг в функции или проблемы с БД, я могу отключить лямбду, которая может вызывать эти проблемы.
Как победить cold start
-----------------------
В [первой части](https://habr.com/ru/company/lineate/blog/655523/) я коснулся немного проблемы cold start. Для уменьшения времени холодного запуска я выбрал nodejs, поскольку у интерпретируемых языках программирования время инициализации меньше. Но тем не менее, даже с использованием определенного языка, эта проблема может не исчезнуть. Чем больше логики в блоке инициализации, тем больше время ожидания первого ответа. Как же быть? Что еще можно предпринять для сокращения этого времени, или для того, чтобы влияние этого было минимальным?
В фазе инициализации происходит скачивание кода, подготовка окружения. После того как окружение готово, происходит собственно инициализация кода.
Как разработчик, я могу повлиять на то, как мой код инициализируется. Очевидно, что использование “тяжелых” библиотек и фреймворков увеличит это время. Поэтому если в приложении можно обойтись без каких-либо фреймворков, то лучше их не добавлять. Например, можно прекрасно обойтись без Express.js при написании лямбда функций. Нет необходимости добавлять в зависимости aws-sdk целиком, если из этой библиотеки нужен только клиент работы с SSM.
Как разработчик, я также могу повлиять на размер моей кодовой базы. Здесь рекомендация очень похожа на предыдущие. Фреймворки и библиотеки помимо времени загрузки влияют еще и на размер артефакта. AWS-SDK занимает 70 МБ, тогда как aws-ssm client всего около 5 МБ (по данным npm).
Другим способом уменьшения кодовой базы является использование специальных инструментов для сжатия исходников, например webpack. Этот вариант наиболее прост и эффективен в случае, если не применяются слои с зависимостями, а все библиотеки находятся внутри лямбда функции.
Организация сжатия внутри слоев потребует больше усилий. Зависимости из слоев могут использоваться во многих функциях. Придется зафиксировать используемые методы библиотек через прокси модули. Такое решение очень неудобное и громоздкое.
Все эти способы помогут уменьшить время cold start. Но окончательно побороть это явление сложно. Да, я могу оптимизировать свои зависимости, но они все равно будут вносить какой-то вклад в общее время инициализации. Что делать?
### Provisioned Concurrency
В AWS существует возможность держать в облаке определенное число “живых” экземпляров функций. Таким образом, при появлении нового события для обработки функция сразу готова к работе, ей не нужно время на инициализацию. Этот функционал в AWS для лямбда функций называется Provisioned Concurrency. Я плачу деньги за то, чтобы облачный провайдер держал некоторое число функций “прогретыми”.
Для этих “прогретых” функций проблема cold start становится неактуальной. Если количество событий превышает количество существующих прогретых функций, то включаются обычные правила AWS. Создаются новые экземпляры по обычным правилам (c cold start)
Настройка ProvisionedConcurrency для лямбда функции выполняется в SAM шаблоне:
```
# template.yaml
Globals:
Function:
ProvisionedConcurrencyConfig:
ProvisionedConcurrentExecutions: 5
```
В каком-то смысле можно рассматривать возможность поднимать уже “прогретые” экземпляры как серебряную пулю для борьбы с cold start. Это решение особенно выигрышно в случае небольших нагрузок. Для приложений с плавающей нагрузкой, такое решение может таить в себе дополнительные расходы.
Подведение итогов
-----------------
Приложение готово и пришло время подвести итоги всего приключения. Разработка serverless приложения была увлекательной и интересной. Я затронул базовый набор: api gateway, лямбда функции, RDS, sam. В процессе разработки я старался затронуть те же моменты, с которыми часто сталкиваюсь при разработке классических серверных приложений: тестирование, отладка, развертывание и так далее.
Чемоданчик наполнился следующими инструментами:
* SAM framework для построения и управления приложением;
* AWS X-Ray как решение для трассировк;
* Logs Insights, sam logs для работы с логами;
* lambda-log для создание структурированных логов.
В предисловии я писал о плюсах, которые обычно приписывают serverless разработке. В процессе работы над приложением я точно могу подтвердить два из четырех:
* быстрота разработки;
* быстрые релизы.
Часто при старте проектов первые недели идет усиленная работа по созданию окружений, написанию скриптов развертывания, проработка CI/CD. Достаточно много работы в это время ложится на DevOps инженеров. С serverless приложениями этот первый шаг можно пройти быстрее.
Безусловно, скорее всего потребуется помощь DevOps для настройки VPC, VPN, и их интеграции с AWS сервисами. Что касается самого приложения, то тут разработчик вполне в состоянии создать скрипты развертывания, настроить SSM, задать параметры сборки, организовать dev/qa/stg/feature environments. SAM оказался очень удобным инструментом для развертывания.
Сами релизы происходят быстро, нет необходимости обновлять все приложение целиком, можно обновить только часть.
“Гибкое масштабирование” и “уменьшение времени или затрат на администрирование приложений” в полной мере прочувствовать не удалось. Настоящей опытной эксплуатации у моего проекта не было, несмотря на это удалось немного протестировать работу приложения в условиях плавающей нагрузки.
Тюнинг производительности существенно упрощается, есть 3 параметра, которыми можно управлять для повышения/понижения производительности приложения: объем памяти в самой функции, значения ReservedConcurrency и ProvisionedConcurrency.
Но не может быть все идеальным и таким безоблачным. Есть моменты, которые требуют большого внимания.
Если с serverless компонентами проблем практически не было, то на стыке SAM и CF возникали затруднения. В CF число ресурсов и компонентов гораздо больше, эти ресурсы сложнее в настройке. Поэтому по ощущениям больше времени тратилось именно на CF ресурсы и настройки.
Иногда не хватало подсказок в документации AWS о том, как делать те или иные вещи.
Признаться, в процессе работы над приложением я несколько раз переделывал структуру проекта. Все потому, что не было каких-то четких указаний или рекомендаций от AWS, как лучше располагать файлы в проекте. Изначально все мои js файлы были в одной папке и все казалось простым и понятным, пока я не заглянул в папку со сборкой. Пришлось даже потратить время на то, чтобы научиться применять webpack для сжатия моих исходников. Но потом пришло понимание, что такая структура проекта не совсем подходит для serverless приложения.
Это приключение подошло к концу. Я однозначно в будущих своих проектах буду рассматривать возможность переезда на serverless рельсы.
Я надеюсь, что получится сделать какое-то продолжение. В “стране serverless” есть еще множество интересных вещей:
* работа с длительными вычислениями (ведь время работы лямбда функции ограничено 15 минутами);
* построение цепочек из лямбда функций при помощи step functions;
* использование других фреймворков для развертывания (serverless, aws cdk);
* другие облачные провайдеры.
Оставляйте в комментариях набор инструментов, который входит в ваш личный чемоданчик serverless разработчика.
*P.S. Спасибо* [*oN0*](https://habr.com/ru/users/oN0/) *за помощь в написании статей.*
*P.P.S Код можно найти в* [*репе*](https://github.com/akoval/serverless-bugtracker/tree/chapter5) | https://habr.com/ru/post/663650/ | null | ru | null |
# Quarkus: модернизация приложений на примере helloworld из JBoss EAP Quickstart (продолжение)
Всем привет – с вами пятый пост из нашей серии про Quarkus! (Кстати, смотрите наш вебинар [«Это Quarkus – Kubernetes native Java фреймворк»](https://primetime.bluejeans.com/a2m/events/playback/61a77eb5-53ae-4dff-9ea6-92a9d66caf9d). Покажем, как начать «с нуля» или перенести готовые решения)
В [предыдущем посте](https://habr.com/ru/company/redhatrussia/blog/499524/) мы рассмотрели модернизацию Java-приложений с помощью поддерживаемых Quarkus технологий (CDI и Servlet 3) на примере программы helloworld из репозитория [Red Hat JBoss Enterprise Application Platform (JBoss EAP) Quickstart](https://github.com/jboss-developer/jboss-eap-quickstarts/tree/7.2.0.GA/helloworld). Сегодня мы продолжим тему модернизации и обсудим вопрос потребления памяти.
Измерение производительности – это фундаментальная основа практически любой модернизации, а отчеты по использованию памяти являются важной частью процесса анализа производительности. Сегодня мы рассмотрим соответствующие измерительные инструменты, с помощью которых можно количественно оценить улучшения, полученные в результате модернизации Java-приложений.
Подробности об измерении использования памяти можно узнать из руководства Quarkus под названием [Measuring Performance—How do we measure memory usage?](https://quarkus.io/guides/performance-measure#how-do-we-measure-memory-usage)
А ниже мы просто покажем, как сравнить данные по использованию памяти тремя различными типами приложений (JBoss EAP, JAR-пакет и исполняемый файл), собирая эти данные в Linux с помощью утилит pmap и ps.
### JBoss EAP
Запускаем экземпляр приложения JBoss EAP (см. раздел «Разворачиваем helloworld» в [предыдущем посте](https://habr.com/ru/company/redhatrussia/blog/499524/)) и затем смотрим его идентификатор процесса PID (в нашем примере это 7268) с помощью следующей команды:
```
$ pgrep -lf jboss
7268 java
```
**Примечание.** Опция –a позволяет извлечь полную командную строку (то есть: $ pgrep -af jboss).
Теперь используем PID 7268 в командах ps и pmap.
Вот так:
```
$ ps -o pid,rss,command -p 7268
PID RSS COMMAND
7268 665348 java -D[Standalone] -server -verbose:gc -Xloggc:/home/mrizzi/Tools/jboss-eap-7.2.0/jboss-eap-7.2/standalone/log/gc.log -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=5 -XX:GCLogFileSize=3M -XX:-TraceClassUnloading -Xms1303m -Xmx1303m -XX:MetaspaceSize=96M -XX:MaxMetaspaceSize=256m -Djava.net.preferI
```
И вот так:
```
$ pmap -x 7268
7268: java -D[Standalone] -server -verbose:gc -Xloggc:/home/mrizzi/Tools/jboss-eap-7.2.0/jboss-eap-7.2/standalone/log/gc.log -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=5 -XX:GCLogFileSize=3M -XX:-TraceClassUnloading -Xms1303m -Xmx1303m -XX:MetaspaceSize=96M -XX:MaxMetaspaceSize=256m -Djava.net.preferIPv4Stack=true -Djboss.modules.system.pkgs=org.jboss.byteman -Djava.awt.headless=true -Dorg.jboss.boot.log.file=/home/mrizzi/Tools/jboss-eap-7.2.0/jboss-eap-7.2/standa
Address Kbytes RSS Dirty Mode Mapping
00000000ae800000 1348608 435704 435704 rw--- [ anon ]
0000000100d00000 1035264 0 0 ----- [ anon ]
000055e4d2c2f000 4 4 0 r---- java
000055e4d2c30000 4 4 0 r-x-- java
000055e4d2c31000 4 0 0 r---- java
000055e4d2c32000 4 4 4 r---- java
000055e4d2c33000 4 4 4 rw--- java
[...]
ffffffffff600000 4 0 0 r-x-- [ anon ]
---------------- ------- ------- -------
total kB 3263224 672772 643024
```
Смотрим значение RSS и видим, что JBoss EAP потребляет примерно 650 МБ памяти.
### JAR-пакет
Запускаем JAR-приложение (см. раздел «Запускаем helloworld, упакованный в JAR» в [предыдущем посте](https://habr.com/ru/company/redhatrussia/blog/499524/)):
```
$ java -jar ./target/helloworld--runner.jar
```
Опять смотрим PID с помощью команды pgrep (на этот раз используем описанную выше опцию -a):
```
$ pgrep -af helloworld
6408 java -jar ./target/helloworld--runner.jar
```
Запускаем ps и pmap, чтобы измерить использование памяти, но теперь для процесса 6408.
Вот так:
```
$ ps -o pid,rss,command -p 6408
PID RSS COMMAND
6408 125732 java -jar ./target/helloworld-quarkus-runner.jar
```
И вот так:
```
$ pmap -x 6408
6408: java -jar ./target/helloworld-quarkus-runner.jar
Address Kbytes RSS Dirty Mode Mapping
00000005d3200000 337408 0 0 rw--- [ anon ]
00000005e7b80000 5046272 0 0 ----- [ anon ]
000000071bb80000 168448 57576 57576 rw--- [ anon ]
0000000726000000 2523136 0 0 ----- [ anon ]
00000007c0000000 2176 2088 2088 rw--- [ anon ]
00000007c0220000 1046400 0 0 ----- [ anon ]
00005645b85d6000 4 4 0 r---- java
00005645b85d7000 4 4 0 r-x-- java
00005645b85d8000 4 0 0 r---- java
00005645b85d9000 4 4 4 r---- java
00005645b85da000 4 4 4 rw--- java
[...]
ffffffffff600000 4 0 0 r-x-- [ anon ]
---------------- ------- ------- -------
total kB 12421844 133784 115692
```
Опять смотрим RSS и видим, что JAR-пакет потребляет примерно 130 МБ.
### Исполняемый файл
Запускаем нативник (см. раздел «Запускаем нативный исполняемый файл helloworld» в [предыдущем посте](https://habr.com/ru/company/redhatrussia/blog/499524/)):
```
$ ./target/helloworld--runner
```
Опять смотрим его PID:
```
$ pgrep -af helloworld
6948 ./target/helloworld--runner
```
И затем используем полученный идентификатор процесса (6948) в командах ps и pmap.
Вот так:
```
$ ps -o pid,rss,command -p 6948
PID RSS COMMAND
6948 19084 ./target/helloworld-quarkus-runner
И вот так:
$ pmap -x 6948
6948: ./target/helloworld-quarkus-runner
Address Kbytes RSS Dirty Mode Mapping
0000000000400000 12 12 0 r---- helloworld-quarkus-runner
0000000000403000 10736 8368 0 r-x-- helloworld-quarkus-runner
0000000000e7f000 7812 6144 0 r---- helloworld-quarkus-runner
0000000001620000 2024 1448 308 rw--- helloworld-quarkus-runner
000000000181a000 4 4 4 r---- helloworld-quarkus-runner
000000000181b000 16 16 12 rw--- helloworld-quarkus-runner
0000000001e10000 1740 156 156 rw--- [ anon ]
[...]
ffffffffff600000 4 0 0 r-x-- [ anon ]
---------------- ------- ------- -------
total kB 1456800 20592 2684
```
Смотрим RSS и видим, что исполняемый файл занимает около 20 МБ памяти.
### Сравниваем расход памяти
Итак, мы получили следующие цифры по использованию памяти:
* JBoss EAP – 650 МБ.
* JAR-пакет – 130 МБ.
* Исполняемый файл – 20 МБ.
Очевидно, что исполняемый файл занимает гораздо меньше памяти.
### Подводим итоги 4 и 5 постов
В этом и предыдущем постах мы рассмотрели вопрос модернизации Java-приложений с использованием поддерживаемых в Quarkus технологий (CDI и Servlet 3), а также различные способы разработки, сборки и запуска таких приложений. Мы показали, как выполнять сбор данных по использованию памяти для оценки улучшений, достигнутых в результате такой модернизации. Эти статьи помогают понять, как работает Quarkus и в чем заключается его польза – вне зависимости от того, идет ли речь о простейшей программке helloworld из наших примеров или о гораздо более сложных приложениях из реальной жизни.
Мы вернемся через две недели с заключительным постом про Quarkus – до встречи!
В нашем заключительном посте мы покажем, как объединить AMQ Online и Quarkus, чтобы построить современную систему обмена сообщениями на базе OpenShift с использованием двух новых технологий, связанных с обработкой сообщений. Читайте по [ссылке](https://habr.com/ru/company/redhatrussia/blog/503940/). | https://habr.com/ru/post/501746/ | null | ru | null |
# Создаем сайт с эффектом Parallax, используя Stellar.js
Один из самых популярных трендов современного веб-дизайна является эффект Parallax. В этом туториале я покажу вам, как создать подобный эффект на вашем веб-сайте, используя воображение и Stellar.js.
[**Скачать исходники**](http://webdesigntutsplus.s3.amazonaws.com/tuts/338_parallax/src.zip) | [**Демо**](http://pavel.shimansky.ru/parallax_effect/)
---
Вступление
----------
Популярность эффекта parallax берет начало с сайта [Nike’s Better World](http://www.nikebetterworld.com), который был представлен несколько лет тому назад. Эффект parallax применялся еще в 1980-х в интерфейсах игр: сначала в заголовках, а потом и [в самих играх](http://active.tutsplus.com/tutorials/games/add-depth-to-your-game-with-parallax-scrolling/).
---
Parallax в действии
-------------------
Взгляните на некоторые примеры, которые демонстрируют эффект parallax во всей красе.
[](http://community.saucony.com/kinvara3/)
[](http://www.loisjeans.com/web2012/es)
[](http://www.nike.com/jumpman23/aj2012/)
[](http://www.globaltv.com/bombgirls/index.html)
[](http://www.tokiolab.it/#/)
[](http://www.intacto10years.com/index_start.php)
---
Как будет работать наш веб-сайт
-------------------------------
Чтобы продемонстрировать, как работает эффект parallax, я решил показать вам простой 4-х слайдный веб-сайт, с использованием различных фонов и картинок. Я также добавил навигацию в верхний левый угол, которая будет пролистывать страницу к определенному слайду.
Вот как выглядит структура папки сайта:
---
Используемые плагины
--------------------
### [Stellar.js](http://markdalgleish.com/projects/stellar.js/)
### [Waypoints](http://imakewebthings.com/jquery-waypoints/)
### [jQuery Easing](http://gsgd.co.uk/sandbox/jquery/easing/)
---
Разметка HTML
-------------
Перво-наперво в файле index.html мы должны прописать HTML5 doctype и создать секцию . Она будет содержать [CSS Reset](http://developer.yahoo.com/yui/reset/) и файл ‘styles.css’. Мы также добавим библиотеку jQuery вместе с кастомной библиотекой jQuery ‘js.js’. И наконец три плагина: ‘jquery.stellar.min.js’,'waypoints.min.js’ и ‘jquery.easing.1.3.js’.
```
Create a parallax Website using Stellar.js
```
.Следующий элемент разметки будет логотип Envato, который будет в зафиксированном положении. Для него мы добавим класс ‘envatologo’, чтобы потом мы могли определить положение логотипа в CSS.
```
![]()
```
### Слайды
Слайды будут иметь четыре одинаковых разметки:
```
```
Мы используем класс ‘slide’, который будет задавать стиль для всех слайдов. Затем каждому слайду дается собственный порядковый id. Мы используем data attribute HTML5 и назовем его ‘data-slide’. Добавим еще один data attribute – ‘data-stellar-background-ratio’.
Все слайды, кроме последнего, будут иметь кнопку, которая позволит нам перейти в следующему слайду. Для этого мы добавим атрибут ‘data-slide’ с значением следующего слайда..
```
Slide 1
```
На третий и четвертый слайды мы добавим несколько изображений к диву ‘slide’. Эти картинки придадут эффект погружения в parallax. Мы должны убедиться, что изображения будут отображаться корректно на экранах любых размеров.
```
![]()
![]()
![]()
![]()
![]()
![]()
```
---
CSS
---
К счастью для нас, нам особо не нужно задерживаться на CSS. В основном мы назначим основные стили нескольким элементам.
Первое, что нам нужно сделать с CSS – это прикрепить шрифт BEBAS, используя @font-face. Затем мы должны назначить ширину и высоту html и body на 100%.
*###### //Тут должно быть @font-face. Баг хабра?*
```
@font-face {
font-family: 'BebasRegular';
src: url('font/BEBAS___-webfont.eot');
src: url('font/BEBAS___-webfont.eot?#iefix') format('embedded-opentype'),
url('font/BEBAS___-webfont.woff') format('woff'),
url('font/BEBAS___-webfont.ttf') format('truetype'),
url('font/BEBAS___-webfont.svg#BebasRegular') format('svg');
font-weight: normal;
font-style: normal;
}
html,body{
font-family: 'BebasRegular';
width:100%;
height:100%;
}
```
### Навигация
Главной навигационной панели мы назначали позицию ‘fixed’, чтобы она «стояла» на одном месте. Мы подвинули ее на 20px вниз и назначили z-index на 1, чтобы убедиться, что эта панель будет поверх всего остального.
```
.navigation {
position:fixed;
z-index:1;
top:20px;
}
.navigation li {
color:#333333;
display:block;
padding: 0 10px;
line-height:30px;
margin-bottom:2px;
font-weight:bold;
-webkit-transition: all .2s ease-in-out;
border-bottom:1px solid black;
text-align:left;
width:53px;
}
.navigation li:hover,
.active {
font-size:25px;
cursor:pointer;
width:100px!important;
}
```
Логотипу envato мы назначили такие правила, чтобы он находился по центру экрана и поверх всего сайта.
```
.envatologo {
position:fixed;
top:50%;
left:50%;
width:446px;
margin-top:-41px;
margin-left:-223px;
z-index:1;
}
```
Теперь перейдем непосредственно к самим слайдам. Назначим параметр background-attachment ‘fixed’. Мы использовали обои [Philipp Seiffert](http://philipp-seiffert.com/), которые можно скачать [здесь](http://philipp-seiffert.com/#daynight-wallpaper).
```
.slide {
background-attachment: fixed;
width:100%;
height:100%;
position: relative;
box-shadow:inset 0px 10px 10px rgba(0,0,0,0.3);
}
.wrapper {
width:960px;
height:200px;
margin:0 auto;
position:relative;
}
.slideno {
position:absolute;
bottom:0px;
left:0px;
font-size:100px;
font-weight:bold;
color:rgba(255,255,255,0.3);
}
```
Класс .button нужен для кнопки внизу страницы, которая позволяет перейти к следующему слайду. Мы разместили снизу по центру каждого слайда и использовали картинку стрелки в качестве указателя.
```
.button{
display:block;
width:50px;
height:50px;
position:absolute;
bottom:0px;
left:50%;
background-color:#333333;
background-image:url(../images/arrow.png);
background-repeat:no-repeat;
}
.button:hover{
background-color:#494949;
cursor:pointer;
}
```
Правила стиля для каждого слайда относительно просты и похожи друг на друга. Изображения второго слайда мы будем обозначать CSS селектором `nth-child(n)`.
Мы задаем правила для каждого изображения по мере их появления на экране.
```
/******************************
SLIDE 1
*******************************/
#slide1{
background-color:#5c9900;
}
/******************************
SLIDE 2
*******************************/
#slide2{
background-color:#005c99;
}
#slide2 img:first-child{
position:absolute;
top: 700px;
left: -150px;
}
#slide2 img:nth-child(2){
position:absolute;
top:300px;
left:100px;
}
#slide2 img:nth-child(3){
position:absolute;
top:600px;
left:300px;
}
#slide2 img:nth-child(4){
position:absolute;
top:400px;
left:300px;
}
#slide2 img:nth-child(5){
position:absolute;
top:600px;
right:300px;
}
#slide2 img:nth-child(6){
position:absolute;
top:600px;
right:300px;
}
#slide2 img:nth-child(7){
position:absolute;
top:400px;
right:100px;
}
#slide2 img:nth-child(8){
position:absolute;
top:100px;
right:300px;
}
```
Третий слайд имеет такую же структуру, что и второй.
```
/****************************** SLIDE 3 *******************************/
#slide3 {
background-color:#b6c10b;
}
#slide3 img:first-child {
position:absolute;
top: 700px;
left: 300px;
}
#slide3 img:nth-child(2){
position:absolute;
top:100px;
left:100px;
}
#slide3 img:nth-child(3){
position:absolute;
top:150px;
left:300px;
}
#slide3 img:nth-child(4){
position:absolute;
top:450px;
left:300px;
}
#slide3 img:nth-child(5){
position:absolute;
top:200px;
right:300px;
}
#slide3 img:nth-child(6){
position:absolute;
top:100px;
right:300px;
}
```
Четвертый слайд отличается от двух предыдущих, так как не содержит никаких изображений, кроме фонового. Мы зададим параметр ‘background-size:cover’. Он позволит покрыть весь экран фоновым изображением.
```
/******************************
SLIDE 4
*******************************/
#slide4{
background-image:url(../images/Slide4/desktop4.jpg);
-webkit-background-size: cover;
-moz-background-size: cover;
-o-background-size: cover;
background-size: cover;
}
#slide4 .parallaxbg{
position:absolute;
right:40px;
top:40px;
font-size:28px;
color:rgba(51,51,51,0.3);
}
```
---
jQuery
------
jQuery – это то место, где оживают вещи. Я прокомментировал код, чтобы вы поняли что к чему.
```
jQuery(document).ready(function ($) {
//инициализация Stellar.js
$(window).stellar();
//Кэш некоторых переменных
var links = $('.navigation').find('li');
slide = $('.slide');
button = $('.button');
mywindow = $(window);
htmlbody = $('html,body');
//Установка плагина waypoints
slide.waypoint(function (event, direction) {
//кэш переменной параметра data-slide
dataslide = $(this).attr('data-slide');
//Если пользователи переходят вверх по сайту, то изменять внешний вид навигации
if (direction === 'down') {
$('.navigation li[data-slide="' + dataslide + '"]').addClass('active').prev().removeClass('active');
}
// else Если пользователи переходят вниз по сайту, то изменять внешний вид навигации and
else {
$('.navigation li[data-slide="' + dataslide + '"]').addClass('active').next().removeClass('active');
}
});
//Отменяем waypoints для первого слайда
mywindow.scroll(function () {
if (mywindow.scrollTop() == 0) {
$('.navigation li[data-slide="1"]').addClass('active');
$('.navigation li[data-slide="2"]').removeClass('active');
}
});
//Анимация перехода между слайдами
function goToByScroll(dataslide) {
htmlbody.animate({
scrollTop: $('.slide[data-slide="' + dataslide + '"]').offset().top
}, 2000, 'easeInOutQuint');
}
//Когда пользователь нажимает на ссылку в навигации, получаем значение параметра data-slide слайда и передаем его функции goToByScroll
links.click(function (e) {
e.preventDefault();
dataslide = $(this).attr('data-slide');
goToByScroll(dataslide);
});
//Когда пользователь нажимает на кнопку перехода, получаем значение параметра data-slide кнопки и передаем его функции goToByScroll
button.click(function (e) {
e.preventDefault();
dataslide = $(this).attr('data-slide');
goToByScroll(dataslide);
});
});
```
---
Еще немного
-----------
 | https://habr.com/ru/post/145772/ | null | ru | null |
# Ответственный подход к JavaScript-разработке, часть 1
Цифры говорят нам о том, что [рост объёмов](https://httparchive.org/reports/state-of-javascript#bytesJs) JavaScript-кода плохо влияет на производительность веб-проектов. Если так будет продолжаться и дальше, то уже очень скоро при загрузке средней страницы будет передаваться как минимум 400 Кб JS-кода. И это — всего лишь объём передаваемых данных. Как и другие текстовые ресурсы, JavaScript-код практически всегда передаётся в сжатом виде. Пожалуй, сжатие — это единственное, что обычно делается правильно при передаче кода с сервера на клиент.
[](https://habr.com/ru/company/ruvds/blog/447576/)
К сожалению, в то время как уменьшение времени передачи неких ресурсов вносит серьёзный вклад в то, что мы называем «производительностью», сжатие никак не влияет на то, сколько времени у браузера уйдёт на разбор и обработку скрипта после того, как он будет полностью загружен.
Если сервер отправляет клиенту 400 Кб сжатого JS-кода, то реальное количество кода, которое браузеру нужно обработать после декомпрессии полученных данных, будет находиться в районе мегабайта. То, насколько хорошо различные устройства справляются с подобной работой, зависит от самих этих устройств. Об этом [много](https://habr.com/ru/company/ruvds/blog/419369/) всего написано, но с уверенностью можно утверждать лишь то, что время, которое требуется даже для разбора вполне обычного для своего времени объёма кода, сильно варьируется между разными устройствами.
Взгляните, например, на [этот](https://devmode.jeremy.codes/) мой простенький проект. В ходе загрузки страницы на клиент передаётся около 23 Кб несжатого JS-кода. Chrome, работающий на MacBook Pro, который выпущен в середине 2017 года, этот довольно-таки небольшой объём кода обрабатывает примерно за 25 мс. На Android-смартфоне [Nokia 2](https://www.gsmarena.com/nokia_2-8513.php), однако, похожий показатель разрастается до 190 мс. Нельзя сказать, что это очень мало, но в любом случае страница становится интерактивной достаточно быстро.
Теперь — важный вопрос. Как вы думаете, как простой смартфон Nokia 2 справляется со средними современными страницами? На самом деле — просто ужасно. Просмотр веб-страниц, даже на быстром интернет-соединении, заставляет пользователя упражняться в терпеливости, так как работа с нагруженными JavaScript-кодом страницами становится возможной только после изрядного периода ожидания.
*Обзор производительности Nokia 2 при просмотре страницы, содержащей большой объём JS-кода, обработка которого блокирует главный поток*
Хотя и устройства, с помощью которых просматривают веб-страницы, и сети, по которым передаются данные, за последние годы серьёзно улучшились, исследования показывают, что все эти улучшения «съедаются» большими объёмами JS-кода, включаемого в состав страниц. Нам нужно ответственно использовать JavaScript. Ответственность начинается с понимания того, что именно мы создаём, и с того, как именно мы это делаем.
Сравнение идеологии «сайтов» и «приложений»
-------------------------------------------
Странные вещи происходят с неточными терминами, которые мы используем для того, чтобы что-либо называть, хотя их значения, на интуитивном уровне, понятны всем. Иногда мы чрезмерно нагружаем смыслом слово «пчела», называя «пчёлами» и ос, даже хотя разница между пчёлами и осами весьма существенна. Учёт подобных различий может привести к тому, что с «пчёлами» и «осами» будут поступать по-разному. Например, мы собираемся уничтожить осиное гнездо, но если речь идёт о пчёлах, насекомых куда более полезных и уязвимых, их гнездо, расположенное в неудачном месте, вероятно, будет решено не уничтожить, а куда-нибудь перенести.
Подобная же свобода может наблюдаться и в том, как мы пользуемся терминами «веб-сайт» и «веб-приложение». Различия этих понятий гораздо менее очевидны, чем различия между настоящими осами и медоносными пчёлами, но если эти понятия объединить, подобное может привести к очень неприятным последствиям. Неприятности начинаются тогда, когда мы что-либо позволяем себе в зависимости от того, является ли некий проект «просто веб-сайтом» или «полномасштабным веб-приложением». Если вы создаёте информационный сайт для некоей компании, то, скорее всего, вы не будете полагаться на мощный фреймворк для управления изменениями DOM или для реализации маршрутизации на клиенте. Как минимум, я надеюсь, что это так. Использование инструментов, которые плохо подходят для решения неких задач, не только повредит тем, кто будет пользоваться сайтом, но и, вероятно, плохо скажется на процессе разработки.
При разработке веб-приложения всё выглядит иначе. Мы устанавливаем пакеты, что сопровождается добавлением в проект сотен, если не тысяч, зависимостей. При этом мы даже не уверены в [безопасности](https://snyk.io/blog/malicious-code-found-in-npm-package-event-stream/) некоторых из них. Мы пишем сложные конфигурации для бандлеров. При работе в подобной повсеместно встречающейся безумной среде разработки нужны знания и внимание для того, чтобы убедиться в том, что то, что было собрано, получилось быстрым, что проект будет работать там, где он должен работать. Если вы в этом сомневаетесь — выполните команду [npm ls --prod](https://docs.npmjs.com/cli/ls.html#prod--production) в корневой директории своего проекта и посмотрите, сможете ли вы назвать цель использования [всего того](https://gist.github.com/malchata/dae0a011033846e2cb44d315b0496f0d), что выведет эта команда. Если даже вы сможете это сделать, это не распространяется на скрипты сторонних разработчиков. Уверен, несколько таких скриптов используется и в вашем проекте.
Мы забываем о том, что и веб-сайты, и веб-приложения занимают одну и ту же «экологическую нишу». И те и другие находятся под одинаковым влиянием среды, которая состоит из разнообразных сетей и устройств. Подобные ограничения никуда не исчезнут в том случае, если мы решим называть то, что мы разрабатываем, «приложением», да и устройства наших пользователей не станут волшебным образом гораздо быстрее, если мы назовём «сайт» «приложением».
В сферу нашей ответственности входит выяснение того, кто пользуется тем, что мы создаём, мы должны учитывать то, что условия, в которых разные пользователи подключаются к интернету, могут отличаться от тех, на которые мы рассчитываем. Мы, создавая что-либо, должны знать цель, ради достижения которой мы это создаём, а уже после этого заниматься разработкой того, что помогает достичь этой цели — даже в том случае, если разработка окажется [не таким уж восхитительным занятием](https://css-tricks.com/simple-boring/).
Это означает необходимость переоценки нашей зависимости от JavaScript, и того, как его использование, в частности, в ущерб HTML и CSS, может привести нас к применению нерациональных паттернов, вредящих производительности и доступности веб-проектов.
Не позволяйте фреймворкам навязывать вам нерациональные паттерны
----------------------------------------------------------------
Я был свидетелем обнаружения странных вещей в кодовых базах, когда работал с командами, зависящими от фреймворков, для того, чтобы помочь им быть более продуктивными. У множества подобных находок есть одна общая черта, которая заключается в том, что то, как они написаны, часто приводит к проблемам с доступностью и производительностью сайтов. Например, рассмотрим следующий React-компонент:
```
import React, { Component } from "react";
import { validateEmail } from "helpers/validation";
class SignupForm extends Component {
constructor (props) {
this.handleSubmit = this.handleSubmit.bind(this);
this.updateEmail = this.updateEmail.bind(this);
this.state.email = "";
}
updateEmail (event) {
this.setState({
email: event.target.value
});
}
handleSubmit () {
// если адрес почты проходит проверку - отправить данные
if (validateEmail(this.state.email)) {
// ...
}
}
render () {
return (
Enter your email:
Sign Up
);
}
}
```
Тут можно найти несколько заметных проблем, касающихся доступности проекта:
1. Форма, которая не использует элемент , это уже не форма. На самом деле, исправить это можно, просто указав [role=«form»](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles/Form_Role) у родительского элемента , но если вы создаёте форму, а то, что мы видим, определённо, выглядит как форма, используйте элемент , настроив соответствующим образом атрибуты `action` и `method`. Атрибут `action` играет тут важнейшую роль, так как он позволяет форме сделать хоть что-то даже в том случае, если JavaScript оказывается недоступным (естественно, если компонент был отрендерен на сервере).
2. Тег не является заменителем для тега , который даёт некоторые возможности, касающиеся доступности проектов, которых нет у .
3. Элемент без атрибута `type="submit"` — это просто кнопка, нажатие на которую приводит к вызову привязанного к ней обработчика события. Если мы хотим что-то сделать с данными до отправки формы, кнопке нужно назначить атрибут `type="submit"`, и переместить код из обработчика события `onClick` в обработчик события формы `onSubmit`.
4. Между прочим, зачем использовать JavaScript для проверки адреса электронной почты, в то время как HTML5 даёт в наше распоряжение элементы управления, поддерживающие проверку введённых данных практически во всех браузерах — вплоть до IE10? Тут мы видим упущенную возможность воспользоваться функционалом, который уже есть в браузере и применить подходящий [тип элемента](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email), а также атрибут [required](https://developer.mozilla.org/en-US/docs/Learn/HTML/Forms/Form_validation#The_required_attribute). Правда, применяя подобные конструкции, учитывайте то, что наладка их нормального взаимодействия с программами для чтения экрана потребует [некоторых усилий](https://developer.paciellogroup.com/blog/2019/02/required-attribute-requirements/).
Учтя вышесказанное, подвергнем код компонента рефакторингу:
```
import React, { Component } from "react";
class SignupForm extends Component {
constructor (props) {
this.handleSubmit = this.handleSubmit.bind(this);
}
handleSubmit (event) {
// Нужно в том случае, если мы отправляем данные на сервер с использованием XHR
// (но будет работать и в том случае, если страница рендерится на сервере, а в браузере отключён JS).
event.preventDefault();
// Продолжаем работу…
}
render () {
return (
Enter your email:
Sign Up
);
}
}
```
Теперь то, что рендерит этот компонент, не только оказывается более доступным, но и для реализации того же функционала, что и раньше, используется меньше JS-кода. В мире, который буквально утонул в JavaScript, избавление от нескольких строк кода должно восприниматься как нечто позитивное. Браузер даёт нам [массу возможностей](https://alistapart.com/article/paint-the-picture-not-the-frame), и нам нужно стремиться к тому, чтобы пользоваться этими возможностями как можно чаще.
Я не хочу тут сказать, что проблемы с доступностью страниц возникают исключительно при использовании неких фреймворков. Я имею в виду то, что, чрезмерно полагаясь на JavaScript, разработчик, в итоге, будет попросту упускать много важных возможностей HTML и CSS. Эти пробелы в знаниях часто ведут к ошибкам, причём, мы об этих ошибках даже и не подозреваем. Фреймворки могут быть полезными инструментами, увеличивающими производительность разработчика, но постоянное изучение возможностей базовых веб-технологий крайне важно в создании удобных, пригодных к использованию продуктов, вне зависимости от применяемых при их разработке вспомогательных инструментов.
Положитесь на возможности веб-платформы и обеспечьте своим проектам светлое будущее
-----------------------------------------------------------------------------------
Раз уж мы говорим о фреймворках, нельзя не отметить то, что веб-платформа, сама по себе, это тоже огромный фреймворк. Как было показано в предыдущем разделе, мы оказываемся в более выгодном положении в том случае, если можем рассчитывать на устоявшиеся паттерны работы с разметкой и на возможности браузера. Альтернатива этим стандартным возможностям заключается в том, чтобы снова их изобрести. Не стоит и говорить о том, что подобное «изобретательство» сопряжено с немалыми трудностями. А что если бы подобные проблемы, каждый по-своему, решали бы авторы всех устанавливаемых нами JavaScript-пакетов?
### ▍Одностраничные приложения
Одна из слабостей разработчиков, которую они легко себе позволяют, заключается в применении модели одностраничных приложений (Single Page Application, SPA) даже в тех проектах, для которых эта модель не подходит. Конечно, такие проекты выигрывают от того, что они воспринимаются пользователями как более производительные за счёт маршрутизации, выполняемой средствами клиента. Но в чём минусы применения модели SPA? Встроенные возможности браузера по навигации по страницам, хотя и построены по синхронной модели, дают проекту массу преимуществ. Одно из них заключается в том, что управление историей посещений осуществляется благодаря реализации [сложной спецификации](https://html.spec.whatwg.org/#the-history-interface). Пользователи без JavaScript, [отключили ли они его сами или нет](https://kryogenix.org/code/browser/everyonehasjs.html), не потеряют возможность работать с проектом. Для того чтобы одностраничное приложение было бы доступным в браузерах с отключённым JavaScript, внезапно оказывается, что нужно уделять немалое внимание серверному рендерингу.
*Сравнение разных вариантов загрузки экспериментального приложения на медленном канале связи. Рендеринг приложения слева полностью зависит от JavaScript. Приложение справа рендерится на сервере, но затем использует, на клиенте, метод [hydrate()](https://reactjs.org/docs/react-dom.html#hydrate) для подключения компонентов к уже созданной на сервере разметке*
Здесь можно видеть то, что приложение, которое рендерится на клиенте, несколько секунд демонстрирует пользователю пустой экран, после чего выводит готовый интерфейс.
Приложение, которое рендерится на сервере и приводится в рабочее состояние на клиенте, довольно быстро выводит основные элементы интерфейса, но пользоваться им можно примерно через то же время, что и приложением, которое рендерится целиком на клиенте.
Доступность приложения так же страдает и в том случае, если маршрутизатор, расположенный на клиенте, не может сообщить пользователю о том, что изменилось на просматриваемой им странице. Это может заставить пользователя полагаться на вспомогательные технологии для того, чтобы разузнать о том, что именно изменилось на странице, в результате работа пользователя с сайтом значительно усложняется.
Далее, тут же можно встретить нашего старого врага — излишнюю нагрузку на систему. Некоторые клиентские маршрутизаторы отличаются очень маленькими размерами. Но если делать проект на [React](https://bundlephobia.com/[email protected]), воспользоваться совместимым [маршрутизатором](https://bundlephobia.com/[email protected]), и, возможно, [библиотекой](https://bundlephobia.com/[email protected]) для управления состоянием приложения, это значит, что придётся принять то, что в нём будет присутствовать некий объём служебного кода, от которого никуда уже не деться. А именно, в данном случае это примерно 135 Кб такого кода. Тщательно анализируйте проекты, которые создаёте, и то, стоит ли клиентская маршрутизация создаваемой ей дополнительной нагрузки на систему. Обычно бывает так, что лучше от системы клиентской маршрутизации отказаться.
Если вас беспокоят ощущения пользователя, если вы хотите, чтобы сайт казался бы ему быстрым, то вы можете положиться на атрибут ссылок [rel=prefetch](https://www.w3.org/TR/resource-hints/#prefetch-link-relation-type), который позволяет организовать заблаговременную загрузку документов из одного и того же источника. Использование этого атрибута оказывает огромное влияние на улучшение производительности проекта, воспринимаемой пользователями, так как страницы, ссылки на которые оформлены с использованием этого атрибута, при щелчках по этим ссылкам, мгновенно загружаются из кэша. Кроме того, так как предварительная загрузка данных имеет низкий приоритет, она вряд ли будет конкурировать за полосу пропускания с важными ресурсами.
*HTML-код, на который ведёт ссылка writing/, предварительно загружен при посещении главной страницы сайта. Когда пользователь щёлкает по соответствующей ссылке, HTML-код мгновенно загружается из кэша браузера*
Главная проблема, которая может возникнуть с предварительной загрузкой страниц, и о которой нужно знать, заключается в том, что такая загрузка может оказаться пустой тратой времени и ресурсов. Для её решения можно, например, воспользоваться небольшим скриптом [Quicklink](https://github.com/GoogleChromeLabs/quicklink) от Google, который смягчает эту проблему. Он проверяет, пользуется ли текущий клиент медленным соединением, включён ли у него [режим экономии данных](https://support.google.com/chrome/answer/2392284?co=GENIE.Platform%3DAndroid&hl=en), и, по умолчанию, позволяет избегать предварительной загрузки материалов из источников, отличающихся от источника страницы.
Для того чтобы сайт выглядел бы в глазах пользователей, которые многократно посещают его, быстрым, можно воспользоваться [сервис-воркерами](https://adactio.com/articles/13796). Их можно применять независимо от того, используется ли в проекте клиентская система маршрутизации или нет, учитывая то, что вы знакомы с [некоторыми особенностями](https://developers.google.com/web/fundamentals/primers/service-workers/high-performance-loading#for_best_performance_bypass_the_network_for_navigations) сервис-воркеров. Выполняя [кэширование маршрутов](https://developers.google.com/web/ilt/pwa/caching-files-with-service-worker) средствами сервис-воркеров, мы получаем множество тех же преимуществ, которые характерны для заблаговременной загрузки материалов некоторых ссылок, но в нашем распоряжении оказывается гораздо более обширные возможности по работе с запросами и ответами. Воспринимаете ли вы свой сайт как «приложение» или нет, оснащение его сервис-воркером, возможно, пример одного из самых ответственных вариантов использования JavaScript из существующих в наше время.
### ▍JavaScript не предназначен для формирования макетов
Если мы устанавливаем JS-пакет, предназначенный для решения задач, касающихся макетов страниц, то нам самое время проявить повышенную осторожность и задаться вопросом о том, чего мы пытаемся с помощью этого пакета добиться. CSS создан [специально](https://twitter.com/rachelandrew/status/1088870059240505344) для построения макетов страниц, для того, чтобы эффективно его использовать, не нужно никаких абстракций. Большинство задач построения макетов, которые пытаются решать средствами JavaScript, наподобие [размещения](https://www.npmjs.com/package/flexibility) элементов, их выравнивания, настройки их размеров, наподобие [управления текстом](https://www.npmjs.com/package/shave) или даже полного [формирования макетов](https://www.npmjs.com/package/lost) средствами JavaScript, в наши дни может быть решено с помощью CSS. Современные средства создания макетов наподобие Flexbox и Grid, достаточно хорошо поддерживаются браузерами, поэтому у нас нет нужды разрабатывать проекты, основанные на фреймворках для работы с макетами. Кстати, CSS — это ведь тоже фреймворк. Когда в нашем распоряжении оказывается такая возможность, как [запросы свойств](https://hacks.mozilla.org/2016/08/using-feature-queries-in-css/), прогрессивное улучшение макетов для поддержки новых средств их формирования, как выясняется, оказывается [не такой уж и сложной задачей](https://hacks.mozilla.org/2016/08/using-feature-queries-in-css/).
```
/* Тут будут стили, рассчитанные, в первую очередь, на мобильные устройства и не пользующиеся возможностями CSS Grid. */
/* Правило @supports игнорируется браузерами, которые не поддерживают технологию CSS Grid, или не поддерживают это правило. */
@supports (display: grid) {
/* Стили для более крупных экранов */
@media (min-width: 40em) {
/* Сюда попадают прогрессивно улучшаемые стили для CSS Grid */
}
}
```
Использование возможностей JavaScript для решения задач формирования макетов страниц и настройки их внешнего вида — это не новость. Это то, чем мы занимались в 2009 году, когда жили в атмосфере самообмана, говоря о том, что каждый сайт должен выглядеть в IE6 так же, как и в более продвинутых браузерах того времени. Если мы и сегодня, в 2019 году, продолжаем разрабатывать сайты так, чтобы они одинаково выглядели во всех браузерах, это значит, что нам нужно пересмотреть наши цели. Всегда будут некоторые браузеры, которые нужно поддерживать, и которые не обладают теми же возможностями, что и самые современные браузеры. Полное внешнее сходство проектов на всех платформах — это не только напрасная трата сил, это ещё и принципиальный враг идеи [прогрессивных улучшений](https://alistapart.com/article/understandingprogressiveenhancement).
Итоги: я не собираюсь стать убийцей JavaScript
----------------------------------------------
Поймите меня правильно, я не отношусь к врагам JavaScript. Благодаря этому языку я построил карьеру, и, если честно, JavaScript, уже более десяти лет, приносит мне массу удовольствия. Как бывает в любых длительных взаимоотношениях, чем больше времени я провожу, работая с JavaScript, тем лучше я его узнаю. Это — зрелый язык, обладающий множеством возможностей, который, с каждым годом, становится всё лучше.
Однако иногда мне кажется, что в наших с JavaScript отношениях что-то разладилось. Я его критикую. Или, если точнее, я критикую существующую тенденцию считать JavaScript главным инструментом сайтостроения, к которому прибегают в первую очередь, не глядя ни на что другое. Когда я проанализировал очередной бандл, похожий на запутанную новогоднюю гирлянду, мне стало ясно, что веб опьянён JavaScript. Мы прибегаем к этому языку практически по любому поводу, даже в случаях, когда обстоятельства этого и не требуют. Иногда я размышляю о том, насколько тяжёлыми могут быть последствия подобного отношения к JS.
Я планирую продолжать писать о JavaScript и о веб-разработке, продолжать искать способы рационального использования веб-технологий. Надеюсь, вместе мы сделаем современный веб лучше.
**Уважаемые читатели!** Как вы думаете, действительно ли современный веб перегружен JavaScript-кодом?
[](https://ruvds.com/turbo_vps/) | https://habr.com/ru/post/447576/ | null | ru | null |
# Проверяем RBAC в Kubernetes
Одно дело обезопасить кластер Kubernetes, а вот поддерживать защиту — задачка та еще. Впрочем, в Kubernetes добавилось новых средств: теперь выполнять и то, и другое намного проще.
В Kubernetes (начиная с версии 1.6) ввели концепт контроля доступа на основе ролей (RBAC), который позволяет администраторам определять политики ограничения для пользователей кластера. То есть создаете пользователя с ограниченным доступом: лимитируете доступ пользователя к ресурсам вроде секретов или к определенным неймспейсам.
В этом посте мы не станем разбираться, как реализовать RBAC. Приличных источников, где эта тема разобрана от и до, хватает:
* <https://medium.com/containerum/configuring-permissions-in-kubernetes-with-rbac-a456a9717d5d>
* <https://www.cncf.io/blog/2018/08/01/demystifying-rbac-in-kubernetes/>
* <https://docs.bitnami.com/kubernetes/how-to/configure-rbac-in-your-kubernetes-cluster/>
* <https://kubernetes.io/docs/reference/access-authn-authz/rbac/>
Лучше сосредоточимся на том, как сделать так, чтобы выполнялись требования вашего бизнеса, и проследим, нуждаются ли запущенные объекты RBAC в проверке: выполняют ли они свои функции.
### Наш сценарий
Некая организация принимает для работы с новым кластером Kubernetes несколько групп. Есть требование: нельзя вмешиваться в развертывания соседней группы, чтобы не случилось непредвиденных межгрупповых проблем или даунтаймов.
И вот владелец кластера развернул в кластер RBAC, ограничив тем самым доступ в определенный неймспейс. Первая проверка показала: группы не могут просматривать поды друг у друга в неймспейсах.
Прошла неделя. Владелец кластера заметил, что пользователь из изолированного неймспейса читает секреты из другого неймспейса. Как так? Он же применил RBAC!
Применить-то применил, но, как и в работе с кодом, систему надо тестировать на соответствие желаемому результату. Хорошо, что инструмент CLI Кубернетес `kubectl` дает набор средств для проверки конфигурации RBAC. `kubectl auth can-i`
Can I? («можно мне?»)
`can-i` при помощи API просто проверяет, можно ли выполнить некое действие. Параметры он использует следующие: `kubectl auth can-i VERB [TYPE | TYPE/NAME | NONRESOURCEURL]`. Теперь текущий пользователь может проверить, доступно ли ему определенное действие. Поехали:
```
kubectl auth can-i create pods
```
Это должно вернуть ответ «yes» или «no» с соответствующим кодом выхода.
Однако при попытке проверить права другого пользователя наткнемся на проблему: пользователь, под которым мы авторизованы в кластере, задан в файле конфига `./kube/config`, а иметь отдельные конфиги для тестирования отдельных пользователей — неудобно. К счастью, на помощь снова приходит Kubernetes: он способен имитировать пользователей при помощи меток `--as=` и `--as-group=`.
Обновим команду, воспользуемся имитацией другого пользователя:
```
kubectl auth can-i create pods --as=me
```
Мы должны увидеть, что с кодом выхода `1` возвращается ответ «no».
И это здорово, потому что у нас теперь есть набор команд, позволяющих проверять, нет ли у пользователя или группы пользователей доступа к какому-либо из ресурсов Kubernetes — от просмотра подов до удаления секретов.
### Автоматизация
Впрочем, останавливаться рано: теперь нам под силу реализовать тестовую последовательность, которая опишет перечень требований, и запустить ее как часть конвейера CD. За дело!
Выбирать есть из чего, языков для реализации достаточно: начиная с Ava и Mocha в JavaScript и заканчивая Rspec. В этом случае я реализую чисто bash-евский тестовый фреймворк [Bats](https://github.com/bats-core/bats-core).
Ниже — пример запуска теста. Он проверяет работу правил RBAC, разрешающих пользователю из группы изменять количество запущенных подов в неймспейсе. Выполняется, если был установлен атрибут «исполняемый». Или — используя `bats filename`.
```
#!/usr/bin/env bats
@test "Team namespaces can scale deployments within their own namespace" {
run kubectl auth can-i update deployments.apps --subresource="scale" --as-group="$group" --as="$user" -n $ns
[ "$status" -eq 0 ]
[ "$output" == "yes" ]
done
}
```
Команды `--as` и `--as-group` требуют использования следующих правил RBAC:
```
rules:
- apiGroups:
- authorization.k8s.io
resources:
- selfsubjectaccessreviews
- selfsubjectrulesreviews
verbs:
- create
```
Вот вам простой метод, как реализовать проверки ваших правил RBAC в Kubernetes. Сделав его частью конвейера Kubernetes, мы существенно усилим политику RBAC. Способ проверен на практике: отлавливать изменения, нарушающие политики доступа, получается куда быстрее!
Спасибо, что нашли время прочитать этот пост! | https://habr.com/ru/post/434374/ | null | ru | null |
# Постгрессо 29
*Мы продолжаем знакомить вас с самыми интересными новостями PostgreSQL.*
Конференция PGConf.Online 2021
------------------------------
[Она начинается](https://pgconf.ru/2021) уже 1-го марта и закончится 3-го. О ней подробно написано [в статье](https://habr.com/ru/company/postgrespro/blog/543384/) *Ивана Панченко*, зам. гендира Postgres Professional.
На этой конференции (которая не вместо, а кроме офлайновой, теплой-ламповой, она ожидается в конце весны) будет рекордное число иностранных гостей — чему явно поспособствовал онлайн-формат. В том числе на этот раз поучаствует и *Саймон Риггс* (Simon Riggs). [Доклады](https://pgconf.ru/2021/talks) в [3 потока](https://pgconf.ru/2021/schedule) с 10 утра до 6 вечера. А также [мастер-классы](https://pgconf.ru/2021/tutorials).
Статьи
------
**[PostgreSQL 14: Часть 4 или «январское наступление» (Коммитфест 2021-01)](https://habr.com/ru/company/postgrespro/blog/541252/)**
Очередной must read *Павла Лузанова*. Крупные изменения после первых трех относительно скромных коммитфестов ([июльский](https://habr.com/ru/company/postgrespro/blog/510124/), [сентябрьский](https://habr.com/ru/company/postgrespro/blog/522428/), [ноябрьский](https://habr.com/ru/company/postgrespro/blog/533058/)).
«Вопросы для затравки», предложенные Павлом:
* Могут ли диапазоны содержать пропуски значений?
* Зачем нужна индексная нотация типу json?
* Может ли индекс при частых обновлениях разрастаться меньше, чем таблица? А вообще не разрастаться?
* Сколько времени простаивали сеансы в `idle_in_transaction`?
* Как построить ER-диаграмму для таблиц системного каталога?
**[Deep PostgreSQL Thoughts: The Linux Assassin](https://info.crunchydata.com/blog/deep-postgresql-thoughts-the-linux-assassin)**
Слово deep уже пугает: не про ИИ ли это. Но нет. *Джо Конвей* (Joe Conway, Crunchy Data) действительно копает вглубь. Даже не Постгреса, не своего же расширения [plr](https://github.com/jconway). На этот раз тема — Жуткий Убийца, являющийся из недр Linux — **[OOM Killer](https://en.wikipedia.org/wiki/Out_of_memory)**.
Джо начинает с истории: первые дискуссии в Postgres-сообществе и первые патчи в 2003-м году — как заставить киллера работать по понятиям Postgres. Далее Джо поясняет отношения киллера и Postgres на уровне хоста (`oom_score` и `oom_score_adj`) и на уровне `CGroup`, поясняет, почему так важно не допустить прихода киллера.
И дальше Джо Конвей переходит к специфическим проблемам OOM Killer в Kubernetes — это, видимо, и был главный повод для написания этой статьи. Оказывается, что там, в K8s, разрушительная деятельность киллера может начаться даже при относительно благополучном состоянии памяти. В K8s своп по умолчанию выключен. До этого момента автор не трогал тему свопа, которая, вообще-то, очень даже обсуждается среди постгресистов-практиков.
Джо ссылается на обстоятельную статью *Криса Дауна* (Chris Down) **[In defence of swap: common misconceptions](https://chrisdown.name/2018/01/02/in-defence-of-swap.html)**, причём есть и русский перевод (не автопереводчиком): [В защиту свопа: распространенные заблуждения](https://web.archive.org/web/20200924111107/https://softdroid.net/v-zashchitu-svopa-rasprostranennye-zabluzhdeniya). О Postgres там нет речи, но может заинтересовать и постгресистов.
Также ссылается он на статью [The weird interactions of cgroups and linux page cache in hypervisor environments](https://storpool.com/blog/the-weird-interactions-of-cgroups-and-linux-page-cache-in-hypervisor-environments) в блоге компании StorPool, где в команде в основном болгарские фамилии.
Далее Джо Конвей плавно переходит к разработкам и усилиям Crunchy Data в треугольнике PostgreSQL — Kubernetes — ядро Linux.
**[Things I Wished More Developers Knew About Databases](https://rakyll.medium.com/things-i-wished-more-developers-knew-about-databases-2d0178464f78)**
Статья не (только) о Postgres. Иногда полезно ещё разок глянуть на разные СУБД с птичьего полёта. Вот внушительный список тем, о которых стоит помнить разработчикам приложений. В статье *Джоанна Доган* ([Jaana Dogan](https://rakyll.org/)) не поленилась их разворачивать и развивать. Иногда в неожиданную сторону: в пункте #1 мы, например, узнаём, что гугловские кабели давеча [покусали акулы](https://www.theguardian.com/technology/2014/aug/14/google-undersea-fibre-optic-cables-shark-attacks). Немало SQL-примеров, схем и есть матрица PostgreSQL vs. MySQL.
* Если сеть доступна 99.999% времени, вам сильно повезло;
* ACID понимают по-разному;
* у каждой СУБД свои возможности поддержки согласованности и изоляции;
* оптимистические блокировки могут помочь, когда удерживать эксклюзивные блокировки нет возможности;
* есть аномалии кроме грязного чтения и потери данных;
* моя СУБД, в каком порядке хочу исполнять транзакции, в таком и исполняю;
* шардинг на уровне приложения не означает шардинг вне СУБД;
* AUTOINCREMENT может преподнести неприятные сюрпризы;
* устаревшие данные могут быть полезны и помогают обойтись без блокировок;
* рассогласования из-за часов;
* под задержками (latency) могут подразумевать разное;
* надо оценивать производительность не по усредненным показателям, а по критическим операциям/транзакциям;
* вложенные транзакции небезопасны;
* транзакции не должны поддерживать состояния приложений;
* планировщик поможет узнать многое о базе данных;
* миграции без останова сложны, но возможны;
* существенный рост базы данных увеличивает непредсказуемость.
**[Troubleshooting Performance Issues Due to Disk and RAM](https://www.highgo.ca/2021/02/08/troubleshooting-performance-issues-due-to-disk-and-ram/)**
*Хамид Ахтар* (Hamid Akhtar, HighGo, Китай) написал простенькую, но небесполезную памятку для тех, кто хочет быстро сузить круг подозреваемых при поиске проблем с железом. Начав с совсем очевидных `top`, `free` и `df`, он обращается к утилитам анализа производительности дисков, процессора и памяти, и предлагает полезные наборы их опций:
**iostat** (информация и о диске, и о процессоре), напр. `iostat -dmx sda 1`
**sar** (System Activity Report, часть пакета sysstat), напр. `sar -f /var/log/sa/sa03 -b -s 02:00:00 -e 02:30:00 -r -S`
**dstat**, напр. `dstat -cdngy`
А вот скриптик для анализа памяти:
```
#!/bin/bash
grep -A3 "MemTotal" /proc/meminfo
grep "Swap" /proc/meminfo
grep -A1 "Dirty\|Active" /proc/meminfo
```
.
**[Starting with Pg – where is the config?](https://www.depesz.com/2021/02/12/starting-with-pg-where-is-the-config/)**
Депеш (*Хуберт Любашевски*) в короткой заметке напоминает, как можно найти конфигурационные файлы, если они лежат в нестандартном месте. Способы, которыми он предлагает воспользоваться не сенсационны, но может быть полезен, скажем, удобный набор опций.
Например, так:
`ps -fxao pid,command | grep -E 'post(gres|master)'`
— на выходе будет path. И отсюда:
`sudo grep -E '(hba|ident)\.conf' <путь к postgresql.conf>`
Или теперь танцуем от `pid`:
`sudo cat /proc/<подставляем pid>/environ | tr '\0' '\n' | grep ^PG | sort`
Или:
`sudo lsof -p <подставляем pid> -a -d cwd`
— получаем каталог данных и сведения о нём.
Если такие советы не понадобились, можно порефлексировать на тему «я бы сделал по-другому». Скажем, просто-напросто используя `find`, например.
**[Агрегаты в БД](https://habr.com/ru/company/tensor/blog/539638/)**
Кирилл Боровиков aka kilor завершил мини-серию статей про агрегаты:
[Зачем, как, а стоит ли?](https://habr.com/ru/company/tensor/blog/539016/)
— как сделать отчеты быстрыми, способы их реализации и какие «грабли» встречаются на этом пути;
[Эффективная обработка потока «фактов»](https://habr.com/ru/company/tensor/blog/539638/)
— как обработать БОЛЬШОЕ (капслок kilor-а) количество записей и при этом особо никого не заблокировать, включая «набегающий поток» данных. Например, это может быть пересчет остатков и ведение сводных продаж по товарам при их постоянных отгрузках, или агрегация сальдо и оборотов по бухгалтерским счетам, при массовых изменениях проводок.
[Многомерные суперагрегаты](https://habr.com/ru/company/tensor/blog/540572/)
— иерархичные агрегаты в нескольких одновременных разрезах;
[Прокси-таблицы](https://habr.com/ru/company/tensor/blog/541374/)
— как можно снизить суммарные задержки на вставку множества изменений в таблицы агрегатов за счет использования промежуточных таблиц и внешней обработки.
Облака
------
**[Babelfish: the Elephant in the Room?](https://postgresql.fund/blog/babelfish-the-elephant-in-the-room/)**
Русский перевод названия этой статьи, появившейся на сайте фонда испаноговорящего сообщества [FUNDACIÓN POSTGRESQL](https://postgresql.fund/) звучал бы так: "[Вавилонская рыбка](https://ru.wikipedia.org/wiki/%D0%92%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE%D0%BD%D1%81%D0%BA%D0%B0%D1%8F_%D1%80%D1%8B%D0%B1%D0%BA%D0%B0) или слона-то я и не приметил?" Мы уже [упоминали](https://habr.com/ru/company/postgrespro/blog/530444/), что идея проекта сверхамбициозная: Bablefish это PostgreSQL, совместимый с SQL Server настолько, что приложения, под него написанные (в том числе с T-SQL и протоколом TDS), будут сразу работать, «не зная», что работают с PostgreSQL.
Автор статьи — *Альваро Эрнандес* (Álvaro Hernández Tortosa, OnGres) — начинает с рыночной конъюнктуры, чтобы дальше предъявить гамлетовский вопрос, которым авторы Вавилонской Рыбки должны были задаться: форкать или не форкать?
Babelfish пока не может работать как расширение без доработки ядра PostgreSQL. Альваро напоминает, что 25-го января заслуженный и авторитетный в сообществе человек — *Ян Вик* (Jan Wieck) — [предложил](https://www.postgresql.org/message-id/CAGBW59d5SjLyJLt-jwNv%2BoP6esbD8SCB%3D%3D%3D11WVe5%3DdOHLQ5wQ%40mail.gmail.com) обсудить расширяемость протокола PostgreSQL: сделать такие хуки, которые позволят реализовать протокол SQL Server в виде расширения без изменений в ядре. Но это процесс небыстрый. Заодно решили обсудить и совместимость с MySQL. Но что делать AWS с Bablefish, если сообщество проигнорирует этот путь или интеграция пойдёт ни шатко, ни валко? Вероятней всего, считает Альваро, AWS будет развивать Bablefish как форк (так уже случилось с Aurora), как бы им не хотелось бы обойтись без форка. А если всё же придётся, то AWS это по силам.
Далее Альваро привлекает [Дилемму инноватора](https://habr.com/ru/company/rocketcallback/blog/291068/). И задаёт ещё один интересный вопрос: хотим ли мы (то есть сообщество), чтобы Babelfish стала “MariaDB у PostgreSQL”?
Персона
-------
PG-персоной одной из недель стал **[Александр Сосна](https://postgresql.life/post/alexander_sosna/)**, живущий в небольшом городке на Нижнем Рейне и в свободное от работы в [credativ](https://www.credativ.de/en/) время преподающий ИТ-безопасность в Нижнерейнском Университете. Он работает над довольно необычным расширением: **[pg\_snakeoil](https://github.com/credativ/pg_snakeoil)**. Это антивирус специально для PostgreSQL: он ищет вирусы в данных так, чтобы не мешать работе базы, что отнюдь не характерно для обычных антивирусов. Как замечает Александр, за вирусами охотятся не всегда из-за их вредоносности, иногда только потому, что этого требуют нормативные документы.
Релизы
------
**[PostgreSQL 13.2](https://www.postgresql.org/docs/13/release-13-2.html)**
Вышли PostgreSQL 13.2, 12.6, 11.11, 10.16, 9.6.21, 9.5.25 (последний выпуск ветки 9.5). В этих релизах одолели две проблемы безопасности:
в PostgreSQL 13 [можно было](https://access.redhat.com/security/cve/CVE-2021-20229), имея права на SELCT одного столбца, получить при помощи изощрённого запроса все столбцы таблицы;
вторая проблема касалась версий 11, 12 и 13. Если у пользователя есть права на UPDATE партицированной таблицы, но нет прав на SELECT некоторого столбца, он мог получить данные столбца из сообщений об ошибке.
Кроме того исправлено [более 80 багов](https://www.postgresql.org/about/news/postgresql-132-126-1111-1016-9621-and-9525-released-2165/).
**[pg\_probackup 2.4.9](https://github.com/postgrespro/pg_probackup/releases/tag/2.4.9)**
Появился флаг `--force` для инкрементального режима. Теперь можно переписывать содержимое в каталоге, указанном в PGDATA, если `system-identifier` в целевом экземпляре и копии НЕ совпадают (раньше приходило сообщение об ошибке).
**[pgAdmin 4 v. 5.0](https://www.pgadmin.org/docs/pgadmin4/5.0/release_notes_5_0.html)**
В версии 5.0 среди прочего появилась поддержка логической репликации; поддержка публикаций и подписок в Schema Diff.
**[Apache AGE 0.3.0](https://github.com/apache/incubator-age/releases/tag/v0.3.0.rc0-incubating)**
Apache AGE — это расширение, добавляющее в PostgreSQL функциональность графовой базы данных. Цель проекта — единое хранилище для реляционной и графовой моделей данных, чтобы пользователи могли использовать и стандартный SQL, и языки запросов к графовым базам [openCypher](https://www.opencypher.org/) и [GQL](https://en.wikipedia.org/wiki/Graph_Query_Language). | https://habr.com/ru/post/542192/ | null | ru | null |
# Xcode: управляем зависимостями собственных библиотек в проектах. Cocoapods advanced
[Cocoapods](http://cocoapods.org/) – это менеджер зависимостей библиотек в Xcode проектах. Я не буду рассказывать, как с его помощью подключить в проект уже существующую библиотеку, информации достаточно, в том числе и [эта статья](http://habrahabr.ru/company/luxoft/blog/149631/) на Хабре. Я расскажу что делать, если вы не нашли нужную вам библиотеку [в списке](https://github.com/CocoaPods/Specs), или, что ещё хуже, вы хотите создать свою библиотеку и, как вариант, не делать её доступной.
#### Часть I: подключаем библиотеки через podfile
Для начала стоит посмотреть, какие возможности даёт нам Cocoapods, для подключения библиотеки в проект (через podfile):
1. Подключить библиотеку из списка поддерживаемых:
```
pod 'Reachability'
pod 'AFNetworking/Reachability'
pod 'JSONKit', '~> 1.4'
```
Самый простой способ (он же основной), при этом можно указать привязку к конкретной версии и подключить не всю библиотеку, а только её часть (через subspec)
2. Подключить библиотеку, но при этом указать путь к спецификации
```
pod 'ZipKit', :podspec => 'ZipKit.podspec'
```
Можно использовать тогда, когда существующая Cocoapods спецификация вас каким-то образом не устраивает (например, в спецификации к библиотеке стоит iOS 6.1, а у вас в проекте Deployment target выставлен в 6.0). Сохраняем себе спецификацию, редактируем её под свои нужды, сохраняем в корень проекта – в результате у вас всё работает, и при этом нет необходимости добавлять потенциально вредные изменения в публичную спецификацию.
3. Подключить библиотеку по локальному пути (вместе со спецификацией):
```
pod 'SuperLibrary', :path => 'Submodules/SuperLibrary'
```
Этот вариант уже интереснее, так как можно указать путь к совместному коду (subversion external, git submodule...). При таком способе файлы библиотеки включаются в проект со ссылками на этот путь, что позволяет нам редактировать библиотеку и сохранять измения в системе контроля версий. Более подробно вернёмся к этому позже
4. Подключить библиотеку (вместе со спецификацией), расположенную в системе контроля версий, или просто по ссылке на архив:
```
pod 'SuperLibrary', :git => '[email protected]:bestcompany/SuperLibrary.git', :branch => 'development'
```
Основное отличие от предыдущего пункта в том, что редактировать исходный код библиотеки уже нельзя (технически можно, однако при установке зависимостей в проект будут просто добавлены копии файлов, которые никак не будут ссылаться на оригинал и будут переписаны на оригинальные файлы при последующем обновлении зависимостей)
#### Часть II: пишем спецификацию к собственной библиотеке – «как 2 байта переслать»
Создать спецификацию просто:
```
pod spec create SuperLibrary
```
Открываем сгенерированный файл, заполняем сгенерированные разделы, читая комментарии, при затруднениях обращаемся к [документации](http://docs.cocoapods.org/specification.html).
И здесь стоит вспомнить про такой механизм, как модули библиотеки (subspec). В кратце, разбиваем нашу библиотеку на некоторые логические модули (в том числе связанные между собой), описываем ресурсы, исходные коды, зависимости по-отдельности, например:
```
s.subspec 'Data' do |ds|
ds.source_files = 'Data/*.{h,m}', 'Data/Categories/*.{h,m}', 'Data/Objects/*.{h,m}'
ds.resources = 'Data/SuperLibrary.xcdatamodeld'
ds.dependency 'MagicalRecord'
ds.dependency 'SuperLibrary/Resources'
end
```
Доступ к модулю осуществляется через MasterSpec/Subspec, одни модули внутри могут зависеть от других внутри одной спецификации, допускается многоуровневая вложенность. Осталось указать модуль, который будет подключен по умолчанию, например
```
s.default_subspec = 'Controllers'
```
И всё, библиотеку можно подключать по частям, например только сетевое ядро, не затрагивая ресурсы и Unit-тесты.
Несколько советов:
Схема базы данных (\*.xcdatamodeld и иже с ними) это ресурс а не исходный код, с недавней версии cocoapods подключается нормально, в том числе вместе с версиями схемы.
Зависимости своей библиотеки от других желательно прописывать без привязки к конкректной версии (за исключением, например, Facebook-iOS-SDK, API которой меняется слишком часто).
#### Часть III: свой репозиторий спецификаций «с шахматами и поэтессами»
Библиотеки подключать знаем как, создавать спецификацию умеем, идея версий библиотек нам нравится, но делиться библиотеками не будем. Весьма частая ситуация в маленьких и больших компаниях, есть много проектов, на них используется совместный код, хорошо бы их оформить как библиотеки и работать с версиями так же просто, как и с обычными cocoapods библиотеками. И тут на помощь приходит приватные репозитории. Что нам для этого потребуется:1. Создаём новый репозиторий для спецификаций, который будет доступен вашей команде. Плохая новость, для репозитория спецификаций поддерживается только git. (Хорошая новость, на git должен быть только репозиторий спецификаций, сами библиотеки по-прежнему будут доступны по git/svn или даже по обычной ссылке на архив). Добавляем его в cocoapods простой командой из консоли:
```
pod repo add Private-Cocoapods [email protected]:bestcompany/cocoapods-specs.git
```
Осталось дело за малым, создаём в корне этого репозитория папку с именем библиотеки, в ней создаём папку с версией библиотеки, куда уже помещаем непосредственно саму спецификацию.
Всё, осталось отправить эти изменения на репозиторий и последующие команды pod install (или pod update) будут работать с нашей библиотекой так же, как и с официальной, то есть подключать pod можно будет просто по имени библиотеки.
#### Часть IV: Подключаем всё вместе, или как можо построить процесс разработки
И один из сценариев, как с этим можно успешно работать. Предпосылка: ведётся разработка нескольких продуктов (одновременно или нет, не важно), в приложениях есть совместно используемый код (библиотеки), разработка каждой библиотеки ведётся в собственной ветке репозитория.
Итак, нам надо, чтобы в корне каждой библиотеки лежал актуальный podspec файл, версия в podspec файле идёт с постфиксом dev, параметр source ссылается на текущую ветку, например:
```
Pod::Spec.new do |s|
s.name = "SuperLibrary"
s.version = "1.0.5-dev"
s.source = { :git => "ssh://[email protected]:bestcompany/my-super-library.git"}
```
Таким образом, при подключении этой версии непосредственно из репозитория, мы будем иметь пометку dev, говорящую о том, что версия не готова. После тестирования этот библиотеки создаём tag с именем версии (проверить версию, и, если необходимо, поднять минорную/мажорную версию), копируем podspec файл в наш собственный репозиторий спецификаций, убирая приставку dev из версии и указав конкретный таг в репозитории, который мы только что создали:
```
Pod::Spec.new do |s|
s.name = "SuperLibrary"
s.version = "1.1.0"
s.source = { :git => "ssh://[email protected]:bestcompany/my-super-library.git", :tag => "SuperLibrary_v1.1.0" }
```
Всё, осталось в репозитории библиотеки выставить версию на один больше не убирая постфикс dev (1.1.1-dev в нашем случае) и отправить все изменения в репозиторий.
Разработка, обычно, это процесс бесконечный, и необходимость править библиотеки возникает очень часто. Для таких случаев можно всегда хранить ссылку на текущую версию библиотеки в репозитории через сабмодуль в Git (external в Subversion). При этом в podfile конкретного продукта всегда указана стабильная версия (podspec хранится на нашем репозитории спецификаций), но рядом закоментированная строчка на текущую версию:
```
#pod 'SuperLibrary', :path => 'Submodules/SuperLibrary'
pod 'SuperLibrary'
```
В случае необходимости внести изменения в библиотеку, убираем комментарий со строчки, обновляем библиотеку до последней версии в репозитории, делаем pod update в консоли и всё, можно смело изменять и тестировать. Перед подготовкой приложения в публикацию стоит зафиксировать все версии библиотек (то есть создать новые версии для всех изменённых библиотек и подключить их из нашего репозитория спецификаций). Всегда проверяйте podfile.lock на то, какие версии библиотек используются, наш постфикс -dev очень помогает определить, что версия библиотеки может быть не протестирована.
И да, делать pod update как часть процесса сборки приложения явно не стоит (по-крайней мере на стадии подготовки версии к релизу, так как из-за обновления библиотеки обязательно что-то перестанет работать в последний момент).
P.S. Cocoapods обновляется постоянно, исправляются ошибки, добавляются новые возможности (и новые ошибки). Если у вас что-то перестало работать (а такое случается), не поленитесь, пожалуйста, найти причину, и, если дело именно в cocoapods, [дайте знать](https://github.com/CocoaPods/CocoaPods/issues) разработчикам. | https://habr.com/ru/post/196736/ | null | ru | null |
# «Шакал»: сжимаем фронтенд
Привет! Я — Ваня, лид платформенной команды в Тинькофф Бизнес.
Мое любимое занятие — открывать вкладку DevTools и проверять, сколько весят артефакты сайта. В этой статье расскажу, как мы сократили вес приложения на 30% силами платформенной фронтенд-команды за один день без изменения кода сайта. Никаких хитростей и регистраций — только nginx, docker и node.js (опционально).
### Зачем
Сейчас фронтенд-приложения весят немало. Собранные артефакты могут весить 2—3 Мб, а то и больше. Однако пользователям на помощь приходят алгоритмы сжатия.
До недавнего времени мы использовали только Gzip, который был представлен миру еще в 1992 году. Наверное, это самый популярный алгоритм сжатия в вебе, его поддерживают [все браузеры выше IE 6.](https://caniuse.com/#search=gzip%20compression)
Напомню, что уровень сжатия у Gzip изменяется в диапазоне от 1 до 9 (больше — эффективнее), а сжимать можно либо «на лету», либо статически.
* «На лету» (динамически) — артефакты хранятся в полученном после сборки виде, их сжатие происходит во время выдачи на клиент. В нашем случае на уровне nginx.
* Статически — артефакты после сборки сжимаются, а HTTP-сервер выдает их на клиент «как есть».
Очевидно, что первый вариант требует больше ресурсов сервера на каждый запрос. Второй же — на этапе сборки и подготовки приложения.
Наш фронтенд сжимался динамически четвертым уровнем. Продемонстрирую разницу между сжатым артефактом и исходным:
| **Уровень сжатия** | **Вес артефакта,** **Кб** | **Время сжатия, мс** |
| --- | --- | --- |
| 0 | 2522 | – |
| 1 | 732 | 42 |
| 2 | 702 | 44 |
| 3 | 683 | 48 |
| **4** | **636** | **55** |
| 5 | 612 | 65 |
| 6 | 604 | 77 |
| 7 | 604 | 80 |
| 8 | 603 | 104 |
| 9 | 601 | 102 |
Можно заметить, что даже четвертый уровень сокращает размер артефакта в 4 раза! А разница между четвертым уровнем и девятым составляет 35 Кб, то есть 1,3% от исходного, но в 2 раза увеличивается время сжатия.
И вот недавно мы задумались: почему бы не перейти на Brotli? Да еще и на самый мощный уровень сжатия!
К слову, этот алгоритм был представлен Google в 2015 году и имеет 11 уровней сжатия. При этом четвертый уровень Brotli эффективнее девятого у Gzip. Я замотивировался и быстро накидал код для сжатия артефактов алгоритмом Brotli. Результаты представлены ниже:
| **Уровень сжатия** | **Вес артефакта,** **Кб** | **Время сжатия, мс** |
| --- | --- | --- |
| 0 | 2522 | — |
| 1 | 662 | 128 |
| 2 | 612 | 155 |
| 3 | 601 | 156 |
| **4** | **574** | **202** |
| 5 | 526 | 227 |
| 6 | 512 | 249 |
| 7 | 501 | 303 |
| 8 | 496 | 359 |
| 9 | 492 | 420 |
| 10 | 452 | 3708 |
| 11 | 446 | 8257 |
Однако из таблицы видно, что даже первый уровень сжатия Brotli выполняется дольше, чем девятый у Gzip. А последний уровень — аж 8,3 секунды! Это насторожило меня.
С другой стороны, результат однозначно впечатляет. Далее я попробовал перенести сжатие на nginx — [загуглил документацию](https://github.com/google/ngx_brotli). Все оказалось предельно просто:
```
brotli on;
brotli_comp_level 11;
brotli_types text/plain text/css application/javascript;
```
Собрал докер-образ, запустил контейнер и был ужасно удивлен:
Время загрузки моего файла выросло в десятки раз — со 100 мс до 5 секунд! Приложением стало невозможно пользоваться.
Изучив документацию глубже, понял, что можно раздавать статически. Воспользовался ранее написанным скриптом, сжал те же артефакты, положил в контейнер, запустил. Время загрузки вернулось в норму — победа! Однако радоваться рано, потому что доля браузеров, поддерживающих этот тип сжатия, — [около 80%](https://caniuse.com/#search=gzip%20compression).
Это означает, что необходимо сохранить обратную совместимость, при этом дополнительно хочется использовать самый эффективный уровень Gzip. Так появилась идея сделать утилиту по сжатию файлов, которая позже получила название «Шакал».
### Что нам понадобится?
Nginx, Docker и Node.js, хотя при желании можно и на bash.
С Nginx почти все понятно:
```
brotli off;
brotli_static on;
gzip_static on;
```
Но что делать с приложениями, которые еще не успели обновить докер-образ? Правильно, добавить обратную совместимость:
```
gzip on;
gzip_level 4;
gzip_types text/plain text/css application/javascript;
```
Объясню принцип работы:
Клиент при каждом запросе передает заголовок Accept-Encoding, в котором перечисляет через запятую поддерживаемые алгоритмы сжатия. Обычно это deflate, gzip, br.
Если у клиента в строке есть br, то nginx ищет файлы с расширением .br, если таких файлов нет и клиент поддерживает Gzip, то ищет .gz. Если таких файлов нет, то пожмет «на лету» и отдаст с четвертым уровнем компрессии.
Если клиент не поддерживает ни один тип сжатия, то сервер выдаст артефакты в исходном виде.
Однако возникла проблема: наш докер-образ nginx не поддерживает модуль Brotli. За основу я взял [готовый докер-образ](https://hub.docker.com/r/fholzer/nginx-brotli/).
**Dockerfile для «запаковки» nginx в проекте**
```
FROM fholzer/nginx-brotli
# предварительно очищаем директорию с контентом
RUN rm -rf /usr/share/nginx/html/
# копируем нашу конфигурацию в образ
COPY app/nginx /etc/nginx/conf.d/
# копируем наши артефакты в образ
COPY dist/ /usr/share/nginx/html/
# запускаем
CMD nginx -c /etc/nginx/conf.d/nginx.conf
```
С балансировкой трафика разобрались, но откуда взять артефакты? Вот здесь-то и придет на помощь «Шакал».
### «Шакал»
[Это утилита](https://github.com/IshIvan/shakal) для сжатия статики вашего приложения.
Сейчас это три node.js-скрипта, обернутые в докер-образ с node:alpine. Пробежимся по скриптам.
**base-compressor** — скрипт, который реализует базовую логику по сжатию.
Аргументы на вход:
1. Функция сжатия — любая javascript-функция, можно реализовать свой алгоритм сжатия.
2. Параметры сжатия — объект с параметрами, необходимыми для переданной функции.
3. Расширение — расширение артефактов сжатия. Необходимо указывать начиная с символа точки.
**gzip.js** — файл с вызовом base-compressor с переданной функцией Gzip из пакета [zlib](https://www.npmjs.com/package/zlib) и указанием девятого уровня компрессии.
**brotli.js** — файл с вызовом base-compressor с переданной функцией Brotli из [одноименного npm-пакета](https://www.npmjs.com/package/brotli) и указанием 11-го уровня компрессии.
**Dockerfile создания образа «Шакала»**
```
FROM node:8.12.0-alpine
# копируем скрипты в образ
COPY scripts scripts
# копируем package.json и package-lock.json в образ
COPY package*.json scripts/
# задаем рабочую директорию в образе
WORKDIR scripts
# выполняем установку модулей
# эта установка оставит node_modules/ в образе
# можно оптимизировать, если собрать скрипт предварительно
RUN npm ci
# выполняем параллельно два скрипта
CMD node gzip.js | node brotli.js
```
Разобрались, как он работает, теперь можно смело запускать:
```
docker run \
-v $(pwd)/dist:/scripts/dist \
-e 'dirs=["dist/"]' \
-i mngame/shakal
```
* -v $(pwd)/dist:/scripts/dist — указываем, какую локальную директорию считать директорией в контейнере (ссылка на маунтинг). Указание директории scripts обязательно, так как она является рабочей внутри контейнера.
* -e 'dirs=[«dist/»]' — указываем параметр окружения dirs — массив строк, которые описывают директории внутри scripts/, которые будут сжаты.
* -i mngame/shakal — указание образа с docker.io.
В указанных директориях скрипт рекурсивно сожмет все файлы с указанными расширениями .js, .json, .html, .css и сохранит рядом файлы с расширениями .br и .gz. На нашем проекте этот процесс занимает около двух минут при весе всех артефактов около 6 Мб.
На этом моменте, а может быть, и раньше вы могли подумать: «Какой докер? Какая нода? Почему бы просто не добавить два пакета к себе в package.json проекта и вызывать прямо на postbuild?»
Лично мне очень больно видеть, когда ради прогона линтеров в CI проект устанавливает себе 100+ пакетов, из которых ему на этапе линтинга нужны максимум 10. Это время агента, ваше время, как никак time to market.
В случае с докером мы получаем заранее собранный образ, в котором установлено все необходимое именно для сжатия. Если вам сейчас не нужно ничего сжимать — не сжимайте. Нужен линт — прогоняйте только его, нужны тесты — прогоняйте только их. Плюс мы получаем хорошее версионирование «Шакала»: нам не нужно обновлять его зависимости в каждом проекте — достаточно выпустить новую версию, а проекту — использовать latest-тег.
### Результат:
* Размер артефактов изменился с 636 Кб до 446 Кб.
* Процентно размер уменьшился на 30%.
* Время загрузки уменьшилось на 10—12%.
* Время на декомпрессию, [исходя из статьи](https://www.opencpu.org/posts/brotli-benchmarks/), осталось прежним.
### Итого
Помочь своим пользователям можно прямо сейчас, прямо следующим ПРом: добавляете шаг после сборки — сжатие «Шакалом», после чего доставляете артефакты к себе в контейнер. Через полчаса ваши пользователи чувствуют себя чуть лучше.
У нас получилось уменьшить вес фронтенда на 30% — получится и у вас! Всем легких сайтов.
#### Ссылочки:
* [Докер-образ утилиты](https://hub.docker.com/r/mngame/shakal)
* [Репозиторий утилиты](https://github.com/IshIvan/shakal)
* **UPD:** Благодаря [kellas](https://habr.com/ru/users/kellas/) появилась CLI версия в виде [npm пакета](https://www.npmjs.com/package/shakal-cli) | https://habr.com/ru/post/474632/ | null | ru | null |
# Запуск программ в Yakuake при старте KDE
Всем привет!
На домашнем компьютере я использую Linux в виде Kubuntu 10.04, т.к. с давних пор проникся функциональностью десктопа KDE.
Не представляю себе пользователя KDE, который бы не использовал очень удобный эмулятор терминала Yakuake. И все бы хорошо, но недавно захотелось, чтобы при старте системы, в разных сессиях Yakuake запускались некоторые консольные утилиты (возьмем, к примеру, htop и rtorrent). Команды `man yakuake` и `yakuake --help` подсказали. что не стоит ждать простых решений. Как-то сами в голове всплыли слова классика:
*«За мной, читатель! Кто сказал тебе, что нет нет на свете настоящей, верной, вечной любви? Да отрежут лгуну его гнусный язык! За мной, мой читатель, и только за мной, и я покажу тебе такую любовь!»*
… детективное расследование с привлечением гугла подсказало, что решение проблемы надо искать в использовании системных вызовов d-bus. Для этих целей была использована утилита qdbusviewer из пакета qt4-dev-tools. Скорбный интерфейс утилиты не помешал найти нужные команды:
`qdbus org.kde.yakuake /yakuake/sessions runCommand rtorrent # Запуск команды rtorrent в текущей сессии
qdbus org.kde.yakuake /yakuake/sessions addSession # Добавление новой сессии
qdbus org.kde.yakuake /yakuake/sessions runCommand htop # Запуск команды htop в добавленной сессии`
Поместив данные строчки в скрипт, а скрипт в автозагрузку KDE- получаем желаемое.
Вот, собственно, и все. Удачи! | https://habr.com/ru/post/101711/ | null | ru | null |
# О том, что происходит, когда в поиске Google используют слово «vs»
Случалось у вас такое: ищете что-нибудь в Google и вводите после искомого слова «vs», надеясь на то, что поисковик автоматически предложит вам что-то, немного похожее на то, что вам нужно?
[](https://habr.com/ru/company/ruvds/blog/508652/)
*Ввод «vs» после искомого слова*
Со мной такое бывало.
Как оказалось, это — большое дело. Это — [приём](https://www.linkedin.com/posts/andriyburkov_this-simple-hack-will-save-you-a-ton-of-time-activity-6675799581655203840-1XuH), который, при поиске альтернативы чему-либо, способен сэкономить массу времени.
Я вижу 3 причины, по которым этот приём отлично себя показывает в том случае, если его используют для поиска сведений о технологиях, неких разработках и концепциях, в которых хотят разобраться:
1. Лучший способ изучить что-то новое заключается в том, чтобы выяснить, чем это, новое, похоже на то, что уже известно, или чем новое от известного отличается. Например, в списке предложений, появляющемся после «vs», можно увидеть что-то такое, о чём можно сказать: «А, так, оказывается, то, что я ищу, похоже на это, мне уже знакомое».
2. Это — простой приём. Для того чтобы им воспользоваться нужно, в буквальном смысле, несколько секунд.
3. Слово «vs» — это чёткое указание, говорящее Google о том, что пользователя интересует прямое сравнение чего-то с чем-то. Тут можно воспользоваться и словом «or», но оно далеко не так сильно выражает намерение сравнить что-то с чем-то. Поэтому, если воспользоваться «or», Google выдаст список предложений, в котором более вероятно появление чего-то постороннего.
*Обрабатывая запрос «bert or», Google выдаёт предложения, касающиеся «Улицы Сезам». А запрос «bert vs» даёт подсказки по* [*Google BERT*](https://www.blog.google/products/search/search-language-understanding-bert/)
Это заставило меня задуматься. А что если взять те слова, что Google предложил после ввода «vs», и поискать по ним, тоже добавляя после них «vs»? Что если повторить это несколько раз? Если так, можно получить симпатичный сетевой граф связанных запросов.
Например, он может выглядеть так.
*Эго-граф для запроса bert с радиусом 25*
Это — весьма полезная методика создания ментальных карт технологий, разработок или идей, отражающих взаимосвязь подобных сущностей.
Расскажу о том, как строить такие графы.
Автоматизация сбора «vs»-данных из Google
-----------------------------------------
Вот ссылка, которую можно использовать для того чтобы получить от Google предложения по автозавершению запроса в формате XML. Эта возможность не выглядит как API, предназначенный для широкого использования, поэтому, вероятно, не стоит слишком сильно налегать на эту ссылку.
```
http://suggestqueries.google.com/complete/search?&output=toolbar≷=us&hl=en&q=
```
URL-параметр `output=toolbar` указывает на то, что нас интересуют результаты в формате XML, `gl=us` задаёт код страны, `hl=en` позволяет указать язык, а конструкция `q=` — это как раз то, для чего нужно получить результаты автозавершения.
Для параметров `gl` и `hl` используются стандартные двухбуквенные идентификаторы [стран](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) и [языков](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes).
Давайте со всем этим поэкспериментируем, начав поиск, скажем, с запроса `tensorflow`.
Первый шаг работы заключается в том, чтобы обратиться по указанному URL, воспользовавшись следующей конструкцией, описывающей запрос: `q=tensorflow%20vs%20`. Вся ссылка при этом будет выглядеть так:
```
http://suggestqueries.google.com/complete/search?&output=toolbar≷=us&hl=en&q=tensorflow%20vs%20
```
В ответ мы получим XML-данные.
Что делать с XML?
-----------------
Теперь нужно проверить полученные результаты автозавершения на соответствие некоему набору критериев. С теми, которые нам подойдут, мы продолжим работу.
*Проверка полученных результатов*
Я, при проверке результатов, пользовался следующими критериями:
* Рекомендованный поисковый запрос не должен содержать текст исходного запроса (то есть — `tensorflow`).
* Рекомендация не должна включать в себя запросы, которые были признаны подходящими ранее (например — `pytorch`).
* Рекомендация не должна включать в себя несколько слов «vs».
* После того, как найдено 5 подходящих поисковых запросов, все остальные уже не рассматриваются.
Это — лишь один из способов «очистки» полученного от Google списка рекомендаций по автозавершению поискового запроса. Я, кроме того, иногда вижу пользу в том, чтобы выбирать из списка только рекомендации, состоящие исключительно из одного слова, но использование этого приёма зависит от каждой конкретной ситуации.
Итак, используя этот набор критериев, мы получили 5 следующих результатов, каждому из которых присвоен определённый вес.
*5 результатов*
Следующая итерация
------------------
Затем эти 5 найденных рекомендаций подвергают такой же обработке, какой был подвергнут исходный поисковый запрос. Их передают API с использованием слова «vs» и опять выбирают 5 результатов автозавершения, соответствующих вышеозначенным критериям. Вот результат такой обработки вышеприведённого списка.
*Поиск результатов автозавершения для уже найденных слов*
Этот процесс можно продолжать, изучая ещё не исследованные слова из столбца `target`.
Если провести достаточно много итераций подобного поиска слов, получится довольно большая таблица, содержащая сведения о запросах и о весах. Эти данные хорошо подходят для визуализации в виде графа.
Эго-графы
---------
Сетевой граф, который я вам показывал в начале статьи, это — так называемый эго-граф (ego graph), построенный, в нашем случае, для запроса `tensorflow`. Эго-граф — это такой граф, все узлы которого находятся на каком-то расстоянии от узла `tensorflow`. Это расстояние не должно превышать заданного расстояния.
А как определяется расстояние между узлами?
Давайте сначала посмотрим на готовый граф.
*Эго-граф для запроса tensorflow с радиусом 22*
Вес ребра (weight), соединяющего запрос `A` и `B`, мы уже знаем. Это — ранг рекомендации из списка автозавершения, изменяющийся от 1 до 5. Для того чтобы сделать граф неориентированным, можно просто сложить веса связей между вершинами, идущими в двух направлениях (то есть — от `A` к `B`, и, если такая связь есть, от `B` к `A`). Это даст нам веса рёбер в диапазоне от 1 до 10.
Длина ребра (distance), таким образом, будет вычисляться по формуле `11 — вес ребра`. Мы выбрали здесь число 11 из-за того, что максимальный вес ребра — 10 (ребро будет иметь такой вес в том случае, если обе рекомендации появляются на самом верху списков автозавершения друг для друга). В результате минимальным расстоянием между запросами будет 1.
Размер (size) и цвет (color) вершины графа определяется количеством (count) случаев, в которых соответствующий запрос появляется в списке рекомендаций. В результате получается, что чем больше вершина — тем важнее представляемая ей концепция.
Рассматриваемый эго-граф имеет радиус (radius) 22. Это означает, что добраться до каждого запроса, начиная с вершины `tensorflow`, можно, пройдя расстояние, не превышающее 22. Взглянем на то, что произойдёт, если увеличить радиус графа до 50.
*Эго-граф для запроса tensorflow с радиусом 50*
Интересно получилось! Этот граф содержит большинство базовых технологий, о которых надо знать тем, кто занимается искусственным интеллектом. При этом названия этих технологий логически сгруппированы.
И всё это построено на основе одного единственного ключевого слова.
Как рисовать подобные графы?
----------------------------
Я, для рисования такого графа, использовал онлайн-инструмент [Flourish](https://flourish.studio/).
Этот сервис позволяет строить сетевые графики и другие диаграммы с помощью простого интерфейса. Полагаю, на него вполне стоит взглянуть тем, кого интересует построение эго-графов.
Как создать эго-граф с заданным радиусом?
-----------------------------------------
Для создания эго-графа с заданным радиусом можно воспользоваться Python-пакетом `networkx`. В нём есть очень удобная функция `ego_graph`. Радиус графа указывают при вызове этой функции.
```
import networkx as nx
#Формат исходных данных
#nodes = [('tensorflow', {'count': 13}),
# ('pytorch', {'count': 6}),
# ('keras', {'count': 6}),
# ('scikit', {'count': 2}),
# ('opencv', {'count': 5}),
# ('spark', {'count': 13}), ...]
#edges = [('pytorch', 'tensorflow', {'weight': 10, 'distance': 1}),
# ('keras', 'tensorflow', {'weight': 9, 'distance': 2}),
# ('scikit', 'tensorflow', {'weight': 8, 'distance': 3}),
# ('opencv', 'tensorflow', {'weight': 7, 'distance': 4}),
# ('spark', 'tensorflow', {'weight': 1, 'distance': 10}), ...]
#Построить исходный полный граф
G=nx.Graph()
G.add_nodes_from(nodes)
G.add_edges_from(edges)
#Построить эго-граф для 'tensorflow'
EG = nx.ego_graph(G, 'tensorflow', distance = 'distance', radius = 22)
#Найти двусвязные подграфы
subgraphs = nx.algorithms.connectivity.edge_kcomponents.k_edge_subgraphs(EG, k = 3)
#Получить подграф, содержащий 'tensorflow'
for s in subgraphs:
if 'tensorflow' in s:
break
pruned_EG = EG.subgraph(s)
ego_nodes = pruned_EG.nodes()
ego_edges = pruned_EG.edges()
```
Я, кроме того, воспользовался тут ещё одной функцией — `k_edge_subgraphs`. Она применяется для удаления некоторых результатов, которые не соответствуют нашим нуждам.
Например, `storm` — это опенсорсный фреймворк для распределённых вычислений в реальном времени. Но это — ещё и персонаж из вселенной Marvel. Как вы думаете, какие поисковые подсказки «победят», если ввести в Google запрос «storm vs»?
Функция `k_edge_subgraphs` находит группы вершин, которые невозможно разделить, выполнив `k` или меньшее число действий. Как оказалось, тут хорошо показывают себя значения параметров `k=2` и `k=3`. Остаются, в итоге, только те подграфы, которым принадлежит `tensorflow`. Это позволяет обеспечить то, что мы не слишком удаляемся от того, с чего начали поиск, и не уходим в слишком далёкие области.
Использование эго-графов в жизни
--------------------------------
Давайте отойдём от примера с `tensorflow` и рассмотрим другой эго-граф. В этот раз — граф, посвящённый ещё кое-чему такому, что меня интересует. Это — шахматный дебют, получивший название «Испанская партия» (Ruy Lopez chess opening).
### ▍Исследование шахматных дебютов
*Исследование «Испанской партии» (ruy lopez)*
Наша методика позволила быстро обнаружить самые распространённые идеи дебютов, что может помочь исследователю шахмат.
Теперь давайте рассмотрим другие примеры использования эго-графов.
### ▍Здоровое питание
Капуста! Вкуснятина!
Но что если у вас возникло желание заменить прекрасную, несравненную капусту на что-то другое? Вам в этом поможет эго-граф, построенный вокруг капусты (`kale`).
*Эго-граф для запроса kale с радиусом 25*
### ▍Покупаем собаку
Собак так много, а времени так мало… Мне нужна собака. Но какая? Может — что-то вроде пуделя (`poodle`)?
*Эго-граф для запроса poodle с радиусом 18*
### ▍Ищем любовь
Собака и капуста ничего не меняют? Нужно найти свою вторую половину? Если так — вот маленький, но весьма самодостаточный эго-граф, который может в этом помочь.
*Эго-граф для запроса coffee meets bagel с радиусом 18*
### ▍Что делать, если приложения для знакомств ничем не помогли?
Если приложения для знакомств оказались бесполезными, стоит, вместо того, чтобы в них зависать, посмотреть сериал, запасшись мороженым со вкусом капусты (или со вкусом недавно обнаруженной рукколы). Если вам нравится сериал «The Office» (безусловно, тот, что снят в Великобритании), то вам могут понравиться и некоторые другие сериалы.
*Эго-граф для запроса the office с радиусом 25*
Итоги
-----
На этом я завершаю рассказ об использовании слова «vs» в поиске Google и об эго-графах. Надеюсь, вам всё это хотя бы немного поможет в поиске любви, хорошей собаки и здоровой еды.
**Пользуетесь ли вы какими-нибудь необычными приёмами при поиске в интернете?**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=google-vs) | https://habr.com/ru/post/508652/ | null | ru | null |
# Кортежи в языках программирования. Часть 1
Сейчас во многих языках программирования существует такая конструкция, как кортежи (tuples). Где-то кортежи в той или иной мере встроены в язык, иногда — опять же в той или иной мере — реализуются средствами библиотек. C++, C#, D, Python, Ruby, Go, Rust, Swift (а также Erlang, F#, Groovy, Haskell, Lisp, OCaml и многие другие)…
Что же такое кортеж? В Википедии дается достаточно точное [определение](https://ru.wikipedia.org/wiki/Кортеж_(информатика)): кортеж — упорядоченный набор фиксированной длины. Определение хоть и точное, но для нас пока бесполезное, и вот почему: задумывается ли большинство программистов, зачем понадобилась эта сущность? В программировании существует множество структур данных, как фиксированной, так и переменной длины; они позволяют хранить различные значения — как однитипные, так и разных типов. Всевозможные массивы, ассоциативные массивы, списки, структуры… зачем еще и кортежи? А в языках со слабой типизацией — и тем более, разница между кортежами и списками/векторами совсем размытая… ну нельзя добавлять в кортеж элементы, ну и что с того? Это может ввести в некоторое заблуждение. Поэтому стоит копнуть глубже и разобраться, зачем же на самом деле нужны кортежи, чем они отличаются от других языковых конструкций, и как сформировать идеальный синтаксис и семантику кортежей в идеальном (или близком к идеальному) языке программирования.
В первой части мы рассмотрим кортежи и кортежеподобные конструкции в распространенных и не очень языках программирования. Во второй части я попытаюсь обобщить и расширить и предложить наиболее универсальный синтаксис и семантику кортежей.
Первая важная вещь, о которой на Википедии не упомянули: кортеж — это структура времени компиляции. Иными словами, это некая сущность, объединяющая некоторые объекты на этапе компиляции. И это очень важно. Кортежи неявно используются во всех языках программирования, даже в Си и Ассемблере. Давайте поищем их в том же Си, С++, в любом компилируемом языке.
Так, список аргументов функции — это кортеж;
Список инициализации структуры или массива — это тоже кортеж;
Список аргументов шаблона или макроса — тоже кортеж
Описание структуры, и даже обычный блок кода — это тоже кортеж; только элементами его являются не объекты, а синтаксические конструкции.
Кортежей в программе гораздо больше чем кажется на первый взгляд. Но они все неявные; так или иначе они являются жестко прикрученными к каким-то синтаксическим конструкциям. Явное использование кортежей в старых языках было не предусмотрено. В более современных языках некоторые возможности явного использования стали появляться — но далеко не все. Здесь мы будем рассматривать в основном кортежи значений — или переменных, или констант. Возможно, в следующих частях я рассмотрю и кортежи произвольных синтаксических элементов.
Начнем с самого очевидного — возврата нескольких значений из функции. Еще со школьных времен меня удивляла такая несправедливость: почему функция может принимать сколько угодно значений, а возвращать только одно? В самом деле, почему y=x\*x — нормальная парабола, а y = sqrt(x) — какая-то обрезанная наполовину фигня? Разве это не нарушение математической гармонии? В программировании конечно можно возвратить структурный объект, но суть остается та же: возвращается один объект, а не несколько.
Непосредственная реализация множественного возврата есть в **Go**. Функция может явно вернуть несколько значений. Синтаксис позволяет присвоить эти несколько значений нескольким переменным, а также выполнять групповые присваивания и даже перестановки аргументов за одну операцию. Однако, никаких других групповых действий кроме присваивания не предусмотрено.
```
func foo() (r1 int, r2 int) {
return 7, 4
}
x, y := foo()
x, y = 1, 2
x, y = y, x
```
Интересная возможность, на которую следует обратить внимание — «пакетная» передача нескольких возвращаемых значений одной функции в другую функцию.
```
func bar(x int, y int) {
}
bar(foo())
```
Такая пакетная передача сама по себе крайне интересна. С одной стороны, она кажется весьма элегантной; но с другой — она слишком «неявная», неуниверсальная. Например, если попытаться добавить в bar третий аргумент, и попытаться совместить «пакетную» передачу и обычную
```
bar(foo(), 100)
```
то ничего не получится — ошибка компиляции.
Еще один интересный аспект — неиспользование возвращаемых значений. Вспомним С/С++. В них (а также в подавляющем большинстве других языков — Java, C#, ObjC, D...) можно было спокойно игнорировать возвращаемые значения при вызове функции. В Go такое тоже возможно, причем можно игнорировать как единственное возвращаемое значение, так и группу. Однако, попытка использовать первое возвращаемое значение и неявно проигнорировать второе приводит к ошибке компиляции. Игнорировать возможно, но явно — с использованием специального символа "\_":
```
x, _ := foo()
```
Т.е. работает принцип «все или ничего»: можно или игнорировать все возвращаемые значения, или использовать — но также все.
В **Rust** имеются схожие возможности. Точно также функции могут возвращать несколько значений; также можно инициализировать ими новые значения. При этом множественное присваивание как таковое отсутствует, возможна только инициализация. Аналогично можно использовать символ "\_" для неиспользуемых значений. Аналогично можно игнорировать возвращаемые значения полностью, или получать их также все полностью. Также кортежи можно сравнивать:
```
let x = (1i, 2i, 3i);
let y = (2i, 3i, 4i);
if x == y {
println!("yes");
} else {
println!("no");
}
```
Отметим этот факт: мы встретили первую операцию над кортежами, отличную от присваивания. Также здесь наблюдается еще одна интересная возможность — создание именованных кортежей и их последующее использование «как единого целого».
В языке **Swift** возможности в целом аналогичны. Из интересного — обращение к элементам кортежа по константному индексу через точку; возможность назначать элементам кортежа имена и обращаться к элементам через них.
```
let httpStatus = (statusCode: 200, description: "OK")
print("The status code is \(httpStatus.0)")
print("The status code is \(httpStatus.statusCode)")
```
Такие кортежи уже близки к структурам, но все-же структурами не являются. И здесь я бы хотел отойти от примеров и перейти к своим собственным мыслям. Разница между кортежами и структурами в том, что кортеж — это не тип данных, это нечто более низкоуровневое; можно сказать — что кортеж — это просто (возможно именованная) группа (возможно именованных) объектов времени компиляции. В этом месте вспомним языки C/С++. Простейшие конструкции инициализации массива и структуры выглядят так:
```
int arr[] = {1, 2, 3};
Point3D pt = {1, 2, 3};
```
Обратите внимание, списки инициализации в данном случае вообще идентичны. И тем ни менее, они инициализируют совершенно разные объекты данных. Такое поведение в общем нетипично для типа данных. Но зато это близко к другой интересной фиче, которая иногда (но редко) встречается в языках программирования — [структурной типизации](https://en.wikipedia.org/wiki/Structural_type_system). Конструкция в фигурных скобках — типичный кортеж. Кстати, в Си есть именованная инициализация полей структуры (идея кстати весьма похожа на Swift), которую пока так и не протащили в C++17:
```
Point3D pt = {.x=1, .y=2, .z=3};
```
В **С++** пошли немного в другом направлении: ввели понятие " унифицированный синтаксис инициализации и списки инициализации". Синтаксически это те же кортежи, которые можно использовать для инициализации объектов; в дополнение к старым возможностям, унифицированный синтаксис инициализации позволяет передавать объекты в функции и возвращать из функций в виде кортежей.
```
Point3D pt{10,20,30}; // новый синтаксис инициализации
Point3D foo(Point3D a)
{
return {1, 2, 3}; // возвращаем "кортеж"
}
foo( {3,2,1} ); // передаем "кортеж"
```
Другая интересная возможность — списки инициализации.Они используются для начальной инициализации динамических структур данных — таких как вектора и списки. Списки инициализации в С++ должны быть однородными, то есть все элементы списка должны быть одного типа. Технически такие списки формируют константные массивы в памяти, для доступа к которым применяются итераторы std::initializer\_list. Можно сказать, что шаблонный тип std::initializer\_list — специальный определенный на уровне компилятора интерфейс к однородным кортежам (а фактически к константным массивам). Разумеется, списки инициализации можно использовать не только в конструкторах, но и как аргументы любых функций и методов. Думаю, если бы в С++ изначально был бы некий шаблонный тип данных, соответствующий литеральному массиву и содержащий информацию о длине этого массива, он бы вполне подошел на роль std::initializer\_list.
Также в стандартной библиотеке С++ (и в Boost) существуют кортежи, реализованные с помощью шаблонов. Поскольку такая реализация не является частью языка, синтаксис получился слегка громоздким и неуниверсальным. Так, тип кортежа приходится объявлять явно с указанием типов всех полей; для конструирования объектов применяется функция std::make\_tuple; для создания кортежа «на лету» (из существующих переменных) применяется другой шаблон — tie, а получение доступа к элементам осуществляется с помощью специального шаблонного метода, который требует константного индекса.
```
std::tuple t1(10,'x');
auto t2 = std::make\_tuple ("test", 3.1, 14, 'y');
int myint; char mychar;
std::tie (myint, mychar) = t1; // unpack elements
std::tie (std::ignore, std::ignore, myint, mychar) = t2; // unpack (with ignore)
std::get<2>(t2) = 100;
char mychr = std::get<3>(t2);
```
В примере применяется распаковка со специальным значением std::ignore. Это в точности соответствует символу подчеркивания "\_", применяемому для тех же целей при групповых возвратах из функций в Go и Rust.
Похожим способом (хотя и упрощенно по сравнению с С++) реализованы кортежи в **C#**. Для создания используются методы Tuple.Create(), набора шаблонных классов Tuple<>, для доступа к элементам — поля с фиксированными именами Item1… item8 (чем достигается константность индекса).
В языке **D** есть достаточно богатая поддержка кортежей. С помощью конструкции tuple можно сформировать кортеж, и — в том числе — осуществить множественный возврат из функции. Для доступа к элементам кортежа используется индексация константными индексами. Также кортеж можно сконструировать с помощью шаблона Tuple, что позволяет создать кортеж с именованными полями.
```
auto t = Tuple!(int, "number", string, "message")(123, "hello");
writeln("by index 0 : ", t[0]);
writeln("by .number : ", t.number);
writeln("by index 1 : ", t[1]);
writeln("by .message: ", t.message);
```
Кортежи можно передавать в функции. Для этого применяется индексация с диапазоном. Синтаксически это выглядит как будто передается один аргумент, а на самом деле кортеж раскрывается сразу в несколько аргументов. При этом в D, в отличие от Go, нет требования точного равенства количества аргументов функции и элементов кортежа, то есть можно смешивать передачу одиночных аргументов и кортежей.
```
void bar(int i, double d, char c) { }
auto t = tuple(1, "2", 3.3, '4');
bar(t[0], t[$-2..$]);
```
В D существует еще множество возможностей, связанных с кортежами — Compile-time foreach для обхода кортежей на этапе компиляции, шаблон AliasSeq, оператор tupleof… в общем все это требует отдельной большой статьи.
А напоследок рассмотрим реализацию кортежей в малоизвестном расширении языка Си — CForAll или C∀ (*забавно, но на момент написания статьи я не смог нагуглить сайт языка — весьма вероятно что он давно закрылся и упоминаний просто не осталось; вот поэтому я регулярно сканирую сеть в поисках новых языков программирования и скачиваю все до чего смогу дотянуться*).
Кортежи в C∀можно объявить на уровне языка, заключив список объектов в квадратные скобки. Тип кортежа создается аналогично — в квадратные скобки заключается список типов. Объекты и типы кортежей можно объявлять явно. Кортежи можно передавать в функции, где они разворачиваются в списки аргументов (в отличие от Go, где такое возможно только при точном совпадении кортежа и списка аргументов функции).
```
[ int, int ] w1; // объект-кортеж из двух элементов
[ int, int, int ] w2; // объект-кортеж из трех элементов
void f (int, int, int); // функция, принимающая три аргумента
f( 1, 2, 3 ); // просто числа
f( [ 1, 2, 3 ] ); // кортеж-объект объявленный прямо на месте
f( w1, 3 ) // кортеж и число
f( w2 ) // кортеж-объект
```
Еще одна интересная тема — вложенные кортежи и правила их раскрытия. В С/С++ также применяется вложенность — при инициализации массивов структур, элементы которых также являются массивами и структурами. В C∀ существуют правила, называемые «tuple coercions», в частности — раскрытие кортежей с внутренней структурой (flattering) и наоборот, структурирование (structuring), когда «плоский» кортеж подстраивается под сложную внутреннюю структуру (хотя эта возможность весьма спорная, обсуждение будет в следующей части). И все это относится лишь к присваиванию, никаких упоминаний использования этих возможностей с другими операциями нет.
```
[ a, b, c, d ] = [ 1, [ 2, 3 ], 4 ];
```
В C∀ предусмотрено как групповое, так и множественное присваивание.
```
[ x, y, z ] = 1.5;
[ x, y, z ] = [ 1, 2, 3 ];
```
и даже использование кортежей для доступа к полям структур
```
obj.[ f3, f1, f2 ] = [ x, 11, 17 ];
```
Ввиду отсутствия компилятора проверить все эти возможности на практике не удалось, но это безусловно отличная пища для размышлений. Собственно, этим размышлениям и будет посвящена следующая часть статьи. | https://habr.com/ru/post/276871/ | null | ru | null |
# Революция дата-байндинга с Object.Observe()
#### Введение
Грядет революция. Появилось новое дополнение к JavaScript, которое изменит всё, что вы когда-либо знали о дата-байндинге. Помимо этого, изменится и подход ваших MVC библиотек к наблюдениям за редактированием и обновлением моделей. Вы готовы?
Хорошо, хорошо. Не будем тянуть. Я рад вам представить Object.observe(), который появился в бета версии Chrome 36. [ТОЛПА ЛИКУЕТ]
Object.observe() является частью следующего ECMAScript стандарта. Он позволяет асинхронно отслеживать изменения JavaScript объектов… без использования каких-либо сторонних библиотек, он позволяет наблюдателю отслеживать изменения состояния объекта во времени.
```
// Давайте представим, что у нас есть модель с данными
var model = {};
// Изменения которой мы начинаем отслеживать
Object.observe(model, function(changes){
// Эта асинхронная возвращаемая функция запускается,
changes.forEach(function(change) {
// Давая нам понять, что изменилось
console.log(change.type, change.name, change.oldValue);
});
});
```
При каждом изменении объекта мы получаем оповещение:
С помощью Object.observe()(мне нравится называть его O.o() или Oooooooo), вы можете реализовать двухсторонний дата-байндинг без необходимости использовать фреймворк.
Это совсем не говорит о том, что вам не стоит его использовать. Для больших проектов со сложной бизнес-логикой, фреймворки необходимы, и вам я не собираюсь отговоривать вас от их использования. Они нацелены на упрощение работы для новых разработчиков, требует меньше кода для поддержки и вводят определенные шаблоны для работы над общими задачами. Когда вам не требуется подобная функциональность, вы можете использовать более легковесные решения, такие, как polymer (который, кстати, уже использует O.o()).
Даже если вы во всю используете фреймворки или MV\* библиотеки, O.o() позволит им получить неплохой прирост в производительности, который достигается за счёт быстрой, упрощенной реализации, и в то же время продолжает использовать тот же интерфейс API. Например, последний год команда разработчиков Angular провела сравнительный анализ и установила, что dirty-checking занимает приблизительно 40мс, в то время как О.о() занимает где-то 1-2мс (получается, быстрее в 20-40 раз).
Дата-байндинг без необходимости использовать тонны сложного кода! А ведь это так же означает, что вам больше не придется опрашивать модель на получение изменений!
Если вы уже поняли, что делает О.о(), можете сразу листать к описанию новой функциональности, или же можете прочитать, какие проблема решает данный подход.
#### За чем мы собираемся наблюдать?
Когда мы говорим о наблюдении за данными, мы обычно имеем ввиду отслеживание нескольких типов изменений:
* Изменение нативных JavaScript объектов
* Добавление, изменение или удаление свойств
* Когда удаляются или добавляются данные в массив
* Изменения в прототипе объекта
#### О важности дата-байндинга
Дата-байндинг начинает становится важной частью вашего приложения, когда вы начинаете затрагивать взаимодействие модели и представления. HTML является великолепным декларативным механизмом, но он полностью статичен. В идеале, вы просто хотите связать ваши данные с DOM и держать его в постоянно актуальном состоянии. Решение с O.o() позволяет вам сэкономить большое количество времени, за счёт отсутствия необходимости писать большие куски повторяющегося кода, который будет просто посылать новые данные в DOM, и наобарот.
Дата-байндинг действительно удобен, когда вы создаете комплексный пользовательский интерфейс, где вам необходимо наладить большое количество связей между различными свойствами ваших моделей и UI элементами, отражающими их. Это одна из самых распространенных задач во время создания SPA (Single Page Application) приложений.
Первоначально, у нас не было никакого механизма для наблюдения за данными, и мы перекладывали ответственность за это на различные JavaScript фреймворки(или же писали небольшие библиотеки), полагаясь на различные медленные хаки, которые мир использует и по сей день.
#### Что мир представляет из себя сегодня?
##### Dirty-checking
Где вы видели дата-байндинг до этого момента? Ну, если вы используете современные MV\*-библиотеки для создания ваших веб приложений (Angular, Knockout), то вы, возможно, уже использовали привязку данных модели к вашему DOM. Чтобы освежить это в памяти, вот вам пример приложения «Телефонная книга», где мы байндим номер каждого телефона из массива номеров к элементу списка, и таким образом поддерживаем постоянную синхронизацию между ними:
```
...
* {{phone.name}}
{{phone.snippet}}
```
и JavaScript для контроллера:
```
var phonecatApp = angular.module('phonecatApp', []);
phonecatApp.controller('PhoneListCtrl', function($scope) {
$scope.phones = [
{'name': 'Nexus S',
'snippet': 'Fast just got faster with Nexus S.'},
{'name': 'Motorola XOOM with Wi-Fi',
'snippet': 'The Next, Next Generation tablet.'},
{'name': 'MOTOROLA XOOM',
'snippet': 'The Next, Next Generation tablet.'}
];
});
```
[(Демо)](http://angular.github.io/angular-phonecat/step-2/app/)
Каждый раз, когда данные модели изменяются, наш список в DOM будет обновлен. Как Angular достигает этого? Что ж, за сценой он выполняет то, что мы называется dirty-checking.
Основополагающая идея dirty-checking´а заключается в том, что в любой момент времени данные могут быть изменены, и библиотеке необходимо проверить, каким образом они изменились. В случае ангуляра, это происходит через регистрацию состояний всех данных модели, которые необходимо отслеживать. Он знает о предыдущих значениях модели и если они изменяются, возникает соответствующее событие. Для разработчика, основной профит заключается в том, что мы работаем с нативными JS объектами, которые легко поддерживать и объединять. С другой стороны, в меру того, что алгоритм весьма прожорлив, это может оказаться очень дорогим решением.
Расходы на такие операции пропорциональны общему количеству наблюдаемых объектов. Возможно, мне потребуется делать очень много подобных проверок. Так же возможно, что мне потребуется способ вызвать события dirty-checking´а, когда модель «возможно» изменилась. Существует довольно много хитрых трюков, к которым прибегает фреймворк, чтобы реализовать подобные решения. Пока еще непонятно, доведут ли данное решение до ума.
Экосистема веба должна иметь больше возможностей для совершенствования и развития своих декларативных механизмов, например
* Системы моделей, основанных на контейнерах с внешним доступом к атрибутам через сеттеры/геттеры
* Системы с автосохранением (сохраняющие изменения в IndexedDB или localStorage)
* Объекты-контейнеры (например, Backbone, Ember)
Объекты-контейнеры — это механизм хранения данных, при котором фреймворк создает объекты, которые хранят внутри себя данные, доступ к которым предоставляется с помощью акцессоров (геттеры/сеттеры), а также реализует возможность подписки на любые свои изменения. Это работает весьма неплохо: алгоритм обеспечивает довольно быструю работу. Пример использования таких объектов в Ember можно найти ниже:
```
// Объект-контейнер
MyApp.president = Ember.Object.create({
name: "Barak Obama"
});
MyApp.country = Ember.Object.create({
// суффикс "Binding" в названии свойства говорит Ember о том,
// что необходимо создать байндинг к этому свойству
presidentNameBinding: "MyApp.president.name"
});
// Позже, после того как Ember создал байндинг
MyApp.country.get("presidentName");
// "Барак Обама"
// Данные с сервера должны быть конвертированы,
// т.к. они не соответствуют существующему коду.
```
Расходы на детектирование изменений в данном случае пропорциональны количеству свойств, которые меняются. Другой проблемой является то, что вы используете объекты разного типа. Проще говоря, вы конвертируете данные, которые вам приходят с сервера для установки их в наблюдаемый объект.
Это не особо сочетается с существующим JS кодом, т.к. большая часть кода предполагает, что он может взаимодействовать с обычными данными(не обёрнутыми в объект-контейнер *пр. пер.*), но не с этими специализированными объектами.
#### Введение в Object.observe()
Было бы по-настоящему здорово, если бы мы могли получить лучшее от этих двух вселенных: возьмем возможность наблюдать за изменением данных с поддержкой для обычных объектов (нативные объекты JavaScript) и уберем dirty-checking, а вместо него добавим какой-нибудь алгоритм с хорошим характеристиками. Какой-нибудь такой, который будет объединять все эти положительные качества и будет встроен в платформу. Так вот, встречайте — Object.observe(), уже готовый к использованию!
Он позволяет нам наблюдать за объектом, изменять свойства и наблюдать за изменением через отчеты об изменениях. Но хватит теории, давайте посмотрим на код!
#### Object.observe() и Object.unobserve()
Давайте представим, что мы имеем нативный JS объект, представляющий модель:
```
// Модель может быть обычным нативным объектов
var todoModel = {
label: 'Default',
completed: false
};
```
Мы так же можем объявить возвращаемую функцию, которая будет вызвана, как только над объектом произойдут изменения
```
function observer(changes){
changes.forEach(function(change, i){
console.log('what property changed? ' + change.name);
console.log('how did it change? ' + change.type);
console.log('whats the current value? ' + change.object[change.name]);
console.log(change); // all changes
});
}
```
Заметка: Когда у наблюдателя вызывается возвращаемая функция, наблюдаемые объекты могут быть изменены несколько раз, поэтому для каждого изменения, новое значение и текущее значение не обязательно одно и то же.
Мы можем наблюдать за такими изменениями, используя O.o(), передавая в качестве первого аргумента наблюдаемый объект и в качестве второго возвращаемую функцию:
```
Object.observe(todoModel, observer);
```
Давайте попробуем что-нибудь сделать с нашей моделью:
```
todoModel.label = 'Buy some more milk';
```
Посмотрите в консоль, мы получили ряд полезной информации! Мы знаем, какое свойство изменилось, как оно было изменено и какое новое значение ему было присвоено.
Вау! Прощай, dirty-checking! Надпись на твоём надгробии будет высечена Comic Sans'ом. Давайте изменим другое свойство. В этот раз completeBy:
```
todoModel.completeBy = '01/01/2014';
```
Как мы видим, мы опять успешно получили отчёт об изменении:
Отлично, а что если теперь мы решим удалить из нашего объекта свойство «completed»:
```
delete todoModel.completed;
```
Теперь, как мы можем видеть, отчет об изменениях включает в себя информацию об удалении. Как и ожидалось, новое значение свойства теперь undefined. Так, теперь мы знаем, что можем отследить, когда новые свойства были добавлены или удалены. Проще говоря, ряд свойств объекта («new», «deleted», «reconfigured») и его цепочки прототипов.
Как и в любой системе наблюдения, должен существовать метод для прекращения наблюдения за изменениями объекта. В нашем случае, это Object.unobserve(), который имеет такую же сигнатуру, как и O.o(), но может быть вызван следующим образом:
```
Object.unobserve(todoModel, observer);
```
Как мы можем видеть ниже, любые изменения, которые были сделаны после вызова последнего метода, больше не выведут в консоль отчет об изменениях.
#### Фокусируемся на свойствах
Итак, когда мы познакомились с основами, давайте вернемся к списку изменений наблюдаемого объекта.
```
Object.observe(obj, callback, opt_acceptList)
```
Давайте сразу перейдем к примеру, чтобы посмотреть, как это можно использовать:
```
// Как мы и говорили выше, модель может быть просто нативным объектом
var todoModel = {
label: 'Default',
completed: false
};
// Мы можем указать возвращаемую функцию для любых
// изменений, происходящих с объектом
function observer(changes){
changes.forEach(function(change, i){
console.log(change);
})
};
// С помощью которой мы в дальнейшем будем наблюдать объект,
// и конкретные события изменения, который нас интересует
Object.observe(todoModel, observer, ['delete']);
// Без третьего параметра мы будем получать уведомления
// о любых изменениях данного объекта
todoModel.label = 'Buy some milk';
// Обратите внимание, что события не возникает!
```
Теперь, если мы удалим свойство «label», нотификация об изменении возникнет:
```
delete todoModel.label;
```
Если вы не указываете список применимых типов к O.o(), то по умолчанию передается «внутренний» объект, регламентирующий изменения «add», «update», «delete», «reconfigure», «preventExtensions» (если объект нельзя изменить, он не поддается наблюдению).
#### Нотификации
В O.o() так же есть понятие нотификаций (оповещений). Они не имеют ничего общего с теми надоедливыми штуками, которые всплывают в вашем телефоне, они намного полезнее. Нотификации схожи с [Mutation Observers](https://developer.mozilla.org/en/docs/Web/API/MutationObserver) (и замечательная [статья на хабре](http://habrahabr.ru/post/202366/) от [zag2art](https://habrahabr.ru/users/zag2art/)). Они возникают во время окончания выполнения микрозадач. В контексте браузера, они почти всегда возникают в конце текущего обработчика события.
Такое время крайне удобно из-за того, что основная работа уже была выполнена, и наблюдатели могут начать делать свою работу, не мешая основной логике. Это отличная модель пошаговой обработки событий.
Рабочий процесс, построенный с использованием оповещений выглядит как-то так:
А теперь давайте посмотрим на пример того, как нотификации могут быть использованы для оповещения об изменении состояния объекта. Обратите внимание на комментарии:
```
// Объявляем простую модель
var model = {
a: {}
};
// И отдельную переменную, которую мы позже будем использовать
// в геттере нашей модели
var _b = 2;
// Определяем новое свойство "b" в нашем объекте "a"
// и устанавливаем ему геттер и сеттер
Object.defineProperty(model.a, 'b', {
get: function () {
return _b;
},
set: function (b) {
// Когда свойство "b" установлено в модель,
// мы должны оповестить мир о спецефических
// изменениях, которые мы сделали. Это даёт вам
// невероятный контроль над оповещениями
Object.getNotifier(this).notify({
type: 'update',
name: 'b',
oldValue: _b
});
// Давайте еще будем выводить значение каждый раз
// когда что-то будет происходить
console.log('set', b);
_b = b;
}
});
// Объявляем функцию наблюдения
function observer(changes) {
changes.forEach(function (change, i) {
console.log(change);
})
}
// Начинаем наблюдать за изменениями model.a
Object.observe(model.a, observer);
```
Здесь мы выводим оповещение при изменении данных («update»), да и всего, чего угодно, собственно говоря, если это указано в вызове метода notifier.notifyChange().
Годы опыта в веб-разработке научили нас, что синхронные операции — это первое, чему мы учимся, т.к. проще всего управлять именно такими операциями. Проблема заключается в том, что это создает потенциально опасную процессинговую модель (модель обработки данных *пр. пер.*). Если вы пишите код и, скажем, пишите «обнови свойство объекта», вы вряд ли хотите, чтобы это привело к срабатыванию какого-то произвольного кода в середине функции, который может делать всё, что захочет.
Даже со стороны наблюдателя, вы не хотите, чтобы какая-то сторонняя функция была вызвана из середины текущей функции и т.п. Несогласованность и разобщенность мест вызовов функций раздражает, верно? И прибавьте к этому ещё проверки на ошибки, и прочие ситуации, которые могут усложнить жизнь при данном подходе. И в результате мы видим, что с подобной моделью реально трудно работать. Асинхронный подход сложнее в понимании, но всё же, на сегодняшний день, ничего лучше него нет.
Решением этой проблемы может стать синтетическое изменении записей.
#### Синтетическое изменение записей
Проще говоря, если вам потребуется получить доступ к акцессору или вычисляемому свойству (про выч. свойства можно прочитать [тут](http://emberjs.com/guides/object-model/computed-properties/)), на вас ложится ответственность за создание оповещения при изменении этого свойства. Это немного добавляет работы, но скорее является фичей, чем неудобством. Ваши оповещения будут доставлены вместе с оповещении об изменении других свойств и будут иметь следующий вид:
Наблюдение за акцессорами и изменениями вычисляемых свойств может быть выполнено с помощью notifier.notify (это тоже включено в спецификацию Object.observe). Многие системы для наблюдения за изменениями должны предоставлять информацию об измененных значениях, и, честно говоря, у нас есть довольно много способов, как это сделать. Object.observe не навязывает нам «правильный» путь.
Я думаю, что веб-разработчики могут ожидать от библиотек какие-то готовые решения для помощи с оповещением изменения вычисляемых свойств.
Теперь давайте перейдем к следующему примеру, который иллюстрирует нам создание класса «Круг». Суть в том, что у нас есть круг и его свойство «радиус». В нашем примере радиус будет акцессором, и когда его значение поменяется, возникнет событие, оповещающее об этом. Оно будет доставлено вместе со всеми остальными оповещениями об изменении объекта.
Давайте посмотрим, как наш код будет работать в DevTools:
```
function Circle(r) {
var radius = r;
var notifier = Object.getNotifier(this);
function notifyAreaAndRadius(radius) {
notifier.notify({
type: 'update',
name: 'radius',
oldValue: radius
})
notifier.notify({
type: 'update',
name: 'area',
oldValue: Math.pow(radius * Math.PI, 2)
});
}
Object.defineProperty(this, 'radius', {
get: function() {
return radius;
},
set: function(r) {
if (radius === r)
return;
notifyAreaAndRadius(radius);
radius = r;
}
});
Object.defineProperty(this, 'area', {
get: function() {
return Math.pow(radius, 2) * Math.PI;
},
set: function(a) {
r = Math.sqrt(a)/Math.PI;
notifyAreaAndRadius(radius);
radius = r;
}
});
}
function observer(changes){
changes.forEach(function(change, i){
console.log(change);
})
}
```
#### Свойства акцессоров
Небольшое примечение о свойствах акцессора. Ранее мы говорили только о наблюдении на изменениями значений свойств, но совсем не упоминали подобное поведение для акцессоров или вычисляемых свойств. Причиной тому является то обстоятельство, что JavaScript на самом деле не имеет возможности отслеживать изменения значения для акцессоров, ведь по факту они являются лишь коллекцией функций.
Если вы уже работали с акцессорами, то можете себе представить, как они работают: они просто предоставляет набор функций, которые дают доступ к свойствам, и ничего больше.
#### Наблюдение за несколькими объектами с одной возвращаемой функцией
Другим возможным паттерном при работе с O.o() является нотация использования наблюдения за объектом с единственной возвращаемой функцией. Это позволяет использовать данную функцию в качестве функции-наблюдателя для любого количества различных объектов. Возвращаемая функция будет предоставлять каждый раз полный набор изменений для всех объектов, которые она отслеживает (это будет происходить по окончанию всех микрозадач, см. Mutation Observers).
#### Масштабные изменения
Возможно, вы работаете над реально огрооооомным проектом и регулярно вынуждены сталкиваться с масштабными изменениями.
O.o() помогает в этом с помощью двух специфический функций: notifier.performChange() и notifier.notify(), о котором мы уже говорили.
Давайте посмотрим на пример того, как масштабные изменения могут бы описаны с помощью Thingy object с помощью некоторых математических функций (multiply, increment, incrementAndMultiply). Каждый раз, когда мы используем функцию, она говорит системе, что коллекция работ включает в себя определенный тип изменений.
Например: notifier.performChange('foo', performFooChangeFn);
```
function Thingy(a, b, c) {
this.a = a;
this.b = b;
}
Thingy.MULTIPLY = 'multiply';
Thingy.INCREMENT = 'increment';
Thingy.INCREMENT_AND_MULTIPLY = 'incrementAndMultiply';
Thingy.prototype = {
increment: function(amount) {
var notifier = Object.getNotifier(this);
// Скажем системе, что коллекция работы включает в себя
// переданный тип изменения:
// notifier.performChange('foo', performFooChangeFn);
// notifier.notify('foo', 'fooChangeRecord');
notifier.performChange(Thingy.INCREMENT, function() {
this.a += amount;
this.b += amount;
}, this);
notifier.notify({
object: this,
type: Thingy.INCREMENT,
incremented: amount
});
},
multiply: function(amount) {
var notifier = Object.getNotifier(this);
notifier.performChange(Thingy.MULTIPLY, function() {
this.a *= amount;
this.b *= amount;
}, this);
notifier.notify({
object: this,
type: Thingy.MULTIPLY,
multiplied: amount
});
},
incrementAndMultiply: function(incAmount, multAmount) {
var notifier = Object.getNotifier(this);
notifier.performChange(Thingy.INCREMENT_AND_MULTIPLY, function() {
this.increment(incAmount);
this.multiply(multAmount);
}, this);
notifier.notify({
object: this,
type: Thingy.INCREMENT_AND_MULTIPLY,
incremented: incAmount,
multiplied: multAmount
});
}
}
```
Мы объявляем два наблюдателя для нашего объекта: один для наблюдения за всеми изменениями и другой для отчетов о специфических изменениях, которые мы описали выше(Thingy.INCREMENT, Thingy.MULTIPLY, Thingy.INCREMENT\_AND\_MULTIPLY).
```
var observer, observer2 = {
records: undefined,
callbackCount: 0,
reset: function() {
this.records = undefined;
this.callbackCount = 0;
},
};
observer.callback = function(r) {
console.log(r);
observer.records = r;
observer.callbackCount++;
};
observer2.callback = function(r){
console.log('Observer 2', r);
}
Thingy.observe = function(thingy, callback) {
// Object.observe(obj, callback, optAcceptList)
Object.observe(thingy, callback, [Thingy.INCREMENT,
Thingy.MULTIPLY,
Thingy.INCREMENT_AND_MULTIPLY,
'update']);
}
Thingy.unobserve = function(thingy, callback) {
Object.unobserve(thingy);
}
```
Что ж, теперь мы можем немного поиграться с кодом. Давайте объявим новый Thingy:
```
var thingy = new Thingy(2, 4);
```
Поставим его под наблюдение и сделаем несколько изменений. Охтыжмать, круто!
```
// Наблюдаем за thingy (простите, язык не повернется писать "наблюдаем за рюшечками")
Object.observe(thingy, observer.callback);
Thingy.observe(thingy, observer2.callback);
// Потыкаем методы, которые предоставляет нам thingy
thingy.increment(3); // { a: 5, b: 7 }
thingy.b++; // { a: 5, b: 8 }
thingy.multiply(2); // { a: 10, b: 16 }
thingy.a++; // { a: 11, b: 16 }
thingy.incrementAndMultiply(2, 2); // { a: 26, b: 36 }
```
Всё, что находится внутри «выполняемой функции» будем считать работой с «большим количеством изменений». Наблюдатели, которые принимают «большие изменения» будут получать только их. Оставшиеся наблюдатели будут получать остальные изменения.
#### Наблюдение за массивами
Мы поговорили о наблюдении изменений у объектов, но что насчет массивов? Отличный вопрос! Кстати говоря, каждый раз, когда мне говорят «Отличный вопрос», я никогда не слышу ответ, т.к. слишком сконцентрирован на поздравлении себя с таким удачным вопросом, но мы отвлеклись :) У нас есть новые методы и для работы с массивами!
`Array.observe()` — это метод, который работает с большим количеством изменений самого объекта, например splice, unshift или что-либо другое, что изменяет его длину, как, например, splice.
Для этого он использует `notifier.performChange("splice",...)`
Вот пример того, где мы наблюдаем за моделью «массив» и точно так же получаем назад список изменений, когда над моделью выполняются действия, изменяющие её данные:
```
var model = ['Buy some milk', 'Learn to code', 'Wear some plaid'];
var count = 0;
Array.observe(model, function(changeRecords) {
count++;
console.log('Array observe', changeRecords, count);
});
model[0] = 'Teach Paul Lewis to code';
model[1] = 'Channel your inner Paul Irish';
```
#### Производительность
О вычислительной скорости O.o() можно думать, как о скорости чтения кеша. Вообще говоря, кеш является отличным выбором, когда (в порядке важности):
* Частота чтения выше, чем частота записи
* Когда у вас есть возможность создать кеш, который будет жертвовать временем записи в сторону фиксированного времени на операции чтения
* Постоянное время задержки для операций записи приемлимо
O.o() спроектирован для use-кейсов вроде первого.
Dirty-checking требует держать копии всех данных, за которыми вы наблюдаете. Это значит, что вы получаете просадку по памяти, которую вы никогда не получите с O.o(). Dirty-checking является своего рода затычкой, которая так же создает своего рода ненужную абстракцию, которая в результате создает лишние сложности в приложениях.
Почему? Потому, что dirty-checking запускается каждый раз, когда данные «могли» быть изменены. Это не является надежным способом подобной проверки и имеет существенные недостатки, например, гонку между кодом рендеринга (и т.п.) и вычислительным кодом (ведь все знают, что в JS используется один поток и для интерфейса и для вычислений?). Для dirty-checking так же требуется подключение глобального реестра наблюдателей, создавая тем самым риски утечки памяти и т.п., чего позволяет избежать O.o().
Давайте взглянем на некоторые цифры.
Представленные ниже бенчмарки (доступны на [GitHub](https://github.com/Polymer/observe-js/tree/master/benchmark)) позволяют нам сравни dirty-checking и O.o(). Они представлены в виде графа с абсциссой Observed-Object-Set-Size и ординатой Number-Of-Mutations.
Главные результаты — это то, что производительность dirty-checking'а пропорциональна количеству наблюдаемых объектов, в то время как производительность O.o() пропорциональна кол-ву мутаций, которые мы сделали.
###### Dirty-checking
###### Object.observe()
#### Object.observe() для старых браузеров
Круто, O.o() может быть использован в Chrome 36 beta, но что насчет остальных браузеров? Мы вам поможем. Observe-JS — это полифил для Polymer, который будет использовать нативную реализацию, как только она появится, но он также включает в себя несколько полезных вещей поверх этого. Он предлагает использовать обобщенный взгляд на объекты наблюдения и докладывает об общих изменениях. Вот пара полезных вещей, которые он предлагает:
1) Вы можете наблюдать за «путями». Это означает, что вы можете сказать «эй, я хочу следить за foo.bar.baz» у выбранного объекта и он будет оповещать вас об изменении свойств, как только оно будет происходить. Если путь недоступен, он вернет `undefined`.
Пример наблюдения за значением по пути указанного объекта:
```
var obj = { foo: { bar: 'baz' } };
var observer = new PathObserver(obj, 'foo.bar');
observer.open(function(newValue, oldValue) {
// Оповещаем, что у obj.foo.bar изменилось значение
});
```
2) Он будет оповещать вас об изменении длины массивов. Изменение длины массива в нашем случае — это минимальное количество splice-операций, которые мы должны сделать с массивом, чтобы перевести его из старого состояния в новое (изменившееся).
Пример оповещения о таких изменениях касательно массива, как минимальный набор splice-операций:
```
var arr = [0, 1, 2, 4];
var observer = new ArrayObserver(arr);
observer.open(function(splices) {
// Оповещаем об изменениях элементов массива
splices.forEach(function(splice) {
splice.index; // Позиция элемента, где возникло изменение
splice.removed; // Массив значений, иллюстрирующий последовательность элементов, которые были удалены
splice.addedCount; // Количество элементов, которые были добавлены
});
});
```
#### Фреймворки и Object.observe()
Как мы уже говорили, O.o() дает фреймворкам и библиотекам огромные возможности улучшить производительность их механизма дата-байндинга в браузерах, поддерживающих это нововведение.
Иегуда Кац и Эрик Брин из Ember утвердили поддержку O.o() в ближайших roadmap'ах Ember'а. Миско Херви (из Angular) так же написал в проекте своей документации к Angular 2.0 об улучшении детектирования изменений.
Yehuda Katz and Erik Bryn from Ember confirmed that adding support for O.o() is in Ember's near-term roadmap. Angular's Misko Hervy wrote a design doc on Angular 2.0's improved change detection. Я думаю, что наиболее вероятно ожидать движения в этом направлении, когда эта фича появится в пакете Chrome 36 stable.
#### Итоги
O.o() — мощное нововведение для web платформы, которое вы можете использовать уже сегодня.
Мы надеемся, что это функциональность вскоре появится и в других браузерах, позволяя JavaScript фреймворкам получить некий выигрыш в производительности с новыми нативными возможностями объектов и наблюдением за ними. Помимо Chrome 36, эта функциональность также будет доступна в ближайшем релизе Opera.
Что ж, теперь вы можете идти рассказывать авторам JS фреймворков об Object.observe() и как они могут использовать его, чтобы улучшить их механизм data-binding'а.
Похоже, грядут действительно удивительные времена!
#### Использованные ресурсы:
* [Object.observe() из Harmony wiki](http://wiki.ecmascript.org/doku.php?id=harmony:observe)
* [Data-binding с Object.observe() by Rick Waldron](http://bocoup.com/weblog/javascript-object-observe/)
* [Всё, что вы хотели знать об Object.observe() — JSConf](http://addyosmani.com/blog/the-future-of-data-binding-is-object-observe/)
* [Почему Object.observe() является лучшей фичей ES7](http://georgestefanis.com/blog/2014/03/25/object-observe-ES7.html)
**UPD:** «Биндинг» превратился в «байндинг»
**UPD 2:** Комментарии были переведены на русский
**UPD 3:** Исправил грамматические и пунктуационные ошибки. Спасибо, [Mingun](https://habrahabr.ru/users/mingun/) | https://habr.com/ru/post/225065/ | null | ru | null |
# std::stringstream и форматирование строк
Ввод и вывод информации — критически важная задача, без выполнения которой любая программа становится бесполезной. В **C++** для решения данной задачи традиционно применяются потоки ввода-вывода, которые реализованы в стандартной библиотеке **IOStream**.
Плюсами такого подхода являются:
— универсальность: не важно, с чем связан поток, — ввод-вывод с консоли, файла, сокета, процесса происходит одинаково;
— прозрачность: программисту не нужно явно указывать тип вводимого или выводимого объекта;
— расширяемость: программист может добавить поддержку ввода-вывода в поток для любого своего объекта, просто перегрузив соответствующие операторы.
В библиотеке **IOStream** есть также класс `stringstream`, который позволяет связать поток ввода-вывода со строкой в памяти. Всё, что выводится в такой поток, добавляется в конец строки; всё, что считыватся из потока — извлекается из начала строки.
Он позволяет делать весьма забавные вещи, например, осуществлять преобразование типов:
```
#include
#include
int main(int argc, char\* argv[])
{
std::stringstream ss;
ss << "22";
int k = 0;
ss >> k;
std::cout << k << std::endl;
return 0;
}
```
Кроме того, этот класс можно использовать для форматирования сложных строк, например:
```
void func(int id, const std::string& data1, const std::string& data2)
{
std::stringstream ss;
ss << "Operation with id = " << id << " failed, because data1 (" << data1 << ") is incompatible with data2 (" << data2 << ")";
std::cerr << ss.str();
}
```
Понятно, что в данном случае использование `stringstream` излишне, так как сообщение можно было выводить напрямую в `cerr`. Но что если вы хотите вывести сообщение не в стандартный поток, а использовать, скажем, функцию `syslog()` для вывода сообщения в системный журнал? Или, скажем, сгенерировать исключение, содержащее данную строку как пояснение:
```
void func(int id, const std::string& data1, const std::string& data2)
{
std::stringstream ss;
ss << "Operation with id = " << id << " failed, because data1 (" << data1 << ") is incompatible with data2 (" << data2 << ")";
throw std::runtime_error(ss.str());
}
```
Получается, вам необходим промежуточный объект `stringstream`, в котором вы сначала формируете строку, а затем получаете её с помощью метода `str()`. Согласитесь, громоздко?
**C++** порой винят за его чрезмерную сложность и избыточность, которые, однако, в ряде случаев позволяют создавать весьма изящные конструкции. Вот и сейчас, *шаблоны* и возможность *перегрузки операторов* помогли мне создать обёртку над `stringstream`, которая позволяет форматировать строку в любом месте кода без дополнительных переменных как если бы я просто выводил данные в поток:
```
void func(int id, const std::string& data1, const std::string& data2)
{
throw std::runtime_error(MakeString() << "Operation with id = " << id << " failed, because data1 (" << data1 << ") is incompatible with data2 (" << data2 << ")");
}
```
А вот и сам `MakeString`:
```
class MakeString {
public:
template
MakeString& operator<< (const T& arg) {
m\_stream << arg;
return \*this;
}
operator std::string() const {
return m\_stream.str();
}
protected:
std::stringstream m\_stream;
};
```
Работает это очень просто. С одной стороны, в классе `MakeString` перегружен оператор вывода (<<), который принимает в качестве аргумента константную ссылку на объект любого типа, тут же выводит этот объект в свой внутренний `stringstream` и возвращает ссылку на себя. С другой стороны, перегружен оператор преобразования к строке, который возвращает строку, сформированную `stringstream`'ом.
Быть может, кому-то эта обёртка окажется полезной. Буду рад услышать комментарии, предложения и пожелания. | https://habr.com/ru/post/131977/ | null | ru | null |
# Использование машинного обучения в статическом анализе исходного кода программ
Машинное обучение плотно укоренилось в различных сферах деятельности людей: от распознавания речи до медицинской диагностики. Популярность этого подхода столь велика, что его пытаются использовать везде, где только можно. Некоторые попытки заменить классические подходы нейросетями оканчиваются не столь уж успешно. Давайте взглянем на машинное обучение с точки зрения задач создания эффективных статических анализаторов кода для поиска ошибок и потенциальных уязвимостей.
Команду PVS-Studio часто спрашивают, не хотим ли мы начать использовать машинное обучение для нахождения ошибок в исходном коде программ. Короткий ответ: да, но очень ограниченно. Мы считаем, с применением машинного обучения в задачах анализа кода скрывается много подводных камней. Во второй части статьи мы расскажем про них. А начнём с обзора новых решений и идей.
Новые подходы
-------------
В настоящее время существует уже множество реализаций статических анализаторов, основанных на или использующих машинное обучение, в том числе — глубокое обучение и NLP для обнаружения ошибок. На потенциал машинного обучения при поиске ошибок обратили внимание не только энтузиасты, но и крупные компании, например, Facebook, Amazon или Mozilla. Некоторые проекты не являются полноценными статическими анализаторами, а лишь промежуточно находят некоторые определенные ошибки при коммитах.
Интересно, что почти все позиционируются как game-changer продукты, которые с помощью искусственного интеллекта изменят процесс разработки. 
Рассмотрим некоторые известные примеры:
1. DeepCode
2. Infer, Sapienz, SapFix
3. Embold
4. Source{d}
5. Clever-Commit, Commit Assistant
6. CodeGuru
### DeepCode
Deep Code — инструмент поиска уязвимостей в коде программ, написанных на Java, JavaScript, TypeScript и Python, в котором машинное обучение присутствует в качестве компонента. По заявлению Бориса Паскалева, уже работает более 250 тысяч правил. Этот инструмент обучается на основе изменений, вносимых разработчиками в исходный код открытых проектов (миллион репозиториев). Сама компания говорит, что их проект — это Grammarly для разработчиков.
По сути этот анализатор сравнивает ваше решение со своей базой проектов и предлагает вам предполагаемое наилучшее решение из опыта других разработчиков.
В мае 2018 года разработчики писали, что готовится поддержка языка C++, однако до сих пор этот язык не поддерживается. Хотя на самом сайте и указано, что добавление нового языка можно произвести за считанные недели, благодаря тому, что от языка зависим лишь один этап — парсинг.
Также на сайте опубликована группа публикаций о методах, на которых основан анализатор.
### Infer
Фейсбук достаточно широко старается внедрить новые подходы в своих продуктах. Не обошли они своим вниманием и машинное обучение. В 2013 году они купили стартап, который разрабатывал статический анализатор, основанный на машинном обучении. А в 2015 году исходный код проекта [стал открытым](https://github.com/facebook/infer).
Infer — статический анализатор для проектов, написанных на языках Java, C, C++, и Objective-C, разрабатываемый Фейсбуком. Согласно сайту, он также используется в Amazon Web Services, Oculus, Uber и других популярных проектах.
В настоящее время Infer способен находить ошибки, связанные с разыменовыванием нулевого указателя, утечками памяти. Infer основан на логике Хоара, separation logic и bi-abduction, а также на теории абстрактной интерпретации (abstract interpretation). Использование этих подходов позволяет анализатору разбивать программу на малые блоки (chunks) и анализировать их независимо друг от друга.
Вы можете попробовать использовать Infer и на своих проектах, однако разработчики предупреждают, что, хотя на проектах Facebook полезные срабатывания составляют 80% результатов, на других проектах низкое число ложных срабатываний не гарантируется. Некоторые из ошибок, которые Infer пока что не может находить, но разработчики работают над введением таких срабатываний:
* выход за пределы массива;
* исключения приведения типов;
* утечки непроверенных данных;
* состояние гонки потоков.
### SapFix
SapFix является автоматизированным инструментом внесения правок. Он получает информацию от Sapienz, инструмента для автоматизации тестирования, и статического анализатора Infer, и на основании последних внесенных изменений и сообщениях Infer выбирает одну из нескольких стратегий для исправления ошибок.
В части случаев SapFix откатывает все изменения или их часть. В других случаях он пытается разрешить проблему, генерируя патч из своего набора шаблонов фиксов. Этот набор формируется из шаблонов правок, собранных самими программистами из набора уже произведенных когда-то правок. Если такой шаблон не исправит ошибку, SapFix пытается подстроить шаблон под ситуацию, производя малые модификации в абстрактном синтаксическом дереве, пока потенциальное решение не будет найдено.
Но одного потенциального решения недостаточно, поэтому SapFix собирает несколько решений, которые отбираются на основе трех вопросов: есть ли ошибки компиляции, остается ли падение, не вносит ли правка новых падений. После того, как правки будут полностью протестированы, патчи отправляются на ревью программисту, который примет решение, какая из правок наилучшим образом разрешает проблему.
### Embold
Embold – стартап-платформа для статического анализа исходного кода программ, которая до переименования носила имя Gamma. Статический анализ производится на основе собственных диагностик, а также на базе встроенных анализаторов, таких как Cppсheck, SpotBugs, SQL Check и других.
Кроме самих диагностик акцент делается на возможности наглядного отображения инфографики по нагруженности кодовой базы и удобного просмотра найденных ошибок, а также поиска возможности рефакторинга. Кроме того, в этом анализаторе есть набор анти-паттернов, который позволяет обнаруживать проблемы в структуре кода на уровне классов и методов, и различные метрики для расчета качества системы.
Одним из основных преимуществ заявляется интеллектуальная система предложения решений и правок, которая, в дополнение к обычным диагностикам, проверяет правки на основе информации о предыдущих изменениях.
С помощью NLP Embold разбивает код на части и ищет между ними взаимосвязи и зависимости между функциями и методами, что позволяет сэкономить время рефакторинга.
Таким образом, Embold в основном предлагает удобную визуализацию результатов анализа вашего исходного кода различными анализаторами, а также собственными диагностиками, часть которых основана на машинном обучении.
### Source{d}
Source{d} является наиболее открытым в плане способов своей реализации из рассмотренных нами анализаторов. Также он является решением [с открытым исходным кодом](https://github.com/src-d/sourced-ce). На их сайте можно (в обмен на адрес своей почты) заполучить буклетик с описанием используемых ими технологий. Кроме того, в нём есть [ссылка](https://github.com/src-d/awesome-machine-learning-on-source-code#program-repair-and-bug-detection) на собранную ими базу публикаций, связанную с использованием машинного обучения для анализа кода, а также [репозиторий](https://github.com/src-d/datasets/tree/master/PublicGitArchive) с датасетом для обучения на коде. Сам продукт представляет собой целую платформу анализа исходного кода и программного продукта, и ориентируется, скорее, не на разработчиков, а на звено менеджеров. Среди его возможностей присутствует функционал для выявления объема технического долга, бутылочных горлышек в процессе разработки и другой глобальной статистики по проекту.
Свой подход к анализу кода с помощью машинного обучения они основывают на Natural Hypothesis, сформулированной в статье "[On the Naturalness of Software](https://people.inf.ethz.ch/suz/publications/natural.pdf)".
*«Языки программирования, в теории, являются сложными гибкими и мощными, но программы, которые на самом деле пишут реальные люди, в большинстве своем простые и достаточно повторяющиеся, и, следовательно, в них присутствуют полезные и предсказуемые статистические свойства, которые можно выразить в статистических языковых моделях и использовать для задач разработки программного обеспечения.»*
Исходя из этой гипотезы, чем больше кодовая база для обучения анализатора, тем сильнее выделяются статистические свойства и тем точнее будут достигнутые через обучение метрики.
Для анализа кода в source{d} используется сервис Babelfish, который может распарсить файл с кодом на любом из доступных языков, получить абстрактное синтаксическое дерево и преобразовать его в универсальное синтаксическое дерево.
Однако source{d} не занимается поиском ошибок в коде. На основе дерева с помощью машинного обучения на базе всего проекта, source{d} выявляет то, как код отформатирован, какой стиль кодирования применяется в проекте и при коммите, а если новый код не соответствует код-стайлу проекта — вносит соответствующие правки.
Обучение ориентируется на несколько основных элементов: пробелы, табуляция, переносы строки и т.д.
Подробнее можно почитать об этом в их публикации: "[STYLE-ANALYZER: fixing code style inconsistencies with interpretable unsupervised algorithms](https://arxiv.org/abs/1904.00935)".
В целом, source{d} представляет собой широкую платформу для сбора самой разнообразной статистики по исходному коду и процессу разработки проекта, от расчета эффективности разработчиков до выявления временных затрат на код-ревью.
### Clever-Commit
Clever-Commit – анализатор, созданный Mozilla в сотрудничестве с Ubisoft. Он основан на исследовании [CLEVER](https://static-wordpress.akamaized.net/montreal.ubisoft.com/wp-content/uploads/2018/03/03172129/clever-commit-msr18.pdf) (Combining Levels of Bug Prevention and Resolution Techniques), проведенном Ubisoft, и основанном на нем продукте Commit Assistant, который выявляет подозрительные коммиты, скорее всего содержащие ошибку. Благодаря тому, что CLEVER основан на сравнении кода, он не только указывает на опасный код, но и делает предложения о возможных правках. Согласно описанию, в 60-70% случаев Clever-Commit находит проблемные места и с той же частотой предлагает для них верные правки. В целом, информации об этом проекте и об ошибках, которые он способен находить, немного.
### CodeGuru
А ещё совсем недавно список анализаторов, использующих машинное обучение, пополнился продуктом от Amazon под названием CodeGuru. Это сервис, основанный на машинном обучении, который позволяет находить ошибки в коде, а также выявлять в нем затратные участки. Пока что анализ есть только для Java кода, но пишут о поддержке и других языков в будущем. Хотя он и был анонсирован совсем недавно, СЕО AWS (Amazon Web Services) Энди Джасси говорит, что он уже долгое время используется в самом Амазоне.
На сайте сказано, что обучение проводилось на кодовой базе самого Амазона, а также на более чем 10 000 проектах с открытым исходным кодом.
По сути сервис разделен на две части: CodeGuru Reviewer, обученный с помощью поиска ассоциативных правил и ищущий ошибки в коде, и CodeGuru Profiler, занимающийся мониторингом производительности приложений.
В целом, информации об этом проекте опубликовано не так уж и много. На сайте сказано, что чтобы обучиться ловить отклонения от «лучших практик», Reviewer анализирует кодовые базы Амазона и ищет в них пулл-реквесты, содержащие вызовы API AWS. Далее он просматривает внесенные изменения и сравнивает их с данными из документации, которая анализируется параллельно. В результате получается модель «лучших практик».
Также сказано, что рекомендации для пользовательского кода улучшаются после получения фидбэка по рекомендациям.
Список ошибок, на которые реагирует Reviewer, достаточно размыт, так как конкретной документации по ошибкам не опубликовано:* «Лучшие практики» AWS
* Параллелизм
* Утечки ресурсов
* Утечка конфиденциальной информации
* Общие «лучшие практики» кодирования
Наш скептицизм
--------------
Теперь давайте посмотрим на задачу поиска ошибок глазами нашей команды, которая занимается разработкой статических анализаторов много лет. Мы видим ряд высокоуровневых проблем применения обучения, о которых и хотим рассказать. Но в начале грубо разделим все ML подходы на два типа:
1. Вручную обучить статический анализатор искать различные проблемы, используя синтетические и реальные примеры кода;
2. Обучить алгоритмы на большом количестве открытого исходного кода (GitHub) и истории изменений, после чего анализатор сам начнёт выявлять ошибки и даже предлагать правки.
О каждом направлении мы поговорим отдельно, так как им будут присущи различные недостатки. После чего, думаю, читателям станет понятно, почему мы не отрицаем возможности машинного обучения, но и не разделяем энтузиазм.
**Примечание.** Мы смотрим с позиции разработки универсального статического анализатора общего назначения. Мы нацелены на разработку анализатора, ориентированного не на конкретную кодовую базу, а который может использовать любая команда в любом проекте.
### Обучение статического анализатора «вручную»
Допустим, мы хотим использовать ML для того, чтобы анализатор начал искать в коде аномалии следующего вида:
```
if (A == A)
```
Странно сравнивать переменную саму с собой. Мы можем написать множество примеров корректного и некорректного кода и обучить анализатор искать такие ошибки. Дополнительно, можно добавить в тесты реальные примеры уже найденных ошибок. Вопрос, конечно, где эти примеры взять. Но будем считать, что это возможно. Например, у нас накопилось некоторое количество примеров таких ошибок: [V501](https://www.viva64.com/ru/examples/v501/), [V3001](https://www.viva64.com/ru/examples/v3001/), [V6001](https://www.viva64.com/ru/examples/v6001/).
Итак, можно ли искать такие дефекты в коде, используя алгоритмы машинного обучения? Можно. Только непонятно, зачем это делать!
Смотрите, чтобы обучить анализатор нам потребуется потратить много сил на подготовку примеров для обучения. Или размечать код реальных приложений, указывая, где надо ругаться, а где нет. В любом случае потребуется проделать очень большую работу, так как примеров для обучения должны быть тысячи. Или десятки тысяч.
Ведь мы хотим искать не только случаи (A == A), но и:
* if (X && A == A)
* if (A + 1 == A + 1)
* if (A[i] == A[i])
* if ((A) == (A))
* и так далее.
А теперь давайте посмотрим, как была бы реализована такая простейшая диагностика в PVS-Studio:
```
void RulePrototype_V501(VivaWalker &walker,
const Ptree *left, const Ptree *right, const Ptree *operation)
{
if (SafeEq(operation, "==") && SafeEqual(left, right))
{
walker.AddError("Ой беда, беда!", left, 501, Level_1, "CWE-571");
}
}
```
И всё. Не нужно никакой базы примеров для обучения!
В дальнейшем диагностику следует научить учитывать ряд исключений и понимать, что надо ругаться на (A[0] == A[1-1]). Однако всё это очень легко программируется. А вот как раз с базой примеров для обучения всё будет обстоять плохо.
Отметим, что в обоих случаях ещё потребуется система тестов, написание документации и так далее. Однако трудозатраты по созданию новой диагностики явно на стороне классического подхода, где правило просто жёстко программируется в коде.
Давайте рассмотрим теперь какое-то другое правило. Например, что результат некоторых функций обязательно должен использоваться. Нет смысла их вызывать и при этом не использовать их результат. Вот некоторые такие функции:* malloc
* memcmp
* string::empty
В общем, это то, что делает реализованная в PVS-Studio диагностика [V530](https://www.viva64.com/ru/w/v530/).
Итак, мы хотим искать вызовы таких функций, где результат их работы не используется. Для этого можно сгенерировать множество тестов. И думаем, всё будет хорошо работать. Вот только опять непонятно, зачем это нужно.
Реализация диагностики V530 со всеми исключениями в анализаторе PVS-Studio составляет 258 строк кода, из которых 64 строки являются комментариями. Плюс есть таблица с аннотациями функций, где отмечено, что их результат должен использоваться. Пополнять эту таблицу намного проще, чем создавать синтетические примеры.
Ещё хуже дело будет обстоять с диагностиками, в которых используется анализ потока данных. Например, анализатор PVS-Studio умеет отслеживать значение указателей, что позволяет найти вот такую утечку памяти:
```
uint32_t* BnNew() {
uint32_t* result = new uint32_t[kBigIntSize];
memset(result, 0, kBigIntSize * sizeof(uint32_t));
return result;
}
std::string AndroidRSAPublicKey(crypto::RSAPrivateKey* key) {
....
uint32_t* n = BnNew();
....
RSAPublicKey pkey;
pkey.len = kRSANumWords;
pkey.exponent = 65537; // Fixed public exponent
pkey.n0inv = 0 - ModInverse(n0, 0x100000000LL);
if (pkey.n0inv == 0)
return kDummyRSAPublicKey; // <=
....
}
```
Пример взят из статьи "[Chromium: утечки памяти](https://www.viva64.com/ru/b/0555/)". Если выполнится условие *(pkey.n0inv == 0)*, то происходит выход из функции без освобождения буфера, указатель на который хранится в переменной *n*.
С точки зрения PVS-Studio здесь нет ничего сложного. Анализатор изучил функцию *BnNew* и запомнил, что она возвращает указатель на блок выделенной памяти. В другой функции он заметил, что возможна ситуация, когда буфер не освобождается, а указатель на него теряется в момент выхода из функции.
Работает общий алгоритм отслеживания значений. Не важно, как написан код. Не важно, что ещё есть в функции, не относящееся к работе с указателями. Алгоритм универсален и диагностика V773 находит массу ошибок в различных проектах. Посмотрите сколь различны [фрагменты кода](https://www.viva64.com/ru/examples/v773/), где выявлены ошибки!
Мы не являемся знатоками машинного обучения, но, кажется, здесь будут большие проблемы. Есть невероятное количество способов, как можно написать код с утечками памяти. Даже если машина будет обучена отслеживать значение переменных, потребуется обучить её понимать, что бывают вызовы функций.
Есть подозрение, что потребуется столь большое количество примеров для обучения, что задача становится грандиозной. Мы не говорим, что она нереализуема. Мы сомневаемся, что затраты на создание анализатора окупят себя.
**Аналогия.** На ум приходит аналогия с калькулятором, где вместо диагностик надо программировать арифметические действия. Уверены, можно научить калькулятор на базе ML хорошо складывать числа, введя в него базу знаний про результат операций 1+1=2, 1+2=3, 2+1=3, 100+200=300 и так далее. Как вы понимаете, целесообразность разработки такого калькулятора под большим вопросом (если под это не выделен грант :). Намного более простой, быстрый, точный и надёжный калькулятор можно написать, используя в коде обыкновенную операцию "+".
**Вывод**. Способ будет работать. Но использовать его, на наш взгляд, не имеет практического смысла. Разработка будет более трудоёмкой, а результат менее надёжен и точен, особенно если речь пойдёт о реализации сложных диагностик, основанных на анализе потока данных.
### Обучение на большом количестве открытого исходного кода
Хорошо, с ручными синтетическими примерами мы разобрались, но ведь есть GitHub. Можно отследить историю коммитов и вывести закономерности изменения/исправления кода. Тогда можно указать не только на участки подозрительного кода, но даже, возможно, предложить способ его исправления.
Если остановиться на этом уровне детализации, то всё выглядит хорошо. Дьявол же, как всегда, кроется в деталях. Давайте как раз и поговорим про эти детали.
**Первый нюанс. Источник данных.**
Правки на GitHub достаточно хаотичны и разнообразны. Люди часто ленятся делать атомарные коммиты и вносят в код одновременно сразу несколько правок. Сами знаете, как это бывает: поправили ошибку, а заодно и порефакторили немножко («А вот тут ещё заодно добавлю обработку такого случая...»). Даже человеку потом может быть непонятно, связаны эти правки между собой, или нет.
Встаёт задача, как отличить собственно ошибки от добавления новой функциональности или чего-то ещё. Можно, конечно, посадить 1000 человек вручную размечать коммиты. Люди должны будут указать, что вот здесь ошибку поправили, здесь рефакторинг, здесь новая функциональность, здесь требования поменялись и так далее.
Возможна такая разметка? Возможна. Но обратите внимание, как быстро происходит подмена. Вместо «алгоритм научится сам на базе GitHub» мы уже обсуждаем как озадачить сотни человек на продолжительное время. Трудозатраты и стоимость создания инструмента резко возрастают.
Можно попытаться выявить автоматически, где именно исправлялись ошибки. Для этого следует анализировать комментарии к коммитам, обращать внимание на небольшие локальные правки, которые, скорее всего, являются именно правкой ошибки. Затрудняюсь сказать, насколько хорошо можно автоматически искать правки ошибок. В любом случае, это большая задача, требующая отдельного исследования и программирования.
Итак, мы ещё не добрались до обучения, а уже есть нюансы :).
**Второй нюанс. Отставание в развитии.**
Анализаторы, которые будут обучаться на основании таких баз, как GitHub, всегда будут подвержены такому синдрому, как «задержка психического развития». Это связано с тем, что языки программирования изменяются со временем.
В C# 8.0 [появились](https://www.viva64.com/ru/b/0631/) Nullable Reference типы, помогающие бороться с Null Reference Exception'ами (NRE). В JDK 12 появился новый оператор switch ([JEP 325](https://openjdk.java.net/jeps/325)). В C++17 появилась возможность выполнять условные конструкции на этапе компиляции ([constexpr if](https://www.bfilipek.com/2018/03/ifconstexpr.html)). И так далее.
Языки программирования развиваются. Причем такие, как C++, очень быстро и активно. В них появляются новые конструкции, добавляются новые стандартные функции и так далее. Вместе с новыми возможностями появляются и новые паттерны ошибок, которые тоже хотелось бы выявлять с помощью статического анализа кода.
И здесь у рассматриваемого метода обучения проблема: паттерн ошибки может быть уже известен, есть желание его выявлять, но учить ещё не на чем.
Давайте рассмотрим эту проблему на каком-то конкретном примере. В C++11 появился Range-based for loop. И можно написать следующий код, перебирающий все элементы в контейнере:
```
std::vector numbers;
....
for (int num : numbers)
foo(num);
```
Новый цикл принёс с собой и новый паттерн ошибки. Если внутри цикла изменить контейнер, то это приведёт к инвалидации «теневых» итераторов.
Рассмотрим следующий некорректный код:
```
for (int num : numbers)
{
numbers.push_back(num * 2);
}
```
Компилятор превратит его в нечто подобное:
```
for (auto __begin = begin(numbers), __end = end(numbers);
__begin != __end; ++__begin) {
int num = *__begin;
numbers.push_back(num * 2);
}
```
При операции *push\_back* может произойти инвалидация итераторов *\_\_begin* и *\_\_end*, если произойдёт реаллокация памяти внутри вектора. Результатом будет неопределённое поведение программы.
Итак, паттерн ошибки давно известен и описан в литературе. Анализатор PVS-Studio диагностирует его с помощью диагностики [V789](https://www.viva64.com/ru/w/v789/) и уже находил [реальные ошибки](https://www.viva64.com/ru/examples/v789/) в открытых проектах.
Как скоро на GitHub наберётся достаточно нового кода, чтобы заметить такую закономерность? Хороший вопрос… Надо понимать, что если появился range-based for loop, это не означает, что все программисты сразу начали его массово использовать. Могут пройти годы, прежде чем появится много кода, использующего новый цикл. Более того, должно быть совершено множество ошибок, а потом они должны быть поправлены, чтобы алгоритм смог заметить закономерность в правках.
Сколько должно пройти лет? Пять? Десять?
Десять — это слишком много, и мы пессимисты? Отнюдь. К моменту написания статьи прошло уже восемь лет, как в C++11 появился range-based for loop. Но пока в нашей базе выписано только [три случая](https://www.viva64.com/ru/examples/v789/) такой ошибки. Три ошибки — это не много и не мало. Из их количества не следует делать какой-то вывод. Главное, можно подтвердить, что такой паттерн ошибки реален и есть смысл его обнаруживать.
Теперь сравним это количество, например, вот с этим паттерном ошибки: [указатель разыменовывается до проверки](https://www.viva64.com/ru/examples/v595/). Всего при проверке open-source проектов мы уже выявили 1716 подобных случаев.
Возможно, вообще не стоит искать ошибки range-based for loop? Нет. Просто программисты инерционны, и этот оператор очень неспеша приобретает популярность. Постепенно кода с его участием станет много, и ошибок, соответственно, тоже станет больше.
Произойдёт это, по всей видимости, лишь спустя 10-15 лет с момента появления C++11. И теперь философский вопрос. Уже зная паттерн ошибки, мы будем просто ждать многие годы, пока накопится много ошибок в открытых проектах?
Если ответ — «да», то тогда можно заранее обоснованно поставить всем анализаторам на базе ML диагноз «задержка психического развития».
Если ответ — «нет», то как быть? Примеров нет. Писать их вручную? Но тогда мы возвращается к предыдущей главе, где мы рассматривали написание человеком множества примеров для обучения.
Такое можно сделать, но вновь встаёт вопрос целесообразности. Реализация диагностики V789 со всеми исключениями в анализаторе PVS-Studio составляет всего 118 строк кода, из которых 13 строк являются комментариями. Т.е. это очень простая диагностика, которую можно легко взять и запрограммировать классическим способом.
Аналогичная ситуация будет с любыми другими нововведениями, появляющимися в любых других языках. Как говорится, есть над чем подумать.
**Третий нюанс. Документация.**
Важной составляющей любого статического анализатора является документация, описывающая каждую диагностику. Без неё использовать анализатор будет крайне сложно или вообще невозможно. В [документации](https://www.viva64.com/ru/w/) к PVS-Studio у нас есть описание каждой диагностики, где приводится пример ошибочного кода и как его исправить. Также приводится ссылка на [CWE](https://cwe.mitre.org/), где можно прочитать альтернативное описание проблемы. И всё равно, иногда пользователям бывает что-то непонятно, и они задают нам уточняющие вопросы.
В случае статических анализаторов, которые строятся на алгоритмах машинного обучения, вопрос документации как-то замалчивается. Предполагается, что анализатор просто укажет на место, которое кажется ему подозрительным и, возможно, даже предложит как его исправить. Решение вносить правку или нет остаётся за человеком. И во тут… кхм… Непросто принять решение, не имея возможности прочитать, на основании чего анализатору кажется подозрительным то или иное место в коде.
Конечно, в ряде случаев всё будет очевидно. Предположим, анализатор укажет вот на этот код:
```
char *p = (char *)malloc(strlen(src + 1));
strcpy(p, src);
```
И предложит заменить его на:
```
char *p = (char *)malloc(strlen(src) + 1);
strcpy(p, src);
```
Сразу понятно, что программист опечатался и прибавил 1 не туда, куда надо. В результате чего памяти будет выделено меньше необходимого.
Тут и без документации всё понятно. Однако так будет далеко не всегда.
Представьте, что анализатор «молча» указывает на этот код:
```
char check(const uint8 *hash_stage2) {
....
return memcmp(hash_stage2, hash_stage2_reassured, SHA1_HASH_SIZE);
}
```
И предлагает изменить тип возвращаемого значения с сhar на int:
```
int check(const uint8 *hash_stage2) {
....
return memcmp(hash_stage2, hash_stage2_reassured, SHA1_HASH_SIZE);
}
```
Документации для предупреждения нет. Да и видимо самого текста у предупреждения, как мы понимаем, тоже не будет, если мы говорим про полностью самостоятельный анализатор.
Что делать? В чём разница? Стоит ли делать такую замену?
В принципе, здесь можно будет рискнуть и согласиться исправить код. Хотя соглашаться на правки без их понимания, это так себе практика… :) Можно заглянуть в описание функции [*memcmp*](http://www.cplusplus.com/reference/cstring/memcmp/) и прочитать, что функция действительно возвращает значения типа *int*: 0, больше нуля и меньше нуля. Но всё равно может быть непонятно, зачем вносить правки, если код сейчас и без того успешно работает.
Теперь, если вы не знаете, в чём смысл такой правки, ознакомьтесь с описанием диагностики [V642](https://www.viva64.com/ru/w/v642/). Сразу становится понятным, что это самая настоящая ошибка. Более того, она может стать причиной уязвимости.
Возможно, пример показался неубедительным. Ведь анализатор предложил код, который, скорее всего, будет лучше. Ok. Давайте рассмотрим другой пример псевдокода, на этот раз, для разнообразия, на языке Java.
```
ObjectOutputStream out = new ObjectOutputStream(....);
SerializedObject obj = new SerializedObject();
obj.state = 100;
out.writeObject(obj);
obj.state = 200;
out.writeObject(obj);
out.close();
```
Есть какой-то объект. Он сериализуется. Затем состояние объекта меняется, и он вновь сериализуется. Вроде всё хорошо. Теперь представим, что анализатору, вдруг, этот код не нравится, и он предлагает заменить его на:
```
ObjectOutputStream out = new ObjectOutputStream(....);
SerializedObject obj = new SerializedObject();
obj.state = 100;
out.writeObject(obj);
obj = new SerializedObject(); // Добавилась эта строка
obj.state = 200;
out.writeObject(obj);
out.close();
```
Вместо изменения объекта и его повторной записи, создаётся новый объект и уже он сериалиузется.
Описания проблемы нет. Документации нет. Код стал длиннее. Зачем-то добавлено создание нового объекта. Вы готовы сделать в своём коде такую правку?
Вы скажете, что непонятно. Действительно, непонятно. И так будет непонятно постоянно. Работа с таким «молчаливым» анализатором станет бесконечным исследованием в попытке понять, почему анализатору что-то не нравится.
Если же есть документация, то всё становится прозрачно. Класс *java.io.ObjectOuputStream*, который используется для сериализации, кэширует записываемые объекты. Это означает, что один и тот же объект не будет сериализован дважды. Один раз класс сериализует объект, а во второй раз просто запишет в поток ссылку на тот же самый первый объект. Подробнее: [V6076](https://www.viva64.com/ru/w/v6076/) — Recurrent serialization will use cached object state from first serialization.
Надеемся, нам удалось объяснить важность наличия документации. А теперь вопрос. Как появится документация для анализатора, построенного на базе ML?
Когда разрабатывается классический анализатор кода, то здесь всё просто и понятно. Есть некий паттерн ошибок. Мы его описываем в документации и реализуем диагностику.
В случае ML всё наоборот. Да, анализатор может заметить аномалию в коде и указать на неё. Но он ничего не знает о сути дефекта. Он не понимает и не расскажет, почему же так нельзя писать код. Это слишком высокоуровневые абстракции. Тогда уж анализатору надо заодно научиться читать и **понимать** документацию для функций.
Как я уже сказал, поскольку тема документации обходится в статьях по машинному обучению, мы не готовы рассуждать дальше. Просто ещё один большой нюанс, который мы вынесли на обозрение.
**Примечание**. Можно возразить, что документация не обязательна. Анализатор может привести отсылки к множеству примеров исправления на GitHub и человек, просматривая коммиты и комментарии к ним, разберётся что к чему. Да, это так. Но идея не выглядит привлекательной. Анализатор по-прежнему вместо помощника выступает в качестве инструмента, который ещё больше будет озадачивать программиста.
**Четвёртый нюанс. Узкоспециализированные языки.**
Описываемый подход не применим для узкоспециализированных языков, для которых статический анализ также может быть крайне полезен. Причина в том, что на GitHub и других источниках просто не наберётся достаточно большой базы исходных кодов, чтобы проводить эффективное обучение.
Рассмотрим это на конкретном примере. Для начала зайдём на GitHub и выполним поиск репозиториев для популярного языка Java.
Результат: language:«Java»: **3,128,884** available repository results
Теперь возьмём специализированный язык «1C Enterprise», используемый в бухгалтерских приложениях, выпускаемых российской компанией [1C](https://ru.wikipedia.org/wiki/1%D0%A1).
Результат: language:«1C Enterprise»: **551** available repository results
Быть может анализаторы для этого языка не нужны? Нужны. Имеется практическая потребность в анализе таких программ и уже существуют соответствующие анализаторы. Например, существует SonarQube 1C (BSL) Plugin, выпускаемый компанией "[Серебряная Пуля](https://silverbulleters.org/)".
Думаю, каких-то специальных пояснений не требуется, почему подход с машинным обучением будет затруднителен для специализированных языков.
**Пятый нюанс. C, C++, #include**.
Статьи, посвящённые исследованиям в области статического анализа кода на базе ML, тяготеют к таким языкам, как Java, JavaScript, Python. Объясняют это их крайней популярностью. А вот языки C и C++ как-то обходят стороной, хотя их точно нельзя назвать непопулярными.
У нас есть гипотеза, что дело не в популярности/перспективности, а в том, что с языками C и C++ есть проблемы. И сейчас мы «вытащим» одну неудобную проблему на обозрение.
Абстрактный c/cpp-файл бывает очень непросто скомпилировать. По крайней мере, не получится выкачать проект с GitHub, выбрать какой-то cpp-файл и просто его скомпилировать. Сейчас мы поясним, какое отношение всё это имеет к ML.
Итак, мы хотим обучать анализатор. Мы скачали с GitHub проект. Мы знаем патч и предполагаем, что он исправляет ошибку. Мы хотим, чтобы эта правка стала одним из примеров для обучения. Другим словами, у нас есть .cpp-файл до правки и после правки.
Вот здесь и начинается проблема. Недостаточно просто изучить исправления. Необходимо иметь полный контекст. Необходимо знать описание используемых классов, необходимо знать прототипы используемых функций, нужно знать как раскрываются макросы и так далее. А для этого нужно выполнить полноценное [препроцессирование](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D0%BE%D1%80_%D0%A1%D0%B8) файла.
Рассмотрим пример. Вначале код выглядел так:
```
bool Class::IsMagicWord()
{
return m_name == "ML";
}
```
Его исправили так:
```
bool Class::IsMagicWord()
{
return strcmp(m_name, "ML") == 0;
}
```
Следует ли на основании этого случая начинать учиться, чтобы в дальнейшем предлагать заменять *(x == «y»)* на strcmp(x, «y»)?
На этот вопрос нельзя дать ответ, не зная, как объявлен член *m\_name* в классе. Могут быть, например, такие варианты:
```
class Class {
....
char *m_name;
};
class Class {
....
std::string m_name;
};
```
Правки будут вноситься в том случае, если речь идёт об обыкновенном указателе. Если не учитывать тип переменной, можно научиться вместе с полезными предупреждениями выдавать и вредные (для случая *std::string*).
Объявления классов, как правило, находятся в заголовочных .h файлах. Вот мы и подошли к необходимости выполнять препроцессирование, чтобы иметь всю необходимую информацию. Это очень, очень важно для C и C++.
Если кто-то скажет, что можно обойтись без препроцессирования, то он или шарлатан, или просто недостаточно знаком с языками C или C++.
Чтобы собрать всю необходимую информацию, нужно правильно выполнить препроцессирование. Для этого нужно знать, где и какие заголовочные файлы находятся, какие макросы задаются в процессе сборки. Для этого нужно знать, как собирается конкретный cpp-файл.
В этом и состоит проблема. Нельзя просто взять и скомпилировать файл (вернее, указать ключ компилятору, чтобы он сгенерировал препроцессированный файл). Нужно разобраться, как этот файл компилируется. Эта информация есть в скриптах сборки, но вот как её оттуда достать, в общем случае задача крайне сложная.
Более того, во многих проектах на GitHub царит бардак. Если взять оттуда абстрактный проект, то часто приходится повозиться, чтобы его скомпилировать. То не хватает какой-то библиотеки и её надо найти и скачать вручную. То используется какая-то самописная сборочная система, с которой надо разбираться. Может быть всё что угодно. Иногда скачанный проект в принципе отказывается собираться и его нужно «дорабатывать напильником». Нет никакой и речи, чтобы просто взять проект, и автоматически получить для .cpp файлов их препроцессированное (.i) представление. Даже вручную это бывает сделать сложно.
Можно сказать, хорошо, проблема с несобирающимися проектами понятна, но не страшна. Давайте работать только с теми проектами, которые можно собрать. Всё равно остаётся задача препроцессирования конкретного файла. И уж промолчим про те случаи, когда будут использоваться какие-то специализированные компиляторы, например, для встраиваемых систем.
В целом, описанная проблема не является непреодолимой. Однако всё это в любом случае очень сложно и трудозатратно. В случае C и C++ исходные коды, лежащие на GitHub, сами по себе ничего не дают. Нужно проделать колоссальную работу, чтобы научиться автоматически запускать компиляторы.
**Примечание**. Если читателю всё равно непонятна проблематика, то предлагаем ему провести следующий эксперимент. Возьмите с GitHub десять произвольных C++ проектов среднего размера и попробуйте их скомпилировать, а потом получить для .cpp файлов их препроцессированный вариант. После этого вопрос про трудоёмкость этой задачи отпадёт :).
С другими языками могут быть похожие проблемы, но в C и C++ они особенно выражены.
**Шестой нюанс. Цена устранения ложных срабатываний.**
Статические анализаторы склонны к генерации ложных срабатываний и приходится постоянно дорабатывать диагностики, чтобы сократить их количество.
Вернёмся к уже рассмотренной ранее диагностике [V789](https://www.viva64.com/ru/w/v789/), выявляющей изменения контейнера внутри Range-based for loop. Допустим, мы были недостаточно тщательны при её разработке, и клиент сообщает про ложное срабатывание. Он пишет, что анализатор не учитывает сценарий, когда после модификации контейнера цикл завершается, и поэтому никакой беды нет. И приводит следующий пример кода, где анализатор выдаёт ложное срабатывание:
```
std::vector numbers;
....
for (int num : numbers)
{
if (num < 5)
{
numbers.push\_back(0);
break; // или, например, return
}
}
```
Да, это недоработка. В классическим анализаторе её устранение крайне быстро и дёшево. В PVS-Studio реализация этого исключения состоит из 26 строк кода.
Эту недоработку можно устранить и в случае, когда анализатор построен на алгоритмах обучения. Наверняка, его можно доучить, составив десятки или сотни примеров кода, который должен считаться корректным.
Здесь вновь вопрос не в реализуемости, а в практичности. Есть подозрение, что борьба с конкретными ложными срабатываниями, которые беспокоят клиентов, намного более затратна в случае ML. Т.е. поддержка клиентов в плане устранения ложных срабатываний будет стоить больше денег.
**Седьмой нюанс. Редко используемые функции и длинный хвост.**
Ранее рассматривалась проблема узкоспециализированных языков, для которых может оказаться недостаточно исходного кода для обучения. Аналогичная проблема с редко используемыми функциями (системными, WinAPI, из популярных библиотек и т.д.).
Если речь идёт о таких функциях языка C, как *strcmp*, то здесь есть почва для обучения. GitHub, available code results:
* strcmp — 40,462,158
* stricmp — 1,256,053
Да, примеров использования много. Возможно, анализатор научится замечать, например, следующие закономерности:* Странно, если строка сравнивается сама собой. Это исправляют.
* Странно, если один из указателей NULL. Это исправляют.
* Странно, что результат работы этой функции не используют. Это исправляют.
* И так далее.
Всё великолепно? Нет. Здесь мы сталкиваемся с «длинным хвостом». Совсем кратко суть «длинного хвоста» в следующем. Непрактично продавать в книжном магазине только Top50 наиболее популярных и читаемых сейчас книг. Да, каждая такая книга будет приобретаться, скажем, в 100 раз чаще, чем книги не из этого списка. Однако большую часть выручки составят другие книги, которые, как говорится, находят своего читателя. Например, интернет-магазин Amazon.com получает более половины прибыли с того, что находится за пределами 130 тысяч «наиболее популярных наименований».
Есть популярные функции и их мало. Есть непопулярные, но их много. Например, существуют ещё вот такие разновидности функции сравнения строк:
* g\_ascii\_strncasecmp — 35,695
* lstrcmpiA — 27,512
* \_wcsicmp\_l — 5,737
* \_strnicmp\_l — 5,848
* \_mbscmp\_l — 2,458
* и т.д.
Как видите, они используются гораздо реже, но при их использовании можно допустить всё те же ошибки. Для выявления закономерностей примеров слишком мало. Однако и игнорировать эти функции нельзя. По отдельности они используются редко, но в сумме с их использованием написано много кода, который полезно проверять. Здесь как раз и проявляет себя «длинный хвост».
В PVS-Studio мы вручную аннотируем функции. Например, для C и С++ на данный момент размечено около 7200 функций. Разметке подвергается:
* WinAPI
* стандартная библиотека C,
* стандартная библиотека шаблонов (STL),
* glibc (GNU C Library)
* Qt
* MFC
* zlib
* libpng
* OpenSSL
* и т.д.
С одной стороны, это кажется тупиковым способом. Невозможно всё проаннотировать. С другой стороны, это работает.
Теперь вопрос. Какие преимущества может дать ML? Существенные преимущества не видны, зато видны сложности.
Можно сказать, что алгоритмы, построенные на ML, сами выявят закономерности с часто используемыми функциями и их не придётся размечать. Да, это правда. Однако нет никакой проблемы самостоятельно разметить такие популярные функции, как *strcmp* или *malloc*.
C длинным же хвостом начинаются проблемы. Можно обучать, составляя синтетические примеры. Однако здесь мы возвращаемся к разделу статьи, где рассматривали, что тогда проще и быстрее писать классические диагностики, а не генерировать множество примеров.
Возьмём для примера такую функцию, как [*\_fread\_nolock*](https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/fread-nolock). Конечно, она используется реже, чем *fread*. Но при её использовании можно допустить все те же ошибки. Например, буфер должен быть достаточного размера. Этот размер должен быть не меньше, чем результат умножения второго и третьего аргумента. То есть хочется обнаруживать вот такой некорректный код:
```
int buffer[10];
size_t n = _fread_nolock(buffer, size_of(int), 100, stream);
```
Вот как выглядит аннотирование этой функции в PVS-Studio:
```
C_"size_t _fread_nolock"
"(void * _DstBuf, size_t _ElementSize, size_t _Count, FILE * _File);"
ADD(HAVE_STATE | RET_SKIP | F_MODIFY_PTR_1,
nullptr, nullptr, "_fread_nolock", POINTER_1, BYTE_COUNT, COUNT,
POINTER_2).
Add_Read(from_2_3, to_return, buf_1).
Add_DataSafetyStatusRelations(0, 3);
```
На первый взгляд подобная аннотация может выглядеть сложно, но, на самом деле, когда начинаешь их писать, это становится просто. Плюс надо учитывать, что это write-only код. Написал и забыл. Аннотации меняются редко.
Теперь поговорим про эту функцию с точки зрения ML. GitHub нам не поможет. Находится около 15000 упоминаний этой функции. Толкового кода там ещё меньше. Существенную часть результатов поиска занимает подобное:
```
#define fread_unlocked _fread_nolock
```
Какие есть варианты?
1. Ничего не делать. Это путь в никуда.
2. Обучать анализатор, написав сотни примеров только для одной этой функции, чтобы анализатор понял взаимосвязь между размером буфера и другими аргументами. Да, так поступить можно, но это экономически нерационально. Это путь в никуда.
3. Можно придумать способ, аналогичный нашему, когда аннотации к функциям будут задаваться вручную. Хороший, разумный способ. Вот только ML тогда тут вообще ни при чём :). Это возврат к классическому способу написания статических анализаторов.
Как видите, ML и длинный хвост из редко используемых функций не сочетаются.
Здесь люди, связанные с тематикой ML, нам возражали и говорили, что мы не учитываем вариант, когда анализатор изучит функции и сделает выводы, что они делают. Тут, видимо, или мы не понимаем экспертов, или они не понимают нас.
Тела функций могут быть неизвестны. Например, это может быть функция, относящаяся к WinAPI. Если это редко используемая функция, то как анализатор поймёт, что она делает? Мы можем фантазировать, что анализатор во время обучения сам воспользуется Google, найдёт описание функции, прочитает и **поймёт его**. Более того, нужно сделать высокоуровневые выводы из документации. В описании [*\_fread\_nolock*](https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/fread-nolock)нигде не говорится про взаимосвязь между размером буфера, вторым и третьим аргументом. Это сопоставление надо вывести искусственному интеллекту самостоятельно, основываясь на понимании общих принципов программирования и том, как работает язык C++. Думается, что всерьёз над всем этим можно будет подумать лет так через 20.
Тела функций могут быть доступны, но толку от этого может не быть. Рассмотрим такую функцию, как *memmove*. Она часто реализуется как-то так:
```
void *memmove (void *dest, const void *src, size_t len) {
return __builtin___memmove_chk(dest, src, len, __builtin_object_size(dest, 0));
}
```
А что такое *\_\_builtin\_\_\_memmove\_chk*? Это intrinsic функция, которую реализует уже сам компилятор. Исходного кода у этой функции нет.
Или *memmove* может выглядеть как-то так: [первый попавшийся вариант на ассемблере](https://github.com/esialb/yocto-3.10-edison/blob/624014e385e6ab4a62f74e60573502b647cf3330/arch/mn10300/lib/memmove.S). Можно учить анализатор понимать ещё и разные варианты ассемблера, но что-то это не то.
Ok, иногда тела функций действительно известны. Более того, ведь известны и тела функций в пользовательском коде. Казалось бы, в этом случае ML получает колоссальные преимущества, читая и разбираясь в том, что делают все эти функции.
Однако и в этом случае мы полны пессимизма. Эта задача слишком сложна. Она для человека и то сложна. Вспомните, с каким трудом вам приходится разбираться в коде, написанном не вами. Если это сложно человеку, почему эта задача должна быть легка для AI? Собственно, у AI большая проблема в том, чтобы осознать высокоуровневые понятия. Если же мы говорим о понимании кода, то не обойтись без умения абстрагироваться от деталей реализации и рассматривать алгоритм на высоком уровне. Думается, что и здесь лет на 20 можно отложить обсуждение.
**Прочие нюансы**
Существуют и другие моменты, которые тоже следует принимать во внимание, но над которыми мы внимательно не думали. Да и статья уже затянулась. Поэтому бегло перечислим ещё некоторые нюансы, оставив их для размышления читателю.* **Устаревшие рекомендации**. Как уже говорилось, языки меняются, меняются и рекомендации по их использованию. В случае обучения на коллекциях старого исходного кода может возникнуть ситуация, когда анализатор в какой-то момент будет выдавать устаревшие рекомендации. Пример. Раньше C++ программистам рекомендовалось вместо сырых указателей перейти к использованию [*auto\_ptr*](http://www.cplusplus.com/reference/memory/auto_ptr/). Теперь этот умный указатель считается устаревшим и рекомендуется использовать *unique\_ptr*.
* **Модели данных**. Как минимум, в языках C и C++ существует такое понятие, как [модель данных](https://www.viva64.com/ru/t/0012/). Это означает, что типы данных имеют различную разрядность на различных платформах. Если это не учитывать, то можно неверно обучить анализатор. Например, тип *long* в Windows 32/64 всегда имеет разрядность 32 бита. А вот в Linux его размер будет меняться и занимать 32/64 бита в зависимости от разрядности платформы. Не учитывая всё это, анализатор может научиться неправильно считать размеры типов и образуемых им структур. А ведь типы ещё и выравниваются по-разному. Всё это, конечно, можно учесть. Можно научить анализатор знать про размеры типов, их выравнивание и разметить проекты (указать как они собираются). Однако всё это дополнительная сложность, про которую нет упоминаний в исследовательских статьях.
* **Однозначность поведения**. Раз мы говорим про ML, то результат анализа, скорее всего, будет иметь вероятностный характер. Т.е. иногда ошибочный паттерн будет распознаваться, а иногда — нет, в зависимости от того, как написан код. По нашему опыту мы знаем, что пользователя крайне раздражает неоднозначность поведения анализатора. Он хочет точно понимать, какой паттерн будет считаться ошибочным, а какой — нет, и почему. В случае классического подхода написания анализаторов эта проблема выражена слабо. Только иногда нам приходится объяснять клиентам, почему вот здесь есть/нет срабатывания анализатора, объясняя, как работает алгоритм, и обработка каких исключений в него заложена. Алгоритмы чётки и всегда всё можно легко пояснить. Пример подобного общения: "[Ложные срабатывания в PVS-Studio: как глубока кроличья нора](https://www.viva64.com/ru/b/0612/)". Как будут решать описанную проблему в анализаторах, построенных на обучении, непонятно.
Выводы
------
Мы не отрицаем перспективности направления машинного обучения, в том числе, в задачах статического анализа кода. Есть потенциал использовать ML в задачах поиска опечаток, при фильтрации ложных сообщений, в поиске новых (ещё нигде не описанных) паттернов ошибок и так далее. Однако мы совершенно не разделяем и оптимизм, которыми пропитаны статьи, посвящённые ML в задачах анализа кода.
В статье мы описали несколько проблем, над которыми придётся работать, если брать за основу ML. Описанные нюансы во многом сводят на нет преимущества от нового подхода, более того, старые классические подходы имплементации анализаторов оказываются более выигрышными и более экономически целесообразными.
Что интересно, в статьях приверженцев методологии ML про эти подводные камни не говорится. Впрочем, это не удивительно. Тема ML сейчас является слишком «хайповой» и странно ждать от её апологетов взвешенных оценок её применимости в задачах статического анализа кода.
С нашей точки зрения, машинное обучение займёт свою нишу в технологиях, используемых в статических анализаторах, наряду с анализом потоков управления, символьными вычислениями и так далее.
Методология статического анализа может получить пользу от внедрения ML, но не стоит преувеличивать возможности этой технологии.
P.S.
----
Поскольку статья носит в целом критический характер, то кто-то может подумать, что мы опасаемся нового и как [луддиты](https://ru.wikipedia.org/wiki/%D0%9B%D1%83%D0%B4%D0%B4%D0%B8%D1%82%D1%8B) ополчились против ML, боясь потерять рынок инструментов статического анализа.
Нет, мы не боимся. Просто мы не видим смысла тратить деньги на неэффективные подходы в развитии анализатора кода PVS-Studio. В том или ином виде мы возьмём на вооружение ML. Более того, некоторые диагностики уже содержат в себе элементы самообучающихся алгоритмов. Однако мы точно будем очень консервативны и брать только то, что явно даст больший эффект, чем классические подходы, построенные на циклах и if-ах :). Ведь нам надо создавать эффективный инструмент, а не отрабатывать грант :).
Статья же написана по той причине, что по рассмотренной теме задают всё больше вопросов и захотелось иметь статью-ответ, расставляющую всё по своим местам.
Спасибо за внимание. И предлагаем познакомиться со статьёй "[Причины внедрить в процесс разработки статический анализатор кода PVS-Studio](https://www.viva64.com/ru/b/0687/)".
[](https://habr.com/en/company/pvs-studio/blog/484202/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov, Victoria Khanieva. [Machine Learning in Static Analysis of Program Source Code](https://habr.com/en/company/pvs-studio/blog/484202/). | https://habr.com/ru/post/484208/ | null | ru | null |
# Бесшовные A/B-обновления в Android: как они устроены
Всем привет. В SberDevices наша команда занимается разработкой различных железок и прошивок для них на базе AOSP.
Начиная с Android 8 (у некоторых вендоров с 7.1) в системе появился новый механизм накатки OTA-обновлений, т. н. Seamless A/B OTA Updates — бесшовные обновления. В этом посте я опишу общие принципы его работы, рассмотрю механизм с точки зрения разработчика, а также проведу сравнение со старым (будем его называть recovery-based) подходом применения обновлений. Всё нижесказанное будет справедливо только для чистого AOSP, т. к. конкретная реализация зависит от вендора.
Recovery-based OTA
------------------
Обновления для Android поставляются в виде zip-архива с образами обновляемых разделов (block-based updates). Во времена KitKat это был просто набор файлов, которые копировались на устройство прилагаемым скриптом. Я не стану подробно останавливаться на [этом режиме](https://source.android.com/devices/tech/ota/nonab), кратко опишу основные принципы его работы:
* zip-архив скачивается системой на устройство;
* система перезагружается в режим *recovery*;
* проверяется совместимость обновления с устройством, его подпись;
* если всё OK, выполняется *updater-script* из zip-архива;
* в процессе обновления устройство может несколько раз перезагрузиться (например, для обновления *device tree*);
* если всё прошло успешно, загружаемся в новую прошивку.
Какие минусы в данной схеме?
* Необходимость резервировать достаточное количество встроенной памяти для OTA-архива. Для этого служит раздел */cache*. Некоторые вендоры используют */data*, но это редкость. В итоге пользователю остаётся меньше места (да, приложения всё ещё могут использовать место в разделе */cache*, но с некоторыми ограничениями).
* Перезагрузка и применение обновления занимает время, что может быть критично для некоторых видов устройств, например, для Smart TV.
* Прерывание процесса обновления может привести к *boot loop*.
* Нет возможности откатиться на старую версию прошивки.
Эти неудобства позволяет обойти способ бесшовного обновления. Давайте посмотрим, как он устроен.
Seamless A/B OTA
----------------
Ключевые компоненты и механизмы, необходимые для реализации [бесшовных A/B-обновлений](https://source.android.com/devices/tech/ota/ab):
* слотовая разметка флеш-памяти;
* взаимодействие с загрузчиком, управление состоянием *слотов*;
* системный демон *update\_engine*;
* генерация zip-архива с обновлением. В рамках данной статьи этот аспект рассматриваться не будет.
### Слотирование
Основным принципом работы A/B OTA является *слотирование*. Все разделы, которые необходимо обновлять (это могут быть любые разделы, а не только системные), должны находиться в двух копиях или, иначе, в слотах. В Android-реализации поддерживается 2 слота, которые именуются соответственно *A* и *B*. Система загружается и работает из текущего слота, второй используется только в момент обновления. К имени раздела добавляется суффикс с именем слота.
Ниже приведена таблица сравнения двух вариантов организации разделов на устройстве.
[](https://habrastorage.org/webt/0h/5o/fz/0h5ofzon-7tbjo-yu09aiwzimpc.png)
Все слотируемые разделы помечаются опцией монтирования *slotselect*, чтобы система могла выбрать правильный слот. В зависимости от того, где они описаны, это может быть *fstab* либо *dts*.
### Изменения в таблице разделов
* В */сache* больше нет необходимости. Теперь обновление может сохраняться либо в */data*, либо сразу прошиваться в неактивный слот (об этом ниже).
* Раздел *recovery* также больше не используется. Однако **режим** *recovery* всё ещё существует, он необходим, например, для сброса устройства на заводские настройки (к этому может привести [rescue party](https://source.android.com/devices/tech/debug/rescue-party)). Или для т. н. ручного обновления (*sideload*) через *adb*. *Recovery ramdisk* теперь лежит внутри *boot*-раздела, ядро общее.
* Для переключения режима загрузки (android/recovery) появилась новая опция в cmdline ‑ *skip\_initramfs*.
На первый взгляд кажется, что такая схема не оптимальна, т. к. под систему необходимо выделить в два раза больше места. Но ведь мы избавились от */cache*, а значит уже сэкономили большое количество памяти. Таким образом, система будет занимать немного больше, чем в варианте с *recovery*.
Главным достоинством A/B-обновлений является возможность *стриминга* прошивки. Именно она обеспечивает бесшовность и прозрачность обновлений для пользователя: для обновления устройству достаточно перезагрузиться в новый слот. В этом режиме нет необходимости заранее скачивать zip-архив, занимая место в */data*. Вместо этого система сразу пишет блоки данных из специально подготовленного файла (*payload*, см. ниже) в каждый раздел неактивного слота. С точки зрения реализации нет разницы, скачиваем ли мы предварительно обновление либо сразу стримим его в слот.
Слоты имеют следующие состояния:
* *active* – активный слот, из него будет загружена система при следующей перезагрузке;
* *bootable* – обновление успешно прошито в слот, прошло валидацию, совпали хеш-суммы и т. д.;
* *successful* – система смогла успешно загрузиться в новый слот;
* *unbootable* – слот поврежден. Система всегда помечает слот как *unbootable* перед началом процесса обновления.
Оба слота могут быть *bootable* и *successful*, но только один — *active*.
Алгоритм работы загрузчика при выборе слота:
[](https://habrastorage.org/webt/8u/q4/9x/8uq49xpfsieqyjpebw96yxwigfq.png)
* Загрузчик определяет, что имеется один или более слотов с флагом *bootable*.
* Из них выбирается активный слот (либо слот с наибольшим приоритетом).
* Если система загрузилась успешно, слот помечается как *successful* и *active*.
* Иначе слот помечается как *unbootable* и система перезагружается.
Изменение состояний слотов во время обновления:
[](https://habrastorage.org/webt/-r/7s/4u/-r7s4ucdozhivxpw9jkv-sjyqcm.png)
### Необходимые компоненты для работы с Seamless A/B.
#### boot\_control
Для поддержки A/B-обновлений вендор должен реализовать специальный HAL-интерфейс — [boot\_control](https://android.googlesource.com/platform/hardware/libhardware/+/master/include/hardware/boot_control.h). Он позволяет изменять состояния слотов и получать о них информацию. Для внешней работы (например, через *adb shell*) используется утилита – [bootctl](https://android.googlesource.com/platform/system/extras/+/master/bootctl/). Интерфейс используется как средство взаимодействия между ОС и загрузчиком.
#### update\_engine
Основной [компонент](https://android.googlesource.com/platform/system/update_engine/) всей A/B-схемы. Занимается загрузкой, стримингом обновлений, проверкой подписи и многим другим. Изменяет состояния слотов через *boot\_control*. Позволяет контролировать процесс обновления устройства: приостанавливать, возобновлять, отменять.
Компонент пришёл в Android из ChromeOS, где уже используется некоторое время. AOSP поддерживает *update\_engine* в виде статической *sideload*-сборки. Именно она используется в *recovery*, т.к данный режим не поддерживает динамическую линковку.
Процесс работы данного компонента можно разделить на следующие шаги:
* загрузка обновления в слот. Загружать можно как из предварительно скачанного пакета с обновлением, так и напрямую по Сети через http/https. В процессе загрузки проверяется подпись, открытый ключ уже находится на устройстве (/system/etc/update\_engine/update-payload-key.pub.pem);
* верификация загруженного обновления и сравнение хеш-сумм;
* выполнение *post-install* скриптов.
Структура пакета обновления:
```
2009-01-01 00:00:00 ..... 360 360 META-INF/com/android/metadata
2009-01-01 00:00:00 ..... 107 107 care_map.txt
2009-01-01 00:00:00 ..... 384690699 384690699 payload.bin
2009-01-01 00:00:00 ..... 154 154 payload_properties.txt
2009-01-01 00:00:00 ..... 1675 943 META-INF/com/android/otacert
```
* care\_map.txt — используется *update\_verifier*-ом (см. ниже);
* payload\_properties.txt — содержит хеши и размеры данных внутри *payload*;
* payload.bin — пакет обновления, содержит блоки всех разделов, метаданные, подпись.
#### update\_engine\_client
Клиент для управления демоном *update\_engine*. Может напрямую вызываться вендором для применения обновления.
#### update\_verifier
Утилита для проверки целостности системы при первом запуске (слот с флагом *active*, но еще не *successful*). Контроль целостности реализуется с помощью модуля ядра [dm-verity](https://source.android.com/security/verifiedboot/dm-verity). Если проверка закончилась успешно, утилита помечает текущий слот как *successful*. Иначе система перезагружается в старый слот. Верифицируются только блоки, указанные в файле *care\_map.txt*.
#### UpdateEngineApi
Для реализации vendor-сервисов обновлений существует [Java API](https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/os/UpdateEngine.java). Также имеется [пример реализации](https://android.googlesource.com/platform/packages/apps/Car/SystemUpdater/+/refs/heads/master) такого сервиса.
Рассмотрим пример сборки A/B update в AOSP. Для этого отредактируем Makefile целевой платформы:
```
#Включим поддержку A/B
AB_OTA_UPDATER := true
#Укажем необходимые разделы для слотирования:
AB_OTA_PARTITIONS := boot system vendor
#Добавим необходимые пакеты
PRODUCT_PACKAGES := update_engine update_engine_client update_verifier
#Отключим раздел recovery
TARGET_NO_RECOVERY := true
#Убедимся, что НЕ определяются переменные для раздела cache:
#BOARD_CACHEIMAGE_PARTITION_SIZE := ...
#BOARD_CACHEIMAGE_FILE_SYSTEM_TYPE := ...
```
После вызова *make otapackage* получаем zip-архив с обновлением. В таком виде он уже подходит для *sideload*-режима. Можем выполнить перезагрузку в *recovery* и вызвать *adb sideload ota.zip*. Этот способ удобен для отладки.
Применение обновления изнутри рабочей системы обычно определяется вендором. Самый простой способ — выложить *payload.bin* на http-сервер и напрямую вызвать *update\_engine\_client*.
Пример вызова:
```
update_engine_client \
--payload=http://path/to/payload.bin \
--update \
--headers=" \
FILE_HASH=ozGgyQEddkI5Zax+Wbjo6I/PCR8PEZka9gGd0nWa+oY= \
FILE_SIZE=282344983 \
METADATA_HASH=GLIKfE6KRwylWMHsNadG/Q8iy5f786WTatvMdBlpOPg= \
METADATA_SIZE=26723"
```
В параметр *headers* передается содержимое файла *payload\_properties.txt*. В *logcat* можно наблюдать прогресс обновления. Если передать ключ *--follow*, прогресс будет дублироваться в *stdout*.
### Заключение
Плюсы нового механизма обновлений очевидны:
* обновление системы происходит в фоне, не прерывая работу пользователя. Да, всё так же потребуется перезагрузка (в новый слот), но пройдёт она **значительно** быстрее, чем перезагрузка в recovery для применения обновления;
* минимизируется вероятность *boot loop* (от ошибок в реализации никто не застрахован). Процесс обновления можно прерывать, на активный слот это никак не повлияет;
* появляется возможность отката на предыдущую версию прошивки. Даже если по каким-то причинам обновление прошло неуспешно, система просто вернётся к старой версии;
* благодаря стримингу устройство обновится быстрее;
* в зависимости от реализации можно полностью исключить пользователя из процесса обновления.
Из минусов я бы выделил два момента:
* A/B OTA становится зависимой от текущей разметки диска, т. к. обновление происходит во время работы системы. Т. е. становится невозможно накатить обновление с изменёнными разделами;
* относительная сложность реализации.
И все же, на мой взгляд, плюсы перевешивают. Кстати, в нашем недавно анонсированном [устройстве](https://www.sber.ru/salute/sberportal) мы используем A/B OTA обновления. | https://habr.com/ru/post/521036/ | null | ru | null |
# Как я html-парсер на php писал, и что из этого вышло. Вводная часть
Привет.
Сегодня я хочу рассказать, как написать html парсер, а также с какими проблемами я столкнулся, разрабатывая подобный парсер на php. А проблем было много. И в первой части я расскажу о проектировании парсера, и о возникших проблемах, ведь html парсер отличается от парсера привычных всем языков программирования.
Введение
--------
Я старался написать текст этой статьи максимально понятно, чтобы любой, кто даже не знаком с общим устройством парсеров мог понять то, как работает html парсер.
Здесь и далее в статье я буду называть документ, содержащий html просто *«Документ»*.
Dom дерево, находящееся в элементе, будет называться *«Подмассив»*.
Что должен делать парсер?
-------------------------
Давайте сначала определимся, что должен делать парсер, чтобы в будущем отталкиваться от этого при разработке. А именно, парсер должен:
* Проектировать dom-дерево на основе документа
* Если есть ошибки в документе, то он должен их решать
* Находить элементы в dom-дереве
* Находить children элементы
* Находить текст
Это самый простой список того, что должен уметь парсер. По-хорошему, он еще должен отправлять информацию об ошибках, если таковые были найдены в исходном документе.
Впрочем, это мелочи. Основного функционала вполне хватит, чтобы поломать голову пару ночей напролет.
Но тут есть проблема, с которой я столкнулся сразу же: Html — это не просто язык, это язык гипертекста. У такого языка свой синтаксис, и обычный парсер не подойдет.
Разделяй и властвуй
-------------------
Для начала, нужно разделить работу парсера на два этапа:
* Отделение обычного текста от тегов
* Сортировка всех полученных тегов в dom дерево
Это что касается непосредственно парсинга документа. Про поиск элементов я буду говорить чуть позже далее в этой главе.
Для описания первого этапа я нарисовал схему, которая наглядно показывает, как обрабатываются данные на первом этапе:
Я решил опустить все мелкие детали. Например, как отличить, что после открывающего "<" идет тег, а не текст? Об этом я расскажу в следующих частях. Пока что этого вполне хватит.
Также тут стоит уточнить. Логично, что в документе помимо тегов есть еще и текст. Говоря простым языком, если парсер найдет открывающий тег и если в нем будет текст, он запишет его после открывающего тега в виде отдельного тега. Такой тег будет считаться как одиночный и не будет участвовать в дальнейшей работе парсера.
Ну и второй этап. Самый сложный с точки зрения проектирования, и самый простой на первый взгляд с точки зрения понимания:
В данном случаи уровень означает уровень рекурсии. То есть если парсер нашел открывающий тег, он вызывает самого себя, «входит на уровень ниже», и так будет продолжаться до тех пор, пока не будет найден закрывающий тег. В этом случаи рекурсия выдает результат, «Выходит на уровень выше». Но, как обстоят дела с одиночными тегами? Такие теги считаются рекурсией ни как открывающие, ни как закрывающие. Они просто переходят в dom «Как есть».
В итоге у нас получится что-то вроде этого:
```
[0] => Array
(
[is_closing] =>
[is_singleton] =>
[pointer] => 215
[tag] => div
[0] => Array //открывается подмассив
(
[0] => Array
(
[is_closing] =>
[is_singleton] =>
[pointer] => 238
[tag] => div
[id] => Array
(
[0] => tjojo
)
[0] => Array //открывается подмассив
(
[0] => Array //Текст записывается в виде отдельного тега
(
[tag] => __TEXT
[0] => Привет!
)
[1] => Array
(
[is_closing] => 1
[is_singleton] =>
[pointer] => 268
[tag] => div
)
)
)
)
)
```
Что там насчет поиска элементов?
--------------------------------
А теперь давайте поговорим про поиск элементов. Но тут не все так однозначно, как можно подумать. Сначала стоит разобраться, по каким критериям мы ищем элементы. Тут все просто, мы ищем их по тем же критериям, как это делает Javascript: теги, классы и идентификаторы. Но тут проблема. Дело в том, что тег может быть только один, а вот классов и идентификаторов у одного элемента — множество, либо вообще не быть. Поэтому, поиск элемента по тегу будет отличаться от поиска по классу или идентификатору. Я нарисовал схему поиска по тегу, но не волнуйтесь: поиск по классу или идентификатору не особо отличаются.
Немного уточнений. Под исходным значением я имел в виду название тега, «div» например. Также, если элемент не равен исходному значению, но у него есть подмассив с подходящим элементом, в результат запишется именно подходящий элемент с его подмассивом, если таковой существует.
Стоит также сказать, что у парсера будет функция, позволяющая искать определенный элемент в документе. Это заметно ускорит производительность парсера, что позволит ему выполняться быстрее. Можно будет, например, взять только первый найденный элемент, или пятый, как вы захотите. Согласитесь, в таком случаи парсеру будет гораздо проще искать элементы.
Поиск children элементов
------------------------
Хорошо, с поиском элементов разобрались, а как насчет children элементов? Тут тоже все просто: наш парсер будет брать все вложенные подмассивы найденных до этого элементов, если таковые существуют. Если таковых нет, парсер выведет пустой результат и пойдет дальше:
Поиск текста
------------
Тут говорить особо не о чем. Парсер просто будет брать весь полученный текст из подмассива и выводить его.
Ошибки
------
Документ может содержать ошибки, с которыми наш скрипт должен успешно справляться, либо, если ошибка критическая, выводить ее на экран. Тут будет приведен список всех возможных ошибок, о которых, в будущем, мы будем говорить:
* **Символ ">" не был найден**
Такая ошибка будет возникать в том случаи, если парсер дошел до конца документа и не нашел закрывающего символа ">".
* **Неизвестное значение атрибута**
Данная ошибка сигнализирует о том, что была проведена попытка передачи значения атрибуту когда закрывающий тег был найден.
* **Ошибка html синтаксиса**
Данная ошибка возникает в двух случаях: Либо у атрибута тега в названии есть "<", либо если знак "=" ставится дважды, хотя значение еще не было передано.
```
```
* **Слишком много открывающих тегов**
Данная ошибка часто встречается на сайтах, и говорит она о том, что открывающих тегов больше, чем закрывающих.
```
Привет!
```
Данная ошибка не является критической и будет решаться парсером.
* **Слишком много закрывающих тегов**
То же самое, что и прошлая ошибка, только наоборот.
```
Привет!
```
Данная ошибка также не является критической.
- **Children элемент не найден**
В этом случаи парсер просто будет выводить пустой массив.
Script, style и комментарии
---------------------------
В парсере теги script и style будут сразу же пропускаться, поскольку я не вижу смысл их записывать. С комментариями ситуация другая. Если вы захотите из записывать, то вы сможете включить отдельную функцию скрипта, и тогда он будет их записывать. Комментарии будут записываться точно так же как и текст, то есть как отдельный тег.
Заключение
----------
Эту статью скорее нужно считать небольшим экскурсом в тему парсеров html. Я ее написал для тех, кто задумывается над написанием своего парсера, либо для тех, кому просто интересно. Поверьте, это действительно весело!
Данная статья является первой вводной частью. В следующих частях этого цикла уже будет участвовать непосредственно код, и будет меньше картинок с алгоритмами(что прекрасно, потому что рисовать я их не умею). Stay tuned! | https://habr.com/ru/post/505264/ | null | ru | null |
# Как работать с ошибками бизнес-логики через HTTP
Почти все разработчики так или иначе постоянно работают с api по http, клиентские разработчики работают с api backend своего сайта или приложения, а бэкендеры "дергают" бэкенды других сервисов, как внутренних, так и внешних. И мне кажется, одна из самых главных вещей в хорошем API это формат передачи ошибок. Ведь если это сделано плохо/неудобно, то разработчик, использующий это API, скорее всего не обработает ошибки, а клиенты будут пользоваться молчаливо ломающимся продуктом.
За 7 лет я как поддерживал множество legacy API, так и разрабатывал c нуля. И я поработал, наверное, с большинством стратегий по возвращению ошибок, но каждая из них создавала дискомфорт в той или иной мере. В последнее время я нащупал оптимальный вариант, о котором и хочу рассказать, но с начала расскажу о двух наиболее популярных вариантах.
№1: HTTP статусы
----------------
Если почитать апологетов REST, то для кодов ошибок надо использовать HTTP статусы, а текст ошибки отдавать в теле или в специальном заголовке. Например:
Success:
```
HTTP 200 GET /v1/user/1
Body: { name: 'Вася' }
```
Error:
```
HTTP 404 GET /v1/user/1
Body: 'Не найден пользователь'
```
Если у вас примитивная бизнес-логика или API из 5 url, то в принципе это нормальный подход. Однако как-только бизнес-логика станет сложнее, то начнется ряд проблем.
**Http статусы предназначались для описания ошибок при передаче данных, а про логику вашего приложения никто не думал.** Статусов явно не хватает для описания всего разнообразия ошибок в вашем проекте, да они и не были для этого предназначены. И тут начинается натягивание "совы на глобус": все начинают спорить, какой статус ошибки дать в том или ином случае. Пример: *Есть API для task manager. Какой статус надо вернуть в случае, если пользователь хочет взять задачу, а ее уже взял в работу другой пользователь?* [Ссылка на http статусы](https://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B8%D1%81%D0%BE%D0%BA_%D0%BA%D0%BE%D0%B4%D0%BE%D0%B2_%D1%81%D0%BE%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D1%8F_HTTP).И таких проблемных примеров можно придумать много.
**REST скорее концепция, чем формат общения из чего следует неоднозначность использования статусов.** Разработчики используют статусы как им заблагорассудится. Например, некоторые API при отсутствии сущности возвращают 404 и текст ошибки, а некоторые 200 и пустое тело.
**Бэкенд разработчику в проекте непросто выбрать статус для ошибки, а клиентскому разработчику неочевидно какой статус предназначен для того или иного типа ошибок бизнес-логики.** По-хорошему в проекте придется держать enum для того, чтобы описать какие ошибки относятся к тому или иному статусу.
Когда бизнес-логика приложения усложняется, начинают делать как-то так:
```
HTTP 400 PUT /v1/task/1 { status: 'doing' }
Body: { error_code: '12', error_message: 'Задача уже взята другим исполнителем' }
```
**Из-за ограниченности http статусов разработчики начинают вводить “свои” коды ошибок для каждого статуса и передавать их в теле ответа.** Другими словами, пользователю API приходится писать нечто подобное:
```
if (status === 200) {
// Success
} else if (status === 500) {
// some code
} else if (status === 400) {
if (body.error_code === 1) {
// some code
} else if (body.error_code === 2) {
// some code
} else {
// some code
}
} else if (status === 404) {
// some code
} else {
// some code
}
```
Из-за этого ветвление клиентского кода начинает стремительно расти: множество http статусов и множество кодов в самом сообщении. Для каждого ошибочного http статуса необходимо проверить наличие кодов ошибок в теле сообщения. От комбинаторного взрыва начинает конкретно пухнуть башка! А значит обработку ошибок скорее всего сведут к сообщению типа “Произошла ошибка” или к молчаливому некорректному поведению.
**Многие системы мониторинга сервисов привязываются к http статусам, но это не помогает в мониторинге, если статусы используются для описания ошибок бизнес логики.** *Например, у нас резкий всплеск ошибок 429 на графике. Это началась DDOS атака, или кто-то из разработчиков выбрал неудачный статус?*
Итог: Начать с таким подходом легко и просто и для простого API это вполне подойдет. Но если логика стала сложнее, то использование статусов для описания того, что не укладывается в заданные рамки протокола http приводит к неоднозначности использования и последующим костылям для работы с ошибками. Или что еще хуже к формализму, что ведет к неприятному пользовательскому опыту.
### №2: На все 200
Есть другой подход, даже более старый, чем REST, а именно: на все ошибки связанные с бизнес-логикой возвращать 200, а уже в теле ответа есть информация об ошибке. Например:
Вариант 1:
```
Success:
HTTP 200 GET /v1/user/1
Body: { ok: true, data: { name: 'Вася' } }
Error:
HTTP 200 GET /v1/user/1
Body: { ok: false, error: { code: 1, msg: 'Не найден пользователь' } }
```
Вариант 2:
```
Success:
HTTP 200 GET /v1/user/1
Body: { data: { name: 'Вася' }, error: null }
Error:
HTTP 200 GET /v1/user/1
Body: { data: null, error: { code: 1, msg: 'Не найден пользователь' } }
```
На самом деле формат зависит от вас или от выбранной библиотеки для реализации коммуникации, например JSON-API.
Звучит здорово, мы теперь отвязались от http статусов и можем спокойно ввести свои коды ошибок. У нас больше нет проблемы “впихнуть невпихуемое”. Выбор нового типа ошибки не вызывает споров, а сводится просто к введению нового числового номера (например, последовательно) или строковой константы. Например:
```
module.exports = {
NOT_FOUND: 1,
VALIDATION: 2,
// ….
}
module.exports = {
NOT_FOUND: ‘NOT_AUTHORIZED’,
VALIDATION: ‘VALIDATION’,
// ….
}
```
Клиентские разработчики просто основываясь на кодах ошибок могут создать классы/типы ошибок и притом не бояться, что сервер вернет один и тот же код для разных типов ошибок (из-за бедности http статусов).
Обработка ошибок становится менее ветвящейся, множество http статусов превратились в два: 200 и все остальные (ошибки транспорта).
```
if (status === 200) {
if (body.error) {
var error = body.error;
if (error.code === 1) {
// some code
} else if (error.code === 2) {
// some code
} else {
// some code
}
} else {
// Success
}
} else {
// transport erros
}
```
В некоторых случаях, если есть библиотека десериализации данных, она может взять часть работы на себя. Писать SDK вокруг такого подхода проще нежели вокруг той или иной имплементации REST, ведь реализация зависит от того, как это видел автор. Кроме того, теперь никто не вызовет случайное срабатывание alert в мониторинге из-за того, что выбрал неудачный код ошибки.
Но неудобства тоже есть:
* Избыточность полей при передаче данных, т.е. нужно всегда передавать 2 поля: для данных и для ошибки. Это усложняет чтение логов и написание документации.
* При использовании средств отладки (Chrome DevTools) или других подобных инструментов вы не сможете быстро найти ошибочные запросы бизнес логики, придется обязательно заглянуть в тело ответа (ведь всегда 200)
* Мониторинг теперь точно будет срабатывать только на ошибки транспорта, а не бизнес-логики, но для мониторинга логики надо будет дописывать парсинг тела сообщения.
В некоторых случаях данный подход вырождается в RPC, то есть по сути вообще отказываются от использования url и шлют все на один url методом POST, а в теле сообщения передают все параметры. Мне кажется это не правильным, ведь url это прекрасный именованный namespace, зачем от этого отказываться, не понятно?! Кроме того, RPC создает проблемы:
* нельзя кэшировать по http GET запросы, так как замешали чтение и запись в один метод POST
* нельзя делать повторы для неудавшихся GET запросов (на backend) на реверс-прокси (например, nginx) по указанной выше причине
* имеются проблемы с документированием – swagger и ApiDoc не подходят, а удобных аналогов я не нашел
Итог: Для сложной бизнес-логики с большим количеством типов ошибок такой подход лучше, чем расплывчатый REST, не зря в проектах c “разухабистой” бизнес-логикой часто именно такой подход и используют.
### №3: Смешанный
Возьмем лучшее от двух миров. Мы выберем один http статус, например, 400 или 422 для всех ошибок бизнес-логики, а в теле ответа будем указывать код ошибки или строковую константу. Например:
Success:
```
HTTP 200 /v1/user/1
Body: { name: 'Вася' }
```
Error:
```
HTTP 400 /v1/user/1
Body: { error: { code: 1, msg: 'Не найден пользователь' } }
```
Коды:
* 200 – успех
* 400 – ошибка бизнес логики
* остальное ошибки в транспорте
Тело ответа для удачного запроса у нас имеет произвольную структуру, а вот для ошибки есть четкая схема. Мы избавляемся от избыточности данных (поле ошибки/данных) благодаря использованию http статуса в сравнении со вторым вариантом. Клиентский код упрощается в плане обработки ошибки (в сравнении с первым вариантом). Также мы снижаем его вложенность за счет использования отдельного http статуса для ошибок бизнес логики (в сравнении со вторым вариантом).
```
if (status === 200) {
// Success
} else if (status === 400) {
if (body.error.code === 1) {
// some code
} else if (body.error.code === 2) {
// some code
} else {
// some code
}
} else {
// transport erros
}
```
Мы можем расширять объект ошибки для детализации проблемы, если хотим. С мониторингом все как во втором варианте, дописывать парсинг придется, но и риска “стрельбы” некорректными alert нету. Для документирования можем спокойно использовать Swagger и ApiDoc. При этом сохраняется удобство использования инструментов разработчика, таких как Chrome DevTools, Postman, Talend API.
Итог: Использую данный подход уже в нескольких проектах, где множество типов ошибок и все крайне довольны, как клиентские разработчики, так и бэкендеры. Внедрение новой ошибки не вызывает споров, проблем и противоречий. Данный подход объединяет преимущества первого и второго варианта, при этом код более читабельный и структурированный.
Самое главное какой бы формат ошибок вы бы не выбрали лучше обговорить его заранее и следовать ему. Если эту вещь пустить на “самотек”, то очень скоро обработка ошибок в проекте станет невыносимо сложной для всех.
**P.S.** Иногда ошибки любят передавать массивом
```
{ error: [{ code: 1, msg: 'Не найден пользователь' }] }
```
Но это актуально в основном в двух случаях:
* Когда наш API выступает в роли сервиса без фронтенда (нет сайта/приложения). Например, сервис платежей.
* Когда в API есть url для загрузки какого-нибудь длинного отчета в котором может быть ошибка в каждой строке/колонке. И тогда для пользователя удобнее, чтобы ошибки в приложении сразу показывались все, а не по одной.
В противном случае нет особого смысла закладываться сразу на массив ошибок, потому что базовая валидация данных должна происходить на клиенте, зато код упрощается как на сервере, так и на клиенте. А user-experience хакеров, лезущих напрямую в наше API, не должен нас волновать?HTTP | https://habr.com/ru/post/545524/ | null | ru | null |
# Медленная работа SD карточек — кто виноват и что делать?
Давно думал написать статью на Хабр, но все как-то не решался. Хотя и кажется, что есть мысли, которые были бы небезинтересны сообществу, но останавливает предположение, что это «кажется» проистекает от завышенной самооценки. Тем не менее попробую. Поскольку я профессионально занимаюсь электроникой, в частности, программированием микроконтроллеров, довольно-таки длительное время (как я подозреваю, дольше, чем живет большАя а может даже и бОльшая часть читателей Хабра), то за это время накопилось изрядное количество интересных случаев. Представляю на суд сообщества рассказ об одном из них.
Итак, в одной разработке мне потребовалось сохранять значительные объемы информации с целью последующей передачи через сеть в обрабатывающий центр. Поскольку полученное устройство предполагало серийное производство, был выбран вариант с применением относительно недорогих компонентов, и, в частности, микроконтроллера как центрального элемента системы. Поскольку в тот момент (середина 2012 года) предложение микроконтроллеров с Ethernet PHY на борту не отличалось разнообразием (да и сейчас положение не намного лучше), был выбран МК фирмы TI семейства Stellaris, конкретно LM3S8962, тем более что отладочная плата для него у меня уже имелась. МК на тот момент относительно новый, активно продвигаемый фирмой TI (это в конце 2013 года она ВНЕЗАПНО перевела всю серию в разряд NRND), и обладающий вполне достаточными для решения данной задачи параметрами. Для хранения информациии был выбран вариант с SD карточкой, в первую очередь из за их доступности и дешевизны, а также потому, что на отладочной плате наличествовало контактное устройство для них, а на поставляемом с платой отладки CD имелись многочисленные примеры, в том числе и для SD карт. Интерфейс к карточке был реализован простейший — SPI, предложенные примеры сходу заработали, принятое решение позволяло обрабатывать полученные данные до написания интерфейса при помощи элементарного переноса карточки из устройства в кард-ридер ПК, так что первоначальная отладка алгоритмов взаимодействия с объектом управления проблем не вызвало, по крайней мере в этой части проекта. Как все понимают, проблемы возникли несколько позже…
Когда алторитмы были отлажены и устройство в целом заработало, начались тестовые прогоны. И тут выясняется, что SD карточка не способна записывать информацию в том темпе, в котором объект управления ее поставляет, причем разница скоростей составляет разы, а с учетом размеров единицы хранения (2.7 мегабайта) создать промежуточный буфер по приемлемой цене не удасться. Переходя к конкретным цифрам, требовалось файл размером 2.7 мегабайта записывать на SD карточку не более, чем за 1.6 секунды, а реально данные записывались 30 секунд, причем карточки были приобретены класса 10, то есть утверждали скорость записи 10 мбайт/сек. Борьба за скорость шла в несколько этапов и противниками оказывались то микроконтроллер, то стандартная библиотека (фирменная от TI между прочим), то, собственно, SD карточки.
Первый этап — исследую тайминги записи и сразу же выясняю, что запись различных участков информации идет разное время, причем время записи одинаковых блоков информации существенно (в разы) отличается. Путем экспериментов с различными размерами блоков записи устанавливаю простую закономерность — чем больше блоки информации для записи, тем меньше время записи, отнесенное к ее размеру. Псокольку модули библиотеки поддерживают FAT и записывают информацию посекторно, а переделывать их смысла не вижу, переформатирую карточку на размер сектора 32 кбайт и получаю время записи 14 секунд — 1 очко SD.
Второй этап — проверяю работы SPI интерфейса и обнаруживаю, что он работает на частоте 12.5 мгц, хотя описание позволяет установить частоту передачи до 25 мгц (половина от тактовой частоты процессора 50 мгц). Выясняется, что подпрограмма установки частоты SPI модуля из библиотеки ограничивает максимально возможную частоту значением 12.5 мгц, причем в документации на интерфейсный модуль микроконтроллера подобное ограничение отсутствует.
```
i = ROM_SysCtlClockGet() / 2; if(i > 12500000) { i = 12500000; }
```
Изменяем код и получаем уменьшение времени записи в 2 раза до 7 секунд — 1 очко TI.
Третий этап — исследую модули обмена с SD карточкой и обнаруживаю весьма непроизводительное расходование времени в низкоуровневых процедурах, а именно: модуль SPI в микроконтроллере имеет в своем составе FIFO буфер на 8 байт, что позволяет ускорить работу с ним. Модуль вывода до передачи очередного байте проверяет флаг «буфер передачи не полон» для ожидания возможности переслать следующий байт, и вроде бы все нормально. Но вслед за передачей байта вызывается модуль приема байта (дело в том, что при передаче в интерфейсе SPI одновременно производится и прием), который должен выбрать из приемного буфера эти ненужные принятые байты. И вот эта процедура опрашивает флаг «буфер приема не пуст», то есть ожидает окончания сериализации последнего байта буфера. То есть ждет, пока не будет полностью передан текущий байт и лишь потом готовит следующий для передачи.
```
void xmit_spi(BYTE dat) {
uint32_t ui32RcvDat;
SSIDataPut(SDC_SSI_BASE, dat); /* Write */
SSIDataGet(SDC_SSI_BASE, &ui32RcvDat); /* flush data */
}
```
Исправляю обнаруженую ошибку (а как это еще назвать ?) и получаю время передачи файла 3 секунды — 1 очко TI.
И вот что получилось в результате оптимизации, не учитывающей особенности задачи.
```
static void xmit_spi_my (BYTE const *dst, int length)
{ int i, *p, *d;
d=(int*)(SDC_SSI_BASE+SSI_O_DR);
p=(int*)(SDC_SSI_BASE+SSI_O_SR);
do {
while (!(*p & SSI_SR_TNF)) {}
*d=*dst++;
} while (--length);
while (*p & SSI_SR_RNE) i=*d;
}
```
Четвертый этап — исследую модули более высокого уровня и выясняю что, поскольку передача данных в интерфейс предусмотрена только из памяти, мне приходится проводить двойную работу — сначала читать поток данных из объекта управления и пересылать в оперативную память микроконтроллера (а это, между прочим, 32 килобайта буфера), а потом из памяти в регистры интерфейса SPI. Пишу свой собственный модуль для передачи данных непосредственно из регистра в регистр, и получаю время записи 1.6 секунды. При этом обращение к своему модулю маскирую внутри стандартного вызова, чтобы файловую система понимала, что переданы 32 килобайта — 1 очко TI.
Пятый этап. Поставленная цель уже достигнута, но процесс оптимизации продолжается по инерции. Исследую еще раз сигналы на интерфейсе и обнаруживаю, что на самом деле передается не непрерывная последовательность тактовых импульсов, а 8 бит данных плюс пауза в 2 такта. Ну хорошо, девятый бит нужен для передачи сигнала синхронизации (не путать с тактовым сигналом), причем мне он совершенно не нужен, но десятый то зачем? Эксперименты с различными режимами SPI привели к получению передаваемого сигнала в реальные 8 бит без пропусков и, соответственно, к времени записи 1.3 секунды — 1 очко Stellaris.
Шестой этап. Вроде бы все хорошо, но совершенно неожидано возникает еще 1 проблема — при потоковой записи множества файлов первые 3 укладываются в требуемый интервал и даже с небольшим запасом, а вот четвертый файл показвает время записи намного большее — до 1.8-2.0 секунд и, соответственно, нарушает последовательность. Пробую очевидное решение, предположив что дело в переходах через страницы записи FLASH памяти, и исключаю эти места из обработки. Теперь начинают долго записываться те файлы, которые раньше записывались хорошо. Многочисленные эксперименты приводят к выводу, что поведение FLASH как то связано с ее особенностями внутренней организации. Я полагаю, что внутренний генератор высокого напряжения для записи ( его существование несомненно) не способен удержать требуемый уровень напряжения при длительных операциях и требует определенного времени на восстановление заряда. При этом общая средняя скорость выдерживается, но мне то нужна не средняя скорость, а мгновенная скорость записи каждого файла. Здесь могло бы выручить введение буфера данных для выравнивания нагрузки, но было найдено другое решение — приобретены SD карточки различных фирм и среди них нашлись те, которые давали постоянное время записи в 1.4 секунды без существенных разбросов. Конкретные названия фирм-производителей карточек называть не буду, чтобы не сочли статью рекламной — 1 очко SD.
Итог — задача решена, устройcтва отгружены потребителю и функционируют без сбоев, общий счет по количеству обнаруженных и исправленных проблем: SD карточки — 2, библиотека от TI — 3, особенности микроконтроллера -1. А из всего вышесказанного можно сделать следующий выводы:
1. С особым вниманием следует относится к имеющимся библиотекам стандартных программ с примерами применения. Они, как правило, функционируют и даже иногда без ошибок, но никоим образом НЕ оптимизированы по производительности. Так что смотрим исходные коды (благо они есть) и творчески модифицируем их. Более того, у меня сложилось мнение, что подобные свободно распространяемые бибилиотеки сознательно сделаны неоптимальными, чтобы стимулировать приобретение их платных аналогов.
2. С осторожностью относимся к спецификациям относительно производительности различных устройств, то есть внимательно читаем спецификации, в каких режимах и какие цифры достигнуты, а не просто смотрим 1-2 цифры параметров и решаем, что нас они устроят.
3. Внимательно читаем документацию на модули микроконтроллеров, пытаемся понять их внутреннее устройство, не забываем про осциллограф для изучения реальных процессов на реальной плате.
И в завершение статьи одно маленькое замечание — решил посмотреть, как обстоят дела в реализации аналогичных процедур в новом пакете поддержки микроконтроллеров типа TIVA-C (TivaWare\_C\_Series-2.0.1.11577). Ну что можно сказать — традиции не нарушены. Абсолютно все те же грабли лежат все в тех же местах, причем добавились еще одни — теперь функциии вызываются не непосредственно из FLASH памяти, а из так называемой ROM библиотеки с использованием двойного индексирования, что быстродействия не прибавляет. Как говорил Михаил Жванецкий «Или мы будет жить хорошо, или мои произведения всегда будут актуальны». Пока что верно второе. | https://habr.com/ru/post/220433/ | null | ru | null |
# Делаем модем: передаем цифровые данные по воздуху с помощью OFDM и GNU Radio
Привет, Хабр.
Данный текст можно считать продолжением статьи "[Разбираем звук Dial-up модема](https://habr.com/ru/post/486542/)", в которой разбирался метод установки связи между модемами. Сегодня мы пойдем дальше, и посмотрим на практике как передаются данные, для чего создадим простую реализацию модема с помощью OFDM и GNU Radio.
Данные мы будем передавать по воздуху, в прямом смысле этого слова — для приема и передачи будет достаточно динамика и микрофона.
Для тех, кому интересно как это работает, продолжение под катом.
Итак, наша задача — сделать простейший модем, способный передать данные из точки А в точку Б. Существует много способов модуляции цифрового сигнала, мы воспользуемся [OFDM](https://en.wikipedia.org/wiki/Orthogonal_frequency-division_multiplexing) — методом, широко используемым в современных системах связи. В OFDM цифровой сигнал с помощью преобразования Фурье преобразуется в несколько параллельных поднесущих, что обеспечивает высокую скорость и эффективность использования канала передачи. OFDM используется много где, от цифрового телевидения и радио, до LTE. Наш аудиоканал гораздо уже и скромнее по параметрам, так что и скорости будут поменьше, но принципиально суть, в общем, не меняется. Строго говоря, OFDM *не предназначен* для передачи данных по воздуху, хотя для небольших расстояний обычного микрофона и динамика будет вполне достаточно.
OFDM в GNU Radio
----------------
Минимальный граф для тестирования приема и передачи показан ниже:
Исходный код для GNU Radio 3.8:
**ofdm1.grc**
```
options:
parameters:
author: ''
category: '[GRC Hier Blocks]'
cmake_opt: ''
comment: ''
copyright: ''
description: ''
gen_cmake: 'On'
gen_linking: dynamic
generate_options: qt_gui
hier_block_src_path: '.:'
id: ofdm_test_1
max_nouts: '0'
output_language: python
placement: (0,0)
qt_qss_theme: ''
realtime_scheduling: ''
run: 'True'
run_command: '{python} -u {filename}'
run_options: prompt
sizing_mode: fixed
thread_safe_setters: ''
title: OFDM Test 1
window_size: ''
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [8, 8]
rotation: 0
state: enabled
blocks:
- name: fft_len
id: variable
parameters:
comment: ''
value: '64'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [448, 12.0]
rotation: 0
state: enabled
- name: packet_len
id: variable
parameters:
comment: ''
value: '12'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [336, 12.0]
rotation: 0
state: enabled
- name: samp_rate
id: variable
parameters:
comment: ''
value: '2400'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [216, 12.0]
rotation: 0
state: enabled
- name: blocks_file_source_0
id: blocks_file_source
parameters:
affinity: ''
alias: ''
begin_tag: pmt.PMT_NIL
comment: ''
file: D:\Temp\1\data2.txt
length: '0'
maxoutbuf: '0'
minoutbuf: '0'
offset: '0'
repeat: 'True'
type: byte
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [32, 128.0]
rotation: 0
state: enabled
- name: blocks_stream_to_tagged_stream_0
id: blocks_stream_to_tagged_stream
parameters:
affinity: ''
alias: ''
comment: ''
len_tag_key: '"key"'
maxoutbuf: '0'
minoutbuf: '0'
packet_len: packet_len
type: byte
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [488, 156.0]
rotation: 0
state: enabled
- name: blocks_throttle_0
id: blocks_throttle
parameters:
affinity: ''
alias: ''
comment: ''
ignoretag: 'True'
maxoutbuf: '0'
minoutbuf: '0'
samples_per_second: samp_rate
type: byte
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [272, 168.0]
rotation: 0
state: enabled
- name: blocks_udp_sink_0
id: blocks_udp_sink
parameters:
affinity: ''
alias: ''
comment: ''
eof: 'True'
ipaddr: 127.0.0.1
port: '40868'
psize: '128'
type: byte
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [424, 476.0]
rotation: 180
state: enabled
- name: channels_channel_model_0
id: channels_channel_model
parameters:
affinity: ''
alias: ''
block_tags: 'True'
comment: ''
epsilon: '1.0'
freq_offset: 0 * 1.0/fft_len
maxoutbuf: '0'
minoutbuf: '0'
noise_voltage: '0.1'
seed: '0'
taps: 1.0 + 1.0j
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1112.0, 280]
rotation: 270
state: enabled
- name: digital_ofdm_rx_0
id: digital_ofdm_rx
parameters:
affinity: ''
alias: ''
comment: ''
cp_len: fft_len//4
fft_len: fft_len
header_mod: '"BPSK"'
log: 'False'
maxoutbuf: '0'
minoutbuf: '0'
occupied_carriers: ((-4,-3,-2,-1,1,2,3,4),)
packet_len_key: '"key"'
payload_mod: '"QPSK"'
pilot_carriers: ((-6,-5,5,6),)
pilot_symbols: ((-1,1,-1,1),)
scramble_bits: 'False'
sync_word1: None
sync_word2: None
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [776, 428.0]
rotation: 180
state: enabled
- name: digital_ofdm_tx_0
id: digital_ofdm_tx
parameters:
affinity: ''
alias: ''
comment: ''
cp_len: fft_len//4
fft_len: fft_len
header_mod: '"BPSK"'
log: 'False'
maxoutbuf: '0'
minoutbuf: '0'
occupied_carriers: ((-4,-3,-2,-1,1,2,3,4),)
packet_len_key: '"key"'
payload_mod: '"QPSK"'
pilot_carriers: ((-6,-5,5,6),)
pilot_symbols: ((-1,1,-1,1),)
rolloff: '0'
scramble_bits: 'False'
sync_word1: None
sync_word2: None
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [776, 80.0]
rotation: 0
state: enabled
- name: qtgui_freq_sink_x_0
id: qtgui_freq_sink_x
parameters:
affinity: ''
alias: ''
alpha1: '1.0'
alpha10: '1.0'
alpha2: '1.0'
alpha3: '1.0'
alpha4: '1.0'
alpha5: '1.0'
alpha6: '1.0'
alpha7: '1.0'
alpha8: '1.0'
alpha9: '1.0'
autoscale: 'False'
average: '1.0'
axislabels: 'True'
bw: samp_rate
color1: '"blue"'
color10: '"dark blue"'
color2: '"red"'
color3: '"green"'
color4: '"black"'
color5: '"cyan"'
color6: '"magenta"'
color7: '"yellow"'
color8: '"dark red"'
color9: '"dark green"'
comment: ''
ctrlpanel: 'False'
fc: '0'
fftsize: '1024'
freqhalf: 'True'
grid: 'False'
gui_hint: ''
label: Relative Gain
label1: Rx Spectrum
label10: ''
label2: ''
label3: ''
label4: ''
label5: ''
label6: ''
label7: ''
label8: ''
label9: ''
legend: 'True'
maxoutbuf: '0'
minoutbuf: '0'
name: Rx Spectrum
nconnections: '1'
showports: 'True'
tr_chan: '0'
tr_level: '0.0'
tr_mode: qtgui.TRIG_MODE_FREE
tr_tag: '""'
type: complex
units: dB
update_time: '0.10'
width1: '1'
width10: '1'
width2: '1'
width3: '1'
width4: '1'
width5: '1'
width6: '1'
width7: '1'
width8: '1'
width9: '1'
wintype: firdes.WIN_BLACKMAN_hARRIS
ymax: '10'
ymin: '-140'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1232, 92.0]
rotation: 0
state: enabled
connections:
- [blocks_file_source_0, '0', blocks_throttle_0, '0']
- [blocks_stream_to_tagged_stream_0, '0', digital_ofdm_tx_0, '0']
- [blocks_throttle_0, '0', blocks_stream_to_tagged_stream_0, '0']
- [channels_channel_model_0, '0', digital_ofdm_rx_0, '0']
- [digital_ofdm_rx_0, '0', blocks_udp_sink_0, '0']
- [digital_ofdm_tx_0, '0', channels_channel_model_0, '0']
- [digital_ofdm_tx_0, '0', qtgui_freq_sink_x_0, '0']
metadata:
file_format: 1
```
В качестве источника данных используется обычный текстовый файл (в моем случае он содержит строку «Hello Habr!!»), затем данные разбиваются на блоки, которые подаются на **OFDM Transmitter**. OFDM это достаточно сложный вид модуляции, в настройках OFDM-кодера нужно указать достаточно много не совсем очевидных параметров.
Более детальный разбор значений можно найти [здесь](https://wiki.gnuradio.org/index.php/Basic_OFDM_Tutorial). Разумеется, параметры блока **OFDM Receiver** должны совпадать с параметрами передачи.
Блок **Channel Model** используется для симуляции канала связи, блок **QT GUI Frequency Sink** используется для визуализации спектра. Также стоит обратить внимание на невысокую частоту дискретизации (sample rate = 2400), это специально сделано для того, чтобы сигнал занимал небольшую полосу спектра, пригодную для передачи по аудиоканалу.
К сожалению, встроенного блока для отображения принимаемых данных в GNU Radio я не нашел, так что приходится использовать UDP. Блок **UDP Sink** используется для вывода данных, для их приема используется программа на языке Python:
```
import socket
UDP_IP = "127.0.0.1"
UDP_PORT = 40868
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind((UDP_IP, UDP_PORT))
sock.settimeout(0.5)
while True:
try:
data, addr = sock.recvfrom(128)
print("Msg:", data, 'Hex:', ' '.join('{:02x}'.format(x) for x in data))
except socket.timeout:
pass
```
Это позволяет выводить принимаемые данные в консоли, что достаточно удобно. Возможно есть более простой способ вывода в GNU Radio, если кто знает, напишите в комментариях.
Если все было сделано правильно, мы можем запустить GNU Radio и наш скрипт для приема, результат должен выглядеть примерно так:
Казалось бы, тему можно закрывать? Нет, все интересное только начинается.
Выходим в эфир
--------------
В вышеприведенном примере все довольно просто. Но есть одно «но» — GNU Radio работает с так называемым «комплексным сигналом», фактически представляющим собой пары чисел, сдвинутых по фазе на 90 градусов. Это удобно для компьютерной обработки, но мы не можем просто взять и передать в эфир комплексное число.
И тут есть два варианта. Владельцы SDR-трансмиттеров (HackRF, LimeSDR, USRP и пр) могут дальше не читать, а просто взять готовый блок для GNU Radio, в котором все делается «автоматом». Но т.к. мы собираемся передать сигнал с помощью звуковой карты, мы должны сделать преобразование самостоятельно, для чего воспользуемся блок-схемой, которая есть в любой статье по ЦОС:
Здесь OFDM это наш передатчик, Fc частота несущей, мы зададим её равной 4КГц, чтобы сигнал попадал в максимум чувствительности колонок и микрофона. Блок-схема графа для передачи также соответственно, усложняется:
Для удобства тестирования я использую **WAV File Sink**, чтобы сохраненный файл можно было записать и воспроизводить отдельно. Также мы можем открыть файл и посмотреть его спектр, можно убедиться что центральная частота действительно равна 4КГц:
Прием
-----
И наконец, последний шаг: создадим блок-схему для приема сигнала. Тут фактически все то же самое, только в обратном порядке.
Мы домножаем исходный сигнал на сдвинутые по фазе опорные сигналы, затем с помощью LPF отсекаем высокочастотные компоненты. На выходе получается комплексный сигнал, который может использоваться для дальнейшей обработки.
Граф для приема в GNU Radio имеет следующий вид:
Стоит отметить блок **Audio Source** для приема данных из звуковой карты, блок **QT GUI Frequency Sink** используется для визуализации принимаемого сигнала.
Для тестирования, я записал WAV-файл на смартфон, при поднесении его к микрофону компьютера, на экране появляется декодированный текст:
Заключение
----------
Как можно видеть, прием и передача сигналов с помощью GNU Radio достаточно интересен и нагляден. OFDM имеет достаточно большое число параметров, желающие могут поэспериментировать самостоятельно с размером блока FFT, числом несущих, частотой передачи и пр.
Всем спасибо за внимание, и удачных экспериментов.
Для желающих, исходник под спойлером.
**ofdm2.grc**
```
options:
parameters:
author: ''
category: Custom
cmake_opt: ''
comment: ''
copyright: ''
description: Transmit a pre-defined signal (a complex sine) as OFDM packets.
gen_cmake: 'On'
gen_linking: dynamic
generate_options: qt_gui
hier_block_src_path: '.:'
id: ofdm_test_2
max_nouts: '0'
output_language: python
placement: (0,0)
qt_qss_theme: ''
realtime_scheduling: ''
run: 'True'
run_command: '{python} -u {filename}'
run_options: prompt
sizing_mode: fixed
thread_safe_setters: ''
title: OFDM Test 2
window_size: 1280, 1024
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [8, 12.0]
rotation: 0
state: enabled
blocks:
- name: audio_samp_rate
id: variable
parameters:
comment: ''
value: '24000'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [648, 20.0]
rotation: 0
state: true
- name: carrier_freq
id: variable
parameters:
comment: ''
value: '4000'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [792, 20.0]
rotation: 0
state: true
- name: fft_len
id: variable
parameters:
comment: ''
value: '64'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [448, 20.0]
rotation: 0
state: enabled
- name: len_tag_key
id: variable
parameters:
comment: ''
value: '"packet_len"'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [320, 20.0]
rotation: 0
state: enabled
- name: packet_len
id: variable
parameters:
comment: ''
value: '12'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [216, 20.0]
rotation: 0
state: enabled
- name: samp_rate
id: variable
parameters:
comment: ''
value: '2400'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [536, 20.0]
rotation: 0
state: enabled
- name: analog_sig_source_x_0
id: analog_sig_source_x
parameters:
affinity: ''
alias: ''
amp: '1'
comment: ''
freq: carrier_freq
maxoutbuf: '0'
minoutbuf: '0'
offset: '0'
phase: '0'
samp_rate: audio_samp_rate
type: float
waveform: analog.GR_COS_WAVE
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1080, 88.0]
rotation: 0
state: true
- name: analog_sig_source_x_0_0
id: analog_sig_source_x
parameters:
affinity: ''
alias: ''
amp: '1'
comment: ''
freq: carrier_freq
maxoutbuf: '0'
minoutbuf: '0'
offset: '0'
phase: '0'
samp_rate: audio_samp_rate
type: float
waveform: analog.GR_SIN_WAVE
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1080, 344.0]
rotation: 0
state: true
- name: analog_sig_source_x_0_0_0
id: analog_sig_source_x
parameters:
affinity: ''
alias: ''
amp: '1'
comment: ''
freq: carrier_freq
maxoutbuf: '0'
minoutbuf: '0'
offset: '0'
phase: '0'
samp_rate: audio_samp_rate
type: float
waveform: analog.GR_SIN_WAVE
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1376, 824.0]
rotation: 180
state: true
- name: analog_sig_source_x_0_1
id: analog_sig_source_x
parameters:
affinity: ''
alias: ''
amp: '1'
comment: ''
freq: carrier_freq
maxoutbuf: '0'
minoutbuf: '0'
offset: '0'
phase: '0'
samp_rate: audio_samp_rate
type: float
waveform: analog.GR_COS_WAVE
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1376, 672.0]
rotation: 180
state: true
- name: audio_sink_0
id: audio_sink
parameters:
affinity: ''
alias: ''
comment: ''
device_name: ''
num_inputs: '1'
ok_to_block: 'True'
samp_rate: audio_samp_rate
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1608, 224.0]
rotation: 0
state: disabled
- name: audio_source_0
id: audio_source
parameters:
affinity: ''
alias: ''
comment: ''
device_name: ''
maxoutbuf: '0'
minoutbuf: '0'
num_outputs: '1'
ok_to_block: 'True'
samp_rate: audio_samp_rate
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1376, 584.0]
rotation: 180
state: enabled
- name: blocks_add_xx_0
id: blocks_add_xx
parameters:
affinity: ''
alias: ''
comment: ''
maxoutbuf: '0'
minoutbuf: '0'
num_inputs: '2'
type: float
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1480, 264.0]
rotation: 0
state: true
- name: blocks_complex_to_float_0
id: blocks_complex_to_float
parameters:
affinity: ''
alias: ''
comment: ''
maxoutbuf: '0'
minoutbuf: '0'
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1128, 256.0]
rotation: 0
state: true
- name: blocks_file_source_0
id: blocks_file_source
parameters:
affinity: ''
alias: ''
begin_tag: pmt.PMT_NIL
comment: ''
file: D:\Temp\1\data2.txt
length: '0'
maxoutbuf: '0'
minoutbuf: '0'
offset: '0'
repeat: 'True'
type: byte
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [32, 224.0]
rotation: 0
state: enabled
- name: blocks_float_to_complex_0
id: blocks_float_to_complex
parameters:
affinity: ''
alias: ''
comment: ''
maxoutbuf: '0'
minoutbuf: '0'
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [744, 768.0]
rotation: 180
state: true
- name: blocks_multiply_xx_0
id: blocks_multiply_xx
parameters:
affinity: ''
alias: ''
comment: ''
maxoutbuf: '0'
minoutbuf: '0'
num_inputs: '2'
type: float
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1336, 176.0]
rotation: 0
state: true
- name: blocks_multiply_xx_0_0
id: blocks_multiply_xx
parameters:
affinity: ''
alias: ''
comment: ''
maxoutbuf: '0'
minoutbuf: '0'
num_inputs: '2'
type: float
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1336, 344.0]
rotation: 0
state: enabled
- name: blocks_multiply_xx_0_1
id: blocks_multiply_xx
parameters:
affinity: ''
alias: ''
comment: ''
maxoutbuf: '0'
minoutbuf: '0'
num_inputs: '2'
type: float
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1168, 696.0]
rotation: 180
state: true
- name: blocks_multiply_xx_0_1_0
id: blocks_multiply_xx
parameters:
affinity: ''
alias: ''
comment: ''
maxoutbuf: '0'
minoutbuf: '0'
num_inputs: '2'
type: float
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1176, 864.0]
rotation: 180
state: true
- name: blocks_null_sink_0
id: blocks_null_sink
parameters:
affinity: ''
alias: ''
bus_structure_sink: '[[0,],]'
comment: ''
num_inputs: '1'
type: float
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1608, 168.0]
rotation: 0
state: true
- name: blocks_stream_to_tagged_stream_0
id: blocks_stream_to_tagged_stream
parameters:
affinity: ''
alias: ''
comment: ''
len_tag_key: '"key"'
maxoutbuf: '0'
minoutbuf: '0'
packet_len: packet_len
type: byte
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [424, 252.0]
rotation: 0
state: enabled
- name: blocks_throttle_0
id: blocks_throttle
parameters:
affinity: ''
alias: ''
comment: ''
ignoretag: 'True'
maxoutbuf: '0'
minoutbuf: '0'
samples_per_second: samp_rate
type: byte
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [248, 264.0]
rotation: 0
state: enabled
- name: blocks_udp_sink_0
id: blocks_udp_sink
parameters:
affinity: ''
alias: ''
comment: ''
eof: 'True'
ipaddr: 127.0.0.1
port: '40868'
psize: '128'
type: byte
vlen: '1'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [104, 748.0]
rotation: 180
state: enabled
- name: blocks_wavfile_sink_0
id: blocks_wavfile_sink
parameters:
affinity: ''
alias: ''
bits_per_sample: '16'
comment: ''
file: D:\Temp\1\ofdm.wav
nchan: '1'
samp_rate: audio_samp_rate
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [1608, 308.0]
rotation: 0
state: disabled
- name: digital_ofdm_rx_0
id: digital_ofdm_rx
parameters:
affinity: ''
alias: ''
comment: ''
cp_len: fft_len//4
fft_len: fft_len
header_mod: '"BPSK"'
log: 'False'
maxoutbuf: '0'
minoutbuf: '0'
occupied_carriers: ((-4,-3,-2,-1,1,2,3,4),)
packet_len_key: '"key"'
payload_mod: '"QPSK"'
pilot_carriers: ((-6,-5,5,6),)
pilot_symbols: ((-1,1,-1,1),)
scramble_bits: 'False'
sync_word1: None
sync_word2: None
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [440, 700.0]
rotation: 180
state: enabled
- name: digital_ofdm_tx_0
id: digital_ofdm_tx
parameters:
affinity: ''
alias: ''
comment: ''
cp_len: fft_len//4
fft_len: fft_len
header_mod: '"BPSK"'
log: 'False'
maxoutbuf: '0'
minoutbuf: '0'
occupied_carriers: ((-4,-3,-2,-1,1,2,3,4),)
packet_len_key: '"key"'
payload_mod: '"QPSK"'
pilot_carriers: ((-6,-5,5,6),)
pilot_symbols: ((-1,1,-1,1),)
rolloff: '0'
scramble_bits: 'False'
sync_word1: None
sync_word2: None
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [664, 176.0]
rotation: 0
state: enabled
- name: low_pass_filter_0
id: low_pass_filter
parameters:
affinity: ''
alias: ''
beta: '6.76'
comment: ''
cutoff_freq: carrier_freq
decim: audio_samp_rate//samp_rate
gain: '1'
interp: '1'
maxoutbuf: '0'
minoutbuf: '0'
samp_rate: audio_samp_rate
type: fir_filter_fff
width: '1000'
win: firdes.WIN_HAMMING
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [960, 648.0]
rotation: 180
state: true
- name: low_pass_filter_0_0
id: low_pass_filter
parameters:
affinity: ''
alias: ''
beta: '6.76'
comment: ''
cutoff_freq: carrier_freq
decim: audio_samp_rate//samp_rate
gain: '1'
interp: '1'
maxoutbuf: '0'
minoutbuf: '0'
samp_rate: audio_samp_rate
type: fir_filter_fff
width: '1000'
win: firdes.WIN_HAMMING
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [960, 816.0]
rotation: 180
state: true
- name: qtgui_freq_sink_x_0
id: qtgui_freq_sink_x
parameters:
affinity: ''
alias: ''
alpha1: '1.0'
alpha10: '1.0'
alpha2: '1.0'
alpha3: '1.0'
alpha4: '1.0'
alpha5: '1.0'
alpha6: '1.0'
alpha7: '1.0'
alpha8: '1.0'
alpha9: '1.0'
autoscale: 'False'
average: '1.0'
axislabels: 'True'
bw: samp_rate
color1: '"blue"'
color10: '"dark blue"'
color2: '"red"'
color3: '"green"'
color4: '"black"'
color5: '"cyan"'
color6: '"magenta"'
color7: '"yellow"'
color8: '"dark red"'
color9: '"dark green"'
comment: ''
ctrlpanel: 'False'
fc: '0'
fftsize: '1024'
freqhalf: 'True'
grid: 'False'
gui_hint: ''
label: Relative Gain
label1: Rx Spectrum
label10: ''
label2: ''
label3: ''
label4: ''
label5: ''
label6: ''
label7: ''
label8: ''
label9: ''
legend: 'True'
maxoutbuf: '0'
minoutbuf: '0'
name: Rx Spectrum
nconnections: '1'
showports: 'True'
tr_chan: '0'
tr_level: '0.0'
tr_mode: qtgui.TRIG_MODE_FREE
tr_tag: '""'
type: complex
units: dB
update_time: '0.10'
width1: '1'
width10: '1'
width2: '1'
width3: '1'
width4: '1'
width5: '1'
width6: '1'
width7: '1'
width8: '1'
width9: '1'
wintype: firdes.WIN_BLACKMAN_hARRIS
ymax: '10'
ymin: '-140'
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [728, 612.0]
rotation: 0
state: enabled
- name: rational_resampler_xxx_0
id: rational_resampler_xxx
parameters:
affinity: ''
alias: ''
comment: ''
decim: '1'
fbw: '0'
interp: audio_samp_rate//samp_rate
maxoutbuf: '0'
minoutbuf: '0'
taps: ''
type: ccf
states:
bus_sink: false
bus_source: false
bus_structure: null
coordinate: [912, 236.0]
rotation: 0
state: true
connections:
- [analog_sig_source_x_0, '0', blocks_multiply_xx_0, '0']
- [analog_sig_source_x_0_0, '0', blocks_multiply_xx_0_0, '1']
- [analog_sig_source_x_0_0_0, '0', blocks_multiply_xx_0_1_0, '1']
- [analog_sig_source_x_0_1, '0', blocks_multiply_xx_0_1, '1']
- [audio_source_0, '0', blocks_multiply_xx_0_1, '0']
- [audio_source_0, '0', blocks_multiply_xx_0_1_0, '0']
- [blocks_add_xx_0, '0', audio_sink_0, '0']
- [blocks_add_xx_0, '0', blocks_null_sink_0, '0']
- [blocks_add_xx_0, '0', blocks_wavfile_sink_0, '0']
- [blocks_complex_to_float_0, '0', blocks_multiply_xx_0, '1']
- [blocks_complex_to_float_0, '1', blocks_multiply_xx_0_0, '0']
- [blocks_file_source_0, '0', blocks_throttle_0, '0']
- [blocks_float_to_complex_0, '0', digital_ofdm_rx_0, '0']
- [blocks_float_to_complex_0, '0', qtgui_freq_sink_x_0, '0']
- [blocks_multiply_xx_0, '0', blocks_add_xx_0, '0']
- [blocks_multiply_xx_0_0, '0', blocks_add_xx_0, '1']
- [blocks_multiply_xx_0_1, '0', low_pass_filter_0, '0']
- [blocks_multiply_xx_0_1_0, '0', low_pass_filter_0_0, '0']
- [blocks_stream_to_tagged_stream_0, '0', digital_ofdm_tx_0, '0']
- [blocks_throttle_0, '0', blocks_stream_to_tagged_stream_0, '0']
- [digital_ofdm_rx_0, '0', blocks_udp_sink_0, '0']
- [digital_ofdm_tx_0, '0', rational_resampler_xxx_0, '0']
- [low_pass_filter_0, '0', blocks_float_to_complex_0, '0']
- [low_pass_filter_0_0, '0', blocks_float_to_complex_0, '1']
- [rational_resampler_xxx_0, '0', blocks_complex_to_float_0, '0']
metadata:
file_format: 1
``` | https://habr.com/ru/post/497638/ | null | ru | null |
# Почему процессоры Skylake иногда работают в 2 раза медленнее
Мне сообщили, что на новых компьютерах некоторые регрессиионные тесты стали медленнее. Обычное дело, такое бывает. Неправильная конфигурация где-то в Windows или не самые оптимальные значения в BIOS. Но в этот раз нам никак не удавалось найти ту самую «сбитую» настройку. Поскольку изменение значительное: 9 против 19 секунд (на графике синий — это старое железо, а оранжевый — новое), то пришлось копать глубже.
Та же ОС, то же оборудование, другой процессор: в 2 раза медленнее
==================================================================
Падение производительности с 9,1 до 19,6 секунд определённо можно назвать значительным. Мы провели дополнительные проверки со сменой версий тестируемых программ, Windows и настроек BIOS. Но нет, результат не изменился. Единственная разница проявлялась только на разных процессорах. Ниже представлен результат на новейшем CPU.
И вот тот, который используется для сравнения.
Xeon Gold работает на другой архитектуре под названием Skylake, общей для новых процессоров Intel с середины 2017 года. Если вы покупаете новейшее железо, то получите процессор с архитектурой Skylake. Это хорошие машины, но, как показали тесты, новизна и быстрота — не одно и то же.
Если больше ничего не помогает, то надо использовать профайлер для глубокого исследования. Проведём тест на старом и новом оборудовании и получим примерно такое:
Вкладка в Windows Performance Analyzer (WPA) показывает в таблице разницу между Trace 2 (11 с) и Trace 1 (19 с). Отрицательная разница в таблице соответствует увеличению потребления CPU в более медленном тесте. Если посмотреть на самые значительные различия в потреблении CPU, то мы увидим *AwareLock::Contention*, *JIT\_MonEnterWorker\_InlineGetThread\_GetThread\_PatchLabel* и *ThreadNative.SpinWait*. Всё указывает на «спиннинг» в CPU [спиннинг (spinning) — циклическая попытка получить блокировку, прим. пер.], когда потоки борются за блокировки. Но это ложный след, потому что спиннинг не является основной причиной снижения производительности. Усиленная конкуренция за блокировки означает, что нечто в нашем программном обеспечении замедлилось и удержало блокировку, что как следствие привело к усилению спиннинга в CPU. Я проверял время блокировки и другие ключевые показатели, такие как показатели диска, но не удалось найти ничего значимого, что могло бы объяснить снижение производительности. Хотя это не логично, но я вернулся к увеличению нагрузки на CPU в различных методах.
Было бы интересно найти, где именно застревает процессор. В WPA есть столбцы file # и line #, но они работают только с приватными символами, которых у нас нет, потому что это код .NET Framework. Следующее лучшее, что мы можем сделать — получить адрес dll, где находится инструкция под названием Image RVA. Если загрузить эту dll в отладчик и сделать
`u xxx.dll+ImageRVA`
то мы должны увидеть инструкцию, которая сжигает большинство циклов CPU, потому что это будет единственный «горячий» адрес.
Изучим этот адрес различными методами Windbg:
`0:000> u clr.dll+0x19566B-10
clr!AwareLock::Contention+0x135:
00007ff8`0535565b f00f4cc6 lock cmovl eax,esi
00007ff8`0535565f 2bf0 sub esi,eax
00007ff8`05355661 eb01 jmp clr!AwareLock::Contention+0x13f (00007ff8`05355664)
00007ff8`05355663 cc int 3
00007ff8`05355664 83e801 sub eax,1
00007ff8`05355667 7405 je clr!AwareLock::Contention+0x144 (00007ff8`0535566e)
00007ff8`05355669 f390 pause
00007ff8`0535566b ebf7 jmp clr!AwareLock::Contention+0x13f (00007ff8`05355664)`
И различными методами JIT:
`0:000> u clr.dll+0x2801-10
clr!JIT_MonEnterWorker_InlineGetThread_GetThread_PatchLabel+0x124:
00007ff8`051c27f1 5e pop rsi
00007ff8`051c27f2 c3 ret
00007ff8`051c27f3 833d0679930001 cmp dword ptr [clr!g_SystemInfo+0x20 (00007ff8`05afa100)],1
00007ff8`051c27fa 7e1b jle clr!JIT_MonEnterWorker_InlineGetThread_GetThread_PatchLabel+0x14a (00007ff8`051c2817)
00007ff8`051c27fc 418bc2 mov eax,r10d
00007ff8`051c27ff f390 pause
00007ff8`051c2801 83e801 sub eax,1
00007ff8`051c2804 75f9 jne clr!JIT_MonEnterWorker_InlineGetThread_GetThread_PatchLabel+0x132 (00007ff8`051c27ff)`
Теперь у нас есть шаблон. В одном случае горячий адрес является инструкцией jump, а в другом случае это вычитание. Но обеим горячим инструкциям предшествует одна и та же общая инструкция pause. Разные методы выполняют одну и ту же инструкцию процессора, который по какой-то причине выполняется очень долго. Давайте замерим скорость выполнения инструкции pause и посмотрим, правильно ли мы рассуждаем.
Если проблема задокументирована, то она становится фичей
========================================================
| | |
| --- | --- |
| **CPU** | **pause в наносекундах** |
| Xeon E5 1620v3 3,5 ГГц | 4 |
| Xeon® Gold 6126 @ 2,60 ГГц | 43 |
Pause в новых процессорах Skylake выполняется на порядок дольше. Конечно, что угодно может стать быстрее, а иногда и немного медленнее. Но в **десять раз** медленнее? Это скорее похоже на баг. Небольшой поиск в интернете об инструкции паузы приводит к [руководству Intel](https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-optimization-manual.pdf), где явно упоминаются микроархитектура Skylake и инструкция паузы:
Нет, это не ошибка, это документированная функция. Есть даже [страница](http://www.agner.org/optimize/instruction_tables.pdf) с указанием времени выполнения почти всех инструкций процессора.
* Sandy Bridge 11
* Ivy Bridege 10
* Haswell 9
* Broadwell 9
* SkylakeX 141
Здесь указано количество циклов процессора. Для вычисления фактического времени нужно разделить количество циклов на частоту процессора (обычно в ГГц) и получить время в наносекундах.
Это означает, что если запустить сильно многопоточные приложения на .NET на последнем железе, то они могут работать намного медленнее. Кто-то уже заметил это и ещё в августе 2017 года [зарегистрировал баг](https://github.com/dotnet/coreclr/issues/13388). Проблему [исправили](https://github.com/Microsoft/dotnet-framework-early-access/blob/master/release-notes/build-3621/dotnet-build-3621-changes.md#clr) в .NET Core 2.1 и .NET Framework 4.8 Preview.
> Улучшенный spin-wait в нескольких примитивах синхронизации для лучшего выполнения на Intel Skylake и более поздних микроархитектурах. [495945, mscorlib.dll, Баг]
Но поскольку до выхода .NET 4.8 ещё год, я попросил бэкпортировать исправления, чтобы .NET 4.7.2 вернулся к нормальной скорости на новых процессорах. Поскольку взаимоисключающая блокировка (спинлок) есть во многих частях .NET, то следует отследить увеличенную нагрузку на CPU при работе Thread.SpinWait и других методов спиннинга.
Например, Task.Result внутренне использует спиннинг, так что я предвижу существенный рост нагрузки на CPU и снижение производительности и в других тестах.
Насколько всё плохо?
====================
Я посмотрел код .NET Core на предмет того, сколько процессор будет продолжать спиннинг, если блокировка не освобождена, прежде чем вызывать WaitForSingleObject для оплаты «дорогостоящего» переключения контекста. Переключатель контекста занимает где-то микросекунду или гораздо больше, если много потоков ожидают один и тот же объект ядра.
.NET-блокировки умножают максимальную продолжительность спиннинга на количество ядер, если брать абсолютный случай, где поток на каждом ядре ожидает одной и той же блокировки, а спиннинг продолжается достаточно долго, чтобы все немного поработали, прежде чем оплатить вызов ядра. Спиннинг в .NET использует алгоритм экспоненциальной выдержки, когда он начинается с цикла из 50-ти вызовов pause, где для каждой итерации количество спинов утраивается, пока следующий счётчик спинов не превысит их максимальную продолжительность. Я подсчитал общую продолжительность спиннинга в расчёте на процессор для различных процессоров и разного количества ядер:
Ниже упрощённый код спиннинга в .NET Locks:
```
///
/// This is how .NET is spinning during lock contention minus the Lock taking/SwitchToThread/Sleep calls
///
///
void Spin(int nCores)
{
const int dwRepetitions = 10;
const int dwInitialDuration = 0x32;
const int dwBackOffFactor = 3;
int dwMaximumDuration = 20 * 1000 * nCores;
for (int i = 0; i < dwRepetitions; i++)
{
int duration = dwInitialDuration;
do
{
for (int k = 0; k < duration; k++)
{
Call_PAUSE();
}
duration *= dwBackOffFactor;
}
while (duration < dwMaximumDuration);
}
}
```
Раньше время спиннинга находилось в миллисекундном интервале (19 мс для 24 ядер), что уже немало по сравнению с упоминавшимся временем переключения контекста, которое на порядок быстрее. Но в процессорах Skylake общее для процессора время спиннинга просто взрывается до 246 мс на 24-х или 48-ядерной машине просто потому, что инструкция pause замедлилась в 14 раз. Это действительно так? Я написал небольшой тестер для проверки общего спиннинга на CPU — и рассчитанные цифры хорошо соответствуют ожиданиям. Вот 48 потоков на 24-ядерном CPU, ожидающих одну блокировку, которую я назвал Monitor.PulseAll:
Только один поток выиграет гонку, но 47 продолжат спиннинг до потери пульса. Это экспериментальное доказательство того, что у нас действительно есть проблема с нагрузкой на CPU и очень долгий спиннинг реален. Он подрывает масштабируемость, потому что эти циклы идут вместо полезной работы других потоков, хотя инструкция pause освобождает некоторые общие ресурсы CPU, обеспечивая засыпание на более продолжительное время. Причина спиннинга — попытка быстрее получить блокировку без обращения к ядру. Если так, то увеличение нагрузки на CPU было бы лишь номинальным, но вообще не влияло на производительность, потому что ядра занимаются другими задачами. Но тесты показали снижение производительности в почти однопоточных операциях, где один поток добавляет что-то в рабочую очередь, в то время как рабочий поток ожидает результат, а затем выполняет некую задачу с рабочим элементом.
Причину проще всего показать на схеме. Спин для состязательной блокировки происходит с утроением спиннинга на каждом шаге. После каждого раунда блокировка снова проверяется на предмет того, может ли текущий поток её получить. Хотя спиннинг пытается быть честным и время от времени переключается на другие потоки, чтобы помочь им завершить свою работу. Это увеличивает шансы на освобождение блокировки при следующей проверке. Проблема в том, что проверка на взятие возможна только по завершении полного спин-раунда:
Например, если в момент начала пятого спин-раунда блокировка сигнализирует о доступности, взять её можно только по завершении раунда. Вычислив длительность спина последнего раунда, можно оценить худший случай задержки, для нашего потока:
Много миллисекунд ожидания до окончания спиннинга. Это реальная проблема?
Я создал простое тестовое приложение, в котором реализована очередь производителей-потребителей, где рабочий поток выполняет каждый элемент работы 10 мс, а у потребителя задержка 1-9 мс перед следующим рабочим элементом. Этого достаточно, чтобы увидеть эффект:
Мы видим для задержек в 1-2 мс общую продолжительность 2,2-2,3 с, тогда как в других случаях работа выполняется быстрее вплоть до 1,2 с. Это показывает, что чрезмерный спиннинг на CPU — не просто косметическая проблема чрезмерно многопоточных приложений. Она реально вредит простой поточности производителя-потребителя, включающей только два потока. Для прогона выше данные ETW говорят сами за себя: именно рост спиннинга является причиной наблюдаемой задержки:
Если внимательно посмотреть на секцию с «тормозами», мы увидим в красной области 11 мс спиннинга, хотя воркер (светло-синий) завершил свою работу и давно отдал блокировку.
Быстрый недегенативный случай выглядит намного лучше, здесь только 1 мс тратится на спиннинг для блокировки.
Я использовал тестовое приложение *SkylakeXPause*. В [zip-архиве](https://1drv.ms/u/s!AhcFq7XO98yJgsMDiyTk6ZEt9pDXGA) собраны исходный код и двоичные файлы для .NET Core и .NET 4.5. Для проведения сравнения я установил .NET 4.8 Preview с исправлениями и .NET Core 2.0, который по-прежнему реализует старое поведение. Приложение предназначено для .NET Standard 2.0 и .NET 4.5, производящих и exe, и dll. Теперь можно проверить старое и новое поведение спиннинга бок о бок без необходимости что-либо исправлять, так очень удобно.
```
readonly object _LockObject = new object();
int WorkItems;
int CompletedWorkItems;
Barrier SyncPoint;
void RunSlowTest()
{
const int processingTimeinMs = 10;
const int WorkItemsToSend = 100;
Console.WriteLine($"Worker thread works {processingTimeinMs} ms for {WorkItemsToSend} times");
// Test one sender one receiver thread with different timings when the sender wakes up again
// to send the next work item
// synchronize worker and sender. Ensure that worker starts first
double[] sendDelayTimes = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
foreach (var sendDelay in sendDelayTimes)
{
SyncPoint = new Barrier(2); // one sender one receiver
var sw = Stopwatch.StartNew();
Parallel.Invoke(() => Sender(workItems: WorkItemsToSend, delayInMs: sendDelay),
() => Worker(maxWorkItemsToWork: WorkItemsToSend, workItemProcessTimeInMs: processingTimeinMs));
sw.Stop();
Console.WriteLine($"Send Delay: {sendDelay:F1} ms Work completed in {sw.Elapsed.TotalSeconds:F3} s");
Thread.Sleep(100); // show some gap in ETW data so we can differentiate the test runs
}
}
///
/// Simulate a worker thread which consumes CPU which is triggered by the Sender thread
///
void Worker(int maxWorkItemsToWork, double workItemProcessTimeInMs)
{
SyncPoint.SignalAndWait();
while (CompletedWorkItems != maxWorkItemsToWork)
{
lock (_LockObject)
{
if (WorkItems == 0)
{
Monitor.Wait(_LockObject); // wait for work
}
for (int i = 0; i < WorkItems; i++)
{
CompletedWorkItems++;
SimulateWork(workItemProcessTimeInMs); // consume CPU under this lock
}
WorkItems = 0;
}
}
}
///
/// Insert work for the Worker thread under a lock and wake up the worker thread n times
///
void Sender(int workItems, double delayInMs)
{
CompletedWorkItems = 0; // delete previous work
SyncPoint.SignalAndWait();
for (int i = 0; i < workItems; i++)
{
lock (_LockObject)
{
WorkItems++;
Monitor.PulseAll(_LockObject);
}
SimulateWork(delayInMs);
}
}
```
Выводы
======
Это не проблема .NET. Затронуты все реализации спинлока, использующие инструкцию pause. Я по-быстрому проверил ядро Windows Server 2016, но там на поверхности нет такой проблемы. Похоже, Intel была достаточно любезна — и намекнула, что необходимы некоторые изменения в подходе к спиннингу.
О баге для .NET Core сообщили в августе 2017 года, а уже в сентябре 2017 года [вышел патч](https://github.com/dotnet/coreclr/issues/13388) и версия .NET Core 2.0.3. По ссылке видна не только великолепная реакция группы .NET Core, но и то, что несколько дней назад проблема устранена в основной ветке, а также дискуссия о дополнительных оптимизациях спиннинга. К сожалению, Desktop .NET Framework двигается не так быстро, но в лице .NET Framework 4.8 Preview у нас есть хотя бы концептуальное доказательство, что исправления там тоже реализуемы. Теперь я жду бэкпорт для .NET 4.7.2, чтобы использовать .NET на полной скорости и на последнем железе. Это первый найденный мною баг, который непосредственно связан с изменением производительности из-за одной инструкции CPU. ETW остаётся основным профайлером в Windows. Если бы я мог, то попросил бы Microsoft портировать инфраструктуру ETW на Linux, потому что текущие профайлеры в Linux по-прежнему отстойные. Там недавно добавили интересные возможности ядра, но инструментов анализа вроде WPA до сих пор нет.
Если вы работаете с .NET Core 2.0 или десктопным .NET Framework на последних процессорах, которые выпускались с середины 2017 года, то в случае проблем со снижением производительности следует обязательно проверить свои приложения профайлером — и обновиться на .NET Core и, надеюсь, вскоре на .NET Desktop. Моё тестовое приложение скажет вам о наличии или отсутствии проблемы.
`D:\SkylakeXPause\bin\Release\netcoreapp2.0>dotnet SkylakeXPause.dll -check
Did call pause 1,000,000 in 3.5990 ms, Processors: 8
No SkylakeX problem detected`
или
`D:\SkylakeXPause\SkylakeXPause\bin\Release\net45>SkylakeXPause.exe -check
Did call pause 1,000,000 in 3.6195 ms, Processors: 8
No SkylakeX problem detected`
Инструмент сообщит о проблеме, если вы работаете на .NET Framework без соответствующего апдейта и на процессоре Skylake.
Надеюсь, вам расследование этой проблемы показалось настолько же увлекательным, как и мне. Чтобы по-настоящему понять проблему, нужно создать средство её воспроизведения, позволяющее экспериментировать и искать влияющие факторы. Остальное — просто скучная работа, но теперь я намного лучше разбираюсь в причинах и последствиях циклической попытки получить блокировку в CPU. | https://habr.com/ru/post/415053/ | null | ru | null |
# [в закладки] 9 инструментов, повышающих продуктивность веб-разработчика
Интернет — это не только то место, где можно научиться программировать. Тут имеется множество полезных онлайновых инструментов, способных помочь разработчику на разных этапах работы над проектом и таким образом сэкономить немного времени.
[](https://habr.com/ru/company/ruvds/blog/479272/)
Автор статьи, перевод которой мы сегодня публикуем, отобрал 9 таких инструментов.
1. Can I Use
------------
Если вы когда-нибудь интересовались тем, совместим ли с неким браузером какой-нибудь API (`localStorage`, например), это значит, что вам пригодится сайт [Can I Use](https://caniuse.com/). Он содержит постоянно обновляемые сведения о том, какие технологии поддерживают настольные и мобильные браузеры.
*Проверка поддержки технологии localStorage различными браузерами*
2. Unminify
-----------
Ресурс [unminify.com](https://unminify.com/) — это бесплатный онлайновый инструмент для деминификации (распаковки, деобфускации) JavaScript-, CSS- и HTML-кода. Он позволяет превратить минифицированный код в код, удобный для восприятия. Это один из самых широко используемых ресурсов для приведения кода в читабельный вид.
Хотите разобраться в чьём-то коде, написанном без отступов, или изучить содержимое файла, код в котором представляет собой одну нечитабельную строку? Для того чтобы всё это сделать — достаточно вставить код в соответствующее поле на ресурсе Unminify. Это позволит буквально тут же увидеть то, что раньше выглядело непонятным, в удобной для восприятия форме.
*Ресурс unminify.com*
3. Compressor
-------------
Размеры файлов изображений — это то, что способно внести значительный вклад во время загрузки веб-страниц.
[Compressor.io](https://compressor.io/) — это ресурс, который нацелен на уменьшение размеров изображений с сохранением их качества. Этот сайт отлично справляется со своей работой. В результате между исходными и сжатыми изображениями нет почти никаких внешних различий.
*Ресурс compressor.io*
4. Cloudcraft
-------------
Проект [Cloudcraft](https://cloudcraft.co/) помогает проектировать облачные системы и рассчитывать затраты на облачные услуги. Его удобный интерфейс позволяет создавать объёмные схемы, манипулируя объектами, представляющими собой службы облачных инфраструктур (пока, правда, поддерживается только платформа [AWS](https://aws.amazon.com/)). Он, кроме того, позволяет рассчитывать стоимость использования проектируемых с его помощью облачных архитектур.
*Планирование облачной архитектуры с использованием служб AWS*
5. Repl.it
----------
На сайте [repl.it](https://repl.it/) можно найти отличную онлайновую IDE. Возможно — именно такую, которую вы давно искали. Тут, буквально за пару секунд, можно получить доступ к среде разработки, рассчитанной на практически любой язык программирования или стек технологий.
Этот проект поддерживает все современные языки программирования. Среди них — Python, [Kotlin](https://kotlinlang.org/), [Ruby](https://www.ruby-lang.org/en/), JavaScript. Здесь можно устанавливать дополнительные библиотеки или пакеты и напрямую, без необходимости загружать их на локальную машину, ими пользоваться.
Ресурс позволяет делиться ссылками на рабочее окружение, содержащее код некоего проекта.
*Разработка Express-приложения в среде Node.js*
6. RequestBin
-------------
Проект [RequestBin](https://requestbin.com/) даёт разработчику доступ к конечным точкам HTTP, способным собирать все отправленные к ним запросы. Это позволяет анализировать такие запросы, проверять их и передаваемые в них данные.
Эти возможности могут оказаться очень кстати в тех случаях, например, когда нужно отлаживать Webhook-запросы от различных сайтов, в ситуациях, когда заранее неизвестна структура таких запросов и особенности имеющихся в них данных.
*Данные, принятые конечной точкой в POST-запросе*
7. Web Code
-----------
[Web Code](https://webcode.tools/) — это один из лучших существующих генераторов кода. Он позволяет автоматически создавать код для самых разных нужд, просто задавая требования к этому коду.
Этот инструмент может оказаться весьма полезным для веб-разработчиков, которые не особенно хорошо знакомы с некоторыми аспектами HTML и CSS.
*Генерирование CSS-кода, позволяющего по-разному настроить границы элемента*
8. BundlePhobia
---------------
С тех пор, как появились современные фронтенд-фреймворки, разработчики стремятся к тому, чтобы как можно сильнее сократить размеры бандлов своих приложений и снизить таким образом время загрузки своих проектов пользователями.
Ресурс [BundlePhobia](https://bundlephobia.com/) призван помочь разработчикам в деле анализа того, насколько некий npm-пакет способен увеличить размер сборки приложения.
На этот сайт можно загрузить файл `package.json` и получить сводку по используемым в проекте пакетам. Тут можно выяснить подробности и об отдельном пакете.
*Выяснение размера библиотеки pdfmake*
9. Fingerprint.js
-----------------
Никого в наши дни не удивишь тем, что сбор уникальных идентификаторов браузеров через веб-сайт — это непростая задача.
Упростить решение этой задачи можно с помощью замечательной библиотеки [fingerprint.js](https://fingerprintjs.com/). Она помогает формировать особые идентификаторы браузеров, не используя при этом куки-файлы, или такие данные, на которые легко могут воздействовать недобросовестные пользователи. Она позволяет быстро собирать подробные сведения о браузере, которые можно использовать либо в исходном виде, либо — создавая на их основе хэш, который позволяет идентифицировать уникального пользователя.
Это библиотека позволяет формировать нечто вроде аналога идентификатора мобильного устройства UUID. Пользоваться ей можно и через CDN, и установив её в виде npm-пакета.
*Извлечение из браузера информации о пользователе*
**Уважаемые читатели!** Какие инструменты, повышающие продуктивность веб-разработчика, вы добавили бы в этот список?
[](https://ruvds.com/ru-rub)
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/479272/ | null | ru | null |
# goader — консольный бенчмарк с уклоном на запись-чтение файлов
*goader* — консольный бенчмарк с простой конфигурацией и поддержкой различных бэкендов для тестирования. Название происходит от go и loader, а также имеет свое значение на английском, "подгонять копьем, палкой"
На данный момент можно тестировать (аргумент *-requests-engine*):
* http (GET запросы либо GET+PUT)
* disk
* s3 (С авторизацией по ACCESS/SECRET keys, endpoint необходим, но это дает возможность проверять private s3, signature ver4 на данный момент не поддерживается, но планирую)
* null и sleep для тестирования самого бенчмарка
Уклон сделан на запись и считывание файлов, не страничек
### Пример использования
```
goader -rps=300 -wps=150 -min-body-size=1 -max-body-size=128k --max-requests=1000 -requests-engine=disk -url=tmp/NN/RRRRR
```
Точки появляются в реальном времени в соответствии с каждым запросом, мне в свое время это позволило визуально выявить проблемы, в том случае, что цифры мало что дали бы. В случае ошибок на их месте будет E
Существует немало утилит для нагрузочного тестирования, но лично у меня к ним ряд претензий, что и сподвигло написать свой...
Проблема номер 1, что мы тестируем?
-----------------------------------
Упор на “кол-во параллельных тредов”, поиск максимальной нагрузки, максимального кол-ва тредов. Либо фиксированное кол-во тредов. Это конечно здорово, но лично у меня, в реальной жизни, при замене какого либо компонента системы достаточно редко возникал именно этот вопрос, сколько же оно потянет. При замене компонентов куда чаще вопроса два и они другие:
а) Отклик при заранее известной нагрузке. Как например 50 PUT/s, 300 GET/s. Проверяем время отклика на старой и новой системе. От замены компонентов кол-во пользователей не вырастет, цель как правило — улучшить отзывчивость системы.
```
goader -rps=300 -wps=50 -min-body-size=1 -max-body-size=128k -requests-engine=upload -url=http://localhost/files/user_NNNNN/file_RRRR
```
б) Мы все таки хотим дать больше, чем было, хотим знать максимум системы. Опять таки, что это такое? Кол-во клиентов которые сервер может выдержать? Кол-во параллельных клиентов которые получают Н-ый процент ошибок? Очень часто ошибок нет, а просто получаем огромное время отклика.
Поэтому для себя максимум системы я определил как “кол-во параллельных клиентов, при котором время отклика не превышает заданное значение".
```
goader -rpw 2 -max-latency 5ms -requests-engine=disk -url=tmp/RRRRRRR -body-size=4k -max-requests=30000
```
Нагрузка выравнивается по WRITE-ам (PUT/WriteFile), кол-во READ-ов установлено относительно WRITE-ов, т.е reads-per-write, чтений на запись — в примере 2, может быть дробным числом.
Кол-во тредов будет адаптироваться под задержки и на выходе получим число одновременных клиентов которые мы можем выдержать с данной загрузкой. Опционально максимум можно ограничить-увеличить аргументом -max-channels, по дефолту 32.
Традиционное “кол-во одновременных клиентов” так же существует, -wt=5 -rt=10 (5 тредов на запись, 10 на на чтение).
Это 2 режима, которых мне не хватало. Но была у проверенных мной бенчмарков еще проблема номер 2.
Сложность конфигурации
----------------------
Дополнительным требованием, выставленным себе, было отсутствие UI и файлов конфигурации. Это конечно очень круто когда настроек миллион и возможности безграничны, но для этого нужна еще одна мощная машина, UI, пол дня на написание конфигурации и потом таскать эти файлы за собой. Безусловно, иногда это все таки плюс, мне было важно иметь возможность подключиться на любой из серверов и иметь возможность запустить, в ручную, по памяти тест системы. Либо послать сотрудникам в слеке короткое сообщение с командой, а дальше они все сделают сами. В крайнем случае подсмотрят в goader --help и опять таки доделают все сами.
Пока что, удается обходиться без файлов конфигурации, и я надеюсь так это и оставить.
Например, зачастую, список путей предоставляется отдельным файлом. Альтернатива: `-url=http://127.0.0.1/user/NNNN/images/RRRRRRR.jpg`
NNNN — будет заменено случайными числами
RRRRRRR — будет заменено случайными буквами
XXXXX — будет заменено последовательно увеличивающимися числами
Наглядность
-----------
Цифры цифрами, а порой глазами можно увидеть аномалии, которые сложно увидеть цифрами, не зная что искать. Каждый запрос отображается в консоли точкой(зеленая — чтение, синяя — запись), ошибка E, смена кол-ва тредов стрелкой вверх либо вниз.
Эта функция позволила найти нам проблемы в системе, так как мы смогли визуально увидеть, как просела производительность в определенный момент.
Помимо этого, конечный результат так же стремится быть лаконичным и информативным. Есть возможность заменить его на json, `-output=json/human`
Порой точки мешают, их можно отключить `-show-progress=false`
При большом кол-ве запросов, либо при удаленном исполнении, глазами бывает трудно увидеть прогресс, для этого есть экспериментальная функция создания html файла с визуальным отображением (`-timeline-file=timeline.html`), когда запрос вышел и сколько времени он занял. Есть планы по улучшению, сменить отображение времени жизни запроса на вертикальное и тогда будет куда более наглядно, в какое время сколько запросов существовало. Но пока что это не приоритет.
#### Поддержка простых http запросов
Под простыми я подразумеваю только GET-запросы к страничками, без PUT-ов используя все вышеописанное. Это не было приоритетом, но использовать можно.
Запросов в секунду:
```
goader -rps=300 --max-requests=1000 -url=http://localhost/user/NN/product/RRRR
```
Кол-во одновременных клиентов:
```
goader -rt=32 --max-requests=1000 -url=http://localhost/user/NN/product/RRRR
```
Поиск максимального кол-ва одновременных клиентов с заданной максимальной задержкой:
```
goader -wt=0 -max-latency=300ms --max-requests=1000 -url=http://localhost/user/NN/product/RRRR
```
Лучше делать большее кол-во запросов в этом режиме, для более точных результатов.
К слову, это был мой первый опыт с go, хотелось на практике проверить восторженные отзывы, не могу сказать, что я их не поддерживаю. Да, есть свои недостатки, но в целом, быстрая компиляция, быстрая проверка ошибок, единая экосистема, простая система типов — все это позволяет как модно утверждать, сконцентрироваться на коде, а не особенностях экосистемы.
А то, что, без лишней магии на выходе получаются бинарники под все системы — вообще прелесть.
На гитхаб заливаю только linux/386 linux/amd64 windows/amd64 darwin/386 darwin/amd64, но если кому то необходимо расширить этот список — то без проблема. В рамках поддерживаемого самим golang-ом. Комментарии по поводу самого кода тоже приветствуются.
Скачать можно с [Github](https://github.com/tigrawap/goader/releases) либо собрать самим, лицензия MIT. Для удобства использования лучше положить в $PATH. | https://habr.com/ru/post/314220/ | null | ru | null |
# Работа с ветками SVN
Прежде чем приступать вообще к использованию веток, и даже если вы и не думаете их использовать, необходимо прочесть [Этот Священный Талмуд](http://svnbook.red-bean.com/nightly/ru/svn-book.html#svn.branchmerge.using.create).
После того как вы прочли статью о ветках в svnbook, вы уже понимаете для чего нужны ветки, как с ними работать и в каких случаях их необходимо использовать. В принципе, после этого, то, что написано под катом вам уже скорее всего не нужно. Но если вам было лень читать, то может текст ниже вас заинтересует, и вы все таки прочтете статью документации. А может, просто поможет вам лучше понять то, что только что прочли в svnbook-е.
**Для чего все это?**Допустим у вас задача, которая займет времени больше чем один день. Политика частых коммитов предполагает, что мы коммитимся чаще чем 1 раз в день. Это позволяет нам чаще получать изменения, и избегать конфликтов. Если изменений в ревизии не много, то вероятность конфликтов уменьшается. Так же мы страхуемся от форс мажоров, вдруг что гафкнется — мы не потеряем недельную работу.
Но иногда задача длинная, а закоммититься где нибудь посредине мы не можем, по причине что недоделанная задача, закомиченная в основной код, может мешать другим разработчикам в их работе. Но не коммитится несколько дней тоже неправильно. Во-вторых, может понадобиться выгрузка кода на продакшен. Если мы коммитим в основную ветку недоделанную задачу, она попадет на продакшен, что не кошерно. Для этого существуют ветки. Они позволяют нам комитится в любое удобное для нас время, при этом не мешая всем остальным. Так же ветки позволяют работать над несколькими задачами параллельно, не перемешивая их.
**Что такое ветка?**
Это всего лишь копия директории svn. Точнее так называемая «легкая копия», содержащая только изменения. Одинаковые файлы не копируются. Ветка имеет общую историю до момента её создания с основной веткой. В общем случае веток может быть сколько угодно, и каждая из них может ветвиться. Но в стандартом проекте принято иметь три постоянных ветки:
\* **trunk** — основная линия разработки. Здесь будет актуальный на данный момент код, здесь будут выполняться мелкие задачи и правки багов.
\* **branches** — ветка для разработчиков. гсуто ветвится другими ветками. Именно в ней вы будете создавать свои ветки.
\* **tags** — ветка тэгов. Тут создаются всякие метки, отмечающие значимые вехи развития проектов, проще говоря его стабильные и не очень версии. Нужна она для того, что бы всегда можно было вернуться до какой нибудь версии, например что бы посмотреть «почему эта хрень раньше работала а потом перестала, сцуко»
Программисты отвечают за то, что бы
\* **Создать ветку тогда когда это нужно** для стабильного существования проекта. В общем случае если вы чувствуете что задача будет длиться больше пары дней (а иногда и дня), и все это время вы не сможете безболезненно коммититься хотя бы пару раз в день, вам нужна ветка.
\* **Поддерживать свою ветку в актуальном состоянии** — то есть необходимо избавиться от панического страха перед командой merge как можно раньше, и мержить не реже чем комитишь. Иначе конфликтов при сливании ветки с транком не избежать.
\* **Удалить ветку после завершения задачи**. Ветки разработчиков — временные ветки, поэтому они должны удаляться, когда задача завершена. В крайнем случае, они могут пожить еще несколько дней, для уверенности, что в задаче нет больших ошибок. Дальше ветка никому нужна не будет, её можно удалять. Все равно, через некоторое время, она так далеко отойдет от основной линии разработки, что уже никакой мердж не сможет ей вернуть актуальность.
**Как работать с ветками**
Создать новую ветку очень просто. Как следует из талмуда, делается это командой copy. Допустим, мы разрабатываем некий проект — BUMP (Большой Афигенный Мега Проект). Для нашего случая, нужно выполнить такую команду:
`svn copy svn://svnserver/var/bump/trunk svn://svnserver/var/bump/branches/my-branch -m="Creating a private branch of /bump/trunk"`
Для того, что бы переключиться в новую ветку:
s`vn switch svn://svnserver/var/bump/branches/my-branch`
Для того что бы проверить в какой ветке находитесь сейчас
`svn info`
Переключившись в новую ветку, вы можете вносить правки, коммитить, и никто другой ничего не заметит. Но надо помнить, что команда switch очень похожа на команду update, поэтому, если вы будете переключаться из одной ветки в другую, вы можете получить конфликты, если были правки в одном и том же файле. Именно поэтому, надо почаще мержить изменения из основной ветки.
**Копирование изменений между ветками**
Для того что бы держать свою ветку в актуальном состоянии, вам необходимо периодически копировать изменения из основной ветки. Это необходимо для того, что бы избежать конфликтов при слиянии веток или при переключении в основную ветку. Поэтому мержится нужно почаще, хотя бы раз-два за день. Можно взять за правило: мержиться перед каждым коммитом. Команада merge, наверное, самая сложная из команд svn. И все дело в том, что svn не помнит о ваших предыдущих мержах (до версии 1.5). А раз не помнит, значит вы рискуете скопировать себе изменения, которые уже у вас есть, после предыдущего мержа. Но этот недостаток легко обойти. После каждого копирования изменений себе в рабочую копию, вам необходимо закомитить их в свою ветку. В комментарии укажите диапазон ревизий, включенных в ваш текущий мерж. То есть например так: «merged from trunk r1234:1256». Этот комментарий будет служить вам памяткой, и вы в любой момент сможете посмотреть когда вы последний раз мержились и какая ревизия является последней. Такие комментарии включать обязательно, иначе, будут большие проблемы и непонятки. И еще. Для того что бы быть уверенным что все смержится удачно, можно сначала, перед реальным копированием, сделать проверочное. Для этого используется параметр --dry-run который только показывает вывод, не внося изменений в рабочую копию.
Итак, посомтреть изменения из транка можно такой командой:
`svn merge -r4106:HEAD svn://svnserver/var/bump/trunk ./ --dry-run`
Получаем, например, такой вывод:
`--- Merging r4107 into '.':
U db/queries.txt
U ejb/src/main/java/ru/bump/action/folder/MoveFolderActionLocal.java
U ejb/src/main/java/ru/bump/action/user/UserRegistrationAction.java`
Это означает что в ревизии r4107 изменилось 3 файла. Отлично, все правильно, копируем изменения
`svn merge -r4106:HEAD svn://svnserver/var/bump/trunk ./`
И комитимся:
`svn ci -m "merged from trunk r4106:4108"`
Число 4108 это номер текущей ревизии. Получить его просто. Достаточно выполнить команду svn up.
Заметьте, что число 4106, в этом случае, это ревизия создания нашей ветки. Когда вы будете первый раз мержиться, вам нужно будет узнать номер этой ревизии. Это легко, достаточно выполнить команду
`svn log --stop-on-copy`
Далее вам это число больше не понадобиться. Номер нужной ревизии вы сможете узнать из вашего же комментария. Таким образом, когда вы будете мержить в следующий раз вам необходимо выяснить номер ревизии последнего мержа. Например в Linux я делаю так:
`#:~/www/bump$ svn log | grep merged
merged from trunk r4106:4108`
Таким образом, что бы смержить еще раз из транка нужно выполнить команду
`svn merge -r4109:HEAD svn://svnserver/var/bump/trunk ./`
**Завершение работы над задачей**
Если работа над задачей завершена, вам нужно
\* Слить свои изменения в транк
\* Удалить свою ветку что бы не мешалась
Сливаем в транк той же командой merge. Для этого выясняем ревизию создания ветки, и свитчимся в транк.
`svn switch svn://svnserver/var/bump/trunk`
После этого копируем изменения из своей ветки
`#svn up
At revision 4155
#svn merge svn://svnserver/var/bump/trunk@4155 svn://svnserver/var/bump/branches/my-branch@4155`
Если все прошло нормально, нет никаких конфликтов и доделать ничего не нужно, комитим изменения в основную ветку, а свою ветку можно теперь удалить. Она совсем не отличается от транка, и в случае надобности мы всегда сможем создать еще одну ветку. Да и стоит помнить что наша ветка конечно же не удаляется физически, просто она удаляется из HEAD, но в ранних ревизиях мы всегда сможем её отыскать, и при необходимости востановить. Так что смелее:
`svn delete svn://svnserver/var/bump/branches/my-btanch -m "Removing my-branch branch."`
Между прочим, удаление ветки, после слития задачи в транк, не строго обязательно. Удаление ветки обязательно при завршении задачи, а слитие в транк вовсе не означает что задача полностью завершена. Теоретически сливать свои изменения (как полностью так и частично) вы можете и несколько раз в течении работы над задачей, например, если задача разбита на этапы, каждый из которых является законченным и работоспособным. Или, например изменения которые вы сделали нужны (или могут пригодиться) другим разработчикам, но при этом не мешают работе всего приложения (новая либа, или дополнения к интерфейсу существующих либ и классов). Вообщем, решение об мёрже своих изменений в транк должен принимать программист (или группа) — владелец ветки. Что конечно не исключает варианта с кем нибудь посоветоваться в случае если есть сомнения.
В принципе, желательно стараться не допускать каких-то значительных расхождений транка и других веток, если, конечно, это не мешает проекту.
**Заключение**
В этой статье содержится лишь малая часть сведений о работе с ветками. Она может служить как памятка, но не как самоучитель. Поэтому настоятельно рекомендуется прочесть соответствующий раздел svnbook. В нем содержится множество сведений которые не попали в этот опус, но необходимы для понимания того как работать с ветками. | https://habr.com/ru/post/45203/ | null | ru | null |
# Объясняя необъяснимое. Часть 5
*Мы продолжаем готовиться к PG Day’16 и знакомить вас с интересными возможностями PostgreSQL.*
В [предыдущих](https://habrahabr.ru/post/275851/) [постах](https://habrahabr.ru/post/276973/) [этой](https://habrahabr.ru/post/279255/) [серии](https://habrahabr.ru/post/281036/) я говорил о том, как читать вывод EXPLAIN и что означает каждая строка (операция/узел).
В заключительном посте я постараюсь объяснить, почему Постгрес выбирает «Операцию X», а не «Операцию Y».
Возможно, вы слышали, что планировщик PostgreSQL выбирает операции, основываясь на статистике. Какой статистике?
Давайте представим самый простой сценарий из возможных:
```
SELECT * FROM table WHERE column = some_value;
```
Если у всех строк в таблиц одинаковое значение some\_value, тогда применение к столбцу индекса (потенциально существующего) не имеет смысла.
С другой стороны, если значения в столбце уникальны (или почти уникальны), использование индекса – отличная идея.
Давайте посмотрим, что происходит:
```
create table test ( all_the_same int4, almost_unique int4 );
CREATE TABLE
insert into test ( all_the_same, almost_unique )
select 123, random() * 1000000 from generate_series(1,100000);
INSERT 0 100000
```
Итак, у меня есть таблица на 100,000 строк, в которой столбец «all\_the\_same» всегда имеет одинаковые значения (123), а столбец almost\_unique, как понятно из названия, почти уникален:
```
select count(*), count(distinct almost_unique) from test;
count | count
--------+-------
100000 | 95142
(1 row)
```
Теперь, чтобы сделать их равными, я создам два простых индекса:
```
create index i1 on test (all_the_same);
CREATE INDEX
create index i2 on test (almost_unique);
CREATE INDEX
```
Ок, тестовая конфигурация готова. А как насчет планов?
```
explain select * from test where all_the_same = 123;
QUERY PLAN
------------------------------------------------------------
Seq Scan on test (cost=0.00..1693.00 rows=100000 width=8)
Filter: (all_the_same = 123)
(2 rows)
explain select * from test where almost_unique = 123;
QUERY PLAN
---------------------------------------------------------------
Index Scan using i2 on test (cost=0.29..8.31 rows=1 width=8)
Index Cond: (almost_unique = 123)
(2 rows)
```
Как видите, Постгрес сделал мудрый выбор. Но здесь вызывает интерес оценочное значение «rows=». Откуда он знает, сколько строк может вернуть запрос?
Ответ лежит в команде [ANALYZE](http://www.postgresql.org/docs/current/interactive/sql-analyze.html) или [VACUUM ANALYZE](http://www.postgresql.org/docs/current/interactive/sql-vacuum.html).
Когда вы применяете к таблице «ANALYZE», Постгрес берет некий «случайный образец» (random sample) (через секунду расскажу об этом подробнее) и получает какие-то статистические данные. Что это за статистика, где она, и можем ли мы её увидеть? Конечно, можем:
```
select * from pg_statistic where starelid = 'test'::regclass;
-[ RECORD 1 ]-----------------------------------------------------------------------------
starelid | 16882
staattnum | 1
stainherit | f
stanullfrac | 0
stawidth | 4
stadistinct | 1
stakind1 | 1
stakind2 | 3
stakind3 | 0
stakind4 | 0
stakind5 | 0
staop1 | 96
staop2 | 97
staop3 | 0
staop4 | 0
staop5 | 0
stanumbers1 | {1}
stanumbers2 | {1}
stanumbers3 | [null]
stanumbers4 | [null]
stanumbers5 | [null]
stavalues1 | {123}
stavalues2 | [null]
stavalues3 | [null]
stavalues4 | [null]
stavalues5 | [null]
-[ RECORD 2 ]-----------------------------------------------------------------------------
starelid | 16882
staattnum | 2
stainherit | f
stanullfrac | 0
stawidth | 4
stadistinct | -0.92146
stakind1 | 1
stakind2 | 2
stakind3 | 3
stakind4 | 0
stakind5 | 0
staop1 | 96
staop2 | 97
staop3 | 97
staop4 | 0
staop5 | 0
stanumbers1 | {0.0001,0.0001,0.0001,0.0001,0.0001,0.0001,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05}
stanumbers2 | [null]
stanumbers3 | {-0.000468686}
stanumbers4 | [null]
stanumbers5 | [null]
stavalues1 | {21606,27889,120502,289914,417495,951355,283,1812,3774,6028,6229,10372,12234,13291,18309,18443,21758,22565,26634,28392,28413,31208,32890,36563,39277,40574,44527,49954,53344,53863,56492,56715,60856,62993,64294,65275,65355,68353,71194,74718,77205,82096,82783,84764,85301,87498,90990,94043,97304,98779,101181,103700,103889,106288,108562,110796,113154,117850,121578,122643,123874,126299,129236,129332,129512,134430,134980,136987,137368,138175,139001,141519,142934,143432,143707,144501,148633,152481,154327,157067,157799,162437,164072,164337,165942,167611,170319,171047,177383,184134,188702,189005,191786,192718,196330,197851,199457,202652,202689,205983}
stavalues2 | {2,10560,20266,31061,40804,50080,59234,69240,79094,89371,99470,109557,119578,130454,140809,152052,162656,173855,183914,194263,204593,214876,224596,233758,243246,253552,264145,273855,283780,294475,303972,314544,324929,335008,346169,356505,367395,376639,387302,397004,407093,416615,426646,436146,445701,455588,466463,475910,485228,495434,505425,515853,525374,534824,545387,554794,563591,573721,584021,593368,602935,613238,623317,633947,643431,653397,664177,673976,684042,694791,703922,714113,724602,735848,745596,754477,764171,772535,781924,791652,801703,812487,822196,831618,841665,850722,861532,872067,881570,891654,901595,910975,921698,931785,940716,950623,960551,970261,979855,989540,999993}
stavalues3 | [null]
stavalues4 | [null]
stavalues5 | [null]
```
Эта таблица (pg\_statistic), безусловно, описана [в документации](http://www.postgresql.org/docs/current/interactive/catalog-pg-statistic.html), но всё равно довольно загадочна. Конечно, вы можете найти очень точное объяснение [в исходниках](http://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/include/catalog/pg_statistic.h), но это (обычно) не лучшее решение.
К счастью, существует view для этой таблицы, который содержит те же самые данные в более «читабельном» представлении:
```
select * from pg_stats where tablename = 'test';
-[ RECORD 1 ]----------+------------------------------------------------------------------
schemaname | public
tablename | test
attname | all_the_same
inherited | f
null_frac | 0
avg_width | 4
n_distinct | 1
most_common_vals | {123}
most_common_freqs | {1}
histogram_bounds | [null]
correlation | 1
most_common_elems | [null]
most_common_elem_freqs | [null]
elem_count_histogram | [null]
-[ RECORD 2 ]----------+------------------------------------------------------------------
schemaname | public
tablename | test
attname | almost_unique
inherited | f
null_frac | 0
avg_width | 4
n_distinct | -0.92146
most_common_vals | {21606,27889,120502,289914,417495,951355,283,1812,3774,6028,6229,10372,12234,13291,18309,18443,21758,22565,26634,28392,28413,31208,32890,36563,39277,40574,44527,49954,53344,53863,56492,56715,60856,62993,64294,65275,65355,68353,71194,74718,77205,82096,82783,84764,85301,87498,90990,94043,97304,98779,101181,103700,103889,106288,108562,110796,113154,117850,121578,122643,123874,126299,129236,129332,129512,134430,134980,136987,137368,138175,139001,141519,142934,143432,143707,144501,148633,152481,154327,157067,157799,162437,164072,164337,165942,167611,170319,171047,177383,184134,188702,189005,191786,192718,196330,197851,199457,202652,202689,205983}
most_common_freqs | {0.0001,0.0001,0.0001,0.0001,0.0001,0.0001,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05}
histogram_bounds | {2,10560,20266,31061,40804,50080,59234,69240,79094,89371,99470,109557,119578,130454,140809,152052,162656,173855,183914,194263,204593,214876,224596,233758,243246,253552,264145,273855,283780,294475,303972,314544,324929,335008,346169,356505,367395,376639,387302,397004,407093,416615,426646,436146,445701,455588,466463,475910,485228,495434,505425,515853,525374,534824,545387,554794,563591,573721,584021,593368,602935,613238,623317,633947,643431,653397,664177,673976,684042,694791,703922,714113,724602,735848,745596,754477,764171,772535,781924,791652,801703,812487,822196,831618,841665,850722,861532,872067,881570,891654,901595,910975,921698,931785,940716,950623,960551,970261,979855,989540,999993}
correlation | -0.000468686
most_common_elems | [null]
most_common_elem_freqs | [null]
elem_count_histogram | [null]
```
Отлично. Так какие же знания мы можем отсюда почерпнуть?
Столбцы schemaname, tablename и attname кажутся очевидными. Inherited просто сообщает, содержат ли значения этой таблицы значения из любых таблиц, которые унаследовали этот столбец.
Так что, если бы я создал таблицу:
```
create table z () inherits (test);
```
А потом добавил в эту таблицу z какие-то данные, то статистика таблицы test показала бы «inherited = true».
Остальные столбцы означают следующее:
* null\_frac — сколько строк имеют значение null в данном столбце. Это доля, поэтому значение будет от 0 до 1.
* avg\_width — средняя ширина (прим. пер.: размер) данных в этом столбце. Это не очень интересно, если ширина постоянна (как у int4 в этом примере), а вот в случае с любыми типами данных с переменной шириной (как у text/varchar/numeric) это может пригодиться.
* n\_distinct — очень интересная величина. Если она положительная (1+), то это будет просто ориентировочное число (не доля!) различных значений, как мы видим в случае со столбцом all\_the\_same, где n\_distinct справедливо равна 1. А если она отрицательная, то смысл меняется: n\_distinct показывает, какая доля строк имеет уникальное значение. Поэтому, в случае с almost\_unique статистика полагает, что 92.146% строк имеют уникальное значение (что немного меньше 95.142%, которые я показывал ранее). Значения могут быть неверны из-за той штуки с «случайным образцом», которую я уже упоминал и чуть позже объясню подробно.
* most\_common\_vals — массив наиболее распространенных значений в этой таблице.
* most\_common\_freqs — как часто встречаются значения из most\_common\_vals — это тоже доля, так что максимальное значение — 1 (но это будет означать, что у нас всего одно значение в most\_common\_vals). Здесь, в almost\_unique, мы видим, что Постгрес «думает», что значения 21606, 27889, 120502, 289914, 417495, 951355 встречаются чаще всего, но это не так. Опять же, во всём виноват эффект «случайного образца».
* histogram\_bounds — массив значений, который делит (или должен делить — снова всё упирается в «случайный образец») весь набор данных на группы с одинаковым количеством строк. То есть количество строк almost\_unique между 2 и 10560 такое же (более-менее), как и количество строк almost\_unique между 931785 и 940716.
* correlation — это очень интересная статистика, она показывает, есть ли корреляция между физической сортировкой строк на диске и значениями. Эта величина может меняться от -1 до 1, и чем ближе она к -1/1, тем больше корреляция. Например, после запуска «CLUSTER test using i2», который пересортировывает таблицу в порядке almost\_unique, я получил корреляцию 0.919358 — гораздо лучше по сравнению с предыдущим значением -0.000468686.
most\_common\_elems, most\_common\_elem\_freqs и elem\_count\_histogram такие же, как most\_common\_vals, most\_common\_freqs и histogram\_bounds, но для нескалярных типов данных (то есть, arrays, tsvectors и alike).
Основываясь на этих данных, PostgreSQL может приблизительно оценить, сколько строк будет возвращено любой выбранной частью запроса, и, исходя из этой информации, решить, что лучше использовать: seq scan, index scan или bitmap index scan. А при объединении — какая операция должна быть быстрее: Hash Join, Merge Join или, быть может, Nested Loop.
Если вы внимательно изучили представленные выше данные, то могли задаться вопросом: это достаточно обширный набор выходных данных, в массивах most\_common\_vals/most\_common\_freqs/histogram\_bounds содержится много значений. Почему же их так много?
Причина проста — всё дело в настройках. В postgresql.conf вы можете найти переменную default\_statistics\_target. Эта переменная говорит Постгресу, сколько значений хранить в этих массивах. В моём случае (по умолчанию) это число равно 100. Но вы можете легко изменить его. Внести изменение в postgresql.conf, или даже для каждого отдельно взятого столбца вот таким образом:
```
alter table test alter column almost_unique set statistics 5;
```
После применения ALTER (и ANALYZE) данные в pg\_stats существенно укорачиваются:
```
select * from pg_stats where tablename = 'test' and not inherited and attname = 'almost_unique';
-[ RECORD 1 ]----------+---------------------------------------------------------
schemaname | public
tablename | test
attname | almost_unique
inherited | f
null_frac | 0
avg_width | 4
n_distinct | -0.92112
most_common_vals | {114832,3185,3774,6642,11984}
most_common_freqs | {0.0001,6.66667e-05,6.66667e-05,6.66667e-05,6.66667e-05}
histogram_bounds | {2,199470,401018,596414,798994,999964}
correlation | 1
most_common_elems | [null]
most_common_elem_freqs | [null]
elem_count_histogram | [null]
```
Изменение statistic target также имеет ещё один эффект.
Давайте я вам покажу. Для начала я откачу изменения в подсчете статистики, которые я внёс с помощью ALTER TABLE:
```
alter table test alter column almost_unique set statistics -1;
```
А теперь сделаем следующее:
```
$ analyze verbose test;
INFO: analyzing "public.test"
INFO: "test": scanned 443 of 443 pages, containing 100000 live rows and 0 dead rows; 30000 rows in sample, 100000 estimated total rows
ANALYZE
$ alter table test alter column almost_unique set statistics 10;
ALTER TABLE
$ alter table test alter column all_the_same set statistics 10;
ALTER TABLE
$ analyze verbose test;
INFO: analyzing "public.test"
INFO: "test": scanned 443 of 443 pages, containing 100000 live rows and 0 dead rows; 3000 rows in sample, 100000 estimated total rows
ANALYZE
```
Заметьте, что второй analyze протестировал всего 3000 строк, а не 30000, как первый.
Это и есть «случайный образец».
Анализ всех строк будет непомерно затратным для любой средней или большой таблицы.
Поэтому Постгрес поступает умнее.
Во-первых, он читает случайную часть страниц в таблице (напоминаю: каждая страница — это 8кБ данных). Сколько именно? 300 \* statistics\_target.
Это значит, что в моём случае с default\_statistics\_target = 100 он прочитает 30000 страниц (в моей таблице столько нет, поэтому Постгрес прочитает их все).
Из этих страниц ANALYZE берет только информацию о живых и мёртвых строках. Затем он получает данные о случайном образце строк — снова 300 \* statistics target — и считает статистику по столбцу, основываясь на этих данных.
В моём случае в таблице было 100,000 строк, но с default\_statistics\_target = 100 только треть была проанализирована. А, с учетом значения statistics target, количество проанализированных строк ещё меньше — всего 3000.
Вы могли бы сказать: ОК, но в таком случае эта статистика неточная. Может так случиться, что какое-нибудь супер-распространенное значение не попалось ни в одной из просканированных строк. Конечно, вы правы. Это возможно. Хотя и не слишком вероятно. Вы берете случайную часть данных. Шансы, что вы получите x% таблицы, в которой нет ни одной строки с каким-то значением, которое присутствует во всех остальных строках, ничтожно малы.
Это также значит, что в некоторых случаях запуск analyze будет «ломать» ваши запросы. Например, вы получите статистику по другим страницам, и выйдет так, что некоторые значения окажутся пропущены (или наоборот — вы получите в most\_common\_vals не такие уж распространенные значения, просто так получилось, что Постгрес выбрал подходящие страницы/строки, чтобы их увидеть). И на основании такой статистики Pg будет генерировать неоптимальные планы.
Если вы столкнётесь с такой ситуацией, решить её достаточно просто — увеличьте statistics target. Это заставит analyze работать усерднее и сканировать больше строк, поэтому шансы, что подобное повторится, станут ещё меньше.
Но в установке больших значений statistics target есть определенные недостатки. Во-первых, ANALYZE приходится больше работать, но это вопрос эксплуатации, так что он нас не слишком волнует (обычно). Основная же проблема заключается в том, что, чем больше данных в pg\_statistic, тем больше данных должно приниматься во внимание планировщиком Pg. Поэтому, как бы ни было заманчиво установить default\_statistics\_target на максимум в 10,000, в реальности я не встречал баз данных, в которых это значение было бы таким высоким.
Текущие 100 по умолчанию установлены, начиная с версии 8.4. В предыдущих версиях значение по-умолчанию было 10, и на irc часто встречались советы его увеличить. Теперь со значением 100 всё более-менее настроено.
Последнее, о чем мне придётся рассказать, хоть и не очень хочется, — настройки, которые заставляют планировщик Постгреса использовать разные операции.
Во-первых, объясню, почему мне не хочется об этом говорить: я точно знаю, что этим можно легко злоупотребить. Так что запомните: эти настройки нужны для поиска проблем, а не для их решения. Приложение, которое будет использовать их в рабочем режиме, можно, как минимум, заподозрить в том, что оно сломано. И да, я знаю, что иногда приходится так делать. Но это «иногда» случается крайне редко.
Теперь, когда я вас предупредил, давайте посмотрим, что можно сделать.
В postgresql.conf у вас есть несколько настроек:
```
enable_bitmapscan = on
enable_hashagg = on
enable_hashjoin = on
enable_indexscan = on
enable_indexonlyscan = on
enable_material = on
enable_mergejoin = on
enable_nestloop = on
enable_seqscan = on
enable_sort = on
enable_tidscan = on
```
Эти настройки нужны для отключения выбранных операций.
Например, переключение enable\_seqscan на false (это можно сделать с помощью команды SET в сессии SQL, вам не нужно изменять postgresql.conf) приведёт к тому, что планировщик будет использовать всё, что только можно, дабы избежать последовательного сканирования.
А, поскольку иногда избежать последовательное сканирование невозможно (например, если в таблице нет индексов), эти настройки на самом деле не отключают операции, а просто привязывают к их использованию огромные затраты.
Приведем пример. В отношении нашей тестовой таблицы мы знаем, что поиск с помощью «all\_the\_same = 123» будет использовать последовательное сканирование, потому что оно не требует больших затрат:
```
explain select * from test where all_the_same = 123;
QUERY PLAN
------------------------------------------------------------
Seq Scan on test (cost=0.00..1693.00 rows=100000 width=8)
Filter: (all_the_same = 123)
(2 rows)
```
Но если мы отключим seq scan:
```
set enable_seqscan = false;
SET
explain select * from test where all_the_same = 123;
QUERY PLAN
-----------------------------------------------------------------------
Index Scan using i1 on test (cost=0.29..3300.29 rows=100000 width=8)
Index Cond: (all_the_same = 123)
(2 rows)
```
Мы видим, что оценочная стоимость получения тех же данных с помощью index scan ~ в два раза выше (3300.29 против 1693).
Если я удалю i1 индекс:
```
drop index i1;
DROP INDEX
set enable_seqscan = false;
SET
explain select * from test where all_the_same = 123;
QUERY PLAN
-----------------------------------------------------------------------------
Seq Scan on test (cost=10000000000.00..10000001693.00 rows=100000 width=8)
Filter: (all_the_same = 123)
(2 rows)
```
И мы видим, что, когда других возможностей, кроме последовательного сканирования, нет (интересно, что Постгрес не выбрал провести index scan по i2, хотя у этого индекса есть указатели на все строки в таблице), затраты взлетели до 10,000,000,000 — именно это enable\_\* = false и делает.
Думаю, на этом всё. Если вы прочитали всю серию, теперь вам должно хватать знаний, чтобы понимать, что происходит и, что важнее, — почему. | https://habr.com/ru/post/282011/ | null | ru | null |
# Фреймворки для тестирования: личный опыт и новые методы
Привет, Хабр! Меня зовут Сергей Радченко, и мы с командой профессионально занимаемся тестированием уже несколько лет. Сегодня я посчитал количество автотестов, которые мы подготовили для веб-интерфейсов, десктопных приложений, API, систем двухфакторной авторизации и так далее (их оказалось более 5000). И мне захотелось рассказать о нашем опыте создания экосистемы для автоматизированного тестирования. В этом посте вы найдете описание полезных для комплексного тестирования фреймворков, а также исходный код некоторых дополнительных методов, которые мы дописали самостоятельно, чтобы написание тестов происходило быстрее, и тестирование приносило больше пользы.
Иногда кажется, что тесты — это очень просто. Нередко в инструментах инфраструктурного мониторинга предусмотрена возможность отслеживания доступности веб ресурсов по простым http-запросам: ответ пришел — значит сервис доступен, нет ответа или код ответа отличается от "200" — значит недоступен. Но таким способом не получается проверить что-то более специфичное, например, корректность работы системы авторизации или обнаружить проблемы с синхронной подгрузкой данных, ну и удостовериться, что все бизнес услуги предоставляются пользователям корректно.
Часто бывает так, что сайт и ресурсы по показателям мониторинга доступны, но пользователи жалуются на их неработоспособность. Тут надо тестировать функционал самого сайта. Мы делаем это следующим образом — автоматический тест запускается по расписанию, а после выполнения теста происходит сбор метрик с отправкой в систему мониторинга. Метрики должны содержать в себе различные параметры: прошел тест или нет, на каком шаге произошел провал (если он был), а также время выполнения каждого шага.
В системе мониторинга можно создать триггеры на провал теста, а также на превышение времени выполнения шага. Иногда имеет смысл ввести триггеры и на провал конкретного шага. В этом случае группа мониторинга получает уведомление при срабатывании одного из триггеров и может расследовать инцидент сразу, чтобы предпринять действия по оперативному устранению проблем. Также можно настроить информирование лиц, ответственных за конкретный продукт или сервис.
Такой подход хорошо зарекомендовал себя, потому что комплексный мониторинг позволяет не только понять, работает система в целом или нет, но также выявить замедление работы, и иногда — даже поймать плавающие проблемы.
### Тесты проще писать на Python. Это факт
Когда речь идет о проверке работоспособности одного сайта, тестов обычно требуется не более 10, и они оказываются довольно простыми. Поэтому не имеет смысла строить сложную структуру классов: каждый тест проверяет свой набор страниц сайта, большинство элементов используются по одному разу, а данные прописываются внутри самого теста. Но когда тестов приходится готовить достаточно много, приходит желание все это стандартизировать и формализовать.
В качестве основы для написания тестов мы выбрали Python. Это достаточно простой и популярный на сегодняшний день язык программирования. В нем есть много полезных библиотек, и их количество продолжает расти. Поэтому готовить тестовые системы на Python достаточно просто.
***Быстрый старт***
Чтобы быстрее начинать работу по проекту, мы создали один базовый класс Python со всеми необходимыми методами и постоянно дополняем его новыми. Далее для тестирования конкретного сайта создаем классы-наследники. В них выносим общие данные, элементы и метод. Благодаря этому приступить к началу тестирования получается достаточно быстро.
***Простота входа***
Обучить человека базовым навыкам программирования на Python несложно. Существует масса курсов и обучающих программ. Но в дополнение к ним мы также написали инструкции по развертыванию окружения и структуры проекта тестов. Как показала практика, с помощью всего этого багажа знаний даже незнакомые с программированием и автоматизацией сотрудники могут приступить к выполнению боевых задач в первый же день своего общения с тестовым окружением. А писать новые тесты они начинают уже на первой неделе.
***Работа с разными окружениями***
Учитывая, что тестированием мы занимаемся давно, у нас есть старый код, который написан на Python 2.7. Основная часть тестов была подготовлена для версии Python 3. Все они должны работать вместе на одной рабочей машине автоматизатора тестирования. Виртуальные окружения Python позволяют развернуть готовое окружения за несколько минут с использованием нескольких команд в консоли. Также несколько минут уходит на установку всех необходимых пакетов ещё одной консольной командой.
### Браузерные тесты удобно запускать через Selenium
Когда речь идет о фреймворке для браузерных тестов, мы делаем выбор в пользу Selenium. Несколько лет назад, это был единственный крупный проект для автоматизации тестирования через web интерфейс. Сейчас уже появились новые решения, но зато экосистема Selenium остается одной из самых зрелых.
Исторически Selenium использует свой закрытый протокол для взаимодействия с браузером: запросы упаковываются в JSON и передаются через http. Но сейчас же во все основные браузеры внедрен протокол, позволяющий обращаться к ним напрямую: [Remote Debugging Protocol](https://firefox-source-docs.mozilla.org/devtools/backend/protocol.html#remote-debugging-protocol) для Firefox, [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/) для chromium. С помощью этих протоколов можно управлять браузерами на более низком уровне, например, отслеживать запросы. Эти возможности, должны появиться в Selenium версии 4, которая сейчас находится в разработке (очень ждём…).
Например, [библиотека Selenium для Python](https://pypi.org/project/selenium/) включает в себя класс ActionChains. Он позволяет создавать цепочки действий с клавиатурой и мышью. Например, вы можете передвигать курсор на элемент разворачивающий список или меняющий свое состояние при наведении. Также можно имитировать нажатия на клавиши, что иногда требуется в некоторых поля ввода, когда стандартный метод send\_keys из Selenium не работает.
Изначально за основу для разработки тестов был взят wrapper (<https://pypi.org/project/seleniumwrapper/>). Мы предполагали, что его методов будет достаточно для написания любых сценариев. Но в процессе работы возможностей wrapper стало не хватать: во многих местах появилось дублирование кода, было много провалов, которые приходилось обходить костылями. Для решения этих проблем мы начали добавлять свои методы такие как:
* переключение между вкладками,
* ожидание исчезновения элемента со страницы,
* имитация нажатий клавиш и использование ActionChains,
* ожидание скачанного файла
* и так далее
Вот некоторые примеры этих методов в коде:
```
class Page(SeleniumWrapper):
def switch_to_window(self, title_name, close_others=False):
windows = self.window_handles
windows_title = {}
for window in windows:
self.switch_to.window(window)
windows_title[self.title] = window
for window in windows_title:
if re.search(title_name, window):
self.switch_to.window(windows_title[window])
break
if close_others:
self.close_all_other_windows()
def get_current_window_index(self):
return self.window_handles.index(self.current_window_handle)
def switch_to_next_window(self):
current_index = self.get_current_window_index()
self.switch_to.window(self.window_handles[current_index + 1])
def switch_to_previous_window(self):
current_index = self.get_current_window_index()
self.switch_to.window(self.window_handles[current_index - 1])
def close_all_other_windows(self):
windows = self.window_handles
current_window = self.current_window_handle
for window in windows:
if window != current_window:
self.switch_to.window(window)
self.close()
self.switch_to.window(current_window)
def is_xpath_present(self, xpath, eager=False, timeout=1, presleep=0):
time.sleep(presleep)
self.silent = True
elements = self.xpath(xpath, eager=eager, timeout=timeout)
self.silent = False
if eager:
return elements
if not elements:
return []
if elements.is_displayed():
return True
return []
@_wait_until
def wait_for_not_displayed(self, xpath):мента.
"""
assert not bool(self.is_xpath_present(xpath)), f'Элемент {xpath} не исчез'
return True
def press_keys(self, keys):
"""
Ввод символов нажатиями на клавиши
:param keys: Строка символов для ввода
"""
for key in keys:
ActionChains(self).key_down(key).key_up(key).perform()
time.sleep(0.01)
def press_backspaces(self, count=20):
keys = [Keys.BACKSPACE for _ in range(count)]
self.press_keys(keys)
def get_downloaded_file_names(self):
if settings.run_local:
return []
response = requests.get(self.download_url)
result = re.findall(r'>(.*?)', response.text)
print(f'Downloaded response: {response.text}')
print(f'Downloaded result: {result}')
return result
@_wait_until
def wait_for_downloaded_file(self, filename):
assert not settings.run_local, 'Can not check downloaded file on local running'
assert filename in self.get_downloaded_file_names(), f"Файл {filename} не скачан"
return True
@_wait_until
def wait_for_downloaded_file_by_substring(self, filename_part):
assert not settings.run_local, 'Can not check downloaded file on local running'
matches = [filename for filename in self.get_downloaded_file_names() if filename_part in filename]
assert len(matches) > 0, f'Нет файла содержащего `{filename_part}` в названии'
return True
```
К тому же в базовой библиотеке есть только основные методы, которые плохо работают с динамическими страницами. Часто нужно применять интеллектуальные ожидания для элементов страницы: видимости, изменения атрибутов, изменения текста, внутреннего id элемента, доступности для взаимодействия и так далее.
Это очень важно в реальных тестах. Например, чтобы начать вводить в поле ввода данные, нужно сперва дождаться появления элемента на странице, затем проверить его видимость, доступность для ввода, и только после этого начать вводить данные. Если использовать чистый Selenium, то придется в каждом тесте прописывать эти действия, удобнее вынести это всё в отдельный метод и просто его использовать.
А вот и исходный код метода:
```
def send_keys(self, xpath, value, name="", timeout=None, wait_interactable=True, postsleep=0):
timeout = timeout or self.timeout
element = self.xpath(xpath, name, timeout=timeout)
if wait_interactable:
self.can_click(xpath, timeout=timeout)
try:
element.send_keys(value)
except WebDriverException:
message = f"В поле ввода `{name or xpath}`не удалось ввести значение `{value}` за `{timeout}` секунд"
raise WebDriverException(message)
time.sleep(postsleep)
def click(self, xpath_or_dict="", name="", timeout=None, presleep=0, postsleep=0, ignored_exceptions=None):
xpath, name = Page.get_xpath_and_name(xpath_or_dict, name)
timeout = timeout or self.timeout
ignored_exceptions = ignored_exceptions or tuple()
# Сначала ждем появления элемента
element = self.xpath(xpath_or_dict, timeout=timeout)
time.sleep(presleep)
errors = list()
end_time = time.time() + timeout
while time.time() < end_time:
try:
element.click(timeout=timeout / 10)
break
except ignored_exceptions:
continue
except InvalidSessionIdException:
message = "Потеряно соединение с браузером. Возможно браузер был закрыт или аварийно завершил работу"
raise InvalidSessionIdException(message)
except StaleElementReferenceException as e:
element = self.xpath(xpath_or_dict, timeout=timeout)
errors.append(e)
continue
except WebDriverException as e:
errors.append(e)
continue
else:
if errors:
message = f"Не удалось выполнить клик по элементу `{name or xpath}` в течение {timeout} секунд(ы)\n{errors}"
raise TimeoutException(message)
time.sleep(postsleep)
```
Кстати, на Хабре уже есть статьи про Selenium. И если вы хотите почитать про этот фреймворк подробнее, можно посмотреть материалы по этим ссылкам: (<https://habr.com/ru/post/248559/> <https://habr.com/ru/post/329256/> <https://habr.com/ru/post/208638/> <https://habr.com/ru/post/152653/> <https://habr.com/ru/post/327184/> <https://habr.com/ru/post/322742/>)
**Распознавание изображений с** PyAutoGUI
PyAutoGUI — это хороший и простой фреймворк для написания несложных тестов под десктоп. Он позволяет управлять клавиатурой и мышью, то есть имитировать нажатия на клавиши, двигать курсором и производить клики. Кроме этого PyAutoGUI умеет находить координаты на экране по референсному скриншоту. Поиска по пиксельному совпадению обычно бывает достаточно, потому что тесты обычно гоняются на одном и том же окружении, с одним разрешением и на изолированных экранах.
С одной стороны, чтобы прогнать тест, нужно всего лишь сделать скриншот и использовать его. Но с другой стороны изменение шрифта, размеров элементов требует новых и новых скриншотов.
Мы решили эту проблему, реализовав поиск элемента по нескольким эталонным скриншотам, был добавлен метод, который в течение указанного промежутка времени ищет и по очереди сопоставляет каждый из эталонных скриншотов с тем, что сейчас отображено на экране. Если за один проход нужные элементы не были обнаружены, метод делает повторные попытки, пока не найдет совпадение или не превысит отведенный лимит времени.
```
class RecognitionClient(abc.ABC):
def __init__(self, project_dir):
self.project_dir = Path(project_dir)
self.process = None
self.wait_time = 25
def _find_image_path(self, img_file):
parent_img_path = self.project_dir.parent.joinpath('img', img_file)
if parent_img_path.is_file():
return str(parent_img_path)
img_path = self.project_dir.joinpath('img', img_file)
if img_path.is_file():
return str(img_path)
return ImageNotRecognized(f'Not found image file: {img_path}')
@sleeper
def find_one_of(self, *imgs, wait_time=None, confidence=0.9, raise_errors=True):
"""
Поиск координат одного скрина из списка.
"""
wait_time = wait_time or self.wait_time
timeout = time.time() + wait_time
while time.time() < timeout:
for img in imgs:
position = self.find_screen(img, wait_time=0.1, raise_errors=False, confidence=confidence)
if position:
return position
else:
if raise_errors:
for img in imgs:
img_path = self._find_image_path(img)
with open(img_path, "rb") as image_file:
img_obj = image_file.read()
allure.attach(img, img_obj, type=AttachmentType.PNG)
raise ImageNotRecognized(f"Images not recognized: {', '.join(map(str, imgs))}")
```
### Запуск тестов с PyTest
PyTest — действительно мощный фреймворк для тестирования. Он имеет массу возможностей и расширений в виде пакетов. С его помощью можно реализовать автоматический перезапуск тестов, визуализацию отчетов и многое другое.
Для нас PyTest — это способ избежать необходимости писать кучу однотипного кода для каждого теста, потому что обычно дополнительный код в этой экосистеме или полностью отсутствует, или связан с объявлением новой фикстуры.
К тому же в PyTest есть несколько дополнительных пакетов, которые расширяют его функциональность. Мы используем Allure и Rerunfailures.
[Пакет allure](https://pypi.org/project/allure-pytest/) проводит сбор результатов тестов для последующей генерации отчетов. Он позволяет получать данные о прохождении тестов без глубоких модификаций кода. Из полученной информации можно сгенерировать отчет с понятной структурой, историей запуска тестов и перезапусков при провалах.
пример — скриншот отчета
Изначально мы использовали allure.step из самой библиотеки, но затем появилась необходимость делать скриншоты для каждого шага браузера. Если делать один скриншот в конце шага, то в случае провала тест просто не дойдет до этого места, а в проваленных тестах скриншот с места провала невероятно важен для понимания проблемы.
Первым решением было оборачивание кода внутри теста в блок try. В итоге это привело к увеличению количества строк кода теста и повсеместному дублированию. Тогда мы решили сделать свой класс наследник StepContext. Сначала решение показалось удобным, но внутри класса получилось много лишних строк и условных блоков. На текущий момент мы перешли к варианту использования декоратора contextmanager из библиотеки contextlib и реализовали обращение к глобальному объекту браузера. А поскольку декоратор преобразует генератор в дескриптор его можно использовать в блоке with.
Описание метода
```
@contextmanager
def allure_step(name, wait_time: int = None):
from web.register import pages
with allure.step(name):
try:
if wait_time:
pages.browser.wait_time = wait_time
yield
pages.browser.wait_time = settings.wait_time
make_screen('screen')
except Exception:
make_screen('error')
raise
```
Применение метода
```
from utils.allure import allure_step
def test_1(pages):
with allure_step('Шаг 1. Загрузка главной страницы', 50):
pages.main_page.open()
```
Кроме этого мы используем библиотеку [Rerunfailures](https://pypi.python.org/pypi/pytest-rerunfailures), которая обеспечивает удобный перезапуск тестов при провале. Этот набор методов позволяет настраивать количество перезапусков, интервал ожидания перед перезапуском после провала. В общем — полезная штука для тестировщика, у которого действительно много работы.
### Изоляция тестов с Selenoid
Тесты необходимо запускать изолированно друг от друга, чтобы результат выполнения предыдущего никак не влиял на следующий. Тесты надо прогонять на разных браузерах различных версий. И для этого идеально подходит Selenoid в связке с Selenoid GGR и Selenoid UI.
Когда у нас идут большие проекты тестирования, на одной машине мы разворачиваем Selenoid GGR, а на нескольких других — ноды. Все запросы изначально отправляются в GGR, который создает сессию на свободной ноде, и мы можем использовать её для тестирования.
Для каждого теста поднимается свой контейнер с нужной версией браузера, а после завершения теста, контейнер гасится. Когда возникает необходимость посмотреть, как работает тест или проверить работу ресурса через браузер на сервере, можно использовать Selenoid UI, создать сессию и работать с окружением через VNC как с обычным браузером.
### Запуск тестов через Jenkins
Вообще Jenkins создавался (и используется) для CI/CD. Но мы применяем его как систему для запуска тестов, используя те же плюсы, которые эта платформа дает при деплое приложений.
Для каждого теста или группы тестов создается отдельный проект. В его настройках мы прописываем периодичность запуска тестов, выбираем необходимые параметры через переменные окружения и создаем скрипт запуска теста. Скрипт определяет, на каком окружении и какой тест нужно запускать. После этого Jenkins прогоняет тест, специальный скрипт собирает метрики и отправляет их в систему мониторинга.
На стенде, где установлен Jenkins, может быть создано несколько окружений Python и размещены разные репозитории с тестами. Тесты обычно берутся с локального диска стенда, а не из Git, потому что одновременно работают десятки проектов, и каждый раз делать Pull оказывается накладно с точки зрения ресурсов. Впрочем, сами тесты могут не меняться месяцами, а иногда и годами, так что это не очень страшно. )
Для обновления репозиториев мы создаем отдельный проект, который запускается по расписанию, либо его можно запустить вручную в случае необходимости.
Создание проектов мы автоматизировали через отдельный скрипт. На основе шаблона скрипт создает проект почти со всеми необходимыми настройками, чтобы свести к минимуму ввод дополнительных параметров.
### Заключение
Надеюсь, эта подборка тестовых фреймворков и методов оказалась полезной. В следующем посте я расскажу о практике написания некоторых тестов на Python. А если у вас есть другой опыт работы с тестовыми окружениями, пожалуйста, поделитесь им в комментариях. | https://habr.com/ru/post/579032/ | null | ru | null |
# Добавление специальных предложений для клиентов в почтовых сообщениях средствами Zentyal + Postfix + alterMIME
Добрый день, вечер или ночь, все зависит от времени суток в который вам довелось прочитать мою статью.
Отделу продаж потребовалось в переписке с клиентами отправлять спец предложения по email без рутиной работы. В двух словах изложу, что и как получилось.
Исходные данные:
— почтовый сервер на базе Zentyal 5.0.1(postfix + dovecot + openDKIM и т.д.)
— alterMIME v0.3.10
— HTML шаблон с предложением.
Сразу скажу спасибо статье [Унифицированная динамическая корпоративная подпись с логотипом Postfix + alterMIME](https://habrahabr.ru/post/242185/), а так же комментариям, из неё подчеркнул основную идею.
Первым делом в файл `master.cf` внесем изменения, а именно:
Заменим:
```
smtp inet n - y - - smtpd
```
На:
```
smtp inet n - y - - smtpd
-o content_filter=dfilt:
dfilt unix - n n - - pipe
flags=Rq user=filter argv=/etc/postfix/disclaimer.sh -f ${sender} -- ${recipient}
```
Далее создадим структуру каталогов:
```
useradd -r -c "Postfix Filters" -d /var/spool/filter filter
mkdir /var/spool/filter
mkdir /etc/postfix/disclaimer
chown filter:filter /var/spool/filter
chmod 750 /var/spool/filter
```
Теперь основное, создадим исполняемый файл /etc/postfix/disclaimer.sh с содержимым:
```
#!/bin/bash
# Рабочий каталог
INSPECT_DIR=/var/spool/filter
# Ссылка на sendmail
SENDMAIL=/usr/sbin/sendmail
# Список email отдела продаж
DISCLAIMER_ADDRESSES=/etc/postfix/disclaimer/addresses
EX_TEMPFAIL=75
EX_UNAVAILABLE=69
trap "rm -f in.$$" 0 1 2 3 15
cd $INSPECT_DIR || { echo $INSPECT_DIR does not exist; exit
$EX_TEMPFAIL; }
cat > in.$$ || { echo Cannot save mail to file; exit $EX_TEMPFAIL; }
# Определим адрес назначения (для точно чтобы не слать вложения локальным пользователям)
from_address=`grep "From:" in.$$ | cut -d "<" -f 2 | cut -d ">" -f 1 | sed 's/^From: //g' | awk '{print $1}' | cut -d "@" -f 2 | grep -v ^h= | grep -v ^To`
to_dom=`echo $to_address |cut -d "@" -f 2`
my_domain="example.org"
# Применяем правило только для отдела продаж
if [ `grep -wi ^${from_address}$ ${DISCLAIMER_ADDRESSES}` ]; then
# Определяем что шлем не локальным клиентам
if [ "$from_address" = "example.org" ]; then
# Прикреплять только в HTML сообщения
ContentTypeFirst=`grep -m 1 '^Content-Type: ' in.$$ | cut -d " " -f 2 | cut -d ";" -f 1`
ContentTypeMixed=`grep -m 2 '^Content-Type: ' in.$$ | cut -d " " -f 2 | cut -d ";" -f 1 | tail -n 1`
isHTML=true
if [ "$ContentTypeFirst" = "" ] || [ "$ContentTypeFirst" = "text/plain" ]; then isHTML=false; fi
if [ "$ContentTypeFirst" = "multipart/mixed" ] && [ "$ContentTypeMixed" = "text/plain" ]; then isHTML=false; fi
if [ "$ContentTypeFirst" = "multipart/mixed" ] && [ "$ContentTypeMixed" != "text/html" ] && [ "$ContentTypeMixed" != "multipart/related" ] && [ "$ContentTypeMixed" != "multipart/alternative" ]; then isHTML=false; fi
if $isHTML ; then
/usr/bin/altermime --input=in.$$ \
--disclaimer=/etc/postfix/disclaimer/disclaimer.txt \
--disclaimer-html=/etc/postfix/disclaimer/disclaimer.html \
--xheader="X-Copyrighted-Material: Please visit https://www.example.org/privacy.htm" || \
{ echo Message content rejected; exit $EX_UNAVAILABLE; }
fi
fi
fi
$SENDMAIL -oi "$@" < in.$$
exit $?
```
Теперь по порядку:
**DISCLAIMER\_ADDRESSES** — в данный файл заносим адреса отдела продаж, в принципе если у вас домен можно автоматизировать, пример есть в статье откуда я брал идею.
**from\_address, to\_dom и my\_domain** — требуется для создания фильтра, чтобы не применять это правило для других отделов и не слать письма с предложениями самим себе.
**disclaimer.html** — html файл с предложениями, включая картинки т.п.
В принципе, если есть желание, модифицировать можно до бесконечности, главное задача, для которой это необходимо.
P.S. Данное решение можно было реализовать и через amavisd-new, но от этой идеи пришлось отказаться, так как нельзя в тело письма вставить xheader, но это тема для другой статьи. | https://habr.com/ru/post/344614/ | null | ru | null |
# Написание пакета для PFSense
В этой статье я постараюсь на простом примере показать создание собственного GUI пакета для [pfSense](https://www.pfsense.org). Предполагается, что читатель имеет опыт работы с pfSense, имеет некоторые знания в PHP.
Маршрутизатор [pfSense](https://www.pfsense.org) (на базе FreeBSD) используется многими сисадминами благодаря, в первую очередь, управлению настройками системы через WEB интерфейс. С многими настройками вполне по силам справиться даже начинающему администратору, что позволяет расширить область применения этого маршрутизатора. При этом, опытные коллеги могут в полной мере воспользоваться доступом к консоли для изучения и контроля работы системы.
Помимо стандартных настроек маршрутизатора, большинство которых можно сделать через WEB интерфейс, иногда возникают специфические для предприятия задачи, требующие от сисадмина управления настройками через консоль. Далее я хочу показать, как облачить свои наработки в код, позволяющий управлять настройками системы из WEB интерфейса.
Итак, у вас есть установленный и настроенный тестовый pfSense. Для начала нам понадобятся инструменты доступа к консоли и файлам pfSense по SSH. Так как я winuser, то и инструменты для работы буду использовать WinSCP + Putty.
Подключаемся с помощью [WinSCP3](http://winscp.net/eng/docs/lang:ru) к pfSense и открываем каталог */usr/local/pkg*. В этой папке хранятся файлы, относящиеся к GUI пакетам. Обычно это XML и INC файлы, включающие в себя описание конфигурации и PHP обработчики пакетов. Описание конфигурации GUI пакета размещено в XML файлах, и содержит в себе:
* служебную информацию;
* шапку страницы WEB интерфейса;
* форму страницы WEB интерфейса;
* информацию о PHP функциях-обработчиках событий WEB интерфейса.
Создаем два пустых файла *mypkg.xml* и *mypkg.inc*. Название *mypkg* является именем нашего пакета, и имя XML файла является ключевым для доступа к WEB интерфейсу пакета. Название inc файла может быть произвольным, и далее будет показан способ его подключения.
Формируем наш XML файл.
Служебная информация содержит имя, заголовок, категорию, версию GUI пакета и список подключаемых INC файлов. В нашем случае подключаемый INC файл только один, должен быть указан полный путь к подключаемому файлу.
```
xml version="1.0" encoding="utf-8" ?
mypkg
My First Package
Test
0.1
/usr/local/pkg/mypkg.inc
```
Шапка WEB интерфейса содержит описание GUI страниц в узле *tabs*, и выводится в области навигации. У нас будет только одна страница. Элемент *text* содержит имя пункта навигации в GUI. Элемент *url* содержит относительный путь доступа к странице нашего пакета.
```
My Package
/pkg\_edit.php?xml=mypkg.xml
```
Форма WEB интерфейса описывает, какие элементы управления параметрами нашего пакета будут доступны пользователю. Для начала создадим одно единственное поле Enable с элементом *checkbox*:
```
Enable
enable
Check this for enable package.
checkbox
```
Обработчики событий WEB интерфейса является завершающим участком XML файла, и описывает какие функции будут вызваны в тот или иной момент работы формы GUI. Представлено три часто используемых обработчика:
* *custom\_php\_command\_before\_form* — вызывается перед отображением формы;
* *custom\_php\_validation\_command* — вызывается при проверке данных каждого элемента формы перед сохранением ее данных;
* *custom\_php\_resync\_config\_command* — вызывается при сохранении данных формы
```
```
Пользуясь обработчиками, можно указать имена php функций из файла mypkg.inc, которые будут вызваны при том или ином событии. Выполнение конкретных действий по изменению конфигурации маршрутизатора производится в обработчике *custom\_php\_resync\_config\_command*, вызываемом как при нажатии кнопки *Save* на формы, так и при загрузке pfSense.
Здесь можно посмотреть полный текст файла:
**Файл mypkg.xml**
```
xml version="1.0" encoding="utf-8" ?
mypkg
My First Package
Test
0.1
/usr/local/pkg/mypkg.inc
My Package
/pkg\_edit.php?xml=mypkg.xml
Enable
enable
Check this for enable package.
checkbox
```
Файл mypkg.inc создаем пустым, так как наш тестовый пакет ничего не делает.
**Файл mypkg.inc**
```
php
/*
mypkg.inc
*/
?
```
После сохранения созданных файлов *mypkg.xml* и *mypkg.inc* в каталоге */usr/local/pkg* можно проверить, как наш пакет будет выглядеть. Для этого заходим в WEB интерфейс pfSense и добавляем в адресной строке путь */pkg\_edit.php?xml=mypkg.xml*. Если все правильно и без ошибок сделано, получим вот такую картинку
В итоге нами был получен очень простой GUI пакет, который не выполняет ничего полезного, не сохраняет никаких данных, и даже не зарегистрирован в меню WEB интерфейса. Но тем не менее, на примере этого пакета можно получить представление о механизме работы графического интерфейса pfSense.
PS: За ранее приношу извинения за возможные недочеты. Эта статья написана для получения *инвайта*. Если данная тема будет интересна сообществу, то постараюсь рассказать более подробно о том, как создать полноценный GUI пакет для pfSense. | https://habr.com/ru/post/228977/ | null | ru | null |
# Автоматический вторичный DNS давно уже не проблема
Посмотрев недавно [статью](//habrahabr.ru/company/parallels/blog/200452/), был сильно удивлен, что кто-то еще задается вопросом автоматического прописывания ДНС доменов на вторичном сервере. Хочу поделится своим вариантом «Automate slave DNS support», которым пользуюсь уже много лет. Возможно он подойдет не всем, но он довольно прост.
В качестве вторичного использую PowerDNS, мастером использую Bind, хотя подойдет любой другой сервер умеющий DNS NOTIFY при изменении/создании зоны (присматриваюсь к [YADIFA](http://www.yadifa.eu/), но руки пока не дошли). Именно эту фичу мы и будем использовать чтобы создавать и изменять зоны на вторичном сервере, минус будет только в том при удалении зоны на слейве, ее нужно удалить вручную. В логах удаленные зоны хорошо видны и при необходимости можно навоять скриптик для автоматизации процесса, у меня зоны удаляются довольно редко, поэтому такой необходимости не было.
Наверное если Вы заинтересовались этой статьей, то имеете представление о том, как настроить мастер или при желании самостоятельно найдете материал по настройке. В случаи Bind хочу обратить внимание, что в конфиге обязательная должна быть прописана опция:
```
notify yes
```
Итак у нас есть два хоста 10.0.0.1 (ns.server.net) и 10.0.0.2 (ns0.server.net), где ns.server.net основной, а ns0.server.net вторичный.
Опишем их в файле домена server.net:
```
@ IN NS ns.server.net.
@ IN NS ns0.server.net.
ns IN A 10.0.0.1
ns0 IN A 10.0.0.2
```
Приступим к установке и настройки Pdns. На серверах у меня Debian:
```
apt-get install pdns-backend-sqlite3
```
Такой вариант автоматом подтянет pdns-server, sqlite3, а так же все что необходимо для запуска PowerDNS сервер с Sqlite v3, который используется хранения днс записей. Sqlite3 выбран так как не требует для себя много внимания, но ничто не мешает Вам выбрать другой вариант.
```
[skip]
creating database pdns.sqlite3: success.
verifying database pdns.sqlite3 exists: success.
populating database via sql... done.
Processing triggers for pdns-server ...
[ ok ] Restarting PowerDNS Authoritative Name Server: pdns.
```
Итак у нас есть установленный PowerDNS сервер с базой Sqlite3 в дистрибутивах отличных от Debian возможно придется вручную настроить базу. К сожалению в пакете ошибка и чтобы сервер увидел базу нужно закомментировать одну строчку.
В файле /etc/powerdns/pdns.d/pdns.simplebind нужно удалить или закомментировать строчку `bind-config=/etc/powerdns/bindbackend.conf`
Так же в конфиге нужно объявить сервер как вторичный:
/etc/powerdns/pdns.conf
```
slave=yes
```
Теперь нам можно прописать Master DNS в Sqlite базу:
```
cd /var/lib/powerdns
sqlite3 pdns.sqlite3
sqlite> INSERT INTO supermasters VALUES('10.0.0.1','ns.server.net','master');
.quit
```
На этом настройка завершена, но это еще не все, теперь надо загрузить в sqlite базу, есть два способа это сделать.
Самый простой на мой взгляд это обновление Serial на мастере, чтобы он отправил слейву DNS NOTIFY и тем самым оповестил его о наших доменах, заставив его завести и забрать их.
На местере это выглядит так:
```
master named[12318]: reloading configuration succeeded
master named[12318]: reloading zones succeeded
master named[12318]: zone server.net/IN: loaded serial 1
master named[12318]: zone server.net/IN: sending notifies (serial 1)
master named[12318]: client 10.0.0.2#14310: transfer of 'server.net/IN': AXFR started
master named[12318]: client 10.0.0.2#14310: transfer of 'server.net/IN': AXFR ended
```
На вторичном:
```
slave pdns[21225]: Received NOTIFY for server.net from 10.0.0.1 for which we are not authoritative
slave pdns[21225]: Created new slave zone 'server.net' from supermaster 10.0.0.1, queued axfr
slave pdns[21225]: Initiating transfer of 'server.net' from remote '10.0.0.1'
slave pdns[21225]: gsqlite3: connection to '/var/lib/powerdns/pdns.sqlite3' successful
slave pdns[21225]: 1 slave domain needs checking, 0 queued for AXFR
```
Альтернативой могу предложить завести домены напрямую в sqlite:
```
INSERT INTO "domains" VALUES(1,'domain.ru','10.0.0.1',0,'SLAVE',NULL,'master');
INSERT INTO "domains" VALUES(2,'domain.su','10.0.0.1',0,'SLAVE',NULL,'master');
INSERT INTO "domains" VALUES(3,'domain.com','10.0.0.1',0,'SLAVE',NULL,'master');
```
Где 0 это сериал зоны, на мастере он явно будет больше и поэтому произойдет обновление.
```
slave pdns[21225]: Received serial number updates for 1 zones, had 0 timeouts
slave pdns[21225]: Domain server.net is stale, master serial 3, our serial 0
slave pdns[21225]: Initiating transfer of 'server.net' from remote '10.0.0.1'
slave pdns[21225]: AXFR started for 'server.net', transaction started
```
Надеюсь теперь вопрос автоматического создания доменов на вторичном сервере больше не будет Вас беспокоить. | https://habr.com/ru/post/201816/ | null | ru | null |
# Топ-10 докладов конференции C++ Russia 2018: полные видеозаписи, слайды, комментарии
В этой статье вас ждёт десять лучших докладов от Андрея Александреску, Дэвида Вандервурда, Джона Калба и многих других.
Фичи компилятора C++, асинхронность, многопоточность, параллелизм, модель памяти, алгоритмы и STL, метапрограммирование и рефлекшен, огромное множество тем.
Всё это — записи с конференции C++ Russia, самой большой в истории. Восемь сотен участников, немаленький зал, спикеры с мировым именем. Прошёл год, но большинство докладов ничуть не утратило своей актуальности. Впрочем, и неудивительно — именно такие доклады и попадают в топ по оценке участников.
Формат таков:
* Обязательное видео на YouTube
* Слайды, если есть
* Подробное описание доклада на русском языке
* Краткая биография докладчика
Плюс у вас есть комментарии Хабра, чтобы обсудить увиденное. Реклама на ютубе отключена, никто не будет мешать. Есть всё, чтобы начать смотреть прямо сейчас.
10. Memory Management Tips & Tricks
===================================
*Алексей Салмин*
В 2017 году вопрос выбора аллокатора в C++ не теряет актуальности. В стандарт добавили новый способ выбрать локальный аллокатор для контейнеров (`std::pmr`), глобальные `tcmalloc` и `jemalloc` продолжают развиваться, как и интерфейсы ядра, на которые они опираются. Этот доклад посвящен «нижнему этажу» конструкции: особенностям работы `mmap` и `madvise` в ядре Linux и влиянию этих особенностей на производительность аллокаторов.
**О докладчике**
 Алексей Салмин закончил ММФ НГУ, занимался символьными вычислениями и статическим анализом, работал в Intel в Новосибирске. С 2016 года работает в московском офисе Яндекса, разрабатывает backend realtime-поиска.
---
9. Best Practices for Concurrency in Modern C++
===============================================
*Rainer Grimm*
[Слайды](https://2018.cppconf.ru/talks/day-2/track-a/4.pdf)
Стандартизация C++11 дала нам модель памяти и многопоточность. В библиотеке есть такие стандартные штуки вроде атомиков, тредов, тасков, локов, условных переменных. Модель памяти дает гарантии на многопоточное использование этих базовых блоков.
Прошло семь лет, появились практики безопасного применения многопоточности и модели памяти. В этом докладе мы подробно узнаем об этих практиках: об общих правилах многопоточности и специальных правилах как для библиотечных примитивов, так и для модели памяти. Рассматриваемые вопросы затрагивают темы более широкие, чем только язык C++.
**О докладчике**
 Rainer Grimm проработал архитектором, тимлидом и инструктором более 20 лет. В свободное время он любит писать статьи о C++, Python и Haskell и выступать на конференциях. Он ведет блог «Modern C++». Сейчас он докладчик по темам современного C++ и Python. O'Reilly и Leanpub издают несколько его книг: «C++11 für Programmierer», «C++», «C++ — Standardbiliothek», «The C++ Standard Library».
---
8. 2020: A void\_t odyssey
==========================
*Ivan Čukić*
[Слайды](https://2018.cppconf.ru/talks/day-2/track-a/2.pdf)
В C++ всегда присутствовало мощное подмножество языка для метапрограммирования, позволяющее разработчикам выполнять магические приёмы вроде статической интроспекции для обеспечения полиморфного выполнения без наследования. Проблема в том, что синтаксис этот весьма извращенный и излишне многословный — всё это превращает метапрограммирование в довольно устрашающую задачу.
Последние улучшения в стандарте, объединённые с новыми фичами C++20, делают метапрограммирование более простым, а сами метапрограммы — более читаемыми и понятными.
В этом докладе мы посмотрим на современные техники метапрограммирования, фокусируясь на магической метафункции `void_t`.
Кстати, на C++ Russia 2019 в Москве Иван выступит с докладом [«Move-only C++ design»](https://cppconf.ru/talks/11auqe0dbeawgemasoqws2/?utm_source=habr&utm_medium=442498), а также проведет тренинг [«Applied functional programming in C++»](https://cppconf.ru/trainings/applied-functional-programming-in-c/?utm_source=habr&utm_medium=442498): далека ли STL от функционального программирования, что такое функциональные объекты, std::invoke и монады, монады, монады. И ещё немного монад. Тренинг Ивана — не для начального уровня, он подойдет мидлам, которые хотят открыть пошире двери восприятия.
**О докладчике**
 Иван работает в департаменте PhD Computer Science факультета математики в Белградском университете, специализируясь на дизайне языков программирования. Давний контрибьютор в KDE, работающий над Plasma и низкоуровневыми фреймворками для анализа и управления действиями пользователя. Мейнтейнер KActivities, Contour и Lancelot.
---
7. Modern C++ Parallelism from CPU to GPU
=========================================
*Simon Brand*
[Слайды](https://2018.cppconf.ru/talks/day-2/track-a/5.pdf)
Параллельное программирование можно использовать для извлечения пользы из многоядерных и гетерогенных архитектур, существенно увеличивая производительность софта. Современный C++ прошёл долгий путь по упрощению процесса параллельного программирования благодаря введению как высокоуровневых, так и низкоуровневых абстракций. C++17 продвинулся ещё дальше и дал нам новые высокоуровневые параллельные алгоритмы, и от C++20 ожидается ещё больше. В этом докладе мы поучаствуем в обзоре существующих утилит для организации параллелизма и заглянем в будущее, где GPU и гетерогенные системы получат поддержку новыми фичами стандартной библиотеки, посмотрим на новые стандарты вроде SYCL.
**О докладчике**
 Саймон — разработчик GPGPU-тулчейна с упором на C++. Нездорово любит шаблонное метапрограммирование и самые тёмные стороны языка. Его легко можно встретить в комментариях на StackOverflow, C++ канале в Slack или на митапах сообщества C++ Edinburgh, где он является одним из организаторов. Любит обсуждать вопросы формализмов в языке, хаки на шаблонах, пиво, виски, экспериментальное кино и творчество Carly Rae Jepsen.
---
6. Память – идеальная абстракция
================================
*Фёдор Короткий*
[Слайды](https://2018.cppconf.ru/talks/day-1/track-d/2.pdf)
```
int* ptr = new int;
*ptr = 42;
delete ptr;
```
Что на самом деле происходит, когда выполняются эти 3 строчки кода? Мы заглянем внутрь аллокатора памяти, операционной системы и современного железа, чтобы дать исчерпывающий ответ на этот вопрос.
**О докладчике**
 Фёдор — выпускник Физтеха, занимался High Frequency Trading на московской бирже. Работает в Яндексе, разрабатывает систему хранения и обработки данных YT. Преподаёт С++ на первом курсе школы анализа данных.
---
5. 105 STL Algorithms in Less Than an Hour
==========================================
*Jonathan Boccara*
[Слайды](https://2018.cppconf.ru/talks/day-1/track-a/3.pdf)
Все мы знаем, что неплохо бы знать алгоритмы STL. Используя их при построении архитектуры, можно сделать её более выразительной и надежной. Иногда — весьма значительно и эффектно.
А вы уже пришли к осознанию ваших алгоритмов?
В этом докладе вы увидите все 105 алгоритмов, включая те, что добавились в 11 и 17 стандартах. Но это не просто перечисление — суть доклада в том, чтобы показать наличие в этих алгоритмах системы, групп и паттернов, в которые они организуются, и как они относятся друг к другу.
Эта большая картина — лучший способ запомнить их все и осмыслить как полный набор инструментов и способов сделать код более выразительным и более надежным.
**О докладчике**
 Jonathan Boccara обожает C++ и в особенности — вопросы написания понятного выразительного кода. В частности, поэтому он ведёт блог «Fluent C++». А ещё он работает senior developer в компании Murex, где ворочает огромными кодовыми базами на С++, предназначенными для использования в финансах. У них в компании есть интересная практика каждый день делать короткие доклады в формате [«dailies»](https://en.wikipedia.org/wiki/Dailies), которые он и ведёт.
---
4. Асинхронность в программировании
===================================
*Иван Пузыревский*
В области разработки высоконагруженных многопоточных или распределенных приложений можно все чаще услышать разговоры об асинхронном коде, в том числе спекуляции о необходимости (отсутствии необходимости) учитывать асинхронность в коде, о понятности (непонятности) асинхронного кода, о его эффективности (неэффективности). В данном докладе мы с вами попробуем более глубоко погрузиться в предметную область: разберем, что такое асинхронность; когда она возникает; как влияет на код, который мы пишем, и на язык программирования, который мы используем. Постараемся разобраться, при чем тут futures & promises, немного поговорим про корутины и акторы. Затронем JavaScript и операционные системы. Цель доклада — сделать более явными компромиссы, возникающие при том или ином подходе к разработке многопоточного или распределенного ПО.
**О докладчике**
 Иван начал работать в Яндексе в 2009 году в отделе лингвистических технологий в Поиске. Сейчас занимается разработкой систем распределённого хранения и обработки данных. Выпускник кафедры математической логики и теории алгоритмов механико-математического факультета МГУ. Преподаватель ШАД.
---
3. C++ Today: The Beast is Back
===============================
*Jon Kalb*
[Слайды](https://2018.cppconf.ru/talks/day-1/track-a/1.pdf)
Это доклад, частично основанный на книге «C++ Today: The Beast is Back» издательства O'Reilly. В этом докладе мы немного поспекулируем, почему инженеры, желающие писать производительный код, выбирают именно C++. Джон представит историческую перспективу фокусировки на C++, расскажет, чем живёт сообщество C++ прямо сейчас и куда направляется язык и его аудитория. В последнее время эффективным кодом заинтересовались все, от производителей мобилок до больших датацентров, поэтому C++ с его опенсорсными библиотеками снова стал горячей темой. Этот доклад четко объясняет, почему большинство инженеров выбирают для всего этого именно C++. Имеется общая зарисовка C++ в масштабе истории с объяснениями точек роста и падения популярности.
**О докладчике**
 Джон кодит на C++ более 20 лет. За это время он успел поучаствовать в C++ проектах компаний Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, Yahoo! и ещё в парочке компаний, о которых никто всё равно не слышал. Он — председатель Boost Steering Committee, а также занимается программой C++ трека в Silicon Valley Code Camp и является одним из управляющих C++ Now (aka BoostCon). В 2014 году он получил Microsoft Most Valuable Professional.
---
2. Reflective Metaprogramming in C++
====================================
*Daveed Vandevoorde*
[Слайды](https://2018.cppconf.ru/talks/day-2/track-a/1.pdf)
Однажды комитет стандартизации C++ организовал подгруппу «SG-7», занимающуюся изучением возможностей реализовать рефлекшн. Недавно эта группа занялась ещё и метапрограммированием и сделала несколько важных решений относительно того, как будет выглядеть возможное решение. В этом докладе мы посмотрим в прошлое, которое довело нас до жизни такой, и порассуждаем над возможностями нативной поддержки «рефлективного метапрограммирования» в языке C++.
**О докладчике**
 Дэвид — бельгийский учёный, живущий рядом с Принстоном в США. Он является вице-президентом по инженерии в Edison Design Group, где контрибьютит, в основном, в их собственный фронтенд для C++ компилятора. Он активно участвует в комитете по стандартизации C++, где занимается эволюцией ядра языка.
---
1. Unexpected expected
======================
*Andrei Alexandrescu*
Написание кода, устойчивого к ошибкам — боль, боль на любом языке. Исключения хоть и являются политкорректным способом сигнализировать об ошибках в C++, но во множестве приложений приходится использовать коды возврата — по причинам, связанным с простотой понимания, простотой локальной обработки, эффективностью сгенерированного кода и так далее.
В этом докладе мы посмотрим, как теорию и практику можно объединить для решения проблем с обработкой ошибок. Обобщенный тип `Expected` можно использовать как локально (в стиле кодов возврата), так и централизованно (в стиле исключений), объединяя преимущества обоих подходов.
**О докладчике**
 Румынский разработчик Андрей Александреску является экспертом по широкому набору вопросов, включая архитектуру и реализацию программных систем, дизайн языков программирования, архитектуру библиотек, все аспекты языков C++ и D, машинное обучение и анализ естественных языков. Его креативный подход к решению проблем, широчайшие знания и харизматичность делают Андрея одним из самых популярных докладчиков в мире.
Книги и статьи Андрея повлияли на всю индустрию. Он — автор таких книг-бестселлеров, как «Modern C++ Design», «C++ Coding Standards» (вместе с Herb Sutter), «The D Programming Language», а также статей вроде «Simplify Your Exception-Safe Code — Forever» (написанной вместе с Petru Marginean) и «Mojo: Move of Joint Objects». Полный список его работ можно [посмотреть здесь](http://erdani.com/index.php/articles/).
> Следующая конференция C++ Russia пройдёт 19-20 апреля в Москве, то есть — совсем скоро. Новая программа, новые докладчики, а еще целый день [тренингов](https://cppconf.ru/trainings/?utm_source=habr&utm_medium=442498). Программу можно посмотреть [на официальном сайте](https://cppconf.ru/?utm_source=habr&utm_medium=442498#schedule), там же можно [приобрести билеты](https://cppconf.ru/registration/?utm_source=habr&utm_medium=442498). | https://habr.com/ru/post/442498/ | null | ru | null |
Subsets and Splits