text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Автоматизируем и ускоряем процесс настройки облачных серверов с Ansible. Часть 3: Переменные и файл inventory
[В первой части](http://habrahabr.ru/company/infobox/blog/249143/) мы начали изучение Ansible, популярного инструмента для автоматизации настройки и развертывания ИТ-инфраструктуры. Ansible был успешно установлен, описаны принципы работы, базовая настройка. В завершении статьи мы показали как быстро установить nginx на несколько серверов.
[Во второй части](http://habrahabr.ru/company/infobox/blog/250115/) мы разобрались в выводе playbook, научились отлаживать и повторно использовать скрипты Ansible.
В этой части вы узнаете, как писать единый Ansible playbook для разных ОС (например с rpm и deb), как обслуживать множество хостов и не писать их все в inventory, как сгруппировать сервера по регионам [InfoboxCloud](http://infoboxcloud.ru) и многое другое.
#### **Переменные в Ansible**
Переменные используются для хранения значений, которые могут применяться в playbook. В процессе использования переменные можно переопределять множество раз. Информация о серверах из inventory также может использоваться как переменные.
Есть несколько способов определения переменных в Ansible:
* передача файла переменных
* определение переменных в playbook
* передача в ansible-playbook, используя команду **-e** / **--extra-vars**
* определение переменных в файле inventory
Необходимость использования переменных отлично демонстрирует пример с установкой Apache. Дело в том, что в разных дистрибутивах пакет с apache называется по-разному. Разница в конфигурациях разных ОС встречается достаточно часто.
Например:
```
- set_fact package_name=httpd
when: ansible_os_family == "Redhat"
- set_fact package_name=apache2
when: ansible_os_family == "Debian"
```
Задача установит в переменную package\_name значение httpd или apache2 в зависимости от семейства ОС на сервере.
Переменные можно использовать для установки значений пользователя в процессе исполнения playbook:
```
- name: Package to install
pause: prompt="Provide the package name which you want to install "
register: package_name
```
В переменные удобно сохранить список значений для его многократного использования. Если одна и та же переменная используется во множестве playbook – их использование уменьшит сложность скриптов.
**Все переменные в Ansible должны начинаться с буквы. В имени можно использовать буквы, цифры и подчеркивания.**
Переменные, определенные в include файлах будут перегружать (заменять) переменные, определенные на других уровнях иерархии, кроме переменных, переданных через **--extra-vars**.
##### **Переменные в импортированных файлах**
Давайте рассмотрим, как можно использовать переменные из импортированных в playbook файлов.
Сделаем отдельный файл задачи по установке Apache (~/ansible/playbooks/tasks/**pkg\_apache\_install.yml**):
```
- set_fact: package_name=httpd
when: ansible_os_family == "Redhat"
- set_fact: package_name=apache2
when: ansible_os_family == "Debian"
- name: Install httpd package
yum: name=httpd state=latest
sudo: yes
when: ansible_os_family == "Redhat"
- name: Install apache2 package
apt: name=apache2 state=latest
sudo: yes
when: ansible_os_family == "Debian"
```
Включим его в файл установки Apache и проверки, что сервис запущен (~/ansible/**setup\_apache.yml**):
```
---
- hosts: experiments
remote_user: root
tasks:
- include: tasks/pkg_apache_install.yml
- name: Check apache service
service: name={{ package_name }} state=started
sudo: yes
```
Как мы видим, в файле setup\_apache.yml мы успешно используем переменную, определенную во включенном файле. Данный playbook будет правильно устанавливать apache и на rpm дистрибутивы и на deb, используя правильное имя пакета с apache.
##### **Переменные в playbook**
Переменные в playbook устанавливаются с помощью ключевого слова **vars:**. Переменные устанавливаются в виде имя\_переменной: значение. Переменные перегрузят другие переменные, которые установлены в глобальном файле или в inventory.
Пример описания переменной в playbook:
```
vars:
- package_name: "httpd"
```
##### **Переменные в глобальном файле**
Переменные в Ansible можно задавать в отдельном файле, что позволяет отделить данные от playbook. Можно создавать столько файлов переменных, сколько необходимо, нужно только сказать playbook где их искать. Формат определения переменных в файле похож на формат определения переменных в Playbook.
~/ansible/common/vars/**global.yml**
```
---
package_name: "httpd" #Apache
#Enviroment variables
proxy_env:
INFOBOXCLOUD_API_KEY: "{{ lookup('env', 'INFOBOXCLOUD_API_KEY') }}"
INFOBOXCLOUD_LOGIN: "{{ ('env', 'INFOBOXCLOUD_LOGIN') }}"
```
В данном примере мы задаем переменную package\_name напрямую (после # можно написать комментарий), а ключи доступа для InfoboxCloud API ищем в переменных окружения с помощью плагина lookup.
В playbook путь к файлам переменных задается через vars\_files:
```
vars_files:
- var1.yml
- var2.yml
```
##### **Использование фактов как переменных**
Вы можете использовать любой факт как переменную, который собирается при gather\_facts. Для получения списка всех фактов для конкретной группы машин используйте команду:
```
ansible experiments -i inventory -m setup
```
, где experiments – название группы машин в inventory.
#### **Погружаемся в inventory–файл**
[В первой части](https://infoboxcloud.ru/community/blog/iaas/226.html) мы кратко рассматривали простой inventory–файл. Давайте посмотрим на него внимательнее.
Простой inventory (~/ansible/**inventory**):
```
ansible.trukhin.com
77.221.144.179
```
Можно просто записать имена хостов и ip адреса и будут использоваться все сервера при исполнении playbook с этим файлом inventory.
##### **Группы в inventory**
Использование групп мы также уже видели ранее:
```
[my]
ansible.trukhin.com
ansible2.trukhin.com
[corp]
ansible.sandbox.infoboxcloud.ru
ansible2.sandbox.infoboxcloud.ru
```
Группа для исполнения playbook указывается в разделе «hosts:» playbook
```
hosts: my
```
Если вы хотите использовать конкретный хост — можно в раздел hosts передать его.
```
hosts: ansible.trukhin.com
```
Если вы хотите использовать все хосты всех групп — можно использовать
```
hosts: all
```
##### **Группы групп в inventory**
Очень полезная функция, позволяющая, например, сгруппировать хосты не только по назначению, но и по региону размещения, что очень актуально для InfoboxCloud (Москва, Амстердам). Нередко бывают и другие задачи, где нужно использовать группы групп.
```
[msk]
webMSK.trukhin.com
dbMSK.trukhin.com
[ams]
webAMS.trukhin.com
dbAMS.trukhin.com
[web:children]
msk
ams
```
В этом примере в группу web my входят сервера в Москве и Амстердаме. Можно из playbook обращаться как к группе web, так и к группам серверов в конкретном регионе.
##### **Регулярные выражения в inventory**
Если у вас есть большое количество серверов, использование соглашений о наименовании (например web001, web002… web00N) позволит проще указывать их в inventory. Можно использовать регулярные выражения в inventory файле:
```
[web]
web[001:200]
[db]
db[001:020]
[balancer]
192.168.2.[1:3]
```
, где **web[001:200]** будет соответствовать web 001, web002, web003, web004, ..., web199, web200 для группы web;
**db[001:020]** будет соответствовать db001, db002, db003 ..., db019, db020 для группы db.
**192.168.2.[1:30]** будет соответствовать 192.168.2.1, 192.168.2.2, 192.168.2.3 для группы balancer.
##### **Переменные в inventory–файле**
Рассмотренные ранее способы установки переменных применяли их сразу ко всем хостам в inventory. Иногда может потребоваться использование специфических переменных для конкретной группы хостов или конкретного хоста.
Установка переменных для конкретных хостов:
```
ansible.trukhin.com
web001
db001 db_name=mysql
192.168.2.1 db_name=redis db_port=6380
```
Установка переменных для группы хостов (web):
```
[web]
web[001:010]
[db]
db[001:002]
[web:vars]
web_port=443
```
##### **Вынос переменных в отдельные файлы для inventory**
Можно создавать файлы переменных для хостов и для групп. Папки с этими файлами должны быть в одной директории с файлом inventory. Файлы переменных, относящиеся к конкретным хостам, нужно сохранять в папку host\_vars, относящиеся к конкретным группам — в папку group\_vars.
Пример файла переменных для хоста web001 (~/ansible/**host\_vars**/web001):
```
web_port_ssl=443
web_port=80
```
Пример файла переменных для группы db (~/ansible/group\_vars/db):
```
db_port=6380
db_name=redis
```
Переменные inventory следуют иерархии: переменные в глобальном файле перегружают любые хост-переменные, групповые переменные и переменные в файле inventory. Хост-переменные перегружают групповые переменные, а в свою очередь групповые переменные перегружают переменные файла inventory.
Через **ansible.cfg** можно переопределить параметры конфигурации Ansible.
#### Заключение
В написании статьи очень помогла книга "[Learning Ansible](http://www.amazon.com/Learning-Ansible-Madhurranjan-Mohaan/dp/1783550635/ref=sr_1_2?ie=UTF8&qid=1422482924&sr=8-2&keywords=ansible)" и конечно [официальная документация](http://docs.ansible.com).
Все эксперименты с Ansible удобно проводить в [InfoboxCloud](http://infoboxcloud.ru), так как имеется возможность для каждого виртуального сервера установить именно то количество ресурсов, которое необходимо для задачи (CPU/Ram/диск независимо друг от друга) или использовать автомасштабирование, а не выбирать VM из готовых шаблонов. Когда эксперименты не проводятся — можно просто выключить VM и оплачивать только стоимость диска.
Если вы обнаружили ошибку в статье, автор ее с удовольствием исправит. Пожалуйста напишите в ЛС или [на почту](mailto:trukhinyuri@infoboxcloud.com) о ней. Туда же можно задавать вопросы по Ansible для освещения в последующих статьях.
[Часть 4: работаем с модулями](http://habrahabr.ru/company/infobox/blog/252239/)
[Часть 5: local\_action, условия, циклы и роли](http://habrahabr.ru/company/infobox/blog/252461/)
Успешной работы! | https://habr.com/ru/post/252001/ | null | ru | null |
# Знакомство с Helm 3
***Прим. перев.**: 16 мая этого года — значимая веха в развитии менеджера пакетов для Kubernetes — Helm. В этот день был представлен первый альфа-релиз будущей крупной версии проекта — 3.0. Её выход принесёт в Helm существенные и долгожданные изменения, на которые многие в Kubernetes-сообществе возлагают большие надежды. К таковым относимся и мы сами, поскольку активно используем Helm для деплоя приложений: мы интегрировали его в свой инструмент для реализации CI/CD [werf](https://github.com/flant/werf) и от случая к случая вносим посильный вклад в развитие upstream. Этот перевод объединяет 7 заметок из официального блога Helm, что приурочены к первому альфа-релизу Helm 3 и рассказывают об истории проекта и основных фичах Helm 3. Их автор — Matt «bacongobbler» Fisher, сотрудник Microsoft и один из ключевых мейнтейнеров Helm.*
15 октября 2015 года родился проект, ныне известный как Helm. Всего через год после основания сообщество Helm присоединилось к Kubernetes, попутно активно работая над Helm 2. В июне 2018 года Helm [вошел в состав CNCF](https://www.cncf.io/blog/2018/06/01/cncf-to-host-helm/) в качестве развивающегося (incubating) проекта. Перенесемся в настоящее — и вот уже на подходе первый альфа-релиз нового Helm 3 *(этот релиз [уже состоялся](https://github.com/helm/helm/releases/tag/v3.0.0-alpha.1) в середине мая — прим. перев.)*.
В этом материале я расскажу о том, с чего все начиналось, как мы дошли до нынешней стадии, представлю некоторые уникальные особенности, доступные в первом альфа-релизе Helm 3, и объясню, как мы планируем развиваться дальше.
Краткое содержание:
* история создания Helm;
* нежное прощание с Tiller'ом;
* репозитории чартов;
* управление релизами;
* изменения в зависимостях чартов;
* library charts;
* что дальше?
История создания Helm
---------------------
### Рождение
Helm 1 начинался как Open Source-проект, созданный компанией Deis. Мы были небольшим стартапом, [поглощенным](https://blogs.microsoft.com/blog/2017/04/10/microsoft-acquire-deis-help-companies-innovate-containers/) Microsoft весной 2017 года. У нашего другого Open Source-проекта, также носящего имя Deis, был инструмент `deisctl`, который использовался (кроме прочего) для установки и эксплуатации платформы Deis в [кластере Fleet](https://github.com/coreos/fleet). В то время Fleet был одной из первых платформ для оркестровки контейнеров.
В середине 2015-го мы решили сменить курс и перевели Deis (на тот момент переименованный в Deis Workflow) с Fleet на Kubernetes. Одним из первых был переработан инструмент установки `deisctl`. Мы использовали его для инсталляции и управления Deis Workflow в кластере Fleet.
Helm 1 был создан по образу и подобию известных пакетных менеджеров, таких как Homebrew, apt и yum. Его основной задачей являлось упрощение таких задач, как упаковка и инсталляция приложений в Kubernetes. Официально Helm был представлен в 2015 году на конференции KubeCon в Сан-Франциско.
Наша первая попытка с Helm сработала, однако не обошлось без серьезных ограничений. Он брал набор манифестов Kubernetes, сдобренных генераторами в качестве вводных YAML-блоков *(front-matter)*\*, и загружал результаты в Kubernetes.
*\* **Прим. перев.**: С первой версии Helm для описания ресурсов Kubernetes был выбран синтаксис YAML, а при написании конфигураций поддерживались шаблоны Jinja и Python-скрипты. Подробнее об этом и устройстве первой версии Helm вообще мы писали в главе «Краткая история Helm» [этого материала](https://habr.com/ru/company/flant/blog/417079/).*
Например, чтобы заменить поле в YAML-файле, нужно было добавить в манифест следующую конструкцию:
```
#helm:generate sed -i -e s|ubuntu-debootstrap|fluffy-bunny| my/pod.yaml
```
Классно, что сегодня существуют шаблонизаторы, не правда ли?
По многим причинам этот ранний Kubernetes-инсталлятор требовал жестко прописанный список манифест-файлов и выполнял только небольшую фиксированную последовательность событий. Пользоваться им было настолько тяжело, что R&D-команде Deis Workflow пришлось несладко, когда они попытались перевести свой продукт на эту платформу — впрочем, семена идеи уже были посеяны. Наша первая попытка стала отличной возможностью для обучения: мы осознали, что по-настоящему увлечены созданием прагматичных инструментов, решающих повседневные проблемы для наших пользователей.
Опираясь на опыт прошлых ошибок, мы приступили к разработке Helm 2.
### Создание Helm 2
В конце 2015 года с нами связалась команда Google. Они работали над похожим инструментом для Kubernetes. Deployment Manager для Kubernetes был портом существующего инструмента, который использовался для Google Cloud Platform. «Не хотим ли мы, — спросили они, — потратить несколько дней на обсуждение сходств и различий?»
В январе 2016 команды Helm'а и Deployment Manager'а встретились в Сиэтле, чтобы обменяться идеями. Переговоры завершились амбициозным планом: объединить оба проекта, чтобы создать Helm 2. Вместе с Deis и Google к команде разработчиков присоединились парни из [SkippBox](https://github.com/skippbox) *(ныне входит в состав Bitnami — прим. перев.)*, и мы приступили к работе над Helm 2.
Мы хотели сохранить простоту использования Helm, но добавить следующее:
* шаблоны чартов для кастомизации;
* внутрикластерное управление для команд;
* первоклассный репозиторий чартов;
* стабильный формат пакетов с возможностью подписи;
* твердую приверженность семантическому версионированию и сохранению обратной совместимости между версиями.
Для достижения этих целей в экосистему Helm был добавлен второй элемент. Этот внутрикластерный компонент назывался Tiller и занимался инсталляцией Helm-чартов и их управлением.
С момента выхода Helm 2 в 2016-м Kubernetes оброс несколькими серьезными нововведениями. Появилось управление доступом на основе ролей ([RBAC](https://habr.com/ru/company/flant/blog/422801/)), которое в конечном итоге заменило контроль доступа на основе атрибутов (ABAC). Были представлены новые типы ресурсов (Deployments в то время по-прежнему оставались в статусе бета-версии). Были изобретены Custom Resource Definitions (изначально они назывались Third Party Resources или TPRs). А самое главное — появился набор лучших практик.
На фоне всех этих изменений Helm продолжал служить верой и правдой пользователям Kubernetes. После трех лет и множества новых дополнений стало ясно, что пора вносить существенные изменения в кодовую базу, чтобы Helm и дальше мог удовлетворять растущие потребности развивающейся экосистемы.
Нежное прощание с Tiller'ом
---------------------------
Во время разработки Helm 2 мы представили Tiller как часть нашей интеграции с Deployment Manager'ом от Google. Tiller играл важную роль для команд, работающих в рамках общего кластера: он позволял различным специалистам, эксплуатирующим инфраструктуру, взаимодействовать с одним и тем же набором релизов.
Поскольку контроль доступа на основе ролей (RBAC) был по умолчанию включен в Kubernetes 1.6, работа с Tiller'ом в production становилась сложнее. Из-за огромного числа возможных политик безопасности наша позиция состояла в том, чтобы по умолчанию предлагать разрешительную конфигурацию. Это позволяло новичкам проводить эксперименты с Helm и Kubernetes без необходимости сначала погружаться в настройки безопасности. К сожалению, эта разрешительная конфигурация могла наделить пользователя слишком широким диапазоном разрешений, которые ему не были нужны. DevOps- и SRE-инженерам приходилось изучать дополнительные эксплуатационные шаги, устанавливая Tiller в многопользовательский (multi-tenant) кластер.
Узнав, как представители сообщества используют Helm в конкретных ситуациях, мы поняли, что системе управления релизами Tiller'а не нужно полагаться на внутрикластерный компонент, чтобы поддерживать состояния или функционировать в качестве центрального хаба с информацией о релизе. Вместо этого мы могли бы просто получать информацию от API-сервера Kubernetes, генерировать чарт на стороне клиента и сохранять запись об установке в Kubernetes.
Основную задачу Tiller'а можно было осуществить и без Tiller'а, поэтому одним из первых наших решений в отношении Helm 3 стал полный отказ от Tiller'а.
С уходом Tiller'а модель безопасности Helm радикально упростилась. Helm 3 теперь поддерживает все современные способы безопасности, идентификации и авторизации нынешнего Kubernetes. Разрешения Helm определяются с помощью [файла kubeconfig](https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/). Администраторы кластера могут ограничивать права пользователей с любой степенью детализации. Релизы по-прежнему сохраняются внутри кластера, остальная функциональность Helm сохраняется.
Репозитории чартов
------------------
На высоком уровне репозиторий чартов — это место, где можно хранить и совместно использовать чарты. Клиент Helm пакует и отправляет чарты в репозиторий. Проще говоря, репозиторий чартов — это примитивный HTTP-сервер с файлом index.yaml и некоторыми упакованными чартами.
Хотя есть некоторые преимущества в том, что API репозитория чартов отвечает наиболее основным требованиям к хранилищу, у него есть и несколько недостатков:
* Репозитории чартов плохо совместимы с большинством реализаций безопасности, необходимых в production-окружении. Наличие стандартного API для аутентификации и авторизации крайне важно в production-сценариях.
* Инструменты Helm’а для отслеживания происхождения чарта, используемые для подписи, проверки целостности и происхождения чарта, являются необязательной частью процесса публикации Chart’а.
* В многопользовательских сценариях один и тот же чарт может быть загружен другим пользователем, в два раза увеличивая объем пространства, необходимый для хранения одного и того же контента. Для решения этой проблемы были разработаны более умные репозитории, однако они не являются частью формальной спецификации.
* Использование единого индекс-файла для поиска, хранения метаданных и получения чартов усложнило разработку безопасных многопользовательских реализаций.
Проект [Docker Distribution](https://github.com/docker/distribution) (также известный как Docker Registry v2) является преемником Docker Registry и фактически выступает набором инструментов для упаковки, отправки, хранения и поставки образов Docker. Многие крупные облачные сервисы предлагают продукты на основе Distribution. Благодаря такому повышенному вниманию проект Distribution выиграл от многолетних усовершенствований, лучших практик в области безопасности и тестирования в «боевых» условиях, превративших его в одного из самых успешных невоспетых героев мира Open Source.
Но знаете ли вы, что проект Distribution был разработан для распространения любой формы контента, а не только образов контейнеров?
Благодаря усилиям [Open Container Initiative](https://www.opencontainers.org/) (или OCI), Helm-чарты могут быть размещены на любом экземпляре Distribution. Пока этот процесс носит экспериментальный характер. Работа над поддержкой логинов и другими функции, необходимыми для полноценного Helm 3, еще не окончена, но мы очень рады возможности учиться на открытиях, сделанных командами OCI и Distribution за эти годы. А благодаря их наставничеству и руководству мы узнаём, что такое эксплуатация высокодоступного сервиса в большом масштабе.
Более подробное описание некоторых предстоящих изменений в репозиториях Helm-чартов доступно [по ссылке](https://blog.bacongobbler.com/post/2019-01-25-distributing-with-distribution/).
Управление релизами
-------------------
В Helm 3 состояние приложения отслеживается внутри кластера парой объектов:
* release object — представляет экземпляр приложения;
* release version secret — представляет желаемое состояние приложения в конкретный момент времени (например, релиз новой версии).
Вызов `helm install` создает release object и release version secret. Вызов `helm upgrade` требует наличия release object (который он может менять) и создает новый release version secret, содержащий новые значения и подготовленный манифест.
Release object содержит информацию о релизе, где релиз — конкретная инсталляция именованного чарта и значений. Этот объект описывает метаданные верхнего уровня о релизе. Release object сохраняется в течение всего жизненного цикла приложения и выступает владельцем всех release version secret'ов, а также всех объектов, которые непосредственно создаются Helm-чартом.
Release version secret связывает релиз с серией ревизий (инсталляция, обновления, откаты, удаление).
В Helm 2 ревизии были исключительно последовательными. Вызов `helm install` создавал v1, последующее обновление (upgrade) — v2, и так далее. Release и release version secret были свернуты в единый объект, известный как revision. Revision'ы хранились в том же пространстве имен, что и Tiller, что означало, что каждый релиз был «глобален» в плане пространства имен; в результате можно было использовать только один экземпляр имени.
В Helm 3 каждый релиз связан с одним или несколькими release version secret'ами. Release object всегда описывает текущий релиз, развернутый в Kubernetes. Каждый release version secret описывает только одну версию этого релиза. Обновление (upgrade), например, создаст новый release version secret и затем изменит release object, чтобы тот указывал на эту новую версию. В случае отката (rollback) можно использовать предыдущие release version secret'ы, чтобы откатить релиз к предыдущему состоянию.
После отказа от Tiller'а Helm 3 хранит данные о релизе в едином с релизом пространстве имен. Подобное изменение позволяет инсталлировать чарт с таким же именем релиза в другое пространство имен, и данные сохраняются между обновлениями/перезагрузками кластера в etcd. Например, можно установить Wordpress в пространство имен «foo», а затем в пространство имен «bar», и оба релиза могут называться «wordpress».
Изменения в зависимостях чартов
-------------------------------
Чарты, упакованные (с помощью `helm package`) для использования с Helm 2, можно инсталлировать с Helm 3, однако рабочий процесс разработки чартов был полностью пересмотрен, поэтому необходимо внести некоторые изменения, чтобы продолжить разработку чартов с Helm 3. В частности, изменилась система управления зависимостями чартов.
Система управления зависимостями чарта перешла с `requirements.yaml` и `requirements.lock` на `Chart.yaml` и `Chart.lock`. Это означает, что чарты, использовавшие команду `helm dependency`, требуют некоторой настройки, чтобы работать в Helm 3.
Давайте рассмотрим пример. Добавим зависимость к чарту в Helm 2 и посмотрим, что изменится при переходе к Helm 3.
В Helm 2 `requirements.yaml` выглядел следующим образом:
```
dependencies:
- name: mariadb
version: 5.x.x
repository: https://kubernetes-charts.storage.googleapis.com/
condition: mariadb.enabled
tags:
- database
```
В Helm 3 та же зависимость будет отражена в вашем `Chart.yaml`:
```
dependencies:
- name: mariadb
version: 5.x.x
repository: https://kubernetes-charts.storage.googleapis.com/
condition: mariadb.enabled
tags:
- database
```
Чарты по-прежнему загружаются и помещаются в директорию `charts/`, поэтому субчарты *(subcharts)*, лежащие в каталоге `charts/`, продолжат работать без изменений.
Представляем Library Charts
---------------------------
Helm 3 поддерживает класс чартов, получивший название чартов-библиотек *(library chart)*. Этот чарт используется другими чартами, но самостоятельно не создает никаких артефактов релиза. Шаблоны library chart'ов могут объявлять только элементы `define`. Иной контент попросту игнорируется. Это позволяет пользователям повторно использовать и обмениваться фрагментами кода, которые можно задействовать во многих чартах, тем самым избежав дублирования и придерживаясь принципа [DRY](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself).
Library charts объявляются в разделе `dependencies` в файле `Chart.yaml`. Установка и управление ими не отличаются от других чартов.
```
dependencies:
- name: mylib
version: 1.x.x
repository: quay.io
```
Мы с предвкушением ждем вариантов использования, которые этот компонент откроет перед разработчиками чартов, а также лучших практик, что могут возникнуть благодаря library charts.
Что дальше?
-----------
Helm 3.0.0-alpha.1 — основа, опираясь на которую, мы начинаем создавать новую версию Helm. В статье я описал некоторые интересные возможности Helm 3. Многие из них пока находятся на ранних стадиях разработки и это нормально; суть альфа-релиза в том, чтобы проверить идею, собрать отзывы от первых пользователей и подтвердить наши предположения.
Как только альфа-версия будет выпущена *(напомним, что это [уже произошло](https://github.com/helm/helm/releases/tag/v3.0.0-alpha.1) — прим. перев.)*, мы начнем принимать патчи для Helm 3 от сообщества. Необходимо создать надежный фундамент, который позволит разрабатывать и принимать новые функциональные возможности, а пользователи смогут чувствовать себя вовлеченными в процесс, открывая тикеты и внося исправления.
В статье я постарался осветить некоторые серьезные улучшения, которые появятся в Helm 3, однако этот список ни в коем случае нельзя назвать исчерпывающим. Полномасштабный план для Helm 3 включает в себя такие нововведения, как улучшенные стратегии обновления, более глубокая интеграция с реестрами OCI и использование JSON-схем для проверки значений чартов. Также мы планируем очистить кодовую базу и обновить те ее части, которые оставались без внимания последние три года.
Если чувствуете, что мы что-то упустили, будем рады услышать ваши мысли!
Присоединяйтесь к обсуждению в наших [Slack-каналах](https://kubernetes.slack.com/):
* `#helm-users` для вопросов и простого общения с сообществом;
* `#helm-dev` для обсуждения pull requests, кода и багов.
Вы также можете пообщаться в наших еженедельных Public Developer Calls по четвергам в 19:30 MSK. Встречи посвящены обсуждению задач, над которыми работают ключевые разработчики и сообщество, а также темам обсуждения на неделю. Любой желающий может присоединиться и принять участие во встрече. Ссылка доступна в Slack-канале `#helm-dev`.
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «[Пакетный менеджер для Kubernetes — Helm: прошлое, настоящее, будущее](https://habr.com/ru/company/flant/blog/417079/)»;
* «[Трезвый взгляд на Helm 2: „Вот такой, какой есть...“](https://habr.com/ru/company/flant/blog/438814/)»;
* «[Практическое знакомство с пакетным менеджером для Kubernetes — Helm](https://habr.com/ru/company/flant/blog/420437/)»;
* «[Kubernetes tips & tricks: перевод работающих в кластере ресурсов под управление Helm 2](https://habr.com/ru/company/flant/blog/441964/)»;
* «[Практика с dapp. Часть 2. Деплой Docker-образов в Kubernetes с помощью Helm](https://habr.com/ru/company/flant/blog/336170/)». | https://habr.com/ru/post/453734/ | null | ru | null |
# Поиск по блогам на Хабре
За последнее время Хабр очень сильно вырос. При создании очередного топика у меня возникла необходимость поискать по названиям блогов на хабре. У самого хабра такой возможности нет, но эту проблему можно решить с помощью Google.
Итак, открываем google.com и пишем такой запрос:
`site:habrahabr.ru inurl:blogs intitle:Блог intitle:Хабрахабр intitle:**Программирование**`
Где вместо слова **«программирование»** нужно вставить искомое слово | https://habr.com/ru/post/49445/ | null | ru | null |
# Обобщаем паттерн посетитель (С++)
Недостатки типичной реализации
------------------------------
В статье намеренно не приведен пример типичной реализации паттерна посетителя в C++.
Если вы не знакомы с этим паттерном, то вот [тут](https://refactoring.guru/ru/design-patterns/visitor) можно с ним ознакомиться.
А если в двух словах, то этот паттерн очень полезен если вам нужно обойти коллекцию из указателей на абстрактный базовый класс, применив к ним какую-то операцию в зависимости от типа, который скрывается за абстракцией.
Поэтому перейдем сразу к недостаткам, которые хотели бы устранить.
* При добавлении класса в иерархию (или удалении), приходится изменить много мест в коде. (Каждый раз лезть и добавлять чисто виртуальную функцию-член в абстрактный класс, и почти во все реализации.)
* При добавлении нового посетителя, приходится наследоваться от абстрактного класса, даже если мы всего то хотим вызвать просто шаблон функции. При этом мы не можем сделать шаблон виртуальной функции-члена *visit* у посетителя (причина этого проста, шаблонов виртуальных функций-членов просто нет). Каждую реализацию функции-члена *visit* приходится делать отдельно.
* Класс посетителя привязан к предметной области.
Что хотим получить?
-------------------
* Имея на руках указатель на абстрактный базовый класс, хотим сразу получать реальный тип объекта и отправлять его самого или его тип в какой-нибудь шаблон функции, не используя при этом никаких конструкций из *dynamic\_cast* или *static\_cast* и не создавая множество одинаковых переопределений виртуальных функций.
* Простым способом добавлять или удалять классы, которые посетитель может обойти.
* Не привязанный к предметной области посетитель.
Реализация
----------
Начинаем с создания абстрактного посетителя.
Source:
```
template< class T >
struct AbstractVisitor
{
virtual ~AbstractVisitor() = default;
virtual void visit( T& ) = 0;
};
```
*(Пояснение: здесь виртуальная функция-член visit не является шаблоном, количество виртуальных функций при инстанцировании класса AbstractVisitor точно известно т.к. T является параметром шаблона класса, а не функции )*
Инстанс конкретного посетителя сможет обойти только один тип объекта. Нам же необходимо чтобы посетитель мог обходить несколько различных типов объектов.
Для этого создадим простой список типов *TypeList* и класс агрегатор *AbstractVisitors*. Список у *AbstractVisitors* будет содержать все типы объектов, которые посетитель может обойти.
Source:
```
template< class ... T >
struct TypeList
{
};
template< class T >
struct AbstractVisitor
{
virtual ~AbstractVisitor() = default;
virtual void visit( T& ) = 0;
};
template< class ...T >
struct AbstractVisitors;
template< class ... T >
struct AbstractVisitors< TypeList< T... > > : AbstractVisitor< T >...
{
};
```
Т.к. мы не хотим каждый раз наследоваться от абстрактного посетителя, наследуемся от него один раз и будем принимать функтор (если быть точным, то принимать будем обобщённую лямбду). Для этого создадим класс *Dispatcher*.
Source:
```
template< class Functor, class ... T >
struct Dispatcher;
template< class Functor, class ... T >
struct Dispatcher< Functor, TypeList< T... > > : AbstractVisitors< TypeList< T... > >
{
Dispatcher( Functor functor ) : functor( functor ) {}
Functor functor;
};
```
Теперь необходимо для всех типов из листа переопределить виртуальную функцию-член *visit*.
Для этого создадим класс *Resolver*, который этим и будет заниматься. А сам класс *Dispatcher* унаследуем от всех возможных типов *Resolver*-ов.
Дополнительно необходимо вызывать функтор в переопределенной функции, воспользуемся (CRTP) и передадим тип *Dispatcher* как аргумент шаблона во все *Resolver*.
(Подробнее о том что такое CRTP можно почитать [тут](https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern)).
Source:
```
template< class Dispatcher, class T >
struct Resolver : AbstractVisitor< T >
{
void visit( T& obj ) override
{
static_cast< Dispatcher* >( this )->functor( obj );
};
};
template< class Functor, class ... T >
struct Dispatcher< Functor, TypeList< T... > > : AbstractVisitors< TypeList< T... > >, Resolver< Dispatcher< Functor, TypeList< T... > >, T >...
{
Dispatcher( Functor functor ) : functor( functor ) {}
Functor functor;
};
```
Вроде все в порядке.
Попробуем создать объект класс *Dispatcher*. Компилятор начинает ругаться на то, что объект класса *Dispatcher* абстрактный, как же так?
Причина этого в том, что мы переопределили виртуальные функции для *Resolver*, но для *Dispatcher* мы ведь ничего не переопределяли.
Чтобы этого избежать, необходимо сделать наследование от *AbstractVisitor< T >*виртуальным.(Подробнее о размещении объектов в памяти и виртуальном наследовании можно почитать [тут](http://scrutator.me/post/2014/06/02/objects_memory_layout_p2.aspx).)
Source:
```
template< class ... T >
struct AbstractVisitors< TypeList< T... > > : virtual AbstractVisitor< T >...
{
};
template< class Dispatcher, class T >
struct Resolver : virtual AbstractVisitor< T >
{
void visit( T& obj ) override
{
static_cast< Dispatcher* >( this )->functor( obj );
};
};
```
Создадим абстрактный базовый класс (*AbstractObject*) и какие-нибудь классы (*Object1*, *Object2*), которые хотели обойти.
Так же создадим функцию *test* и шаблон функции *test*, которые будут получать непосредственно ссылку на объект определенного типа.
Пример использования:
Source:
```
struct Object1;
struct Object2;
using ObjectList = TypeList< Object1, Object2 >;
struct AbstractObject
{
virtual void accept( AbstractVisitors< ObjectList >& visitor ) = 0;
};
struct Object1 : AbstractObject
{
void accept( AbstractVisitors< ObjectList >& visitor ) override
{
static_cast< AbstractVisitor< Object1 >& >( visitor ).visit( *this );
};
};
struct Object2 : AbstractObject
{
void accept( AbstractVisitors< ObjectList >& visitor ) override
{
static_cast< AbstractVisitor< Object2 >& >( visitor ).visit( *this );
};
};
void test( Object1& obj )
{
std::cout << "1" << std::endl;
}
template< class T >
void test( T& obj )
{
std::cout << "2" << std::endl;
}
int main()
{
Object1 t1,t2,t3,t4;
Object2 e1,e2,e3;
std::vector< AbstractObject* > vector = { &t1, &e1, &t2, &t3, &e2, &e3, &t4 };
auto l = []( auto& obj ){ test(obj); };
Dispatcher dispatcher;
for( auto\* obj : vector )
{
obj->accept( dispatcher );
}
}
```
*(Пояснение: мы не можем просто написать* `visitor.visit( *this )`*, это приведет к неоднозначности, если классов в иерархии будет больше двух.)*
Строчки на которых создается обобщенная лямбда и объект класса *Dispatcher* какие-то то страшные и не удобные, спрятать бы все это от глаз.
Так же, хотелось бы спрятать функцию-член accept у *AbstractObject*, *Object1* и *Object2*, т.к. тело функции для всех типов объектов будет одинаковое, различаться будет только тип объекта.
Для этого создадим абстрактный класс *Dispatchable*. Cделаем у него чисто виртуальную функцию-член *accept* и шаблон функции-члена который будет принимать функтор. В нем собственно и будем создавать наш *Dispatcher*.
Помимо этого создадим макрос *DISPATCHED*, он понадобится чтобы спрятать переопределение функции-члена *accept* у *Object1* и *Object2*.
Source:
```
template< class TypeList >
struct Dispatchable
{
virtual ~Dispatchable() = default;
virtual void accept( AbstractVisitors< TypeList >& ) = 0;
template< class Functor >
void dispatch( Functor functor )
{
static Dispatcher< decltype(functor), TypeList > dispatcher( functor );
accept( dispatcher );
};
};
#define DISPATCHED( TYPE, TYPE_LIST ) \
void accept( AbstractVisitors< TYPE_LIST >& visitor ) override \
{ \
static_cast< AbstractVisitor< TYPE >& >( visitor ).visit( *this ); \
}
```
Затем наследуем *AbstractObject* от класса *Dispatchable*. А в классы *Object1* и *Object2* добавляем макрос *DISPATCHED*.
Source:
```
struct Object1;
struct Object2;
using ObjectList = TypeList< Object1, Object2 >;
struct AbstractObject : Dispatchable< ObjectList >
{
};
struct Object1 : AbstractObject
{
DISPATCHED( Object1, ObjectList )
};
struct Object2 : AbstractObject
{
DISPATCHED( Object2, ObjectList )
};
```
Отлично, мы спрятали все функции-члены *accept* и вынесли общий код. Вот теперь все готово.
Пример использования:
Source:
```
void test( Object1& obj )
{
std::cout << "1" << std::endl;
}
template< class T >
void test( T& obj )
{
std::cout << "2" << std::endl;
}
int main()
{
Object1 t1,t2,t3,t4;
Object2 e1,e2,e3;
std::vector< AbstractObject* > vector = { &t1, &e1, &t2, &t3, &e2, &e3, &t4 };
for( auto* obj : vector )
{
obj->dispatch( []( auto& obj ) { test(obj); } );
}
}
```
Output:1
2
1
1
2
2
1
Производительность
------------------
Хороший вопрос был задан в комментариях, чем этот подход лучше по сравнению с уже имеющимися в стандартной библиотеке std::visit и std::variant.
Проблема std::variant в том, что он не выделяет общего поведения. Т.е. мы не можем просто взять и вызвать напрямую какую-то функцию базового класса, необходимо обращаться к std::visit.
Сравним производительность при их типичном использовании.
А именно:
1. Диспетчеризацию через метод dispatch и std::visit.
2. Вызов виртуальной функции-члена с вызовом обычной, обернутой в std::visit.
3. Вызов обычной функции-члена с вызовом обычной функции, обернутой в std::visit.
Вызов виртуальной функции сравнивать с вызовом виртуальной обернутой в std::visit нет особого смысла.
1. ДиспетчеризацияClang 10.0, Optim=OFast
GCC 10.1, Optim=OFast
2. Вызов виртуальной функцииClang 10.0, Optim=OFast
GCC 10.1, Optim=OFast
3. Вызов обычной функцииClang 10.0, Optim=OFast
GCC 10.1, Optim=OFast
[Тут](https://quick-bench.com/q/L4AQ4CjKomGmXi5Gfa9KS9blS6Q) ссылка на код для Quick Benchmarks.
Когда использовать?
-------------------
Если у вас есть иерархия классов и вы хотите помимо вызова диспетчеризации использовать обычные и виртуальные функции. Где базовый класс может быть как и абстрактным, так и не быть им.
Пример:
Source
```
template< class T >
void templateFunc1()
{
/*some code*/
}
template< class T >
void templateFunc2( T& obj )
{
/*some code*/
}
std::vector< AbstractObject* > vector = { /* ... */ };
for( auto* obj : vector )
{
//вызов обычной функции-члена
obj->getName();
//вызов виртуальной функции-члена
obj->action();
//получение типа и передача его в шаблон-функции
obj->dispatch([](auto& obj)
{
//1 case
using T = std::decay_t< decltype(obj) >;
templateFunc1();
//2 case
templateFunc2( obj );
};
}
```
Заключение
----------
* Чтобы добавить или удалить класс, который будет обрабатываться посетителем, достаточно просто изменить список типов.
* Посетитель не привязан к предметной области, т.к. является шаблоном класса.
* Можем в полной мере пользоваться шаблонами функций.
* Остается возможность пользоваться обычной реализацией посетителя, достаточно лишь сделать своего наследника от *AbstractVisitors* и передавать его в функцию *accept*.
Какие недостатки?
* Дополнительная косвенность, т.к. *Dispatcher* содержит функтор.
[Ссылка](https://godbolt.org/z/zx7cvz) на код в compiler explorer.
Full source:
```
#include
#include
#include
template< class ... T >
struct TypeList
{
};
template< class T >
struct AbstractVisitor
{
virtual ~AbstractVisitor() = default;
virtual void visit( T& ) = 0;
};
template< class ...T >
struct AbstractVisitors;
template< class ... T >
struct AbstractVisitors< TypeList< T... > > : virtual AbstractVisitor< T >...
{
};
template< class Dispatcher, class T >
struct Resolver : virtual AbstractVisitor< T >
{
void visit( T& obj ) override
{
static\_cast< Dispatcher\* >( this )->functor( obj );
};
};
template< class Functor, class ... T >
struct Dispatcher;
template< class Functor, class ... T >
struct Dispatcher< Functor, TypeList< T... > > : AbstractVisitors< TypeList< T... > >, Resolver< Dispatcher< Functor, TypeList< T... > >, T >...
{
Dispatcher( Functor functor ) : functor( functor ) {}
Functor functor;
};
template< class TypeList >
struct Dispatchable
{
virtual ~Dispatchable() = default;
virtual void accept( AbstractVisitors< TypeList >& ) = 0;
template< class Functor >
void dispatch( Functor functor )
{
static Dispatcher< decltype(functor), TypeList > dispatcher( functor );
accept( dispatcher );
};
};
#define DISPATCHED( TYPE, TYPE\_LIST ) \
void accept( AbstractVisitors< TYPE\_LIST >& visitor ) override \
{ \
static\_cast< AbstractVisitor< TYPE >& >( visitor ).visit( \*this ); \
}
struct Object1;
struct Object2;
using ObjectList = TypeList< Object1, Object2 >;
struct AbstractObject : Dispatchable< ObjectList >
{
};
struct Object1 : AbstractObject
{
DISPATCHED( Object1, ObjectList )
};
struct Object2 : AbstractObject
{
DISPATCHED( Object2, ObjectList )
};
void test( Object1& obj )
{
std::cout << "1" << std::endl;
}
template< class T >
void test( T& obj )
{
std::cout << "2" << std::endl;
}
int main()
{
Object1 t1,t2,t3,t4;
Object2 e1,e2,e3;
std::vector< AbstractObject\* > vector = { &t1, &e1, &t2, &t3, &e2, &e3, &t4 };
for( auto\* obj : vector )
{
obj->dispatch( []( auto& obj ) { test(obj); } );
}
}
``` | https://habr.com/ru/post/532412/ | null | ru | null |
# Растянуть Canvas и элементы внутри него по всей клиентской области
Во время работы над нашим десктопным приложением столкнулся с такой задачей: имеется элемент-график с некоторыми настройками для отображения (реализован в виде ControlTemplate подключаемого через привязку в ContentControl), к имеющимся настройкам нужно было добавить группу дополнительных. Чтобы не засорять уже имеющийся интерфейс, я решил поместить список этих настроек в элемент Expander, который, при необходимости, можно было бы развернуть, а в остальное время график занимал бы максимально возможное полезное пространство.
Один из способов размещения элементов — под катом.
В итоге была получена следующая иерархия элементов:
```
<Элемент для настройки 1 />
<Элемент для настройки 2 />
<Элемент для настройки n />
Grid.Row="1" />
```
Использую Grid, поскольку этот контейнер занимает пространство внутри вкладки полностью и сам способен растягивать элементы в строках по ширине.
Разместил Expander в верхней части вкладки, контрол для работы со спектром — сразу под ним. Однако, результат не оправдал ожиданий: при разворачивании Expander'a контрол графика сдвигается вниз, тем самым приходится закрывать Expander и проверять результат, либо скроллить оставшуюся для графика половинку экрана.
Возникла мысль взять тот же Expander и заставить его открываться как бы над настраиваемым контролом. Для этого идеально подходит контейнер Canvas, ведь именно в нем можно задавать ZIndex (глубину слоя) для каждого содержащегося в нем элемента. Я перепробовал несколько вариантов компоновки, ниже — один из них:
```
<Элемент для настройки 1 />
<Элемент для настройки 2 />
<Элемент для настройки n />
Canvas.Top="25" />
```
Но тут меня опять ждало разочарование, Canvas либо вообще не отображался (поскольку по умолчанию его ширина и высота = 0), либо элементы внутри него то были слишком малы в размерах, то наооборот — выходили за границу видимости экрана.
Добиться нужно было следующего: растянуть Canvas по всей клиентской области вкладки; разместить в верхней правой части Canvas'а Expander фиксированной ширины, а под ним на всю оставшуюся область растянуть ContentControl.
Проведя некоторое время в поиске информации, её фильтрации и обобщении, пришел к следующему решению: внутри вкладки размещаем DockPanel. Этот контейнер также может автоматически задавать размеры элементам, находящимся внутри него. Устанавливаем для DockPanel свойство LastChildFill=«True», чтобы он растягивал последний из элементов на всю оставшуюся область. Задаем DockPanel имя, например, x:Name=«spectrumDock» и помещаем в него Canvas, который «прикрепляем» к верхней части панели (хотя размещение имеет особого значения). Внутри Canvas размещаем Expander и ContentControl следующим образом:
```
<Элемент для настройки 1 />
<Элемент для настройки 2 />
<Элемент для настройки n />
```
… тень для Expander'а создает ощущение, что этот элемент находится сверху, над остальными. Для задания размеров ContentControl'у используется просто биндинг свойств ширины и высоты (именно Actual) DockPanel. Однако, было одно «НО» — ContentControl сдвинут на 25 пикселей вниз и имеет высоту, равную высоте DockPanel, следовательно, он выезжает за видимую границу на эти самые 25 пикселей, т.е. нужно забиндить к ContentControl высоту DockPanel минус 25 пикселей. Эта задача решается довольно просто — использованием конвертера, которому в качестве параметра передается требуемое количество пикселей для отступа:
```
namespace пространство_имен
{
[ValueConversion(typeof(double), typeof(double))]
public class SizeTrimmerConverter : IValueConverter
{
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
return (double)value - ConvertParameter(parameter);
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
return (double)value + ConvertParameter(parameter);
}
private double ConvertParameter(object parameter)
{
string _stringValue = parameter.ToString();
double _result = 0;
double.TryParse(_stringValue, out _result);
return _result;
}
}
}
```
В описании главного контрола (UserControl или форма) указываем ссылку на пространство имен:
```
xmlns:Converters="clr-namespace:пространство_имен;assembly=название_сборки"
```
… и описываем конвертер в ресурсах:
```
<Главный контрол.Resources>
```
… конвертеры лежат в отдельной библиотеке, поэтому указывается название\_сборки.
В результате всё получилось так, как и было в ожиданиях. Прошу не судить строго, возможно, данный метод и является «костыльным», но моего опыта в использовании технологий WPF + XAML ещё достаточно не много. Надеюсь, мой опыт окажется кому-то полезен. | https://habr.com/ru/post/306008/ | null | ru | null |
# Телевидение через Acestream на Raspberry PI. Теперь в docker контейнерах
На хабре уже неоднократно упоминался AceStream: технология, предоставляющая пользователю доступ к видеопотокам по закрытому P2P протоколу AceStream, т.н. torrent телевидение. AceStream предоставляет доступ к распределенной сети доставки контента, т.е. просматривая телеканал пользователь передает данные другим пользователям, что позволяет кардинально снизить стоимость услуг.
А теперь хорошая новость для обладателей медиаплеера на основе raspberry (OSMC, LibreELEC): нашлась [**сборка acestream под arm**](https://dl.bintray.com/pipplware/dists/unstable/armv7/misc/acestream_rpi_3.1.5.tar.gz), что позволило установить его прямо на raspberry pi. В этой статье предлагается инструкция по установке acestream, и всего необходимого для просмотра ТВ в докер-контейнерах под raspberry. На момент написания статьи, предлагаемое решение позволяет смотреть бесплатно большое количество телеканалов, впрочем без гарантий: acestream в любой момент может перестать быть бесплатным.
1. Установка docker на raspbian/osmc
====================================
Для docker существует родной инсталляционный скрипт: <https://get.docker.com/>. Он конечно создан для хипстерского метода curl-pipe-bash и я вам его советовать не буду :) К тому же на момент написания он был немного сломан и на RPi не работал. Поэтому надо выполнить несколько команд из-под root:
```
apt-key adv --keyserver hkp://ha.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D
apt-key adv -k 58118E89F3A912897C070ADBF76221572C52609D
mkdir -p /etc/apt/sources.list.d
echo deb \[arch=armhf\] http://apt.dockerproject.org/repo raspbian-jessie main > /etc/apt/sources.list.d/docker.list
sleep 3; apt-get update; apt-get install -y -q docker-engine
```
Таким образом мы добавили в систему новый репозитарий, ключи для него, и установили пакет docker-engine. Теперь, для запуска докер демона можно воспользоваться командой `systemctl start docker`
2. Установка acestream
======================
Для установки acestream достаточно положить [service file](https://github.com/aaaler/acestreamproxyvlc-pi/blob/master/acestream.service) в директорию /etc/systemd/system и запустить средствами systemd, например так:
```
curl -sSL https://raw.githubusercontent.com/aaaler/acestreamproxyvlc-pi/master/acestream.service > /etc/systemd/system/acestream.service
systemctl daemon-reload
systemctl enable acestream
systemctl start acestream
```
Если при запуске нужный докер-образ не будет найден — докер его скачает сам. поэтому первый запуск сервиса потребует значительного времени. Если хочется видеть прогресс загрузки — можно заранее скачать образ командой `docker pull aaaler/acestream-pi`.
Теперь AceStream запущен и отвечает на порту `62062`. Этого достаточно, например, для работы дополнений к Kodi типа torrent-tv, lostfilm и других приложений, использующих acestream напрямую. Однако можно пойти дальше, и настроить в Live TV в Kodi. Для этого потребуется поднять еще пару контейнеров.
3. Установка [aceproxy](https://github.com/ValdikSS/aceproxy)
=============================================================
Для работы Live TV необходимо передать Kodi список каналов в виде плейлиста, и для этого [ValdikSS](https://habrahabr.ru/users/valdikss/) написал специальный прокси. Он слушает запросы по HTTP и передает их в AceStream, а приходящий из AceStream видеопоток — раздает средствами VLC. Т.к. авторcкий репозиторий давно не обновлялся, для построения образа был выбран этот [форк](https://github.com/AndreyPavlenko/aceproxy).
Сначала нужно разложить конфиги:
```
mkdir /etc/aceproxy/
curl -sSl https://raw.githubusercontent.com/aaaler/acestreamproxyvlc-pi/master/etc/torrenttv.py > /etc/aceproxy/torrenttv.py
curl -sSl https://raw.githubusercontent.com/aaaler/acestreamproxyvlc-pi/master/etc/p2pproxy.py > /etc/aceproxy/p2pproxy.py
```
Если у вас есть vip аккаунт на torrent-tv — пропишите ссылку на плейлист AceStream (из личного кабинета) в файле /etc/aceproxy/torrenttv.py. Использовать torrent-tv необязательно, есть и другие источники не требующие регистрации.
Кроме того, есть возможность сконфигурировать плагин [p2pproxy](https://github.com/ValdikSS/aceproxy/wiki/P2PProxy-%D0%BF%D0%BB%D0%B0%D0%B3%D0%B8%D0%BD) для просмотра каналов через DNLA.
Теперь скачаем service файл и запустим контейнеры средствами systemd:
```
curl -sSL https://raw.githubusercontent.com/aaaler/acestreamproxyvlc-pi/master/aceproxy.service > /etc/systemd/system/aceproxy.service
curl -sSL https://raw.githubusercontent.com/aaaler/acestreamproxyvlc-pi/master/vlc-nox.service > /etc/systemd/system/vlc-nox.service
systemctl daemon-reload
systemctl enable aceproxy
systemctl start aceproxy
```
При запуске aceproxy все необходимые компоненты будут запущены автоматически. Теперь нам доступны для скачивания обычные m3u плейлисты соответствующих плагинов:
| playlist url | service |
| --- | --- |
| `http://127.0.0.1:8000/torrenttv/playlist.m3u` | [torrent-tv.ru](http://torrent-tv.ru) |
| `http://127.0.0.1:8000/torrent-telik` | [torrent-telik.ru](http://torrent-telik.com) |
| `http://127.0.0.1:8000/allfon` | [allfon.org](http://allfon.org) |
Более подробно про использование aceproxy можно почитать [у ValdikSS в Wiki](https://github.com/ValdikSS/aceproxy/wiki)
4. Настройка плеера KODI
========================
Все вышеописанное используется мной для просмотра TV в плеере KODI. В нем есть функция показа Live TV, она включается в `SYSTEM` → `Settings` → `TV` → `General`.
После этого Kodi сообщит, что требуется включить PVR addon, и покажет их список. (Если этого не произошло, список PVR аddons можно найти в `SYSTEM` → `Add-ons` → `My add-ons`). Выберите `PVR IPTV Simple Client`, включите его (enable), и укажите в настройках playlist url выбраного плагина.
В разделе `EPG Settings` можно указать ссылку на программу передач — epg. Я использовал `http://api.torrent-tv.ru/ttv.xmltv.xml.gz`
Кроме того, переключение каналов в acestream может занимать значительное время, так что рекомендую увеличить таймаут на переключение каналов в экспетном режиме настроек `SYSTEM` → `Settings` → `TV`
После подтверждения опций, рекомендуется перезапустить kodi. При следующем запуске, должны подгрузиться каналы и появится раздел TV в главном меню.
UPD 30.12.2016: Если есть желание участвовать в тестировании обновлений — они публикуются в контейнерах с тэгом `:newest`. Например образ `aaaler/acestream-pi:newest` сейчас соответствует версии 3.1.14. После некоторого тестирования, будут обновлены и контейнеры с тегом `:latest`. | https://habr.com/ru/post/316208/ | null | ru | null |
# 10 строк кода, которые уменьшат боль от вашего проекта на Vue
… или знакомство с плагинами Vue JS на примере интегрированной шины событий
---------------------------------------------------------------------------
### Пара слов о…
Всем привет! Сразу оговорюсь. Я очень люблю VueJS, активно пишу на нем уже больше 2-х лет и не считаю, что разработка на нем может причинить боль хоть в какой-то значимой степени :)
С другой стороны, мы всегда пытаемся найти универсальные решения, которые помогут тратить меньше времени на механическую работу и больше – на то, что действительно интересно. Иногда решение оказывается особенно удачным. Одним из таких я хочу поделиться с вами. 10 строк, о которых пойдет речь (спойлер: в конце их окажется немного больше), родились в процессе работы над проектом Cloud Blue – Connect, который представляет собой достаточно крупное приложение на 400+ компонентов. Найденное нами решение уже интегрировано в самые разные точки системы и вот уже более полугода ни разу не требовало правок, поэтому его смело можно считать успешно проверенным на устойчивость.
И последнее. Перед тем, как непосредственно перейти к решению, я хотел бы немного подробнее остановиться на описании трех типов взаимодействия компонентов Vue между собой: принципах однонаправленного потока, паттерн стора и шины событий. Если для вас это объяснение лишнее (или скучное), переходите сразу к разделу с решением – там все максимально кратко и технично.
### Немного о том как компоненты Vue общаются между собой
Пожалуй, первый вопрос, который возникает у человека, написавшего свой первый компонент, касается того, как он получит данные для работы и как, в свою очередь, передаст данные, полученные им, «наружу». Принцип взаимодействия, принятый во фреймворке Vue JS, называется…
#### Однонаправленный поток данных
Если коротко, этот принцип звучит как «свойства — вниз, события — вверх». То есть для получения данных снаружи («сверху») мы регистрируем внутри компонента специальное свойство, в которое фреймворк при необходимости записывает наши данные, полученные «снаружи». Для того же, чтобы передать данные «наверх», внутри компонента в нужном месте мы вызываем специальный метод фреймворка $emit, который передает наши данные в обработчик родительского компонента. При этом во Vue JS мы не можем просто «транслировать» событие вверх на неограниченную глубину (как например в Angular 1.x). Оно «всплывает» только на один уровень, до непосредственного родителя. То же касается и событий. Чтобы передать их на следующей уровень, для каждого из них также нужно зарегистрировать специальный интерфейс – свойства и события, которые передадут наше «сообщение» дальше.
Это можно описать как офисное здание, в котором работники могут переходить со своего этажа только на соседние – один наверх и один вниз. Так, чтобы передать «документ на подпись» с пятого этажа на второй, потребуется цепочка из трех работников, которые доставят его с пятого этажа на второй, и потом еще трое, которые доставят его обратно на пятый.
«Но это же неудобно!» Конечно, это не всегда удобно с точки зрения разработки, зато, глядя на код каждого компонента, нам видно, что и кому он передает. Нам не нужно держать в голове всю структуру приложения, чтобы понять, находится наш компонент «на пути» события или нет. Мы можем увидеть это из компонента родителя.
Хотя преимущества этого подхода понятны, у него есть и очевидные недостатки, а именно высокая связанность компонентов. Проще говоря для того, чтобы нам поместить какой-то компонент в структуру, нужно обложить его необходимыми интерфейсами, чтобы управлять его состоянием. Для того, чтобы уменьшить эту связанность, чаще всего используют «инструменты управления состояниями». Пожалуй, самый популярный инструмент для Vue это…
#### Vuex (сторы)
Продолжая нашу аналогию с офисным зданием, Vuex стор – это внутренняя почтовая служба. Представим, что на каждом этаже офиса есть окно выдачи и приема посылок. На пятом этаже передают документ №11 на подпись, а на втором периодически спрашивают: «Есть ли документы на подпись?», подписывают имеющиеся и отдают их обратно. На пятом так же спрашивают: «А есть ли подписанные?». При этом работники могут переехать на другие этажи или в другие помещения – принцип работы не поменяется, пока почта работает.
Примерно по такому принципу и работает паттерн, который называется Store. С помощью интерфейса Vuex регистрируется и настраивается некоторое глобальное хранилище данных, а компоненты подписываются на него. Причем не важно, с какого уровня какой структуры произошло обращение, store всегда выдаст нужную информацию.
Казалось бы, на этом все проблемы уже решены. Но в какой-то момент в нашем метафорическом здании один сотрудник хочет позвать другого на обед… или сообщить о какой-то ошибке. И здесь начинается странное. Само по себе сообщение не требует передачи как таковой. Но для того, чтобы воспользоваться почтой надо что-то передать. Тогда наши сотрудники придумывают шифр. Один зеленый шарик – идем на обед, два красных кубика – произошла ошибка приложения E-981273, три желтые монетки – проверь почту и так далее.
Нетрудно догадаться, что с помощью этой неуклюжей метафоры я описываю ситуации, когда нам нужно обеспечить реакцию нашего компонента на событие, произошедшее в другом компоненте, которое само по себе никак не связано с потоком данных. Завершено сохранение нового элемента – требуется переспросить коллекцию. Произошла ошибка 403 Unauthorized – требуется запустить выход пользователя из системы и так далее. Обычная (и далеко не лучшая) практика в таком случае – создание флагов внутри стора или косвенная интерпретация хранимых данных и их изменений. Это быстро приводит к загрязнению как самого стора, так и логики компонентов вокруг него.
На этом этапе мы начинаем задумываться о том, как передавать события напрямую, минуя всю цепочку компонентов. И, немного погуглив или покопавшись в документации, натыкаемся на паттерн…
#### Шина событий
С технической точки зрения шина событий – это объект, который позволяет с помощью одного специального метода запускать «событие» и подписываться на него с помощью другого. Иначе говоря, при подписании на событие «eventA» этот объект сохраняет внутри своей структуры переданную функцию-обработчик, которую он вызовет, когда где-то в приложении будет вызван метод запуска с ключом «eventA». Для подписания или запуска достаточно получить к нему доступ через импорт или по ссылке, и готово.
Метафорически в нашем «здании» шина – это общие чаты в мессенджере. Компоненты подписываются на «общий чат», в который другие компоненты отправляют сообщения. Как только в «чате» появится «сообщение», на которое подписался компонент, запустится обработчик.
Существует множество разных способов создать шину событий. Ее можно написать самостоятельно или можно воспользоваться готовыми решениями – тем же RxJS, который предоставляет огромный функционал для работы с целыми потоками событий. Но чаще всего при работе с VueJS используют, как ни странно, сам VueJS. Экземпляр Vue, созданный через конструктор (new Vue()), предоставляет прекрасный и лаконичный интерфейс событий, описанный в официальной документации.
Здесь мы вплотную подходим к следующему вопросу…
### Чего же мы хотим?
А хотим мы встроить в наше приложение шину событий. Но у нас есть два дополнительных требования:
1. Она должна быть легко доступна в каждом компоненте. Отдельный импорт в каждый из десятков компонентов нам кажется избыточным.
2. Она должна быть модульной. Мы не хотим держать в голове все имена событий, чтобы избежать ситуации, когда событие «item-created» запускает обработчики со всего приложения. Поэтому мы хотим, чтобы можно было легко отделить небольшой фрагмент дерева компонентов в отдельный модуль и транслировать его события внутри него, а не снаружи.
Для того, чтобы реализовать такой впечатляющий функционал, мы используем мощный интерфейс плагинов, который нам предоставляет VueJS. Ознакомиться с ним подробнее можно [здесь](https://ru.vuejs.org/v2/api/#Vue-use), на странице с официальной документацией.
Давайте для начала зарегистрируем наш плагин. Для этого прямо перед точкой инициализации нашего Vue приложения (перед вызовом Vue.$mount()) поместим следующий блок:
```
Vue.use({
install(vue) { },
});
```
Фактически плагины Vue это способ расширения функционала фреймворка на уровне всего приложения. Интерфейс плагинов реализует несколько способов встроиться в компонент, но сегодня мы познакомимся с интерфейсом mixin. Этот метод принимает объект, который расширяет дескриптор каждого компонента перед началом жизненного цикла в приложении. *(Код компонентов, который мы пишем, является скорее не самим компонентом, а описанием его поведения и инкапсуляцией определенной части логики, которая в процессе жизненного цикла используется фреймворком на разных его этапах. Инициализация плагина находится за пределами жизненного цикла компонента, предваряя его, поэтому мы говорим «дескриптор», а не компонент, чтобы подчеркнуть, что внутрь mixin секции плагина будет передан именно тот код, который написан в нашем файле, а не какая-то сущность, которая является продуктом работы фреймворка)*.
```
Vue.use({
install(vue) {
vue.mixin({}); // <--
},
});
```
Именно этот пустой объект будет содержать расширения для наших компонентов. Но для начала еще одна остановка. В нашем случае мы хотим создать интерфейс для доступа к шине на уровне каждого компонента. Давайте добавим к нашему дескриптору поле ‘$broadcast’ (англ. — «эфир»), оно будет хранить ссылку на нашу шину. Для этого воспользуемся Vue.prototype:
```
Vue.use({
install(vue) {
vue.prototype.$broadcast = null; // <--
vue.mixin({});
},
});
```
Теперь нам нужно создать саму шину, но сначала давайте вспомним про требование модульности и примем, что в дескрипторе компонента мы будем объявлять новый модуль полем «$module» с каким-то текстовым значением (оно нам понадобится немного позже). Если поле $module будет задано в самом компоненте, создадим для него новую шину, если же нет — передадим ссылку на родительскую через поле $parent. При этом обратим внимание, что поля дескриптора будут нам доступны через поле $options.
Поместим создание нашей шины на как можно более ранний этап – в хук beforeCreate.
```
Vue.use({
install(vue) {
vue.prototype.$broadcast = null;
vue.mixin({
beforeCreate() { // <--
if (this.$options.$module) { // <--
} else if (this.$parent && this.$parent.$broadcast) { // <--
}
},
});
},
});
```
И наконец давайте заполним логические ветви. В случае, если дескриптор содержит объявление нового модуля, создадим новый экземпляр шины, если нет, возьмем ссылку из $parent.
```
Vue.use({
install(vue) {
vue.prototype.$broadcast = null;
vue.mixin({
beforeCreate() {
if (this.$options.$module) {
this.$broadcast = new Vue(); // <--
} else if (this.$parent && this.$parent.$broadcast) {
this.$broadcast = this.$parent.$broadcast; // <--
}
},
});
},
});
```
Отбрасываем объявление плагина, считаем… 1, 2, 3, 4 … 10 строчек, как я и обещал!
### А можем еще лучше?
Конечно, можем. Этот код легко расширяется. Например, в нашем случае мы решили помимо $broadcast добавить интерфейс $rootBroadcast, который дает доступ к единой для всего приложения шине. События, которые пользователь запускает на шине $broadcast, дублируются на шине $rootBroadcast таким образом, чтобы можно было подписаться либо на все события конкретного модуля (в этом случае первым аргументом в обработчик будет передано имя события), либо на все события приложения вообще (тогда имя модуля будет передано в обработчик первым аргументом, имя события — вторым, а данные, переданные с событием, будут передаваться следующими аргументами). Такая конструкция позволит нам наладить взаимодействие между модулями, а также вешать единый обработчик на события разных модулей.
```
// This one emits event
this.$broadcast.$emit(‘my-event’, ‘PARAM_A’);
// This is standard subscription inside module
this.$broadcast.$on(‘my-event’, (paramA) => {…});
// This subscription will work for the same event
this.$rootBroadcast.$on(‘my-event’, (module, paramA) => {…});
// This subscription will also work for the same event
this.$rootBroadcast.$on(‘*’, (event, module, paramA) => {…});
```
Давайте посмотрим, как нам этого добиться:
Во-первых, создадим единую шину, к которой будет организован доступ через $rootBroadcast, и само поле со ссылкой:
```
const $rootBus = new Vue(); // <--
Vue.use({
install(vue) {
vue.prototype.$broadcast = null;
vue.mixin({
beforeCreate() {
vue.prototype.$rootBroadcast = $rootBus; // <--
if (this.$options.$module) {
this.$broadcast = new Vue();
} else if (this.$parent && this.$parent.$broadcast) {
this.$broadcast = this.$parent.$broadcast;
}
},
});
},
});
```
Теперь нам необходима принадлежность к модулю в каждом компоненте, поэтому давайте расширим определение модульности вот так:
```
const $rootBus = new Vue();
Vue.use({
install(vue) {
vue.prototype.$broadcast = null;
vue.mixin({
beforeCreate() {
vue.prototype.$rootBroadcast = $rootBus;
if (this.$options.$module) {
this.$module = this.$options.$module; // <--
this.$broadcast = new Vue();
} else if (this.$parent && this.$parent.$broadcast) {
this.$module = this.$parent.$module; // <--
this.$broadcast = this.$parent.$broadcast;
}
},
});
},
});
```
Далее нам нужно сделать так, чтобы событие на модульной локальной шине отражалось нужным нам образом на корневой. Для этого нам сначала придется создать простой прокси интерфейс и разместить саму шину в условно приватном свойстве $bus:
```
const $rootBus = new Vue();
Vue.use({
install(vue) {
vue.prototype.$broadcast = null;
vue.mixin({
beforeCreate() {
vue.prototype.$rootBroadcast = $rootBus;
if (this.$options.$module) {
this.$module = this.$options.$module;
this.$broadcast = { $bus: new Vue() }; // <--
} else if (this.$parent && this.$parent.$broadcast) {
this.$module = this.$parent.$module;
this.$broadcast = { $bus: this.$parent.$broadcast.$bus }; // <--
}
},
});
},
});
```
И наконец добавим к объекту проксирующие методы — ведь теперь поле $broadcast не предоставляет прямого доступа к шине:
```
const $rootBus = new Vue();
Vue.use({
install(vue) {
vue.prototype.$broadcast = null;
vue.mixin({
beforeCreate() {
vue.prototype.$rootBroadcast = $rootBus;
if (this.$options.$module) {
this.$module = this.$options.$module;
this.$broadcast = { $bus: new Vue() };
} else if (this.$parent && this.$parent.$broadcast) {
this.$module = this.$parent.$module;
this.$broadcast = { $bus: this.$parent.$broadcast.$bus };
}
// >>>
this.$broadcast.$emit = (…attrs) => {
this.$broadcast.$bus.$emit(…attrs);
const [event, …attributes] = attrs;
this.$rootBroadcast.$emit(event, this.$module, …attributes));
this.$rootBroadcast.$emit(‘*’, event, this.$module, …attributes)
};
this.$broadcast.$on = (…attrs) => {
this.$broadcast.$bus.$on(…attrs);
};
// <<<
},
});
},
});
```
Ну и в качестве последнего штриха давайте вспомним, что мы получаем доступ к шине по замыканию, а это значит что обработчики добавленные однажды не очистятся с компонентом, но будут жить в течении всего времени работы с приложением. Это может вызвать неприятные сайд-эффекты, поэтому давайте добавим к нашей шине функцию очистки слушателей с окончанием жизненного цикла компонента:
```
const $rootBus = new Vue();
Vue.use({
install(vue) {
vue.prototype.$broadcast = null;
vue.mixin({
beforeDestroy() { // <--
this.$broadcast.$off(this.$broadcastEvents); // <--
},
beforeCreate() {
vue.prototype.$rootBroadcast = $rootBus;
this.$broadcastEvents = []; // <--
if (this.$options.$module) {
this.$module = this.$options.$module;
this.$broadcast = { $bus: new Vue() };
} else if (this.$parent && this.$parent.$broadcast) {
this.$module = this.$parent.$module;
this.$broadcast = { $bus: this.$parent.$broadcast.$bus };
}
this.$broadcast.$emit = (…attrs) => {
this.$broadcastEvents.push(attrs[0]); // <--
this.$broadcast.$bus.$emit(…attrs);
const [event, …attributes] = attrs;
this.$rootBroadcast.$emit(event, this.$module, …attributes));
this.$rootBroadcast.$emit(‘*’, event, this.$module, …attributes)
};
this.$broadcast.$on = (…attrs) => {
this.$broadcast.$bus.$on(…attrs);
};
this.$broadcast.$off =: (...attrs) => { // <--
this.$broadcast.$bus.$off(...attrs); // <--
};
},
});
},
});
```
Таким образом, этот вариант предоставляет более интересный функционал, хотя и менее лаконичный. С его помощью можно реализовать полноценную систему альтернативной коммуникации между компонентами. При этом он полностью находится под нашим контролем и не привносит внешних зависимостей в наш проект.
Надеюсь, после прочтения вы приобрели или освежили для себя знания по плагинам Vue, и, возможно, когда в следующий раз вам потребуется добавить в ваше приложение какой-то генеричный функционал, вы сможете реализовать его эффективнее – без добавления внешних зависимостей. | https://habr.com/ru/post/488422/ | null | ru | null |
# Интернационализация (i18n) простой текстовой разметки
Введение
========
[Go to English version](https://habr.com/ru/post/599437/)
Несколько лет назад коллега опубликовал [статью](https://habr.com/ru/post/456032/) о создании презентации при помощи [Asciidoctor](https://asciidoctor.org/). С тех пор мы пользуемся только этим подходом.
Недавно возникла проблема перевести презентации на несколько языков и обеспечить синхронизацию переводов по мере доработки оригинала. Решение оказалось настолько простым и отработанным, что я решил описать его в этой статье.
Предлагаемое решение ничего не знает о синтаксисе. Это означает, что не так важно, используется Asciidoc, другой формат простой текстовой разметки или даже смешанный формат (например, включающий мои любимые Plantuml или любые другие диаграммы). Серьезные ограничения данного подхода — (1) переводчик не должен ломать используемую разметку и (2) невозможно напрямую использовать машинный перевод.
Решение использует [Translation Toolkit](http://docs.translatehouse.org/projects/translate-toolkit/en/latest/) и стандартные [инструменты GNU Gettext](https://www.gnu.org/software/gettext/).
Для демонстрации подхода у данной статьи есть английская и русская версия. [В её репозитории](https://github.com/fiddlededee/asciidoc-i18n) настроена простая автоматизация, которая синхронизирует перевод, создает печатную версию статьи (pdf, docx, odt), а также создает файл в формате Markdown для публикации на Хабре.
В [предыдущей статье о тестировании документации](https://habr.com/ru/post/571326/) я только упомянул стандартные текстовые линтеры, т.к. старался сфокусироваться в целом на подходах к тестированию, а не конкретных инструментах. Тем не менее существующие линтеры могут очень и очень многое. Поэтому эта статья проверялась при помощи [vale](https://github.com/errata-ai/vale).
Основная идея
=============
Gettext предполагает, что ключевые строки для перевода являются оригинальными сообщениями.
Gettext использует файлы расширением `.po` (PO — [Portable Object](https://www.gnu.org/software/gettext/manual/html_node/PO-Files.html#PO-Files)) для хранения как оригинальных, так и переведенных сообщений. Большое количество редакторов позволяет редактировать такие файлы как в однопользовательской, так и в многопользовательской среде.
Основная идея Translation Toolkit заключается в использовании блоков смежных строк в качестве констант для перевода.
Рассмотрим пример:
```
.Зима -- это
```
```
* снег
* мороз
```
```
* Рожество
* Новый год
```
В примере показано три блока смежных строк, поэтому Translation Toolkit извлечёт три константы для перевода и поместит их в файл с расширением `.pot` (шаблон `.po`)
Вставляя или убирая переносы строк в данном примере вы можете получить любое количество констант в диапазоне от 1 до 5. Количество констант зависит от удобства для переводчика.
Используя файл `.pot` в качестве шаблона, Gettext создает (обновляет) файлы `.po` для всех требуемых языков. Переводчики работают именно с этими файлами. Далее Translation Toolkit берет (1) файл `.po` с переводом, (2) оригинальный файл и создает переведенный файл.
Описание процесса
=================
Процесс перевода состоит из следующих шагов.
* Исходные шаги для получения первого перевода на один или несколько языков.
* Обновление перевода после модификации исходного текста.
На следующих диаграммах предполагается, что исходный файл — `i18n-adoc.adoc`, а перевод должен быть помещен в файл `i18n-adoc-ru.adoc`.
Исходные шаги
-------------
Существует много редакторов для перевода файлов `.po`. На следующем снимке экрана показан интерфейс [Gtranslator](https://wiki.gnome.org/Apps/Gtranslator). Я предпочитаю [Poedit](https://poedit.net/), хотя то, как он заменяет гравис на апостроф при использовании машинного перевода, раздражает.
Обновление перевода
-------------------
Несколько замечаний
===================
1. В нашей документации мы часто повторно используем константы интернационализации, чтобы имена элементов интерфейса в документации совпадали с именами этих же элементов в приложении. Мы генерируем эти константы автоматически в следующем формате:
```
:main-menu-documents: Документы
:main-menu-documents-my: Мои
...
```
Мы включаем этот файл в документ Asciidoc (`include i17n-{lang}.adoc[]`). Теперь нет необходимости использовать атрибуты. Просто переведите `include i17n-en.adoc[]` в `include i17n-ru.adoc[]`.
2. Когда `gettext` обновляет файлы `.po`, он использует нечеткий поиск. Если вы немного измените исходный текст, перевод не пропадет. Он будет просто помечен как возможно неверный (flaky).
3. Актуальность файла с переводом проверить очень легко при помощи утилиты Gettext — `msgfmt`.
```
msgfmt --statistics i18n-adoc-ru.po
```
Команда показывает количество переведенных строк, количество строк, которые нуждаются в проверке, и количество непереведенных строк.
Заключение
==========
* Translation Toolkit и Gettext обеспечивают эффективную интернационализацию документации.
* Простая текстовая разметка — не такая уж и простая. Использование всех возможностей простой текстовой разметки выставляет определенный уровень требований к специалисту по документации. Попробуйте представить переводчику файлы в формате `.po`. Многие ли из них будут готовы сделать перевод? Или попросят предоставить текст в более традиционном формате, например, в Microsoft Word.
* Контроль качества: 58 переведенных сообщений, 0 ошибок, 0 предупреждений и 0 предложений в 1 файле. | https://habr.com/ru/post/599775/ | null | ru | null |
# Распознаем номера автомобилей. Разработка multihead-модели в Catalyst
Фиксация различных нарушений, контроль доступа, розыск и отслеживание автомобилей – лишь часть задач, для которых требуется по фотографии определить номер автомобиля (государственный регистрационный знак или ГРЗ).
В этой статье мы рассмотрим создание модели для распознавания с помощью [Catalyst](https://github.com/catalyst-team/catalyst/) – одного из самых популярных высокоуровневых фреймворков для Pytorch. Он позволяет избавиться от большого количества повторяющегося из проекта в проект кода – цикла обучения, расчёта метрик, создания чек-поинтов моделей и другого – и сосредоточиться непосредственно на эксперименте.
Сделать модель для распознавания можно с помощью разных подходов, например, путем поиска и определения отдельных символов, или в виде задачи image-to-text. Мы рассмотрим модель с несколькими выходами (multihead-модель). В качестве датасета возьмём [датасет](https://nomeroff.net.ua/datasets/autoriaNumberplateOcrRu-2020-10-12.zip) с российскими номерами от проекта [Nomeroff Net](https://github.com/ria-com/nomeroff-net). Примеры изображений из датасета представлены на рис. 1.
*Рис. 1. Примеры изображений из датасета*
Общий подход к решению задачи
-----------------------------
Необходимо разработать модель, которая на входе будет принимать изображение ГРЗ, а на выходе отдавать строку распознанных символов. Модель будет состоять из экстрактора фичей и нескольких классификационных “голов”. В датасете представлены ГРЗ из 8 и 9 символов, поэтому голов будет девять. Каждая голова будет предсказывать один символ из алфавита “1234567890ABEKMHOPCTYX”, плюс специальный символ “-” (дефис) для обозначения отсутствия девятого символа в восьмизначных ГРЗ. Архитектура схематично представлена на рис. 2.
*Рис. 2. Архитектура модели*
В качестве loss-функции возьмём стандартную кросс-энтропию. Будем применять её к каждой голове в отдельности, а затем просуммируем полученные значения для получения общего лосса модели. Оптимизатор – Adam. Используем также OneCycleLRWithWarmup как планировщик leraning rate. Размер батча – 128. Длительность обучения установим в 10 эпох.
В качестве предобработки входных изображений будем выполнять нормализацию и преобразование к единому размеру.
Кодирование
-----------
Далее рассмотрим основные моменты кода. Класс датасета (листинг 1) в общем обычный для CV-задач на Pytorch. Обратить внимание стоит лишь на то, как мы возвращаем список кодов символов в качестве таргета. В параметре *label\_encoder* передаётся служебный класс, который умеет преобразовывать символы алфавита в их коды и обратно.
```
class NpOcrDataset(Dataset):
def __init__(self, data_path, transform, label_encoder):
super().__init__()
self.data_path = data_path
self.image_fnames = glob.glob(os.path.join(data_path, "img", "*.png"))
self.transform = transform
self.label_encoder = label_encoder
def __len__(self):
return len(self.image_fnames)
def __getitem__(self, idx):
img_fname = self.image_fnames[idx]
img = cv2.imread(img_fname)
if self.transform:
transformed = self.transform(image=img)
img = transformed["image"]
img = img.transpose(2, 0, 1)
label_fname = os.path.join(self.data_path, "ann",
os.path.basename(img_fname).replace(".png", ".json"))
with open(label_fname, "rt") as label_file:
label_struct = json.load(label_file)
label = label_struct["description"]
label = self.label_encoder.encode(label)
return img, [c for c in label]
```
*Листинг 1. Класс датасета*
В классе модели (листинг 2) мы используем библиотеку [PyTorch Image Models](https://github.com/rwightman/pytorch-image-models) для создания экстрактора фичей. Каждую из классификационных голов модели мы добавляем в *ModuleList*, чтобы их параметры были доступны оптимизатору. Логиты с выхода каждой из голов возвращаются списком.
```
class MultiheadClassifier(nn.Module):
def __init__(self, backbone_name, backbone_pretrained, input_size, num_heads, num_classes):
super().__init__()
self.backbone = timm.create_model(backbone_name, backbone_pretrained, num_classes=0)
backbone_out_features_num = self.backbone(torch.randn(1, 3, input_size[1], input_size[0])).size(1)
self.heads = nn.ModuleList([
nn.Linear(backbone_out_features_num, num_classes) for _ in range(num_heads)
])
def forward(self, x):
features = self.backbone(x)
logits = [head(features) for head in self.heads]
return logits
```
*Листинг 2. Класс модели*
Центральным звеном, связывающим все компоненты и обеспечивающим обучение модели, является *Runner*. Он представляет абстракцию над циклом обучения-валидации модели и отдельными его компонентами. В случае обучения multihead-модели нас будет интересовать реализация метода *handle\_batch* и набор колбэков.
Метод *handle\_batch*, как следует из названия, отвечает за обработку батча данных. Мы в нём будем только вызывать модель с данными батча, а обработку полученных результатов – расчёт лосса, метрик и т.д. – мы реализуем с помощью колбэков. Код метода представлен в листинге 3.
```
class MultiheadClassificationRunner(dl.Runner):
def __init__(self, num_heads, *args, **kwargs):
super().__init__(*args, **kwargs)
self.num_heads = num_heads
def handle_batch(self, batch):
x, targets = batch
logits = self.model(x)
batch_dict = { "features": x }
for i in range(self.num_heads):
batch_dict[f"targets{i}"] = targets[i]
for i in range(self.num_heads):
batch_dict[f"logits{i}"] = logits[i]
self.batch = batch_dict
```
*Листинг 3. Реализация runner’а*
Колбэки мы будем использовать следующие:
* *CriterionCallback* – для расчёта лосса. Нам потребуется по отдельному экземпляру для каждой из голов модели.
* *MetricAggregationCallback* – для агрегации лоссов отдельных голов в единый лосс модели.
* *OptimizerCallback* – чтобы запускать оптимизатор и обновлять веса модели.
* *SchedulerCallback* – для запуска LR Scheduler’а.
* *AccuracyCallback* – чтобы иметь представление о точности классификации каждой из голов в ходе обучения модели.
* *CheckpointCallback* – чтобы сохранять лучшие веса модели.
Код, формирующий список колбэков, представлен в листинге 4.
```
def get_runner_callbacks(num_heads, num_classes_per_head, class_names, logdir):
cbs = [
*[
dl.CriterionCallback(
metric_key=f"loss{i}",
input_key=f"logits{i}",
target_key=f"targets{i}"
)
for i in range(num_heads)
],
dl.MetricAggregationCallback(
metric_key="loss",
metrics=[f"loss{i}" for i in range(num_heads)],
mode="mean"
),
dl.OptimizerCallback(metric_key="loss"),
dl.SchedulerCallback(),
*[
dl.AccuracyCallback(
input_key=f"logits{i}",
target_key=f"targets{i}",
num_classes=num_classes_per_head,
suffix=f"{i}"
)
for i in range(num_heads)
],
dl.CheckpointCallback(
logdir=os.path.join(logdir, "checkpoints"),
loader_key="valid",
metric_key="loss",
minimize=True,
save_n_best=1
)
]
return cbs
```
*Листинг 4. Код получения колбэков*
Остальные части кода являются тривиальными для Pytorch и Catalyst, поэтому мы не станем приводить их здесь. Полный код к статье доступен [на GitHub](https://github.com/articles-simbirsoft/lp_ocr_multihead).
Результаты эксперимента
-----------------------
*Рис. 3. График лосс-функции модели в процессе обучения. Оранжевая линия – train loss, синяя – valid loss*
В списке ниже перечислены некоторые ошибки, которые модель допустила на тест-сете:
* Incorrect prediction: T970XT23- instead of T970XO123
* Incorrect prediction: X399KT161 instead of X359KT163
* Incorrect prediction: E166EP133 instead of E166EP123
* Incorrect prediction: X225YY96- instead of X222BY96-
* Incorrect prediction: X125KX11- instead of X125KX14-
* Incorrect prediction: X365PC17- instead of X365PC178
Здесь присутствуют все возможные типы: некорректно распознанные буквы и цифры основной части ГРЗ, некорректно распознанные цифры кода региона, лишняя цифра в коде региона, а также неверно предсказанное отсутствие последней цифры.
Заключение
----------
В статье мы рассмотрели способ реализации multihead-модели для распознавания ГРЗ автомобилей с помощью фреймворка Catalyst. Основными компонентами явились собственно модель, а также раннер и набор колбэков для него. Модель успешно обучилась и показала высокую точность на тестовой выборке.
**Спасибо за внимание! Надеемся, что наш опыт был вам полезен.**
Больше наших статей по машинному обучению и обработке изображений:
* [Data Science: предсказание бизнес-событий для улучшения сервиса](https://habr.com/ru/company/simbirsoft/blog/529580/)
* [Как мы используем алгоритмы компьютерного зрения: обработка видео в мобильном браузере с помощью OpenCV.js](https://habr.com/ru/company/simbirsoft/blog/501882/)
* [Тестируем комплементарную кросс-энтропию в задачах классификации текста](https://habr.com/ru/company/simbirsoft/blog/529580/) | https://habr.com/ru/post/561866/ | null | ru | null |
# ОС с нуля: Глава 1, Часть 2 — 32 лучше 16-ти
### Дисклеймер?
Хай Хабр! Это серия статей по написанию моей ОС с нуля. Я лютый фанат ретропрограммирования, поэтому я мгновенно забуду про существование EDК. Просьба не писать комменты по типу "BIOS давно устарела где UEFI?". Пишу это просто чтобы было, что почитать вечером и порелаксить. Спасибо.
### Давайте договоримся
Если вы не владеете языком ассемблера, то можете испытать сложности в понимании происходящего. Пользуюсь я ассемблером [FASM](https://flatassembler.net).
В [прошлой части](https://habr.com/ru/post/670030/) мы написали собственный загрузчик из двух стадий: ограниченой рамками [MBR](https://ru.wikipedia.org/wiki/%D0%93%D0%BB%D0%B0%D0%B2%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BE%D1%87%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C) и без ограничений(ну, почти), которая даже имеет красивый колхозный [BSOD](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BD%D0%B8%D0%B9_%D1%8D%D0%BA%D1%80%D0%B0%D0%BD_%D1%81%D0%BC%D0%B5%D1%80%D1%82%D0%B8). В этой части будем переходить в защищенный режим.
BSOD(да, здесь я попробовал запустить это чудо в Oracle VMs VirtualBox)Проблемы х86-16
---------------
Ну, думаю здесь можно долгий список писать. Выделю, как по мне, самые основные:
1. ограничение адресации ОЗУ в 1Мб;
2. 0 защиты и изоляции памяти;
3. Отсутствие некоторых возможностей. Думаю, и здесь можно понять, что IA-32 лучше чем х86-16 как архитектура.
Выйди за меня, OSDev.org!
-------------------------
Да, да-а... Этот самый сайт для медитации в момент brainkudatoushel'. Я изучил страницы осдева, посвященные защищенному режиму вдоль и поперек, и уже начинал заталкивать в голову монитор. Через пару часов, не без помощи Макса(он попросил убрать ссылку), я все понял и начал писать.
Что такое GDT и с чем его едят
------------------------------
Итак, реальный режим плохой, есть более удобный вариант - защищенный. В нем память адресуется линейно, все 4ГБ адресов, помещающихся в регистр x86 процессора. Но за годы работы в реальном режиме уже выяснили, что адресовать физическую память напрямую очень неудобно (как минимум, возникает вопрос загрузки в неё нескольких процессов так, чтобы они не конфликтовали), небезопасно (процессы могут нарушать память друг друга), да и вообще памяти может быть меньше 4ГБ и было бы удобно назначать разным участкам виртуальной памяти разные права (Read, Write, Execute или ничего). Поэтому придумали страничную адресацию и виртуальную память.
Каждый процесс имеет свои виртуальные 4ГБ, а процессор соотносит виртуальный адрес с реальным, проверяя, заодно, права на запрошенную операцию. Для этого виртуальная память делится на страницы. Страница - как сегмент, но она может начинаться в произвольном месте физической памяти, иметь произвольный размер, настройки доступа и предназначение. Описание страницы, по-английски - "дескриптор" содержит все эти свойства. А список всех страниц, соответственно, будет называться таблицей дескрипторов. Почему таблицей? Потому, что для доступа к разным страницам можно будет просто указать номер дескриптора нужной страницы в сегментном регистре (теперь это "селектор").
Было бы удобно иметь глобальную таблицу дескрипторов, одну на всю систему, для доступа к разделяемым библиотекам и для целей ядра системы, и локальные - по одной на каждый поток/процесс. Называются они, соответственно, Global Descriptor Table и Local Descriptor Table.
Ну вот. Итак, нам нужен "описыватель" для кода и данных. Всю таблицу можно найти под спойлером с отрывком 1.
Дресс-код
---------
kernel.asm (отрывок 1)
```
GDT:
; нулевой дескриптор. просто надо.
dw 0
.size dw @f-GDT-1 ; размер
.linear dd GDT ; адрес
.code = $ - GDT ; дескриптор кода
dw -1,0
db 0,9ah,0cfh,0
.data = $ - GDT ; дескриптор данных
dw -1,0
db 0,92h,0cfh,0
.pointer: ; указатель
dw GDT.size
dd GDT
@@:
```
В принципе, этот код можно взять за шаблон и использовать везде, он практически универсален.
kernel.asm (другой отрывок)
```
cli ; чтобы никто не отвлекал
lgdt fword[GDT.pointer] ; Загрузить GDT
mov eax, cr0 ; получить контент регистра СR0
or al, 1 ; установить бит РЕ
mov cr0,eax ; применить изменения
jmp GDT.code:pmode ; прыжок, просто надо
pmode:
use32 ; генерировать 32-битный машинный код
; здесь настроим сегментные регистры
mov ax, GDT.data
; data segment
mov ds, ax
; stack segment
mov ss, ax
mov ax, 0xA000
; graphic segment ??
mov gs, ax
mov sp, 0xFFFF ; Почему бы не расположить стек в нижней памяти?
...
```
Здесь мы входим в защищенный режим, подгружая в GDTR указатель на GDT и настраивая сегментные регистры.
Ну вот и все! В конец можно поставить код для зависания ЦП или свой код (демку какую-нибудь, например).
Вот, например, что сделал я:
Просто слеш. скуууушноСпасибо за внимание!
П.Ы.: Принимаю любые предложения по развитию проекта или статей в лс Хабра.
Ссылки:
1. [HexOS-GitHub](https://github.com/vanosoft/HexOS).
2. [Предыдущая часть](https://habr.com/ru/post/670030/).
3. Здесь будет ссылка на следующую часть. | https://habr.com/ru/post/670162/ | null | ru | null |
# Создание Zero Player Game, используя libgdx
#### Идея
1. Игровое пространство — клетчатое поле ограниченное рамкой
2. Существующие типы клеток:
* Пустая клетка — белый
* Стена — чёрный
* Зверь — красный
* След — коричневый
* Дом — зелёный
3. Перемещение зверя оставляет неисчезающий след
4. При запуске генерируется лабиринт
5. Зверь знает состояние соседних клеток и на основании этого строит карту при перемещении
6. При перемещении зверь расходует силы, которые восстанавливаются в доме(+5) или на любой клетке(+1)
7. При столкновении звери объединяются в стаи(дома переносятся в соседние точки), если несколько зверей одновременно отдыхают в доме их карты объединяются
8. (Не реализовано)Разные «кланы» случайным образом объединяются или воюют
9. (Не реализовано)Генетический алгоритм для различных поведений зверей, случайно перемешивающиеся при размножении(+мутации), более перспективный вид выживет в войнах
##### Почему libgdx?
Разработку я вёл с разных устройств, домашний комп на ubuntu и планшет на win8, связка java + eclipse позволила делать это без проблем. Libgdx использован для удобства работы с камерой, возможности добавления графики в дальнейшем, а также для создания версии под андроид.
#### В этой статье
Заготовка игры, в которой реализовано:
* Игровое поле
* Генерация лабиринта
* Создание зверя кликом по карте
* Перемещение существа, обходя препятствия, по полю с целью построить полную карту местности.
Результат:
#### Начало
После создания и импорта проекта в eclipse добавим необходимые поля(в зависимости от версии libgdx некоторые уже могут быть добавлены)
```
SpriteBatch batch;//Класс для рисования спрайтов на игровом поле
OrthographicCamera camera;//Перемещение по игровому полю
Texture texture;//Текстура клетки(на видео это png изображение - белый квадрат с чёрной рамкой)
```
В методе create() инициализируем их:
```
batch = new SpriteBatch();
batch.disableBlending();
camera = new OrthographicCamera(FIELD_SIZE, FIELD_SIZE);
```
Добавим необходимые константы:
```
public static final int FIELD_SIZE = 51;//Размер поля(поле квадратное)
public static float UPDATE_TIME = 0.001f;//интервал между "шагами" существ
```
Далее пригодится абстрактный класс Cell, который будет описывать общий функционал клеток.
```
public abstract class Cell {
public Color color;
Sprite sprite;
public Cell(Texture texture, Color color){
this.color = color;
sprite = new Sprite(texture);
sprite.setColor(color);
sprite.setSize(1, 1);
}
public abstract void update(Cell[][] map, int x, int y, Texture texture);
public void setColor(Color color){
this.color = color;
sprite.setColor(color);
}
public void draw(SpriteBatch batch,int x, int y){
sprite.setPosition(x-Main.FIELD_SIZE/2-sprite.getWidth()/2, y-Main.FIELD_SIZE/2-sprite.getHeight()/2);
sprite.draw(batch);
}
}
```
Сразу рассмотрим двух его наследников Wall и Empty.
```
public class Wall extends Cell {
public Wall(Texture texture) {
super(texture, new Color(0f, 0f, 0f, 1));
}
@Override
public void update(Cell[][] map, int x, int y, Texture texture) {
}
}
public class Empty extends Cell {
public Empty(Texture texture) {
super(texture, new Color(1, 1, 1, 1));
}
@Override
public void update(Cell[][] map, int x, int y, Texture texture) {
}
}
```
Теперь необходимо создать лабиринт. Пояснять алгоритм не буду, он неплохо изложен [тут](http://algolist.manual.ru/games/maze.php). Этот алгоритм я выделил в отдельный класс MazeGenerator с единственным методом getMaze(int size), который возвращает двумерный массив нулей и единиц, где 0 — пустая клетка, 1 — стена.
Игровое поле будет храниться в простом двумерном массиве:
```
Cell[][] map;
```
Создание поля выглядит так:
```
map = new Cell[FIELD_SIZE][FIELD_SIZE];
texture = new Texture(Gdx.files.internal("tile.png"));//не забываем подгрузить изображение
char[][] bmap = (new MazeGenerator()).getMaze(FIELD_SIZE - 1);
for (int i = 0; i < FIELD_SIZE; i++)
for (int j = 0; j < FIELD_SIZE; j++) {
if (bmap[i][j] == 0)
map[i][j] = new Empty(texture);
if (bmap[i][j] == 1)
map[i][j] = new Wall(texture);
}
```
Теперь мы имеем случайный лабиринт при каждом запуске программы. Можно поиграться с константами и определить для себя лучшую комбинацию.
Да на этом скрине tile.png это просто белый квадрат.
#### Зверь
Настало время наполнить мир жизнью.
Создадим потомка Cell:
```
public class Unit extends Cell {
Cell[][] my_map = new Cell[3][3];//собственная карта, изначально известны только соседние клетки
float update_time = Main.UPDATE_TIME;//счётчик шага
int mapX = 1, mapY = 1;//координаты зверя на собственной карте
Vector queue = new Vector();//список действий для выполнения
enum Action {
left, right, up, down//список действий
}
public Unit(Texture texture, Cell[][] map, int x, int y) {
super(texture, new Color(1f, 0, 0, 1));
for (int i = x - 1; i <= x + 1; i++)
for (int j = y - 1; j <= y + 1; j++)
my\_map[i - x + 1][j - y + 1] = map[i][Main.FIELD\_SIZE - j - 1];
my\_map[1][1] = this;
homeX = 1;
homeY = 1;
}
private int goRight(Cell[][] map, int x, int y, Texture texture) {...}//map - полная, истинная карта мира, x,y - расположение зверя на ней
private int goLeft(Cell[][] map, int x, int y, Texture texture) {...}
private int goUp(Cell[][] map, int x, int y, Texture texture) {...}
private int goDown(Cell[][] map, int x, int y, Texture texture) {...}
```
Не хочу загружать пост кодом, поэтому весь метод update приводить не буду.
Алгоритм работы прост: проверяем очередь действий, если она не пуста, то уменьшаем счётчик такта, если он пуст, заново увеличиваем его и выполняем действие и обновляем окрестности на карте. Если действий нет, то строим новый маршрут, но об этом немного дальше, а сейчас рассмотрим шаг персонажа.
Для удобства создадим отдельный метод для шага в каждую сторону:
```
private int goRight(Cell[][] map, int x, int y, Texture texture) {...}//map - полная, истинная карта мира
private int goLeft(Cell[][] map, int x, int y, Texture texture) {...}//x,y - расположение зверя на ней
private int goUp(Cell[][] map, int x, int y, Texture texture) {...}
private int goDown(Cell[][] map, int x, int y, Texture texture) {...}
```
«Шаг» будет состоять из нескольких действий.
* Проверка не надо ли расширить собственную карту
* Расширение карты(создание нового увеличенного массива и копирование в него старой карты)
* Перемещение на новую клетку
* Запись изменений в mapX, mapY
##### Определение маршрута
На мой взгляд самое простое решение — волновой алгоритм, который строит маршрут в случайную пустую клетку
Для этого я добавил новый класс WavePath со статичным методом:
```
public static Vector getPath(Cell[][] my\_map, int x, int y, int nx,int ny){...}
```
Этот метод возвращает последовательность шагов для достижения случайно выбранной точки.
#### Финальные штрихи
Теперь осталось только рисовать всё это на экран и, перебирая массив карты, обновлять состояние клеток
```
@Override
public void render() {
this.update();//обновление карты
Gdx.gl.glClearColor(0, 0, 0, 1);
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
batch.setProjectionMatrix(camera.combined);
batch.begin();
for (int i = 0; i < FIELD_SIZE; i++)
for (int j = 0; j < FIELD_SIZE; j++)
if(!(map[i][j] instanceof Wall))//не рисуем чёрные квадраты на чёрном фоне
map[i][j].draw(batch, i, j);
batch.end();
}
public void update() {
Input input = Gdx.input;
for (int i = 0; i < FIELD_SIZE; i++)
for (int j = 0; j < FIELD_SIZE; j++)
map[i][j].update(map, i, j, texture);//обновляем
if(input.isKeyPressed(Input.Keys.W))//сдвиг камеры, масштабирование, вращение, ускорение
camera.zoom-=Gdx.graphics.getDeltaTime();
if(input.isKeyPressed(Input.Keys.S))
camera.zoom+=Gdx.graphics.getDeltaTime();
if(input.isKeyPressed(Input.Keys.Q))
camera.rotate(Gdx.graphics.getDeltaTime()*90);
if(input.isKeyPressed(Input.Keys.E))
camera.rotate(-Gdx.graphics.getDeltaTime()*90);
if(input.isKeyPressed(Input.Keys.CONTROL_LEFT))
UPDATE_TIME+=Gdx.graphics.getDeltaTime();
if(input.isKeyPressed(Input.Keys.SHIFT_LEFT))
UPDATE_TIME-=Gdx.graphics.getDeltaTime();
if(input.isKeyPressed(Input.Keys.LEFT))
camera.translate(new Vector2(-Gdx.graphics.getDeltaTime()*50,0));
if(input.isKeyPressed(Input.Keys.RIGHT))
camera.translate(new Vector2(Gdx.graphics.getDeltaTime()*50,0));
if(input.isKeyPressed(Input.Keys.UP))
camera.translate(new Vector2(0,Gdx.graphics.getDeltaTime()*50));
if(input.isKeyPressed(Input.Keys.DOWN))
camera.translate(new Vector2(0,-Gdx.graphics.getDeltaTime()*50));
if(input.isKeyPressed(Input.Keys.SPACE)){//восстановление камеры
UPDATE_TIME = 1f;
camera = new OrthographicCamera(FIELD_SIZE, FIELD_SIZE);
}
camera.update();
if (input.isTouched()) {//садим зверя на поле
float stepX = Gdx.graphics.getWidth() / FIELD_SIZE;
float stepY = Gdx.graphics.getHeight() / FIELD_SIZE;
float x = input.getX();
float y = input.getY();
for (int i = 0; i < FIELD_SIZE; i++)
for (int j = 0; j < FIELD_SIZE; j++) {
if (x >= stepX * i && x <= stepX * (i + 1)
&& y >= stepY * j && y <= stepY * (j + 1))
if (map[i][FIELD_SIZE - j - 1] instanceof Empty)
map[i][FIELD_SIZE - j - 1] = new Unit(texture, map,
i, j);
}
}
}
```
#### Заключение
Заранее прошу прощения за ошибки, и не полное изложение материала. Исходники на [github](https://github.com/opot/Cellular_Machine).
Если кого-то заинтересовало, напишу продолжение. | https://habr.com/ru/post/224525/ | null | ru | null |
# Обзор особенностей ядра Андроида
*“А я… карбюратор промываю!”
Анекдот*
**Введение**
В детском садике мы с единомышленниками препарировали кузнечиков в надежде разобраться в их строении. В школе распаивали радиоприёмник “Россия”. В институте дошла очередь до автомобилей, гайки которых были многократно переставлены. Интересы поменялись, но желание “разбирать” иногда просыпается, и сегодня оно направлено на Андроид.
Сколько раз вас выручало наличие исходников Андроида? Меня — уже не счесть. Андроид — открытый проект, но, к сожалению, у нас есть возможность только читать; править код Андроида, не будучи сотрудником Google, практически невозможно. Погрустим над этим моментом и загрузим репозиторий. Как это сделать, отлично описано на официальном [сайте](http://source.android.com/source/building.html).
**Общая архитектура**
Архитектуру Андроида можно схематично изобразить так:
[Оригинальная](http://developer.android.com/images/system-architecture.jpg) схема не содержит информации об особенностях ядра и не акцентирует внимание на Binder-е и системных сервисах. А ведь Binder является “клеем”, связывающим все компоненты системы.
Как правило, в книгах описывается верхний левый синий прямоугольник, то есть API, которое доступно разработчику прикладных приложений. Нас же интересует всё, что ниже. Сегодня мы рассмотрим только ядро.
**Ядро**
Ядро — центральная часть любого дистрибутива, называемого “Линукс”. Несмотря на доступность “[чистого](http://kernel.org/)” ядра, многие разработчики (Ubuntu, Fedora, SuSe и т.д.) добавляют к нему свои патчи перед включением в дистрибутив. Андроид идёт той же дорогой, только ценой потери прямой совместимости: на “чистом” ядре он не заведётся. В настоящее время есть намерения включить “андроидизмы” в основную версию ядра, в 2011 году Линус Торвальдс [давал](http://www.zdnet.com/blog/open-source/linus-torvalds-on-android-the-linux-fork/9426) на этот процесс 4-5 лет. Успех уже достигнут в рамках [включения](http://kernelnewbies.org/Linux_3.5#head-e04ea6fe9005ea057124123d7834624cd445e124) механизма wakelocks в версии ядра 3.5.
Рассмотрим “андроидизмы” более подробно.
**Wakelocks**
История данного механизма эпична, потянет на сборник статей “Путь wakelock-ов в Линукс”: их обсуждение заняло порядка 2000 писем в рассылке [LKML](http://lkml.org/).
Настольные компьютеры и ноутбуки имеют устоявшуюся систему энергорежимов (у x86 процессоров таковых несколько): компьютер работает “на полных оборотах”, когда что-то делается, и уходит в энергоэффективный режим, когда система простаивает. Уход в “спящий” режим происходит либо после довольно длительного бездействия, либо вручную, например, при закрытии крышки ноутбука.
На телефонах требовался другой механизм: основное состояние системы — “спячка”, выход из него осуществляется только в случаях необходимости. Таким образом, система может уснуть, даже если какое-то приложение проявляет активность. В Андроиде был реализован механизм wakelock-ов: если приложение (или драйвер) выполняет что-то важное, что должно дойти до логического завершения, оно “захватывает” wakelock, предотвращая засыпание устройства.
Попытки портирования механизма wakelock-ов в ядро вызвали сопротивление многих разработчиков. Программисты Андроида решали конкретную проблему, решением которой стал определённый механизм. Условия задачи были весьма узки. Целевая платформа — ARM, поэтому использовались её особенности: ARM-процессоры изначально предполагают частую смену режимов работы “сна” и “бодрствования”, в отличие от x86. В Андроиде приложения общаются с системой управления питанием через [PowerManager](https://developer.android.com/reference/android/os/PowerManager.html), а что делать клиентским Линукс-приложениям?
Разработчики Андроида даже не пытались найти общее решение “на будущее”, которое потом без проблем бы вливалось в основное ядро, не консультировались по этой проблеме с сообществом ядра Линукс. Можно ли их за это винить? Несмотря на все проблемы и обсуждения, как упоминалось выше, в ядре появилось API с идентичной функциональностью [autosleep](https://lwn.net/Articles/479841/).
Программистам приложений под Андроид довольно редко приходится сталкиваться с wakelock-ами, так как платформа и драйверы обрабатывают возложенные на них обязательства с учётом “спящего” режима. Тем не менее, вмешаться в этот процесс поможет знакомый [PowerManager](http://developer.android.com/reference/android/os/PowerManager.html). Кстати, автору приходит в голову только один сценарий: не дать телефону уснуть при запуске сервиса из BroadcastReceiver-а, что решается вспомогательным классом из Android Support Library [WakefulBroadcastReceiver](https://developer.android.com/reference/android/support/v4/content/WakefulBroadcastReceiver.html).
**Low Memory Killer**
В стандартном ядре Линукса есть [Out of Memory Killer](https://www.kernel.org/doc/gorman/html/understand/understand016.html), который на основании параметра badness определяет убиваемый процесс:
`badness_for_task = total_vm_for_task / (sqrt(cpu_time_in_seconds) *
sqrt(sqrt(cpu_time_in_minutes)))`
Таким образом, чем больше процесс потребляет памяти и чем меньше живёт, тем меньше ему повезёт.
Все программисты, [читавшие](http://developer.android.com/guide/components/processes-and-threads.html) документацию или проходившие собеседования, знают, что, во-первых, процесс может быть “убит” и при наличии свободных ресурсов, во-вторых, кандидат на вытеснение выбирается по другим критериям: наличие “живых” Андроид-компонент, видимость пользователю и так далее.
Механизм довольно простой: каждому процессу присваивается приоритет от -17 до 16, при этом чем выше приоритет, тем выше вероятность убивания процесса, и, в зависимости от количества свободной памяти, выбирается приоритет, начиная с которого процессы будут завершены. Приоритеты описаны в [ProcessList.java](https://android.googlesource.com/platform/frameworks/base/+/master/services/java/com/android/server/am/ProcessList.java). Занимательно, что приоритет приложения домашнего экрана HOME\_APP\_ADJ довольно высок, а я-то думал: почему он постоянно перезапускается?
Массивы mOomAdj и mOomMinFreeLow/mOomMinFreeHigh как раз задают правила “когда что очистить”:
```
private final int[] mOomAdj = new int[] {FOREGROUND_APP_ADJ, VISIBLE_APP_ADJ, PERCEPTIBLE_APP_ADJ, BACKUP_APP_ADJ, CACHED_APP_MIN_ADJ, CACHED_APP_MAX_ADJ};
private final long[] mOomMinFreeHigh = new long[] {49152, 61440, 73728,86016, 98304, 122880};
```
Таким образом, приложение домашнего экрана вытесняется при остатке свободной памяти в 73728 КБ на телефоне с экраном 1280x800 и ОЗУ в 700 МБ.
ProcessList передаёт соответствующие значения в [ядро](https://git.kernel.org/cgit/linux/kernel/git/next/linux-next.git/tree/drivers/staging/android/lowmemorykiller.c?id=HEAD), что можно видеть в его методе updateOomLevels.
Приоритеты процессам выставляет [Activity Manager Service](https://github.com/android/platform_frameworks_base/blob/master/services/java/com/android/server/am/ActivityManagerService.java), один из многих системных сервисов, общаться с которым можно через [Activity Manager](https://developer.android.com/reference/android/app/ActivityManager.html).
**Binder**
[Binder](http://www.cs.fsu.edu/~baker/devices/lxr/http/source/linux/drivers/staging/android/binder.c), наряду с другими решениями (Files, Sigmals, Sockets, Pipes, Semaphores, Shared Memory и т.д.), решает задачу межпроцессного взаимодействия. Ноги у данного решения растут из проекта [OpenBinder](http://www.angryredplanet.com/~hackbod/openbinder/docs/html/), разработчики которого в своё время перешли в команду Андроида.
[Bionic](http://en.wikipedia.org/wiki/Bionic_(software)) (реализация libc) не использует [System V IPC](https://android.googlesource.com/platform/ndk/+/4e159d95ebf23b5f72bb707b0cb1518ef96b3d03/docs/system/libc/SYSV-IPC.TXT), так как в андроидовском окружении стандартные средства приведут к утечкам ресурсов.
Особенности:
1. Управление потоками (мы все [помним](http://developer.android.com/guide/components/aidl.html), что сервис, поддерживающий AIDL, должен работать в многопоточном окружении). Максимальное число потоков — 15 ([ProcessState.c](https://github.com/cozybit/aosp-frameworks-base/blob/master/libs/binder/ProcessState.cpp), метод open\_driver), поэтому не стоит блокировать Binder-потоки в большом количестве без лишней необходимости.
2. Механизм информирования о смерти процесса, держащего объект Binder “[Link to Death](https://developer.android.com/reference/android/os/IBinder.html#linkToDeath(android.os.IBinder.DeathRecipient,%20int))”. Например, через него [Window Manager](http://developer.android.com/reference/android/view/WindowManager.html) узнаёт о смерти приложения и удаляет связанные с ним окна. Также [LocationManager](https://developer.android.com/reference/android/location/LocationManager.html) при смерти всех своих слушателей перестаёт опрашивать GPS-приёмник. Lowmemorykiller доволен. :)
3. 2 режима вызова: блокирующий и неблокирующий (oneway). В первом случае вызывающий поток блокируется и ждёт отработки метода в потоке процесса-обработчика. Программисты просто вызывают методы через точку, взаимодействие потоков берёт на себя платформа.
4. Передача UID и PID для безопасности. Через них системные сервисы [определяют](https://developer.android.com/reference/android/content/Context.html#checkPermission(java.lang.String,%20int,%20int)), есть ли у вызывающего процесса права совершать запрашиваемые действия.
5. Для Java-программистов — средства создания Proxy и Stub-ов для конвертирования вызовов Java-методов в транзакции Binder-а.
Рассмотрим как это работает на примере LocationManager-а.
Когда мы хотим получить информацию о GPS, происходит следующее:
1. Наше приложение вызывает соответствующий метод у LocationManager-а.
2. LocationManager делегирует вызов прокси-объекту, преобразующему Java-методы и объекты в Binder-транзакцию (прокси-объектом у [LocationManager-а](https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/location/java/android/location/LocationManager.java) является mService).
3. Транзакция посылается драйверу ядра, который перенаправляет её LocationManagerService-у, отнаследованному от .LocationManager.Stub.
4. .LocationManager.Stub делает обратные действия: разворачивает транзакцию в вызов Java-метода.
5. .LocationManagerService обрабатывает запрос (используя, например, GPS-драйвер).
6. Stub-объект пакует ответ в транзакцию, и процесс идёт в обратном направлении.
7. Драйвер пересылает ответ обратно.
8. Прокси-объект распаковывает результат вызова метода в Java-объекты.
Как видим, за вызовом методов системных сервисов скрывается довольно большая логика.
**Ashmem**
Anonymous Shared Memory (ashmem) — механизм разделяемой памяти. В Линуксе, как правило, данный механизм реализован через [POSIX SHM](http://www.kohala.com/start/unpv22e/unpv22e.chap12.pdf). Разработчики Андроида сочли его недостаточно защищённым, что могло сыграть на руку вредоносному ПО. Особенностями ashmem-а являются счётчик ссылок, при обнулении которого разделяемая память может быть освобождена (например, память освобождается при завершении всех процессов, использующих её), и сокращение разделяемого региона при нехватке памяти в системе.
Ярким примером использования ashmem-а является процесс zygote, в котором загружается стартовая версия Dalvik VM с загруженными базовыми классами и ресурсами, а остальные приложения просто ссылаются на эту память.
Binder имеет ограничение на размер транзакции в 1МБ (иначе будет выброшено исключение [TransactionTooLargeException](https://developer.android.com/reference/android/os/TransactionTooLargeException.html)). Если нам надо передать из одного процесса в другой большой объём данных, можно как раз воспользоваться Ashmem-ом: создать [MemoryFile](https://developer.android.com/reference/android/os/MemoryFile.html) и передать дескриптор файла в другой процесс.
**Logger**
Обычные дистрибутивы, как правило, используют две системы логирования: лог ядра, доступный через команду dmesg, и системные логи, располагающиеся обычно в директории /var/log.
Система Андроида включает несколько циклических буферов для хранения сообщений пользовательских программ (что продлевает время жизни карт памяти, так как циклы чтения-записи не расходуются впустую) и не имеет дополнительных задержек от работы с сокетами, которые применяются в стандартном [syslog-е](http://ru.wikipedia.org/wiki/Syslog).
На диаграмме представлена общая система логирования Андроида. Драйвер логирования предоставляет доступ к каждому буферу через /dev/log/\*. Приложения имеют доступ к ним не напрямую, а через библиотеку liblog. С библиотекой liblog общаются классы [Log](http://developer.android.com/reference/android/util/Log.html), [Slog](https://github.com/android/platform_frameworks_base/blob/master/core/java/android/util/Slog.java) и [EventLog](http://developer.android.com/reference/android/util/EventLog.html). Команда adb logcat показывает содержимое буфера “main”.
**Заключение**
В данной заметке мы кратко рассмотрели некоторые особенности Андроида как Линукс-системы. За скобками остались некоторые другие части (pmem, RAM console и т.д.), а также такие важные аспекты платформы в целом, как System Service, процесс запуска системы и другие. Если данная тема будет интересна, в следующих статьях мы рассмотрим и их. | https://habr.com/ru/post/211663/ | null | ru | null |
# Объединяем Websockets, Lisp и функциональное программирование
Объединяем Websockets, Lisp и функциональное программирование. Но как?
С помощью Clojure.
На Хабре существует достаточно статей — примеры приложений, использующих
вебсокеты ([WebSocket](https://ru.wikipedia.org/wiki/WebSocket), [RFC](https://tools.ietf.org/html/rfc6455)), реализованные с помощью популярных языков и технологий. Сегодня я хотел бы показать пример простого веб-приложения, с использованием менее популярных, но от этого не менее хороших, технологий и маленькой (~90kB JAR with zero dependencies and ~3k lines of (mostly Java) code) клиент/сервер библиотеки http-kit.
Возможный побочный эффект — (не цель) развеяние мифа о сложности написания современных приложений используя Lisp и функциональное программирование.
Эта статья — не ответ другим технологиям, и не их сравнение. Эта проба пера продиктована исключительно моей личной привязанностью к Clojure и давним желанием попробовать написать.
Встречайте дружную компанию:
* В главной роли [Clojure](https://ru.wikipedia.org/wiki/Clojure)
* Жанр: **FP** (Functional programming)
* Клиент/сервер: [http-kit](http://www.http-kit.org/index.html)
* Инструментарий: lein ([leiningen](https://leiningen.org/)) — утилита для сборки(build tool), менеджер зависимостей.
* и другие
Я не хотел бы делать экскурс в Clojure и Lisp, стек и инструментарий, лучше буду делать короткие ремарки, и оставлять комментарии в коде, поэтому приступим:
`lein new ws-clojure-sample`
*Ремарка: leiningen позволяет использовать шаблоны для создания проекта, его структуры и задания стартовых "настроек" или подключения базовых библиотек. Для ленивых: можно создать проект с помощью одного из таких шаблонов так:
`lein new compojure ws-clojure-sample`
где [compojure](https://github.com/weavejester/compojure) — библиотека для маршрутизации(роутинга) работающая с Ring. Мы же сделаем это вручную (наша команда тоже реализует/использует шаблон, называемый, default)*
В результате выполнения будет сгенерирован проект, имеющий следующую структуру:
В дальнейшем, для сборки проекта и управления зависимостями, *leiningen* руководствуется файлом в корне проекта *project.clj*.
На данный момент у нас он принял следующий вид:
###### project.clj
```
(defproject ws-clojure-sample "0.1.0-SNAPSHOT"
:description "FIXME: write description"
:url "http://example.com/FIXME"
:license {:name "Eclipse Public License"
:url "http://www.eclipse.org/legal/epl-v10.html"}
:dependencies [[org.clojure/clojure "1.8.0"]])
```
Давайте сразу добавим необходимые нам зависимости в раздел *dependencies*
*Ремарка: ключевое слово(clojure keyword) :dependencies.*
и укажем точку входа(пространство имен) в наше приложение *:main*
**project.clj**###### project.clj
```
(defproject ws-clojure-sample "0.1.0-SNAPSHOT"
:description "FIXME: write description"
:url "http://example.com/FIXME"
:license {:name "Eclipse Public License"
:url "http://www.eclipse.org/legal/epl-v10.html"}
:dependencies [[org.clojure/clojure "1.8.0"]
[http-kit "2.2.0"] ;; Подключаем http-kit
[compojure "1.6.0"] ;; Подключаем compojure (роутинг/маршрутизация)
[ring/ring-defaults "0.3.1"] ;; Джентльменский набор middleware по умолчанию
[org.clojure/data.json "0.2.6"]] ;; Пригодится для работы с JSON
:profiles ;; Профили для запуска lein with-profile <имя профиля>
{:dev ;; Профиль разработки
{:dependencies [[javax.servlet/servlet-api "2.5"] ;; пригодится если вы будете устанавливать ring/ring-core
[ring/ring-devel "1.6.2"]]}} ;; пригодится для горячей перезагрузки
:main ws-clojure-sample.core) ;; пространство имен в котором находится функция -main(точка входа в приложение)
```
*Ремарка: middleware [ring-defaults](https://github.com/ring-clojure/ring-defaults)*
Перейдем, собственно, к самой точке входа в приложение. Откроем файл *core.clj*
###### core.clj
```
(ns ws-clojure-sample.core)
(defn foo
"I don't do a whole lot."
[x]
(println x "Hello, World!"))
```
и заменим сгенерированную функцию *foo*, на более понятную и общепринятую -main. Далее импортируем в текущее пространство имен необходимые нам компоненты. Собственно нам нужен, в первую очередь, сервер, далее маршруты, и наши middleware. В роли сервера у нас выступает **http-kit** и его функция *run-server*.
**core.clj**###### core.clj
```
(ns ws-clojure-sample.core
(:require [org.httpkit.server :refer [run-server]] ;; http-kit server
[compojure.core :refer [defroutes GET POST DELETE ANY]] ;; defroutes, и методы
[compojure.route :refer [resources files not-found]] ;; маршруты для статики, а также страница not-found
[ring.middleware.defaults :refer :all])) ;; middleware
```
*Ремарка: данный код, является совершенно валидным кодом на Clojure, и одновременно структурами данных самого языка. Это свойство языка называется [**гомоиконностью**](https://ru.wikipedia.org/wiki/%D0%93%D0%BE%D0%BC%D0%BE%D0%B8%D0%BA%D0%BE%D0%BD%D0%B8%D1%87%D0%BD%D0%BE%D1%81%D1%82%D1%8C)
Читать, на мой взгляд, тоже просто, и не требует особых пояснений.*
Серверу, в качестве аргумента, необходимо передать функцию обработчик и параметры сервера
примерно так:
```
(run-server <Обработчик(handler)> {:port 5000})
```
В качестве этого обработчика будет выступать функция(на самом деле макрос) маршрутизатор *defroutes* которому мы дадим имя, и которая в свою очередь будет вызывать, в зависимости от маршрута, уже непосредственный обработчик. И все это мы еще можем обернуть и приправить нашим middleware.
*Ремарка: middleware ведет себя как **декоратор** запросов*.
**core.clj**###### core.clj
```
(ns ws-clojure-sample.core
(:require [org.httpkit.server :refer [run-server]] ;; http-kit server
[compojure.core :refer [defroutes GET POST DELETE ANY]] ;; defroutes, и методы
[compojure.route :refer [resources files not-found]] ;; маршруты для статики, и not-found
[ring.middleware.defaults :refer :all])) ;; middleware
(defroutes app-routes
(GET "/" [] index-page) ;; Нам нужна будет главная страница для демонстрации
(GET "/ws" [] ws-handler) ;; здесь будем "ловить" веб-сокеты. Обработчик.
(resources "/") ;; директория ресурсов
(files "/static/") ;; префикс для статических файлов в папке `public`
(not-found "### Страница не найдена
")) ;; все остальные, возвращает 404)
(defn -main
"Точка входа в приложение"
[]
(run-server (wrap-defaults #'app-routes site-defaults) {:port 5000}))
```
Итак, теперь у нас есть точка входа в приложение, которая запускает сервер, который имеет маршрутизацию. Нам не хватает здесь двух функций обработчиков запросов:
* index-page
* ws-handler
Начнем с *index-page*.
Для этого в директории `ws_clojure_sample` создадим папку `views` и в ней файл `index.clj`. Укажем получившееся пространство имен,
и создадим нашу заглавную страницу *index-page*:
###### views/index.clj
```
(ns ws-clojure-sample.views.index)
(def index-page "Главная")
```
~~На этом можно было бы и закончить~~. По сути тут вы можете строкой задать обычную HTML страницу. Но это некрасиво. Какие могут быть варианты? Неплохо бы было вообще использовать какой-нибудь шаблонизатор. Нет проблем. Например вы можете использовать [Selmer](https://github.com/yogthos/Selmer). Это быстрый шаблонизатор, вдохновленный шаблонизатором Django. В этом случае, представления будут мало отличаться от таковых в *Django* проекте. Поклонникам *Twig*, или *Blade* тоже все будет знакомо.
Я же пойду другим путем, и выберу Clojure. Буду писать HTML на *Clojure*. Что это значит — сейчас увидим.
Для этого нам понадобится небольшая (это относится к большинству *Clojure* библиотек) библиотека ***hiccup***. В файле `project.clj` в `:dependencies` добавим `[hiccup "1.0.5"]`.
*Ремарка: к слову автор, у библиотек **compojure** и **hiccup**, и многих других ключевых библиотек в экосистеме Clojure, один и тот же, его имя James Reeves, за что ему большое спасибо.*
После того как мы добавили зависимость в проект, необходимо импортировать ее содержимое в пространство имен нашего представления `src/ws_clojure_sample/views/index.clj` и написать наш HTML код. Дабы ускорить процесс я сразу приведу содержимое `views/index.clj` целиком
(а вы ~~удивляйтесь что это~~ наблюдайте):
**views/index.clj**###### views/index.clj
```
(ns ws-clojure-sample.views.index
(:use [hiccup.page :only (html5 include-css include-js)])) ;; Импорт нужных функций hiccup в текущее пространство имен
;; Index page
(def index-page
(html5
[:head
(include-css "https://unpkg.com/bootstrap@3.3.7/dist/css/bootstrap.min.css")]
[:body {:style "padding-top: 50px;"}
[:div.container
[:div.form-group [:input#message.form-control {:name "message" :type "text"}]]
[:button.btn.btn-primary {:name "send-btn"} "Send"]]
[:hr]
[:div.container
[:div#chat]]
(include-js "js/ws-client.js")
(include-js "https://unpkg.com/jquery@3.2.1/dist/jquery.min.js")
(include-js "https://unpkg.com/bootstrap@3.3.7/dist/js/bootstrap.min.js")]))
```
Наше представление готово, и думаю не нуждается в комментариях. Создали обычный и кнопку `Send`. С помощью этой нехитрой формы мы будем отправлять сообщеия в ~~чат~~ канал. Осталось не забыть импортировать `index-page` в пространство имен `core`. Для этого возвращаемся в `src/ws_clojure_sample/core.clj` и дописываем в директиву `:require` строку `[ws-clojure-sample.views.index :refer [index-page]]`.
Заодно давайте и основной обработчик `ws-handler` пропишем, который следом нам необходимо создать.
**core.clj**###### core.clj
```
...
[ws-clojure-sample.views.index :refer [index-page]] ;; Добавляем представление index-page
[ws-clojure-sample.handler :refer [ws-handler]])) ;; Предстоит создать ws-handler
(defroutes app-routes
(GET "/" [] index-page)
(GET "/ws" [] ws-handler) ;; Создать handler.clj
```
Большинство методов и абстракций для работы с веб-сокетами/long-polling/stream, предоставляет наш **http-kit** сервер, возможные примеры и вариации легко найти на сайте библиотеки. Дабы не городить огород, я взял один из таких примеров и немного упростил. Создаем файл `src/ws_clojure_sample/handler.clj`, задаем пространство имен и импортируем методы `with-channel, on-receive, on-close`из *htpp-kit*:
**handler.clj**###### handler.clj
```
(ns ws-clojure-sample.handler
(:require [org.httpkit.server :refer [with-channel on-receive on-close]] ;; Импорт из http-kit
[ws-clojure-sample.receiver :refer [receiver clients]])) ;; Предстоит создать
;; Главный обработчик (handler)
(defn ws-handler
"Main WebSocket handler"
[request] ;; Принимает запрос
(with-channel request channel ;; Получает канал
(swap! clients assoc channel true) ;; Сохраняем пул клиентов с которыми установлено соединение в атом clients и ставим флаг true
(println channel "Connection established")
(on-close channel (fn [status] (println "channel closed: " status))) ;; Устанавливает обработчик при закрытии канала
(on-receive channel (get receiver :chat)))) ;; Устаналивает обработчик данных из канала (его создадим далее)
```
* `swap! clients` — меняет состояние атома clients, записывает туда идентификатор канала в качестве ключа и флаг в качестве значения. Зададим далее.
* `with-channel` — получает канал
* `on-close` — Устанавливает обработчик при закрытии канала
* `on-receive` — Устаналивает обработчик данных из канала `(get receiver :chat)` — это нам предстоит.
Давайте определим обработчик для получения данных из канала `on-receive` и наших `clients`. Создадим `src/ws_clojure_sample/receiver.clj`, как обычно укажем наше пространство имен.
###### receiver.clj
```
(ns ws-clojure-sample.receiver)
(def clients (atom {})) ;; наши клиенты
```
Поскольку нужен наглядный пример, и обработчиков может быть несколько, сперва покажу на примере чата, и назову его `chat-receiver`.
```
(defn chat-receiver)
[data] ;; Принимает данные (для чата это сообщение из *input*)
(doseq [client (keys @clients)] ;; каждому клиенту (выполняет для каждого элемента последовательности и дает ему alias client)
(send! client (json/write-str {:key "chat" :data data}))) ;; посылает json-строку с ключом "chat" и данными "data" которые и были получены
```
`send!` и `json/write-str` надо импортировать в текущее пространство имен.
###### receiver.clj
```
(ns ws-clojure-sample.receiver
(:require [clojure.data.json :as json]
[org.httpkit.server :refer [send!]]))
```
А что если мы захотим не чат? Или не только чат, а например принимать данные из внешнего источника и отправлять в сокеты? Я придумал хранитель обработчиков, ну о-о-очень сложный.
```
(def receiver {:chat chat-receiver})
```
Для примера я сделал такой "ресивер" для отправки-получения данных, чтобы можно было поиграть не только с чатом, поэтому добавим в хранитель обработчиков пример `data-receiver`. Пусть будет.
```
(def receiver {:chat chat-receiver
:data data-receiver})
```
Просто приведу его код:
**data-receiver**
```
(def urls ["https://now.httpbin.org" "https://httpbin.org/ip" "https://httpbin.org/stream/2"])
(defn data-receiver
"Data receiver"
[data]
(let [responses (map #(future (slurp %)) urls)] ;; отсылаю запросы (в отдельных потоках) по списку urls
(doall (map (fn [resp] ;; бегу по всем ответам
(doseq [client (keys @clients)] ;; бегу по всем сокет-клиентам
(send! client @resp))) responses)))) ;; и рассылаю эти данные всем сокет-клиентам
```
Теперь мы можем выбирать какой из них запускать при получении данных из канала, и как будет работать приложение, просто меняя ключ:
```
(on-receive channel (get receiver :chat :data)) ;; можем менять местами на :data или добавить как параметр, в случае если :chat не будет найден.
```
С серверной частью всё.
Осталась клиентская. А на клиенте, в коде представления, вдруг вы заметили, как я подключал файл `ws-client.js`который живет в директории `resources/public/js/ws-client.js`
```
(include-js "js/ws-client.js")
```
Именно он и отвечает за клиентскую часть. Поскольку это обычный JavaScript, то я просто приведу код.
*Ремарка: не могу не отметить, что клиентский код, вместо javascript, можно было писать на Clojure. Если говорить точнее, то на ClojureScript. Если пойти еще дальше, то фронтенд можно сделать, например, с помощью [Reagent](https://reagent-project.github.io/).*
**ws-client.js**
```
let msg = document.getElementById('message');
let btn = document.getElementsByName('send-btn')[0];
let chat = document.getElementById('chat');
const sendMessage = () => {
console.log('Sending...');
socket.send(msg.value);
}
const socket = new WebSocket('ws://localhost:5000/ws?foo=clojure');
msg.addEventListener("keyup", (event) => {
event.preventDefault();
if (event.keyCode == 13) {
sendMessage();
}
});
btn.onclick = () => sendMessage();
socket.onopen = (event) => console.log('Connection established...');
socket.onmessage = (event) => {
let response = JSON.parse(event.data);
if (response.key == 'chat') {
var p = document.createElement('p');
p.innerHTML = new Date().toLocaleString() + ": " + response.data;
chat.appendChild(p);
}
}
socket.onclose = (event) => {
if (event.wasClean) {
console.log('Connection closed. Clean exit.')
} else {
console.log(`Code: ${event.code}, Reason: ${event.reason}`);
}
}
socket.onerror = (event) => {
console.log(`Error: ${event.message}`);
socket.close();
}
```
Если запустить этот код из корня проекта с помощью *leiningen* командой `lein run`, то
проект должен скомпилироваться, и пройдя по адресу <http://localhost:5000>, можно увидеть
тот самый и кнопку `Send`. Если открыть две таких вкладки и в каждой послать сообщение, то можно убедиться что простейший чат работает. При закрытии вкладки, срабатывает наш метод `on-close`. Аналогично можно поиграть с данными. Они должны просто выводиться в браузере в консоль.
В итоге получилось простое, минималистичное приложение (62 строчки кода вместе с импортами), дающее представление о том как писать веб-приложения на современном диалекте лиспа, при этом совершенно спокойно можно писать асинхронный код, распараллеливать задачи и использовать легкие, современные, простые решения для веба. ~~И все это делают мои 62 убогие строчки кода!~~
**На прощание интересный факт***На прощание интересный факт: не знаю обратили ли вы внимание, но при подключении в проект clojure библиотек, большинство из них имеют "низкую" версионность, столь непривычную для хороших стабильных проектов, например `[ring/ring-defaults "0.3.1"]` или `[org.clojure/data.json "0.2.6"]`. Причем, обе библиотеки используются практически повсеместно. Но для экосистемы Clojure такое версионирование довольно обыденное явление. Связано это прежде всего с высокой стабильностью кода написанного на Clojure. Хотите верьте, как говорится, хотите нет.*
И еще немного про http-kit:
http-kit это не только сервер, библиотека предоставляет и http-client API. И клиент, и сервер удобны в использовании, минималистичны, при этом обладают хорошими возможностями ([600k concurrent HTTP connections, with Clojure & http-kit](http://www.http-kit.org/600k-concurrent-connection-http-kit.html)).
Весь код приложения ~~гиганта~~ доступен на [Github](https://github.com/lensgolda/ws-clojure-sample).
Если есть вопросы — пишите, в меру своих скромных познаний постараюсь ответить. Принимаю замечания, пожелания.
Спасибо за внимание! | https://habr.com/ru/post/339628/ | null | ru | null |
# Пытаемся управлять освобождением памяти в JavaScript
В JavaScript есть тысячи способов выделить память, но разработчики языка лишили нас права её освобождать. Этим занимается сборщик мусора (Garbage collector, GC), функций управления которым также нет. В большинстве случаев он неплохо справляется со своей работой, однако когда в программе непрерывно освобождаются **большие** объёмы данных, порядка мегабайта в секунду, сборщик мусора может тупить, из-за чего процесс браузера разрастается в памяти до невменяемых размеров. В этой статье я покажу пару грязных трюков, с помощью которых можно ускорить освобождение памяти.
#### ПОДРОБНЕЕ О ПРОБЛЕМЕ
В качестве примера будет выступать расширение для [Chrome](https://chrome.google.com/webstore/detail/twitch-5/knankefoajngclnjgnelanfohgihifpc) и [Firefox](https://addons.mozilla.org/firefox/addon/twitch_5/), которое показывает видео — прямые трансляции — непрерывно загружая из сети, обрабатывая и освобождая массивы двоичных данных размером в несколько мегабайт. Взгляните на потребление памяти (working set) процессом браузера, в котором работает расширение. Зелёный цвет — Chrome 57, красный — Firefox 52. Сам график был любезно предоставлен виндовой оснасткой `perfmon2.msc`.
[](https://habrastorage.org/files/929/b77/1bb/929b771bb7ee44baa22ae7639398b7fd.png)
[](https://habrastorage.org/files/d3c/4bf/c99/d3c4bfc997c54ff3b8041843a1524b9f.png)
Если в Firefox сборщик мусора достаточно неплохо справляется, то в Chrome он явно отлынивает от работы и напрашивается на увольнение. Забавно, что год назад картина была противоположной! Браузеры, и алгоритмы работы сборщика мусора в частности, постоянно изменяются, причем не всегда в лучшую сторону. И что, нам переписывать код после выхода новой версии браузера?
Мне могут возразить, что в наше время половина гигабайта — это семечки, даже в смартфонах памяти больше. Во-первых, я предпочитаю, чтобы свободная память (если она есть) использовалась для хранения не заведомо ненужного мусора, а полезных вещей, таких как кэш операционной системы. Во-вторых, большинство браузеров по прежнему 32-битные, а значит их адресное пространство заметно меньше 4-х гигабайт. Несколько запущенных копий расширения довольно быстро его исчерпают и приведут либо к «падению» процесса, либо к проблемам воспроизведения видео.
#### ПОИСК РЕШЕНИЯ
Данные хранятся в `[ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)`. Этот объект был специально создан для хранения и работы с большими объёмами двоичных данных. Однако у него нет функции, которая освобождает память, отведённую под буфер, или хотя бы меняющую размер буфера. В 2014 году компания Mozilla предложила добавить метод `[ArrayBuffer.transfer()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/transfer)`, который в том числе позволял освободить память, оставляя объект в detached-состоянии. Несмотря на несложную реализацию функции, разработчики других браузеров отказались от её добавления. Счастье было так близко…
`ArrayBuffer.transfer()` был предложен в первую очередь для работы в паре с [asm.js](http://asmjs.org/). Я проверил как обстоят дела с управлением памятью в текущей версии потомка asm.js, [WebAssembly](http://webassembly.org/). Да никак, управлением памятью только в планах.
Как я сказал выше, после освобождения отведённой под объект памяти, этот объект переводится в detached-состояние. Как это выглядит на практике? Сишники наверное сразу подумали, что он заменяется на null. Нет, в качестве замены выступает «объект-пустышка», у которого свойство `byteLength` равно 0, а попытка доступа к содержимому буфера кидает (в Firefox) исключение `TypeError: attempting to access detached ArrayBuffer`. Такие пустышки занимают мало памяти, поэтому сборщик мусора хорошо справляется с их утилизацией.
У всех современных браузеров есть функция `postMessage()`, которая способна переводить `ArrayBuffer` в detached-состояние. Правда, она не освобождает буфер, а передаёт его в другой контекст (например, iframe или рабочий поток), поэтому для освобождения памяти нужны дополнительные действия. Далее я покажу два трюка, которые по-разному вызывают `postMessage()`.
#### ТРЮК С MESSAGECHANNEL
`[MessageChannel](https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel)` предназначен для передачи данных между контекстами. У него есть два порта: в один данные [посылаем](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage), из другого принимаем. Интересной особенностью является возможность [закрыть](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/close) принимающий порт. Что в этом случае произойдёт с посылаемыми данными? Есть два варианта:
* Раз ни посылающей, ни принимающей стороне данные не нужны, они будут переданы сборщику мусора. В [стандарте](https://html.spec.whatwg.org/multipage/comms.html#dom-messageport-postmessage) вроде бы описывается такое поведение. Мне, прикладному программисту, сложно понять стандарт, написанный для разработчиков браузера, поэтому «вроде бы».
* Они застрянут в канале.
Первый вариант нам определённо подходит. Правда, слово «передать» может означать не «освободить немедленно», а лишь «пометить как никому не нужные». В последнем случае освобождение произойдёт во время очередного цикла работы сборщика мусора, который неизвестно когда начнётся.
На практике имеем разброд и шатание. В Chrome 55- и Firefox 50- освобождение памяти ускоряется. В Firefox 51+ память сразу освобождается. В Chrome 56 этот трюк применять нельзя, потому что данные [застревают](https://bugs.chromium.org/p/chromium/issues/detail?id=688862) в канале.
Вот исходный код трюка:
```
// HACK Firefox 49: Нельзя выбрасывать буфер, который используется в asm.js
// в качестве кучи, чтобы не вызвать исключение out of memory.
const м_Помойка = (() =>
{
let _оПомойка = null;
function Выбросить(оБарахло)
{
if (typeof оБарахло !== 'object' || оБарахло === null)
{
return;
}
// Это типизированный массив, например Uint8Array?
if (оБарахло.buffer)
{
оБарахло = оБарахло.buffer;
}
// Это не-detached ArrayBuffer?
if (оБарахло.byteLength)
{
console.log(`[Помойка] Выбрасываю ${оБарахло.byteLength} байтов`);
if (!_оПомойка)
{
_оПомойка = new MessageChannel();
_оПомойка.port2.close();
}
// Посылка transferable буфера в disentangled порт.
_оПомойка.port1.postMessage(оБарахло, [оБарахло]);
}
}
return {Выбросить};
})();
```
И его использование:
```
// Создаём буфер.
// Можно использовать тот, что возвращает XMLHttpRequest, fetch и т.д.
let буфДанные = new ArrayBuffer(1e6);
// Здесь идет работа с данными в буфере...
// Буфер больше не нужен.
// Удаляем все ссылки на буфер и выбрасываем его в помойку.
м_Помойка.Выбросить(буфДанные);
буфДанные = null;
```
Смотрим, как влияет трюк на работу расширения. Сравните с красным графиком в начале статьи.
[](https://habrastorage.org/files/918/d8f/1e0/918d8f1e07664279b9ea8c1cff34fa6c.png)
Максимальное потребление памяти упало на 100 МБ. Неплохая прибавка к пенсии. Плюс имеем гарантию того, что потребление памяти не будет бесконтрольно рости, например, из-за увеличения битрейта видео или частоты скачивания файлов.
Мне этот трюк не нравится из-за вышеописанных проблем с совместимостью. Тем не менее некоторое время он использовался в расширении.
#### ТРЮК С РАБОЧИМ ПОТОКОМ
Рабочий поток (`[Worker](https://developer.mozilla.org/en-US/docs/Web/API/Worker)`) — это код JavaScript, выполняемый параллельно с кодом JavaScript страницы (главным потоком). Буферы в рабочий поток перемещает метод `[Worker.postMessage()](https://developer.mozilla.org/en-US/docs/Web/API/Worker/postMessage)`. Однако одного перемещения недостаточно. Буферы будут валяться в рабочем потоке и ждать, когда у сборщика мусора дойдут до них руки. Скорее всего станет только хуже, потому что по моим наблюдениям сборщик мусора в рабочем потоке [более ленивый](https://bugs.chromium.org/p/chromium/issues/detail?id=713344), чем на странице.
Чтобы получить профит, нужно [завершить выполнение рабочего потока](https://developer.mozilla.org/en-US/docs/Web/API/DedicatedWorkerGlobalScope/close). Во время этой процедуры браузер достаточно быстро освободит всю выделенную потоку память. Не знаю, прописано ли это в стандарте. Я не проверял работоспособность трюка в относительно старых версиях Chrome, но не жду от них никаких неприятных сюрпризов.
На создание и завершение рабочего потока тратится процессорное время, поэтому в целях оптимизации нужно завершать поток только после того, как в нём накопится достаточно много данных, в моём случае примерно 10 мегабайт.
Исходный код трюка:
```
// HACK Firefox 49: Нельзя выбрасывать буфер, который используется в asm.js
// в качестве кучи, чтобы не вызвать исключение out of memory.
const м_Помойка = (() =>
{
const ВМЕСТИМОСТЬ_ПОМОЙКИ = 10e6;
let _сАдрес = '';
let _оПомойка = null;
let _кбВПомойке = 0;
function Выбросить(оБарахло)
{
if (typeof оБарахло !== 'object' || оБарахло === null)
{
return;
}
if (оБарахло.buffer)
{
оБарахло = оБарахло.buffer;
}
if (оБарахло.byteLength)
{
console.log(`[Помойка] Выбрасываю ${оБарахло.byteLength} байтов`);
if (!_оПомойка)
{
if (!_сАдрес)
{
_сАдрес = URL.createObjectURL(new Blob(
[`
'use strict';
self.onmessage = оСобытие =>
{
if (!оСобытие.data)
{
self.close();
}
};
`],
{type: 'application/javascript'}
));
}
_оПомойка = new Worker(_сАдрес);
}
_кбВПомойке += оБарахло.byteLength;
_оПомойка.postMessage(оБарахло, [оБарахло]);
if (_кбВПомойке > ВМЕСТИМОСТЬ_ПОМОЙКИ)
{
Сжечь();
}
}
}
function Сжечь()
{
if (_оПомойка)
{
console.log(`[Помойка] Сжигаю ${_кбВПомойке} байтов`);
// terminate() не подходит, нужно дождаться когда барахло
// попадет в рабочий поток.
_оПомойка.postMessage(null);
_оПомойка = null;
_кбВПомойке = 0;
}
}
return {Выбросить, Сжечь};
})();
```
Функцию `Сжечь()` можно вызвать, чтобы очистить помойку после завершения её использования. В расширении функция вызывается после завершения трансляции.
Посмотрим результат после применения трюка:
[](https://habrastorage.org/files/10d/b5f/9d4/10db5f9d459b41fb9ed347d63c18fc11.png)
[](https://habrastorage.org/files/d4d/cb1/97a/d4dcb197a4d2439886d596fe1f5c8340.png)
Максимальное потребление памяти в Firefox упало на 70 МБ, а в Chrome — на 310 МБ. Без комментариев.
Этот трюк [вызывал утечку](https://bugzilla.mozilla.org/show_bug.cgi?id=1361016) виртуального адресного пространства в Firefox 55-.
#### БЫСТРОДЕЙСТВИЕ
Измерять время подобных быстротекущих процессов — непростое занятие. Возможностей профилировщика JavaScript недостаточно из-за его невысокой точности и размазанности тестируемого кода по разным контекстам, часть которых достаточно быстро уничтожается. Меня в первую очередь интересовал вопрос: на сколько процентов возрастёт время работы расширения после добавления в него кода для освобождения памяти.
Тестирование проводилось следующим образом. В процессоре отключалось энергосбережение (C-states и понижение частоты у Intel). Запускалось расширение в свёрнутом окне. Большую часть времени процессор простаивал, потому что декодированием видео занимается видеокарта. Через 40 минут в [Process Explorer](https://technet.microsoft.com/en-us/sysinternals/processexplorer.aspx) у процесса, в котором работает расширение, проверялось количество затраченных тактов процессора (CPU cycles).
Для обоих трюков количество тактов изменилось в пределах погрешности измерения, так что за быстродействие я не волнуюсь. В синтетическом же тесте в Firefox трюк с `MessageChannel` оказался в несколько раз медленнее трюка с `Worker`. В первую очередь быстродействие зависит от реализации в браузере передачи данных между контекстами в пределах одного процесса. Кстати, в Chrome быстродействие `MessageChannel` не так давно [подняли](https://bugs.chromium.org/p/chromium/issues/detail?id=344814).
#### ЗАКЛЮЧЕНИЕ
Как видно, описанные трюки полезны, правда при достаточно специфических условиях. Большинству людей, работающих с JavaScript, к счастью, они никогда не пригодятся.
А тем, кто заинтересовался проблемой, я дам ещё один совет: старайтесь как можно реже освобождать «толстые» буферы. Например, в расширении я не выбрасываю использованный буфер, а кладу его на «балкон». Если нужно выделить память для данных, то сначала обшаривается балкон, и по возможности используется найденный там буфер, даже если его размер больше требуемого. В моём случае балкон сократил потребление памяти почти в два раза без применения вышеописанных трюков.
**По поводу кириллицы в исходниках*** Русский язык мой родной.
* Не люблю иностранные языки (а ещё запеканку).
* Код писался для себя, за деньги напишу хоть на суахили.
* Я ничего никому не навязываю.
* Приличные люди о вкусах не спорят.
* Жду оригинальных искромётных шуток про 1С. | https://habr.com/ru/post/327426/ | null | ru | null |
# Паттерн Model-Update-View и зависимые типы
Model-Updater-View — функциональный паттерн, успешно применяемый в языке [Elm](http://elm-lang.org/) в основном для разработки пользовательских интерфейсов. Что бы им воспользоваться надо создать тип Model, представляющий полное состояние программы, тип Message, описывающий события внешней среды, на которые программа должна реагировать, меняя свое состояние, функцию updater, которая из старого состояния и сообщения создает новое состояние прораммы и функции view, которая вычисляет по состоянию программы требуемые воздействия на внешнюю среду, которые порождают события типа Message. Паттерн очень удобный, но у него есть маленький недостаток — он не позволяет описать какие события имеют смысл для конкретных состояний программы.
Схожая проблема возникает (и [решается](https://habrahabr.ru/post/341134/)) и при использовании ОО-паттерна State.
Язык Elm простой, но очень строгий — он проверяет, что функция updater хоть как-то обрабатывает все возможные сочетания модели-состояние и сообщения-события. По этому приходится писать лишний, пусть и тривиальный — как правило оставляющий модель без изменений, код. Я хочу продемонстрировать, как этого можно избежать в более сложных языках — Idris, Scala, C++ и Haskell.
Весь приведенный здесь код доступен на [GitHub](https://github.com/potan/MUV-dp-example) для экспериментов. Рассмотрим наиболее интересные места.
Idris
=====
[Idris](https://www.idris-lang.org/) — язык, поддерживающий зависимые типы. То есть в нем компилятор может следить за правильностью типизации, хотя тип одной переменной может зависить от значения другой. Типы в Idris похожи на [обобщенные алгебраические типы](https://en.wikibooks.org/wiki/Haskell/GADT) в Haskell. Он описывается списком параметров типа и набором конструкторов — функций, создающих объекты данного типа. В отличие от Haskell, параметрами типа могут быть не только другие типы и классы типов, но и значения, в том числе функции.
Опишем на нем тип простого приложения, использующего паттерн Model-Updater-View.
```
data Application : (model:Type) ->
(msg: model -> Type) ->
(vtype : Type -> Type) ->
Type
where
MUV : model ->
(updater : (m:model) -> (msg m) -> model) ->
(view : (m:model) -> vtype (msg m)) ->
Application model msg vtype
```
Здесь описан параметризированный тип данных Application. Его параметрами является тип model, функция msg, преобразующая значение типа model в тип события, которое может произойти в данном состоянии прораммы, и тип view, который будет параметризован типом события — его можно трактовать как функцию из типа-параметра в простой тип.
**Лирическое отступление о High Kind Types**Это единственное место, в котором используется параметр типа, который сам имеет параметры-типы. Такая возможность предоставляется не всеми языками — нее нет в том числе в Elm. Но в этом примере view вынесен в параметры типа приложения больше «для красоты» — что бы показать, что он является составляющей паттерна. Можно поступить как в Elm — использовать в качестве View фиксированный парамтеризованный тип (в Elm это Html msg).
Я хочу отметить, что HKT не являются необходимыми для использования зависимых типов — это разные ребра [лямбда-куба](https://ru.wikipedia.org/wiki/%D0%9B%D1%8F%D0%BC%D0%B1%D0%B4%D0%B0-%D0%BA%D1%83%D0%B1)
Функция msg необычна — она возвращает не значение, а тип. Во время исполнения про типы значений ни чего не известно — компилятор выполняет [стирание](https://en.wikipedia.org/wiki/Type_erasure) всей лишней информации. То есть такая функция может быть вызвана только на этапе компиляции.
MUV — это конструктор. Он принимает параметры: model — начальное состояние программы, updater — функция обновления состояния при внешнем событии, и view — функция создания внешнего представления. Заметьте что тип функций updater и view зависит от значения модели (с помощью функции msg из параметров типа).
Теперь посмотрим, как это приложение запустить
```
muvRun : (Application modelType msgType IO) -> IO a
muvRun (MUV model updater view) =
do
msg <- view model
muvRun (MUV (updater model msg) updater view)
```
В качестве внешнего представления (view) мы выбрали операцию ввода/вывода (в Idris, как и в Haskell, операции ввода/вывода — first class values, что бы они выполнились надо предпринять дополнительные действия, обычно вернуть такую операцию из функции main).
**Кратко об IO**При выполнении операции типа (IO a) происходит некоторое воздействие на внешний мир, возможно пустое, и в программу возвращается значение типа a, но функции стандартной библиотеки устроены так, что обработать его можно только порождая новое значение типа IO b. Таким образом чистые функции отделены от функций с побочными эффектами. Это непривычно многим программистам, но помогает писать более надежный код.
Так как функция muvRun порождает ввод/вывод, она должна вернуть IO, но так как она ни когда не завершиться, тип операции может быть любой — IO a.
Теперь опишем типы сущностей, с которыми мы собираемся работать
```
data Model = Logouted | Logined String
data MsgOuted = Login String
data MsgIned = Logout | Greet
total
msgType : Model -> Type
msgType Logouted = MsgOuted
msgType (Logined _) = MsgIned
```
Здесь описан тип модели, отражающий наличие двух состояний интерфейса — пользователь не залогинен, и залогинен пользователь с именем типа String.
Далее мы описывает **два различных** типов сообщений, релевантрых для разных вариантов модели — если мы разлогинены, то мы можем только залогиниться под некоторым именем, а если уже залогинены, то можем либо разлогиниться, либо поздороваться. Idris — строго типизированный язык, который не допустит возможности перепутать разные типы.
И наконец функция, задающая соответствие значения модели типу сообщения.
Функция объявлена тотальной — то есть она не должна упасть или зависнуть, компилятор постарается за этим проследить. msgType вызывается на этапе компиляции, а значит ее тотальность означает, что компиляция не зависнит из-за нашей ошибки, хотя и не может гарантировать, что выполнение этой функции приведет к исчерпанию ресурсов системы.
Так же гарантировано, что она не выполнит «rm -rf /», потому что в ее сигнатуре нет IO.
Опишем updater:
```
total
updater : (m:Model) -> (msgType m) -> Model
updater Logouted (Login name) = Logined name
updater (Logined name) Logout = Logouted
updater (Logined name) Greet = Logined name
```
Думаю логика этой функции понятна. Хочу еще раз отметить тотальность — она означает что компилятор Idris проверит, что мы рассмотрели все разрешенные системой типов альтернативы. Elm тоже осуществляет такую проверку, но он не может знать, что мы не можем разлогиниться, если еще не залогинены, и потребует явную обработку условия
```
updater Logouted Logout = ???
```
Idris же в лишней проверки найдет несоотвествие типов.
Теперь приступим к view — как обычно в UI это будет самой сложной частью кода.
```
total
loginPage : IO MsgOuted
loginPage = do
putStr "Login: "
map Login getLine
total
genMsg : String -> MsgIned
genMsg "" = Logout
genMsg _ = Greet
total
workPage : String -> IO MsgIned
workPage name = do
putStr ("Hello, " ++ name ++ "\n")
putStr "Input empty string for logout or nonempty for greeting\n"
map genMsg getLine
total
view : (m: Model) -> IO (msgType m)
view Logouted = loginPage
view (Logined name) = workPage name
```
view должна создавать операцию ввода/вывода, которая возвращает сообщения, тип которого снова зависит от значения модели. У нас есть два варианта: loginPage, который выводит сообщение «Login:», читает строку с клавиатуры и заворачивает ее в сообщение Login и workPage с параметром именем пользователя, который выводит приветсвие и возвращает различные сообщения (но одинакового типа — MsgIned) в зависимости от того, введет пользоваль пустую или не пустую строку. view возвращает одну из этих операций в зависимости от значения модели, и компилятор проверяет их тип, несмотря на то, что он разный.
Теперь мы можем создать и запустить наше приложение
```
app : Application Model Main.msgType IO
app = MUV Logouted updater view
main : IO ()
main = muvRun app
```
Здесь надо отметить тонкий момент — функция muvRun возврящает **IO a**, где a не было специфицировано, а значение main имеет тип **IO ()**, где **()** — это имя типа, обычно называемого **Unit**, у которого есть единственное значение, тоже записываемое как пустой тупл **()**. Но компилятор с этим легко справляется. подставив вместо a ().
Scala и зависимые от пути типы
==============================
В Scala нет полноценной поддержки зависимых типов, но есть типы, зависимые от экземпляра объекта, через который на него ссылаются (path dependent types). В теории зависимых типов их можно описать как вариант сигма-типа. Зависимые от пути типы позволяют запретить складывать вектора из разных векторных пространств, или описать [кому с кем можно целоваться](https://github.com/anton-k/ru-neophyte-guide-to-scala/blob/master/src/p13-path-dep-types.md). Но мы их применим для более простых задач.
```
sealed abstract class MsgLogouted
case class Login(name: String) extends MsgLogouted
sealed abstract class MsgLogined
case class Logout() extends MsgLogined
case class Greet() extends MsgLogined
abstract class View[Msg] {
def run() : Msg
}
sealed abstract class Model {
type Message
def view() : View[Message]
}
case class Logouted() extends Model {
type Message = MsgLogouted
override def view() : View[Message]
....
}
case class Logined(name: String) extends Model {
type Message = MsgLogined
override def view() : View[Message]
....
}
```
Алгебраические типы в Scala моделируются через наследование. Типу соотвествует некоторый **sealed abstract class**, а каждому конструктору унаследованный от него **case class**. Мы будем стараться их использовать именно как алгебраические типы, описывая все переменные как принадлежащие к родительскому **sealed abstract class**.
Классы MsgLogined и MsgLogouted в рамках нашей программы не имеют общего предка. Функцию view пришлось размазать по разным классам модели, что бы иметь доступ к конкретному типу сообщений. В этом есть свои плюсы, которые оценят сторонники ОО — код получается сгруппирован в соотвествии с бизнес-логикой, все что связано с одним use case оказывается рядом. Но мне бы больше понравилось выделить view в отдельную функцию, разработку которой можно было бы передать другому человеку.
Теперь реализуем updater
```
object Updater {
def update(model: Model)(msg: model.Message) : Model = {
model match {
case Logouted() => msg match {
case Login(name) => Logined(name)
}
case Logined(name) => msg match {
case Logout() => Logouted()
case Greet() => model
}
}
}
}
```
Здесь мы, используя зависимые от пути типы, описываем тип второго аргумента от значения первого. Что бы Scala воспринимала подобные зависимости, функции приходится описывать в карррированном виде, то есть в виде функции от первого аргумента, которая возвращает функцию от второго аргумента. К сожалению, Scala в этом месте не осуществляет многих проверок типов, для которых у компилятора достаточно информации.
Теперь дадим полную реализацию модели и view
```
case class Logouted() extends Model {
type Message = MsgLogouted
override def view() : View[Message] = new View[Message] {
override def run() = {
println("Enter name ")
val name = scala.io.StdIn.readLine()
Login(name)
}
}
}
case class Logined(name: String) extends Model {
type Message = MsgLogined
override def view() : View[Message] = new View[Message] {
override def run() = {
println(s"Hello, $name")
println("Empty string for logout, nonempy for greeting.")
scala.io.StdIn.readLine() match {
case "" => Logout()
case _ => Greet()
}
}
}
}
abstract class View[Msg] {
def run() : Msg
}
object Viewer {
def view(model: Model): View[model.Message] = {
model.view()
}
}
```
Тип возвращаемого функцией view зависит от экземпляра ее аргумента. Но за реализацией она обращается в модель.
Запускается созданное так приложение так
```
object Main {
import scala.annotation.tailrec
@tailrec def process(m: Model) {
val msg = Viewer.view(m).run()
process(Updater.update(m)(msg))
}
def main(args: Array[String]) = {
process(Logouted())
}
}
```
Код runtime-системы, таким образом, ни чего не знает о внутреннем устройстве моделий и типах сообщений, но компилятор может проверить что сообщение подходит к текущей модели.
Здесь нам понадобились не все возможности, продоставляемые зависимыми от пути типами. Интересные свойства проявятся, если мы будем параллельно работать с неколькими экземплярами систем Model-Updater-View, например при симуляции многоагентного мира (view тогда бы представлял из себя воздействие агента на мир и получение обратной связи). В этом случае компилятор проверял, что сообщение обрабатывается именно тем агентом, для которого преднозначено, несмотря на то, что все агенты имеют одинаковый тип.
С++
===
С++ до сих пор чувствителен к порядку определений, даже если они все сделаны в одном файле. Это создает некоторые неудобства. Я буду приводить код в удобной для демонстрации идей последовательнсоти. Упорядоченную для компилируемости версию можно посмотреть на [GitHub](https://github.com/potan/MUV-dp-example/blob/master/cpp/muv.cpp).
Алгебраические типы могут быть реализованы так же, как в Scala — абстрактный класс соответствует типу, а конкретные наследники — конструкторам (назовем их «классами-конструкторами», что бы не путать с обычными конструкторами C++) алгебраического типа.
В C++ есть [поддержка](http://meta-meta.blogspot.ru/2012/12/c11-sort-of-kind-of-has-path-dependent.html) зависимых от пути типов, но компилятор не может использовать этот тип абстрактно, не зная реального типа, с которым он связан. По этому реализовать Model-Updater-View с их помощью не получается.
Но C++ располагает мощной системой шаблонов. Зависимость типа от значения модели можно спрятав его в шаблонный параметр специализированной версии исполнительной системы.
```
struct Processor {
virtual const Processor *next() const = 0;
};
template struct ProcessorImpl : public Processor {
const CurModel \* model;
ProcessorImpl(const CurModel\* m) : model(m) { };
const Processor \*next() const {
const View \* view = model->view();
const typename CurModel::Message \* msg = view->run();
delete view;
const Model \* newModel = msg->process(model);
delete msg;
return newModel->processor();
}
};
```
Мы описываем абстрактную исполнительную систему, с единственным методом — выполнить все, что требуется, и вернуть новую исполнительную систему, подходящую для следующей итерации. Конкреная версия имеет шаблонный параметр и будет специализирована для каждого «класса-конструктора» модели. Здесь важно, что все свойства типа CurModel будут проверены во время специализации шаблона конкретным параметром-типом, а на момент компиляции самого шаблона их описывать не требуется (хотя и возможно с помощью [концептов](https://habrahabr.ru/post/304728/) или [других способов реализации классов типов](https://habrahabr.ru/post/205482/)). Scala тоже имеет достаточно мощную систему параметризованных типов, но проверки свойств типов-параметров она осуществляет во время компиляции параметризованного типа. Там реализация такого паттерна затруднена, но возможна, благодоря поддержке классов типов.
Опишем модель.
```
struct Model {
virtual ~Model() {};
virtual const Processor *processor() const = 0;
};
struct Logined : public Model {
struct Message {
const virtual Model * process(const Logined * m) const = 0;
virtual ~Message() {};
};
struct Logout : public Message {
const Model * process(const Logined * m) const;
};
struct Greet : public Message {
const Model * process(const Logined * m) const;
};
const std::string name;
Logined(std::string lname) : name(lname) { };
struct LoginedView : public View {
...
};
const View \* view() const {
return new LoginedView(name);
};
const Processor \*processor() const {
return new ProcessorImpl(this);
};
};
struct Logouted : public Model {
struct Message {
const virtual Model \* process(const Logouted \* m) const = 0;
virtual ~Message() {};
};
struct Login : public Message {
const std::string name;
Login(std::string lname) : name(lname) { };
const Model \* process(const Logouted \* m) const;
};
struct LogoutedView : public View {
...
};
const View \* view() const {
return new LogoutedView();
};
const Processor \*processor() const {
return new ProcessorImpl(this);
};
};
```
«Классы-конструкторы» модели «все свое носят с собой» — то есть содержат спициализированные для них классы сообщений и view, а так же умеют создавать исполнительную систему под себя. Собственные типы View имеют общего для всех моделей предка, что может оказаться полезно при разработке более сложных исполнительных систем. Принципиально что типы сообщений полностью изолированы и не имеют общего предка.
Реализация updater отделена от модели, поскольку требует что бы тип модели был уже полностью описан.
```
const Model * Logouted::Login::process(const Logouted * m) const {
delete m;
return new Logined(name);
};
const Model * Logined::Logout::process(const Logined * m) const {
delete m;
return new Logouted();
};
const Model * Logined::Greet::process(const Logined * m) const {
return m;
};
```
Теперь соберем вместе все, что относится к view, включая внутренние сущности моделей
```
template struct View {
virtual const Message \* run() const = 0;
virtual ~View() {};
};
struct Logined : public Model {
struct LoginedView : public View {
const std::string name;
LoginedView(std::string lname) : name(lname) {};
virtual const Message \* run() const {
char buf[16];
printf("Hello %s", name.c\_str());
fgets(buf, 15, stdin);
return (\*buf == 0 || \*buf == '\n' || \*buf == '\r')
? static\_cast(new Logout())
: static\_cast(new Greet);
};
};
const View \* view() const {
return new LoginedView(name);
};
};
struct Logouted : public Model {
struct LogoutedView : public View {
virtual const Message \* run() const {
char buf[16];
printf("Login: ");
fgets(buf, 15, stdin);
return new Login(buf);
};
};
const View \* view() const {
return new LogoutedView();
};
};
```
И, наконец, напишем main
```
int main(int argc, char ** argv) {
const Processor * p = new ProcessorImpl(new Logouted());
while(true) {
const Processor \* pnew = p->next();
delete p;
p = pnew;
}
return 0;
}
```
И снова Scala, уже с классами типов
===================================
По структуре эта реализация почти полностью повторяет версию на C++.
**Аналогичная часть кода**
```
abstract class View[Message] {
def run(): Message
}
abstract class Processor {
def next(): Processor;
}
sealed abstract class Model {
def processor(): Processor
}
sealed abstract class LoginedMessage
case class Logout() extends LoginedMessage
case class Greet() extends LoginedMessage
case class Logined(val name: String) extends Model {
override def processor(): Processor = new ProcessorImpl[Logined, LoginedMessage](this)
}
sealed abstract class LogoutedMessage
case class Login(name: String) extends LogoutedMessage
case class Logouted() extends Model {
override def processor(): Processor = new ProcessorImpl[Logouted, LogoutedMessage](this)
}
object Main {
import scala.annotation.tailrec
@tailrec def process(p: Processor) {
process(p.next())
}
def main(args: Array[String]) = {
process(new ProcessorImpl[Logouted, LogoutedMessage](Logouted()))
}
}
```
А вот в реализации среды исполнения возникают тонкости.
```
class ProcessorImpl[M <: Model, Message](model: M)(
implicit updater: (M, Message) => Model,
view: M => View[Message]
) extends Processor {
def next(): Processor = {
val v = view(model)
val msg = v.run()
val newModel = updater(model,msg)
newModel.processor()
}
}
```
Здесь мы видим новые таинственные параметры **(implicit updater: (M, Message) => Model, view: M => View[Message])**. Ключевое слово implicit означает что компилятор при вызове этой функции (точнее конструктора класса) будет искать в контексте помечанные как implicit объекты подходящих типов и передавать их в качестве соответствующих параметров. Это достаточно сложная концепция, одно их применений которой — реализация классов типов. Здесь они обещают компилятору, что для конкретных реализаций модели и сообщения все необходимые функции нами будут предоставлены. Теперь выполним это обещание.
```
object updaters {
implicit def logoutedUpdater(model: Logouted, msg: LogoutedMessage): Model = {
(model, msg) match {
case (Logouted(), Login(name)) => Logined(name)
}
}
implicit def viewLogouted(model: Logouted) = new View[LogoutedMessage] {
override def run() : LogoutedMessage = {
println("Enter name ")
val name = scala.io.StdIn.readLine()
Login(name)
}
}
implicit def loginedUpdater(model: Logined, msg: LoginedMessage): Model = {
(model, msg) match {
case (Logined(name), Logout()) => Logouted()
case (Logined(name), Greet()) => model
}
}
implicit def viewLogined(model: Logined) = new View[LoginedMessage] {
val name = model.name
override def run() : LoginedMessage = {
println(s"Hello, $name")
println("Empty string for logout, nonempy for greeting.")
scala.io.StdIn.readLine() match {
case "" => Logout()
case _ => Greet()
}
}
}
}
import updaters._
```
Haskell
=======
В мейнстримовом Haskell нет зависимых типов. В нем так же отсутствиет наследование, которое мы существенно применяли при реализации паттерна в Scala и C++. Но одноуровневое наследование (с элементами зависимых типов) может быть смоделировано с помощью более-менее стандандартных расширений языка -TypeFamilies и ExistentialQuantification. Для общего интерфейса дочерних ООП-классов заводится класс типов, в котором присутствует зависимый «семейный» тип, сами дочерние классы представляются отдельным типом, а потом заворачиваются в «экзистенциональный» тип с единственным конструктором.
```
data Model = forall m. (Updatable m, Viewable m) => Model m
class Updatable m where
data Message m :: *
update :: m -> (Message m) -> Model
class (Updatable m) => Viewable m where
view :: m -> (View (Message m))
data Logouted = Logouted
data Logined = Logined String
```
Я попытался разнести updater и view как можно дальше, по этому создал два разных класса типов, но пока это плохо получилось.
Реализация updater проста
```
instance Updatable Logouted where
data Message Logouted = Login String
update Logouted (Login name) = Model (Logined name)
instance Updatable Logined where
data Message Logined = Logout | Greeting
update m Logout = Model Logouted
update m Greeting = Model m
```
В качестве View пришлось зафиксировать IO. Попытки сделать его более абстрактным сильно все усложняли и повышали связанность кода — тип Model должен знать, какой именно View мы собираемся использовать.
```
import System.IO
type View a = IO a
instance Viewable Logouted where
view Logouted = do
putStr "Login: "
hFlush stdout
fmap Login getLine
instance Viewable Logined where
view (Logined name) = do
putStr $ "Hello " ++ name ++ "!\n"
hFlush stdout
l <- getLine
pure $ if l == ""
then
Logout
else
Greeting
```
Ну и исполняемая среда мало отличается от аналогичной в Idris
```
runMUV :: Model -> IO a
runMUV (Model m) = do
msg <- view m
runMUV $ update m msg
main :: IO ()
main = runMUV (Model Logouted)
``` | https://habr.com/ru/post/341988/ | null | ru | null |
# Женщины и убийства: есть ли тут взаимосвязь? [часть 2 из 2]
**`R` код ([gist](https://gist.github.com/ikashnitsky/09618405045ea86aca3484881a9094dc)) для воспроизведения всех результатов**
[В первой части](https://habrahabr.ru/post/311970/), подхваченный вдохновением и желанием проверить гипотезы сразу, я проанализировал взаимосвязь между соотношением полов и распространенностью убийств в странах Европы. Результаты не подтвердили моих ожиданий. Похоже, что во многом страны Европы напоминают регионы одной страны со своей периферией и своими центрами.
В следующей итерации своего скептицизма, результаты которого вы можете прочитать ниже, я проверяю свою гипотезу на данных американских графств, как и авторы [исходной статьи](https://dx.doi.org/10.1007/s12110-016-9271-x).
**Коротко о гипотезе**Если вам лень заглянуть в [первую часть статьи](https://habrahabr.ru/post/311970/), то вот кратко суть. Авторы опубликованного в журнале Human Nature исследования утверждают, что соотношения полов во взрослом населении влияет на распространенность тяжких преступлений (в частности, убийств): чем больше женщин, тем больше и преступлений. Я по-прежнему думаю, что все дело в упущенной переменной — центральность/периферийность (urban/rural) — которая и должна объяснять как повышенную долю женщин в городах, так и большее количество преступлений в них.
Убедительно подтвердить свои догадки на простеньких европейских данных мне не удалось. Попробуем на подробных американских.
Данные
------
> А ларчик просто открывался (с)
Все оказалось гораздо проще, чем можно было ожидать. Конечно, я потратил не один час, блуждая по разным ресурсам (благо по США данных… нам бы так). И вот, когда я все еще рисовал себе сложности и сохранял "на потом" десятки закладок, наткнулся на [вот этот замечательный датасет](http://www.icpsr.umich.edu/icpsrweb/NACJD/studies/20660). Датасет свободно скачивается после регистрации и согласия с условиями использования.
Данные как нарочно собраны для подобного рода анализа, что наводит на подозрения в велосипедостроительной специализации авторов исходной статьи. Датасет содержит обширный перечень переменных для графств США за период 2001-2006. Не такие свежие данные, как у авторов, но вряд ли можно ожидать, что human nature меняется за десятилетие. Он содержит все интересующие нас переменные, чтобы беспрепятственно повторить исследование и проверить интересующую нас гипотезу.
Exploratory data analysis
-------------------------
Сперва давайте посмотрим, велики ли различия по ключевым показателям между центральными и периферийными графствами. В нашем датасете есть классификация графств на 9 типов (RuralUrban03, 2003 ERS Rural-Urban Continuum Code). Первые три категории — это городские графства разной численности. Категории 4-9 — сельские, различия в численности населения и удаленности от регионального центра.
**Категории графств (скопировано из Codebook к датасету)**Code Description
Metropolitan counties:
1 Counties in metro areas of 1 million population or more
2 Counties in metro areas of 250,000 to 1 million population
3 Counties in metro areas of fewer than 250,000 population
Nonmetropolitan counties:
4 Urban population of 20,000 or more, adjacent to a metro area
5 Urban population of 20,000 or more, not adjacent to a metro area
6 Urban population of 2,500 to 19,999, adjacent to a metro area
7 Urban population of 2,500 to 19,999, not adjacent to a metro area
8 Completely rural or less than 2,500 urban population, adjacent to a metro area
9 Completely rural or less than 2,500 urban population, not adjacent to a metro area
На карте это выглядит так. Кружочками даны столицы штатов (красный) и крупные города (золотой).
**Рисунок 1.** Классификация графств по центральности/периферийности.
Поскольку с 9 категориями работать неудобно, в дальнейшем анализе я объединил первые три — в категорию `metro`, а оставшиеся — в категорию `non-metro`.
Во-первых, нам интересно, действительно ли соотношение мужчин и женщин отражает результат миграционного закона Равенштейна — действительно ли женщины активнее в миграциях на короткие расстояния, и их больше в городах. Посмотрим на распределения графств по соотношению полов во взрослом возрасте (рис. 2).
**Рисунок 2.** Распределение центральных и периферийных графств по соотношению полов во взрослом возрасте.
Отчетливо видно, что среди графств с повышенным соотношением полов (преобладают мужчины) больше периферийных. Медианное значение показателя для периферийных графств 1.039; для центральных 1.016.
Карта по графствам получается очень шумной, поэтому я построил карту по штатам, сравнивая средние значения соотношения полов для центральных и периферийных графств (рис. 3). Практически нет штатов, в которых соотношение полов было бы выше в центральных графствах.
**Рисунок 3.** Среднее соотношение полов в центральных графствах в сравнении с периферийным.
Еще одним наглядным результатом миграции всегда выступает медианный возраст населения. В среднем, мигранты всегда моложе местного населения. Поэтому миграция перераспределяет медианный возраст населения, омолаживая центральные территории и ускоряя старение населения в периферии. Разумеется, этому общему правилу находится подтверждение и на американских данных (рис. 4 и 5).
**Рисунок 4.** Распределение центральных и периферийных графств по соотношению медианному возрасту населения.
**Рисунок 5.** Медианный возраст населения по графствам США.
Для разнообразия, по медианному возрасту населения построил карту по графствам. Она все еще достаточно шумная, но общую закономерность уловить можно.
Наконец, как же обстоит дело с убийствами в городе и на селе? Тут ситуация любопытная (рис. 6).
**Рисунок 6.** Распределение центральных и периферийных графств по показателю убийств на 100К населения.
В 2004 году, когда были собраны данные, убийства не произошли в 65.2% периферийных графств и 30.3% центральных графств. При этом, когда преступления все же происходили в периферийных территориях, коэффициент получался довольно высоким за счет малой численности населения провинциальных графств. В целом же, разумеется, в городах убийств больше. Значение третьего квартиля (75%) для городов составляет 55.4, а для провинции 36.7 убийств на 100К населения. Если агрегировать данные по штатам и типу графств (рис. 7), то явно видно, что практически во всех штатах городская преступность выше.
**Рисунок 7.** Усредненный коэффициент убийств на 100К населения в центральных графствах в сравнении с периферийным.
Итак, исходные предпосылки подтверждаются данными. Посмотрим, каков будет результат моделирования.
Но сперва давайте еще посмотрим на красивую карту доли чернокожего населения США по графствам (рис. 8), поскольку вслед за авторами мы будем использовать эту переменную в качестве контрольной в моделях.
**Рисунок 8.** Доля чернокожего населения по графствам США.
Модели
------
Итак, моделируем с помощью Пуассоновских регрессий зависимость коэффициента убийств от соотношения полов и прочих дополнительных переменных. Вводим переменные последовательно.
**Обозначения переменных в таблице***Лень было менять обозначения. К тому же, они вполне говорящие.*
**asr** — соотношение полов во взрослом возрасте (15-44)
**perstpov04** — устойчивая бедность: доля населения графства за чертой бедности не менее 20% по данным 4 последних переписей населения, 1970, 1980, 1990 и 2000
**pctblack05** — доля чернокожего населения
**southSouth** — дамми переменная для южных штатов (Юг в сравнении с Севером)
**metroNon-metro** — центральность/периферийность (периферия в сравнении центром)
**ruralurban03** — 9-ступенчатая классификация центральности/периферийности
**unemprate05** — безработица
**medianage05** — медианный возраст населения
**Таблица 1.** Результаты моделирования уровня убийств.
Результаты моделей 1-4 очень сходны с теми, что приводят авторы статьи в Human Nature. Любопытно тут, пожалуй, то, что при переходе от модели 2 к модели 3 коэффициент при переменной "постоянная бедность" меняет знак. Получается, что доля черного населения объясняет вариацию в бедности.
Нам же интересно сравнить модели 4 и 5. Когда мы вводим центральность/периферийность в качестве контрольной переменной, коэффициент при соотношении полов становится существенно менее негативным. То есть, различия в центральности/периферийности объясняю значительную часть выявленной взаимосвязи между частотой убийств и соотношением полов. Остальные модели не столь интересны, но оставил.
Выводы
------
Сенсации не произошло. Но, действительно, центральность/периферийность графств почти наполовину ослабляет выявленную авторами взаимосвязь между соотношением полов и уровнем преступности. Прочие проверенные мной дополнительные переменные не имеют столь же значимого эффекта. Так что подозрение мое подтвердилось наполовину. Статус территории значит много, но не нивелирует полностью выявленную взаимосвязь. Однако, без сомнения, авторы исходной статьи упустили одну из ключевых переменных.
Reproducibility
---------------
`R` код ([gist](https://gist.github.com/ikashnitsky/09618405045ea86aca3484881a9094dc)) для воспроизведения всех результатов. Гарантированно работает при использованнии `R` версии 3.3.2 с пакетами по состоянию на 2016-11-10. В случае пакетных несовместимостей, воспользуйтесь пакетом [checkpoint](https://cran.r-project.org/web/packages/checkpoint/index.html), установив соответствующую дату.
**UPD 2018**: все материалы на [github](https://github.com/ikashnitsky/sex-ratios-and-crime).
--------------------------------------------------------------------------------------------- | https://habr.com/ru/post/312694/ | null | ru | null |
# Звук на чипе AY-3-8910 (или Yamaha YM2149F) родом с ZX Spectrum на PC через USB
Прошло около года, с момента успешного [подключения музыкального синтезатора YM2149F к LPT порту компьютера](http://habrahabr.ru/post/218763/). LPT это конечно хорошо, однако время не стоит на месте, и найти компьютер или ноутбук с LPT портом становится все сложнее и сложнее. Да и сам автор (то есть я) устал лазить каждый раз под стол, где стоит системник, и перетыкать LPT плату на что-то другое, например программатор (у меня LPT-программатор Willem, ну да не суть). Поэтому на сей раз подключать чип YM2149F будем к USB. Ну и конечно, чтобы соотвествовать эпохе, будем это делать на копеечном древнем микроконтроллере **PIC16F628**.
Вкратце, YM2149F (или ее функциональный аналог [AY-3-8910](https://ru.wikipedia.org/wiki/AY-3-8910)) — микросхема звукового трехголосного синтезатора, применялась в старых компьютерах типа Atari ST, Amstrad CPC, ZX Spectrum, MSX и некоторых других для проигрывания музыки. В России чип приобрел определенную известность благодаря установки в различные клоны ZX Spectrum'а. За время шествования ZX Spectrum по бывшему СССР музыкантами были написаны тысячи мелодий под этот звуковой программируемый генератор. Да и сейчас можно вполне найти людей, создающих музыку именно под этот чип. В конце статьи будут приведены ссылки на огромнейший архив чип-тюнов для YM/AY на сотни часов непрерывного прослушивания.
#### Демо
Как и в прошлый раз, перед началом, даю сразу ссылку на прослушивания конечного результата: <https://soundcloud.com/tronix286> Последние записи сделаны как раз с этого устройства. Записывал так-себе плеером, который пишет максимум в 128Kb/s MP3, поэтому в реальности устройство звучит «ярче». Но составить общее представление о звуке можно.
#### Железо
Почему такой странный выбор контроллера? Почему не AVR/ARM/iCore i7/FTDI на худой конец? Частично ответ на этот вопрос дан в начале топика: ретро синтезатору — ретро микроконтроллер! Тем более, что у AY-3-8910 и фирмы Microchip, можно сказать, общие корни. А вообще, так сложилась серия странных обстоятельств. Во-первых я наткнулся в интернете на библиотеку, реализующую программный (софтварный) стек USB 1.1 для микроконтроллеров PIC16F628 — вот эта библиотека: [16FUSB](http://code.google.com/p/16fusb/). Во-вторых, у меня давно лежала и пылилась парочка PIC16F628A, которые я не знал куда деть. В третьих, на компе уже стоял настроенный софт (MPLABX, MPASM) и имеется программатор для PIC. Ну и в отличии от программного стека [V-USB](https://ru.wikipedia.org/wiki/V-USB) на AVR, известного многим, на PIC'ах без аппаратного USB проектов мало или даже вообще нет. А это значит, что нужно восстановить историческую несправедливость.
Вот типовая схема включения с сайта библиотеки 16fusb:
В комплекте с библиотекой 16fusb идет хороший пример под названием «direct-io». Смысл прост — посылаем через USB байт и он «отображается» на восьми ножках микроконтроллера. Так же можно посылать дополнительно два управляющих сигнала, то есть еще два бита (или две ножки). И в обратном направлении, то есть от контроллера к хосту (компьютеру).
Для управления YM2149F используется восьмибитная шина данных D0-D7 и три управляющих сигнала BC1, BDIR и RESET. BC1 и BDIR управляют выбором адреса регистра и его значением, а так же переводят микросхему в неактивное состояние. Сигнал RESET используется для сброса всех регистров на первоначальное значение. Таким образом, чтение из PIC в компьютер не нужно; нужна только возможность посылать команды на YM. И нужен еще третий управляющий сигнал, а значит еще одна ножка МК.
В своей прошивке для управления конкретно YM2149F было сделано следующее:
* выкинуто все, что связано с чтением сигналов из PIC в хост (компьютер) для увеличения быстродействия обработки реквестов USB;
* состояние направлений портов ввода-вывода жёстко задано при инициализации МК и не изменяется в процедурах выдачи байта на ноги.
* организован кольцевой буфер на 64 байта. При декодировании запроса от хоста байты складываются в буфер. Когда есть свободное время, данные из буфера выдаются на YM.
* оптимизирована скорость выдачи байта на ноги МК. Частично за счет жестко указанных направлений ввода-вывода, частично из-за известности предыдущего состояния управляющих бит.
* пофикшен глюк с зацикливанием PIC через несколько тысяч пакетов (развернут цикл RxLoop в файле isr.asm, вместо goto RxLoop вставлена проверка на признак конца пакета)
* что-то еще, не помню
Как уже сказано выше, возникает потребность в еще одном управляющем сигнале — RESET, а свободных ножек уже нет. Поэтому для тактирования PIC применен кварцевый генератор, а не кварц, тем самым высвобождая одну ногу МК (RA6), необходимую для управления сигналом RESET. Нога RA5, торчащая в воздухе, в данном семействе работает только на вход и не может быть использована для управления выходным сигналом. На нее можно было-бы переложить функционал по отлавливанию конца USB пакета (EOP) с ножки RB2, однако это не так просто — в отличии от ножки RB2 ножка RA5 делит функционал с MCLR и VPP для программирования и внутри организован вход как триггер шмитта. Ему просто не хватит напряжения после диодов для сработки. С другой стороны, для тактирования YM2149F собран генератор на микросхеме 74HC02 и кварце 3.579545 MHz. Можно было бы попробовать использовать вторую свободную половину микросхемы для сборки аналогичного генератора и для PIC, но остановило два момента: 1) у меня нету кварца на 24МГц (а кварцевый генератор был, с какой-то древней мамки) 2) я не знаю, как поведет себя 74HC02, если с «разных боков» у нее будут разные частоты, причем одна из них довольно высокая (24МГц все таки очень большая частота). Еще один из вариантов, как освободить ногу RA6 для кварца: Сигналы BC1 и BDIR принимают только такие значения:
```
BC1 BDIR
0 0
0 1
1 1
```
И никогда BC1 = 1, BDIR = 0. Это можно использовать как RESET, добавив NOT и NOR логику из половинки микросхемы 74HC02 и проинвертировав сигнал на выходе с помощью транзистора. Конечно для выдачи BC = 1 и BDIR = 0 нужно немного подправить прошивку.
И еще, нога RA4, которая управляет сигналом BDIR, с открытым коллектором, поэтому ее обязательно нужно подтянуть к питанию — на схеме это 10K резистор R5.
#### Софт
Со стороны компьютера, в качестве музыкального проигрывателя, выступает отличный кросс-платформенный плеер чип-тюнов [ZX Tune](http://zxtune.bitbucket.org/):
Напрямую он не поддерживает USB, зато если находит у себя в директории одну из библиотек dlportio.dll/inpout32.dll/inpoutx64.dll, то позволяет переключится в настройках вывода звука на YM-LPT ([для прошлого проекта](http://habrahabr.ru/post/218763/)), а затем использует функцию \_\_stdcall void DlPortWritePortUchar(unsigned short port, unsigned char val); для выдачи байт YM2149. Порт 0x378 данные, Порт 0x37a передача управляющих сигналов (D1 — ~BDIR, D2 — BC1, D3 — ~RESET). Таким образом, можно написать маленькую библиотеку-заглушку с одной единственной функцией DlPortWritePortUchar, в которой перенаправлять выдачу байт на USB-устройство, что и было сделано. Я просто взял исходники библиотеки [inpout32](http://www.highrez.co.uk/Downloads/InpOut32/) за основу и написал функцию-заглушку для перенаправления выдачи байт на это устройство. В итоге, достаточно положить эту библиотеку-заглушку **inpout32.dll** или **inpoutx64.dll**, в зависимости от используемой версии плеера (x86/x64), в одну директорию с плеером **ZX Tune**, запустить его и в настройках звука переместить устройство **aylpt** на самый верх (как на скриншоте выше).
#### Скачать бесплатно и без СМС
Драйвера для Win XP, Win 7 (x32/x64) можно скачать здесь: [16FUSB\_driver-libusb-win32-1.2.6.0.zip](http://16fusb.googlecode.com/files/16FUSB_driver-libusb-win32-1.2.6.0.zip)
Схема устройства: [ym-usb\_scheme\_1.0.rar](https://dl.dropboxusercontent.com/u/33189328/ym-usb_scheme_1.0.rar)
Скомпилированная прошивка (.hex) и скомпилированные DLL-заглушки: [ym-usb\_firmware\_and\_DLLs\_v1.2.rar](https://dl.dropboxusercontent.com/u/33189328/ym-usb_firmware_and_DLLs_v1.2.rar)
Исходные коды прошивки: [ym-usb\_PIC16F628A\_source\_v1.2.rar](https://dl.dropboxusercontent.com/u/33189328/ym-usb_PIC16F628A_source_v1.2.rar)
Исходные коды библиотеки-заглушки: [inpout32-64\_DLL\_source\_v1.2.rar](https://dl.dropboxusercontent.com/u/33189328/inpout32-64_DLL_source_v1.2.rar)
General Instruments AY-3-8910 / 8912 Programmable Sound Generator (PSG) data Manual: <http://bulba.untergrund.net/AY-3-8910.rar>
Тема на форуме ZX.PK.ru, из которой «родилось» устройство:<http://zx-pk.ru/showthread.php?t=22202>
Огромный архив трекерной музыки: [Modland](http://www.exotica.org.uk/wiki/Modland) ([ФТП](ftp://ftp.modland.com/))
ZX музыка онлайн: <http://zxtunes.com/>
Всем добра! | https://habr.com/ru/post/248115/ | null | ru | null |
# Введение в Git Merge и Git Rebase: зачем и когда их использовать
Часто у разработчиков возникает выбор между Merge (слияние) и Rebase (перемещение). В Гугле вы увидите разное мнение, многие советуют не использовать Rebase, так как это может вызвать серьезные проблемы. В статье я объясню, что такое слияние и перемещение, почему вы должны (или не должны) использовать их и как это сделать.
Git Merge и Git Rebase преследуют одну и ту же цель. Они предназначены для интеграции изменений из одной ветки в другую. Хотя конечная цель одинаковая, принципы работы разные.
Некоторые считают, что вы всегда должны использовать Rebase, другие предпочитают Merge. В этом есть свои плюсы и минусы.
#### Git Merge
Слияние — обычная практика для разработчиков, использующих системы контроля версий. Независимо от того, созданы ли ветки для тестирования, исправления ошибок или по другим причинам, слияние фиксирует изменения в другом месте. Слияние принимает содержимое ветки источника и объединяет их с целевой веткой. В этом процессе изменяется только целевая ветка. История исходных веток остается неизменной.
**Плюсы:**
* простота;
* сохраняет полную историю и хронологический порядок;
* поддерживает контекст ветки.
**Минусы:**
* история коммитов может быть заполнена (загрязнена) множеством коммитов;
* отладка с использованием git bisect может стать сложнее.
**Как это сделать**
Слейте ветку master в ветку feature, используя команды *checkout* и *merge*.
```
$ git checkout feature
$ git merge master
(or)
$ git merge master feature
```
Это создаст новый «Merge commit» в ветке feature, который содержит историю обеих веток.
#### Git Rebase
Rebase — еще один способ перенести изменения из одной ветки в другую. Rebase сжимает все изменения в один «патч». Затем он интегрирует патч в целевую ветку.
В отличие от слияния, перемещение перезаписывает историю, потому что она передает завершенную работу из одной ветки в другую. В процессе устраняется нежелательная история.
**Плюсы:**
* Упрощает потенциально сложную историю
* Упрощение манипуляций с единственным коммитом
* Избежание слияния коммитов в занятых репозиториях и ветках
* Очищает промежуточные коммиты, делая их одним коммитом, что полезно для DevOps команд
**Минусы:**
* Сжатие фич до нескольких коммитов может скрыть контекст
* Перемещение публичных репозиториев может быть опасным при работе в команде
* Появляется больше работы
* Для восстановления с удаленными ветками требуется принудительный пуш. Это приводит к обновлению всех веток, имеющих одно и то же имя, как локально, так и удаленно, и это ужасно.
Если вы сделаете перемещение неправильно, история изменится, а это может привести к серьезным проблемам, поэтому убедитесь в том, что делаете!
**Как это сделать**
Переместите ветку feature на главной ветке, используя следующие команды.
```
$ git checkout feature
$ git rebase master
```
Это перемещает всю ветку функции в главную ветку. История проекта изменяется, создаются новые коммиты для каждого коммита в основной ветке.
#### Интерактивное перемещение
Это позволяет изменять коммиты при их перемещении в новую ветку. Это лучше, чем автоматическое перемещение, поскольку обеспечивает полный контроль над историей коммитов. Как правило, используется для очистки истории до слияния ветки feature в master.
```
$ git checkout feature
$ git rebase -i master
```
Это откроет редактор, перечислив все коммиты, которые будут перемещены.
```
pick 22d6d7c Commit message#1
pick 44e8a9b Commit message#2
pick 79f1d2h Commit message#3
```
Это точно определяет, как будет выглядеть ветка после выполнения перемещения. Упорядочивая объекты, вы можете сделать историю такой, как захотите. Вы можете использовать команды *fixup*, *squash*, *edit*, и так далее.
#### Какой из них использовать?
**Так что же лучше? Что рекомендуют эксперты?**
Трудно принять единственно правильное решение о том, что лучше использовать, поскольку все команды разные. Всё зависит от потребностей и традиций внутри команды.
Принимайте решения на основании компетенции команды в Git. Для вас важна простота или перезаписывание истории, а может быть что-то другое?
**Что рекомендую я?**
По мере роста команды становится сложно управлять или отслеживать изменения в разработке, применяя слияние. Чтобы иметь чистую и понятную историю коммитов, разумно использовать Rebase.
**Преимущества Rebase:**
* Вы разрабатываете локально: если вы не делились своей работой с кем-либо еще. На данный момент вы должны предпочесть перемещение слиянию, чтобы сохранить свою историю в порядке. Если у вас есть личная вилка репозитория, которая не используется совместно с другими разработчиками, вы можете делать rebase даже после того, как переместились в свою ветку.
* Ваш код готов к ревью: вы создали пулл реквест. Другие анализируют вашу работу и потенциально стягивают ее к своей вилке для локального ревью. На данный момент вы не должны перемещать свою работу. Вы должны создать коммит «переделать» и обновить ветку. Это помогает отслеживать запросы на пулл реквест и предотвращает случайную поломку истории.
* Ревью сделано и готово к интеграции в целевую ветку. Поздравляем! Вы собираетесь удалить свою ветку feature. Учитывая, что с этого момента другие разработчики не будут fetch-merging эти изменения, это ваш шанс изменить вашу историю. На этом этапе вы можете переписать историю и сбросить оригинальные коммиты, и эти надоедливые «переделки» и «слияние» сливаются в небольшой набор целенаправленных коммитов. Создание явного слияния для этих коммитов является необязательным, но имеет значение. Он записывает, когда функция достигла master.
Теперь вы знаете хоть и незначительную, но разницу между Merge и Rebase. Уверен, вы примете правильное решение и будете использовать то, что подходит именно вам.
*Не забывайте:*
```
code = coffee + developer
``` | https://habr.com/ru/post/432420/ | null | ru | null |
# rtorrent+rutorrent+nginx+php-fpm. Подводные камни
[Предыдущая статья](http://habrahabr.ru/blogs/linux/120167/) про связку rtorrent+rutorrent+nginx+php-fpm была написана сразу после успешной установки и начальной настройки этой связки. В процессе эксплуатации выявились некоторые подводные камни, о которых я и хочу рассказать.
#### RPC
Как оказалось, чтобы связка nginx с rutorrent+rtorrent работала нормально, достаточно в файле **conf/config.php** в дереве каталогов установки rutorrent прописать такие строчки:
`$scgi_port = 33333;
$scgi_host = "127.0.0.1";`
При этом в файле настроек rtorrent **~/.rtorrent.rc** достаточно прописать сетевой сокет:
`scgi_port = 127.0.0.1:33333`
В nginx больше не нужно писать backend для /RPC2, а из скриптов запуска rtorrent нужно убрать работу с локальным UNIX-сокетом для управления rtorrent.
#### Права доступа
Естественно, для того, чтобы rutorrent успешно работал, нужно пользователю, от имени которого работают демоны nginx и php-fpm, дать права на все файлы и каталоги установки rutorrent. В моём случае это делает команда:
`sudo chown -R http:http /srv/http/nginx/rutorrent.eternity/htdocs`
#### Сокет php-fpm
При локальном использовании php-fpm лучше посадить на UNIX-сокет. Для этого в файле **/etc/php/php-fpm.conf** необходимо закомментировать строчку с сетевым сокетом:
`;listen = 127.0.0.1:9000`
И вписать ниже строчку с UNIX-сокетом:
`listen = /var/run/php-fpm/php-fpm.sock`
После этого необходимо перенастроить nginx. В файле **/etc/nginx/conf/nginx.conf** приводим блок backend'а к такому виду:
````
upstream backend {
server unix:/var/run/php-fpm/php-fpm.sock;
}
````
Использование UNIX-сокетов уменьшает нагрузку на систему, так как не вычисляются контрольные суммы, а поток данных направляется непосредственно в принимающий буфер. Критично только для встраиваемых решений.
#### Безопасность
При локальном использовании nginx лучше всего посадить на 127.0.0.1. Для этого в файле **/etc/nginx/conf/sites-enabled/rutorrent.eternity** строчку **listen** следует привести к такому виду:
`listen 127.0.0.1:80;`
Если этого не сделать, веб-интерфейсом сможет воспользоваться тот, кто знает IP-адрес компьютера. Чтобы иметь возможность удалённо управлять rtorrent'ом, следует позаботиться об аутентификации (хотя бы через базовую аутентификацию nginx).
#### geoip
Для того, чтобы заработал модуль rutorrent под названием geoip, необходимо установить соответствующее расширение для PHP. В моём случае (*Arch Linux*) это действие выглядит так:
`sudo pacman -S php-geoip`
Потом в файле **/etc/php/conf.d/geoip.ini** необходимо снять комментарий с единственной строчки, чтобы она выглядела так:
`extension=geoip.so`
Также необходимо активировать плагин JSON. Делается это созданием в каталоге **/etc/php/conf.d** файла **json.ini** с таким содержимым:
`extension=json.so`
**Без плагина json ничего работать не будет.**
#### Вспомогательные программы
Для того, чтобы rutorrent нашёл дополнительные программы (*curl, stat, mediainfo*), во-первых, их нужно установить:
`sudo pacman -S curl mediainfo`
Во-вторых, необходимо разрешить их выполнение. Для этого в файле **/etc/php/php.ini** нужно закомментировать строчку open\_basedir:
`;open_basedir = /srv/http/:/home/:/tmp/:/usr/share/pear/`
И, в-третьих, требуется дополнительные программы прописать в конфигурации rutorrent. CURL и stat прописываются в файле **conf/config.php** дерева каталогов установки rutorrent таким образом:
````
$pathToExternals = array(
"php" => '',
"curl" => '/usr/bin/curl',
"gzip" => '',
"id" => '',
"stat" => '/usr/bin/stat',
);
````
Путь к программе mediainfo указывается в файле **plugins/mediainfo/conf.php** дерева каталогов установки rutorrent таким образом:
`$pathToExternals['mediainfo'] = '/usr/bin/mediainfo';`
Эти пути можно и не указывать, если для пользователя, от имени которого работают демоны веб-части связки, установлена переменная окружения PATH.
#### Вкусняшки
Лично для себя я сделал скрипт с таким содержимым:
````
#!/usr/bin/env bash
delay="1000"
pid1=`pidof rtorrent`
if [[ $pid1 != "" ]]
then
notify-send -t $delay "Останавливаю rtorrentd…"
sudo rc.d stop rtorrentd
notify-send -t $delay "rtorrentd остановлен"
else
notify-send -t $delay "Запускаю rtorrentd…"
sudo rc.d start rtorrentd
notify-send -t $delay "rtorrentd запущен"
fi
````
Этому скрипту даются права на выполнение:
`sudo chown root:root x-rtorrentd-wrapper.sh
sudo chmod 755 x-rtorrentd-wrapper.sh`
А сам скрипт перемещается в **/usr/bin**:
`sudo mv x-rtorrentd-wrapper.sh /usr/bin`
Потом где-то на панельке своего DE (*я всё делал в xfce*) вешается кнопка на запуск этого скрипта. Если rtorrent не запущен, то скрипт его запустит, а если запущен, то выключит, при этом выводя всплывающее оповещение на экран через libnotify. Конечно же, для этого нужно установить libnotify:
`sudo pacman -S libnotify`
#### Перезапуск демонов
После выполнения всех перечисленных действий необходимо перезапустить php-fpm и nginx:
`sudo rc.d restart php-fpm nginx`
В итоге шансы, что rutorrent полноценно заработает, существенно увеличиваются.
**UPDATE 1:** добавил некоторые объяснения.
**UPDATE 2:** обновил раздел с RPC. Спасибо [svin0](https://habrahabr.ru/users/svin0/). | https://habr.com/ru/post/121138/ | null | ru | null |
# Intel Parallel Studio XE 2016: новые возможности компилятора C/C++
На прошлой неделе вышла новая версия компилятора С/С++ от Intel — 16.0 aka Parallel Studio XE Composer Edition for C++. Существенно расширилась поддержка новых стандартов (C11, C++14, OpenMP 4.1), возможности по работе с Xeon Phi, вышли новые версии библиотек и ещё много всего «вкусного». Давайте более подробно посмотрим на то, что появилось в последнем релизе. Поехали!
* Добавлена поддержка SIMD операторов для работы с целочисленными типами SSE на Линуксе. Теперь следующие операторы работают: *+ — \* / & | ^ += -= \*= /= &= |= ^= == != > < >= <=*
Простой пример, который раньше не компилировался (не забываем инклудить *immintrin.h*):
```
__m128i x,y,z;
x = y + z;
```
Стоит отметить, что работает это только на Линуксе. Компилятор на Windows всё так же ругается: *operation not supported for these simd operands*
Кроме того, поддерживаются только 128 и 256 битные SIMD типы, и только форма с двумя операндами, как в примере. Сами операнды должны быть одного типа, например, типы SSE от Intel не могут использоваться вместе с GNU типами, объявленными с атрибутом *vector\_size*.
* Существенно расширилась поддержка стандартов. Пожалуй, это направление развития компилятора можно так же отнести к одной из самых главных в новой версии.
Так, если в версии 15 из стандарта C11 (для языка С, не путать с С++11) поддерживались только бинарные литералы (начинаются с префикса 0b или 0B), то сейчас есть практически [всё](https://software.intel.com/en-us/articles/c11-support-in-intel-c-compiler). Последний общедоступный драфт стандарта можно найти [здесь](http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf) в свободном доступе. Хорошей обзорной статьи на русском про С11 я не нашёл, поэтому про каждую возможность языка напишу более детально. Не забываем, что при компиляции нужно указывать ключ */Qstd=c11* на Windows и *-std=c11* на Linux и Mac OS X для того, чтобы всё это заработало:
+ Новые ключевые слова (как в C++11) для выравнивания данных *\_Alignas* и *\_Alignof*, позволяющие уйти от компиляторозависимых решений:
```
// массив cacheline выравнен по 64 байта
_Alignas(64) char cacheline[64];
printf("Alignment of char = %d\n", _Alignof(char));
```
Про необходимость и значимость выравнивания данных я уже писал [ранее](http://habrahabr.ru/company/intel/blog/262933/).
+ Выражения, не зависящие от типа, с использованием ключевого слова *\_Generic*. Это своего рода «шаблоны» из С++. Например, следующий макрос для извлечения квадратного корня *sqrt(x)* транслируется в *sqrtl(x)*, *sqrt(x)* или *sqrtf(x)* в зависимости от типа параметра *x*:
```
#define sqrt(x) _Generic((x), long double: sqrtl, default: sqrt, float: sqrtf)(x)
```
А ведь раньше приходилось хорошо потрудиться, чтобы реализовать это ручками [самому](http://habrahabr.ru/post/154811/)!
+ Спецификатор функции *\_Noreturn* позволяет объявлять функции, которые никогда не возвращаются в вызывающий код. Это позволяет избегать предупреждений от компилятора для функций, у которых нет return’а, а так же включать ряд оптимизаций, которые можно выполнять только над «невозвратными» функциями.
```
_Noreturn void func (); // func never returns
```
+ Новое ключевое слово *\_Static\_assert*, позволяющее выдавать ошибку компиляции в случае, если выражение равно нулю. Простой пример:
```
// ошибка во время компиляции
static_assert(sizeof(int) < sizeof(char), "app requires sizeof(char) to be less than char");
error: static assertion failed with "app requires sizeof(char) to be less than char"
```
В отличие от директив *#if* и *#error* позволяет отлавливать ошибки, которые трудно найти во время препроцессинга.
+ Анонимные структуры и объединения. Это некоммерческое общество анонимных алкоголиков… Шучу, просто проверил вашу концентрацию. Они используются для вложения структур и объединений. Например:
```
struct T // C11
{
int m;
union //анонимное объединение
{
char * index;
int key;
};
};
struct T t;
t.key=1300; //прямой доступ к члену объединения key
```
+ Особенность стандарта С11 в том, что он стандартизирует многопоточность в языке С. Конечно же, разработчики уже давным-давно используют блага параллельности в С, но, тем не менее, через библиотеки и другие расширения языка. Сейчас же это прописано в стандарте.
Так, одно из новых ключевых слов, поддерживаемое компилятором Intel, *\_Thread\_local*. С его помощью можно указать, что переменная не является общей для потоков и каждый из них получает свою локальную копию.
* По стандартам С и С++, компилятор не обязан соблюдать приоритет для вычислений выражений в скобках. Например, далеко не факт, что сложение *B* и *C* в выражении *A+(B+C)* будет выполнено в первую очередь, что приводит к различиям в численных результатах. Наконец появилась опция компилятора, которая отключает оптимизацию, меняющую порядок суммирования (реассоциацию) для типов с плавающей точкой. Теперь, если используются опции *-fprotect-parens* (Linux\* OS и OS X\*) или */Qprotect-parens* (Windows\*), порядок выполнения операций будет определяться расставленными скобками. Использование данной опции может несколько замедлить выполнение кода. По умолчанию, компилятор не включает данную опцию.
* Полностью реализовав поддержку С++11 в версии 15.0, разработчики компилятора вплотную занялись следующим – [С++14](http://isocpp.org/files/papers/N3797.pdf), который сейчас будет поддерживаться более чем на половину. Аналогично С11, есть [страничка](https://software.intel.com/en-us/articles/c14-features-supported-by-intel-c-compiler), на которой отслеживается поддержка различных возможностей стандарта в разных версиях компилятора. Включить поддержку С++14 можно опцией */Qstd=c++14* на Windows и *-std=c++14* на Linux и Mac OS X.
Итак, что же теперь поддерживается, начиная с нового релиза:
+ Обобщённые лямбда-функции
+ Захват выражений для лямбда-функций
+ Разделители разрядов
+ Атрибут [[deprecated]]
+ Вывод типа возвращаемого значения для функций
+ Агрегатная инициализация классов с инициализаторами полей
Более детальное описание этих возможностей стандарта можно без труда найти в сети, например, на [Вики](https://ru.wikipedia.org/wiki/C%2B%2B14), или в отличных постах на Хабре ([Ч1](http://habrahabr.ru/post/184606/) и [Ч2](http://habrahabr.ru/post/198238/)).
Так же появилась поддержка макросов (*Feature Test macros*), позволяющих определять поддержку той или иной возможности стандарта компилятором, или наличия хедера. Этот функционал пока ещё не в стандарте С++14, а только в TR, но обещает быть в скором времени. Простой пример:
```
#if __cpp_binary_literals
int const packed_zero_to_three = 0b00011011;
#else
int const packed_zero_to_three = 0x1B;
#endif
```
Теперь мы очень легко можем определить, поддерживаются ли компилятором бинарные литералы. Более подробно (например, найти табличку с именами макросов *\_\_cpp\_binary\_literals*, *\_\_cpp\_digit\_separators* и т.д.) ознакомиться с этой полезной возможностью можно [здесь](https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations).
* Добавлена очень полезная директива pragma block\_loop, позволяющая контролировать оптимизацию с разделением циклов на блоки (loop blocking), о которой я подробно писал в этом [посте](http://habrahabr.ru/company/intel/blog/265095/).
* Поддержка очередной версии стандарта OpenMP 4.1 ([Technical Report 3](http://openmp.org/TR3.pdf)), в основном расширяет возможности по работе с оффлодом (выгрузке) вычислений на сопроцессор Xeon Phi и другие возможные ускорители:
+ Появилась новая директива *omp target enter* data для того, чтобы мапить переменные на сопроцессор (возможно задавать *to* и *alloc* для опции *map*). Если директива *omp target* мапила переменные и выполняла код на устройстве, то *omp target data* только занимается данными. Соответственно, теперь имеется и директива *omp target exit data* для unmap’a переменных (возможно задавать *from*, *release* и *delete* для опции *map*).
+ Улучшены возможности по асинхронному выполнению кода. target регион теперь является задачей (task), поэтому возможен асинхронный оффлод с помощью существующей модели работы с задачами и опции *nowait* для директивы *omp task*.
+ Опция *depend* для директивы *omp task*, позволяющая реализовать выгрузку с зависимостями
+ Новые модификаторы *always* и *delete* для опции *map*
Кроме того, что в рамках OpenMP 4.1 существенно расширяются возможности по работе с ускорителями, так же доработана специфичная для компилятора Intel реализация работы с сопроцессорами:
+ Если раньше было невозможно передавать через указатель поле объекта для выгрузки на сопроцессор в виде *ptr->field*, то теперь это ограничение убрано. При этом появилась возможность передать структуры, поля которой являются указателями. Сами структуры в этом случае передаются побитово, указатели копируются, а вот поля структур, на которые они указывают, нет.
+ Стало возможным выделять память только на сопроцессоре, не выделяя память на хосте, с помощью модификаторов *targetptr* и *preallocated*.
+ Появилось понятие stream (и новая опция *stream* для директивы *pragma offload*) – логической очереди для выгрузок. С её помощью теперь можно выгрузить несколько независимых вычислений на Xeon Phi из одного CPU потока. Порядок работы такой:
Сначала, создаем стрим с помощью API функции *\_Offload\_stream\_create*:
```
OFFLOAD_STREAM* handle = _Offload_stream_create(
int device, // Intel MIC Architecture device number
int number_of_cpus); // Threads allocated to the stream
```
И оффлодим в стрим с помощью директивы *offload* и опции *stream*, указывая при этом сигнальное значение для идентификации выгрузки. Это поможет определить, выполнен ли тот или иной оффлод:
```
// Issue offload to a stream and identify with signal value s1
#pragma offload … stream(handle) signal(s1)
{ … }
…
// Issue offload to a stream and identify with signal value s2
#pragma offload … stream(handle) signal(s2)
{ … }
…
// Check if offload with signal value s1 has completed
if (_Offload_signaled(s1)) …
```
Гораздо больше деталей можно найти в нашей документации, которая была ощутимо расширены с выходом новой версии.
Кроме всего перечисленного, естественно вышли и новые версии всех библиотек (Intel IPP, TBB, MKL), где тоже можно найти много всего интересного. Кроме того, в дополнение к известным «трехбуквенным», добавилась новая библиотека Intel DAAL, о которой я уже рассказывал в [отдельном](http://habrahabr.ru/company/intel/blog/265347/) посте.Мой список улучшений и дополнений не является самым полным, но я постарался рассказать о наиболее значимых вещах. За бортом обзора остались изменения в Intel Cilk Plus, новые листинги с аннотациями от компилятора, улучшения скорости компиляции и ещё много мелких доработок. Пробуем самую [свежую версию](https://software.intel.com/en-us/intel-parallel-studio-xe), которая всё так же доступна с [пробной лицензией](https://registrationcenter.intel.com/en/forms/?productid=2271) на 30 дней (без каких-либо функциональных ограничений и с полной поддержкой) и делимся с нами вашим опытом! | https://habr.com/ru/post/265565/ | null | ru | null |
# Продолжаем удалять. [Re: Работа с «плохими» файлами в командной строке в Linux]
Как известно, мир GNU/Linux многообразен. Для одной и той же задачи существует множество решений.
Порой один линуксоид решает проблему, а второй смотрит на данный процесс и испытывает неуемное желание вмешаться, сделать по-своему. В подобных условиях и была рождена эта запись.
Топик, в котором была затронута тема удаления файлов с неправильными именами находится [здесь](http://habrahabr.ru/post/179597). Далее будут приведены иные методы решения той же задачи.
Предполагается, что использовать возможно только командную строку без файловых менеджеров. Под «правильным» файлом будем понимать файл с именем вида number.txt, под «неправильным» — все прочие.
#### Интерактивное удаление
Метод чрезвычайно удобен, если в директории находится небольшое количество файлов (либо можно выделить некое их подмножество с помощью wildcard), часть из которых нужно удалить.
Команда rm обладает опцией -i, которая запрашивает у пользователя подтверждение для удаления файла.
```
$ ls -lAh
-rw-r--r-- 1 user user 0 May 15 01:47 ?
-rw-r--r-- 1 user user 0 May 15 01:47 ?
-rw-r--r-- 1 user user 0 May 15 01:47 ?
-rw-r--r-- 1 user user 0 May 15 01:48 1.txt
-rw-r--r-- 1 user user 0 May 15 01:48 ?.txt
$ rm -i *
rm: remove regular empty file `\n'? y
rm: remove regular empty file `\v'? y
rm: remove regular empty file `\f'? y
rm: remove regular empty file `1.txt'? n
rm: remove regular empty file `\r.txt'? y
$ ls -lAh
-rw-r--r-- 1 user user 0 May 15 01:48 1.txt
```
Быстро и просто.
#### Отрицающий wildcard
Усложним задачу, создав 100 файлов с правильным названием и 100 неправильных:
```
$ touch {1..100}$'\x0a'.txt
$ touch {1..100}.txt
$ ls -A
? 15?.txt 22?.txt 2?.txt 37?.txt 44?.txt 51?.txt 59?.txt 66?.txt 73?.txt 80?.txt 88?.txt 95?.txt
? 16.txt 23.txt 30.txt 38.txt 45.txt 52.txt 5.txt 67.txt 74.txt 81.txt 89.txt 96.txt
? 16?.txt 23?.txt 30?.txt 38?.txt 45?.txt 52?.txt 5?.txt 67?.txt 74?.txt 81?.txt 89?.txt 96?.txt
100.txt 17.txt 24.txt 31.txt 39.txt 46.txt 53.txt 60.txt 68.txt 75.txt 82.txt 8.txt 97.txt
100?.txt 17?.txt 24?.txt 31?.txt 39?.txt 46?.txt 53?.txt 60?.txt 68?.txt 75?.txt 82?.txt 8?.txt 97?.txt
10.txt 18.txt 25.txt 32.txt 3.txt 47.txt 54.txt 61.txt 69.txt 76.txt 83.txt 90.txt 98.txt
10?.txt 18?.txt 25?.txt 32?.txt 3?.txt 47?.txt 54?.txt 61?.txt 69?.txt 76?.txt 83?.txt 90?.txt 98?.txt
11.txt 19.txt 26.txt 33.txt 40.txt 48.txt 55.txt 62.txt 6.txt 77.txt 84.txt 91.txt 99.txt
11?.txt 19?.txt 26?.txt 33?.txt 40?.txt 48?.txt 55?.txt 62?.txt 6?.txt 77?.txt 84?.txt 91?.txt 99?.txt
12.txt 1.txt 27.txt 34.txt 41.txt 49.txt 56.txt 63.txt 70.txt 78.txt 85.txt 92.txt 9.txt
12?.txt 1?.txt 27?.txt 34?.txt 41?.txt 49?.txt 56?.txt 63?.txt 70?.txt 78?.txt 85?.txt 92?.txt 9?.txt
13.txt 20.txt 28.txt 35.txt 42.txt 4.txt 57.txt 64.txt 71.txt 79.txt 86.txt 93.txt ?.txt
13?.txt 20?.txt 28?.txt 35?.txt 42?.txt 4?.txt 57?.txt 64?.txt 71?.txt 79?.txt 86?.txt 93?.txt
14.txt 21.txt 29.txt 36.txt 43.txt 50.txt 58.txt 65.txt 72.txt 7.txt 87.txt 94.txt
14?.txt 21?.txt 29?.txt 36?.txt 43?.txt 50?.txt 58?.txt 65?.txt 72?.txt 7?.txt 87?.txt 94?.txt
15.txt 22.txt 2.txt 37.txt 44.txt 51.txt 59.txt 66.txt 73.txt 80.txt 88.txt 95.txt
```
Случай немного надуманный, но позволяет показать новый метод. Предполагая, что нам нужны файлы вида number.txt, с помощью отрицающего wildcard выбираем, что удалить:
```
$ ls *[!0-9].txt
100?.txt 17?.txt 24?.txt 31?.txt 39?.txt 46?.txt 53?.txt 60?.txt 68?.txt 75?.txt 82?.txt 8?.txt 97?.txt
10?.txt 18?.txt 25?.txt 32?.txt 3?.txt 47?.txt 54?.txt 61?.txt 69?.txt 76?.txt 83?.txt 90?.txt 98?.txt
11?.txt 19?.txt 26?.txt 33?.txt 40?.txt 48?.txt 55?.txt 62?.txt 6?.txt 77?.txt 84?.txt 91?.txt 99?.txt
12?.txt 1?.txt 27?.txt 34?.txt 41?.txt 49?.txt 56?.txt 63?.txt 70?.txt 78?.txt 85?.txt 92?.txt 9?.txt
13?.txt 20?.txt 28?.txt 35?.txt 42?.txt 4?.txt 57?.txt 64?.txt 71?.txt 79?.txt 86?.txt 93?.txt ?.txt
14?.txt 21?.txt 29?.txt 36?.txt 43?.txt 50?.txt 58?.txt 65?.txt 72?.txt 7?.txt 87?.txt 94?.txt
15?.txt 22?.txt 2?.txt 37?.txt 44?.txt 51?.txt 59?.txt 66?.txt 73?.txt 80?.txt 88?.txt 95?.txt
16?.txt 23?.txt 30?.txt 38?.txt 45?.txt 52?.txt 5?.txt 67?.txt 74?.txt 81?.txt 89?.txt 96?.txt
```
Убедившись, что всё в порядке, удаляем эти файлы.
```
$ rm *[!0-9].txt
```
#### find
Внимательный читатель вероятно заметил, что в предыдущем примере я пропустил 3 неправильных файла. Исправлюсь.
В директории находится 100 файлов вида number.txt и 3 файла с неким непонятным названием.
Одним из методов выделения ненужных нам файлов является find в связке с xargs (старый добрый обычай ~~бородатых~~ администраторов \*nix связывать утилиты через pipe)
```
$ find . -type f -not -name '*txt'
./?
./?
./?
$ find . -type f -not -name '*.txt' | xargs rm
rm: cannot remove `./': Is a directory
```
Хм, какой-то из файлов оказался назойливым.
```
% ls -A
? 15.txt 21.txt 28.txt 34.txt 40.txt 47.txt 53.txt 5.txt 66.txt 72.txt 79.txt 85.txt 91.txt 98.txt
100.txt 16.txt 22.txt 29.txt 35.txt 41.txt 48.txt 54.txt 60.txt 67.txt 73.txt 7.txt 86.txt 92.txt 99.txt
10.txt 17.txt 23.txt 2.txt 36.txt 42.txt 49.txt 55.txt 61.txt 68.txt 74.txt 80.txt 87.txt 93.txt 9.txt
11.txt 18.txt 24.txt 30.txt 37.txt 43.txt 4.txt 56.txt 62.txt 69.txt 75.txt 81.txt 88.txt 94.txt
12.txt 19.txt 25.txt 31.txt 38.txt 44.txt 50.txt 57.txt 63.txt 6.txt 76.txt 82.txt 89.txt 95.txt
13.txt 1.txt 26.txt 32.txt 39.txt 45.txt 51.txt 58.txt 64.txt 70.txt 77.txt 83.txt 8.txt 96.txt
14.txt 20.txt 27.txt 33.txt 3.txt 46.txt 52.txt 59.txt 65.txt 71.txt 78.txt 84.txt 90.txt 97.txt
```
Как видим, он единственный.
#### extglob
Bash имеет множество опций. Нас интересует extglob — использование расширенных возможностей сравнения с образцом(pattern matching).
```
$ shopt extglob
extglob off
$ shopt -s extglob
$ shopt extglob
extglob on
```
После включения опции пользователю становится (в частности) доступна возможность применения «отрицающего wildcard», действующего целиком на список образцов:
```
$ ls !(*.txt)
?
$ rm !(*.txt)
$ ls * | wc
100 100 692
```
Осталось 100 правильных файлов, успех!
Отключаем extglob, если он больше не нужен:
```
$ shopt -u extglob
```
Спасибо за внимание.
Использованные материалы:
man rm
man bash
man find | https://habr.com/ru/post/179837/ | null | ru | null |
# Мысли об ООП
Очередная статья про «азы программирования на C++» меня подтолкнула к мысли, что многие программисты не понимают сути объектно-ориентированного программирования (ООП).
В частности, в этой статье утверждается, что
`"С++ очень прост в том смысле, что классы С++ повторяют описание объектов реального мира. "`
Довольно давно на одном из форумов я наткнулся на рассуждения еще одного программиста, который хотел запрограммировать систему хранения «универсальных» объектов и рассуждал о том, «является ли стул — объектом».
Оба эти человека так или иначе заблуждаются насчет ООП.
Объекты в ООП, как правило, никакого отношения к объектам в реальном мире не имеют. Более того, даже если мы соберем в одном месте (в записи) набор некоторых характеристик чего угодно, то это все равно не будет объект в понимании ООП.
Путаница часто возникает еще и из-за затасканного слова «объект». Да еще и понятия «класс» и «объект» часто смешивают.
Итак, простое правило, которое позволит легко понять, где ООП, а где — нет.
~~Фары и ремень~~
**ПОВЕДЕНИЕ И СОСТОЯНИЕ**
Более развернуто, класс объектов (в понимании ООП) используют, если…
**… у некоторой сущности есть поведение, зависящее от внутреннего состояния этой сущности.**
Что значит «у сущности есть состояние»? Давайте разберемся.
У экземпляра сущности есть набор собственных данных — это очевидно. В чем отличие от обычной записи (структуры)?
Прежде всего, состояние подразумевает, что часть данных в сущности используются «для себя», для реализации собственного поведения. Если сущности «нечего скрывать», то она вырождается в обыкновенную запись данных. Более того, понятие «состояния» является более строгим, чем просто «дополнительный набор данных». Оно предполагает некоторую связанность, взаимозависимость этих внутренних данных. Состояние может быть корректным и некорректным. А кто может это понять? Внешний наблюдатель? Нет, только сама сущность. Таким образом, состояние скрыто не просто так, оно защищено от повреждения некомпетентным пользователем сущности.
Теперь уже проясняется, что такое «поведение» сущности. Это когда сущность реализует какой-то функционал, сохраняя корректность состояния.
Давайте какой-нибудь простой пример возьмем. Есть товар: наименование, цена за единицу, остаток на складе. Это объект ООП?
Подумайте прежде чем читать дальше.
Если не накладывать никаких ограничений на его характеристики — нет. Состояния не возникает.
Мы можем заносить любые значения. Скрывать нечего.
Давайте введем ограничения — остаток не может быть отрицательным, а цена обязана быть положительной.
А теперь?
Может теперь внешний пользователь произвольно менять данные в товаре? Очевидно, нет. У нашего товара появилось поведение — уменьшение остатка означает «забрать товар в определенном количестве» и забрать больше чем остаток — нельзя.
Заметили, что произошло? Мы ввели ограничения, то есть внесли некий смысл в природу свойств сущности. И сразу же появилось осмысленное поведение — «внести товар», «забрать товар».
Другой пример. Предположим в программе требуется динамическая загрузка модулей. Есть состояние — набор уже загруженных модулей. И поведение легко просматривается — «загрузить модуль», «выгрузить модуль». К чему этот пример? К тому, что никакой связи с объектами в реальном мире здесь и в помине нет.
Связывать природу классов в ООП с природой объектов реального мира — довольно абсурдная и бессмысленная затея. Природа сущности будет определяться не реальным миром, а системой и зависеть от окружения сущности, от ее использования, от взаимосвязи компонент.
Вот и все. Можно называть это инкапсуляцией. А можно и не называть. Можно долго рассуждать на тему наследования. А можно просто понять, что «наследование» — это способ расширения поведения объекта.
Главное — понять, что ООП нужно программисту, чтобы контролировать сложность разработки. А не для того, чтобы «отражать объекты реального мира».
**UPD**
Ладно, продолжим кидаться умными словами.
Абстракция и полиморфизм не имеют прямого отношения к ООП. Как ни странно.
Любая процедура или функция являются абстракцией. Любая. Вот объявление:
void sort(int\* array, int size);
Эта функция является абстракцией. Она реализует сортировку. Абстрактно. Мы не знаем как.
Но на выходе будет отсортированный массив. Абстракция есть, а где тут ООП? Нету ООП. Ни объектов, ни классов.
Теперь я объявил указатель sort. И могу ему присвоить такую функцию:
void quick\_sort(int\* array, int size)
или такую:
void bubble\_sort(int\* array, int size).
Возник полиморфизм. Указатель на функцию остался прежним. Но теперь за одним и тем же указателем на функцию стоят разные алгоритмы.
А где ООП? ООП нету. Потому что это даже не C++, это C. В котором нету классов. А абстракция и полиморфизм достигнуты.
Угу?
**UPD2**
`Хм: Для ООП не обязательно иметь какие-то там классы ;)
Берем обычный C, делаем структуры с указателями на функции, договариваемся первым аргументом всегда передавать указатель на this и не обращаться к членам структуры, не являющимся указателями на функции, иначе, чем через этот this. Чем не ООП?
В python, например, нельзя спрятать данные (по крайней мере без особых ухищрений) - он не является ООП языком?`
Вот именно. Я как раз об этом :-) Я же нигде вообще ни строчки ни написал о том, что C++ — это обязательно ООП. А все остальное — якобы нет.
ООП — это не возможности языка. НЕТ! Это архитектура приложения, способ моделирования предметной области. При котором используется разделение на сущности по принципу, описанному в статье.
Возможности языка могут облегчать применение принципов ООП, могут не мешать, а могут усложнять применение этих принципов. Но принципы от этого не меняются.
Я могу на C++ сделать «плохой» класс. Который нарушает принцип согласованного изменения состояния.
А могу на C или на Питоне реализовать «правильный» ООП. Или даже на ассемблере. Я выделю сущности и не позволю изменять их состояние извне.
Основная мысль моей статьи не о возможностях компиляторов.
А о ситуации, когда программист, использующий ООП, размышляет — «нужен тут класс (объектов) или не нужен».
Если есть состояние с поведением — нужен, иначе — не нужен.
Как он будет реализовывать это на своем инструменте программирования — мне не важно. | https://habr.com/ru/post/111125/ | null | ru | null |
# Эксплуатируемая уязвимость в почте Mail.ru
Услышав сегодня на одном из новостных сайтов, что Mail.ru обновили свой поисковый интерфейс, зашёл туда, чтобы узреть его.
Не увидел ничего нового в интерфейсе, писем во «Входящих» не было. Лениво щёлкнул на папочке «Спам», поглядел письма и… Обнаружил, что пришло новое письмо. Письмо было от Mail Delivery System (Mailer-Daemon@prof1.mail.ru). Содержало оно сообщение, что моё письмо не было доставлено уйме адресатов из-за того, что было посчитано спамом. Я же себя считал достаточно вменяемым, чтобы понимать, что такого письма я не слал.
Если предисловие вас заинтересовало, продолжу.
Вернулся в «Спам» на то самое письмо, нажал «F5». Новое письмо о спаме. Посмотрел исходник письма. Привожу только тело:
`----ALT--ZBQj2NTm1312448872
Content-Type: text/plain; charset=koi8-r
Content-Transfer-Encoding: base64
dnRpankgZml1cHcga3ZrZHpvIHNsc2J2ciBxY25odCA=
----ALT--ZBQj2NTm1312448872
Content-Type: text/html; charset=koi8-r
Content-Transfer-Encoding: base64
CjxIVE1MPjxCT0RZPnZ0aWp5IGZpdXB3IDxhIGhyZWY9Imh0dHA6Ly9wb2h1ZGV0Zm9ydW1mb3Rr
aW0uYmxvZ3Nwb3QuY29tIj5rdmtkem8gc2xzYnZyIHFjbmh0IDwvYT48aW1nIHNyYz1odHRwOi8v
aW5mbzIzMmluZm9ybWF0aW8uY29tL2ZyaWVuZC5naWYgd2lkdGg9MT48L0JPRFk+PC9IVE1MPgo=
----ALT--ZBQj2NTm1312448872--`
Распаковав BASE64 получаем нижеследующий HTML-код:
`vtijy fiupw [kvkdzo slsbvr qcnht](http://pohudetforumfotkim.blogspot.com) `
Ничего особо страшного. Ссылочка, картинка. Тело HTML отличается от текста. Неважно.
Посмотрел исходник страницы собственно mail.ru… А там среди уймы мусорного кода:
[](https://habrastorage.org/files/044/b85/e48/044b85e48f144234a096558f33d6bfe4.png)
Тоже, как оказалось, ничего страшного здесь нет.
А проблема кроется в этой самой картинке, friend.gif. При наличии реферера с mail.ru, она даёт редирект на
[](https://habrastorage.org/files/988/19a/9d3/98819a9d30654de89859e544703d7476.png)
И вот этот GET-запрос(!) отправляет почту большому количеству адресатов.
Будем надеятся, проблему исправят быстро. Копию отправлю в Mail.ru, делюсь с уважаемым сообществом, т.к. уязвимость уже эксплуатируется.
Мораль же сей басни проста. Всегда стоит соблюдать RFC, согласно которому GET-запросы не должны менять состояние сервера. Надеюсь, начинающие разработчики правильно поймут важность этого простого правила. | https://habr.com/ru/post/126740/ | null | ru | null |
# Как автоматизировать сбор KPI за месяц и оставить пользователей почти довольными
Во многих организациях оценка подразделений осуществляется с использованием KPI (Key Performance Indicators). В организации, где я работаю, такая система называется «системой показателей деятельности», а в этой статье я хочу рассказать о том, как у нас получилось автоматизировать часть работы с показателями уложившись в месяц. При всем этом трудозатраты наши оказались не самыми большими, а заодно мы попробовали реализовать некоторые давние хотелки. В моем рассказе не будет хайповых технологий или откровений (все-таки провинциальная разработка сурова), зато будут некоторые зарисовки на тему, которые помогут понять, с чего мы начали, что у нас получилось, а также какие мысли появились у нас по итогам разработки. Если вам еще не стало скучно, прошу под кат.
### Предыстория
В далеком уже 2006 году у нас была введена система показателей эффективности деятельности: разработано пятнадцать критериев оценки, методика их расчета, установлена ежеквартальная периодичность подсчета этих показателей. Оценка проводилась для двадцати двух филиалов организации, расположенных во всех районах нашего региона. А чтобы показатели достигались с большим энтузиазмом к ним была привязана премия – чем выше сумма показателей, тем выше место в рейтинге, чем выше место в рейтинге, тем выше премия и так каждый квартал и каждый год.
Со временем менялся состав критериев, каждый квартал то добавлялись новые, то исключались старые. На пике, примерно в 2016 году, количество показателей превышало сорок, а сейчас их всего четырнадцать.
Однако все это время процесс их расчета был однотипен. Каждый критерий рассчитывается ответственным подразделением головной организации по утвержденному именно для этого критерия алгоритму. Расчет может вестись как по простой формуле, так и по ряду сложных, может требовать сбора данных из нескольких систем, при всем этом весьма вероятно, что алгоритм будет меняться достаточно часто. А дальше все уже намного проще: рассчитанный в процентах показатель умножается на свой коэффициент, таким образом, получается балл по критерию, далее баллы ранжируются и каждое подразделение занимает место в соответствии с баллом. То же самое делается и с суммой баллов для подсчета итогового места.
С самого начала для того, чтобы учесть и подсчитать все описанное выше использовался Excel. Многие годы окончательный свод критериев и дальнейший расчет баллов и мест производился в симпатичной табличке, часть которой приведена на рисунке
Замечу только, что в этой симпатичной табличке, большая часть колонок попросту скрыта, а в реальности в 4 квартале 2016 года она выглядела так
Согласитесь, такое количество показателей и такой объем таблицы не прибавляют ей простоты. Кроме того каждый из критериев рассчитывался отдельно, а эту сводную таблицу руками делали девушки из общего отдела. Учитывая то, что менялся не только состав критериев, но и расчеты могли переделываться по нескольку раз (на то есть много причин), последние дни каждого квартала, мягко говоря, не радовали. Приходилось постоянно менять данные в таблице, проверять и перепроверять их: вот так забудешь новую колонку добавить в сумму баллов или коэффициент не обновишь, а у кого-то из-за этого место становится ниже, а с ним и премия меньше. Поэтому после героического сведения таблицы начиналась не менее героическая проверка, проверяли и согласовывали все те, кто считал каждый критерий, руководители и даже организационно закрепленный ИТ-специалист. Учитывая, что вся работа выполнялась вручную, а расчеты показателей для сводной таблицы направлялись на почту, достаточно часто возникали ситуации, когда в сводной таблице были и ошибки в формулах и данные неактуальных версий. Капитан очевидность сообщает, что после выявления каждой ошибки процесс проверки запускался заново.
Когда все показатели подсчитаны, табличка утверждена и разослана по филиалам, там, в филиалах ее перепроверяли: а вдруг коварный Excel посчитал что-то не так? Думаю, очевидно, что составление годового отчета по критериям или анализ исторических данных оказывался не менее увлекательным квестом.
Однако с управленческой точки зрения такая система достаточно эффективна и позволяет при необходимости подтянуть проседающие направления работы, вести мониторинг и иметь представление, что же происходит в каждом из филиалов по тому или иному направлению работы. Кроме того, место филиала, рассчитанное по критериям, было интегральным показателем.
### Система должна измениться
Практика доказывала необходимость и важность системы оценки. В начале 2017 года стало ясно, что расчет критериев раз в квартал позволял оценить проделанную работу, но вот мониторить ее позволял слабо. Слишком уж большой промежуток времени. В связи с этим решили, что расчет показателей станет проводиться раз в две недели, а итоги будут подводиться все так же ежеквартально. Увеличение частоты расчета действительно позволило руководителям филиалов оперативно реагировать на изменения и повысить контроль над процессами внутри их подразделений.
Вот только в головной организации мало кого радовала перспектива выполнять описанный выше процесс свода данных не ежеквартально, а каждые две недели. Как не трудно догадаться, процесс решили автоматизировать. Сроки оказались сжатыми: от момента принятия решения о переходе на новую периодичность подсчета до собственно перехода должен был пройти всего месяц. За этот срок очень желательно было придумать нечто лучшее, чем связка Excel для свода и расчета, а почты для сбора и оповещения.
Сначала шли достаточно жарки дискуссии о том, что очень-очень надо сделать автоматическим и сам расчет показателей с учетом всех их формул и источников данных. Но учитывая сжатые сроки, сложность такой функциональности и необходимость ее постоянного поддержания в актуальном состоянии удалось прийти к следующим требованиям к системе:
* Должен вестись справочник критериев, сохраняющий историю их изменения;
* Должна быть предусмотрена возможность ввода и хранения рассчитанных показателей, а также их преобразования в баллы как в той самой табличке;
* По значениям показателей должен формироваться отчет, доступный всем заинтересованным сторонам;
* Естественно все это должно быть снабжено веб-интерфейсом.
Функциональность совсем небольшая, но и времени немного.
### Начало разработки
Меня всегда привлекали средства быстрой разработки и автоматической генерации интерфейсов. В тех случаях, когда надо реализовывать функциональность CRUD, очень заманчивой кажется идея, когда интерфейс и часть бизнес-логики будут предоставлены так сказать из коробки. Конечно, и интерфейс будет непритязательным и логика топорной, но для многих задач этого достаточно.
Движимый этими идеями я решил попробовать что-нибудь подобное. Существуют Spring Roo, Cuba и другие интересные инструменты, но выбор пал на OpenXava. Во-первых когда-то я уже делал на ней совсем уж простенькое приложение и остался доволен, во-вторых этот фреймворк на тот момент достаточно удачно вписывался в наш технологический стек. Кроме того, очень радует наличие краткого туториала на русском языке.
Краткое описание особенностей и возможностей OpenXava можно прочитать [здесь](http://openxava.org/OpenXavaDoc/docs/reference_ru.html). OpenXava — это фреймворк, реализующий автоматическое построение веб интерфейса, интегрированного с базой данных, на основе JPA, и использующий аннотации для описания правил визуализации. В основе приложения лежат бизнес-компоненты – Java-классы, содержащие информацию, необходимую для создания приложений. К такой информации относится структура данных, валидаторы, допустимые представления, маппинг на таблицы базы данных. Операции над бизнес-компонентами осуществляются посредством контроллеров, из коробки умеющих CRUD, поиск, экспорт в PDF и т.п. Приложение OpenXava представляет набор модулей. Модуль связывает бизнес-компонент с одним или более контроллерами. Для отображения интерфейса используются представления, определяемые для каждого бизнес-компонента. Ничего необычного, MVC с немного своей атмосферой.
### Хранение данных
В большинстве приложений мы используем СУБД IBM DB2. Была создана небольшая база данных, хранящая справочники групп критериев и критериев, по которым ведется оценка филиалов, справочник филиалов ну и табличку, в которую заносятся рассчитанные значения критериев. Каждому критерию на определенный момент времени сопоставляется коэффициент, который будет использоваться при подсчете баллов. Каждый филиал, по каждому критерию получает оценку также на определенную дату. Данные о значениях критериев хранятся исторически, то есть актуальными на какую-либо дату данными будут являться те, которые были внесены на ближайшую дату в прошлом. Этот подход, навеянный регистрами сведений из 1С: Предприятие, мне кажется достаточно удобным: и история есть и с вопросами редактирования/удаления можно не особо париться.
**Структура базы данных**
```
CREATE TABLE SUMMAR.CLS_DEPART
(
ID BIGINT NOT NULL GENERATED BY DEFAULT AS IDENTITY,
PARENT_ID BIGINT NOT NULL DEFAULT 0,
IS_DELETED INT DEFAULT 0,
NAME CLOB,
CODE VARCHAR(255),
PRIMARY KEY (ID)
);
CREATE TABLE SUMMAR.CLS_CRITERIA
(
ID BIGINT NOT NULL GENERATED BY DEFAULT AS IDENTITY,
IS_DELETED INT DEFAULT 0,
NAME CLOB,
CODE VARCHAR(255),
PRIMARY KEY (ID)
);
CREATE TABLE SUMMAR.CLS_GROUP_CRITERIA
(
ID BIGINT NOT NULL GENERATED BY DEFAULT AS IDENTITY,
IS_DELETED INT DEFAULT 0,
NAME CLOB,
CODE VARCHAR(255),
PRIMARY KEY (ID)
);
CREATE TABLE SUMMAR.REG_STATE_CRITERIA
(
ID BIGINT NOT NULL GENERATED BY DEFAULT AS IDENTITY,
ID_CRITERIA BIGINT NOT NULL,
ID_GROUP_CRITERIA BIGINT NOT NULL,
TIME_BEGIN TIMESTAMP NOT NULL DEFAULT CURRENT TIMESTAMP,
TIME_END TIMESTAMP NOT NULL DEFAULT
'9999-12-31-23.59.59.000000000000',
TIME_CREATE TIMESTAMP NOT NULL DEFAULT CURRENT TIMESTAMP,
KOEFFICIENT DECIMAL(15, 2),
PRIMARY KEY (ID),
CONSTRAINT FK_CRITERIA FOREIGN KEY (ID_CRITERIA) REFERENCES
SUMMAR.CLS_CRITERIA(ID) ON DELETE NO ACTION ON UPDATE RESTRICT,
CONSTRAINT FK_GROUP_CRITERIA FOREIGN KEY (ID_GROUP_CRITERIA) REFERENCES
SUMMAR.CLS_GROUP_CRITERIA(ID) ON DELETE NO ACTION ON UPDATE RESTRICT
);
CREATE TABLE SUMMAR.REG_VALUE_CRITERIA
(
ID BIGINT NOT NULL GENERATED BY DEFAULT AS IDENTITY,
ID_CRITERIA BIGINT NOT NULL,
ID_GROUP_CRITERIA BIGINT NOT NULL,
ID_DEPART BIGINT NOT NULL,
DATE_REG TIMESTAMP(12) NOT NULL DEFAULT CURRENT TIMESTAMP,
TIME_END TIMESTAMP NOT NULL DEFAULT
'9999-12-31-23.59.59.000000000000',
TIME_BEGIN TIMESTAMP NOT NULL DEFAULT CURRENT TIMESTAMP,
PERCENT DECIMAL(15, 5),
VAL DECIMAL(15, 5),
PRIMARY KEY (ID),
CONSTRAINT FK_CRITERIA FOREIGN KEY (ID_CRITERIA) REFERENCES
SUMMAR.CLS_CRITERIA(ID) ON DELETE NO ACTION ON UPDATE RESTRICT,
CONSTRAINT FK_DEPART FOREIGN KEY (ID_DEPART) REFERENCES
SUMMAR.CLS_DEPART(ID) ON DELETE NO ACTION ON UPDATE RESTRICT,
CONSTRAINT FK_GROUP_CRITERIA FOREIGN KEY (ID_GROUP_CRITERIA) REFERENCES
SUMMAR.CLS_GROUP_CRITERIA(ID) ON DELETE NO ACTION ON UPDATE RESTRICT
);
```
Для того, чтобы получить из базы заветный отчет о показателях филиалов были созданы хранимые функции, результаты которых уже мапятся на Java-класс. Функции выглядят примерно так.
**Сначала получим все действующие на дату критерии, а также актуальные на эту дату коэффициенты критерия**
```
CREATE OR REPLACE FUNCTION
SUMMAR.SLICE_STATE_ALL_CRITERIA (
PMAX_TIME TIMESTAMP
)
RETURNS TABLE (
ID_CRITERIA BIGINT,
ID_GROUP_CRITERIA BIGINT,
TIME_BEGIN TIMESTAMP,
TIME_END TIMESTAMP,
TIME_CREATE TIMESTAMP,
KOEFFICIENT DECIMAL(15, 2)
)
LANGUAGE SQL
RETURN
SELECT
RSC.ID_CRITERIA,
RSC.ID_GROUP_CRITERIA,
RSC.TIME_BEGIN,
RSC.TIME_END,
RSC.TIME_CREATE,
RSC.KOEFFICIENT
FROM
SUMMAR.REG_STATE_CRITERIA AS RSC
INNER JOIN
(
SELECT
ID_CRITERIA,
MAX(TIME_BEGIN) AS TIME_BEGIN
FROM
(
SELECT DISTINCT
ID_CRITERIA,
TIME_BEGIN
FROM
SUMMAR.REG_STATE_CRITERIA
WHERE
TIME_BEGIN < PMAX_TIME
AND TIME_END > PMAX_TIME
)
AS SL
GROUP BY
ID_CRITERIA
)
AS MAX_SLICE
ON RSC.ID_CRITERIA = MAX_SLICE.ID_CRITERIA
AND RSC.TIME_BEGIN = MAX_SLICE.TIME_BEGIN ;
```
**Теперь получим на эту же дату значения всех критериев по всем филиалам**
```
CREATE OR REPLACE FUNCTION
SUMMAR.SLICE_VALUE_ACTUAL_ALL_CRITERIA_ALL_DEPART_WITH_NAMES (
PMAX_TIME TIMESTAMP
)
RETURNS TABLE (
ID_CRITERIA BIGINT,
ID_GROUP_CRITERIA BIGINT,
ID_DEPART BIGINT,
DATE_REG TIMESTAMP,
PERCENT DECIMAL(15, 2),
VAL DECIMAL(15, 2),
KOEFFICIENT DECIMAL(15, 2),
CRITERIA_NAME CLOB,
CRITERIA_CODE VARCHAR(255),
GROUP_CRITERIA_NAME CLOB,
GROUP_CRITERIA_CODE VARCHAR(255),
DEPART_NAME CLOB,
DEPART_CODE VARCHAR(255),
DEPART_CODE_INT INT
)
LANGUAGE SQL
RETURN
SELECT
CDEP.ID_CRITERIA,
COALESCE(VALS.ID_GROUP_CRITERIA, 0) AS ID_GROUP_CRITERIA,
CDEP.ID_DEPART,
VALS.DATE_REG,
COALESCE(VALS.PERCENT, 0.0) AS PERCENT,
COALESCE(VALS.VAL, 0.0) AS VAL,
COALESCE(VALS.KOEFFICIENT, 0.0) AS KOEFFICIENT,
CDEP.CRITERIA_NAME,
CDEP.CRITERIA_CODE,
COALESCE(VALS.GROUP_CRITERIA_NAME, '') AS GROUP_CRITERIA_NAME,
COALESCE(VALS.GROUP_CRITERIA_CODE, '') AS GROUP_CRITERIA_CODE,
CDEP.DEPART_NAME,
CDEP.DEPART_CODE,
CDEP.DEPART_CODE_INT
FROM
(
SELECT
CCRT.ID AS ID_CRITERIA,
CCRT."NAME" AS CRITERIA_NAME,
CCRT.CODE AS CRITERIA_CODE,
CDEP.ID AS ID_DEPART,
CDEP."NAME" AS DEPART_NAME,
CDEP.CODE AS DEPART_CODE,
CAST (CDEP.CODE AS INT) AS DEPART_CODE_INT
FROM
SUMMAR.CLS_DEPART AS CDEP,
(
SELECT
*
FROM
SUMMAR.CLS_CRITERIA AS CC
INNER JOIN
TABLE(SUMMAR.SLICE_STATE_ALL_CRITERIA (PMAX_TIME)) AS ACTC
ON CC.ID = ACTC.ID_CRITERIA
WHERE
CC.IS_DELETED = 0
)
AS CCRT
WHERE
CDEP.IS_DELETED = 0
)
AS CDEP
LEFT JOIN
(
SELECT
VALS.ID_CRITERIA,
VALS.ID_GROUP_CRITERIA,
VALS.ID_DEPART,
VALS.DATE_REG,
VALS.PERCENT,
VALS.VAL,
VALS.KOEFFICIENT,
CGRT."NAME" AS GROUP_CRITERIA_NAME,
CGRT.CODE AS GROUP_CRITERIA_CODE
FROM
TABLE(SUMMAR.SLICE_VALUE_ACTUAL_ALL_CRITERIA (PMAX_TIME)) AS VALS
INNER JOIN
SUMMAR.CLS_GROUP_CRITERIA AS CGRT
ON VALS.ID_GROUP_CRITERIA = CGRT.ID
)
as VALS
ON CDEP.ID_DEPART = VALS.ID_DEPART
AND CDEP.ID_CRITERIA = VALS.ID_CRITERIA
;
```
**В итоговом запросе пронумеруем значения показателей, ранжируем их и найдем минимальный и максимальный, это понадобится, чтобы потом рассчитать места**
```
SELECT
ROW_NUMBER() OVER() AS ID_NUM,
RANK() OVER(
PARTITION BY ID_CRITERIA
ORDER BY VAL DESC
) AS RATING,
CASE
WHEN MAX(RANK() OVER(
PARTITION BY ID_CRITERIA
ORDER BY VAL DESC
)
) OVER() = RANK() OVER(
PARTITION BY ID_CRITERIA
ORDER BY VAL DESC
)
THEN 1
ELSE 0
END AS MAX_RATING,
CASE
WHEN MIN(RANK() OVER(
PARTITION BY ID_CRITERIA
ORDER BY VAL DESC
)
) OVER() = RANK() OVER(
PARTITION BY ID_CRITERIA
ORDER BY VAL DESC
)
THEN 1
ELSE 0
END AS MIN_RATING,
VALS.*
FROM TABLE(SUMMAR.SLICE_VALUE_ACTUAL_ALL_CRITERIA_ALL_DEPART_WITH_NAMES (?))
AS VALS
ORDER BY GROUP_CRITERIA_CODE,
CRITERIA_CODE,
DEPART_CODE_INT
```
Перенос части бизнес-логики в СУБД оказывается достаточно оправданным, особенно, когда дело касается подготовки данных для разных отчетов. Операции получается записать в более лаконичной и естественной форме, на Java такие манипуляции с данными потребовали бы и большего объема кода и определенных усилий по его структуризации. Хотя относительно сложные или нетривиальные операции все же проще запрограммировать на Java. Поэтому в нашем приложении в отношении выборки данных используется подход, когда соединение наборов данных, отсечение условиям и некоторые операции, которые можно выполнить оконными функциями, выполняются в хранимых функциях и процедурах, а более сложная логика реализуется в приложении.
### Приложение
Как я уже говорил, для реализации приложения использовалась OpenXava. Чтобы получить с ее помощью типовой интерфейс и CRUD из коробки необходимо выполнить некоторые действия.
Начнем с того, что в web.xml надо описать фильтр и сервлет из аддона, осуществляющего навигацию по приложению:
**web.xml**
```
naviox
com.openxava.naviox.web.NaviOXFilter
naviox
\*.jsp
naviox
/modules/\*
REQUEST
FORWARD
naviox
naviox
naviox
module
naviox
com.openxava.naviox.web.NaviOXServlet
naviox
/m/\*
```
Далее в файле controllers.xml определим используемые в приложении контроллеры. В нашем случае достаточно самого простого:
**controllers.xml**
```
```
В приведенном контроллере объединены функции включенных в OpenXava по умолчанию контроллеров, о функциях которых нетрудно догадаться из названий.
И, наконец, в файле application.xml свяжем созданный контроллер и модель. Примерно так:
**application.xml**
```
```
Как было сказано выше в основе приложения лежат бизнес-компоненты, составляющие модель приложения. Для примера рассмотрим связанный с контроллером в application.xml компонент RegValueCriteria. Этот компонент описывает значение критерия по филиалу (для краткости оставлено только описание полей класса, а методы типа геттеров и сеттеров опущу):
**Класс компонента**
```
@Entity
@Table(name = "REG_VALUE_CRITERIA", catalog = "", schema = "SUMMAR")
@XmlRootElement
@Views({
@View(members = "idCriteria [idCriteria];"
+ "idGroupCriteria [idGroupCriteria];"
+ "idDepart [idDepart];"
+ "data [dateReg, percent, val]"),
@View(name="massReg",
members = "idDepart.name, percent, val")
})
@Tab(properties=
"idDepart.name, idCriteria.name, idGroupCriteria.name, dateReg, percent, val"
)
public class RegValueCriteria implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "ID")
private Long id;
@Basic(optional = false)
@NotNull
@Column(name = "DATE_REG")
@Temporal(TemporalType.TIMESTAMP)
@DefaultValueCalculator(CurrentDateCalculator.class)
@Stereotype("DATETIME")
private Date dateReg;
@Column(name = "PERCENT")
@OnChange(OnChangePercentAction.class)
private BigDecimal percent;
@Column(name = "VAL")
private BigDecimal val;
@JoinColumn(name = "ID_CRITERIA", referencedColumnName = "ID")
@ManyToOne(optional = false)
@DescriptionsList(
descriptionProperties="name"
)
@OnChange(OnChangeClsCriteriaAction.class)
private ClsCriteria idCriteria;
@JoinColumn(name = "ID_GROUP_CRITERIA", referencedColumnName = "ID")
@ManyToOne(optional = false)
@DescriptionsList(
descriptionProperties="name"
)
private ClsGroupCriteria idGroupCriteria;
@JoinColumn(name = "ID_DEPART", referencedColumnName = "ID")
@ManyToOne(optional = false)
@DescriptionsList(
descriptionProperties="name"
)
private ClsDepart idDepart;
}
```
Кроме привычных аннотаций JPA. Можно заметить и аннотации OpenXava. Их стоит рассмотреть подробнее.
Аннотация `@View` позволяет управлять форматом представления полей класса, при этом с помощью специального синтаксиса в виде квадратных скобок поля можно объединять в группы и компоновать их горизонтально и вертикально с помощью символов `,` и `;`. Если для одного компонента необходимо задать несколько отображений, то аннотации `@View` группируются с использованием аннотации `@View`. В нашем примере свойства были оформлены так:
```
@View(members = "idCriteria [idCriteria];"
+ "idGroupCriteria [idGroupCriteria];"
+ "idDepart [idDepart];"
+ "data [dateReg, percent, val]")
```
А выглядит это так:
Неказисто, зато с минимумом усилий. Однако есть способы немного «оживить» форму.
Для того, чтобы дата регистрации была заполнена при создании компонента использована аннотация `@DefaultValueCalculator`, которая вызывает специальный объект-калькулятор. Здесь использован калькулятор из самой OpenXava, но можно сделать и кастомный. Для отображения даты с использованием соответствующего элемента управления использована аннотация `@Stereotype`.
Для настройки выпадающих списков, содержащих связанные объекты, применяется аннотация `@DescriptionsList`, в которой можно указать, какое именно свойство будет отображено в списке.
С помощью аннотаций можно реализовать и кое-какую бизнес-логику самой формы. Например, чтобы при изменении процента значение рассчитывалось автоматически с учетом коэффициента критерия можно применить аннотацию `@OnChange` для поля `BigDecimal val`. Чтобы аннотация `@OnChange` работала ей необходимо указать на класс, имплементирующий интерфейс `OnChangePropertyBaseAction`. В классе должен быть реализован единственный метод `execute()`, в котором входные данные берутся из представления, производится расчет и подсчитанное значение записывается обратно в представление:
**Класс-наследник OnChangePropertyBaseAction**
```
public class OnChangePercentAction extends OnChangePropertyBaseAction{
@Override
public void execute() throws Exception {
BigDecimal percent = (BigDecimal)getNewValue();
if (percent != null){
Map value = (Map)getView().getValue("idCriteria");
if (value != null){
Long idCriteria = (Long)value.get("id");
Query query = XPersistence.getManager().createNativeQuery(
"SELECT KOEFFICIENT FROM SUMMAR.SLCLA_STATE_CRITERIA WHERE ID_CRITERIA = ?");
query.setParameter(1, idCriteria);
List list = query.getResultList();
if (list != null && !list.isEmpty()){
BigDecimal koef = (BigDecimal) list.get(0);
BigDecimal vl = koef.multiply(percent);
getView().setValue("val", vl);
}
}
}
}
}
```
Для табличного представления данных используется аннотация `@Tab`, которая позволяет перечислить те свойства объектов, которые будут выведены в табличном представлении. В нашем примере аннотация была оформлена так:
```
@Tab(properties=
"idDepart.name, idCriteria.name, idGroupCriteria.name, dateReg, percent, val"
)
```
Выглядеть это будет следующим образом
Радует наличие фильтров, пагинации и экспорта из коробки, однако многие детали требуют доработки напильником.
Подобным образом построена работа и с другими компонентами. Использование OpenXava позволило резко снизить трудозатраты на реализацию функций CRUD и большей части пользовательского интерфейса. Использование действий из предопределенных контроллеров и аннотаций для построения форм сильно экономит время, если не придираться к деталям и не пробовать реализовать что-то сложнее формы ввода с несколькими событиями. Хотя может быть дело в опыте.
### То, ради чего все затевалось
Помните, для чего затевалось приложение? Да-да для того, чтобы табличка с показателями не героически сводилась в Excel, а создавалась автоматически на основе введенных данных. В окне браузера сводная таблица стала выглядеть так:
Детали реализации приводить не буду, поскольку с ней все не очень хорошо и смесь JSP со сгенерированным при запросе данных HTML, не то, чем стоит делиться с широкой публикой. В то же время сама выборка данных была продемонстрирована выше.
Однако хочу остановиться на одной интересной детали. Когда собирались требования к приложению, руководство очень хотело, чтобы помимо сводного отчета значения отдельного показателя можно было вывести в виде карты региона, разбитого на районы с указанием места и балла соответствующего филиала. Кто по карте узнал регион – тот молодец =)
С одной стороны, требование было опциональным, но с другой стороны и картинка обещала быть наглядной, и с точки зрения реализации интересно было попробовать. После некоторых раздумий пришла идея найти изображение региона в формате SVG и сделать из него XSLT-шаблон.
Полученный шаблон легко заполняется данными, а после этого конвертируется в PNG.
Сначала с помощью запроса, описанного выше, делается выборка данных, полученные данные преобразуются в объект такого класса:
**Классы для вывода данных на карту**
```
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "VisualisedValuesCriteria")
public class VisualisedValuesCriteria {
private XMLGregorianCalendar date;
private String criteriaName;
private String koefficient;
private List departValues;
public XMLGregorianCalendar getDate() {
return date;
}
public void setDate(XMLGregorianCalendar date) {
this.date = date;
}
public String getCriteriaName() {
return criteriaName;
}
public void setCriteriaName(String criteriaName) {
this.criteriaName = criteriaName;
}
public String getKoefficient() {
return koefficient;
}
public void setKoefficient(String koefficient) {
this.koefficient = koefficient;
}
public List getDepartValues() {
if (departValues == null){
departValues = new ArrayList<>();
}
return departValues;
}
public void setDepartValues(List departValues) {
this.departValues = departValues;
}
}
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class VisualizedValueCriteria {
private String departName;
private String departCode;
private String value;
private String percent;
private String colorCode;
public String getDepartName() {
return departName;
}
public void setDepartName(String departName) {
this.departName = departName;
}
public String getDepartCode() {
return departCode;
}
public void setDepartCode(String departCode) {
this.departCode = departCode;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public String getPercent() {
return percent;
}
public void setPercent(String percent) {
this.percent = percent;
}
public String getColorCode() {
return colorCode;
}
public void setColorCode(String colorCode) {
this.colorCode = colorCode;
}
}
}
```
Далее преобразуем объект в XML;
**Преобразование**
```
Private String marshal (VisualisedValuesCriteria obj){
final Marshaller marshaller =
JAXBContext.newInstance(VisualisedValuesCriteria.class).createMarshaller();
marshaller.setEventHandler(new DefaultValidationEventHandler());
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
StringWriter writer = new StringWriter();
marshaller.marshal(obj, writer);
return writer.toString();
}
```
А теперь возьмем полученный XML, подготовленный XSLT-шаблон, применим преобразование и на выходе получим svg:
**Получаем svg**
```
String xml = marshal(obj);
TransformerFactory factory = TransformerFactory.newInstance();
FileInputStream xsltFis = new FileInputStream("C:\\TEMP\\map_xsl.svg");
InputStreamReader xsltIn = new InputStreamReader(xsltFis, "UTF-8");
Source xslt = new StreamSource(xsltIn);
Transformer transformer = factory.newTransformer(xslt);
InputStream xmlIn = new ByteArrayInputStream( xml.getBytes( "UTF-8" ) );
Source text = new StreamSource(xmlIn);
String filename = "map" + System.currentTimeMillis() + ".svg";
String filePath = "C:\\TEMP\\" + filename;
transformer.transform(text, new StreamResult(new File(filePath)));
```
В принципе на этом можно было бы и остановиться, браузеры без проблем отображают SVG. Но описанные отчеты получались еще и через Телеграм-бота, поэтому SVG надо сконвертировать в какой-нибудь формат типа JPEG или PNG. Для этого используем [Apache Batik](https://xmlgraphics.apache.org/batik/)
**Преобразуем в PNG**
```
private String convertToPNG(final String svg, final String filename, final String filePath){
String png = filePath + filename + ".png";
try {
PNGTranscoder trancoder = new PNGTranscoder();
String svgURI = new File(svg).toURL().toString();
TranscoderInput input = new TranscoderInput(svgURI);
OutputStream ostream = new FileOutputStream(png);
TranscoderOutput output = new TranscoderOutput(ostream);
trancoder.transcode(input, output);
ostream.flush();
ostream.close();
return filename + ".png";
} catch (MalformedURLException ex) {
Logger.getLogger(ActualCriteriaValueGraphicServlet.class.getName()).log(Level.SEVERE, null, ex);
} catch (FileNotFoundException | TranscoderException ex) {
Logger.getLogger(ActualCriteriaValueGraphicServlet.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
Logger.getLogger(ActualCriteriaValueGraphicServlet.class.getName()).log(Level.SEVERE, null, ex);
}
return null;
}
```
Отчет в виде карты готов. Его можно и через браузер посмотреть и у телеграм-бота запросить. По-моему неплохо.
### Заключение
К назначенному сроку мы успели и уже в марте 2017 года показатели эффективности вместо Excel стали регулярно заноситься в созданную систему. С одной стороны, задача-максимум решена не была, наиболее сложная часть расчетов показателей так и выполняется вручную. Но с другой стороны, реализация этих расчетов несла риски постоянной доработки. Кроме того, даже созданный простой интерфейс для сбора данных снимал огромное количество вопросов с постоянными изменениями, контролем версий и сводом экселевской таблицы. Большое количество ручной работы, проверок и перепроверок было убрано.
Нельзя не сказать, что интерфейс на Open Xavа не слишком порадовал пользователей. В первое время было много вопросов к его особенностям. В какой-то момент пользователи начали жаловаться, что на ввод данных уходит слишком много времени и вообще «мы хотим как в Экселе, только программу». Пришлось даже провести мониторинг скорости ввода на основе данных о времени создания записей. Этот мониторинг показал, что даже в самых тяжелых случаях пользователи не тратили на ввод более 15 минут, а обычно укладывались в 5-7, при том, что им необходимо было вносить данные по 22 филиалам. Такие показатели кажутся вполне приемлемыми.
Однако, хочется отметить две вещи:
1. Open Xavа неплохо показала себя как средство для быстрого создания интерфейса. Я бы даже сказал прототипа интерфейса. Также ее безусловным плюсом является общая упорядоченность и регулярность. Все формы в приложении создаются по единообразным принципам, что позволяет не придумывать велосипедов разработчику там, где не надо, а пользователю иметь дело с типовыми наборами форм. Однако попытки реализовать более сложную логику или изменить элементы управления под себя натолкнули нас на ряд проблем, с которыми за отведенное время справиться не удалось. Скорее всего, мы просто не разобрались, да и целью являлось создание простого CRUD-интерфейса с минимумом усилий. Для себя я делаю вывод, что Open Xavа интересный инструмент, в котором просто делать простые вещи, но если необходимо делать что-то сложное, то я предпочту потратить больше сил на создание клиентской части с помощью ExtJS или React, но иметь при этом большую гибкость.
2. Даже уверенные пользователи тяжело воспринимают новые интерфейсы. Это конечно не секрет. По-моему мнению это в первую очередь вызвано отсутствием понимания системности многих интерфейсов. Для многих – любое приложение набор экранов, каждый из которых уникален и работает по своим неведомым принципам: например, есть форма со списком объектов/строк(форма списка), но для очень многих пользователей совсем не очевидно, что каждая такая форма в приложении может обладать единообразными функциями фильтрации, пагинации, сортировки и в целом одинаковым поведением, дополненным специфическими функциями. Усугубляется это и тем, что большое количество корпоративного программного обеспечения представляют собой почти стихийное нагромождение кнопок и форм, приправленное невнятной документацией в стиле «Нажмите эту кнопочку». С этой точки зрения интерфейсы создаваемые той же Open Xavа дисциплинируют разработчиков пользователей, создают больше порядка в голове. Правда, при таком подходе волшебные кнопочки никуда не исчезают, а становятся аккуратно разложенными по формам.
Если же говорить о выгодах для организации в целом, то после внедрения приложения, как и предполагалось, степень контроля повысилась. Руководители на местах получили инструмент мониторинга показателей, с помощью которого они могут влиять на работу в более оперативном режиме, сравнивать показатели за различные периоды, не путаясь при этом в потоке рассылаемых файлов. Заинтересованность руководителей в постоянном и неусыпном контроле своего филиала была обнаружена нами весьма интересным способом: просматривая логи Telegram-бота мы заметили, что некоторые отчеты получались в 4 или 5 часов утра. Сразу видно, кто интересуется работой.
На этом все. Буду признателен за конструктивную обратную связь! | https://habr.com/ru/post/423919/ | null | ru | null |
# Cofree Will Tear Us Apart
Всем привет.
В последнее время я работаю с распределенными системами и часто встречаюсь с проблемами работы с данными, части которых могут находиться в различных местах. Ну и так как я уже продолжительное время пишу на Haskell, описание проблемы и мощная система типов здорово помогли в дальнейшем развитии этой идеи. Речь пойдет о том, как всего одна несущая алгебраическая конструкция позволила решить задачу рециркулирующих данных в общем виде.
Введение и мотивация
--------------------
По ходу повествования мы встретим три основных тезиса, которые дадут представление о желаемом результате.
Представьте, что вам нужно написать программу, которая работает с какими-то данными. Если данных слишком много, то вам придется задумываться об организации и хранении — так как хранить их в оперативной памяти слишком ненадежно, может не хватить места или во время аварийного завершения программы вы их полностью потеряете.
Использовать базу данных? Какие? Реляционные, документоориентированные, хранилища типа "ключ-значение" или что-нибудь попроще — просто писать в файлик? Что же, каждая из этих опций имеет собственные достоинства и недостатки.
Где бы мы их не хранили, чтобы сделать с этими данными что-то, что выходит за пределы возможностей выбранного нами способа, нам в любом случае необходимо загрузить их обратно в оперативную память. Разумеется, только какую-то часть, а не все подряд, по причинам описанным выше.
**Тезис 1. Нам не нужно хранить все данные в пямяти, а только какую-то часть.**
И правда, когда мы работаем с базами данных, мы пишем запросы, по которым мы эти данные можем получать в память. Запись в базе данных — это ведь только кусочек от всего нашего общего массива с информацией. В случае реляционных — это записи в таблицах. В случае хранилищ типа "ключ-значение" — пара "ключ-значение".
Когда вы пишете приложения для реального мира, вам приходится подстраивать схему организации данных из своей предметной области под ограничения выбранного вами способа. Это будет зависеть от степени связности, аспектов производительности и многих других факторов.
**Тезис 2. Мы хотим абстрагироваться от способа хранения и обработки информации.**
Основываясь на двух предыдущих свойствах, нам нужен способ разделения данных, с которыми мы сейчас работаем и которые фактически находятся в оперативной памяти, и данными, которые законсервированы где-нибудь на жестком диске. Нам нужен способ их разделения.
Как же мы будем их разделять? Нам нужна такая структура, которая позволит безболезненно разделять и соединять данные. Давайте поразмышляем на эту тему?
* Списки? Можно, но есть проблемы. Стоимость доступа к произвольному элементу — O(n). Стоимость объединения двух списков такая же.
* Какие-нибудь деревья? Если это бинарные, то стоимость доступа в хорошем случае снижается до O(log n). Но нам не всегда будет требоваться хранить отсортированные данные. Слишком частный случай, нам не подходит.
* Массивы? Стоимость доступа — O(1). Но тоже частный случай, просто столкнемся с другими проблемами — эта структура вообще не алгебраическая.
**Тезис 3. Нам нужна несущая конструкция, способная охватить в своем описании многие другие структуры данных.**
И такая структура есть!
Несущая конструкция Cofree
--------------------------
Многие `Haskell`-программисты знакомы с типом `Free`. Но почему-то его дуальности, `Cofree`, уделено не так много внимания. А разница между ними составляет одну деталь: `Free` тип — это сумма из некоторого `а` и `t (Free t a)`, а `Cofree` — произведение:
```
Free t a = a + t (Free t a)
Cofree t a = a × t (Cofree t a)
```
Это означает, что если мы выберем `Cofree` в качестве нашей несущей конструкции, у структуры данных, определенной через последнюю, появятся несколько особенностей:
* Эта структура всегда будет непустой, она всегда будет иметь по крайней мере один элемент.
* Так как Cofree также имеет экземпляр класса типов Comonad, мы уже имеем много полезных методов задаром:
+ `extract` — Получить значение, которое находится в фокусе.
+ `extend` — Обновить значения во всей структуре в зависимости от контекста.
+ `unwrap` — Получить множитель произведения, сегмент информации.
+ `coiter` — Сгенерировать структуру из начального значения.
Так каким образом мы собираемся собирать различные структуры данных с помощью Cofree? Нам всего-то и нужно что инстанциировать тип `t` в `Cofree t a`, имеющий экземпляр класса типов `Functor`.
Представим, что нам нужен стэк или непустой список — простая структура данных. Тут нам подойдет `Maybe`, в этом случае, конструкторы последнего выполняют роль генератора — Just позволят продолжить описывать структуру, а Nothing является терминирующим инвариантом.:
```
data Maybe a = Just a | Nothing
type Stack = Cofree Maybe
example :: Stack Int
example = 1 :< Just (2 :< Just (3 :< Nothing))
```
Вспомогательная конструкция Shape
---------------------------------
Хорошо, мы разобрались как можно описывать структуры данных на `Cofree`. Мы затеяли этот разговор для нахождения способа разделения данных с точки зрения типов, находящихся в разных местах. Для этого мы снабдим `Cofree` еще одной конструкцией:
```
data Shape t raw value
= Ready (t value) -- ^ Сегмент данных в оперативной памяти
| Converted raw -- ^ Cегмент данных где-нибудь в другом месте
data Apart t raw value = Apart (Cofree (Shape t raw) value)
```
И получаем замечательный тип Apart, который будет контролировать, какая часть данных где находится.
Пример использования Apart
--------------------------
А теперь, давайте составим иллюстрированный пример. Представьте, что мы хотим поработать с бинарным деревом. Как мы можем описать его через `Cofree`? Через "функтор ветвления". Узел дерева может не иметь потомков, иметь левого потомка, правого потомка или обоих. Давайте прямо так и закодируем:
```
data Crotch a = End | Less a | Greater a | Crotch a a
type Binary = Cofree Crotch
```
Отлично, теперь мы можем написать значение для этого типа, пример бинарного дерева поиска возьмем с одноименной статьи Википедии:
```
example :: Binary Int
example = 8 :< Crotch
(3:< Crotch
(1 :< End)
(6 :< Crotch
(4 :< End)
(7 :< End)))
(10 :< Greater
(14 :< Less
(13 :< End)))
```
Опробуем первый комбинатор — `limit`, он позволит нам обрезать наше дерево по высоте:
```
limit 3 do_something_with_the_rest example
```
Я намеренно абстрагировался от способа сохранения, чтобы не заострять на этом внимание — мы можем хранить не вошедшие в диапазон сегменты в файл и функция `do_something_with_rest` может возвращать нам название файла и номер строки. Или вовсе класть в `Redis`/`Memcashed`/`Tarantool` и возвращать параметры соединения и ключ для сохраненного сегмента. В общем, не так важно.
```
scattered :: Scattered Binary Int _
scattered = 8 :< Crotch
(3 :< Crotch
(1 :< {RESTORE_INFO})
(6 :< {RESTORE_INFO}))
(10 :< Greater
(14 :< {RESTORE_INFO}))
```
И вот, что осталось от нашего дерева — оно обрезалось по высоте. Но информация для восстановления осталась на месте исчезнувших трех сегментов. Представление выше на самом деле скрывает конструктор `Ready`, а `Converted` заменен на фигурные скобочки (спасибо хитрому экземпляру класса `Show`).
С помощью комбинатора `recover` мы можем вернуть всю структуру данных в память:
```
recover back_to_RAM scattered
```
Или и вовсе пройтись с эффектом по разбросанной структурой данных, по ходу дела восстанавливая сегменты в памяти и применяя к ним такую же функцию как и к значениям в памяти.
```
fluent do_something_whereever_they_are scattered
```
В качестве заключения
---------------------
Вот так алгебраические структуры данных и понятия из теории категорий позволили сначала описать, а после и решить задачу рециркулирующих данных в самом общем виде.
Идеи, описанные выше, были реализованы в [библиотеке](https://github.com/iokasimov/apart), которой пока нет на Hackage, но находящейся в фазе активного развития.
На данный момент мне удалось описать направленный ацикличный граф, бинарные, префиксные, розовые, АВЛ-деревья и немного отдельных функций для работы с ними.
Сама идея использования Cofree в качестве несущей конструкции для других структур данных была мною подхвачена из описания к модулю [`Control.Comonad.Cofree`](https://hackage.haskell.org/package/free-5.0.2/docs/Control-Comonad-Cofree.html) в пакете [`free`](https://hackage.haskell.org/package/free) Эдварда Кметта.
Идея алгебраического описания графов была использована здесь из [работы Андрея Мохова](https://doi.org/10.1145/3122955.3122956).
В планах также остается:
* Реализовать пальчиковые, Splay-деревья и другие структуры посложнее.
* Написать побольше функций для работы с ними (вставки, удаления, балансировки и т.п.).
* Естественные преобразования между ними (так как функтор как раз и определяет особенности отдельной структуры).
* Оптические интерфейсы для работы с внутренностями структур.
* Изучить способы совместимости комбинаторов со стриминговыми библиотеками ([`pipes`](http://hackage.haskell.org/package/pipes), [`conduit`](http://hackage.haskell.org/package/conduit), [`io-streams`](http://hackage.haskell.org/package/io-streams), [`machines`](http://hackage.haskell.org/package/machines)).
* Написать полноценные тесты свойств отдельных структур данных.
* Бенчмарки, в первую очередь с популярными [`containers`](http://hackage.haskell.org/package/containers).
Пишите в комментариях, какие структуры данных вам бы хотелось использовать таким образом и какие комбинаторы могли бы пригодиться в повседневной практике. Буду рад любым замечаниям и критике.
Спасибо за внимание. | https://habr.com/ru/post/358976/ | null | ru | null |
# Microsoft открыла исходный код PowerShell
Расширяемое средство автоматизации и конфигурирования [PowerShell](https://msdn.microsoft.com/en-us/powershell), состоящее из оболочки с интерфейсом командной строки и сопутствующего языка сценариев на базе .NET Framework, теперь доступно под Linux и OS X. Сегодня компания Microsoft открыла [репозиторий на Github](https://github.com/PowerShell/PowerShell), в котором опубликовала исходный код PowerShell.
Для начала опубликованы пакеты PowerShell для Ubuntu, Centos и Red Hat.
Инструкции для настройки рабочего окружения:
* [PowerShell для Linux](https://github.com/PowerShell/PowerShell/blob/master/docs/installation/linux.md)
* [PowerShell для OS X](https://github.com/PowerShell/PowerShell/blob/master/docs/installation/linux.md)
* [PowerShell для Windows](https://github.com/PowerShell/PowerShell/blob/master/docs/installation/windows.md)
Установка PowerShell в Ubuntu 16.04 осуществляется следующей командой:
```
sudo apt-get install libunwind8 libicu55
sudo dpkg -i powershell_6.0.0-alpha.9-1ubuntu1.16.04.1_amd64.deb
```
Установка в OS X 10.11:
```
sudo installer -pkg powershell-6.0.0-alpha.9-osx.10.11-x64.pkg -target /
```
Вдобавок Microsoft выпустила библиотеку [PowerShell Editor Services](https://github.com/powershell/powershelleditorservices), чтобы PowerShell работал с любым сторонним редактором кода (например, VS Code или Sublime).
Microsoft также обещает доработать протокол PowerShell Remoting Protocol ([MS-PSRP](https://msdn.microsoft.com/en-us/library/mt242417.aspx)) для использования [OpenSSH](https://github.com/PowerShell/Win32-OpenSSH) как нативного транспортного протокола. У пользователей будет выбор между SSH и WINRM.
В официальном блоге [написано](https://azure.microsoft.com/en-us/blog/powershell-is-open-sourced-and-is-available-on-linux/), что на такой шаг компания пошла в рамках общей стратегии "Microsoft loves Linux". Компания старается придерживаться этого принципа во всём: почти треть виртуальных машин в облаке Azure работают под Linux, ранее компания уже выпустила SQL Server под Linux, а также открыла исходный код .NET. Microsoft также активно участвует в различных Open Source проектах, в том числе OpenSSH, FreeBSD, Mesos, Docker, Linux и других.
Исходный код PowerShell опубликован под лицензией MIT. | https://habr.com/ru/post/308076/ | null | ru | null |
# Parallelism in PostgreSQL: treatment of trees and conscience
Database scaling is a continually coming future. DBMS get improved and better scaled on hardware platforms, while the hardware platforms themselves increase the performance, number of cores, and memory — Achilles is trying to catch up with the turtle, but has not caught up yet. The database scaling challenge manifests itself in all its magnitude.
Postgres Professional had to face the scaling problem not only theoretically, but also in practice: through their customers. Even more than once. It's one of these real-life cases that this article
will discuss.
> Many thanks to Elena Indrupskaya for the translation. Russian version is [here](https://habr.com/ru/company/postgrespro/blog/423685/).
>
>
PostgreSQL scales well on NUMA systems in the case of a single motherboard with multiple processors and multiple data buses. You can read about some optimizations [here](https://habr.com/company/postgrespro/blog/270827/) and [here](http://akorotkov.github.io/blog/2016/05/09/scalability-towards-millions-tps/).
However, there is another group of systems: they have several motherboards that exchange data using the interconnect and run one instance of the OS; for the user this design looks like a single machine. And although formally such systems can also be referred to NUMA, in essence, they are closer to supercomputers because access to the local memory of a node drastically differs from access to the memory of a neighboring node.
The PostgreSQL community believes that the cause of the issues is the only instance of Postgres running on such architectures, and there is no systematic approach to resolving them yet. Designers of shared-memory oriented software initially presumed that access times to local and remote memory would be more or less comparable. When we work with many nodes, it doesn’t make sense to rely on shared memory as on a fast communication channel: because of latency, it is much «cheaper» to send a request to perform a certain action to the node where the data of interest is located than to send the data through the bus. So, cluster solutions are relevant for supercomputers and for multi-node systems in general.
This does not mean that the combination of multi-node systems and the shared-memory architecture, which is typical for Postgres, should be trashed. After all, if Postgres processes spend most of their time performing complex computations locally, this architecture will be even more efficient. In our situation, the customer had already purchased a powerful multi-node server, and we had to resolve PostgreSQL issues on it.
And the issues were serious: execution of simplest write queries (to change several field values in one row) took from a few minutes to an hour. These issues came out full force exactly due to a large number of cores and accordingly, to massive parallelism in query execution with a relatively slow exchange between nodes.
Therefore, the article will be somewhat dual-purpose:
* To share experiences on: what if on a multi-node system, the database seriously slows down. What to begin with, how to diagnose, where to go.
* Tell how the problems of the PostgreSQL database itself can be solved with a high level of parallelism. Among the rest, how a change to the algorithm of acquiring locks affects the efficiency of PostgreSQL.
### The server and database
The system consisted of 8 blades with 2 sockets each. More than 300 cores in total (hyper-threading not taken into account). The fast bus (the manufacturer's proprietary technology) connected the blades. Not that a supercomputer, but the configuration was impressive for a single DBMS instance. The load was also rather big. More than 1 terabyte of data. About 3000 transactions per second. More than 1000 connections to Postgres.
Having started analyzing hour-long write waits, first we made sure that writing to disk could not cause the delay. As soon as unclear delays began to occur, the tests were done exclusively on `tmpfs`. The picture did not change. So the disk was not to blame.
### Starting to collect diagnoses: views
Since the issues were most likely due to the high concurrency of processes that try to access the same objects, the first thing to check was the locks. For this check, PostgreSQL has `pg.catalog.pg_locks` and `pg_stat_activity` views. Starting as early as with version 9.6, the second one includes the information on what the process is waiting for (*Amit Kapila, Ildus Kurbangaliev*) — `wait_event_type`. Possible values for this field are described [here](https://postgrespro.ru/docs/postgresql/10/monitoring-stats).
But first, let's just count:
```
postgres=# SELECT COUNT(*) FROM pg_locks;
```
```
count
—---—
88453
(1 row)
```
```
postgres=# SELECT COUNT(*) FROM pg_stat_activity;
```
```
count
—---—
1826
(1 row)
```
```
postgres=# SELECT COUNT(*) FROM pg_stat_activity WHERE state='active';
```
```
count
—---—
1005
(1 row)
```
And these are actual figures. It reached 200 000 locks. At the same time, the following locks were acquired for the ill-fated query:
```
SELECT COUNT(mode), mode FROM pg_locks WHERE pid=580707 GROUP BY mode;
```
```
count | mode
—-----+---------------—
93 | AccessShareLock
1 | ExclusiveLock
```
When reading the buffer, the DBMS uses the `share` lock, and when writing — the `exclusive` lock. That is, write locks made less than 1% of all queries. In the `pg_locks` view, the kinds of locks do not always appear as described in the user [documentation](https://postgrespro.ru/docs/postgrespro/10/explicit-locking).
Here is a table of matches:
```
AccessShareLock = LockTupleKeyShare
RowShareLock =LockTupleShare
ExclusiveLock = LockTupleNoKeyExclusive
AccessExclusiveLock = LockTupleExclusive
```
The query «SELECT mode FROM pg\_locks» showed that 234 INSERTs were waiting for execution of the CREATE INDEX command (without the CONCURRENTLY keyword) and 390 INSERTs were awaiting the `buffer content lock`. A possible solution is to «teach» INSERTs from different sessions to reduce buffer overlapping.
### It's time to involve perf
The **`perf`** utility collects pretty much diagnostic information. In the `record`… mode, it writes system event statistics to files (by default they are in `./perf_data`), and in the `report` mode, it analyzes the collected data; for example, you can filter events by being related to `postgres` or to a given `pid`:
```
$ perf record-u postgres or
$ perf record-p 76876 and then, say
$ perf report > ./my_results
```
As a result we will see something like
Usage of `perf` for PostgreSQL diagnostics is described, for example, [here](https://blog.2ndquadrant.com/tracing-postgresql-perf/), as well as in [pg wiki](https://wiki.postgresql.org/wiki/Profiling_with_perf).
In our situation, important information was obtained even in the simplest mode — `perf top`, which certainly worked a la `top` command of the operating system. With `perf top`, we've seen that the processor spends most of the time in kernel locks, as well as in the `PinBuffer()` and `LWLockAttemptLock()` functions.
`PinBuffer()` is a function that increments the count of references to the buffer (mapping of a data page to RAM), through which Postgres processes know what buffers can be evicted and which cannot.
`LWLockAttemptLock()` is a function to acquire `LWLock`. `LWLock` is a kind of lock with two levels – `shared` and `exclusive` – and without `deadlock` detection; locks are preallocated in `shared memory`, and waiting processes are queued.
These functions were already optimized considerably in PostgreSQL 9.5 and 9.6. Spinlocks inside them were replaced with a direct use of atomic operations.
### Flame graphs
No way without them: even if they were useless, they would have still been worth telling about since they are extremely elegant. Moreover, they are useful! Here goes an illustration from `github` – not from the case discussed (neither we nor the customer are ready to disclose details yet).
These impressive pictures very clearly show what the processor cycles are spent on. The same `perf` can collect data, but `flame graph` clearly visualizes the data and builds trees based on the collected call stacks. You can read about profiling with flame graphs, for example, [here](https://queue.acm.org/detail.cfm?id=2927301) and download everything you need [here](https://github.com/brendangregg/FlameGraph).
In our situation, we could see a huge number of `nestloop`s on the flame graphs. It seems like JOINs of a large number of tables in numerous parallel read queries caused a large number of `access share` locks.
Statistics collected by `perf` show where the CPU cycles are spent. And although we've seen that most of the CPU time passes in the locks, we did not see what exactly leads to such long waits of the locks because we do not understand where exactly the waits of the locks occur — CPU time is not spent in waits.
In order to see the waits themselves, we can query the `pg_stat_activity` system view.
```
SELECT wait_event_type, wait_event, COUNT(*) FROM pg_stat_activity GROUP BY wait_event_type, wait_event;
```
revealed that:
```
LWLockTranche | buffer_content | UPDATE *************
LWLockTranche | buffer_content | INSERT INTO ********
LWLockTranche | buffer_content | \r
| | insert into B4_MUTEX
| | values (nextval('hib
| | returning ID
Lock | relation | INSERT INTO B4_*****
LWLockTranche | buffer_content | UPDATE *************
Lock | relation | INSERT INTO ********
LWLockTranche | buffer_mapping | INSERT INTO ********
LWLockTranche | buffer_content | \r
```
(here asterisks just replace the details of the query that we do not share).
The values are visible for `buffer_content` (lock on the contents of buffers) and for `buffer_mapping` (locks on parts of the `shared_buffers` hash table).
### To GDB for help
But why are there so many waits for these locks? For more detailed information about locks, we had to use the `GDB` debugger. With `GDB`, we can get a stack of calls to specific processes. Using sampling, i.e., having collected a certain number of random call stacks, you can get an idea of the stacks where the longest waits happen.
Let's consider the process of collecting statistics. We will consider the «manual» collection of statistics, although in real life special scripts are used to do it automatically.
First, it is necessary to attach `gdb` to the PostgreSQL process. To do this, you need to find `pid` of the server process, say, from
```
$ ps aux | grep postgres
```
Assume we found:
```
postgres 2025 0.0 0.1 172428 1240 pts/17 S jul23 0:00 /usr/local/pgsql/bin/postgres -D /usr/local/pgsql/data
```
and now we will feed the debugger with `pid`:
```
igor_le:~$gdb -p 2025
```
Once inside the debugger, we type `bt` [that is, `backtrace`] or `where`. And we get a lot of information of this kind:
```
(gdb) bt #0 0x00007fbb65d01cd0 in __write_nocancel () from
/lib64/libc.so.6 #1 0x00000000007c92f4 in write_pipe_chunks (
data=0x110e6e8 "2018-06-01 15:35:38 MSK [524647]: [392-1]
db=bp,user=bp,app=[unknown],client=192.168.70.163
(http://192.168.70.163) LOG: relation 23554 new block 493:
248.389503\n2018‐06‐01 15:35:38 MSK [524647]: [393-1]
db=bp,user=bp,app=["..., len=409, dest=dest@entry=1) at elog.c:3123 #2
0x00000000007cc07b in send_message_to_server_log (edata=0xc6ee60
) at elog.c:3024 #3 EmitErrorReport () at
elog.c:1479
```
Having gathered statistics, which included call stacks from all Postgres processes that were collected repeatedly at different points in time, we saw that 3706 seconds (about an hour) were spent awaiting the `buffer partition lock` inside the `relation extension lock`, that is, a lock on a piece of the buffer manager's hash table that was needed to evict the former buffer in order to later replace it with a new one, corresponding to the extended part of the table. A certain number was also noticeable for `buffer content lock`, which corresponded to the wait of the lock of `B-tree` index pages for insertion.
At first, there were two explanations for such a monstrous waiting time:
* Someone else acquired this `LWLock` and got stuck. But this is unlikely. Because nothing complicated happens inside the buffer partition lock.
* We came across some sort of pathologic behavior of `Lwlock`. That is, although none acquired the lock for too long, the wait for it lasted unnecessarily long.
### Diagnostic patches and treatment of trees
By reducing the number of simultaneous joins, we would certainly reduce the flow of requests for locks. But it would be like a surrender. Instead, *Alexander Korotkov*, chief architect of Postgres Professional (he certainly helped to prepare this article), proposed a series of patches.
First of all, it was necessary to get a more detailed picture of the disaster. Although off-the-shelf tools are pretty universal, company's own diagnostic patches still prove useful.
A patch was written to add detailed logging of the time spent in `relation extension` and of what happens inside the `RelationAddExtraBlocks()` function. This way we get to know what the time inside `RelationAddExtraBlocks() is spent on.`
And another patch was written in support of the previous, which reports in `pg_stat_activity` on what we are doing now in `relation extension`. It was done like this: when `relation` is extended, `application_name` becomes `RelationAddExtraBlocks`. This process is now convenient to analyze in maximum details using `gdb bt` and `perf`.
As for treatment patches (rather than diagnostic), two of them were written. The first patch changed the behavior of `B‐tree` leaf locks: previously, in an insert query, the leaf was locked as `share`, and only then acquired `exclusive`. Now it acquires `exclusive` from the beginning. Now this patch [is already committed](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=d2086b08b023c0749a53d617ff3fe0f052646254) for **PostgreSQL 12**. Thanks to the [committer status](https://wiki.postgresql.org/wiki/Committers), which *Alexander Korotkov* received last year — the second PostgreSQL committer in Russia and the second in the company.
The value of `NUM_BUFFER_PARTITIONS` was also increased from 128 to 512 to reduce the load on the mapping locks: the hash table of the buffer manager was divided into smaller pieces with a view of decreasing the load on each particular piece.
After applying this patch, locks on the contents of the buffers were gone, but despite the increase of `NUM_BUFFER_PARTITIONS`, there remained `buffer_mapping` locks, that is, to recall, locks on pieces of the buffer manager's hash table:
```
locks_count | active_session | buffer_content | buffer_mapping
----‐‐‐--‐‐‐+‐------‐‐‐‐‐‐‐‐‐+‐‐‐------‐‐‐‐‐‐‐+‐‐------‐‐‐
12549 | 1218 | 0 | 15
```
And this is not much. B‐tree was no longer a bottleneck. The extension of `heap` came to the forefront.
### Treatment of conscience
Then Alexander suggested the following hypothesis and solution:
We are waiting too long on the `buffer partition lock` during the buffer eviction. It is possible that on the same `buffer partition lock` there lies some highly demanded page, for example, the root of some `B‐tree`. At this location, there is a persistent flow of requests for the `shared-lock` from read queries.
The wait queue in `LWLock` is «not fair». Since as many `shared lock`s as you want can be acquired at the same time, if `shared lock` is already acquired then next `shared lock`s do not wait in line. Therefore, if the flow of shared locks is intensive enough to not leave gaps between them, the wait of the `exclusive lock` goes virtually to infinity.
To fix this, we can try to offer the patch for «gentleman» behavior of locks. It stirs the conscience of `shared locker`-s and they honestly stand in line when `exclusive lock` is already standing there (interestingly, heavyweight locks — `hwlock` — have no trouble with the conscience: they always honestly stand in line)
```
locks_count | active_session | buffer_content | buffer_mapping | reladdextra | inserts>30sec
‐‐‐‐‐‐-‐‐‐‐‐+‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐‐‐‐--‐-‐+‐‐‐‐‐‐-‐‐‐‐‐‐+‐‐‐‐------
173985 | 1802 | 0 | 569 | 0 | 0
```
Everything is OK! There are no long `INSERT`s. However, locks on pieces of hash tables remain. Well, it can’t be helped — these are the properties of the bus of our little supercomputer.
This patch was also [offered to the community](https://www.postgresql.org/message-id/CAPpHfdvJhO1qutziOp%3Ddy8TO8Xb4L38BxgKG4RPa1up1Lzh_UQ%40mail.gmail.com). But regardless of the future of these patches in the community, nothing prevents them from getting into next versions of **Postgres Pro Enterprise**, which are designed right for customers with heavily loaded systems.
### Lesson learned
Upstanding lightweight `share` locks, which let `exclusive` locks into the queue, resolved the issue of hour-long delays on a multi-node system. The hash table of the `buffer manager` failed to work because of a too heavy flow of `share lock`-s, which left no chance for the locks needed to evict the old buffers and load the new ones. Issues with the extension of the buffer for database tables only was the result of this. Previously, it was possible to fix a weakness with access to the root of `B-tree`.
PostgreSQL was not created with an eye to NUMA-architectures and supercomputers. Accommodating Postgres to these architectures is a huge job, which would (and will possibly) require coordinated efforts of many people and even companies. But troublesome consequences of these architectural problems can be mitigated. And we have to: the load types that resulted in delays such as those described are quite typical, and we continue to receive similar distress alerts from other places. Similar troubles manifested themselves before — on systems with fewer cores, but the consequences were just not so terrible, and the symptoms were treated differently and with other patches. Now another treatment is available: although not universal, but definitely useful.
So, when PostgreSQL works with the memory of the whole system as local, no high-speed bus between nodes can be compared with the time of access to local memory. Uneasy problems arise because of this, often urgent, but interesting. And the experience of solving them is useful not only to the solvers, but also for the whole community.
 | https://habr.com/ru/post/500442/ | null | en | null |
# Автоматизированный приём webmoney платежей на вашем сайте.
**0. Вступление**
Ни для кого не секрет, что в последнее время webmoney набрало достаточную популярность для того, чтобы стать одним из самых удобных и доступных средств для безналичного расчёта через интернет. Пополнить баланс своего мобильного, оплатить покупку товаров в веб-магазине — всё это можно сделать с помощью webmoney.
Я бы хотел рассказать вам несколько способов, как можно устроить приём оплаты за какие либо товары или услуги на вашем сайте электронной валютой webmoney. Это, кстати, не так сложно, как могло бы показаться на первый взгляд!
**1. Merchant WebMoney Transfer**
Это тот инструмент, который предоставили нам разработчики для автоматизации совершения платежей. Merchant WebMoney Transfer представляет из себя набор интерфейсов для взаимодействия с системой WebMoney. Ниже я попытаюсь вкратце описать их.
**1.1 Web Merchant Interface** — самый простой способ для организации оплаты webmoney, основан на специальным образом сформированной форме, которая просто посылает пользователя и его данные на сайт webmoney, где он и совершает основные действия по оплате средств.
Всё, что нужно для приёма оплаты данным способом, это разместить на своём сайте 3 страницы — страницу с формой для оплаты, страницу успешно выполненного платежа и страницу невыполненного платежа. Затем вы единожды настраиваете серверную часть для обработки платежей и наслаждаетесь денежным потоком, хлынувшим в ваш карман =) Более подробное описание этого интерфейса доступно здесь: <https://merchant.webmoney.ru/conf/guide_simple.asp>.
**1.2 Click&Buy Merchant Interface** — Этот интерфейс позволяет покупателю платить webmoney одним кликом мыши, используя WM Keeper. Суть в следующем: покупатель кликает по специальной ссылке webmoney (вида wmk:paylink...) и уже в WM Keeper'е происходит весь процесс оплаты. Более подробное описание этого интерфейса доступно здесь <https://merchant.webmoney.ru/conf/guide_pci.asp>.
**1.3 WM Automation Interface** — Самая вкусняжка =) Это набор XML интерфейсов (15 штук, от X1 до X15) основанных на запросах к web-серверу webmoney по протоколу https в формате XML с использованием специального модуля аутентификации для ключей WM Keeper Classic
или стандартных сертификатов x.509 (сертификаты WM Keeper Light). С помощью этих интерфейсов вы можете производить широкий перечень действий во своим кошельком, например:
— Выписать счёт покупателю (X1)
— Получение истории и проверка оплаты счетов (X4)
— Получение баланса(X9)
и ещё много всего интересного. Собственно на этом интерфейсе, а точнее, на этом наборе интерфейсов я хотел бы остановиться подробнее.
**2.XML – выбор профессионалов!**
**2.1 Постановка задачи** — Однажды мне понадобилось реализовать прием и выдачу WM на сайте, в автоматическом режиме, с логированием движения денег, воизбежание казусов. Чтобы обеспечить полный автоматизм работы нужно использовать WM Automation Interface, поскольку другие виды интерфейсов не дадут нам должной функциональности.
**2.2 Инструмент** — Велосипеды изобретать мы не будем, а используем готовую библиотеку под названием WMXI. Она живёт по адресу [my-tools.net/wmxi](http://my-tools.net/wmxi/). Для её успешного функционирования сервер должен удовлетворять следующим требованиям: BCMath или GMP, MHash или Hash, CURL, MBString, Enabled XML. Чтобы проверить, удовлетворяет ли ваш хостинг данным условиям, можно воспользоваться утилитой check.php из комплекта WMXI.
**2.3 Выписка счёта.** Для начала, давайте реализуем самую простую задачу: выписку счёта от магазина клиенту. Для этих целей предусмотрен интерфейс X1, его мы и будем использовать. Однако не стоит забывать о том, что выписка счёта вовсе не гарантирует того, что он будет оплачен =) Так что, нужно будет позже проверять оплату счёта.
Вот и сам код:
`php<br/
//подключаем компоненты
include_once("wmxi/wmsigner.php");
include_once("wmxi/wmxi.php");
include_once("wmxi/wmxiparser.php");
//Создаём объект класса WMXI. Передаваемые параметры:
//путь к сертификату, используемому для защиты от атаки с подменой ДНС
//кодировка, используемая на сайте. По умолчанию используется UTF-8
$wmxi = new WMXI(realpath("../WebMoneyCA.crt"), DOC_ENCODING);
//Инициализация с помощью резервной копии ключей
//от Webmoney Keeper Classic. Передаваемые параметры:
//WMID - идентификатор пользователя
//пароль пользователя от резервной копии файла ключей
//путь к резервной копии файла ключей размером 164 байта
//или бинарное содержимое файла ключа
$wmxi->Classic("000000000000", "password", "../keys/000000000000.kwm");
//Создаем парсер ответа сервера
$parser = new WMXIParser();
//Собственно, сам запрос
$response = $wmxi->X1(
$wm_transfer, //номер счета в системе учета магазина; любое целое число без знака.
$_POST[wmid], //wmid покупателя
"Z999988887777", //Кошелёк магазина
floatval($_POST[money]), //число с плавающей точкой без незначащих символов
"Пополнение счёта на сайте MYSITE.RU", //произвольная строка от 0 до 255 символов; пробелы в начале или конце не допускаются
"http://mysite.ru", //произвольная строка от 0 до 255 символов; пробелы в начале или конце не допускаются
0, //целое число от 0 до 255; если 0 - протекция сделки при оплате счета не разрешена
1 //целое число от 0 до 255; если 0 - срок оплаты не определен
);
//Преобразовываем ответ сервера в структуру. Входные параметры:
//XML-ответ сервера
//кодировка, используемая на сайте. По умолчанию используется UTF-8
$structure = $parser->Parse($response, DOC_ENCODING);
//преобразуем индексы структуры к более удобным для доступа.
//лично я не понял зачем это, но с этим всё работает =)
$transformed = $parser->Reindex($structure, true);
//Если код выполнения запроса == 0 (запрос выполнен)
if($structure["w3s.response"]["retval"] == 0)
{
$transformed["w3s.response"]["reqn"]; // Номер запроса в системе WM
$transformed["w3s.response"]["invoice"]["orderid"]; //номер счёта в вашей системе, первый параметр при запросе
echo "Счёт на оплату успешно выписан!";
}
else echo $structure["w3s.response"]["retdesc"]; //Если ошибка, то выводим её.
?>`
Вот и всё =). Счёт выписан, осталось только дождаться денег. Только с виду это кажется сложным, на самом деле всё суперпросто!
**2.4 Проверка состояния счёта.** Счёт выписан, а как узнать оплачен или нет. Тут нам на помощь приходит интерфейс X4. Он позволяет получить историю выписанных счетов по кошельку, а также проверить оплату счета, что в общем то нам и нужно. Давайте посмотрим, как это сделать:
`php<br/
//подключаем компоненты
include_once("wmxi/wmsigner.php");
include_once("wmxi/wmxi.php");
include_once("wmxi/wmxiparser.php");
//Создаём объект класса WMXI. Передаваемые параметры:
//путь к сертификату, используемому для защиты от атаки с подменой ДНС
//кодировка, используемая на сайте. По умолчанию используется UTF-8
$wmxi = new WMXI(realpath("../WebMoneyCA.crt"), DOC_ENCODING);
//Инициализация с помощью резервной копии ключей
//от Webmoney Keeper Classic. Передаваемые параметры:
//WMID - идентификатор пользователя
//пароль пользователя от резервной копии файла ключей
//путь к резервной копии файла ключей размером 164 байта
//или бинарное содержимое файла ключа
$wmxi->Classic("000000000000", "password", "../keys/000000000000.kwm");
//Создаем парсер ответа сервера
$parser = new WMXIParser();
//Собственно, сам запрос
$response = $wmxi->X4(
"Z999988887777",//Кошелёк магазина
0,//целое число > 0, номер счета в системе WM
$wm_transfer,//номер счета в системе учета магазина; любое целое число без знака
date("Ymd H:i:s", time()-86400),//минимальное время и дата создания счета
date("Ymd H:i:s", time())//максимальное время и дата создания счета
);
//Преобразовываем ответ сервера в структуру. Входные параметры:
//XML-ответ сервера
//кодировка, используемая на сайте. По умолчанию используется UTF-8
$structure = $parser->Parse($response, DOC_ENCODING);
//преобразуем индексы структуры к более удобным для доступа.
//лично я не понял зачем это, но с этим всё работает =)
$transformed = $parser->Reindex($structure, true);
//Если код выполнения запроса == 0 (запрос выполнен)
if($structure["w3s.response"]["retval"] == 0)
{
$state = $transformed["w3s.response"]["outinvoices"]["outinvoice"]["state"];
switch($state)
{
case 0:
echo "не оплачен";
break;
case 1:
echo "оплачен по протекции";
break;
case 2:
echo "оплачен окончательно";
break;
case 3:
echo "отказан";
break;
}
else echo $structure["w3s.response"]["retdesc"]; //Если ошибка, то выводим её.
?>`
Вот и всё. Осталось только реализовать учет выписки и оплаты счетов в вашей БД, и полноценный веб-магазин готов!
**3.Итого.** Надеюсь у меня получилось доступно изложить принципы автоматической работы в WM счетами, несмотря на то, что это — моя первая статья, на тему программирования. Буду рад вашим вопросам, на которые с радостью отвечу! | https://habr.com/ru/post/53805/ | null | ru | null |
# Koin — библиотека для внедрения зависимостей, написанная на чистом Kotlin
### Как управлять внедрением зависимостей с помощью механизма временной области (scope)
> Для будущих студентов курса ["Android Developer. Professional"](https://otus.pw/9kA2/) подготовили перевод полезной статьи.
>
> **Также приглашаем принять участие в открытом вебинаре на тему** [**"Пишем Gradle plugin"**](https://otus.pw/xg3w/)
>
>
---
### О чем эта статья
Вы узнаете, как с помощью модулей Koin ограничивать область живучести зависимостей, относящихся к конкретному компоненту. Вы также познакомитесь со стандартными областями Koin и способами работы с настраиваемыми областями.
### Введение
Разработчики ОС Android не рекомендуют использовать внедрение зависимостей (Dependency Injection, DI (англ.)), если в вашем приложении три экрана или меньше. Но если их больше, лучше применить DI.
Популярный способ реализации DI в Android-приложениях основан на фреймворке Dagger. Но он требует глубокого изучения. Одна из лучших альтернатив этому фреймворку — Koin, библиотека, написанная на чистом Kotlin.
Если вы уже пользовались Dagger или любой другой библиотекой для DI, то, скорее всего, знаете, насколько важен в этом процессе механизм временной области (scope). Он позволяет определять, в каких случаях нужно получать один и тот же зависимый объект, а в каких — новый. Он также помогает освобождать невостребованные ресурсы и память.
### Области в Koin
Концепция области в Koin аналогична таковой в Android. Она позволяет, например, ограничить область живучести модели представления (ViewModel) до определенной активности и использовать эту модель во фрагментах, которыми наполняется активность.
Как правило, в Koin три вида временных областей.
* `single` (одиночный объект) —создается объект, который сохраняется в течение всего периода существования контейнера (аналогично синглтону);
* `factory` (фабрика объектов) — каждый раз создается новый объект, без сохранения в контейнере (совместное использование невозможно);
* `scoped` (объект в области) — создается объект, который сохраняется в рамках периода существования связанной временной области.
Одиночный объект(single). Фабрика объектов(factory)Область вида `single` при каждом запросе возвращает один и тот же экземпляр, а `factory` каждый раз возвращает новый экземпляр.
#### Настраиваемая область
Стандартные области `single` и `factory` в Koin живут в течение жизненного цикла модулей Koin. Однако в реальных сценариях использования требования к внедрению зависимостей будут отличаться.
Зависимости обычно нужны только на определенный период времени. Например, репозиторий `OnBoardRepository` в Android-приложении требуется только при регистрации пользователя. Как только пользователь авторизуется, удержание этого репозитория в памяти станет лишней тратой ресурсов.
Чтобы добиться нужного поведения в Koin, можно воспользоваться API для работы с временными областями. В модуле Koin можно создать **область со строковым квалификатором** и объявить зависимости внутри нее с помощью уникальных квалификаторов. Давайте сделаем это шаг за шагом.
**Шаг 1**
Сначала создадим модуль, объявим пустую область и присвоим ей имя. В данном случае мы дали области имя `CustomScope`. Вы можете назвать ее в соответствии со своими требованиями. Вот как это выглядит:
```
creating custom koin scope
```
**Шаг 2**
Следующим шагом объявим необходимые зависимости с использованием областей `single` и `factory` в соответствии с требованиями проекта. Ключевой момент заключается в присвоении областям уникальных квалификаторов. Вот так:
```
dependencies inside custom scopes
```
**Шаг 3**
Мы закончили настройку в модуле Koin. На этом шаге нам нужно создать область из того компонента, из которого мы импортируем нужные зависимости. Обычно области создаются из Android-компонентов, например Activity, Fragment и т. п.
Чтобы создать область, сначала нам нужно получить существующий экземпляр компонента Koin, а затем вызвать функцию createScope, передав ей идентификатор и имя области.
```
val stringQualifiedScope = getKoin().createScope(
"ScopeNameID", named("CustomeScope"))
```
Получив CustomScope как значение параметра имени, Koin будет искать область, которую мы объявили под этим именем в модулях Koin. `ScopeNameID` — это идентификатор, который мы применяем, чтобы отличать одну область от другой. Он используется на внутреннем уровне в качестве ключа для поиска этой области.
Если вы обращаетесь к областям или создаете их из нескольких Android-компонентов, то вместо функции `createScope` рекомендуется использовать функцию `getOrCreateScope`. Из названий этих функций очевидно, что они делают.
**Шаг 4**
Наконец, создаем экземпляр зависимости, которую хотим использовать. Мы сделали это с помощью созданной нами области. Вот что получилось.
```
val sampleClass = stringQualifiedScope.get(
qualifier = named("scopedName"))
```
`scopedName` и `factoryName` — это квалификаторы, которые мы объявили внутри модуля Koin на шаге 2.
**Шаг 5**
Чтобы избавиться от зависимостей, созданных посредством **stringQualifiedScope**, в частности `sampleclass`, необходимо вызвать функцию `close`. Например, если вы хотите избавиться от созданных в этой области зависимостей при уничтожении активности, то нужно вызвать функцию `close` в рамках соответствующего метода `onDestroy`. Вот так:
```
override fun onDestroy() {
super.onDestroy()
stringQualifiedScope.close()
}
```
### Koin-Android
Выше описан общий подход к ограничению живучести зависимостей определенной временной областью. Его можно применять на любой платформе, поддерживаемой Koin. Будучи Android-разработчиком, теперь я бы хотел совместить механизмы области Koin и области жизненного цикла, чтобы свести к минимуму работу, которую мне приходится делать при каждом создании активности.
Для этого необходимо импортировать библиотеки Koin-Android. Добавьте следующие строки в узел dependencies файла `build.gradle` уровня приложения:
```
// Koin for Android
implementation "org.koin:koin-android:$koin_version"
// Koin Android Scope features
implementation "org.koin:koin-android-scope:$koin_version"
```
*Модули Koin-Android*
Теперь с целью сократить шаблонный код мы хотим, например, автоматически закрывать область в рамках метода `onDestroy` компонента Android. Это можно сделать путем привязки Koin к импорту зависимостей посредством `lifecyclescope`.
Для начала необходимо создать в модуле Koin область для зависимостей с компонентами Android. Как это сделать:
```
val androidModule = module {
scope {
scoped { SampleClass() }
}
}
```
*scoping dependency with android activity*
Затем нужно выполнить внедрение зависимости в активности при помощи `lifecyclescope`:
```
val sampleClass : SampleClass by lifecycleScope.inject()
```
Это позволит закрывать область при уничтожении активности, избавив нас от ручных операций. Вот так выглядит наш код:
```
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy() {
if (event == Lifecycle.Event.ON_DESTROY) {
scope.close()
}
}
}
```
Такой подход позволит автоматизировать работу по созданию областей, назначению квалификаторов и уничтожению областей. Кажется, что это простые действия, их можно выполнить и вручную. Но повторяющуюся работу важно автоматизировать, и по мере развития приложения это становится очевидно.
#### Дополнительные материалы
* Подробнее о внедрении зависимостей читайте [в другой статье о библиотеке Koin](https://medium.com/android-dev-hacks/koin-kotlin-native-dependency-injection-library-f1daddc1ef99).
* Чтобы узнать больше о Kotlin, прочитайте [вторую часть статьи о программировании на Kotlin (продвинутый уровень)](https://medium.com/android-dev-hacks/advanced-android-programming-with-kotlin-part-2-aae2a15258b0).
* Читайте о корутинах и других расширенных функциях Kotlin [в статье о том, как научиться комбинировать потоки в Kotlin](https://medium.com/@sgkantamani/learn-how-to-combine-kotlin-flows-317849a71d3e).
На этом все. Надеюсь, вы узнали что-то полезное для себя. Спасибо за внимание!
---
> [Подробнее о курсе](https://otus.pw/9kA2/) "Android Developer. Professional".Записаться на открытый урок "Пишем Gradle plugin" можно [здесь.](https://otus.pw/xg3w/)
>
> | https://habr.com/ru/post/530024/ | null | ru | null |
# Строковые коллекции только для чтения: экономим на спичках
Нередко случается, что какие-то данные программа загружает в память и оставляет их там надолго (а то и до конца работы) в неизменном виде. При этом используются структуры данных, оптимизированные как для чтения, так и для записи. Например, вы вычитываете из базы [Ensembl](http://www.ensembl.org/) список идентификаторов всех генов человека (включая всякие микроРНК и т. д. — всего чуть больше 50000). Если их прочитать в стандартный ArrayList, то на 32-битной HotSpot вы потратите чуть больше 4 мегабайт. Можно ли сэкономить память, зная, что коллекция больше не будет меняться?
Мы не будем касаться возможности чтения данных из базы по частям: это тема для отдельного разговора. Кроме того, чтение по частям вполне можно сочетать с описанными здесь подходами, добиваясь дополнительной экономии памяти. Также не будем использовать, например, опцию виртуальной машины -XX:+UseCompressedStrings: она экономит память не только в нашем случае и тоже может сочетаться с нашими методами.
Перед тем как что-то оптимизировать, надо это что-то измерить. В нашем случае речь об объёме памяти, занимаемой списком. Причём, разумеется, нас интересует не shallow size (размер самого объекта ArrayList), а retained size (размер ArrayList и всех объектов, на которые он ссылается прямо или косвенно). Замер произведём с помощью [Eclipse Memory Analyzer](http://www.eclipse.org/mat/). Найдём нужный объект в куче (например, по имени класса) и воспользуемся опцией Show retained set. Получим такую картину:
Как и предполагалось, сам ArrayList весит совсем немного — 24 байта. Прилично весит массив Object[] ссылок на строки, определённый внутри ArrayList, но всё же больше 90% места съедают сами объекты строк и связанные с ними массивы char[].
Небольшого улучшения можно добиться, если урезать массив Object[] до реального количества элементов. Как известно, ArrayList выделяет место с запасом, чтобы не выделять заново каждый раз, когда добавляется элемент. Раз мы знаем, что элементов больше не добавится, нам этот запас ни к чему. Просто и эффективно это сделать можно так:
```
List genes = readGenes();
genes = Arrays.asList(genes.toArray(new String[genes.size()]));
```
Здесь результат уже не ArrayList (точнее ArrayList, но другой). Мы сперва создаём копию массива нужной длины, а затем над копией делаем обёртку. Теперь retained set выглядит так:
Массив стал немного меньше, а в итоге мы сэкономили 0.44% места. Ну ничего, мы только разминаемся.
Посмотрим на эти массивы char[]. Они содержат идентификаторы генов типа «ENSG00000121410» (15 символов — 30 байт), ещё по 8 байт системной информации об объекте да по 4 байта длины. И эти 42 байта выравниваются по 8, то есть ещё добавляется 6 неиспользуемых байт. Таким образом из 48 байт только 30 несут полезную информацию (с +UseCompressedStrings их можно убавить до 15, тогда доля «лишней» информации ещё увеличится). Что с этим можно сделать?
Вспомним, как работает String.substring. Строка, которая получается в результате, делит общий буфер char[] с родительской строкой: в дочерней строке устанавливаются соответствующим образом значения offset и count. При этом дочерняя строка с точки зрения пользователя ничем не отличается от обычной, но если родительская была удалена, то полный буфер всё равно хранится, даже если вы от мегабайтной строки отрезали один символ. Иногда это напрягает, приходится выискивать такие места в коде и подписывать new String, но нам сейчас, наоборот, поможет. Мы посадим все строки массива на один буфер char[]. Для этого напишем вспомогательный метод в каком-нибудь утилитном классе:
```
public static List compactify(Collection list) {
StringBuilder sb = new StringBuilder();
for( String item : list ) sb.append(item);
String data = sb.toString();
List result = new ArrayList(list.size());
int index = 0;
for( String item : list ) {
result.add(data.substring(index, index + item.length()));
index += item.length();
}
return result;
}
```
Метод сперва склеивает все строки исходной коллекции в одну длинную строку, а потом нарезает её на подстроки с помощью substring. Прогоним наш список genes через эту, казалось бы, бесполезную операцию и посмотрим на retained set:
Ага, уже существенно. Сэкономили практически все те лишние байты, о которых говорилось выше, в сумме выиграв 24% от исходного размера. Если строки в вашем массиве короче 15 символов, то экономия будет ещё больше. Заметьте, кстати, что при создании ArrayList мы явно указали его длину, поэтому Object[] не содержит лишних элементов, то есть первую оптимизацию мы не потеряли.
Результирующий массив можно спокойно использовать и для записи, следует лишь иметь в виду, что любая строка из него тащит за собой все остальные, поэтому если мы вздумаем удалять строки, то освободим не всю память. Но так как мы договорились, что массив только для чтения, то всё хорошо. Будьте осторожны, если во входном массиве были повторные строки: функция этого не проверяет, и вы можете потерять на этом больше, чем приобрести.
Всё же 24% мало. Глаз режут объекты String, которые по сути не несут никакой пользы (сами данные-то в char[]). Может, можно их не хранить, а нарезать строку по требованию? Для этого нам придётся написать свою реализацию List и хранить смещения начал строк:
```
public class CompactStringList extends AbstractList implements RandomAccess {
private String data;
private int[] offsets;
public CompactStringList(Collection list) {
StringBuilder sb = new StringBuilder();
offsets = new int[list.size()];
int offset = 0, i = 0;
for( String item : list ) {
sb.append(item);
offsets[i++] = offset;
offset+=item.length();
}
data = sb.toString();
}
public String get(int index) {
return index == offsets.length - 1 ? data.substring(offsets[index]) :
data.substring(offsets[index], offsets[index + 1]);
}
public int size() {
return offsets.length;
}
}
```
В конструкторе мы снова склеили все входные строчки в одну, запоминая смещения начал строк в массив. При получении элемента (для простоты я не проверяю корректность параметра) мы отрезаем нужный кусок от строки. При этом создаётся только новый объект String, а сами данные не копируются. Взглянем на retained set такого объекта:
Теперь мы сэкономили 55.5% по сравнению с исходным вариантом, тут уже можно пускаться в пляс.
Конечно же, последняя оптимизация самая спорная и зависит от дальнейших сценариев использования. К примеру, если вы часто делаете get одного и того же элемента и полученные строки сохраняете в других коллекциях, у вас расплодятся объекты String. Хоть они и указывают на общий буфер, но по 40 байт на строку (в 32-битной HotSpot) вы потеряете. Не увлекайтесь оптимизациями ради оптимизаций: может получиться только хуже. Тем не менее, во многих приложениях этот метод может оказаться полезным. Ну или в крайнем случае расширит понимание возможностей Java некоторым читателям. | https://habr.com/ru/post/145145/ | null | ru | null |
# Задача о рюкзаке (Knapsack problem) простыми словами
Пару лет назад столкнулся с так называемой задачей о рюкзаке на одном из собеседований, нашел быстренько решение в интернете. Попытался разобрать и.... ничего не понял. Кое как поменял названия переменных, а кто так не делает когда находит готовое решение для home таски? Отправил и забыл как страшный сон. Недавно друг скинул подобную задачу про монеты и в этот раз я уже быстренько разобрался с этой когда то, как казалось мне неподъемной задачкой.
Хотел бы отметить книгу [Grokking Algorithms](https://www.manning.com/books/grokking-algorithms?gclid=Cj0KCQjwnueFBhChARIsAPu3YkSpwW6L1cpba8-KUENsSqkwOMABrPv94aDzm78QtftwPXbajE6BfG8aAsGjEALw_wcB) автора Aditya Bhargava. У нее прям максимально простым языком расписаны основы алгоритмов. Так что если, вы как и я в универе думали что алгоритмы вам никогда не пригодятся, потому что FAANG это не для вас. То я вас и разочарую и обрадую, попасть туда может каждый, если конечно приложит достаточно усилий, ну а разочарую тем что вам конечно придется поднапрячься и осилить алгоритмы и чем раньше вы начнете это делать, тем лучше.
На Хабре, уже есть одна статья на эту тему: [Алгоритм решения задачи о рюкзаке ( версия 2, исправленная) / Хабр (habr.com)](https://habr.com/ru/post/222577/) . Но, да простит меня автор, на мой взгляд она совершенно непонятная.
И так, перейду к делу. Сначала расскажу обо всем на пальцах, а потом мы рассмотрим решение на нашем любимом C#.
Собственно задача, одна из популярных её вариаций. Вор пробрался в ювелирный магазин, у него есть рюкзак объемом 4 единицы. В магазине, он увидел три вещи:
Вещи которые есть в магазинеЕго задача оптимально уместить эти вещи в рюкзаке так что бы он унес драгоценностей на максимальную стоимость.
Есть несколько способов решения. Один из них это перебор всех вариантов.
Для простоты, предмета будет только три, поскольку количество различных комбинаций в которых их можно унести растет очень быстро и даже для 3 предметов уже будет равно 8. Оно вычисляется по формуле **2n** где n - количество предметов, то есть если предмета будет 4, то количество возможных комбинаций достигнет уже 16 и так далее**.** Такой вариант нас не устроит поскольку решая эту задачу онлайн на каком-нибудь Codility ваше решение зарубят с Timeout Exceeded. Нужно что-то получше.
Мы будем решать эту задачу методом динамического программирования
Задача является одной из базовых в этой области и понимание её решения откроет вам дорогу к более сложным задачам. В динамическом программировании мы разбиваем базовую задачу на более простые и постепенно решая их все, в итоге находим решение основной.
Заполним небольшую табличку:
| | | | | |
| --- | --- | --- | --- | --- |
| | 1 | 2 | 3 | 4 |
| Ожерелье / 4000 / 4 ед | | | | |
| Кольцо / 2500 / 1 ед | | | | |
| Подвеска / 2000 / 3 ед | | | | |
С левой стороны у нас будут все вещи. При этом порядок в котором они расположены, в данной задаче нас не интересует. Количество колонок равно количеству потенциальных рюкзаков размером от 1, минимально возможного целого положительного числа, до размера нашего рюкзака, с шагом 1. Таким образом мы пытаемся решить ряд более мелких задач, для рюкзаков размером 1, 2, 3 и 4. Всегда ведь проще начинать с малого?)
| | | | | |
| --- | --- | --- | --- | --- |
| | 1 | 2 | 3 | 4 |
| Ожерелье / 4000 / 4 ед | 0 | 0 | 0 | 4000 |
Сверху у нас заполненный первый ряд. Мы можем использовать в каждом ряду, только вещь из этого ряда или вещи из верхних рядов.
Рюкзак размером 1: Ожерелье не влезет в рюкзак, значит стоимость того что мы можем унести равна 0.
Рюкзак размером 2: Ожерелье не влезет в рюкзак, значит стоимость того что мы можем унести равна 0.
Рюкзак размером 3: Ожерелье не влезет в рюкзак, значит стоимость того что мы можем унести равна 0.
Рюкзак размером 4: Здесь все становится немного интересней, вес ожерелья 4 и размер рюкзака 4. Ура, наконец то успех, мы не зря ворвались в магазин, кладем ожерелье в большой рюкзак и убегаем.
Немного усложним задачу и добавим еще одну вещь которая потенциально попадет в наш рюкзак. То что подсчитано мы не трогаем, оно нам потом пригодится.
| | | | | |
| --- | --- | --- | --- | --- |
| | 1 | 2 | 3 | 4 |
| Ожерелье / 4000 / 4 ед | 0 | 0 | 0 | 4000 |
| Кольцо / 2500 / 1 ед | 2500 | 2500 | 2500 | 4000 |
Добавилось кольцо. Делаем подсчеты для второго ряда:
Рюкзак размером 1: У нас добавилось кольцо и его размер как раз равен размеру даже самого маленького рюкзака. Но у нас ведь еще есть и ожерелье, мы уже проверили, оно не влезет. Кладем только кольцо.
Рюкзак размером 2: То же что и для размера 1. Кладем только кольцо.
Рюкзак размером 3: То же что и для размера 1. Кладем только кольцо.
Рюкзак размером 4: Здесь у нас есть выбор, либо положить только одно маленькое кольцо, либо взять ожерелье, которое тяжелее, но и стоит дороже. Забываем про кольцо, и возвращаемся за ожерельем!
Так, наконец добавим третий ряд
| | | | | |
| --- | --- | --- | --- | --- |
| | 1 | 2 | 3 | 4 |
| Ожерелье / 4000 / 4 ед | 0 | 0 | 0 | 4000 |
| Кольцо / 2500 / 1 ед | 2500 | 2500 | 2500 | 4000 |
| Подвеска / 2000 / 3 ед | 2500 | 2500 | 2500 | 4500 |
Рюкзак размером 1: Кольцо дороже подвески, да и подвеска не влезет, она по всем параметрам проигрывает вещам выше, берем кольцо размером 1.
Рюкзак размером 2: Тоже самое что и для размера 1.
Рюкзак размером 3: Несмотря на то что мы можем здесь взять подвеску, кольцо выигрывает ее по параметрам, снова кладем ее.
Рюкзак размером 4: А вот тут у нас, весь рюкзак, и все возможные вещи. И мы видим что кольцо и подвеска вместе стоят на 500 долларов дороже ожерелья и при этом все так же влезут в рюкзак. Значит мы возьмем и кольцо и подвеску стоимостью 4500 и весом как раз 4 единицы.
В правом нижнем углу у нас верный результат.
Ну и где же здесь пере использование спросите вы? Да, мы им не пользовались, потому что таблица была сравнительно простая. Но, если присмотреться то можно заметить закономерность!
Представим что для количества вещей у нас счетчик i, а для рюкзаков j.
На примере последней ячейки рассмотрим формулу в действии
Зеленым выделена первая опция, красным вторая. Как видим стоимость в красном круге перевешивает стоимость в зеленомИ собственно алгоритм задачи на языке C#:
```
public static int[] weights = { 4, 1, 3 };
public static int[] values = { 4000, 2500, 2000 };
public static int CountMax(int[] weights, int[] values, int maxCapacity)
{
//строим массив и закладываем место на ячейки пустышки
//выходящие из левого верхнего угла
int[,] arr = new int[weights.Length + 1, maxCapacity + 1];
//проходим по всем вещам
for (int i = 0; i <= weights.Length; i++)
{
//проходим по всем рюкзакам
for (int j = 0; j <= maxCapacity; j++)
{
//попадаем в ячейку пустышку
if (i == 0 || j == 0)
{
arr[i, j] = 0;
}
else
{
//если вес текущей вещи больше размера рюкзака
//казалось бы откуда значение возьмется для первой вещи
//при таком условии. А оно возьмется из ряда пустышки
if (weights[i - 1] > j)
{
arr[i, j] = arr[i - 1, j];
}
else
{
//здесь по формуле. Значение над текущей ячейкой
var prev = arr[i - 1, j];
//Значение по вертикали: ряд вверх
//и по горизонтали: вес рюкзака - вес текущей вещи
var byFormula = values[i - 1] + arr[i - 1, j - weights[i - 1]];
arr[i, j] = Math.Max(prev, byFormula);
}
}
}
}
// возвращаем правую нижнюю ячейку
return arr[weights.Length, maxCapacity];
}
```
Всем побед и удачных собесов! | https://habr.com/ru/post/561120/ | null | ru | null |
# Браузер и числа с плавающей запятой
*Изображение — [www.freepik.com](https://www.freepik.com/vectors/design)*
Несколько лет назад я много думал и писал о математике с плавающей запятой. Это было очень интересно, и в процессе исследований я многое узнал, но иногда я долгое время не *использую* на практике все эти полученные тяжким трудом знания. Поэтому мне необыкновенно приятно каждый раз, когда приходится работать над багом, требующим различных специализированных знаний. В статье я расскажу три истории о багах чисел с плавающей запятой, изученных мной в Chromium.
Часть 1: нереальные ожидания
----------------------------
Баг назывался «JSON некорректно парсит 64-битные Integer»; поначалу это непохоже на проблему с плавающей запятой или браузером, но его отправили на crbug.com, поэтому меня попросили взглянуть. Проще всего воссоздать его, открыв инструменты разработчика Chrome (F12 или Ctrl+Shift+I) и вставив в консоль разработчика следующий код:
```
json = JSON.parse(‘{“x”: 2940078943461317278}’); alert(json[‘x’]);
```
Вставка неизвестного кода в окно консоли — замечательный способ оказаться взломанным, но этот код был настолько прост, я смог понять, что он не вредоносный. В отчёте о баге автор любезно указал свои ожидания и реальные результаты:
> Каково ожидаемое поведение? Должно возвращаться целочисленное значение 2940078943461317278.
>
> В чём ошибка? Вместо него возвращается целочисленное 2940078943461317000.
«Баг» обнаружили под Linux, а я работаю над Chrome для Windows, но это поведение кроссплатформенное, а у меня были знания о числах с плавающей запятой, поэтому я его исследовал.
Такое поведение целых чисел потенциально является багом «плавающей запятой», потому что на самом деле в JavaScript нет типа integer. И по той же причине это на самом деле не баг.
Вводимое число довольно велико, оно примерно равно 2.9e18. И в том-то и проблема. Поскольку в JavaScript нет типа integer, он использует для чисел [IEEE-754 floating-point double-precision](https://www.w3schools.com/js/js_numbers.asp). Этот двоичный формат с плавающей запятой имеет бит знака, 11-битную экспоненту и 53-битную мантиссу (да, это 65 бит, [один бит прячется благодаря магии](https://en.wikipedia.org/wiki/Double-precision_floating-point_format)). Этот тип double так хорошо подходит для хранения integer, что многие программисты на JavaScript никогда не замечали, что типа integer нет. Однако очень большие числа разрушают эту иллюзию.
Число JavaScript может с точностью хранить любое целое значение до 2^53. После этого оно может хранить все чётные числа до 2^54. А после этого оно может хранить все кратные четырём числа до 2^55, и так далее.
Проблемное число выражено в экспоненциальной записи по основанию 2, оно примерно равно 1,275 \* 2^61. В этом интервале можно выразить только очень малое количество целых чисел — расстояние между числами равно 512. Вот три соответствующих числа:
* 2 940 078 943 461 317 278 — число, которое хотел сохранить автор отчёта о баге
* 2 940 078 943 461 317 120 — ближайшее к этому числу double (меньше него)
* 2 940 078 943 461 317 632 — следующее ближайшее к числу double (больше него)
Нужное нам число находится в промежутке между этими двумя double и модуль JSON (например сам JavaScript или любая другая корректно реализованная функция преобразования текста в double) сделал всё возможное и вернул ближайшее double. Проще говоря, число, которое хотел сохранить автор отчёта, *нельзя сохранить во встроенном числовом типе JavaScript*.
Пока всё понятно: если вы достигаете пределов языка, то вам нужно больше знать о том, как он работает. Но остаётся ещё одна загадка. В баг-репорте написано, что на самом деле возвращается такое число:
> 2 940 078 943 461 317 000
Ситуация любопытная, потому что это не введённое число, не ближайшее double и, на самом деле, даже не число, которое можно представить как double!
Эта загадка тоже объясняется спецификацией JavaScript. В спецификации сказано, что при печати числа реализация должна выводить достаточное для его уникальной идентификации количество цифр, и не больше. Это удобно при печати чисел наподобие 0,1, которые невозможно точно представить в виде double. Например, если бы JavaScript требовал, чтобы 0,1 выводилось как хранимое значение, то он бы вывел:
> 0.1000000000000000055511151231257827021181583404541015625
Это будет *точным результатом*, но такое бы просто сбивало людей с толку, не добавляя ничего полезного. Конкретные правила можно [найти здесь](http://www.ecma-international.org/ecma-262/5.1/#sec-9.8.1) (ищите строку «ToString Applied to the Number Type»). Не думаю, что спецификация *требует* конечных нулей, но она определённо их допускает.
Итак, при работе программы JavaScript выводит 2 940 078 943 461 317 000, потому что:
* Значение исходного числа было потеряно при сохранении в виде числа JavaScript
* Выводимое число достаточно близко к хранимому значению, чтобы уникально идентифицировать его
* Выводимое число — это простейшее число, уникальным образом идентифицирующее хранимое значение
Всё работает, как и должно, это не баг, проблема закрыта как WontFix («неисправимая»). Исходный баг можно найти [здесь](https://bugs.chromium.org/p/chromium/issues/detail?id=1022456).
Часть 2: плохой эпсилон
-----------------------
В этот раз я на самом деле устранил баг, сначала в Chromium, а потом в googletest, чтобы избавить от путаницы будущие поколения разработчиков.
[](https://test-results.appspot.com/dashboards/flakiness_dashboard.html#)
Этот баг был [недетерминированным сбоем теста](https://bugs.chromium.org/p/chromium/issues/detail?id=786046), который начал происходить внезапно. Мы ненавидим такие нечёткие сбои тестов. Особенно они сбивают с толку, когда начинают происходить в тесте, который не менялся годами. Спустя несколько недель к расследованию привлекли меня. Сообщения об ошибках (немного изменённые для длины строк) начинались примерно так:
> The difference between expected\_microseconds and converted\_microseconds is 512, which exceeds 1.0 [Разность между expected\_microseconds и converted\_microseconds равна 512, что превышает 1.0]
Да, звучит плохо. Это сообщение об ошибке [googletest](https://github.com/google/googletest), говорящее, что два значения с плавающей запятой, которые расстояние между которыми должно быть не больше 1.0, на самом деле отдалены друг от друга на 512.
Первой уликой стала разность между числами с плавающей запятой. Казалось очень подозрительным, что два числа разделены ровно значением 2^9. Совпадение? Не думаю. Оставшаяся часть сообщения, в которой указывались два сравниваемых значения, ещё сильнее убедили меня в причине:
> expected\_microseconds evaluates to 4.2934311416234112e+18,
>
> converted\_microseconds evaluates to 4.2934311416234107e+18
Если вы достаточно долго боролись с [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754), то сразу же поймёте, что происходит.
> Вы прочитали первую часть, поэтому можете ощутить дежавю из-за одинаковых величин чисел. Однако это чистое совпадение — я просто использую те числа, с которыми столкнулся. На этот раз они выводились в экспоненциальном формате, что немного разнообразит статью.
Основная проблема является вариацией проблемы из первой части: числа с плавающей запятой в компьютерах отличаются от используемых математиками вещественных чисел. При увеличении они становятся менее точными, и в интервале чисел непройденного теста все значения с двойной точностью обязательно были кратными 512. Double имеет 53 бит точности, а эти числа были намного больше 2^53, поэтому значительное снижение точности было неизбежным. И теперь мы можем понять проблему.
Тест вычислял одинаковое значение двумя разными способами. Затем он проверял, близки ли результаты, причём под «близостью» подразумевалась разность в пределах 1.0. Способы вычислений давали очень схожие ответы, поэтому в большинстве случаев результаты округлялись до одинакового значения с двойной точностью. Однако *время от времени* правильный ответ оказывается рядом с перегибом, и одно вычисление округляет одним образом, а второе — другим.
Если конкретнее, то в результате сравнивались следующие числа:
* 4293431141623410688
* 4293431141623411200
Без экспонент заметнее, что они разделены ровно 512. Два бесконечно точных результата, генерируемых тестовыми функциями, всегда отличались менее чем на 1.0, то есть когда они были значениями типа 429…10653.5 and 429…10654.3, оба округлялись до 429…10688. Проблема возникала, когда бесконечно точные результаты были близки к значению типа 4293431141623410944. Это значение ровно посередине между двумя double. Если одна функция генерирует 429…10943.9, а другая 429…10944.1, то эти результаты, разделённые величиной всего 0.2, округлялись в разных направлениях и оказывались на расстоянии 512!
Такова природа перегиба, или ступенчатой функции. Можно получить два результата, произвольно близкие друг к другу, но находящиеся на противоположных сторонах перегиба — точки ровно посередине между двумя — а потому округляющиеся в разных направлениях. Часто рекомендуется сменить режим округления, однако это не помогает — при этом всего лишь смещается точка перегиба.
Это похоже на рождение ребёнка примерно в полночь — крошечное отклонение может навсегда изменить дату (а может быть год, век или тысячелетие) регистрации события.
Возможно, моё примечание к коммиту было чересчур драматичным, зато безошибочным. Я ощущал себя уникальным специалистом, способным справиться с этой ситуацией:
> commit [6c2427457b0c5ebaefa5c1a6003117ca8126e7bc](https://crrev.com/6c2427457b0c5ebaefa5c1a6003117ca8126e7bc)
>
> Author: Bruce Dawson
>
> Date: Fri Dec 08 21:58:50 2017
>
>
>
> Fix epsilon calculation for large-double comparisons
>
>
>
> My whole life has been leading up to this bug fix. [Вся моя жизнь вела меня к устранению этого бага.]
И в самом деле, мне нечасто удаётся внести изменение в Chromium с [примечанием к коммиту, в котором вполне обоснованно есть ссылки на два (2!) моих поста](https://chromium-review.googlesource.com/816053).
Исправление в этом случае заключалось в вычислении разности между двумя соседними double с величиной вычисляемых значений. Это было реализовано при помощи редко используемой функции [nextafter](https://en.cppreference.com/w/cpp/numeric/math/nextafter). Примерно так:
```
epsilon = nextafter(expected, INFINITY) – expected;
if (epsilon < 1.0)
epsilon = 1.0;
```
Функция *nextafter* находит следующее double (в данном случае в направлении бесконечности), а вычитание (которое выполняется точно, и это очень удобно) затем находит разность между double при их величине. Тестируемый алгоритм давал погрешность 1.0, поэтому epsilon должен быть не больше этого значения. Благодаря такому вычислению epsilon стало очень легко проверять, находятся ли значения на расстоянии меньше 1.0 или являются соседними double.
Я так и не изучал причину того, почему тест внезапно начал давать сбои, но подозреваю, что дело в частоте таймера или изменении точки запуска таймера, из-за чего числа стали больше.
> Только что проверил. Тест использует несколько симулируемых счётчиков [QueryPerformanceCounter](https://docs.microsoft.com/en-us/windows/win32/api/profileapi/nf-profileapi-queryperformancecounter) (QPC), в том числе ::max(), или 2^63-1. Это нереалистично высокое число, и именно оно приводит к сбоям. Применив вычисления к выводимым ошибкам, можно понять, что при появлении сбоя использовалась [частота QPC](https://docs.microsoft.com/en-us/windows/win32/api/profileapi/nf-profileapi-queryperformancefrequency) 2 148 МГц. Когда тест был надёжным, частота QPC, вероятно, была выше, возможно, равной частоте процессора, или около 3 ГГц. При такой высокой частоте QPC тестовое значение 2^63-1 интерпретировалось бы как гораздо более короткое время, что позволило бы избежать такого недетерминированного сбоя.
>
>
>
> Следовательно, этот сбой начал проявляться, когда смена машины или ОС снизила частоту QueryPerformanceCounter.
Исправляем googletest
---------------------
Меня раздражало то, что для понимания проблемы требовались эзотерические знания об особенностях чисел с плавающей запятой, поэтому я [захотел исправить googletest](https://github.com/google/googletest/issues/1350). Моя первая попытка закончилась плохо.
Изначально я попробовал исправить googletest, сделав так, чтобы EXPECT\_NEAR выдавал сбой при передаче незначимо малого эпсилон, однако, похоже, множество тестов внутри Google, а также, вероятно, гораздо большее количество за пределами Google, неправильно используют EXPECT\_NEAR при значениях double. Они передают значение эпсилон, которое слишком мало, чтобы быть полезным, однако сравниваемые ими числа одинаковы, поэтому тест завершается успешно. Я исправил с десяток точек использования EXPECT\_NEAR, не приблизившись к решению проблемы, поэтому сдался.
И только при написании этого поста (почти спустя три года после появления бага!) я осознал, как можно безопасно и легко исправить googletest. Если код использует EXPECT\_NEAR со слишком малым эпсилон, и тест проходит успешно (то есть значения на самом деле равны), то это не вызывает проблем. Проблемой это становится только тогда, когда тест выдаёт сбой, поэтому мне достаточно было искать слишком малые значения эпсилон только в случае *сбоя* и отображать при этом информативное сообщение.
Я [внёс это изменение](https://github.com/google/googletest/commit/b5687db554a295e697f5d459cf6d3f343d2ca179#diff-9284ae098945ddfc48ad41d72fd5e687) и теперь сообщение об ошибке для этого сбоя 2017 года выглядит так:
> Разность между expected\_microseconds и converted\_microseconds равна 512, где
>
> expected\_microseconds равно 4.2934311416234112e+18,
>
> converted\_microseconds evaluates to 4.2934311416234107e+18.
>
> Параметр abs\_error равен 1.0, что меньше минимального расстояния между double для чисел этого порядка величин, равного 512; поэтому эта проверка EXPECT\_NEAR становится эквивалентной EXPECT\_EQUAL. Рекомендуется использовать вместо неё EXPECT\_DOUBLE\_EQ.
Следует учесть, что EXPECT\_DOUBLE\_EQ на самом деле не проверяет равенство, она проверяет, равны ли double в четырёх единицах в последнем знаке (units in the last place, ULP). Подробнее об этой концепции можно прочитать в моём посте [Comparing Floating Point Numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).
Я надеюсь, что большинство разработчиков ПО увидит это новое сообщение об ошибке и выберет нужный путь, и считаю, что исправление googletest в конечном итоге более важно, чем исправление теста Chromium.
Часть 3: когда x+y=x (y != 0)
-----------------------------
Это ещё одна вариация проблем с точностью при приближении к границам: возможно, я просто снова и снова нахожу один баг чисел с плавающей запятой?
В этой части я также опишу методики отладки, которые можно применять, если вы хотите исследовать исходный код Chromium или изучить причину сбоя.
Когда я наткнулся эту проблему, то отправил отчёт о баге с названием "[Сбой с ошибкой OOM (Out of Memory) в chrome://tracing при увеличении изображения зумом](https://bugs.chromium.org/p/chromium/issues/detail?id=1039830)"; это не походит на баг чисел с плавающей запятой.
Как обычно, я не искал себе проблем, а просто изучал трассировки chrome://tracing, пытаясь понять некоторые события; внезапно появилась печальная вкладка — произошёл сбой.
Просматривать и загружать последние сбои Chrome можно по адресу chrome://crashes, но я хотел загрузить аварийный дамп в отладчик, поэтому посмотрел, где они хранятся локально:
> %localappdata%\Google\Chrome\User Data\Crashpad\reports
Я загрузил самый последний аварийный дамп в windbg (подойдёт и Visual Studio), а затем приступил к расследованию. Так как у меня были сконфигурированы серверы символов Chrome и Microsoft, а также включен сервер исходных кодов, отладчик автоматически скачал PDB (отладочную информацию) и необходимые исходные файлы. Учтите, что подобная схема доступна всем — вам не нужно быть сотрудником Google или разработчиком Chromium, чтобы эта магия работала. Инструкции по настройке отладки Chrome/Chromium можно найти [здесь](https://www.chromium.org/developers/how-tos/debugging-on-windows). Для автоматического скачивания исходного кода требуется установка Python.
Анализ сбоя показал, что ошибка out-of-memory происходит из-за того, что функция *v8* (движка JavaScript) *NewFixedDoubleArray* пытается выделить массив с 75 209 227 элементами, а максимальный размер, допускаемый в этом контексте, составляет 67 108 863 (0x3FFFFFF в шестнадцатеричном виде).
В тех сбоях, которые я вызвал сам, удобно то, что можно попытаться воссоздать их при более внимательном мониторинге. Эксперименты показали, что при зуминге память оставалась стабильной, пока я не добирался до критической точки, после чего использование памяти внезапно взлетало до небес, а вкладка вылетала, даже если я ничего не делал.
Проблема здесь заключалась в том, что я запросто мог просмотреть стек вызовов для этого сбоя, но только в части кода Chrome на C++. Однако, по видимому, сам баг возникал в JavaScript-коде chrome://tracing. Я попробовал потестировать его с canary-сборкой Chrome (ежедневной) под отладчиком, и получил следующее любопытное сообщение:
> ==== JS stack trace ======================================
К сожалению, за этой интересной строчкой не шло никакой трассировки стека. Немного побродив в дебрях [git](https://git-scm.com/), я выяснил, что возможность вывода стеков вызовов JS по OOM [была добавлена в 2015 году](https://codereview.chromium.org/1149623010), после чего [удалена в декабре 2019 года](https://chromium-review.googlesource.com/c/v8/v8/+/1967377).
Я исследовал этот баг в начале января 2020 года (помните те старые добрые времена, когда всё было невинней и проще?), и это значило, что код трассировки стека OOM был удалён из ежедневной сборки, но по-прежнему оставался в стабильной сборке…
Поэтому моим следующим шагом стала попытка воссоздания бага в стабильной версии Chrome. Это дало мне следующие результаты (я немного подредактировал их для понятности):
> 0: ExitFrame [pc: 00007FFDCD887FBD]
>
> 1: drawGrid\_ [000016011D504859] [chrome://tracing/tracing.js:~4750]
>
> 2: draw [000016011D504821] [chrome://tracing/tracing.js:4750]
Если вкратце, то сбой OOM вызывался [*drawGrid\_*](https://source.chromium.org/chromium/chromium/src/+/master:third_party/catapult/tracing/tracing/ui/tracks/x_axis_track.html;l=78?q=drawGrid_), которую я нашёл (при помощи [страницы поиска кода Chromium](https://source.chromium.org/)) в x\_axis\_track.html. Немного похакав этот файл, я сузил проблему до вызова *updateMajorMarkData*. Эта функция содержит цикл, выполняющий вызов функции *majorMarkWorldPositions\_.push*, которая и является виновницей проблемы.
> Здесь стоит сказать, что хотя я и разрабатываю браузер, я остаюсь худшим в мире программистом на JavaScript. Навык системного программирования на C++ не даёт мне магических навыков «фронтендера». Хакинг JavaScript для понимания этого бага был для меня довольно мучительным процессом.
Цикл (который можно посмотреть [здесь](https://source.chromium.org/chromium/chromium/src/+/master:third_party/catapult/tracing/tracing/ui/timeline_viewport.html;l=317?q=updateMajorMarkData)) выглядел примерно так:
```
for (let curX = firstMajorMark;
curX < viewRWorld;
curX += majorMarkDistanceWorld) {
this.majorMarkWorldPositions_.push(
Math.floor(MAJOR_MARK_ROUNDING_FACTOR * curX) /
MAJOR_MARK_ROUNDING_FACTOR);
}
```
Я добавил перед циклом [операторы вывода отладочной информации](https://www.w3schools.com/jsref/met_console_log.asp) и получил показанные ниже данные. Когда я приближал изображение зумом, то критически важные, но недостаточные для вызова сбоя числа выглядели так:
> firstMajorMark: 885.0999999642371
>
> majorMarkDistanceWorld: 1e-13
Затем я приближал изображение так, чтобы вызвать сбой, и получал примерно такие числа:
> firstMajorMark: 885.0999999642371
>
> majorMarkDistanceWorld: 5e-14
Число 885, разделённое на 5e-14, равно 1.8e16, а точность числа двойной точности с плавающей запятой равна 2^53, то есть 9.0e15. Следовательно, баг возникает, когда majorMarkDistanceWorld (расстояние между точками сетки) настолько мало относительно firstMajorMark (расположения первой основной метки сетки), что сложение в цикле… ничего не делает. То есть если мы прибавляем маленькое число к большому, то когда маленькое «слишком мало», большое число может (в стандартном/sane режиме округления к ближайшему) оставаться равным тому же значению.
Из-за этого цикл работает бесконечно, а команда push выполняется, пока массив не упрётся в пределы размеров. Если бы ограничений размера не было, то команда push продолжала бы выполняться, пока память не закончится у всей машины. Так что ура, проблема решена?
Исправление оказалось довольно простым — не выводить метки сетки, если мы не можем этого сделать:
```
if (firstMajorMark / majorMarkDistanceWorld > 1e15) return;
```
[](https://chromium-review.googlesource.com/c/catapult/+/1991805/4#message-c6970044835eed9f36fbd4ac1a971d93f833ba6d)
Как это довольно часто бывает с теми изменениями, которые я вношу, [мой багфикс](https://chromium-review.googlesource.com/c/catapult/+/1991805) состоял из одной строки кода и шестистрочного комментария. Я удивлён только тому, что там не было пятидесятистрочного примечания к коммиту пятистопным ямбом, нотной нотации и поста в блоге. Хотя постойте-ка…
К сожалению, кадры стеков JavaScript по-прежнему не выводятся при сбоях, вызванных OOM, потому что для записи стеков вызовов требуется память, а значит, на данном этапе это небезопасно. Не совсем понимаю, как бы я расследовал этот баг сегодня, когда кадры стеков OOM удалили полностью, но уверен, что нашёл бы способ.
Итак, если вы JavaScript-разработчик, пытающийся использовать чрезвычайно большие числа, создатель тестов, пытающийся использовать самое большое значение integer или реализуете UI с неограниченным зумом, то важно помнить, что при приближении к границам математики с плавающей запятой эти границы можно и пробить.
---
#### На правах рекламы
[Серверы для разработки](https://vdsina.ru/cloud-servers?partner=habr148) — это **эпичные** от Вдсины.
Используем исключительно быстрые NVMe накопители от Intel и [не экономим на железе](https://habr.com/ru/company/vdsina/blog/514570/) — только брендовое оборудование и самые современные решения на рынке!
[](https://vdsina.ru/cloud-servers?partner=habr148) | https://habr.com/ru/post/525048/ | null | ru | null |
# Как исправить баг с Drawable.setTint в API 21 Android SDK
Привет, в этой заметке наш android-разработчик [Влад Титов](https://habr.com/ru/users/VirtualAD/) расскажет о том, как решить проблему с использованием инструмента изменения цвета для Drawable. Поехали.
В 21 версии API Android SDK появился универсальный инструмент изменения цвета для всех Drawable - *Drawable.setTint(int color)*. Но как раз-таки в этой самой версии он не работает у некоторых наследников Drawable, а именно GradientDrawable, InsetDrawable, RippleDrawable и всех наследников DrawableContainer.
Если посмотреть в исходники API 21, скажем, GradientDrawable (прямого наследника Drawable), мы не найдем переопределенного метода *setTint* и его вариаций. А это значит, что в данной реализации разработчики попросту не поддержали эту функцию.
Проблему условно решили в библиотеке обратной совместимости. Сейчас ее можно найти по артефакту *androidx.core:core*. Чтобы поддержать *tinting* на версиях 14-22, были созданы обертки WrappedDrawableApi14 и WrappedDrawableApi21. Последняя является наследницей первой и, по сути, не несет логики по поддержке окрашивания.
Чтобы обернуть оригинальный Drawable, нужно всего лишь подать его в метод *DrawableCompat.wrap(Drawable)*. Основная идея состоит в том, что сам ColorStateList тинта хранится в обертках, а у оригинального Drawable изменяется цветовой фильтр при изменении состояния Drawable.
```
final ColorStateList tintList = mState.mTint;
final PorterDuff.Mode tintMode = mState.mTintMode;
if (tintList != null && tintMode != null) {
final int color = tintList.getColorForState(state, tintList.getDefaultColor());
if (!mColorFilterSet || color != mCurrentColor || tintMode != mCurrentMode) {
setColorFilter(color, tintMode);
mCurrentColor = color;
mCurrentMode = tintMode;
mColorFilterSet = true;
return true;
}
} else {
mColorFilterSet = false;
clearColorFilter();
}
```
*Данный кусок кода будет вызываться каждый раз при вызове Drawable.setState(int[] stateSet).*
При использовании этих оберток вы теряете возможность вызывать специфические методы для конкретных Drawable. Так, например, при оборачивании GradientDrawable вы не сможете управлять градиентом, так как обертка в своем интерфейсе не имеет методов таких, как *setShape, setGradientType* и.т.п. Чтобы получить доступ к данным методам, обернутый Drawable придется развернуть (*DrawableCompat.unwrap(Drawable)*). Но в таком случае вы теряете тинт. Если он у вас состоял только из одного цвета, ничего страшного, ведь этот цвет сохранится как цветовой фильтр в оригинальном Drawable. Но если тинт был *stateful*, цвета для стейтов, отличных от текущего, будут потеряны.
Выходом из сложившейся ситуации может быть пример, приведенный далее.
Если ваш тинт состоит лишь из одного цвета, вы можете в любой момент выполнить следующие действия:
```
val wrapped = DrawableCompat.wrap(drawable)
wrapped.setTint(...)
drawable = DrawableCompat.unwrap(wrapped)
```
После чего смело делать дальше свои дела.
В ином случае есть смысл воспользоваться следующим решением:
```
class GradientDrawableWrapper(
val original: GradientDrawable,
var tint: ColorStateList
) {
fun get(): Drawable {
return wrap()
}
fun setShape(@Shape shape: Int) {
original.setShape(shape)
}
// other specific method proxies...
private fun wrap(): Drawable {
val wrapped = DrawableCompat.wrap(original)
wrapped.setTint(tint)
return wrapped
}
}
```
Такое решение выглядит немного объемным, но полностью решает указанную проблему. | https://habr.com/ru/post/527138/ | null | ru | null |
# Разделить пользователей по ролям в FeathersJs
Речь пойдет о недооцененном фреймворке [feathersjs](https://feathersjs.com/).
В двух словах как он работает вы можете почитать [тут](https://habrahabr.ru/company/kickidler/blog/322210/). Одним рабочим утром мне в месседжере пришло новое ТЗ и описано оно было следующим образом: нужно разделить пользователей для 2-х сервисов (то есть что бы бэк обрабатывал запросы на аутентификацию с двух разных фронтов).
То есть мы имеем: 2 разделенных фронта написанных на VueJs, находящихся на разных доменах именах, общий backend написанный на feathers (и естественно одну таблицу users в бд с ролью).
То есть таблица может содержать 2 вот таких поля
```
email pass project
+------------+--------+-------
1@gmail.com 123 front_one
1@gmail.com 123 front_two
```
Естественно пароль хэширован.
В качестве модуля для входа в сервис мы используем [feathers-authentication](https://github.com/feathersjs/authentication) (адаптированная для feathers версия [passportjs](http://www.passportjs.org/)).
И так, что касается local login то тут все просто. Для того что бы нам определить откуда на бэк пришел запрос с парой логин/пароль в тело запроса на фронте можно вставить еще один параметр, например «project», и по этому параметру искать в базе нужного пользователя.
Чуть подробнее как сделать local auth пользователя. Я создал отдельный файл для аунтификации (именно файл, а не генерировал сервис) auth.js, подключил его в app.js. Так auth.js примерно будет выглядить у вас
```
const authentication = require('feathers-authentication');
const jwt = require('feathers-authentication-jwt');
const local = require('feathers-authentication-local');
const oauth2 = require('feathers-authentication-oauth2');
const FacebookStrategy = require('passport-facebook');
const commonHooks = require('feathers-hooks-common');
module.exports = function () {
const app = this;
const config = app.get('authentication');
app.configure(authentication(config));
app.configure(jwt());
app.configure(local(config.local));
app.service('authentication').hooks({
before: {
create: [
commonHooks.lowerCase('email'),
authentication.hooks.authenticate(config.strategies)
],
remove: [
authentication.hooks.authenticate('jwt')
]
}
});
};
```
В общем сейчас в нем нет ничего интересного, единственное хотел бы отметить, что я не вынес hooks в отдельных файл (как это происходит, когда вы вызываете стандартный generate service), и добавил hook commonHooks.lowerCase('email') — думаю понятно для чего он нужен.
А теперь добавим немного магии. Покопавшись в документации я нашел [класс verifier](https://docs.feathersjs.com/api/authentication/local.html#verifier), который можно расширить и дописать свой ф-ционал. Я добавил в анонимную ф-цию новую конфигурацию для local auth
```
app.configure(local({ Verifier: CustomVerifier }));
```
и вызвал мой новый класс
```
class CustomVerifier extends Verifier {
verify(req, username, password, done) {
return this.app.service('users').find({
query: {
email: username,
roles: req.query.project
}
}).then(res => {
const user = res.data[0];
if (user) {
const userId = res.data[0].id;
this._comparePassword(user, password).then(() => {
if (!user.isVerified) {
done(null)
} else {
done(null, user, { userId: userId });
}
}).catch(err => {
done(null)
})
} else {
done(null)
}
})
}
}
```
Что же этот класс делает? Сначала мы подключаемся к сервису users — this.app.service('users') — и вызываем метод find с параметром query. То есть мы ищем в бд нужного нам пользователя по двум полям и если его находим то в ответе (переменная res) будет массив найденых пользователей, если пользователи не найдены, то массив вернется пустой. Потом мы вызываем ф-цию
```
this._comparePassword()
```
куда передаем в качестве параметра найденного пользователя и пароль который пришел с фронта. Ф-ция \_comparePassword хэширует пароль и сравнивает его с тем паролем, который лежит в бд и если пароль совпадает то мы вызываем в then()
```
done(null, user, { userId: userId });
```
где первый аргумент это объект ошибки, второй — текущий пользователь, третий — id пользователя в бд, done() в свою очередь возвращает корректный токен. Если передать в done() единственный аргумент null, то статус запроса станет 401, а в ответе мы получим
```
сlassName:"not-authenticated"
code:401
errors:{}
message:"Error"
name:"NotAuthenticated"
```
И на этом дело бы закончилось, но в наш сервис можно так же зайти через facebook. Для того что бы это было возможно, в анонимную ф-цию нужно добавить следующее:
```
app.configure(oauth2(Object.assign({
name: 'facebook',
Strategy: FacebookStrategy,
Verifier: CustomVerifierFB
}, config.facebook)));
```
В этом коде опять же нас интересует только один параметр: «Verifier: CustomVerifierFB». Мы, как и в случае c локальной регистрацией, расширяем встроенный класс Verifier. При login через fb на фронте не отправляется запрос на определенный URL на бэке, а осуществляется переход по ссылке, то есть на фронте будет это выглядеть так:
```
[Войти через Fb](/auth/facebook)
```
Если в двух словах, то после нажатия на ссылку произойдет редирект на бэк, бэк средиректит на FB, FB средиректит на бэк, бэк запишет в cookies сгенерированный токен, и отправит на главную страницу фронта. На фронте же вам нужно распарсить cookies и следующие запросы отправлять на бэк уже с новым токеном.
И не было бы этой статьи, но не мало времени я потратил на вопрос — А как же собственно узнать откуда пришел пользователь?
Ответ оказался достаточно простым. Перед регистрацией компонента для входа через FB нужно сделать так:
```
app.get('/auth/facebook', (req, res, next) => {
referOrigin = req.headers.referer
next();
})
app.configure(oauth2(Object.assign({
name: 'facebook',
Strategy: FacebookStrategy,
Verifier: CustomVerifierFB
}, config.facebook)));
```
То есть мы отлавливаем переход на '/auth/facebook', и записываем в глобальную переменную (referOrigin) значение req.headers.referer и запускаем регистрацию oauth2(). Таким образом мы получаем значение хоста, в глобальной переменной и можем использовать это значение в классе CustomVerifierFB, который будет выглядеть примерно так:
```
class CustomVerifierFB extends Verifier {
verify(req, accessToken, refreshToken, profile, done) {
const refer = referOrigin
let roles = ''
if (refer === 'front_one') {
roles = 'front_one'
} else {
roles = 'front_two'
}
return this.app.service('users').find({
query: {
facebookId: profile.id,
roles: roles
}
}).then(res => {
if (res.data[0]) {
done(null, res.data[0], { userId: res.data[0].id });
} else {
return this.app.service('users').create({
facebookId: profile.id,
email: profile._json.email,
first_name: profile._json.first_name,
last_name: profile._json.last_name,
gender: profile._json.gender,
avatar: profile._json.picture.data.url,
roles: roles,
isVerified: true,
username: profile._json.email + 'whereFromUser'
}).then(createRes => {
done(null, createRes, { userId: createRes.id });
})
}
})
}
}
```
В ф-ции verify мы проделали следующее:
* this.app.service('users').find() — ищем, есть ли в базе пользова с facebookId, который пришел нам в качестве ответа с FB
* done(null, res.data[0], { userId: res.data[0].id }) — если есть, то создаем новый токен и возвращаем его на фронт
* this.app.service('users').create() если не нашли, то создаем такого пользователя и потом вы зываем done()
Вот так я решил задачу по разделению пользователей для двух разных фронтов.
PS — потом напишу как я сделал восстановление паролей для 2-х групп пользователей | https://habr.com/ru/post/346170/ | null | ru | null |
# Автоконфигурация с помощью Puppet и AWS Cloud Formation
Вот и настал тот день, когда пришлось отложить в сторону кукбуки, рецепты, нож шеф-повара и немного позаниматься кукловодством.
Для начала постановка задачи довольно тривиальная — организовать для девелоперов возможность быстро и просто разворачивать окружение. Обязательное требование — для автоконфигурации использовать [Puppet Enterprise](http://puppetlabs.com/puppet/puppet-enterprise)
Итак, более подробно об необходимом окружении. Оно будет состоять из двух компонентов, первый — FrontEnd, функции которого выполняет IIS сервер, второй — BackEnd, который будет содержать некий собственно разработаный Worker service и базу MongoDB. Оба компонента, как уже понятно, будут реализованы на Windows Server. Исходники для контента FrontEnd и Worker service будут браться из AWS S3, куда их уже исправно складывает каждую ночь Jenkins.
##### Создание Cloud Fromation Template
Реализовать Cloud Formation template, который будет стартовать два Windows сервера абсолютно не сложно. Куда интереснее придумать, каким образом сообщить Puppet, какую конфигурацию применять к этим серверам.
В официальной документации Puppet предлагается применять регулярные выражения к хостнейму клиента, что в нашем случае не удобно использовать, так как хостнейм на AWS Amazon выдаётся автоматом и может меняться после стоп-старта инстанса, то есть я был бы вынужден выдумывать пост-старт скрипт, который должен менять хостнейм машины и только потом стартовать puppet agent.
Покопавшись еще в документации, я нашёл то, что надо — [Custom External Facts](http://docs.puppetlabs.com/guides/custom_facts.html#external-facts). Для тех, кто работает c Chef Server, facts — это аналог attributes.
Чтобы добавить свои факты для виндоус машины, необходимо создать bat или ps1 файл примерно следующего содержания и положить его в "**C:\ProgramData\PuppetLabs\facter\facts.d\"**.
```
@echo off
echo node_role=frontend
echo app_version=Build1.2.0
```
Где serverRole — это, как понятно из названия, роль, которая будет назначена серверу, а buildNumber — это версия приложения, которая будет скачана с S3 AWS.
Создавать этот файл будет Cloud Formation template.
**DevEnv.tmpl**
```
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "Developers Stack",
"Parameters" : {
"KeyName" : {
"Description" : "Key-pair name",
"Type" : "String"
},
"SuffixName" : {
"Description" : "Suffix for all created resources",
"Type" : "String"
},
"FrontEndInstanceType" : {
"Type" : "String",
"Default" : "m1.small",
"AllowedValues" : [ "m1.small", "m1.medium", "m1.large", "m1.xlarge"],
"Description" : "EC2 instance type"
},
"BackEndInstanceType" : {
"Type" : "String",
"Default" : "m1.small",
"AllowedValues" : [ "m1.small", "m1.medium", "m1.large", "m1.xlarge"],
"Description" : "EC2 instance type"
},
"PuppetServer": {
"Description" : "Puppet Server URL",
"Type" : "String",
"Default" : "ec2-231-231-123-123.us-west-2.compute.amazonaws.com"
},
"Zone" : {
"Type" : "CommaDelimitedList",
"Description" : "The Availability Zone ",
"Default" : "us-west-2c"
},
"BuildVersion" : {
"Type" : "String",
"Description" : "Version of application build"
},
"RoleName" : {
"Type" : "String",
"Description" : "Instance IAM role",
"Default" : "WebInstance"
},
"SecurityGroup" : {
"Type" : "String",
"Description" : "Default security group for stack",
"Default" : "taws-security-group"
}
},
"Mappings" : {
"WindowsInstanceType" : {
"t1.micro" : { "Arch" : "64" },
"m1.small" : { "Arch" : "64" },
"m1.medium" : { "Arch" : "64" },
"m1.large" : { "Arch" : "64" },
"m1.xlarge" : { "Arch" : "64" }
},
"WindowsRegionMap" : {
"us-east-1" : { "AMI" : "ami-e55a7e8c" },
"us-west-2" : { "AMI" : "ami-1e53c82e" },
"us-west-1" : { "AMI" : "ami-b687b1f3" },
"eu-west-1" : { "AMI" : "ami-5f3ad728" },
"ap-southeast-1" : { "AMI" : "ami-96cd98c4" },
"ap-southeast-2" : { "AMI" : "ami-ab4a2daa" },
"ap-northeast-1" : { "AMI" : "ami-133fa329" },
"sa-east-1" : { "AMI" : "ami-bd3d9ba0" }
}
},
"Resources" : {
"FrontEnd" : {
"Type" : "AWS::EC2::Instance",
"Properties" : {
"KeyName" : { "Ref" : "KeyName" },
"ImageId" : { "Fn::FindInMap" : [ "WindowsRegionMap", { "Ref" : "AWS::Region" }, "AMI" ]},
"InstanceType" : { "Ref" : "FrontEndInstanceType" },
"IamInstanceProfile" : { "Ref" : "RoleName" },
"SecurityGroups" : [{ "Ref" : "SecurityGroup" }],
"Tags" : [
{"Key" : "Name", "Value" : { "Fn::Join" : ["",[{"Ref" : "SuffixName"},"-DEV-FrontEnd"]]}}
],
"UserData" : { "Fn::Base64" : { "Fn::Join" : ["", [
"\n",
"$MsiUrl = \"https://s3-us-west-2.amazonaws.com/mybucket/puppet.msi\"\n",
"$downloadPath = \"c:\\puppet.msi\"\n",
"$webClient = New-Object System.Net.WebClient\n",
"$webClient.DownloadFile($MsiUrl, $downloadPath)\n",
"$process = Start-Process -File $downloadPath -arg \"/qn /norestart\" -PassThru |wait-process\n",
"$PublicHostName = Invoke-RestMethod -Uri http://169.254.169.254/latest/meta-data/public-hostname -Method Get\n",
"Clear-Content 'C:\\ProgramData\\PuppetLabs\\puppet\\etc\\puppet.conf'\n",
"Add-Content 'C:\\ProgramData\\PuppetLabs\\puppet\\etc\\puppet.conf' \"[main]\", \"runinterval=300\", \"certname=$PublicHostName\", \"server=",{ "Ref" : "PuppetServer" },"\", \"environment=",{ "Ref" : "PuppetEnvironment" },"\"\n",
"Add-Content 'C:\\ProgramData\\PuppetLabs\\facter\\facts.d\\facts.bat' \"@echo off\", \"echo node\_role=frontend\", \"echo app\_version=",{ "Ref" : "BuildVersion" },"\"\n",
"Restart-Service pe-puppet\n",
"$MsiUrl = \"https://s3-us-west-2.amazonaws.com/mybucket/7zip.msi\"\n",
"$downloadPath = \"c:\\7zip.msi\"\n",
"$webClient = New-Object System.Net.WebClient\n",
"$webClient.DownloadFile($MsiUrl, $downloadPath)\n",
"$process = Start-Process -File $downloadPath -arg \"/qn \" -PassThru |wait-process\n",
"\n"
]]}}
}
},
"BackEnd" : {
"Type" : "AWS::EC2::Instance",
"Properties" : {
"KeyName" : { "Ref" : "KeyName" },
"ImageId" : { "Fn::FindInMap" : [ "WindowsRegionMap", { "Ref" : "AWS::Region" }, "AMI" ]},
"InstanceType" : { "Ref" : "BackEndInstanceType" },
"IamInstanceProfile" : { "Ref" : "RoleName" },
"SecurityGroups" : [{ "Ref" : "SecurityGroup" }],
"Tags" : [
{"Key" : "Name", "Value" : { "Fn::Join" : ["",[{"Ref" : "SuffixName"},"-DEV-BackEnd"]]}}
],
"UserData" : { "Fn::Base64" : { "Fn::Join" : ["", [
"\n",
"$MsiUrl = \"https://s3-us-west-2.amazonaws.com/mybucket/puppet.msi\"\n",
"$downloadPath = \"c:\\puppet.msi\"\n",
"$webClient = New-Object System.Net.WebClient\n",
"$webClient.DownloadFile($MsiUrl, $downloadPath)\n",
"$process = Start-Process -File $downloadPath -arg \"/qn /norestart\" -PassThru |wait-process\n",
"$PublicHostName = Invoke-RestMethod -Uri http://169.254.169.254/latest/meta-data/public-hostname -Method Get\n",
"Clear-Content 'C:\\ProgramData\\PuppetLabs\\puppet\\etc\\puppet.conf'\n",
"Add-Content 'C:\\ProgramData\\PuppetLabs\\puppet\\etc\\puppet.conf' \"[main]\", \"runinterval=300\", \"certname=$PublicHostName\", \"server=",{ "Ref" : "PuppetServer" },"\", \"environment=",{ "Ref" : "PuppetEnvironment" },"\"\n",
"Add-Content 'C:\\ProgramData\\PuppetLabs\\facter\\facts.d\\facts.bat' \"@echo off\", \"echo node\_role=backend\", \"echo app\_version=",{ "Ref" : "BuildVersion" },"\"\n",
"Restart-Service pe-puppet\n",
"$MsiUrl = \"https://s3-us-west-2.amazonaws.com/mybucket/7zip.msi\"\n",
"$downloadPath = \"c:\\7zip.msi\"\n",
"$webClient = New-Object System.Net.WebClient\n",
"$webClient.DownloadFile($MsiUrl, $downloadPath)\n",
"$process = Start-Process -File $downloadPath -arg \"/qn \" -PassThru |wait-process\n",
"\n"
]]}}
}
}
},
"Outputs" : {
"FrontEndPublicDnsName" : {
"Description" : "Public IP address of FrontEnd",
"Value" : { "Fn::Join" : ["",[{ "Fn::GetAtt" : [ "FrontEnd", "PublicDnsName" ] }]]}
},
"BackEndPublicDnsName" : {
"Description" : "Public IP address of BackEnd",
"Value" : { "Fn::Join" : ["",[{ "Fn::GetAtt" : [ "BackEnd", "PublicDnsName" ]}]]}
}
}
}
```
Параметры, которые используются в темплейте:
* KeyName — Имя ключа для доступа
* SuffixName — Некий суффикс, который будет добавлен а тэг Name (это могут быть инициалы девелопера)
* FrontEndInstanceType — Тип шейпа для FrontEnd
* BackEndInstanceType — Тип шейпа для BackEnd
* PuppetServer — Url вашего Puppet сервера
* Zone — Зона, в которой будут созданы сервера
* BuildVersion — Версия приложения, которая будет взята с S3
* RoleName — заранее создання IAM Role с правами «S3 Read-Only»
* SecurityGroup — Также заранее созданная секьюрити группа
IAM Role и Security Group могут создаваться этим же темплейтом, это будет даже правильнее. В моей примере это не делается с целью упрощения понимания.
В разделе UserData выполняется скачивание и установка puppet agent, 7zip и формируются puppet.conf и facts.bat.
С Cloud Formation закончили, пора переходить к настройке Puppet.
##### Настройка Puppet Server Enterprise
Чтобы установить Puppet Server Enterprise, необходимо только скачать [архив установщика](http://puppetlabs.com/misc/pe-files/previous-releases), распаковать и запустить puppet-server-installer. Чтобы включить автоматическую регистрацию клиентов на сервере, нужно создать файл **/etc/puppetlabs/puppet/autosign.conf** следующего содержания:
```
*
```
Создадим необходимые модули. Модули, это что-то вроде кукбуков в Chef. Размещаются они в папке **/etc/puppetlabs/puppet/modules**.
Упрощённая структура модуля:
* `my_module/` — Название директории будет названием модуля.
+ `manifests/` — Содержит манифесты модуля.
- `init.pp` — Содержит один класс **`my_module`.** **Название класса должно быть таким же как название модуля.**
- `other_class.pp` — Содержит еще один класс модуля **`my_module::other_class`.**
+ `files/` — Содержит файлы, которые будут скачаны клиентом
+ `lib/` — Содержит плагины, кастомные факты
+ `templates/` — Содержит темплейты, которые могут быть использованы в модуле
- `component.erb` — Этот манифест будет доступен в модуле как `template('my_module/component.erb')`.
Сначала добавим необходимые модули из PuppetLabs для установки IIS и менеджмента.
```
puppet module install dism
puppet module install opentable-iis
```
Теперь нужно немного подправить манифест для opentable-iis
**/etc/puppetlabs/puppet/modules/nodes/manifests/init.pp**class iis {
iis::manage\_app\_pool {"${fqdn}":
enable\_32\_bit => true,
managed\_runtime\_version => 'v4.0',
} ->
iis::manage\_site {"${fqdn}":
site\_path => 'C:\MyAppPath',
port => '80',
ip\_address => '\*',
host\_header => "${fqdn}",
app\_pool => "${fqdn}"
}
}
У меня получилось семь модулей (может дальше их количество вырастет).
1. **nodes** — модуль, который будет, исходя из значения **node\_role**, подключать следующий необходимый модуль
**/etc/puppetlabs/puppet/modules/nodes/manifests/init.pp**class nodes {
if "${node\_role}" == «backend» {
include backend
}
if "${node\_role}" == «frontend» {
include frontend
}
}
2. **getbuild** — этот модуль нужен для скачивания и распаковки архива приложения из AWS S3.
**/etc/puppetlabs/puppet/modules/getbuild/manifests/init.pp** class getbuild {
file { 'c:\config':
ensure => 'directory'
} ->
file { 'c:\Build':
ensure => 'directory'
} ->
exec { 'download\_build':
creates => «c:\\config\\${app\_version}»,
path => $::path,
command => «powershell.exe -executionpolicy unrestricted start-bitstransfer -source [s3-us-west-2.amazonaws.com/mybucket](https://s3-us-west-2.amazonaws.com/mybucket/)${app\_version} -Destination 'c:\\config\\'»,
} ->
exec { 'app\_install':
creates => «c:\\Build\CustomBackendService.exe.config»,
command => "\«c:\\Program Files\\7-Zip\\7z.exe\» x c:\\config\\${app\_version} -oC:\\Build ",
}
}
3. **mongodb** — модуль для установки MongoDB
**/etc/puppetlabs/puppet/modules/mongodb/manifests/init.pp**class mongodb {
file { 'c:/config':
ensure => directory,
} ->
file { 'c:/config/mongodb.zip':
ensure => file,
mode => '0777',
source => 'puppet:///modules/mongodb/mongodb-win32-x86\_64-v2.4-latest.zip',
} ->
file { 'c:/MongoDB':
ensure => directory,
} ->
file { 'c:/MongoDB/bin':
ensure => directory,
} ->
file { 'c:/MongoDB/Data':
ensure => directory,
} ->
file { 'c:/MongoDB/logs':
ensure => directory,
} ->
exec { 'mongodb-unzip':
creates => 'c:/MongoDB/bin/mongod.exe',
command => '«c:\\Program Files\\7-Zip\\7z.exe» e c:\\config\mongodb.zip -oC:\\MongoDB\\bin',
} ->
exec { 'mongodb-install':
creates => 'c:/MongoDB/logs/mongodb.log',
command => '«c:\\MongoDB\\mongod.exe» --dbpath=c:\\MongoDB\\Data --port 27017 --logpath=c:\\MongoDB\logs\\mongodb.log --install --serviceName mongodb --serviceDisplayName «MongoDB Server» --serviceDescription «MongoDB Server»',
} ->
exec { 'mongodb-run':
path => $::path,
command => 'powershell.exe start-service mongodb'
}
}
4. **api** — модуль для установки приложения на FrontEnd
**/etc/puppetlabs/puppet/modules/api/manifests/init.pp**class api {
include getbuild
dism { 'IIS-WebServerRole':
ensure => present,
} ->
dism { 'IIS-WebServer':
ensure => present,
require => Dism['IIS-WebServerRole'],
}
}
5. **worker** — модуль для установки приложения на BackEnd
**/etc/puppetlabs/puppet/modules/worker/manifests/init.pp**class worker {
include getbuild
exec { 'service\_install':
creates => «c:\\Build\\Custom.AWS.BackendService.InstallLog»,
command => «c:\\Build\\Custom.AWS.BackendService.exe -install»,
} ->
exec { 'service-run':
path => $::path,
command => 'powershell.exe start-service Custom.AWS.Backend'
}
}
6. **frontend** — модуль, который подключает все необходимые модули для работы FrontEnd
**/etc/puppetlabs/puppet/modules/frontend/manifests/init.pp**class frontend {
include api
include iis
}
7. **backend** — модуль, который подключает все необходимые модули для работы BackEnd
**/etc/puppetlabs/puppet/modules/backend/manifests/init.pp**class backend {
include mongodb
include worker
}
В своих манифестах я практически везде использовал ресурс **exec**. При правильно подобранном параметре **creates** этот ресурс работает безотказно.
Более детально на одном из примеров:
```
exec { 'mongodb-unzip':
creates => 'c:/MongoDB/bin/mongod.exe',
command => '"c:\\Program Files\\7-Zip\\7z.exe" e c:\\config\mongodb.zip -oC:\\MongoDB\\bin',
}
```
Если исполняемый файл **c:/MongoDB/bin/mongod.exe** отсутствует, то будет выполнена распаковка архива.
Теперь можно для удобства создать задачу в Вашей любимой CI системе, например [Jenkins](http://jenkins-ci.org/), поместить туда скрипт для запуска Cloud Formation template и девелоперы смогут разворачивать окружение в один клик.
На этом всё. Надеюсь данное руководство будет полезным…
Если среди прочитавших эту статью, будут спецы по использованию Puppet, я с превеликой благодарностью выслушаю Ваше мнение. | https://habr.com/ru/post/208710/ | null | ru | null |
# Блокчейн: организация сети, проверка подписи и задание для студента, часть 2
Предисловие
-----------
[В первой части](https://habrahabr.ru/post/348014/) было рассказано про возможности блокчейна, структуру и ЭЦП, в этой части будет рассказано про: проверку подписи, майнинг и примерную организацию сети. Отмечу, что не являюсь специалистом по распределенным системам (организация сети может быть неверной).
Одноранговая сеть (P2P)
-----------------------
Одноранговая (равноправная) сеть – это сеть, основанная на равноправии участников. Часто в такой сети отсутствуют выделенные серверы, а каждый узел (peer) является как клиентом, так и выполняет функции сервера. В отличие от архитектуры клиент-сервера, такая организация позволяет сохранять работоспособность сети при любом количестве и любом сочетании доступных узлов. Участники сети называются пиры.
### Организация сети
Сперва необходимо ответить на вопросы:
* как клиенты узнают о том, что существуют другие клиенты?
* каким образом гарантировать оптимальное взаимодействие между клиентами, если их могут отделять друг от друга континенты?
Каждый клиент, участвующий в работе сетевого приложения P2P, для преодоления этих проблем должен быть способен выполнять следующие операции:
* обнаруживать других клиентов;
* подключаться к другим клиентам;
* взаимодействовать с другими клиентами.
При подключении новый клиент связывается с трекером, который содержит списки подключенных узлов. Таких трекеров может быть много, они нужны для оптимальной связи между клиентами, под оптимальностью понимается, что скачивать цепочку блоков лучше с узла, который географически расположен рядом, чем тот, который дальше. То есть связующий центр (трекер) позволяет узнать новому клиенту, кто уже есть в сети и предоставляет список наиболее “подходящих” узлов. Пример сети продемонстрирован на рисунке 1.
*Рисунок 1 – децентрализованная сеть с трекерами, содержащими списки подключенных узлов*
Майнинг
-------
В зависимости от типа блокчейна (децентрализованный вариант с использованием доказательства работы или централизованный с доверенным центром) блоки транзакций (пустые) могут создаваться майнерами или главным узлом (центром). Майнеры – узлы сети, которые вычисляют новый блок (имеется ввиду блок транзакции). Что значит вычислить новый блок и почему его надо вычислять? Все дело в том, что в некоторых типах блокчейна создать новый блок не так просто, необходимо решить сложную задачу путем перебора чисел (если быть точным получить хэш с 10 нулями в начале ~ 0000000000HD83HA653JA…83JS), это сделано с целью безопасности, чтобы другие участники не смогли быстро подменить цепочку блоков, т.к. на расчет такого хэша могут уйти часы, дни, недели (подменив один, придется пересчитать другие блоки). В других типах блокчейна эти хэши уже могут быть вычислены заранее и соответственно отпадает необходимость в майнерах, как добытчиках блоков, здесь цель майнера уже не добывать блок, а предоставлять свой жесткий диск для хранения цепочки.
Проверка данных блокчейна
-------------------------
После добавления нового блока или вставки новых данных в список транзакций уже созданного блока, необходимо, чтобы другие участники сети проверили данную информацию.
### Алгоритм проверки транзакции
Алгоритм проверки транзакции показан на рисунке 2. Проверку транзакций другими участниками сети можно разделить на этапы:
1. Получение данных и подписи из новой транзакции;
2. Получаем хэш SHA512 от данных;
3. Подпись и открытый ключ взятый из адреса этого же блока расшифровываем с помощью RSADecode(подпись, публичный ключ);
4. Сравниваем полученный на этапе 2 хэш, с хэшем полученным на этапе 3 из расшифрованной подписи. Если совпали, значит данные корректны и подписаны ключем владельца, транзакция добавляется к себе в блок. Если не совпали, данные фальшивы и транзакция отклоняется и не добавляется в блок.
*Рисунок 2 — Алгоритм проверки транзакции*
### Алгоритм проверки блока
Проверка нового блока делится на этапы:
1. Берется адрес последнего принятого блока (текущий блок еще не принят и не является последним) и список транзакций текущего блока. Затем вычисляется хэш:
```
Хэш = SHA512(block_prev_adress_hash + transaction_hash1 + transaction_hash2 + … + transaction_hashN)
```
2. Полученный хэш сравнивается с хэшем (связующим) еще непринятого блока. Если совпали, тогда блок корректный и добавляется к себе в цепочку. Иначе, данные некорректные и блок не принимается.
### Пример проверки подписи на языке C#
Передаем методу полученные из транзакции: данные, подпись и адрес блока (публичный ключ).
```
private static bool VerifyMessage(string originalData, string signedDataBase64, string publicKey)
{
// результат проверки будет записан в это поле
bool verified;
// Получаем объект класса RSA через провайдер
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(2048);
// Говорим, что у нас уже есть приватный ключ (например взятый из файла)
// и следует использовать его
rsa.FromXmlString(publicKey);
// Преобразуем символы строки в последовательность байтов
byte[] originalByteData = Encoding.UTF8.GetBytes(originalData);
// Конвертация подписи из string в кодировке Base64 в массив байт
byte[] signedData = Convert.FromBase64String(signedDataBase64);
// данные originalByteDate хэшируются алгоритмом SHA512, полученный хэш сравнивает с signedData
// результат сравнения возвращается в verified
verified = rsa.VerifyData(originalByteData, CryptoConfig.MapNameToOID("SHA512"), signedData);
return verified;
}
```
Задание
-------
Необходимо расширить ПС из [первой части](https://habrahabr.ru/post/348014/), реализовав децентрализованную сеть с трекерами. Узлы-клиенты должны уметь взаимодействовать между собой (передавать/получать/проверять информацию). Узлы-трекеры – обновлять/отдавать список узлов.
Функции трекер-узла:
1. Регистрация (добавление в список) клиента при подключении к трекеру;
2. Возвращение списка подключенных узлов.
Функции клиента:
1. Подключение к трекер-узлу и узлам сети из списка, полученного от трекера;
2. При подключении к узлам сети синхронизировать историю транзакций, приняв ее от другого участника (если у него цепочка новее или длиннее) с последующей проверкой;
3. При добавлении нового блока или транзакции – анонсировать (передать) этот блок остальным участникам;
4. Получение нового блока или транзакции от других участников;
5. При получении нового блока или транзакции от других участников, необходимо их проверить и принять решении о вставке в свою цепочку или отклонить.
Источники
---------
1. [ProfessorWeb // Сеть P2P](https://professorweb.ru/my/csharp/web/level8/8_1.php)
2. [StackOverFlow // Programming P2P application](https://bitcoin.stackexchange.com/questions/3536/how-do-bitcoin-clients-find-each-other) | https://habr.com/ru/post/348020/ | null | ru | null |
# Разработка приложения на SwiftUI. Часть 1: поток данных и Redux
После участия в сессии State of the Union на WWDC 2019 я решил детально изучить SwiftUI. Я потратил много времени на работу с ним и теперь приступил к разработке реального приложения, которое может оказаться полезным широкому кругу пользователей.
Его я назвал MovieSwiftUI — это апп для поиска новых и старых фильмов, а также их сбора в коллекцию при помощи [TMDB API](https://developers.themoviedb.org/3?source=post_page---------------------------). Я всегда любил фильмы и даже создал компанию, работающую в этой сфере, правда давно. Компанию сложно было назвать классной, а вот приложение — да!
> **Напоминаем:** *для всех читателей «Хабра» — скидка 10 000 рублей при записи на любой курс Skillbox по промокоду «Хабр».*
>
>
>
> **Skillbox рекомендует:** Образовательный онлайн-курс [«Профессия Java-разработчик»](https://skillbox.ru/java/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=JAVDEV&utm_content=articles&utm_term=swiftui).
**Итак, что умеет MovieSwiftUI?**
* Взаимодействует с API — это делает почти любое современное приложение.
* Загружает асинхронные данные по запросам и парсит JSON в Swift-модели, используя [Codable](https://developer.apple.com/documentation/foundation/archives_and_serialization/encoding_and_decoding_custom_types?source=post_page---------------------------).
* Показывает изображения, загружаемые по запросу, и кэширует их.
* Это приложение для iOS, iPadOS, и macOS обеспечивает лучший UX для пользователей этих ОС.
* Пользователь может генерировать данные, создавать собственные списки фильмов. Приложение сохраняет и восстанавливает пользовательские данные.
* Представления, компоненты и модели четко разделены при помощи паттерна Redux. Поток данных здесь однонаправлен. Он может быть полностью кэширован, восстановлен и перезаписан.
* Приложение использует базовые компоненты SwiftUI, TabbedView, SegmentedControl, NavigationView, Form, Modal и т.п. Также оно обеспечивает кастомные представления, жесты, UI/UX.
На самом деле анимация плавная, гифка получилась немного дерганая
Работа над приложением дала мне много опыта, и в целом это положительный опыт. Я смог написать полнофункциональное приложение, в сентябре я его улучшу и выложу в AppStore, одновременно с выходом iOS 13.
### Redux, BindableObject и EnvironmentObject
На сегодняшний момент я работаю с Redux уже около двух лет, так что относительно хорошо в этом разбираюсь. В частности, я использую его во фронтенде для [React](http://reactjs.org/?source=post_page---------------------------) веб-сайта, а также для разработки нативных iOS (Swift) и Android (Kotlin) приложений.
Я ни разу не пожалел о выборе Redux в качестве архитектуры потока данных для создания приложения на SwiftUI. Наиболее сложные моменты при использовании Redux в приложении UIKit — это работа со store, а также получение и извлечение данных и сопоставление их с вашими представлениями / компонентами. Для этого пришлось создать своего рода библиотеку коннекторов (на ReSwift и ReKotlin). Работает хорошо, но довольно много кода. К сожалению, он (пока) не open source.
Хорошие новости! Единственное, о чем стоит беспокоиться со SwiftUI — если вы планируете использовать Redux, — это store, состояния и редьюсеры. Взаимодействие со store полностью берет на себя SwiftUI благодаря @EnvironmentObject. Так, store начинается с BindableObject.
Я создал простой пакет Swift, [SwiftUIFlux](https://github.com/Dimillian/SwiftUIFlux?source=post_page---------------------------), который обеспечивает базовое использование Redux. В моем случае это часть MovieSwiftUI. Также я [написал пошаговый туториал](https://github.com/Dimillian/SwiftUIFlux/blob/master/README.md?source=post_page---------------------------), который поможет использовать этот компонент.
**Как это работает?**
```
final public class Store: BindableObject {
public let willChange = PassthroughSubject()
private(set) public var state: State
private func \_dispatch(action: Action) {
willChange.send()
state = reducer(state, action)
}
}
```
Каждый раз, когда вы запускаете действие, вы активируете редуктор. Он будет оценивать действия в соответствии с текущим состоянием приложения. Далее он будет возвращать новое модифицированное состояние в соответствии с видом действия и данными.
Ну а поскольку store является BindableObject, он будет уведомлять SwiftUI об изменении своего значения, используя свойство willChange, предоставленное PassthroughSubject. Это так потому, что BindableObject должен предоставлять PublisherType, но реализация протокола отвечает за управление им. В общем, это очень мощный инструмент от Apple. Соответственно, в следующем цикле рендеринга SwiftUI поможет отобразить тело представлений в соответствии с изменением состояния.
Собственно, это все — сердце и магия SwiftUI. Теперь в любом представлении, которое подписано на состояние, представление будет отображаться в соответствии с тем, какие данные получены из состояния и что изменилось.
```
class SceneDelegate: UIResponder, UIWindowSceneDelegate {
var window: UIWindow?
func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
if let windowScene = scene as? UIWindowScene {
let window = UIWindow(windowScene: windowScene)
let controller = UIHostingController(rootView: HomeView().environmentObject(store))
window.rootViewController = controller
self.window = window
window.makeKeyAndVisible()
}
}
}
struct CustomListCoverRow : View {
@EnvironmentObject var store: Store
let movieId: Int
var movie: Movie! {
return store.state.moviesState.movies[movieId]
}
var body: some View {
HStack(alignment: .center, spacing: 0) {
Image(movie.poster)
}.listRowInsets(EdgeInsets())
}
}
```
Store внедряется как EnvironmentObject при запуске приложения, а затем доступно в любом представлении при помощи @EnvironmentObject. Производительность не снижается, поскольку производные свойства быстро извлекаются или вычисляются из состояния приложения.
Код, который указан выше, изменяет изображение, если меняется постер к фильму.
И выполняется это фактически всего одной строкой, с помощью которой производится подключение представлений к состоянию. Если вы работали с ReSwift на iOS или даже [connect](https://habr.com/ru/users/connect/) с React, вы поймете, в чем магия SwiftUI.
А теперь можно попробовать активировать действие и опубликовать новое состояние. Вот более сложный пример.
```
struct CustomListDetail : View {
@EnvironmentObject var store: Store
let listId: Int
var list: CustomList {
store.state.moviesState.customLists[listId]!
}
var movies: [Int] {
list.movies.sortedMoviesIds(by: .byReleaseDate, state: store.state)
}
var body: some View {
List {
ForEach(movies) { movie in
NavigationLink(destination: MovieDetail(movieId: movie).environmentObject(self.store)) {
MovieRow(movieId: movie, displayListImage: false)
}
}.onDelete { (index) in
self.store.dispatch(action: MoviesActions.RemoveMovieFromCustomList(list: self.listId, movie: self.movies[index.first!]))
}
}
}
}
```
В коде выше я использую действие .onDelete из SwiftUI для каждого IP. Это позволяет строке в списке отображать обычный свайп iOS для удаления. Поэтому, когда пользователь касается кнопки удаления, он запускает соответствующее действие и удаляет фильм из списка.
Ну а поскольку свойство списка является производным от состояния BindableObject и внедряется как EnvironmentObject, то SwiftUI обновляет список, поскольку ForEach связан с вычисляемым свойством movies.
Вот часть редьюсера MoviesState:
```
func moviesStateReducer(state: MoviesState, action: Action) -> MoviesState {
var state = state
switch action {
// other actions.
case let action as MoviesActions.AddMovieToCustomList:
state.customLists[action.list]?.movies.append(action.movie)
case let action as MoviesActions.RemoveMovieFromCustomList:
state.customLists[action.list]?.movies.removeAll{ $0 == action.movie }
default:
break
}
return state
}
```
Редуктор выполняется, когда вы отправляете действие и возвращаете новое состояние, как сказано выше.
Я пока не буду вдаваться в подробности — откуда SwiftUI на самом деле знает, что отображать. Для того, чтобы понять это более глубоко, стоит [просмотреть сессию WWDC о потоке данных](https://developer.apple.com/videos/play/wwdc2019/226/?source=post_page---------------------------) в SwiftUI. Также там подробно рассказывается, зачем и когда использовать [State](https://habr.com/ru/users/state/), @Binding, ObjectBinding и EnvironmentObject.
> **Skillbox рекомендует:**
>
>
>
> * Практический курс [«Мобильный разработчик PRO»](https://skillbox.ru/agima/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=AGIMA&utm_content=articles&utm_term=swiftui).
> * Прикладной онлайн-курс [«Аналитик данных Python»](https://skillbox.ru/python-data/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=PTNANA&utm_content=articles&utm_term=swiftui).
> * Двухлетний практический курс [«Я — веб-разработчик PRO»](https://iamwebdev.skillbox.ru/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=WEBDEVPRO&utm_content=articles&utm_term=swiftui).
> | https://habr.com/ru/post/460713/ | null | ru | null |
# Визуализация concurrency в Go с WebGL
Одной из самых сильных сторон языка программирования Go является встроенная поддержка concurrency, основанная на труде Тони Хоара [«Communicating Sequential Processes»](https://en.wikipedia.org/wiki/Communicating_sequential_processes). Go создан для удобной работы с многопоточным программированием и позволяет очень легко строить довольно сложные concurrent-программы. Но задумывались ли вы когда-нибудь, как выглядят различные паттерны concurrency визуально?
Конечно, задумывались. Все мы, так или иначе, мыслим визуальными образами. Если я попрошу вас о чём-то, что включает числа «от 1 до 100», вы мгновенно их «увидите» в своей голове в той или иной форме, вероятно даже не отдавая себе в этом отчёт. Я, к примеру, ряд от 1 до 100 вижу как линия с числами уходящая от меня, поворачивающая на 90 градусов вправо на числе 20 и продолжающая до 1000+. И, покопавшись в памяти, я вспоминаю, что в самом первом детском саду в раздевалке вдоль стены были написаны номерки, и число 20 было как-раз в углу. У вас же, вероятно, какое-то свое представление. Или вот, другой частый пример — представьте круглый год и 4 сезона года — кто-то их видит как квадрат, каждая грань которого принадлежит сезону, кто-то — как круг, кто-то ещё как-то.
Так или иначе, позвольте мне показать мою попытку визуализировать основные паттерны concurrency с помощью Go и WebGL. Эти интерактивные визуализации более-менее отражают то, как я вижу это в своей голове. Интересно будет услышать, насколько это отличается от визуализаций читателей.
Итак, давайте начнем с простейшего примера — «Hello, concurrent world», чтобы познакомиться с концепцией моего подхода.
#### Привет, concurrent мир
```
package main
func main() {
// создаем новый канал типа int
ch := make(chan int)
// запускаем новую анонимную горутину
go func() {
// отправляем 42 в канал
ch <- 42
}()
// ждем, читаем из канала
<-ch
}
```
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/hello/)
Здесь синие линии представляют горутины, время «бежит» вниз по оси Y. Тонкие синие линии соединяющие 'main' и 'go #19' — это отметки начала и завершения жизни горутины, показывающие предков и детей. Красные стрелочки демонстрируют событие отправки сообщения в канал, и отправленное значение подписано. На самом деле, «отправка в канал» и «чтение из канала» это два отдельных события, и поведение будет сильно отличаться между буферизированными и небуферизированными каналами, но я два этих события анимирую как одно — «передача значения по каналу». Строка "#19" в названии анонимной горутины — это реальный ID запущенной горутины. Хотя официально узнать ID горутин и нельзя (чтобы люди не городили другие модели concurrency, в которых идентификаторы играют важную роль), но для вот таких хакерских случаев таки можно — об этом хорошо написано в статье Скота Мэнсфилда [«Goroutine IDs»](http://blog.sgmansfield.com/2015/12/goroutine-ids/).
#### Таймеры
Фактически, наш простейший Hello, world выше может использоваться для создания простейшего таймера. В стандартной библиотеке Go есть такие удобные функции, как time.After или time.Tick, но давайте реализуем наш собственный — напишем функцию, которая создает канал, запускает горутину, которая спит необходимое время и пишет в канал, и возвратим этот канал вызывающему.
```
package main
import "time"
func timer(d time.Duration) <-chan int {
c := make(chan int)
go func() {
time.Sleep(d)
c <- 1
}()
return c
}
func main() {
for i := 0; i < 24; i++ {
c := timer(1 * time.Second)
<-c
}
}
```
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/timers/)
Здорово, правда? Но идём дальше.
#### Пинг-понг
Этот интересный пример concurrency был взят из известного доклада гуглера Sameer Ajmani "[Advanced Concurrency Patterns](https://talks.golang.org/2013/advconc.slide#1)". Конечно, этот пример не слишком advanced, но для тех, кто только знакомится с concurrency в Go он должен быть интересным и демонстративным.
Итак, у нас есть канал table, выполняющий роль стола, есть мяч Ball, который является переменной типа int и хранит в себе количество ударов по нему, и есть горутины-игроки, которые «забирают мяч со стола» (читают из канала), «бьют по нему» (увеличивают переменную) и «бросают обратно на стол» (пишут в канал).
```
package main
import "time"
func main() {
var Ball int
table := make(chan int)
go player(table)
go player(table)
table <- Ball
time.Sleep(1 * time.Second)
<-table
}
func player(table chan int) {
for {
ball := <-table
ball++
time.Sleep(100 * time.Millisecond)
table <- ball
}
}
```
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/pingpong/)
На этом моменте я хочу ещё раз обратить ваше внимание на [ссылку с интерактивным WebGL демо](https://divan.github.io/demos/pingpong/), доступную под каждой анимацией — открыв в новом табе, вы можете двигать, вращать, увеличивать/уменьшать и рассматривать эти 3D анимации, как вам угодно, а так же замедлять/ускорять и перезапускать их.
Теперь, давайте запустим три игрока-горутины, вместо двух:
```
go player(table)
go player(table)
go player(table)
```
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/pingpong3/)
В данном примере мы видим, что каждый игрок забирает мяч со стола по-очереди, и вы можете задаться вопросом — почему именно так, кто гарантирует этот порядок?
Ответ тут прост — рантайм Go содержит [FIFO очередь](https://github.com/golang/go/blob/master/src/runtime/chan.go#L34) для горутин, готовых читать из канала, поэтому мы и наблюдаем этот порядок. В нашем случае каждая горутина становится в очередь сразу же после отправки мяча на стол. Впрочем, это поведение может измениться в будущем и расчитывать на порядок не стоит. Но пока это так, и давайте запустим не три, а сто горутин.
```
for i := 0; i < 100; i++ {
go player(table)
}
```
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/pingpong100/)
Порядок FIFO теперь более очевиден, не так-ли? Мы можем запросто запустить и миллион горутин (они дешевые, и это ок в больших Go программах иметь сотни тысяч горутин), но для наших целей это будет слишком много. Давайте перейдем к другим паттернам.
#### Fan-in
Один из самых известных паттернов это так называемый *fan-in* паттерн. Он является противоположностью паттерну *fan-out*, который мы рассмотрим далее. Если вкратце, то *fan-in* — это функция, читающая из нескольких источников и мультиплексирующая всё в один канал.
К примеру:
```
package main
import (
"fmt"
"time"
)
func producer(ch chan int, d time.Duration) {
var i int
for {
ch <- i
i++
time.Sleep(d)
}
}
func reader(out chan int) {
for x := range out {
fmt.Println(x)
}
}
func main() {
ch := make(chan int)
out := make(chan int)
go producer(ch, 100*time.Millisecond)
go producer(ch, 250*time.Millisecond)
go reader(out)
for i := range ch {
out <- i
}
}
```
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/fanin/)
Как мы видим, первый *producer* генерирует числа каждые 100мс, второй — каждые 250мс, а *reader* получает числа от обоих продюсеров сразу же. Мультиплексирование, по-сути, происходит в функции main.
#### Fan-out
Противоположностью *fan-in* является *fan-out* или *workers* паттерн. Множество горутин читают из одного канала, забирая на обработку какие-то данные и эффективно распределяя работу между ядрами CPU. Отсюда и название "*workers*". В Go реализовывать этот паттерн очень просто — запустите пачку горутин, передав канал через параметр и пишите в этот канал ваши данные, а мультиплексирование и распределение будет происходит автоматически благодаря рантайму Go.
```
package main
import (
"fmt"
"sync"
"time"
)
func worker(tasksCh <-chan int, wg *sync.WaitGroup) {
defer wg.Done()
for {
task, ok := <-tasksCh
if !ok {
return
}
d := time.Duration(task) * time.Millisecond
time.Sleep(d)
fmt.Println("processing task", task)
}
}
func pool(wg *sync.WaitGroup, workers, tasks int) {
tasksCh := make(chan int)
for i := 0; i < workers; i++ {
go worker(tasksCh, wg)
}
for i := 0; i < tasks; i++ {
tasksCh <- i
}
close(tasksCh)
}
func main() {
var wg sync.WaitGroup
wg.Add(36)
go pool(&wg, 36, 50)
wg.Wait()
}
```
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/workers/)
Одна вещь, на которую тут хотелось бы обратить внимание — параллелизм. Лего заметить, что горутины-воркеры бегут параллельно, забирая себе «работу» по каналам, одна за другой. По данной анимации можно также увидеть, что горутины делают это почти одновременно. К сожалению, пока что в анимации не видно, где горутина реально работает, а где блокируется, и также тут временной масштаб уже близок к порогу погрешности ошибки, но конкретно эта анимация была записана на программе, бегущей на 4 ядрах, тоесть с GOMAXPROCS=4. Чуть дальше мы рассмотрим этот вопрос подробнее.
А пока что, давайте попробуем что-то посложнее — воркеры, у которых есть свои, саб-воркеры.
```
package main
import (
"fmt"
"sync"
"time"
)
const (
WORKERS = 5
SUBWORKERS = 3
TASKS = 20
SUBTASKS = 10
)
func subworker(subtasks chan int) {
for {
task, ok := <-subtasks
if !ok {
return
}
time.Sleep(time.Duration(task) * time.Millisecond)
fmt.Println(task)
}
}
func worker(tasks <-chan int, wg *sync.WaitGroup) {
defer wg.Done()
for {
task, ok := <-tasks
if !ok {
return
}
subtasks := make(chan int)
for i := 0; i < SUBWORKERS; i++ {
go subworker(subtasks)
}
for i := 0; i < SUBTASKS; i++ {
task1 := task * i
subtasks <- task1
}
close(subtasks)
}
}
func main() {
var wg sync.WaitGroup
wg.Add(WORKERS)
tasks := make(chan int)
for i := 0; i < WORKERS; i++ {
go worker(tasks, &wg)
}
for i := 0; i < TASKS; i++ {
tasks <- i
}
close(tasks)
wg.Wait()
}
```
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/workers2/)
Здорово. Конечно, можно было сделать больше и воркеров, и саб-воркеров, но я стремился сделать анимацию максимально наглядной.
Есть гораздо более сложные паттерны, воркеров с сабворкерами со своими сабворкерами, и каналы, которые сами передаются по каналам, но идея fan-out должна быть понятна.
#### Серверы
Следующий популярный паттерн, похожий на fan-out, это *серверы*. Он отличается тем, что горутины стартуют динамически, выполняют необходимую работу и завершаются. И довольно часто этот паттерн применяется для реализации серверов — слушаем порт, принимаем соединение, стартуем горутину, которая дальше займется входящим запросом, передав ей соединение, а в это время слушаем дальше, ожидая следующее соединение. Это достаточно удобно и позволяет реализовать эффективный сервер, выдерживающий 10K соединений, очень просто. Вгляните на следующий пример:
```
package main
import "net"
func handler(c net.Conn) {
c.Write([]byte("ok"))
c.Close()
}
func main() {
l, err := net.Listen("tcp", ":5000")
if err != nil {
panic(err)
}
for {
c, err := l.Accept()
if err != nil {
continue
}
go handler(c)
}
}
```
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/servers/)
Этот пример не слишком интересен — по-сути, тут ничего особо не происходит. Хотя, конечно, под капотом там заботливо спрятана громадная сложность и алгоритмы. [«Простота сложна».](https://www.youtube.com/watch?v=rFejpH_tAHM)
Но давайте добавим немного активности в наш сервер, и, скажем, добавим логгер, в который каждая горутина будет писать адрес клиента.
```
package main
import (
"fmt"
"net"
"time"
)
func handler(c net.Conn, ch chan string) {
ch <- c.RemoteAddr().String()
c.Write([]byte("ok"))
c.Close()
}
func logger(ch chan string) {
for {
fmt.Println(<-ch)
}
}
func server(l net.Listener, ch chan string) {
for {
c, err := l.Accept()
if err != nil {
continue
}
go handler(c, ch)
}
}
func main() {
l, err := net.Listen("tcp", ":5000")
if err != nil {
panic(err)
}
ch := make(chan string)
go logger(ch)
go server(l, ch)
time.Sleep(10 * time.Second)
}
```
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/servers2/)
Достаточно демонстративно, не так ли? На этой анимации видно, что наш логгер может быстро стать узким местом, если количество соединений будет расти, а логгер будет не слишком быстрым (скажем, он будет сереализовать данные и куда-то еще отправлять). Но мы можем решить это, использовав уже знакомый нам паттерн *fan-out*. Давайте напишем это.
#### Сервер+Воркер
Пример сервера с воркером будет чуть более продвинутым вариантом только что озвученного решения. Он не только стартует логгер в нескольких горутинах, но и собирает с них данные с результатами (скажем, результат записи на удаленный сервис).
Посмотрим на код и анимацию:
```
package main
import (
"net"
"time"
)
func handler(c net.Conn, ch chan string) {
addr := c.RemoteAddr().String()
ch <- addr
time.Sleep(100 * time.Millisecond)
c.Write([]byte("ok"))
c.Close()
}
func logger(wch chan int, results chan int) {
for {
data := <-wch
data++
results <- data
}
}
func parse(results chan int) {
for {
<-results
}
}
func pool(ch chan string, n int) {
wch := make(chan int)
results := make(chan int)
for i := 0; i < n; i++ {
go logger(wch, results)
}
go parse(results)
for {
addr := <-ch
l := len(addr)
wch <- l
}
}
func server(l net.Listener, ch chan string) {
for {
c, err := l.Accept()
if err != nil {
continue
}
go handler(c, ch)
}
}
func main() {
l, err := net.Listen("tcp", ":5000")
if err != nil {
panic(err)
}
ch := make(chan string)
go pool(ch, 4)
go server(l, ch)
time.Sleep(10 * time.Second)
}
```
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/servers3/)
Мы улучшили наш сервер, эффективно распределив задачу для логгера между 4-мя горутинами, но всё равно видим, что логгер таки может стать узким местом. Тысячи соединений сходятся в одном канале. перед тем как мультиплексироваться между горутинами. Но, конечно, это случится уже при гораздо больших нагрузках, чем в предыдущем варианте.
#### Решето Эратосфена
Но довольно fan-in/fan-out экспериментов. Давайте посмотрим на более интересные пример. Один из моих любимых — это «Решето Эратосфена» на горутинах и каналах, найденное в докладе "[Go Concurrency Patterns](https://talks.golang.org/2012/concurrency.slide)". Решето Эратосфена это древний алгоритм нахождения простых чисел до заданного лимита. Его суть заключается в последовательном вычеркивании всех чисел, делящихся на каждое последующее найденное простое число. Алгоритм «в лоб» не слишком эффективен, особенно на мультиядерных машинах.
Вариант реализации этого алгоритма с горутинами и каналами запускает по одной горутине на каждое найденное простое число, и эта горутина фильтрует числа, которые на него делятся. Когда же найдено первое простое число в горутине — оно отправляется в главную горутину(main) и выводится на экран. Этот алгоритм тоже далеко не самый эффективный, но я нахожу его потрясающе элегантным. Вот сам код:
```
// A concurrent prime sieve
package main
import "fmt"
// Send the sequence 2, 3, 4, ... to channel 'ch'.
func Generate(ch chan<- int) {
for i := 2; ; i++ {
ch <- i // Send 'i' to channel 'ch'.
}
}
// Copy the values from channel 'in' to channel 'out',
// removing those divisible by 'prime'.
func Filter(in <-chan int, out chan<- int, prime int) {
for {
i := <-in // Receive value from 'in'.
if i%prime != 0 {
out <- i // Send 'i' to 'out'.
}
}
}
// The prime sieve: Daisy-chain Filter processes.
func main() {
ch := make(chan int) // Create a new channel.
go Generate(ch) // Launch Generate goroutine.
for i := 0; i < 10; i++ {
prime := <-ch
fmt.Println(prime)
ch1 := make(chan int)
go Filter(ch, ch1, prime)
ch = ch1
}
}
```
А теперь взгляните на анимацию.
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/primesieve/)
Не забудьте покрутить его интерактивно в 3D пространстве по ссылке выше. Мне очень нравится, как иллюстративен этот пример и изучение его в 3D может помочь понять сам алгоритм лучше. Мы видим, что первая горутина(*generate*) посылает первое простое число (2) в *main*, затем стартует первая горутина-фильтр, отсеивающая двойки, затем тройки, пятерки, семерки… и каждый раз новое найденное простое число отправляется в *main* — это особенно хорошо видно при виде сверху. Красивый алгоритм, в том числе и в 3D.
#### GOMAXPROCS
Теперь давайте вернёмся к нашему примеру с воркерами. Помните, я написал, что этот пример был запущен с GOMAXPROCS=4? Это потому что все эти анимации не нарисованы, это реальные трейсы реальных программ.
Для начала, давайте освежим память и вспомним, что такое [GOMAXPROCS](https://golang.org/pkg/runtime/#GOMAXPROCS):
> GOMAXPROCS устанавливает максимальное количество ядер CPU, которые могут исполнять код одновременно
Я изменил код воркеров слегка, чтобы они делали реальную работу. нагружая процессор, а не просто спали. Затем запустил код без каких либо изменений на Linux-машине с двумя процессорами по 12 ядер каждый — сначала с GOMAXPROCS=1, затем с GOMAXPROCS=24.
Итак. первая анимация показывает одну и ту же программу, бегущую на 1-м ядре, вторая — на 24-х ядрах.
 
[WebGL анимация 1](https://divan.github.io/demos/gomaxprocs1/) [WebGL анимация 24](https://divan.github.io/demos/gomaxprocs24/)
Скорость анимации времени разная в этих примерах (я хотел, чтобы все анимации занимали фиксированное время по высоте), но разница должна быть очевидна. При GOMAXPROCS=1 следующий воркер забирает работу (читает из канала) только когда освободилось ядро процессора и предыдущая горутина отработала свою порцию. С 24-мя ядрами, горутины почти сразу же разбирают задачи и ускорение огромно.
Впрочем, важно понимать, что увеличение GOMAXPROCS не всегда приводит к увеличению производительности, и могут быть случаи, когда она даже падает от увеличения количества ядер.
#### Утечки горутин
Что ещё мы можем продемонстрировать из мира concurrency? Одна из вещей, которая мне приходит в голову, это утечки горутин. Они могут случаться по неосторожности, или, скажем, если вы [запустили горутину, но она вышла из области видимости](http://openmymind.net/Leaking-Goroutines/).
Первый (и единственный) раз, когда я столкнулся с утечкой горутин, в моей голове возникла ужасающая картинка, и буквально на следующих выходных я написал [expvarmon](https://github.com/divan/expvarmon) для быстрого мониторинга. И сейчас я могу визуализировать эту ужасающую картинку с помощью WebGL.
Посмотрите:
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/leak/)
Мне больно даже смотреть на это :) Каждая линия — это потраченные ресурсы компьютера и бомба с часовым механизмом для вашей программы.
#### Concurrency is not Parallelism
Слово concurrency часто переводят как «параллелизм», но это не совсем верно. По правде, хорошего перевода я не знаю, поэтому везде тут и пишу без перевода. Но сама тема, объясняющая отличия между concurrency и параллелизмом [раскрыта](https://existentialtype.wordpress.com/2011/03/17/parallelism-is-not-concurrency/) [многократно](https://ghcmutterings.wordpress.com/2009/10/06/parallelism-concurrency/), в том числе и Робом Пайком в замечательном [одноимённом докладе](https://www.youtube.com/watch?v=cN_DpYBzKso). Посмотрите, если ещё не.
Если вкратце, то:
> Параллелизм — это просто много штук, запущенных параллельно.
>
> Concurrency — это способ структурировать программу.
Важно понимать, что эти концепции несколько ортогональны — concurrent-программа может быть параллельной, а может и не быть. Мы чуть выше видели пример этого с разными GOMAXPROCS — один и тот же код бежал как на 1-м ядре (последовательно), так и на 24-х ядрах (параллельно).
Я мог бы повторять многие постулаты из вышеприведенных ссылок и докладов, но это уже сделано до меня. Лучше попробую показать это визуально.
Итак, вот это параллелизм. Просто много штук, бегущих параллельно.
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/parallelism1/)
И вот это параллелизм. Ещё больше параллельных штук, что, впрочем, ничего не меняет.
[**Ссылка на интерактивное WebGL демо**](https://divan.github.io/demos/parallelism2/)
Но вот это — concurrency:
И вот это:
И вот это тоже concurrency:
#### Как это было сделано?
Чтобы создать эти анимации, я написал две программы — *gotracer* и *gothree.js*. Первая делает следующие вещи:
* парсит AST-дерево исходного кода примеров на Go (ещё один плюс простой грамматики Go) и вставляет специальный вывод на событиях, относящихся к concurrency — старт/стоп горутины, запись/чтения в канал, создание канала
* запускает модифицированную программу
* анализирует вывод, и генерирует специальный JSON с ивентами и таймштампами
Пример результирующего JSON-а:
Далее, *gothree.js* использует мощь шикарной библиотеки [Three.js](http://threejs.org/), чтобы рисовать и анимировать эти данные в 3D с помощью WebGL. Небольшой враппер, чтобы втиснуть это в одну демо-страничку и готово.
Впрочем, этот подход очень ограничен. Мне приходилось очень аккуратно подбирать примеры, переименовывать каналы, чтобы получать корректный трейс. С этим подходом нет легкого способа связать каналы между горутинами, если они называются внутри функции иначе. Также есть проблемы с таймингом — вывод в консоль занимает порой больше времени, чем запуск горутины, запись в канал и выход, поэтому в некоторых примерах мне приходилось чуть подтюнивать, вставляя time.Sleep (в примере с таймерами анимация чуть некорректна поэтому).
Вобщем-то. это основная причина, по которой я пока-что не открываю код. Сейчас я играюсь ещё с [execution tracer](https://golang.org/cmd/trace/)-ом Дмитрия Вьюкова — он, похоже, даёт нужный уровень детализации, хотя не содержит информации о том, что именно было отправлено в канал. Возможно есть ещё какие-то способы достичь максимально детального трейса, буду исследовать дальше. Пишите мне в твиттер или тут в комментариях, если есть идеи. Было бы круто, чтобы этот инструмент в итоге перерос в 3D concurrency-дебаггер, применимый к абсолютно любой программе на Go, без исключений.
Эта статья изначально была в [виде доклада](http://divan.github.io/talks/2016/lviv/vis_concurrency/) на [Go Meetup-е во Львове (23 января 2016)](http://www.meetup.com/Lviv-Golang-Group/events/227453083/), затем [опубликована на английском языке в моём блоге](https://divan.github.io/posts/go_concurrency_visualize/). Также [на HackerNews](https://news.ycombinator.com/item?id=10981616) и [на Reddit](https://www.reddit.com/r/golang/comments/42yc77/visualizing_concurrency_in_go_with_webgl/). | https://habr.com/ru/post/276255/ | null | ru | null |
# Можно писать код и без переменных
Очень часто после фраз в духе: «Ну к примере в этом языке нету переменных, и от того нету проблем с...» или аналогичных с удивлением замечаю полное удивление в глазах собеседника. Это вызвано тем, что многие программисты не могут себе представить программу без такой вещи, как переменная. Ниже будет переведён пример такого кода на Plain C.
Данный код выполняет следующую задачу, он получает на входе массив из 4-х целых чисел, и определяет, могут ли они являться 4-мя сторонами прямоугольной трапеции.
Этот код ни в коей мере не претендует ни на эффективность, ни на выразительность и рассматривать его стоит только как пример того, что это возможно. Это связано с тем, что ни язык, ни задача не способствуют данному стилю программирования. И не смотря на это, можно выделить 1 сильную сторону этого кода, это хорошо выделенные абстракции.
Подробнее о переменных, и в более общем понимание, изменяемых состояниях можно прочитать статью «Изменяемое состояние: опасности и борьба с ними» Евгения Кирпичёва в первом выпуске журнала «Практика функционального программирования» по этой ссылке:
[fprog.ru/2009/issue1/eugene-kirpichev-fighting-mutable-state](http://fprog.ru/2009/issue1/eugene-kirpichev-fighting-mutable-state/)
``> #include
>
>
>
> int find\_dublicate(const int \*lines)
>
> {
>
> return find\_dublicate2(lines, 0, 0);
>
> }
>
>
>
> int find\_dublicate2(const int \*lines, const int i)
>
> {
>
> const int result = find\_dublicate3(lines, i, i + 1);
>
> if (result == -1)
>
> if (i < 3) return find\_dublicate2(lines, i + 1);
>
> else return -1;
>
> else return result;
>
> }
>
>
>
> int find\_dublicate3(const int \*lines,
>
> const int i,
>
> const int j)
>
> {
>
> if (lines[i] == lines[j])
>
> return lines[j];
>
> else
>
> if (j < 4) return find\_dublicate3(lines, i, j + 1);
>
> else return -1;
>
> }
>
>
>
> int delete\_duplicate(const int \*lines, const int a, const int number)
>
> {
>
> return delete\_duplicate2(lines, a, 0, 2, number);
>
> }
>
>
>
> int delete\_duplicate2(const int \*lines, const int a,
>
> const int i, const int j, const int number)
>
> {
>
> if (lines[i] == a && j != 0)
>
> delete\_duplicate2(lines, a, i + 1, j - 1, number);
>
> else if (number != 0)
>
> delete\_duplicate2(lines, a, i + 1, j, number - 1);
>
> else return lines[i];
>
> }
>
>
>
>
>
> int max\_AB(const int \*AB)
>
> {
>
> if (AB[0] > AB[1]) return 0;
>
> else return 1;
>
> }
>
>
>
> int main (int argc, char\*\* argv)
>
> {
>
> const int lines[] = {2,3,8,2};
>
> const int a = find\_dublicate(lines);
>
> if (a == -1) goto no;
>
> const int AB[2] = {delete\_duplicate(lines, a, 0), delete\_duplicate(lines, a, 1)};
>
>
>
> const int max = max\_AB(AB);
>
>
>
> const int delta = AB[max] - AB[max ? 0 : 1];
>
> if (delta/2 < a) goto yes;
>
> else goto no;
>
>
>
> yes:
>
> printf ("yes\n");
>
> return 0;
>
> no:
>
> printf ("no\n");
>
> return 0;
>
>
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
PS Код вроде работает правильно, хотя нормально не трестировался. Компилил gcc-4.2.1
PPS В веду некоторого непонимания, под переменной подразумевались объекты с изменяемым состоянием, а не именованный участоки памяти.` | https://habr.com/ru/post/72063/ | null | ru | null |
# Мины под производительностью ждут своего часа
В этой статье я расскажу о минах, заложенных под производительность, а также об их обнаружении (желательно ещё до взрыва) и обезвреживании.
**Картинка для привлечения внимания**
#### Что такое мина?
Начнём с того, что лежит у истоков любого знания, — с определения. Древние говорили, что правильно назвать — значит правильно понять. Я думаю, что определение мины под производительностью лучше всего выразить его противопоставлением явной ошибке, например, такой:
```
String concat(String... strings) {
String result = "";
for (String str : strings) {
result += str;
}
return result;
}
```
Даже начинающим разработчикам известно, что строки неизменяемы, а склеивание их в цикле не означает дописывание данных в хвост уже существующей строки, а создание **новой** строки при каждом проходе. Если вы оплошали, то не расстраивайтесь — "Идея" вас сразу же предупредит об опасности, а "Сонар" наверняка завалит вашу сборку.
А вот этот [код](https://github.com/spring-projects/spring-data-jpa/pull/269/files#diff-b23bd4fdc1c19109c8f6830041fdc651) привлечёт куда меньше внимания, да и "Идея" ([до версии 2018.2](https://youtrack.jetbrains.com/issue/IDEA-189336)) будет молчать:
```
Long total = 0L;
List totals = query.getResultList();
for (Long element : totals) {
total += element == null ? 0 : element;
}
```
Проблема здесь та же самая: обёртки для простых типов неизменяемы, а значит добавление к объектному числу 5 единицы означает создание новой обёртки и запись в него числа 6.
Злую шутку здесь играет наличие в яве двух представлений некоторых типов данных — простого и объектного, а также их автоматическое преобразование средствами самого языка. Из-за этого многие начинающие разработчики думают примерно так: "Ну, исполнение как-нибудь их там само преобразует, это же просто число".
На деле не всё так просто. Возьмём [бенчмарк](https://github.com/stsypanov/benchmarks/blob/master/benchmark-runners/src/main/java/com/luxoft/logeek/benchmark/boxing/BoxingBenchmark.java) и попробуем сложить числа указанным способом:
**Внезапно, вышло очень и очень недёшево (здесь и далее JDK 11, если явно не указано иное)**
```
(size) Mode Cnt Score Error Units
wrapper 10 avgt 100 23,5 ± 0,1 ns/op
wrapper 100 avgt 100 352,3 ± 2,1 ns/op
wrapper 1000 avgt 100 4424,5 ± 25,2 ns/op
wrapper 10 avgt 100 0 ± 0 B/op
wrapper 100 avgt 100 1872 ± 0 B/op
wrapper 1000 avgt 100 23472 ± 0 B/op
```
Сравните с простым типом:
```
primitive 10 avgt 100 6,4 ± 0,0 ns/op
primitive 100 avgt 100 39,8 ± 0,1 ns/op
primitive 1000 avgt 100 252,5 ± 1,3 ns/op
primitive 10 avgt 100 0 ± 0 B/op
primitive 100 avgt 100 0 ± 0 B/op
primitive 1000 avgt 100 0 ± 0 B/op
```
Отсюда выводим одно из определений мины под производительностью — это код, который не бросается в глаза, не обнаруживается (по крайней мере в то время, когда вы с ним столкнулись) статическими анализаторами, но может тормозить в некоторых использованиях. В нашем случае пока сумма не превышает 127 объекты берутся из кэша и `Long` всего в 4 раза медленнее чем `long`. Однако уже для массива размером 100 скорость ниже почти в 10 раз.
#### Большие мелочи
Иногда незначительное изменение, *почти* не меняющее смысл исполнения, в *некоторых* обстоятельствах становится сильным тормозом.
Предположим, у нас есть код:
```
// org.springframework.data.convert.CustomConversions$ConversionTargetsCache
Map> cache = new ConcurrentHashMap<>();
private TypeInformation getFromCacheOrCreate(Alias alias) {
TypeInformation info = cache.get(alias);
if (info == null) {
info = getAlias.apply(alias);
cache.put(alias, info);
}
return info;
}
```
На что похожа логика метода?
**Не спешите подсматривать, подумайте**Это же `ConcurrentHashMap::computeIfAbsent`!
У нас "восьмёрка" и мы можем круто улучшить код: 6 строк заменить одной, сделав код короче и проще для понимания. Кстати, знатоки многопоточности наверняка укажут на ещё одно улучшение, которое несёт с собой `ConcurrentHashMap::computeIfAbsent`, но о нём чуть позже ;)
Претворим в жизнь великую мысль:
```
// org.springframework.data.convert.CustomConversions$ConversionTargetsCache
Map> cache = new ConcurrentHashMap<>();
private TypeInformation getFromCacheOrCreate(Alias alias) {
return cache.computeIfAbsent(alias, getAlias);
}
```
**Собрались, запустились, прослезились**Чтобы увидеть полный размер нажмите правой клавишей по рисунку и выберите "Открыть изображение в новой вкладке"
Пока приложение работало с одним потоком — всё было более-менее хорошо. Потоков стало больше и стало ощутимо хуже. Выяснилось, что `ConcurrentHashMap::computeIfAbsent` блокируется, при чём [даже в том случае, когда ключ **уже** добавлен в словарь](https://bugs.openjdk.java.net/browse/JDK-8161372). И это стало причиной вполне себе [бага](https://jira.spring.io/browse/DATACMNS-1396) в Спринг Дата Монго.
Убедиться в этом можно с помощью простого [измерения](https://github.com/stsypanov/benchmarks/blob/master/benchmark-runners/src/main/java/com/luxoft/logeek/benchmark/concurrency/ConcurrentHashMapBenchmark.java) ("восьмёрка"). Вот его вывод:
```
Benchmark Mode Cnt Score Error Units
1 thread
computeIfAbsent avgt 20 19,405 ± 0,411 ns/op
getAndPut avgt 20 4,578 ± 0,045 ns/op
2 threads
computeIfAbsent avgt 20 66,492 ± 2,036 ns/op
getAndPut avgt 20 4,454 ± 0,110 ns/op
4 threads
computeIfAbsent avgt 20 155,975 ± 8,850 ns/op
getAndPut avgt 20 5,616 ± 2,073 ns/op
6 threads
computeIfAbsent avgt 20 203,188 ± 10,547 ns/op
getAndPut avgt 20 7,024 ± 0,456 ns/op
8 threads
computeIfAbsent avgt 20 302,036 ± 31,702 ns/op
getAndPut avgt 20 7,990 ± 0,144 ns/op
```
Можно ли это однозначно считать ошибкой разработчиков? По моему скромному мнению — нет, нельзя. В [документации](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentHashMap.html#computeIfAbsent(K,java.util.function.Function)) сказано:
> Some attempted update operations on this map by other threads may be blocked while computation is in progress, so the computation should be short and simple, and must not attempt to update any other mappings of this map
Иными словами `ConcurrentHashMap::computeIfAbsent` закрывает от внешнего мира ячейку, содержащую ключ (в отличие от `ConcurrentHashMap::get`), что в общем случае верно, так как позволяет увернуться от гонки при одновременном вызове метода из разных потоков, когда ключ ещё не добавлен.
С другой стороны, в наиболее распространённом режиме работы вычисление значения и связывание его с ключом происходит только при первом обращении, а все последующие обращения только возвращают ранее рассчитанное значение. Посему имеет смысл изменить логику таким образом, чтобы блокировка выставлялась только при изменении. [Это было сделано здесь](http://hg.openjdk.java.net/jdk9/dev/jdk/rev/fe0d3813e6c3).
В более свежих изданиях (>8) `ConcurrentHashMap::computeIfAbsent` стал шустрее:
```
JDK 11
Benchmark Mode Cnt Score Error Units
1 thread
computeIfAbsent avgt 20 6,983 ± 0,066 ns/op
getAndPut avgt 20 5,291 ± 1,220 ns/op
2 threads
computeIfAbsent avgt 20 7,173 ± 0,249 ns/op
getAndPut avgt 20 5,118 ± 0,395 ns/op
4 threads
computeIfAbsent avgt 20 7,991 ± 0,447 ns/op
getAndPut avgt 20 5,270 ± 0,366 ns/op
6 threads
computeIfAbsent avgt 20 11,919 ± 0,865 ns/op
getAndPut avgt 20 7,249 ± 0,199 ns/op
8 threads
computeIfAbsent avgt 20 14,360 ± 0,892 ns/op
getAndPut avgt 20 8,511 ± 0,229 ns/op
```
Обратите внимание на коварство этого примера: смысловое содержание *почти* не изменилось, ведь на первый взгляд мы всего-лишь использовали более продвинутый синтаксис. При этом пока приложение работает в одну нить, пользователь почти не чувствует разницы! Вот так вроде бы безобидные изменения подкладывают ~~свинью~~ мину под нашу производительность.
**Почему я написал 'почти не изменилось'**Не всегда `ConcurrentHashMap::computeIfAbsent` взаимозаменяем с выражением `getAndPut`, потому что `ConcurrentHashMap::computeIfAbsent` является атомарной операцией. В этом же коде
```
private TypeInformation getFromCacheOrCreate(Alias alias) {
TypeInformation info = cache.get(alias);
if (info == null) {
info = getAlias.apply(alias);
cache.put(alias, info);
}
return info;
}
```
из-за отсутствия внешней синхронизации **появляется гонка**. Если функция, передаваемая в `ConcurrentHashMap::computeIfAbsent` для заданного ключа всегда возвращает одно и то же значения, то это "безопасная" гонка, самое большее, что нам грозит — это вычисление одного и того же значения 2 и более раз. Если же таких гарантий нет, то механическая замена чревата поломкой приложения. Будьте осторожны!
#### Эти руки ничего не меняли
Бывает и так, что код вообще не меняется, но внезапно начинает тормозить.
Представьте, что перед нами стоит задача переложить элементы массива в коллекцию. Наиболее логичным будет использовать готовый метод `Collection::addAll`, да вот незадача — он принимает коллекцию:
```
public interface Collection extends Iterable {
boolean addAll(Collection extends E c);
}
```
Самый простой выход — завернуть массив в `Arrays::asList`. Получится что-то вроде
```
boolean addItems(Collection collection) {
T[] items = getArray();
return collection.addAll(Arrays.asList(items));
}
```
В ходе вычитки заботящиеся о производительности коллеги наверняка укажут нам, что в этом коде есть сразу две проблемы:
* заворачивание массива в список (лишний объект)
* создание итератора (ещё один лишний объект) и проход по нему
В самом деле, в опорной реализации `Collection::addAll` мы увидим вот это:
```
public abstract class AbstractCollection implements Collection {
public boolean addAll(Collection extends E c) {
boolean modified = false;
for (E e : c) {
if (add(e))
modified = true;
}
return modified;
}
}
```
Таки здесь создаётся итератор и элементы перебираются с его помощью. Поэтому опытные товарищи предлагают своё решение:
```
boolean addItems(Collection collection) {
T[] items = getArray();
return Collections.addAll(collection, items);
}
```
Внутри код, вполне справедливо *кажущийся* более производительным:
```
public static boolean addAll(Collection super T c, T... elements) {
boolean result = false;
for (T element : elements)
result |= c.add(element);
return result;
}
```
Во-первых, не создаётся итератор. Во-вторых, проход идёт в обычном счётном цикле, к тому же массивы хорошо ложатся в кэши, его элементы расположены в памяти последовательно (значит будет мало кэш-миссов), а доступ к ним по индексу очень быстрый. Ну и список-обёртка тоже не создаётся. Звучит веско и обоснованно.
Наконец, коллеги приводят ultima ratio regum: документацию. А там серым по белому (или зелёным по чёрному) сказано:
```
/**
* ...
* The behavior of this convenience method is identical to that of
* c.addAll(Arrays.asList(elements)), but this method is likely
* to run significantly faster under most implementations. <----
* @since 1.5
*/
@SafeVarargs
public static boolean addAll(Collection super T c, T... elements) {
//...
}
```
Т. е. сами разработчики (а кому верить, как не им?) пишут, что для большинства реализаций утилитный метод работает *значительно* быстрее. И он действительно быстрее. Иногда.
Убедиться в этом поможет [бенчмарк](https://github.com/stsypanov/benchmarks/blob/master/benchmark-runners/src/main/java/com/luxoft/logeek/benchmark/collection/CollectionsAddAllVsAddAllBenchmark.java), который мы запустим для `HashSet`-а на "восьмёрке":
```
Benchmark (collection) (size) Mode Cnt Score Error Units
addAll HashSet 10 avgt 100 155,2 ± 2,8 ns/op
addAll HashSet 100 avgt 100 1884,4 ± 37,4 ns/op
addAll HashSet 1000 avgt 100 17917,3 ± 298,8 ns/op
collectionsAddAll HashSet 10 avgt 100 136,1 ± 0,8 ns/op
collectionsAddAll HashSet 100 avgt 100 1538,3 ± 31,4 ns/op
collectionsAddAll HashSet 1000 avgt 100 15168,6 ± 289,4 ns/op
```
Похоже, что более опытные товарищи оказались правы. Почти.
В более поздних изданиях (например, в 11) блеск утилитного метода несколько потускнеет:
```
Benchmark (collection) (size) Mode Cnt Score Error Units
addAll HashSet 10 avgt 100 143,1 ± 0,6 ns/op
addAll HashSet 100 avgt 100 1738,4 ± 7,3 ns/op
addAll HashSet 1000 avgt 100 16853,9 ± 101,0 ns/op
collectionsAddAll HashSet 10 avgt 100 132,1 ± 1,1 ns/op
collectionsAddAll HashSet 100 avgt 100 1661,1 ± 7,1 ns/op
collectionsAddAll HashSet 1000 avgt 100 15450,9 ± 93,9 ns/op
```
Видно, что ни о каком "значительно быстрее" речь не идёт. А если мы повторим опыт для `ArrayList`-a, то окажется, что утилитный метод начинает сильно проигрывать (чем дальше — тем сильнее):
```
Benchmark (collection) (size) Mode Cnt Score Error Units
JDK 8
addAll ArrayList 10 avgt 100 38,5 ± 0,5 ns/op
addAll ArrayList 100 avgt 100 188,4 ± 7,0 ns/op
addAll ArrayList 1000 avgt 100 1278,8 ± 42,9 ns/op
collectionsAddAll ArrayList 10 avgt 100 62,7 ± 0,7 ns/op
collectionsAddAll ArrayList 100 avgt 100 495,1 ± 2,0 ns/op
collectionsAddAll ArrayList 1000 avgt 100 4892,5 ± 48,0 ns/op
JDK 11
addAll ArrayList 10 avgt 100 26,1 ± 0,0 ns/op
addAll ArrayList 100 avgt 100 161,1 ± 0,4 ns/op
addAll ArrayList 1000 avgt 100 1276,7 ± 3,7 ns/op
collectionsAddAll ArrayList 10 avgt 100 41,6 ± 0,0 ns/op
collectionsAddAll ArrayList 100 avgt 100 492,6 ± 1,5 ns/op
collectionsAddAll ArrayList 1000 avgt 100 6792,7 ± 165,5 ns/op
```
Ничего неожиданного здесь нет, `ArrayList` построен вокруг массива, поэтому разработчики дальновидно переопределили метод `Collection::addAll`:
```
public boolean addAll(Collection extends E c) {
Object[] a = c.toArray();
modCount++;
int numNew = a.length;
if (numNew == 0)
return false;
Object[] elementData;
final int s;
if (numNew > (elementData = this.elementData).length - (s = size))
elementData = grow(s + numNew);
System.arraycopy(a, 0, elementData, s, numNew); <--- переносим данные пачкой
size = s + numNew;
return true;
}
```
Теперь вернёмся к нашим минам. Предположим, что мы всё же приняли предложенное на вычитке решение и оставили этот код:
```
boolean addItems(Collection collection) {
T[] items = getArray();
return Collections.addAll(collection, items);
}
```
До поры до времени всё хорошо, но после добавления нового функционала метод иногда становится горячим и начинает тормозить. Открываем исходники — код не менялся. Объём данных тот же. А производительность сильно просела. Это ещё одна разновидность мин.
Расчехляем отладчик и находим прекрасное:
Обратите внимание: мы не меняли алгоритм, объём обрабатываемых данных не изменился, но изменилась их природа и в нашем коде завелась проблема производительности:
```
Java 8 Java 11
размер
addAll 10 56,9 25,2 ns/op
collectionsAddAll 10 352,2 142,9 ns/op
addAll 100 159,9 84,3 ns/op
collectionsAddAll 100 4607,1 3964,3 ns/op
addAll 1000 1244,2 760,2 ns/op
collectionsAddAll 1000 355796,9 364677,0 ns/op
```
На больших массивах разница между `Collections::addAll` и `Collection::addAll` составляет скромных 500 раз. Дело в том, что `COWList` не просто расширяет существующий массив, а создаёт новый при каждом добавлении элементов:
```
public boolean add(E e) {
synchronized (lock) {
Object[] es = getArray();
int len = es.length;
es = Arrays.copyOf(es, len + 1); <---- привет сборщику мусора
es[len] = e;
setArray(es);
return true;
}
}
```
~~Кто виноват?~~
**Что делать?**<https://bugs.openjdk.java.net/browse/JDK-8193031>
<http://cr.openjdk.java.net/~martin/webrevs/jdk/Collections-addAll/>
Основная проблема здесь в том, что метод `Collections::addAll` принимает интерфейс, при этом у метода `addAll` нет тела. Нет тела — нет дела, поэтому документация написана исходя из реализации, существующей в `AbstractCollection::addAll`, которая является обобщённым алгоритмом, применимым для всех коллекций. Это означает, что более конкретные реализации структур данных, находящиеся на более низком уровне абстракции, могут изменять это поведение.
**Теперь по-человечески**
```
Collection::addAll – верхний уровень
AbstractCollection::addAll – средний уровень <--- описано в документации
ArrayList::addAll
HashSet::addAll – нижний уровень <--- тут может быть что угодно
COWList::addAll
```
#### Ещё об абстракциях
Раз уж мы заговорили об уровнях абстракции, то расскажу об одном примере из жизни.
Давайте сравним эти два способа сохранения энного количество сущностей в базу:
```
@Transactional
void save(int n) {
for (int i = 0; i < n; i++) {
SimpleEntity e = new SimpleEntity();
repository.save(e);
}
}
@Transactional
void _save(int n) {
for (int i = 0; i < n; i++) {
SimpleEntity e = new SimpleEntity();
repository.saveAndFlush(e);
}
}
```
На первый взгляд, производительность обоих способов не должна особо отличаться, ведь
* в обоих случаях в базу будет сохранено одинаковое количество сущностей
* если ключ берётся из последовательности, то количество обращение будет одинаковым
* объём передаваемых данных одинаков
Обратимся к методу `SimpleJpaRepository::saveAndFlush`:
```
@Transactional
public ~~S save(S entity) {
if (entityInformation.isNew(entity)) {
em.persist(entity);
return entity;
} else {
return em.merge(entity);
}
}
@Transactional
public ~~S saveAndFlush(S entity) {
S result = save(entity);
flush();
return result;
}
@Transactional
public void flush() {
em.flush();
}~~~~
```
Стрёмным местом здесь является метод `flush()`. Почему стрёмным? Как мне кажется, его раскрытие в интерфейсе `JpaRepository` было ошибкой разработчиков. Попробую обосновать свою мысль. Обычно этот метод вообще не используется разработчиком, т. к. вызов `EntityManager::flush` привязан к завершению транзакции, управляемой Спрингом:
```
// управление сессией передано каркасу
@Transactional
public void method() { <-- скрытый Session::open
/*.*/
} <-- скрытый Session::flush
```
Обратите внимание: `EntityManager` — это часть спецификации `JPA`, реализованный в Хибернейте в виде сессии (интерфейс Session и класс SessionImpl, соответственно). Спринг Дата — это каркас, работающий поверх ORM-а, в данном случае — поверх Хибернейта. Получается, что метод `JpaRepository::saveAndFlush` даёт нам доступ к нижним уровням API, хотя задача фреймворка как раз в сокрытии низкоуровневых подробностей (ситуация чем-то похожа на историю с Unsafe в JDK).
В нашем случае при использовании `JpaRepository::saveAndFlush` мы влезаем в низшие слои приложения, ломая тем самым кое-что.
**Не торопитесь подсматривать, подумайте самостоятельно**Ломается способность Хибернейта отправлять данные пачками, кратно настройке `jdbc.batch_size`, которая указывается в `application.yml`:
```
spring:
jpa:
properties:
hibernate:
jdbc.batch_size: 500
```
Работа Хибернейта построена на событиях, поэтому при сохранении 1000 сущностей вот так
```
@Transactional
void save(int n) {
for (int i = 0; i < n; i++) {
SimpleEntity e = new SimpleEntity();
repository.save(e);
}
}
```
при вызове `repository.save(e)` не происходит мгновенного сохранения. Вместо этого создаётся событие, которое ставится в очередь. По завершению транзакции данные сливаются при помощи `EntityManager::flush`, который делит вставки/обновления на пачки кратно `jdbc.batch_size` и создаёт из них запросы. В нашем случае `jdbc.batch_size: 500`, так что сохранение 1000 сущностей на деле означает лишь 2 запроса.
А вот с ручным сливом сессии на каждом проходе цикла
```
@Transactional
void _save(int n) {
for (int i = 0; i < n; i++) {
SimpleEntity e = new SimpleEntity();
repository.saveAndFlush(e);
}
}
```
очередь очищается и сохранение 1000 сущностей означает 1000 запросов.
Таким образом, вмешательство в низшие слои приложения может легко стать миной, при чём не только миной производительности (см. Unsafe и его неконтролируемое применение).
Насколько сильно это тормозит? Возьмём самый лучший (для нас) случай — БД находится на том же хосте, что и приложение. Мой [замер](https://github.com/stsypanov/benchmarks/blob/master/benchmark-runners/src/main/java/com/luxoft/logeek/benchmark/batch/SaveAndFlushBenchmark.java) показывает такую картину:
```
(entityCount) Mode Cnt Score Error Units
bulkSave 10 ss 500 16,613 ± 1,714 ms/op
bulkSave 100 ss 500 31,371 ± 1,453 ms/op
bulkSave 1000 ss 500 35,687 ± 1,973 ms/op
bulkSaveUsingFlush 10 ss 500 32,653 ± 2,166 ms/op
bulkSaveUsingFlush 100 ss 500 61,983 ± 6,304 ms/op
bulkSaveUsingFlush 1000 ss 500 184,814 ± 6,976 ms/op
```
Очевидно, что если БД находится на удалённом хосте, то затраты на передачу данных будут всё более ухудшать производительность по мере роста объёма данных.
Таким образом, работая на неправильном уровне абстракции можно легко создать мину замедленного действия. Кстати, в [одной из своих предыдущих статей](https://habr.com/ru/post/436746/) я рассказывал о курьёзной попытке улучшения `StringBuilder`-a: там меня постигла неудача как раз при попытке влезть в более абстрактный уровень кода.
#### Границы минных полей
Поиграем в сапёра? Найди мину:
```
// org.springframework.cache.interceptor.CacheAspectSupport
Object generateKey(CacheOperationContext ctx, Object result) {
Object key = ctx.generateKey(result);
Assert.notNull(key, "Null key ..." + context.metadata.operation);
// ...
return key;
}
```
**Нашёл? Сверься с правильным ответом**
```
|
\ /
// org.springframework.cache.interceptor.CacheAspectSupport
|
\ /
Object generateKey(CacheOperationContext ctx, Object result) {
Object key = ctx.generateKey(result);
|
\ /
Assert.notNull(key, "Null key ..." + context.metadata.operation);
return key;
}
```
"Издеваетесь?", — воскликнет критик, — "Да там всего-лишь склейка двух строк? Какое это имеет значение в кровавом Э.?" Позвольте обратить ваше внимание на то, что я выделил не только склейку строк, а ещё и имя класс и название метода. Ведь опасность склейки строк не в самой склейке, а в том, что происходит она в методе, создающем ключи для кэша, т. е. в определённых сценариях у нас будет очень много обращений к этому методу, а значит очень много мусорных строк.
Поэтому сообщение об ошибке [нужно создавать только тогда](https://github.com/spring-projects/spring-framework/commit/67f184293b94c076b0474231f739a74f42d5ffa8), когда эта ошибка действительно будет выброшена:
```
// org.springframework.cache.interceptor.CacheAspectSupport
Object generateKey(CacheOperationContext ctx, Object result) {
Object key = ctx.generateKey(result);
if (key == null) {
throw new IAE("Null key ..." + context.metadata.operation);
}
// ...
return key;
}
```
Таким образом, минные поля имеют границы — это тот объём данных, частота обращения к методу и т. п. количественные показатели, при достижении и превышении которых незначительный недостаток становится статистически значимым.
С другой стороны — это та черта, до пересечения которой усложнение кода не даёт значимого (измеримого) улучшения.
Отсюда ещё один вывод для разработчика: в большинстве случаев крохоборство — это зло, ведущее к бессмысленному усложнению кода. В 99 случаях из 100 мы ничего не выигрываем.
При этом нужно помнить, что всегда есть
#### Тот самый сотый случай
Вот код, который приводит в своей статье [The volatile read surprise](http://psy-lob-saw.blogspot.com/2014/08/the-volatile-read-suprise.html) Ницан Вакарт:
```
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
public class LoopyBenchmarks {
@Param({ "32", "1024", "32768" })
int size;
byte[] bunn;
@Setup
public void prepare() {
bunn = new byte[size];
}
@Benchmark
public void goodOldLoop(Blackhole fox) {
for (int y = 0; y < bunn.length; y++) { // good old C style for (the win?)
fox.consume(bunn[y]);
}
}
@Benchmark
public void sweetLoop(Blackhole fox) {
for (byte bunny : bunn) { // syntactic sugar loop goodness
fox.consume(bunny);
}
}
}
```
Когда мы поставим опыт, то обнаружим удивительную разницу между двумя способами перебора массива:
```
Benchmark (size) Score Score error Units
goodOldLoop 32 46.630 0.097 ns/op
goodOldLoop 1024 1199.338 0.705 ns/op
goodOldLoop 32768 37813.600 56.081 ns/op
sweetLoop 32 19.304 0.010 ns/op
sweetLoop 1024 475.141 1.227 ns/op
sweetLoop 32768 14295.800 36.071 ns/op
```
Здесь неопытный разработчик может сделать такой очевидный и подкреплённый бенчмарками вывод: проход по массиву с помощью нового синтаксиса работает быстрее, чем счётный цикл. Это неверный вывод, ведь стоит немного изменить метод `goodOldLoop`:
```
@Benchmark
public void goodOldLoopReturns(Blackhole fox) {
byte[] sunn = bunn; // make a local copy of the field
for (int y = 0; y < sunn.length; y++) {
fox.consume(sunn[y]);
}
}
```
и его показатели сравняются с показателями "более быстрого" метода `sweetLoop`:
```
Benchmark (size) Score Score error Units
goodOldLoopReturns 32 19.306 0.045 ns/op
goodOldLoopReturns 1024 476.493 1.190 ns/op
goodOldLoopReturns 32768 14292.286 16.046 ns/op
sweetLoop 32 19.304 0.010 ns/op
sweetLoop 1024 475.141 1.227 ns/op
sweetLoop 32768 14295.800 36.071 ns/op
```
Дело здесь в коварном `Blackhole::consume`:
```
//...
public volatile byte b1, b2;
public volatile BlackholeL2 nullBait = null;
/**
* Consume object. This call provides a side effect preventing JIT to eliminate dependent computations.
*
* @param b object to consume.
*/
public final void consume(byte b) {
if (b == b1 & b == b2) {
// SHOULD NEVER HAPPEN
nullBait.b1 = b; // implicit null pointer exception
}
}
```
благодаря которому внутри нашего цикла внезапно нарисовался волатильный доступ, который действует подобно барьеру, запрещая компилятору некоторые перестановки и улучшения. В первой версии метода `goodOldLoop` компилятор вынужден загружать из памяти поле `this.bunn` при каждом проходе цикла, а `for-each` цикл делает это лишь единожды, выполняя неявное сохранение поля в местную переменную (ЕМНИП, в Java Concurrency In Practice это называется "синхронизация на стеке"). Именно этим объясняется разница в показателях.
Критически настроенный читатель скажет: "Какое значение это имеет в повседневной работе? Этот пример искусственный, `Blackhole::consume` — часть инфраструктуры JMH и в обычной разработке никогда не используется. И вообще, какая разница, как именно перебирать массив в реальном коде?"
Чтобы отразить этот убийственный аргумент давайте внимательно посмотрим на пример:
```
byte[] bunn;
public void goodOldLoop(Blackhole fox) {
for (int y = 0; y < bunn.length; y++) {
fox.consume(bunn[y]);
}
}
```
Ничего не напоминает? Точно? Что же, давайте внесём некоторые изменения:
```
E[] bunn;
public void forEach(Consumer fox) {
for (int y = 0; y < bunn.length; y++) {
fox.consume(bunn[y]);
}
}
```
Получился `Iterable::forEach`! И если открыть реализации этого метода для коллекций, работающих поверх массива, то внезапно все они используют либо сахарный цикл, либо сохранение в переменную перед проходом (все исходники из JDK 13):
```
//ArrayList
public void forEach(Consumer super E action) {
Objects.requireNonNull(action);
final int expectedModCount = modCount;
final Object[] es = elementData;
final int size = this.size;
for (int i = 0; modCount == expectedModCount && i < size; i++)
action.accept(elementAt(es, i));
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
//Arrays$ArrayList
public void forEach(Consumer super E action) {
Objects.requireNonNull(action);
for (E e : a) {
action.accept(e);
}
}
//CopyOnWriteArrayList
public void forEach(Consumer super E action) {
Objects.requireNonNull(action);
for (Object x : getArray()) {
@SuppressWarnings("unchecked") E e = (E) x;
action.accept(e);
}
}
//ArrayDeque
public void forEach(Consumer super E action) {
Objects.requireNonNull(action);
final Object[] es = elements;
for (int i = head, end = tail, to = (i <= end) ? end : es.length; ; i = 0, to = end) {
for (; i < to; i++)
action.accept(elementAt(es, i));
if (to == end) {
if (end != tail) throw new ConcurrentModificationException();
break;
}
}
}
```
А помнить об этом нужно, когда вы реализовываете свою структуру данных или улучшаете уже существующую. Например, не так давно поступило [предложение об улучшении](http://mail.openjdk.java.net/pipermail/core-libs-dev/2018-December/057192.html) `Collections.nCopies()::forEach`:
```
@Override
public void forEach(final Consumer super E action) {
Objects.requireNonNull(action);
for (int i = 0; i < this.n; i++) {
action.accept(this.element);
}
}
```
На первый взгляд в этом коде нет необходимости выполнять синхронизацию на стеке, т. к. значения полей `this.n` и `this.element` записываются только один раз при создании объекта:
```
private static class CopiesList
extends AbstractList
implements RandomAccess, Serializable {
final int n;
final E element;
CopiesList(int n, E e) {
assert n >= 0;
this.n = n;
element = e;
}
```
Как оказалось, [полагаться на это нельзя](http://mail.openjdk.java.net/pipermail/core-libs-dev/2018-December/057362.html), [равно как и на](https://openjdk.markmail.org/thread/rfqfultw35i2az45) `@Stable`.
Обратите внимание: в 99 случаях из 100 совершенно неважно, как именно вы обходите массив, но всегда есть 1 случай из 100, в котором внутри цикла окажется волатильный доступ и неверное решение станет проблемой производительности. Это ещё один пример мины, срабатывающей только в особых условиях.
В [одной из своих статей](https://habr.com/ru/post/432824/) я показывал похожий пример разрушительного воздействия на производительность связки "цикл и volatile".
#### Эхо войны
Завершить статью хочу примером древнего улучшения, которое стало миной:
```
//java.lang.Integer
@HotSpotIntrinsicCandidate
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
```
Когда-то давно разработчики посчитали, что неплохо было бы кэшировать значения некоторых типов (`java.lang.Integer`, `java.lang.Long`, `java.lang.Short`, `java.lang.Byte`, `java.lang.Character`). Более того, это внесли в спецификацию языка, поэтому когда мы пишем
```
Integer intgr = Integer.valueOf(42);
```
новый объект не создаётся.
Если мы дерзнём писать вот так:
```
Integer intgr = new Integer(42);
```
то все статические анализаторы завопят про ухудшение производительности, ФайндБагз и Сонар будут заваливать сборки до тех пор, пока мы не вернёмся к каноничному `Integer::valueOf` вместо богомерзкого конструктора.
Спустя некоторое время были внедрены куда более крутые усовершенствования: анализ области видимости переменной и скаляризация. Их связка позволяет вместо создания объекта в куче отобразить его в виде набора полей на стеке, в тех случаях, когда объект не утекает из "родного" метода (или утекает недалеко после вклеивания тела метода в точку вызова). И внезапно оказалось, что эта оптимизация работает с конструктором и ломается, если заворачиваемое простое значение протаскивается через кэш внутри `Integer::valueOf`. Подробно эта история описана в докладе ["Сжимай меня полностью"](https://youtu.be/sHHbIStkaqI?t=2472).
На сегодня всё. Помните, что даже очень простой код в определённых условиях может быть очень и очень коварным. Надеюсь, мои примеры помогут вам в повседневной работе. Если у вас есть свои примеры, то я буду признателен, если вы поделитесь ими в комментариях. | https://habr.com/ru/post/443206/ | null | ru | null |
# Предиктивная аналитика на платформе SCP
---
Это третья публикация в рамках помощи участникам конкурса **[«SAP Кодер-2017»](http://sapcoder.ru/)**.
---
Каждое предприятие в процессе своей жизнедеятельности генерирует значительное количество данных, как «больших», так и не очень. Эти данные часто можно использовать для получения нового знания, которое, в свою очередь может оказать существенное влияние на стратегию развития бизнеса или тактику поведения в некоторые локальные моменты работы. Сейчас, в связи с развитием вычислительной техники и ростом объема накопленных данных, большое развитие получили численные методы, позволяющие извлекать полезную информацию из массива «сырых» данных и использовать ее в различных бизнес-сценариях.
[](https://habrahabr.ru/company/sap/blog/327086/)
SAP Cloud Platform имеет, наряду с другими встроенными сервисами, инструментарий предиктивной аналитики, позволяющий строить и использовать построенные модели в созданных на платформе (и вне ее) бизнес-задачи. Набор прогнозных инструментов, входящий в сервис на дату публикации поста, состоит из следующих элементов:
* Clustering – классический кластерный анализ и сегментация базы объектов с большим количеством атрибутов-классификаторов;
* Forecasts – построение прогнозов на базе временных рядов;
* Key Influencers – поиск наиболее влияющих на целевую функцию параметров;
* Outliers – поиск нестандартных паттернов в наборе данных (выявление мошенничеств, ошибок ввода и пр.);
* Recommendation – построение моделей продуктовых рекомендаций на базе истории покупок (чеков);
* Scoring Equation – построение и экстракция уравнения, позволяющего вычислять целевую функцию аналитически и встраивать ее в собственное приложение;
* What If – анализ «что-если», позволяющий предполагать последствия совершения тех или иных действий, базируясь на истории поведения объекта
Актуальный список методов и их описание можно посмотреть [по ссылке](https://help.hana.ondemand.com/c4pa/frameset.htm?842b68bd9c524f2e913218e2499f99d7.html).
Одна из задач на **[конкурс SAP Кодер](http://sapcoder.ru/)** предполагает использование модели рекомендаций. Здесь мы расскажем, как построить подобную модель в Predictive сервисе SCP. Первое, с чего стоит начать – это подготовка данных для «тренировки» модели. В случае сервиса Recommendation под тренировкой подразумевается поиск пар товаров (продающихся вместе) и построение списка рекомендаций конкретным клиентам (например, участникам программы лояльности).
Исходные данные
---------------
Исходные данные для построения модели просты – это кассовые чеки магазина. Они должны содержать следующие параметры:
* userID – номер участника программы лояльности (уникальный идентификатор покупателя)
* itemID – код товара (SKU)
* purchaseDate – дата транзакции (чека)
Загрузить эти данные в систему, не имея доступа к файловой системе сервера, проще всего через функцию Import/Export в HANA Studio (Eclipse). Для этого необходимо:
1. Подготовить данные в файле формата CSV.
2. Создать на SCP новую базу данных HANA MDC. В нашем случае она называется h1
3. Создать схему данных, в которой мы будем проводить наши эксперименты. Мы создали схему PROBA
4. Создать таблицу для помещения исходных данных, здесь PROBA.SALES\_DATA. В таблице должно быть несколько ключевых полей, в нашем случае это RID – номер участника программы лояльности, RDATE, TRIME, RDATETIME – дата и время транзакции в разных форматах, важна только RDATETIME, SKU – артикул товара.
Дополнительно в нашей базе данных содержится таблица PRODUCTS – из двух полей – код и название товара.
5. Выгрузить таблицу SALES\_DATA на локальный диск с помощью функции Export. Спуститься по структуре каталогов до файлов с описанием экспорта
6. В файл data.csv поместить данные в формате CSV
7. В файле data.ctl поменять разделитель полей CSV на необходимый
8. В файле data.info изменить данные о размере файла data.csv и количестве строк в нем
9. Загрузить данные с помощью функции Import с заменой существующего объекта в базе данных
Настройка сервиса
-----------------
Прежде, чем приступить к построению модели, необходимо произвести базовые настройки сервиса Predictive. По умолчанию сервис выключен, первое, что надо сделать – включить сервис
 
Система спросит, стоит ли устанавливать обновления. Правильный ответ – да. После этого необходимо развернуть сервис на вашем эккаунте пользователя, для этого необходимо ввести логин и пароль, используемые для входа на SCP.
После разворачивания сервиса нажимаем на ссылку Java Dashboard
И присваиваем своему пользователю-разработчику обе указанные роли: C4PA-User, C4PA-Admin
Следующим шагом мы должны привязать SCP Predictive service к нашей базе данных
Для этого в базе данных желательно создать технического пользователя, в нашем случае PROBA\_U
и присвоить ему необходимые для запуска предиктивного сервиса полномочия. При создании пользователя HANA спросит начальный пароль, чтобы изменить его (и входить в базу автоматически от имени Predictive Service), необходимо один раз войти в систему от имени этого пользователя. Для этого надо создать новое подключение к облачному источнику данных в HANA Studio и войти в базу данных, изменив начальный пароль.
После создания технического пользователя (или решения использовать существующего) привязываем сервис к конкретной схеме базы данных.
При этом используем данные технического пользователя, Data Source оставляем по умолчанию — .
После разворачивания сервиса на эккаунте разработчика и привязки базы данных рестартуем сервис – последовательно нажимаем кнопки Stop и Start.
После перезапуска сервиса появится ссылка на java-приложение, позволяющее управлять сервисом, контролировать его и использовать в разработке приложений
После вызова ссылки система предлагает нам две панели, одна для разработки, другая для мониторинга сервиса
При нажатии на панель Administration, приложение выдает массу мониторинговой информации о Predictive service, которую можно использовать для анализа, однако для нашего случая основной панелью является «Predictive Services API Documentation»
Построение и использование модели рекомендаций
----------------------------------------------
Посмотрим на наши чеки в более приспособленном для человеческого взгляда виде. Для этого создадим представление данных в виде
`**CREATE** **VIEW** "PROBA"."SALESWPROD" ( "RID",
"USER_ID",
"RDATE",
"RTIMESTAMP",
"ITEMS",
"SKU_ID",
"SKU_NAME" ) **AS** **SELECT**
T0."RID" ,
t0."USER_ID",
T0."RDATE",
TO_TIMESTAMP(T0."RDATETIME"),
T0."ITEMS",
T0."SKU",
T1."SKU_NAME"
**from** "PROBA"."SALES_DATA" T0
**inner** **join** "PROBA"."PRODUCTS" T1 **on** T0."SKU" = T1."SKU_ID" **WITH** READ **ONLY**`
Это view не нужно нам для решения нашей задачи, но позволяет наглядно увидеть чеки с позициями продаж (SKU)
Запускаем «Predictive Services API Documentation». На этой странице приложения Predictive Service собраны все включенные в него математические методы и точки доступа к каждому из них (endpoints).
Начнем с создания источника данных для предиктивной модели. Для этого нажимаем на закладку POST у точки доступа /api/analytics/dataset
и меняем параметр hanaURL в JSON-шаблоне, с помощью которого передаются все параметры в Perdictive service. Нажимаем POST, дожидаемся ответа сервера со статусом 200. В ответ сервер возвращает также JSON-файл, в котором сообщает информацию о подключенном источнике (количество строк, количество и тип поле и т.д., и, главное, ID датасета. Этот ID нам надо запомнить, в дальнейшем мы будем использовать его при создании модели рекомендации. Закрываем данную форму нажатием кнопки close в правом верхнем углу.
Возвращаемся на основную страницу Predictive Service и переходим к созданию модели. Для этого нажимаем закладку POST у ссылки /api/analytics/recommendations/recommender. Открывается страница настройки модели рекомендаций. Параметры построения будущей модели задаются в JSON-формате. Все возможные параметры модели описаны в документации по адресу <https://help.hana.ondemand.com/c4pa/frameset.htm?ee805144d197482abef88bfad8d895da.html>.
Это
* UserColumn – поле с номером участника программы лояльности
* itemColumn – SKU
* dateColumn – дата транзакции
* startDate – дата начала данных для расчета
* endDate – дата окончания данных для расчета
Дополнительно можно менять параметры, описывающие математику модели. Для нашей модели мы возьмем следующие параметры:
Запускаем построение модели и получаем отклик. Ключевой момент – записать ID модели
С помощью ссылки /api/analytics/recommendations/recommender/{jobID} можно посмотреть статус построенной модели, указав 15 в качестве ID. Для нашей модели статус следующий
Видим, что количество SKU, встречающихся в одной корзине с другими составляет 2777 штук, на базе чего удалось найти 9633 правил рекомендаций. С помощью ссылки /api/analytics/recommendations можно протестировать полученную модель. Здесь необходимо ввести следующие параметры:
* itemList – SKU, уже лежащие в корзине
* maxItems – максимальное количество возвращаемых рекомендаций
* recommenderID – ID модели, построенной на предыдущем шаге
* userID – номер участника программы лояльности
Указывать можно либо оба параметра itemList и userID, либо только один из них. При указании только одного параметра система выдаст предупреждение, но позволит продолжить работу.
Проверим модель с SKU 5000267097428
в ответ получаем
Посмотрим, что это такое
Таким образом, получаем, что при покупке виски неплохо бы порекомендовать покупателю еще и сухого вина.
Рекомендательная модель может также быть запущена в пакетном режиме, сгенерировав таблицу рекомендаций для всех пользователей программы лояльности. Для этого нажимаем закладку POST на ссылке /api/analytics/recommendations/batch
Затем указываем таблицу, в которую надо поместить наши рекомендации
И запускаем расчет. Сервис создает таблицу и для каждого пользователя рассчитывает рекомендованный товар, который может быть приобретен с большей вероятностью.
Таки образом, Predictive service позволяет очень быстро настроить и использовать некоторые наиболее часто употребляемые математические методы для построения предиктивных моделей, годных к применению в реальном бизнесе. | https://habr.com/ru/post/327086/ | null | ru | null |
# Как писать кривые запросы с неоптимальным планом и заставить задуматься СУБД
 Всё просто. Тут можно найти «Основы разбора запросов для чайников» в случае PostgreSQL и замечательные невыдуманные примеры из продакшена о том, как не надо писать запросы на PostgreSQL и MySQL и что бывает, если их так всё-таки писать.
### Введение
Расскажу про несколько очевидных вещей, которые довольно хорошо описаны в манах и документации, которую читают, обычно, после вступления на десяток грабель, либо после отстрела определённого числа конечностей или после иного членовредительства.
Частей будет несколько, логически они слабо связаны друг с другом, но все они встретились в ходе решения различных потребностей бизнеса и так или иначе удовлетворяли его потребности.
### НЮансы работы WITH
Та самая штука WITH, которая очень похожа на синтаксический сахар без большой смысловой нагрузки и ассоциируется (у непосвящённых) с разбиением большой портянки на отдельные методы в духе Мартина и Фаулера. Здесь главная особенность заключается в том, что это нифига не аналог метода/функции, особенно когда дело доходит до оптимизации запроса.
Сразу прошу прощения у читателя, но далее в тексте будут только куски запросов, имеющих принципиальное значение, запросы целиком публиковаться не будут. Во-первых, чтобы не утомлять особенностями структуры данных и во-вторых, чтобы я нечаянно не запостил что-нибудь приватно-корпоративное. Если куски будут абсолютно не читаемы, пожалуйста, не бейте сильно, а предложите как их облагородить. Спасибо.
Как делать не надо.
**Исходный кусок sql из основного тела запроса**
```
LEFT JOIN specifications_history AS specification_history
ON specification_history.id = specification_detail.entity_history_id
AND specification_history.specification_id = ANY(specification_parts.ids)
LEFT JOIN specification_revision_details AS specification_section_detail
ON specification_section_detail.specification_revision_id = specification_revision.id
AND specification_section_detail.entity_type = 1002
LEFT JOIN specification_sections_history AS specification_section_history
ON specification_section_history.id = specification_section_detail.entity_history_id
LEFT JOIN specification_revision_details AS section_item_detail
ON section_item_detail.specification_revision_id = specification_revision.id
AND section_item_detail.entity_type = 1003
LEFT JOIN section_items_history AS section_item_history
ON section_item_history.id = section_item_detail.entity_history_id
```
**'Облагороженный' кусок запроса**
```
WITH revision_products AS (
SELECT DISTINCT specification_revision.id AS revision_id,
specification_history.specification_id AS specification_id,
section_item_history.product_id AS product_id
FROM specification_revisions AS specification_revision
INNER JOIN specification_revision_details AS specification_detail
ON specification_detail.specification_revision_id = specification_revision.id
AND specification_detail.entity_type = 1001
INNER JOIN specifications_history AS specification_histor
ON specification_history.id = specification_detail.entity_history_id
INNER JOIN specification_revision_details AS specification_section_detail
ON specification_section_detail.specification_revision_id = specification_revision.id
AND specification_section_detail.entity_type = 1002
INNER JOIN specification_sections_history AS specification_section_history
ON specification_section_history.id = specification_section_detail.entity_history_id
INNER JOIN specification_revision_details AS section_item_detail
ON section_item_detail.specification_revision_id = specification_revision.id
AND section_item_detail.entity_type = 1003
INNER JOIN section_items_history AS section_item_history
ON section_item_history.id = section_item_detail.entity_history_id
WHERE section_item_history.product_id IS NOT NULL
)
```
Тут произошло следующее: из основного тела запроса, в котором было немало LEFT JOIN их унесли в WITH и превратили в INNER JOIN. Куску выдали благозвучное название, дабы таким образом повысить читаемость основного тела, а все детали реализации утащили подальше. Практики чистого кода в лучшем виде. С читаемостью, действительно, стало получше. В основном теле запроса осталось 5 джоинов вместо 10. Вот только скорость выполнения запроса тут же упала с 75мс до 95сек. В Explain появились интересные вещи вида:
```
-> Unique (cost=796821.66..848031.33 rows=5120967 width=12) (actual time=80769.666..94946.622 rows=315260 loops=1)
-> Sort (cost=796821.66..809624.07 rows=5120967 width=12) (actual time=80769.663..90662.993 rows=37659600 loops=1)
Sort Key: specification_revision_1.id, specification_history.specification_id, section_item_history.product_id
Sort Method: external merge Disk: 809888kB
```
То есть кто-то взял 37 лямов строк и начал их бодро сортировать в 1 гиге памяти. Тут же возникли вопросы:
* «а откуда у нас 37кк строк, когда в наибольшей из таблиц их 1.5кк?»
* «мы не меняли алгоритм, мы только код читаемым сделали, почему всё повисло?»
* «он декларативный, мы сказали что хотим, а как не говорили, почему всё сломалось?»
Ответ: перенос джоинов из основного тела в WITH сделал ровно то, что описано в [документации](https://www.postgresql.org/docs/9.5/static/queries-with.html):
**WITH Queries (Common Table Expressions)**A useful property of WITH queries is that they are evaluated only once per execution of the parent query, even if they are referred to more than once by the parent query or sibling WITH queries. Thus, expensive calculations that are needed in multiple places can be placed within a WITH query to avoid redundant work. Another possible application is to prevent unwanted multiple evaluations of functions with side-effects. However, the other side of this coin is that the optimizer is less able to push restrictions from the parent query down into a WITH query than an ordinary subquery. The WITH query will generally be evaluated as written, without suppression of rows that the parent query might discard afterwards. (But, as mentioned above, evaluation might stop early if the reference(s) to the query demand only a limited number of rows.)
Если коротко и грубо: запросы из WITH выполняются один раз и, чаще всего, не оптимизируются, то есть место их использования не влияет на план выполнения.
То есть мы левелапнули кусок запроса до уровня самостоятельной части, забыв добавить к нему важные условий из WHERE, которые урезают выборку по самые помидоры. В результате переджойнили всю базу, а затем отдали этого монстрика в основное тело, где взяли из него десяток строк.
В конкретном вышеописанном случае в WHERE было условие вида «product\_id = 1234», которое и задавало основное ограничение по данным. Если бы это условие утащили в WITH, то всё продолжило бы работать примерно с той же скоростью. Однако, так можно сделать только в случае статического значения для правой части условия. Если айдишних получается, например, в ходе рекурсивного запроса, то в WITH такое условие не утащишь и идея с разделением запроса на куски будет безбожно тормозить.
Вывод:
* нужно читать документацию;
* не все практики разработки одинаково полезны в разных областях этой самой разработки.
### Визуализация explain
Думаю, все в курсе про [explain.depesz.com](https://explain.depesz.com). Там красиво показывают что не так с запросом.
По сути, это просто раскраска для дефолтного вывода команды explain, зато это очень наглядно и особенно помогает в начале, пока не знаешь на что смотреть… хотя чего врать, и не в начале помогает, просто красиво и удобно.
Здесь хочется сказать пару слов по каждой из колонок и пояснить как они влияют на результат выполнения. Таки да, это написано там же в [хелпе](https://explain.depesz.com/help), но редко кто читает хелп, пока не припрёт.
* # — просто порядковый номер операции в ходе выполнения запроса
* Exclusive — время на выполнения конкретной операции (в миллисекундах)
* Inclusive — время на выполнение всего конвейера команд (например, на картинке выше, для выполнения uniq нужно сделать, как минимум, сортировку)
* Rows X — на сколько промахнулся ~~Акелла~~ планировщик, когда ванговал количество строк, которые должна вернуть операция (таки да, это важно для последующего принятия решений о том, как же дальше выполнять запрос)
### Советы начинающим оптимизаторам
Если всё тормозит и не знаете с чего начать, то вот пара советов. Нужно взять раскрашенный explain (желательно вместе с analyze) из предыдущего пункта и посмотреть на него. Чаще всего, проблема (читай, 80%+ времени выполнения), сосредоточена в одной из операций, описанных в плане выполнения. То есть по Exclusive/Inclusive найти самое тёмное и стрёмное место. Опять же, в примере выше видно, что операция uniq длится 94 секунды из суммарных 95 секунд, за которые выполняется запрос. Там же видим, что в uniq почти всё время занимает sort, который идёт 90 сек. Здесь же видно проблему в виде количества строк, алгоритма сортировки и используемой памяти. Осталось всего ничего: понять «кто виноват и что делать». Здесь уже поможет только знание структуры данных целевой БД и требования к результатам запроса. Может будет достаточно переставить пару строк или добавить доп.условие, а может понадобится полностью переписать запрос, так как в исходном виде единственное что у него может хорошо получаться — это тормозить.
Так же стоит обратить внимание на большой «Rows X». Это говорит о промахе предсказанного и фактического результата выборки и, чаще всего, обусловлено недостаточным объёмом статистики о таблицах. Сие может приводить к неоптимальному плану выполнения запроса. Например: хотим выбрать одну строку из таблицы с 1 миллионом элементов; если планировщик решит, что результат выборки будет не 1 строка, а ~200 000, то он не будет искать по индексу, а пойдёт фулл сканом, так как это оптимальная стратегия для такого соотношения результирующих строк и размера таблицы. Выводы о скорости делайте сами.
### Стандартные грабли
Вот, что чаще всего встречалось на практике и что было причиной непотребного поведения запросов:
* непонимание структуры данных и джоин данных через неведомые обходные и окольные пути или, ещё лучше, джоин лишних данных; крайний такой случай был в MySQL; вот немного облегчённый пример, который передаёт суть проблемы:
```
SELECT ordered_products.*
FROM products,
products AS ordered_products
GROUP BY ordered_products.id
```
С одной стороны, просто указали лишнюю таблицу внутри FROM и никак ей не воспользовались. С другой стороны, мы получили неявное соединение двух таблиц через CROSS JOIN и  результирующих строк (актуально, как минимум, для версии MySQL 5.5). В моём случае в таблице products было 40к строк, но конца выполнения запроса я так и не дождался. На сколько я знаю, Oracle умеет делать [join elimination](https://habrahabr.ru/post/248817/), но, в любом случае, лучше не надеяться на фичи СУБД, а думать головой.
**Бонус: как это сделать в ActiveRecord и всё повесить**
```
Product.joins(", (#{Product.table_name}) AS ordered_products").
select('ordered_products.*').
group("ordered_products.#{Product.primary_key}")
```
* Любовь к OUTER JOIN. Они порождают, как минимум, геометрический рост строк в промежуточных результатах и может легко оказаться, что на некоторых входных данных запрос будет тормозить, а СУБД захлёбываться от объёма данных. Крайний пример был на запросе, упомянутом выше по тесту (который с WITH). Он отлично работал при строгом ограничении по product\_id. Этот же запрос хорошо работал с массивом из 5-15 айдишников и время выполнения запроса росло линейно, но далее, каждый следующий айдишник в массиве увеличивал время выполнение запроса в 2-3 раза. Проблема как раз была в множестве OUTER JOIN, которые мультипликативно увеличивали число обрабатываемых строк и с некоторого момента их количество становилось возмутительно большим, а план выполнения нельзя было показывать несовершеннолетним разработчикам.
* В продолжении предыдущего пункта: некоторые любят ставить FULL OUTER JOIN вместо LEFT/RIGHT, которых хватает в подавляющем большинстве случаев (проверенно на обитателях хабра, с которыми обсуждали запрос из предыдущей [статьи о собеседованиях](https://habrahabr.ru/post/314654/)). Проблема всё та же: генерация лишних данных и увеличение потребления ресурсов. Из личного: FULL OUTER JOIN недавно реально понадобился в продакшене впервые за 2 года… счастлив был, как ребёнок.
* Чудесная магия с функциями, например, из PostgreSQL, когда вместо пары джоинов в декларативном стиле пытаются сделать то же самое, но в императивном стиле через массивы и прочие структуры данных вкупе с функциями, их преобразующими. Примера, к сожалению, не найду, поэтому придётся поверить на слово. Помню лишь, что такие вещи периодически мелькают на [stackoverflow](http://stackoverflow.com/). Радует только, что они почти никогда не выбиваются в лидеры по лайкам.
### Конец
Всем спасибо. Если у вас есть свои замечательные примеры того, как делать не надо, то, пожалуйста, не молчите, «вредных советов» и «живых примеров» много не бывает. Да и статья — это, как и билет на экзамене, лишь повод поговорить. | https://habr.com/ru/post/320916/ | null | ru | null |
# Парсер OOXML (docx, xlsx, pptx) на Ruby: наши ошибки и находки
Мы выложили парсер OOXML форматов на Ruby в open-source. Он доступен на [GitHub'е](https://github.com/ONLYOFFICE/ooxml_parser) и [RubyGems.org](https://rubygems.org/gems/ooxml_parser), бесплатен и распространяется под лицензией AGPLv3. Всё как у модненьких Ruby-разработчиков.
Почему мы не использовали сторонние парсеры
===========================================
Не секрет, что наш парсер не первый парсер OOXML на Ruby. Мы могли бы взять продукт сторонних разработчиков, но решили не брать. У тех решений, которые нам удалось найти, есть ряд проблем:
а) они давно заброшены разработчиками;
б) они поддерживают только базовую функциональность;
в) они, как правило, распространяются как три отдельные библиотеки. Зачастую парсер docx и парсер xlsx делали разные люди, поэтому их интерфейсы могут кардинально отличаться. Согласитесь, это неудобно.
Чем отличается наш парсер
=========================
Мы писали его под себя и свои задачи (тестирование редакторов документов), но потом поняли, что, возможно, он может помочь и другим Ruby-разработчикам, потому что он:
а) активно развивается;
б) поддерживает всю функциональность наших редакторов, а это очень много. Вот [тут](https://habrahabr.ru/company/teamlab/blog/275471/) можно почитать;
в) называется OOXML парсер, так как работает и с docx, и xlsx, и pptx.
Отдельно остановимся на пункте б) — функциональность. Реализованы ли у нас все возможные фичи стандарта? Не-а. Стандарт [ECMA-376](http://www.ecma-international.org/publications/standards/Ecma-376.htm) это четыре тома и в сумме over 9000 страниц (нет). На самом деле, около 7 тысяч. Можно выдыхать.
В общем, сами понимаете: реализовано у нас не всё. Но есть всё самое необходимое и более того: распознаются параграфы, таблицы, автофигуры. Есть поддержка таких комплексных вещей как
* Цветовые схемы;
* Стили параграфов и таблиц;
* Встроенные диаграммы;
* Свойства автофигур;
* Колонки;
* Списки.
Зачем нужен был парсер
======================
Спойлер — Зачем нам вообще нужны парсеры?
Он появился на свет в отделе тестирования.
С самого начала автоматизированного тестирования у нас был принят единый концепт функциональных тестов.
Возьмем простейший тест:
1. Создаем новый документ.
2. Печатаем текст и выставляем у него свойство Bold.
3. Проверяем, что Bold выставлен.
Редактор ONLYOFFICE написан на Canvas, то есть, текст в документе представляет собой картинку. Проверифицировать толщину шрифта по картинке чрезвычайно сложно. А ведь применить Bold можно к любому шрифту!
 
В некоторых шрифтах (таких как Arial Black) Bold может вообще визуально никак не проявиться. Согласитесь, что сравнивать картинки imagemagick-ом — не самый оптимальный вариант.
Поэтому шаг верификации теста был выделен в отдельный пункт, а именно:
4. Скачиваем полученный файл в формате docx и проверяем, что у текста выставлен параметр Bold.
Таких параметров сотни. При этом ни одно из существующих решений не поддерживало ничего, кроме простейшего выхватывания текста, таблиц и еще пары вещей. Так мы и решили создавать свою библиотеку.
Постойте, спросите вы, вы же разрабатываете редактор документов, который умеет открывать все эти форматы на редактирование! Почему бы не использовать уже готовое решение из редактора и верифицировать тесты через него?
***Почему нет?***
1. В серверной части редакторов парсер написан на C++, а весь процесс автоматизированного тестирования построен на Ruby. С ходу было не совсем понятно, как это всё завязать друг с другом.
2. Сейчас у нас есть версия для Linux (и она основная), но в момент начала интеграции всей инфраструктуры для тестирования серверная часть документов поддерживала в качестве платформы только Windows. При этом в тестировании мы всегда использовали Ubuntu и производные. Чтобы склеить вот это всё, пришлось бы придумывать хитрые схемы.
3. А можно ли вообще серверный парсер считать эталоном? Верифицировать результаты работы продукта, используя сам продукт? Сомнительная идея.
Как работает парсер
===================
Если вы когда-либо пытались заархивировать docx-файл, то могли заметить, что степень сжатия очень мала. Почему так? Всё просто: ooxml-файлы — это всего лишь заархивированный набор xml-файлов. Их структура достаточно тривиальна.
Для примера создадим простой файл с приветствием в нашем редакторе ONLYOFFICE и скачаем его в docx. Затем разархивируем как zip файл и посмотрим, где же хранится интересное нам мясцо этого документа.
Мы увидим такую структуру:
```
#tree
├── [Content_Types].xml
├── docProps
│ ├── app.xml
│ └── core.xml
├── _rels
└── word
├── document.xml
├── fontTable.xml
├── _rels
│ └── document.xml.rels
├── settings.xml
├── styles.xml
├── theme
│ ├── _rels
│ │ └── theme1.xml.rels
│ └── theme1.xml
└── webSettings.xml
```
Начинаем копаться во внутренностях. По порядку.
*[Content\_Types].xml* — список mime-типов в документе. Холодно.
*app.xml* — метадата документа, приложение-создатель, статистика. Уже тепло, информация интересная, пригодится.
*core.xml* — метадата о последних модификациях.
*document.xml* — Ohh, that's a bingo. В этом файле и прячется контент нашего документа, рассмотрим его позднее.
*fontTable.xml* — таблица шрифтов в документе. Пригодится.
*document.xml.rels* — список всех файлов в архиве, этот список будет нам очень полезен для комплексных документов, с картинками и графиками.
*settings.xml* — из названия понятно, что там хранятся разнообразные параметры документа, такие как дефолтный зум, разделители чисел и прочее.
*styles.xml, theme1.xml и theme1.xml.rels* — очень громоздкие, очень детальные файлы, содержащие параметры стилей и тем документа. Возможность понимать эти документы — одна из ключевых особенностей продукта.
*webSettings.xml* — настройка касаемо web-версии документа. Не самая популярная функциональность для docx, опустим.
Итак, оказалось, что в простом документе интересен именно *word/document.xml*.
Простая xml. Благо с парсингом xml на Ruby проблем никаких нет. Берем Nokogiri и получаем DOM-дерево. Ну а дальше уже дело техники, почитаем стандарт (если не лень, документ же очень большой), или же просто старым добрым реверс-инжинирингом поймем, где в документе запрятан нужный параметр.
Как писался парсер
==================
В начале работы мы допустили ряд ошибок, которые по мере возрастания осознанности сами поправили. Две самые значимые ошибки описаны ниже — благо они в прошлом, и нам уже не стыдно. Надеемся, наш опыт поможет другим не пробежаться по тем же граблям.
***Огромные файлы***
Итак, у нас есть задача обработать три разных формата документов. Как же мы организуем код для этого? Конечно, три файла по 4000 строчек кода (на самом деле, даже 4 файла по 4000 строчек кода, потому что были еще и общие методы для форматов).
Решение проблемы заняло больше всего времени. Пришлось приводить всё это хозяйство в аккуратный вид (хотя до сих пор иногда всплывает файлик на 300 строчек), выделять методы в аккуратные классы и т.д. Сейчас у нас более 200 файлов исходников вместо четырех. Править баги стало легче.
***Отсутствие тестов***
Логика была такая: мы пишем парсер, чтобы тестировать наш основной продукт ONLYOFFICE Document Server, зачем нам тестировать сам парсер?
НЕТ. НЕТ. НЕТ!!!
Сцена из жизни:
— Надо бы поправить вот тут кое-что, у нас цвет фигуры неправильно определяется.
— Да, сейчас, опечатка там была, одну букву исправил, закоммитил.
Итог:
Всё упало. Парсер, редактор, курс доллара, шалтай-болтай, самооценка.
А всего лишь надо было создать папочку `spec`, положить туда пару сотен файлов, проверить кучу параметров, чтобы спать ночами спокойно и знать, что тот коммит, который ты сделал перед уходом с работы, не сломает верификацию той опции, которая выставляется в меню 3-его уровня вложенности. Как мы это называем «в третьей звезде налево».
Но мы не только косячили. Здравые мысли у нас тоже были. Самые классные из них:
***Использование [RuboCop](https://github.com/bbatsov/rubocop)***
RuboCop — это статический анализатор кода для Ruby, и мы его любим. Очень-очень. И всегда прислушиваемся к его мнению. Он помогает держать код в тонусе, не допускать глупых ошибок и строго следить, чтобы код не стал грязнее и хуже после очередного коммита (благодаря интеграции через [overcommit](https://github.com/brigade/overcommit)).
Его работа выглядит так: после тяжелого рабочего дня ты забыл, что переменные в Ruby принято называть с маленькой буквы и пытаешься закоммитить код вида
> — path\_to\_zip\_file = copy\_file\_and\_rename\_to\_zip(path\_to\_file)
>
> + ZIP\_file = copy\_file\_and\_rename\_to\_zip(path\_to\_file)
В этом случае произойдет ошибка:
> Analyze with RuboCop........................................[RuboCop] FAILED
>
> Errors on modified lines:
>
> ooxml\_parser/lib/ooxml\_parser/common\_parser/parser.rb:8:7: E: dynamic constant assignment
Закоммитить этот код без дополнительных манипуляций (`SKIP=RuboCop git commit -av`) не получится. Это отличная защита от дурака.
***Ориентация на open-source проекты***
Практически с самого начала разработки парсера мы ориентировались на другие open-source проекты. Хотя мы не были уверены, что наш код будет выложен в open source, но всегда были к этому готовы. Когда поступила команда «Выкладывайте», мы просто нажали кнопочку «make public» в GitHub'e и всё, никаких дополнительных причесываний и прочего.
В этом большая заслуга того же RuboCop: мы часто подглядывали в их код, думая как лучше организовать ту или иную тему, например Changelog, структуру гема. Кроме того, вся разработка, коммиты, история изменений и прочего изначально велись на английском.
***Использование базы документов***
При тестировании парсеров нам пригодились наши предыдущие наработки — крупная база со всякими странными, огромными и непонятными файлами трех форматов.
Когда-то давным-давно, на ранней стадии разработки редакторов ONLYOFFICE мы собрали эти файлы на просторах интернета — на них проверялся рендеринг сложных и нестандартных документов. Спустя несколько лет по этой же базе документов прогнался парсер. В результате нашлось достаточно много проблем разного уровня сложности и, потратив пару недель на их устранение, мы получили отличный продукт.
Итого
=====
Итак, все доступно, берете, добавляете в своё Ruby-приложение, парсите docx, строите по ним статистику, анализируете, как работает ваша бухгалтерия по xlsx файлам, узнаете, какой мемасик спрятал ваш PM на презентации продукта в четвертом слайде. И все это бесплатно.
А еще можете находить проблемные файлы и создавать issue на GitHub'e, будем это разруливать. Можете даже править сами и слать Pull Requests. | https://habr.com/ru/post/302826/ | null | ru | null |
# .NET: Инструменты для работы с многопоточностью и асинхронностью. Часть 1
*Публикую на Хабр оригинал статьи, перевод которой размещен в блоге [Codingsight](https://codingsight.com/net-tools-for-working-with-multi-threading-and-asynchrony-part-1/).*
*Вторая часть доступна [здесь](https://habr.com/post/459514/)*
Необходимость делать что-то асинхронно, не дожидаясь результат здесь и сейчас, или разделять большую работу между несколькими выполняющими ее единицами была и до появления компьютеров. С их появлением такая необходимость стала очень ощутимой. Сейчас, в 2019, набирая эту статью на ноутбуке с 8 ядерным процессором Intel Core, на котором параллельно этому работает не одна сотня процессов, а потоков и того больше. Рядом, лежит уже немного потрепанный, купленный пару лет назад телефон, у него на борту 8 ядерный процессор. На тематических ресурсах полно статей и видео, где их авторы восхищаются флагманскими смартфонами этого года куда ставят 16ти-ядерные процессоры. MS Azure предоставляет менее чем за 20$/час виртуальную машину со 128 ядерным процессором и 2 TB RAM. К сожалению невозможно извлечь максимум и обуздать эту мощь не умея управлять взаимодействием потоков.
### Терминология
**Процесс (Process)** — объект ОС, изолированное адресное пространство, содержит потоки.
**Поток (Thread)** — объект ОС, наименьшая единица выполнения, часть процесса, потоки делят память и другие ресурсы между собой в рамках процесса.
**Многозадачность** — свойство ОС, возможность выполнять несколько процессов одновременно
**Многоядерность** — свойство процессора, возможность использовать несколько ядер для обработки данных
**Многопроцессорность** — свойство компьютера, возможность одновременно работать с несколькими процессорами физически
**Многопоточность** — свойство процесса, возможность распределять обработку данных между несколькими потоками.
**Параллельность** — выполнение нескольких действий физически одновременно в единицу времени
**Асинхронность** — выполнение операции без ожидания окончания завершения этой обработки, результат же выполнения может быть обработан позднее.
### Метафора
Не все определения хороши и некоторые нуждаются в дополнительном объяснении, потому к формально введенной терминологии добавлю метафору о приготовлении завтрака. Приготовление завтрака в этой метафоре — process.
Готовя завтрак с утра я (**CPU**) прихожу на кухню (**Компьютер**). У меня 2 руки (**Cores**). На кухне есть ряд устройств (**IO**): печь, чайник, тостер, холодильник. Я включаю газ, ставлю на него сковородку и наливаю туда масло, не дожидаясь пока она разогреется (**асинхронно, Non-Blocking-IO-Wait**), я достаю из холодильника яйца и разбиваю их в тарелку, после чего взбиваю одной рукой (**Thread#1**), а второй (**Thread#2**) придерживаю тарелку (Shared Resource). Сейчас бы еще включить чайник, но рук не хватает (**Thread Starvation**) За это время разогревается сковородка (Обработка результата) куда я выливаю то что взбил. Я дотягиваюсь до чайника и включаю его и тупо смотрю как вода в нем закипает (**Blocking-IO-Wait**), хотя мог бы за это время вымыть тарелку, где взбивал омлет.
Я готовил омлет используя всего 2 руки, да больше у меня и нет, но при этом в момент взбивания омлета происходило сразу 3 операции: взбивание омлета, придерживание тарелки, разогревание сковородки.CPU — является самой быстрой частью компьютера, IO это то, что чаще всего тормозит, потому часто эффективным решением является занять чем-то CPU пока идет получение данных от IO.
Продолжая метафору:
* Если бы в процессе готовки омлета, я бы еще и пытался переодеться это был бы пример многозадачности. Важный нюанс: у компьютеров с этим куда лучше чем у людей.
* Кухня с несколькими поварами, например в ресторане — многоядерный компьютер.
* Множество ресторанов на фудкорте в торговом центре — датацентр
### Инструменты .NET
В работе с потоками, как и во многом другом, .NET хорош. С каждой новой версией он представляет все больше новых инструментов для работы с ними, новые слои абстракции над потоками ОС. В работе с построением абстракций разработчики фреймворка используют подход оставляющий возможность при использовании высокоуровневой абстракции, спустится на один или несколько уровней ниже. Чаще всего в этом нет необходимости, более того это открывает возможность для выстрела себе в ногу из дробовика, но иногда, в редких случаях, это может оказаться единственным способом решить проблему, не решающую на текущем уровне абстракции.
Под инструментами я имею ввиду как программные интерфейсы (API) предоставляемые фреймворком и сторонними пакетами, так и целый программные решения упрощающий поиск каких-либо проблем связанных с многопоточным кодом.
#### Запуск потока
Класс Thread, самый базовый в .NET для работы с потоками. В конструктор принимает один из двух делегатов:
* ThreadStart — Без параметров
* ParametrizedThreadStart — с одним параметром типа object.
Делегат будет выполнен во вновь созданном потоке после вызова метода Start, если в конструктор был передан делегат типа ParametrizedThreadStart, то в метод Start необходимо передать объект. Этот механизм нужен для передачи любой локальной информации в поток. Стоит отметить что создание потока это дорогостоящая операция, а сам поток это тяжелый объект, как минимум потому, что происходит выделение 1МБ памяти на стек, и требует взаимодействия с API ОС.
```
new Thread(...).Start(...);
```
Класс ThreadPool представляет концепцию пула. В .NET пул потоков является произведением инженерного искусства и разработчики из Microsoft вложили множество усилий, чтобы он работал оптимально в самых разных сценариях.
**Общая концепция:**
*С момента старта приложение в фоне создает несколько потоков про запас и предоставляет возможность брать их в пользование. Если потоки используются часто и в большом количестве, то пул расширяется, чтобы удовлетворить потребность вызывающего кода. Когда в пуле в нужный момент времени не оказывается свободных потоков он или дождется возврата одного из потоков, либо создаст новый. Из этого следует, что пул потоков отлично подходит для неких коротких действий и плохо подходит, для операций работающих как службы на протяжении всей работы приложений.
Для использования потока из пула, есть метод QueueUserWorkItem, который принимает делегат типа WaitCallback, что по сигнатуре совпадает с ParametrizedThreadStart, а передаваемый в него параметр выполняет туже функцию.*
```
ThreadPool.QueueUserWorkItem(...);
```
Менее известный метод пула потоков RegisterWaitForSingleObject служит для организации неблокирующих IO операций. Делегат переданный в этот метод будет вызван тогда, когда WaitHandle переданный в метод будет “отпущен”(Released).
```
ThreadPool.RegisterWaitForSingleObject(...)
```
В .NET есть потоковый таймер и отличается он от таймеров WinForms/WPF тем, что его обработчик будет вызван в потоке взятом из пула.
```
System.Threading.Timer
```
Так же есть довольно экзотический способ отправить делегат на выполнение в поток из пула — метод BeginInvoke.
```
DelegateInstance.BeginInvoke
```
Хочу еще вскользь остановится на функции к вызову которой сводится многие из вышеуказанных методов — CreateThread из Kernel32.dll Win32 API. Существует способ, благодаря механизму extern методов вызвать эту функцию. Я видел такой вызов лишь однажды в жутчайшем примере legacy кода, а мотивация автора сделавшего именно так все еще остается для меня загадкой.
```
Kernel32.dll CreateThread
```
#### Просмотр и отладка потоков
Созданные вами лично, всеми третисторонними компонентами и пулом .NET потоки можно просмотреть в окне Threads Visual Studio. Это окно отобразит информацию о потоках лишь, когда приложение будет находится под отладкой и в режиме останова (Break mode). Здесь можно удобно просмотреть стек имена и приоритеты каждого потока, переключить отладку на конкретный поток. Свойством Priority класса Thread можно задать приоритет потока, который OC и CLR будут воспринимать как рекомендацию при разделении процессорного времени между потоками.
#### Task Parallel Library
Task Parallel Library (TPL) появился в .NET 4.0. Сейчас это стандарт и основной инструмент для работы с асинхронностью. Любой код использующий более старые подход считается legacy. Основной единицей TPL является класс Task из пространства имен System.Threading.Tasks. Task представляет собой абстракцию над потоком. С новой версией языка C# мы получили изящный способ работы с Task`ами — операторы async/await. Эти концепции позволили писать асинхронный код так, как если бы он был простым и синхронным, это дало возможность даже людям слабо понимающим внутреннюю кухню потоков писать приложения их использующие, приложения не зависающие при выполнении долгих операций. Использование async/await тема для одной или даже нескольких статей, но я попробую в нескольких предложениях уложить суть:
* async это модификатор метода возвращающего Task или void
* а await оператор неблокирующего ожидания Task`а.
Еще раз: оператор await, в общем случае (есть исключения), отпустит текущий поток выполнения дальше, а когда Task закончит свое выполнение, а поток (на самом деле правильнее сказать контекст, но об этом позднее) будет свободен продолжит выполнении метода дальше. Внутри .NET этот механизм реализован так же как и yield return, когда написанный метод превращается в целый класс, который является машиной состояний и может быть выполнен отдельными кусками в зависимости от этих состояний. Кому интересно может написать любой несложный код с использованием asynс/await, скомпилировать и просмотреть сборку с помощью JetBrains dotPeek с включенным Compiler Generated Code.
Рассмотрим варианты запуска и использования Task’а. На примере кода ниже, мы создаем новый таск, который не делает ничего полезного (*Thread.Sleep(10000)*), но в реальной жизни это должна быть некая сложная задействующая CPU работа.
```
using TCO = System.Threading.Tasks.TaskCreationOptions;
public static async void VoidAsyncMethod() {
var cancellationSource = new CancellationTokenSource();
await Task.Factory.StartNew(
// Code of action will be executed on other context
() => Thread.Sleep(10000),
cancellationSource.Token,
TCO.LongRunning | TCO.AttachedToParent | TCO.PreferFairness,
scheduler
);
// Code after await will be executed on captured context
}
```
Task создается с рядом опций:
* LongRunning — подсказка о том, что задача не будет выполнена быстро, а значит, возможно, стоит подумать над тем чтобы не брать поток из пула, а создать отдельный под эту Task’у чтобы не навредить остальным.
* AttachedToParent — Task’и могут выстраиваться в иерархии. Если была использована эта опция, то Task может находится в состоянии, когда сам он выполнился и дожидается выполнения дочерних.
* PreferFairness — означает, что хорошо бы выполнять Task’и отправленные на выполнение раньше перед теми, что были отправлены позже. Но это всего лишь рекомендация и результат не гарантирован.
Вторым параметром в метод передан CancellationToken. Для корректной обработки отмены операции после ее запуска выполняемый код должен быть наполнен проверками состояния CancellationToken. Если проверок нет, то метод Cancel вызванный на объекте CancellationTokenSource сможет остановить выполнение Task’а лишь до его запуска.
Последним параметром передан объект scheduler типа TaskScheduler. Этот класс и его наследники предназначены для управления стратегиями распределения Task’ов по потокам, по умолчанию Task будет выполнен на случайном потоке из пула.
К созданному Task’у применен оператор await, а значит код написанный после него, если такой есть будет выполнен в том же контексте (часто это означает что на том же потоке), что и код до await.
Метод помечен как async void, это значит, что в нем допустимо использование оператора await, но вызывающий код не сможет дождаться выполнения. Если такая возможность необходима, то метод должен возвращать Task. Методы помеченные async void встречаются довольно часто: как правило это обработчики событий или другие методы, работающие по принципу выполнить и забыть (fire and forget). Если необходимо не только дать возможность дождаться окончания выполнения, но и вернуть результат, то необходимо использовать Task.
На Task’е что вернул метод StartNew, впрочем как и на любом другом, можно вызвать метод ConfigureAwait с параметром false, тогда выполнение после await продолжится не на захваченном контексте, а на произвольном. Это нужно делать всегда, когда для кода после await не принципиален контекст выполнения. Также это является рекомендацией от MS при написании кода, что будет поставляться упакованном в библиотеку виде.
Давайте еще немного остановимся на том, как можно дождаться окончания выполнения Task’и. Ниже пример кода, с комментариями, когда ожидание сделано условно хорошо и когда условно плохо.
```
public static async void AnotherMethod() {
int result = await AsyncMethod(); // good
result = AsyncMethod().Result; // bad
AsyncMethod().Wait(); // bad
IEnumerable tasks = new Task[] {
AsyncMethod(), OtherAsyncMethod()
};
await Task.WhenAll(tasks); // good
await Task.WhenAny(tasks); // good
Task.WaitAll(tasks.ToArray()); // bad
}
```
В первом примере мы дожидаемся выполнения Task’и не блокируя вызывающий поток, к обработке результата вернемся лишь когда он уже будет, до тех пор вызывающий поток предоставлен себе.
Во втором варианте мы блокируем вызывающий поток до тех пор пока не будет подсчитан результат метода. Это плохо не только потому, что мы заняли поток, столь ценный ресурс программы, простым безделием, но еще и потому, что если в коде метода что мы вызываем есть await, а контекст синхронизации предполагает возвращение в вызывающий поток после await, то мы получим deadlock: вызывающий поток ждет пока будет вычислен результат асинхронного метода, асинхронный метод тщетно пытается продолжить свое выполнение в вызывающем потоке.
Еще одним недостатком такого подхода является усложненная обработка ошибок. Дело в том, что ошибки в асинхронном коде при использовании async/await обрабатывать очень легко — они ведут себя так же как если бы код был синхронным. В то время, как если мы применяем ~~экзорцизм~~ синхронное ожидание к Task’e оригинальное исключение оборачивается в AggregateException, т.о. Для обработки исключения придется исследовать тип InnerException и самому писать цепочку if внутри одного catch блока или использовать конструкцию catch when, вместо более привычной в C# мире цепочки catch блоков.
Третий и последний примеры так же отмечены плохими по той же причине и содержат все те же проблемы.
Методы WhenAny и WhenAll крайне удобны в ожидании группы Task’ов, они оборачивают группу Task’ов в один, который сработает либо по первому срабатыванию Task’а из группы, либо когда свое выполнение закончат все.
#### Остановка потоков
По разным причинам может появится необходимость остановить поток после его старта. Для этого существует ряд способов. У класса Thread есть два метода с подходящими названиями — это **Abort** и **Interrupt**. Первый крайне не рекомендуется к использованию, т.к. после его вызова в любой случайный момент, в процессе обработки любой инструкции, будет выброшено исключение **ThreadAbortedException**. Вы ведь не ожидаете что такое исключение вылетит при инкременте какой-либо целочисленной переменной, верно? А при использовании этого метода это вполне реальная ситуация. В случае необходимости запретить CLR генерировать такое исключение в определенном участке кода можно обернуть его в вызовы **Thread.BeginCriticalRegion**, **Thread.EndCriticalRegion**. Такими вызовами оборачивается любой код написанный в finally блоке. По этой причине в недрах кода фреймворка можно найти блоки с пустым try, но не пустым finally. Microsoft настолько не рекомендует использовать этот метод, что не включили его в .net core.
Метод Interrupt работает более предсказуемо. Он может прервать поток исключением **ThreadInterruptedException** только в те моменты, когда поток находится в состоянии ожидания. В такое состояние он переходит подвисая в ожидании WaitHandle, lock или после вызова Thread.Sleep.
Оба описанных выше варианта, плохи своей непредсказуемостью. Выходом является использование структуры **CancellationToken** и класса **CancellationTokenSource**. Суть в следующем: создается экземпляр класса CancellationTokenSource и только тот кто им владеет, может остановить операцию вызвав метод **Cancel**. В саму же операцию передается только лишь CancellationToken. Владельцы CancellationToken не могут сами отменить операцию, а могут лишь проверить не была ли операция отменена. Для этого есть булево свойство **IsCancellationRequested** и метод **ThrowIfCancelRequested**. Последний сгенерирует исключение **TaskCancelledException** если на пародившем CancellationToken экземпляре CancellationTokenSource был вызван метод Cancel. И именно этот метод я рекомендую использовать. Это лучше предыдущих вариантов получением полного контроля над тем в какие моменты исключение операция может быть прервана.
Самым жестоким вариантом остановки потока, является вызов функции Win32 API TerminateThread. Поведение CLR после вызова этой функции может быть непредсказуемым. На MSDN же про эту функцию написано следующее: *“TerminateThread is a dangerous function that should only be used in the most extreme cases. “*
#### Преобразование legacy-API в Task Based с помощью метода FromAsync
Если вам посчастливилось работать на проекте, что был начат уже после того как Task’и были введены и перестали вызывать тихий ужас большинства разработчиков, то вам не придется иметь дело с большим количеством старых API, как третисторонних, так и вымученых вашей командой в прошлом. К счастью, команда разработки .NET Framework позаботилась о нас, хотя возможно целью была забота о себе. Как бы то ни было в .NET есть ряд инструментов для безболезненного преобразования кода написанного в старых подходах асинхронного программирования в новую. Один из них это метод FromAsync у TaskFactory. На примере кода ниже, я оборачиваю старые асинхронные методы класса WebRequest в Task с помощью этого метода.
```
object state = null;
WebRequest wr = WebRequest.CreateHttp("http://github.com");
await Task.Factory.FromAsync(
wr.BeginGetResponse,
we.EndGetResponse
);
```
*Это лишь пример и делать такое со встроенными типами вам вряд ли придется, но любой старый проект просто кишит методами BeginDoSomething возвращающими IAsyncResult и методами EndDoSomething его принимающими.*
#### Преобразование legacy-API в Task Based с помощью класса TaskCompletionSource
Еще один важный для рассмотрения инструмент, это класс **TaskCompletionSource**. По функциям, назначению и принципу работы он чем-то может напомнить метод RegisterWaitForSingleObject класса ThreadPool о котором я писал выше. С помощью этого класса можно легко и удобно оборачивать старые асинхронные API в Task’и.
*Вы скажете, что я уже говорил о методе FromAsync класса TaskFactory предназначенном для этих целей. Здесь придется вспомнить всю историю развития асинхронных моделей в .net что предлагал microsoft за последние 15 лет: до Task-Based Asynchronous Pattern (TAP) существовали Asynchronous Programming Pattern (APP), который был о методах **Begin**DoSomething возвращающем **IAsyncResult** и методах **End**DoSomething его принимающем и для legacy этих годов как раз отлично подходит метод FromAsync, но со временем, на смену ему пришел Event Based Asynchronous Pattern (**EAP**), который предполагал, что по завершению выполнения асинхронной операции будет вызвано событие.*
TaskCompletionSource как раз отлично подходит для обертки в Task’и legacy-API построенных вокруг событийной модели. Суть его работы в следующем: у объекта этого класса есть публичное свойство типа Task состоянием которого можно управлять через методы SetResult, SetException и пр. Класса TaskCompletionSource. В местах же где был применен оператор await к этому Task’у он будет выполнен или обрушен с исключением в зависимости от примененного к TaskCompletionSource метода. Если все еще не понятно, то давайте посмотрим на этот пример кода, где некое старое API времен EAP заворачивается в Task при помощи TaskCompletionSource: при срабатывании события Task будет переведен в состояние Completed, а метод применивший к этому Task’у оператор await возобновит свое выполнение получив объект **result**.
```
public static Task DoAsync(this SomeApiInstance someApiObj) {
var completionSource = new TaskCompletionSource();
someApiObj.Done +=
result => completionSource.SetResult(result);
someApiObj.Do();
result completionSource.Task;
}
```
#### TaskCompletionSource Tips & Tricks
Обертка старых API это не все что можно провернуть с помощью TaskCompletionSource. Использование этого класса открывает интересную возможность проектирования различных API, на Task’ах, что не занимают потоки. А поток, как мы помним ресурс дорогой и количество их ограничено (в основном объемом RAM). Этого ограничения легко достичь разрабатывая, например, нагруженное web-приложение со сложной бизнес логикой. Рассмотрим те возможности о которых я говорю на реализации такого трюка как Long-Polling.
*Если коротко суть трюка вот в чем: вам нужно получать от API информацию о некоторых событиях происходящих на его стороне, при этом API по каким-то причинам не может сообщить о событии, а может лишь вернуть состояние. Пример таких — все API построенные поверх HTTP до времен WebSocket или при невозможности по какой-то причине использовать эту технологию. Клиент может спросить у HTTP сервера. HTTP сервер не может сам спровоцировать общение с клиентом. Простым решением является опрос сервера по таймеру, но это создает дополнительную нагрузку на сервер и дополнительную задержку в среднем TimerInterval / 2. Для обхода этого был изобретен трюк получивший название Long Polling, которые предполагает задержку ответа от сервера до тех пор пока не истечет Timeout или не произойдет событие. Если событие произошло, то оно обрабатывается, если нет, то запрос посылается заново.*
```
while(!eventOccures && !timeoutExceeded) {
CheckTimout();
CheckEvent();
Thread.Sleep(1);
}
```
Но такое решение покажет себя ужасно, как только число клиентом ожидающих событие вырастет, т.к. Каждый такой клиент в ожидании события занимает целый поток. Да и получаем дополнительную задержку в 1мс на срабатывании события, чаще всего это не существенно, но зачем делать ПО хуже чем оно может быть? Если же убрать Thread.Sleep(1), то зазря загрузим одно ядро процессора на 100% в холостую вращаясь в бесполезном цикле. С помощью TaskCompletionSource можно легко переделать этот код и решить все обозначенные выше проблемы:
```
class LongPollingApi {
private Dictionary> tasks;
public async Task AcceptMessageAsync(int userId, int duration) {
var cs = new TaskCompletionSource();
tasks[userId] = cs;
await Task.WhenAny(Task.Delay(duration), cs.Task);
return cs.Task.IsCompleted ? cs.Task.Result : null;
}
public void SendMessage(int userId, Msg m) {
if (tasks.TryGetValue(userId, out var completionSource))
completionSource.SetResult(m);
}
}
```
*Этот код не является production-ready, а лишь демонстрационным. Для использования в реальных случаях нужно еще, как-минимум, обработать ситуацию когда сообщение пришло в момент, когда его никто не ожидает: в таком случае метод AsseptMessageAsync должен вернуть уже завершенный Task. Если же этот случай и является наиболее частым, то можно подумать и об использовании ValueTask.*
При получении запроса на сообщение мы создаем и помещаем в словарь TaskCompletionSource, а далее ждем что произойдет первее: истечет заданный интервал времени или будет получено сообщение.
#### ValueTask: зачем и как
Операторы async/await как и оператор yield return генерирует из метода машину состояний, а это создание нового объекта, что почти всегда не важно, но в редких случаях может создать проблему. Этим случаем может быть метод вызываемый действительно часто, речь о десятках и сотнях тысяч вызовов в секунду. Если такой метод написан так, что в большинстве случаев он возвращает результат обходя все await методы, то .NET предоставляет инструмент что бы это оптимизировать — структура ValueTask. Чтобы стало понятно рассмотрим пример его использования: есть кеш в который мы ходим очень часто. Какие-то значения в нем есть и тогда мы их просто возвращаем, если нет, то идем в какой-нибудь медленный IO за ними. Последнее хочется делать асинхронно, а значит весь метод получается асинхронным. Таким образом очевидный вариант написания метода — следующий:
```
public async Task GetById(int id) {
if (cache.TryGetValue(id, out string val))
return val;
return await RequestById(id);
}
```
Из-за желания немного оптимизировать, и легкой боязни по-поводу того что сгенерирует Roslyn компилируя этот код, можно этот пример переписать следующим образом:
```
public Task GetById(int id) {
if (cache.TryGetValue(id, out string val))
return Task.FromResult(val);
return RequestById(id);
}
```
Действительно же оптимальным решением в этом случае будет оптимизировать hot-path, а именно получение значения из словаря вообще без лишних аллокаций и нагрузки на GC, в то время когда в тех редких случаях, когда нам все таки нужно идти в IO за данными все останется плюс/минус по старому:
```
public ValueTask GetById(int id) {
if (cache.TryGetValue(id, out string val))
return new ValueTask(val);
return new ValueTask(RequestById(id));
}
```
Давайте подробнее разберем этот фрагмент кода: при наличиии значения в кеше мы создаем структуру, в противном случае реальный же таск будет завернут в значимый. Вызывающему коду все равно по какому пути выполнялся этот код: ValueTask с точки зрения синтаксиса C# будет вести себя так же как и обычный Task в этом случае.
#### TaskScheduler’ы: управление стратегиями запуска Task’ов
Следующее API, что хотелось бы рассмотреть это класс **TaskScheduler** и его производные. Я уже упоминал выше, что в TPL есть возможность управлять стратегиями распределения Task’ов по потокам. Такие стратегии определяются в наследниках класса TaskScheduler. Практически любая стратегия, что может понадобится будет найдена в библиотеке **ParallelExtensionsExtras**, разработанной microsoft, но не являющейся частью .NET, а поставляемую в виде Nuget пакета. Коротко рассмотрим некоторые из них:
* **CurrentThreadTaskScheduler** — выполняет Task’и на текущем потоке
* **LimitedConcurrencyLevelTaskScheduler** — ограничивает число выполняемых одновременно Task’ов параметром N, что принимает в конструкторе
* **OrderedTaskScheduler** — определяется как LimitedConcurrencyLevelTaskScheduler(1), потому задачи будут выполняться последовательно.
* **WorkStealingTaskScheduler** — реализует [work-stealing](https://en.wikipedia.org/wiki/Work_stealing) подход к распределению задач. По сути является отдельным ThreadPool. Решает проблему того, что в .NET ThreadPool это статический класс, один на все приложения, а значит его перегрузка или неправильное использование в одной части программы может привести к побочным эффектам в другой. Более того понять причину таких деффектов крайне сложно. Т.о. может существовать необходимость использовать отдельные WorkStealingTaskScheduler’ы в тех частях программы, где использование ThreadPool может быть агрессивным и непредсказуемым.
* **QueuedTaskScheduler** — позволяет выполнять задачи по правилам очереди с приоритетами
* **ThreadPerTaskScheduler** — создает отдельный поток на каждый Task что на нем выполняется. Может быть полезно для задач выполняющихся непредсказуемо долго.
Есть хорошая подробная [статья](https://devblogs.microsoft.com/pfxteam/parallelextensionsextras-tour-7-additional-taskschedulers/) о TaskScheduler’ах в блоге microsoft.
Для удобной отладки всего связанного с Task’ами в Visual Studio есть окно Tasks. В этом окне можно увидеть текущее состояние задачи и перейти к выполняемой в данный момент строчке кода.
#### PLinq и класс Parallel
Кроме Task’ов и всего с ними сказанного в .NET есть еще два интересных инструмента это PLinq(Linq2Parallel) и класс Parallel. Первый обещает параллельное выполнение всех Linq операций на нескольких потоках. Число потоков можно сконфигурировать методом-расширением WithDegreeOfParallelism. К сожалению, чаще всего PLinq в режиме работаты по умолчанию не хватит информации о внутренностях вашего источника данных, чтобы обеспечить существенный выигрыш по скорости, с другой стороны цена попытки очень низкая: нужно всего лишь вызвать метод AsParallel перед цепочкой Linq методов и провести тесты производительности. Более того существует возможность передать в PLinq дополнительную информацию о природе вашего источника данных при помощи механизма Partitions. Подробнее можно почитать [здесь](https://devblogs.microsoft.com/pfxteam/partitioning-in-plinq/) и [здесь](https://docs.microsoft.com/en-us/dotnet/standard/parallel-programming/custom-partitioners-for-plinq-and-tpl).
Статический класс Parallel предоставляет методы для параллельного перебора коллекции Foreach, выполнения цикла For и выполнения нескольких делегатов в параллель Invoke. Выполнение текущего потока будет остановлено до окончания выполнения расчетов. Количество потоков можно сконфигурировать передав ParallelOptions последним аргументом. С помощью опций также можно указать TaskScheduler и CancellationToken.
#### Выводы
Когда я начинал писать эту статью по материалам своего доклада и информации что собрал за время работы после него, я не ожидал, что ее получится так много. Сейчас, когда текстовый редактор в котором я набираю эту статью укоризненно говорит мне о том, что пошла 15я страница, я подведу промежуточные итоги. Другие трюки, API, визуальные инструменты и подводные камни будут рассмотрены в следующей статье.
**Выводы:**
* Нужно знать инструменты работы с потоками, асинхронностью и параллелизмом, чтобы использовать ресурсы современных ПК.
* В .NET много различных инструментов для этих целей
* Не все они появились сразу, потому часто можно встретить legacy, впрочем есть способы для преобразования старых API без особых усилий.
* Работа с потоками в .NET представлена классами Thread и ThreadPool
* Методы Thread.Abort, Thread.Interrupt, функция Win32 API TerminateThread опасны и не рекомендуются к использованию. Вместо них лучше использовать механизм CancellationToken’ов
* Поток — ценный ресурс, их количество ограничено. Нужно избегать ситуаций, когда потоки заняты ожиданием событий. Для этого удобно использовать класс TaskCompletionSource
* Наиболее мощным и продвинутым инструментов .NET для работы с параллелизмом и асинхронностью являются Task’и.
* Операторы c# async/await реализуют концепцию неблокирующего ожидания
* Управлять распределением Task’ов по потокам можно с помощью производных TaskScheduler’у классов
* Структура ValueTask может быть полезна в оптимизации hot-paths и memory-traffic
* Окна Tasks и Threads Visual Studio предоставляют много полезной для отладки многопоточного или асинхронного кода информации
* PLinq крутой инструмент, но у него может не быть достаточно информации о вашем источнике данных, впрочем это можно исправить с помощью механизма partitioning
* Продолжение [следует](https://habr.com/ru/post/459514/)... | https://habr.com/ru/post/452094/ | null | ru | null |
# 3 место за 11 шагов в конкурсе по JavaScript от Hola
Наверняка у многих из вас перед глазами уже мелькали заголовки статей с [конкурсом от Hola](http://habrahabr.ru/company/hola/blog/270847/), который недавно подошел к своему логическому завершению. В [окончательных результатах](http://habrahabr.ru/company/hola/blog/275111/) мне посчастливилось быть на 3 месте. По этой причине я позволил себе поделиться описанием [своего решения](https://github.com/hola/challenge_mail_filter/blob/master/submissions/Evgeny%20Zeyler/filter.js), а также того, как я до него докатился.
1. Чем я хуже?
--------------
Самое первое решение, естественно, «в лоб». Формируем для каждого правила пару регулярных выражений, а затем запускаем цикл по сообщениям с вложенным циклом по правилам. Код до безобразия прост (и, как мы уже знаем, легко умещается в это пугающее число 666 байт), так что приводить его здесь не вижу смысла.
2. Да здравствуют динамические функции!
---------------------------------------
Следующим шагом я решил развернуть внутренний цикл. Для этого предварительно на основании правил динамически формируем функцию getActions(from, to) и вызываем её в цикле для каждого сообщения. Фильтр приобретает примерно следующий вид:
```
function filter(messages, rules) {
// Собираем функцию
var builder = [];
builder.push('var actions = [];');
for ( var i = 0; i < rules.length; i++ ) {
var rxFrom = createRegex(rules[i].from);
if ( rxFrom ) builder.push(escapeRegex(rxFrom), '.test(from) && ');
var rxTo = createRegex(rules[i].to);
if ( rxTo ) builder.push(escapeRegex(rxTo), '.test(to) && ');
builder.push('actions.push(\'', escapeString(rules[i].action), '\');');
}
builder.push('return actions;');
var getActions = new Function('from, to', builder.join(''));
// Обрабатываем сообщения
var result = {};
for ( var key in messages ) {
var message = messages[key];
result[key] = getActions(message.from, message.to);
}
return result;
}
```
А ниже приведен пример сформированной функции getActions:
```
function getActions(from, to) {
var actions = [];
/^.*@work\.com$/.test(from) && actions.push('tag work');
/^.*@spam\.com$/.test(from) && actions.push('tag spam');
/^jack@example\.com$/.test(from) && /^jill@example\.org$/.test(to) && actions.push('folder jack');
/^jill@example\.com$/.test(to) && actions.push('forward to jill@elsewhere.com');
return actions;
}
```
Плюсом данного подхода также является то, что внутри функции мы вольны предварительно запрограммировать любые условия, необходимые для того или иного правила. Конкретно в выше приведенном примере, если в правиле не задано свойство from или to, то и нет необходимости добавлять в тело функции проверку соответствующего свойства сообщения для данного правила. А если в правиле не задано ни одно из этих свойств, то указанное в правиле действие просто запишется в результирующий массив безо всяких проверок.
При использовании же обычного вложенного цикла для достижения подобного поведения пришлось бы вставлять дополнительные проверки в тело цикла, вычисляемые на каждой итерации, что, конечно же, накладывает дополнительные расходы.
3. Сам, всё сам!
----------------
Далее я всё же сподобился уйти от регулярных выражений и написал функцию match(value, pattern), которая определяет, соответствует ли адрес заданному шаблону или нет, возвращая соответственно true или false. Изначально функция у меня оперировала символами/строками, но такой подход оказался не очень эффективным, поэтому оперировать она стала в основном ASCII-кодами, которые получаются через String.charCodeAt(index) (была также попытка использовать String.codePointAt(index), но она не оправдала себя по эффективности). Функция громоздкая и не особо интересная, поэтому приводить её здесь я не буду.
Чтобы вызывать функцию match из getActions, я передавал её дополнительным параметром после from и to.
4. Извините, Вы нам точно не подходите
--------------------------------------
В поисках способа дальнейшего увеличения производительности я решил, что собственная функция — это, конечно, здорово, но всё же следует её вызывать пореже, и опять сфокусировался на getActions. Собственно, на данном этапе задача стояла в том, чтобы на основании каких-то признаков заведомо исключить часть правил и не вызывать для них ресурсоёмкую функцию, при чём определение этих признаков само по себе тоже не должно занимать много времени.
Одним из таких признаков стал просто первый символ шаблона. Использовать его можно только в том случае, если он не был символом "?" или "\*". Второй признак, длину, можно было использовать, когда в шаблоне нет символа "\*" (на тот момент до меня ещё не дошла мысль, что можно проверять и минимальную длину адреса).
Чтобы при проверке каждого правила не вызывать кучу методов в свойствах from и to обрабатываемого сообщения, в начале функции getActions рассчитываем дополнительные переменные и используем их по мере необходимости:
```
function getActions(from, to, match) {
var actions = [];
var fb = from.charCodeAt(0), fb61 = fb == 0x61, fb74 == 0x74 /*, ... */;
var tb = to.charCodeAt(0), tb66 = tb === 0x66 /*, ... */;
var fl = from.length, fl14 = fl == 14, fl15 = fl == 15 /*, ... */;
var tl = to.length, tl16 = tl == 16 /*, ... */;
fb61 && tb66 && fl15 && tl16 && match(from, 'abc@example.com') && match(to, 'fake@example.com') && actions.push('action 1');
fb74 && fl14 && match(from, 'test@gmail.com') && match(to, '*@any.net') && actions.push('action 2');
// ...
return actions;
}
```
Это изменение дало заметный рост производительности. Но можно заметить, что в любом шаблоне, начинающемся с символа "\*" невозможно ориентироваться ни по первому символу, ни по длине. А такие шаблоны однозначно должны были встречаться.
5. И ещё несколько вопросов
---------------------------
Поэтому следующим шагом я решил попробовать классифицировать шаблоны ещё и по доменам. Так как в любом месте домена также может встретиться "\*", то я решил, что буду брать из него максимально возможный уровень домена вплоть до 3-го. Соответственно, в начале функции getActions необходимо из свойств сообщения from и to выделить домены 1, 2 и 3 уровня и сформировать большую пачку переменных, сигнализирующих о принадлежности адреса сообщения к тому или иному домену.
Насколько сейчас могу вспомнить, метод не то, чтобы совсем нерабочий, но при разных тестовых данных, он себя проявлял по-разному. Вычленение доменов из адресов и предварительный расчет переменных на каждой итерации съедали много времени. Тут я попробовал много разных вариантов. Например, группировал редко встречающие домены, чтобы уменьшить количество вычисляемых переменных вначале (кстати, с первыми символами и длинами я тоже проводил подобные группировки), пытался вычислять хэш доменов и сравнивать его. Но по итогу от сравнения доменов я всё-таки отказался.
6. Где-то неподалеку
--------------------
Между тем, в голове все витала мысль, а не попробовать ли построить единое дерево от начала (а потом и от конца) шаблонов до первого символа "\*", и засунуть в его листья списки правил, которые и надо проверять? То ли мне просто не очень нравился этот метод, и я подсознательно строил его неэффективно, то ли оно действительно так долго строится, но уже после первых экспериментов я решил, что создание этой структуры — довольно медленная штука, и я не хочу с ней возиться.
7. Зачем изобретать велосипед?
------------------------------
Я вернулся к предыдущему варианту, но вместо классификации по доменам я просто добавил ещё и проверку последнего символа шаблона.
Вроде всё хорошо, но не очень. Теперь получается, что при проверке каждого правила до вызова функций match могло проверяться до 6 переменных (а изначально я ведь хотел уменьшить количество проверок), да ещё и просчитывать их все надо для каждого сообщения. Мне это не нравилось. К тому же, экспериментируя с количеством проверок для каждого правила и их последовательностью, я пришёл к выводу, что при такой длинной проверке от трёх признаков пользы не намного больше, чем от двух. Отсюда следующий шаг.
8. В тесноте, да не в обиде
---------------------------
Я решил, что сравнение длин адресов и шаблонов — самый бесполезный признак, и исключил из исключающих правила признаков. Остались только проверки соответствия первого и последнего символов. Из условий конкурса помним, что в строках могут быть только символы с кодами в диапазоне от 0x20 до 0x7F, а значит, все первые и последние символы шаблонов можно легко уместить в одну переменную типа Integer и для каждого правила производить только одно сравнение перед вызовом match. Оставалась только проблема, что у некоторых шаблонов в начале или конце могли быть символы "?" и "\*", которые участвовать в сравнении не должны. Но эта проблема легко решается, если перед сравнением значений наложить на них маску, обнуляющую лишние октеты. Получаем примерно следующее:
```
function getActions(from, to, match) {
var actions = [];
var hash = (from.charCodeAt(from.length-1)<<24) | (from.charCodeAt(0)<<16) | (to.charCodeAt(to.length-1)<<8) | to.charCodeAt(0);
(hash & 0xFFFFFFFF) == 0x6D616D66 && match(from, 'abc@example.com') && match(to, 'fake@example.com') && actions.push('action 1');
(hash & 0xFFFFFF00) == 0x6D747400 && match(from, 'test@gmail.com') && match(to, '*@any.net') && actions.push('action 2');
// ...
return actions;
}
```
Ну и конечно, наложение масок на хэш тоже логично предварительно рассчитать в переменные (их никак не может быть больше 16-ти) в начале функции, чтобы не выполнять эту операцию для каждого правила.
9. Разделяй и властвуй!
-----------------------
Функция match работала достаточно хорошо, но она была универсальна для всех шаблонов, и в этом был её недостаток. Для шаблонов, не содержащих символа "\*" было не обязательно проходить все эти дополнительные процедуры, а достаточно только посимвольно сравнить две строки с учетом особенностей символа "?" в шаблоне. То же касалось шаблонов, содержащих только один символ "\*". В этом случае логично проверять участки шаблона до "\*" и после.
В итоге, вместо одной функции match их появляется пять:
* m1(value, pattern) — сравнение, если символа "\*" в шаблоне нет.
* m2(value, pattern) — сравнение, если символов "\*" много.
* m3(value, pattern, bl, el) — если один символ "\*" в середине шаблона, то анализ bl символов в начале строки и el в конце.
* m4(value, pattern, bl) — если один символ "\*" в конце шаблона, то анализ bl символов в начале.
* m5(value, pattern, el) — если один символ "\*" в начале шаблона, то анализ el символов в конце.
Кроме того, в эти функции шаблон я передаю уже в виде массива с кодами символов, а не как строку (чтобы лишний раз не дёргать метод String.charCodeAt(index), на самом деле, не знаю, принесло ли это пользу).
Соответственно, в функцию getActions в процессе её формирования подставляются вызовы нужных функций (которые всё так же передаются через дополнительные параметры). В этот же момент из шаблонов удаляются подряд идущие символы "\*", так как на результат это влияния не оказывает, а на выбор функции сравнения ещё как. (В конечном варианте решения реализация этого процесса находится внутри функции createPatternMatchFunc.)
10. Только тссс...
------------------
Есть в данном решении одно слабое место. В худшем случае, если вдруг все шаблоны начинаются с одного и того же символа, да ещё и заканчиваются одним и тем же символом, то у всех них хэш будет одинаковый и функции проверки шаблонов внутри getActions будут вызываться абсолютно для всех правил (если адреса в сообщении, конечно, подходят).
В таком случае логично было бы сравнивать не первые, а вторые или третьи символы с начала и конца шаблона (при условии, что до них не было "\*"). Но как определить, какой вариант наиболее оптимален?
Я пошёл по следующему пути:
1. Для первых и последних трёх позиций шаблонов посчитал частоты появления тех или иных кодов символов;
2. Для каждой позиции вычислил среднеквадратическое отклонение этих частот;
3. Выбрал в начале и конце позиции с минимальным среднеквадратическим отклонением (но не те, в которых встречается только один код символа).
В принципе, всё это работало, но процесс формирования функции getActions замедлился, что сказалось на общей скорости работы фильтра. К тому же, мне не давала покоя мысль, что у позиции с двумя вариантами кодов с равными частотами и у позиции с восемью вариантами кодов с равными частотами одинаковые среднеквадратические отклонения, хотя логически ясно, что второй вариант более уместный для использования. Учитывая небольшой провал производительности, пытаться всё это балансировать я не стал, а просто вернулся к анализу первого и последнего символов (нам ведь обещали реальные данные).
11. Практическая магия и не только
----------------------------------
* В ходе экспериментов выяснилось, что у строки лучше сначала читать свойство length в переменную, а последующие манипуляции проводить с этой переменной. Даже если она используется один раз. Так быстрее.
* Объявлять несколько переменных подряд быстрее с одним var через запятую, чем с несколькими через точку с запятой.
* Передача функций сравнения через параметры функции getActions медленнее, чем помещение их в global и вызов оттуда.
* Менять исходный объект messages эффективней, чем создавать новый объект результатов.
* Безразлично, ставить ли везде == или === .
На этом этапе решение и было отправлено на проверку.
12. Из несбывшегося
-------------------
Для тестирования производительности своего решения я подготовил тестовые данные, в которые входило 600000 сообщений и 1000 правил. Причём среди сообщений не было ни одного с парой повторяющихся адресов. Наверное, поэтому мне как-то и в голову не приходила мысль про кэширование результатов.
Добавив кэширование результата getActions, с данными, используемыми в конкурсе, на своей машине я получил прирост производительности на 15% для large-данных и на 2% для xlarge-данных (на моих данных производительность деградировала на 13%). То есть при отправке решения в таком виде, вероятно, в итоговой таблице мой результат составлял бы около 248 и 2303 мс вместо 292 и 2351 мс соответственно, а статья называлась бы «2 место за 12 шагов». Но, увы и ах!
Спасибо организаторам, жду новых конкурсов! | https://habr.com/ru/post/275343/ | null | ru | null |
# Автоматизируем FreeIPA: как устанавливать клиентов с помощью Ansible и управлять DNS записями через Terraform
У нас в Altenar собралась достаточно большая и продвинутая команда разработчиков. За эти годы внутри компании накоплен разнообразный опыт в создании и развитии высоконагруженных систем. Поэтому время от времени коллегам хочется поделиться с миром своими знаниями. Регистрироваться на Хабре они пока не готовы, зато совсем не против материализовываться на моей странице. Надеюсь острой аллергии это у вас не вызывает. Если будут вопросы к материалу, смело оставляйте их в комментариях, обещаю молниеносно перенаправлять авторам статьи. Добро пожаловать за кат.
Привет, меня зовут Денис, и я около двух лет работаю DevOps инженером в компании Altenar. Наша инфраструктура располагается как в Google Cloud, так и в собственном облаке на базе VMWare, в котором находится более 200 серверов и виртуальных машин.
Когда количество Linux машин в компании достаточно велико, то рано или поздно возникает необходимость в централизованном управлении доступом к серверам и если в случае с Windows использование AD является индустриальным стандартом, то, когда дело доходит до Linux приходится использовать такие инструменты как FreeIPA.
FreeIPA (Free Identity, Policy and Audit) ─ это open-source решение для Linux (аналогичное MS Active Directory), которое обеспечивает централизованное управление учетными записями и централизованную аутентификацию.
Необходимо отметить, что у RedHat есть решение IdM, которое является частью RHEL. Они технически идентичны с FreeIPA и, можно сказать, что FreeIPA является upstream версией для IdM на которой обкатываются новые фичи (как Fedora для RHEL).
FreeIPA использует клиент-серверную модель. Клиентом может быть любая Linux машина, которая настроена для взаимодействия с FreeIPA (IdM) контроллером домена. Клиент осуществляет взаимодействие с помощью Kerberos, NTP, DNS сервисов и сертификатов.
Как настроить решение с репликацией из двух FreeIPA серверов с DNS можно [почитать в этой статье](https://habr.com/ru/company/pixonic/blog/325546/), а для установки FreeIPA клиентов нам понадобится:
● Функционирующий FreeIPA контроллер с настроенным DNS сервером
● Один CentOS 7 сервер по крайней мере с 1GB памяти.
● Ansible version: 2.8+
● Terraform version: 0.13+
Конечно, можно устанавливать FreeIPA клиентов [вручную](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/identity_management_guide/installing_the_ipa_client_on_linux#client-basic-setup). Это можно сделать в 3 шага:
1) Установить пакет yum install ipa-client
2) Запустить скрипт установки ipa-client-install
3) Пройти по шагам, ответив на вопросы установщика.
Но я уверен, что все прекрасно понимают плюсы автоматизации, поэтому мы пойдем немного другим путём. В Altenar мы используем два основных инструмента автоматизации ─ Ansible и Terraform. В данному случае мы решили использовать Ansible и взяли роль [из официального репозитория](https://github.com/freeipa/ansible-freeipa/tree/master/roles/ipaclient) freeipa.org с минимальным набором переменных в дополнение к перечисленным в </ipaclient/defaults/main.yml>.
```
ipaclient_domain: nix.altenar.com
ipaserver_domain: nix.altenar.com
ipaserver_realm: NIX.ALTENAR.COM
ipaclient_realm: NIX.ALTENAR.COM
ipaclient_no_ntp: yes
ipaclient_mkhomedir: yes
```
Playbook для запуска роли выглядит так:
```
---
- name: Playbook to configure IPA clients
hosts:
- linux
- tag_linux
become: yes
gather_facts: True
roles:
- { role: freeipa/ipaclient, state: present }
```
Изначально мы также использовали ansible для создания DNS записей.
```
tasks:
- ipa_dnsrecord:
ipa_host: ipa.nix.altenar.com
ipa_pass:
state: present
zone\_name: nix.altenar.com
record\_name: "{{inventory\_hostname}}"
record\_type: 'A'
record\_value: "{{ansible\_host}}"
validate\_certs: no
ipa\_user: user
```
При этом возникала проблема: чтобы создать dns запись необходимо было сначала явно указать IP адрес "{{ansible\_host}}" в inventory файле, что было не очень удобно.
```
[linux]
xknm0.nix.altenar.com ansible_host=10.10.10.243
```
И так как мы используем в том числе Terraform в нашем частном облаке и стараемся придерживаться подхода [IaC](https://habr.com/ru/company/dododev/blog/465137/) был найден [terraform-provider-freeipa](https://registry.terraform.io/providers/camptocamp/freeipa/latest), который позволил нам добавлять DNS записи при создании виртуальных машин.
```
terraform {
required_providers {
freeipa = {
source = "camptocamp/freeipa"
version = "0.7.0"
}
}
}
provider freeipa {
host = "ipa.nix.altenar.com" # or set $FREEIPA_HOST
username = "admin" # or set $FREEIPA_USERNAME
password = "" # or set $FREEIPA\_PASSWORD
insecure = true
}
resource freeipa\_dns\_record "test" {
dnszoneidnsname = "nix.altenar.com."
idnsname = "test"
records = ["10.10.10.10"]
type = "A"
}
```
В результате мы получаем готовую DNS запись при создании виртуальной машины.
И ничто нам не мешает продолжить установку FreeIPA клиента с помощью Ansible роли.
Так выглядит процесс создания DNS записей и установки FreeIPA клиентов у нас в Altenar. Надеюсь, что наш опыт был вам полезен, ну а мы в свою очередь продолжим делиться лайфхаками.
**P.S.** Если есть вопросы или вы хотели бы рассказать о своем опыте по заявленной теме, смело приходите в комментарии. | https://habr.com/ru/post/568524/ | null | ru | null |
# Наступление на свободный интернет на Украине: Закон Украины «О защите общественной морали»
 Две недели назад правительство Украины [утвердило](http://habrahabr.ru/blogs/eCommerce/130426/) законопроект «Про внутреннюю торговлю», в котором описаны правила работы интернет-магазинов. Этот законопроект касался только интернет-магазинов. Но на этом не успокоились. Неделю назад в первом чтении в Верховной Раде тихонько проголосовали за внесение изменений в закон «О защите общественной морали», в котором есть набор правил по которым сайт может быть закрыт провайдерами в течении суток а так же выдача информации правоохранительным органам о владельце ресурса.
Давайте разберем подробнее этот законопроект.
Смотрим 11 статью:
> Запрещается размещение **и распространение в телекоммуникационных сетях продукции, определенной статьей 10 настоящего Закона.**
>
>
>
> Операторы и провайдеры телекоммуникаций, предоставляющих услуги по размещению, хранению и доступу к электронным информационным ресурсам (веб-сайтов), а также услуги доступа к сети Интернет, **обязаны**:
>
> …
>
> **принимать безотлагательные (в течение суток) меры по ограничению свободного доступа к электронным информационным ресурсам (их частям),** определенных Национальной комиссией Украины по вопросам защиты общественной морали эротическими;
>
>
>
> **при наличии решения суда в течение суток обеспечивать техническими средствами удаление контента**, которая наносит вред общественной морали, в том числе детской порнографии, из национального сегмента сети Интернет, а в условиях его размещения за пределами Украины — надежное блокирование доступа к нему из национального сегмента сети Интернет;
>
>
>
> **по запросу правоохранительных органов** в рамках мероприятий по противодействию распространению в телекоммуникационных сетях информации, которая наносит вред общественной морали, **безотлагательно предоставлять информацию, с помощью которой можно установить**:
>
>
>
> тип информационной услуги, личность пользователя услуг и другие сведения, которые можно получить с помощью соглашения или договоре на обслуживание;
>
>
>
> место установки телекоммуникационного оборудования, время и место создания, функционирования информационных ресурсов и **данные о доступе к ним пользователей телекоммуникационных систем**.
>
>
>
> Теле-и радиокомпаниям, провайдерам программной услуги, которые действуют в Украине, запрещается создавать, распространять, транслировать (ретранслировать) кино-, аудио-, видеопродукцию, телевизионные и радиопрограммы (передачи), предоставлять услуги просмотра или прослушивания продукции, запрещенной к обращению на территории Украины в соответствии со статьей 10 настоящего Закона.
>
>
Весело, правда? Теперь давайте посмотрим что же так напугало блюстителей морали (Статья 10):
> Статья 10. Запрет производства и обращения продукции, которая наносит вред общественной морали
>
>
>
> С целью предупреждения производства и обращения продукции, **которая наносит вред общественной морали запрещается**:
>
>
>
> 1) проведение зрелищных мероприятий, производство и оборот любой продукции, которая:
>
> пропагандирует войну, изменение путем насилия конституционного строя или территориальной целостности Украины, терроризм, другие проявления преступной деятельности;
>
> пропагандирует национальную, расовую и религиозную вражду, в частности расизм, ксенофобию, украинофобию, антисемитизм;
>
> пропагандирует фашизм и неофашизм;
>
> унижает или оскорбляет нацию или личность по национальному признаку;
>
> пропагандирует неуважение к национальным и религиозным святыням;
>
> унижает личность, является проявлением издевательства над душевнобольными, пожилыми людьми, людей с физическими недостатками (увечьем);
>
> пропагандирует употребление токсических, наркотических, психотропных веществ, алкогольных напитков, табакокурение;
>
> пропагандирует насилие и жестокость;
>
> пропагандирует проституцию, сводничество, торговля людьми, создание и распространение продукции порнографического характера;
>
>
>
> 2) производство и оборот продукции порнографического характера;
>
>
>
> 3) изготовление (производство), обращение, предложение или предоставление доступа к продукции, содержащей детскую порнографию;
>
>
>
> 4) размещение объявлений об интимных встречах за вознаграждение в любых средствах массовой информации, а также их распространение любым иным способом;
>
>
>
> **5) употребление нецензурных ругательств и грубых слов в продукции печатных средств массовой информации, в телевизионных и радиопрограммах (передачах), распространяемых в течение эфирного времени в суточном отрезке с 6:00 до 23:00, кроме каналов с ограниченным доступом, в рекламе, мобильном контенте, в компьютерных играх и других играх для детей, в издательской продукции, рассчитанной на детей, а также в детской видео-и аудиопродукции, фильмах, не имеющих ограничения зрительской аудитории, или рассчитаны на зрительскую аудиторию до 16 лет.**
>
>
>
> Прекращении выпуска печатного средства массовой информации, для распространения информации с нарушением требований, предусмотренных настоящим Законом, а также запрет демонстрации фильмов, программ, информационных материалов, зрелищных мероприятий и т.д., которые наносят ущерб общественной морали осуществляется по решению суда.
>
>
Ещё веселее, правда? Прошу обратить внимание что в статье 11 указано
`Запрещается размещение **и распространение в телекоммуникационных сетях продукции, определенной статьей 10 настоящего Закона.**`
**Что имеем ?**
Бороться с детской порнографией ну и с порнографией(ладно) благородное дело, но все остальное извините просто бред.
Наличие на сайте матюка позволяет закрыть его в течении суток. Заходите на любой форум, пишите матюкливый опус, стучите куда надо и вуаля, в течении суток ресурса как не бывало.
Так же если государственному контролеру покажется что слово было брутальным, кроме закрытия ресурса может последовать административное наказание, и удаление источника информации, т.е. сайта.
[Ссылка на законопроект](http://w1.c1.rada.gov.ua/pls/zweb_n/webproc4_1?id=&pf3511=38551)
[Тут можно прочитать аналогичную статью](http://maidan.org.ua/2011/10/alyarm-svobodi-slova-v-interneti-vyneseno-smertnyj-vyrok/) (на украинском языке)
**P.S.**
**Прошу всех обратить внимание на то что такое «продукция» устами самого законопроекта:**
> продукция — любое изделие, картина, гравюра, скульптура, продукция печатных средств массовой информации, издательская продукция, фото-, аудио-, кино-, видеопродукция, телевизионные и радиопрограммы (передачи), реклама, **информация в телекоммуникационных сетях, в том числе сети Интернет**, сообщения и материалы, информация на цифровых носителях, в том числе для лазерных систем считывания, компьютерные и видеоигры, мобильный контент;
Поэтому маты на странице сайта попадает под понятие «продукции» а следовательно под статью 10 закона
> 5) **употребление нецензурных ругательств и грубых слов в продукции** печатных средств массовой информации, в телевизионных и радиопрограммах (передачах), распространяемых в течение эфирного времени в суточном отрезке с 6:00 до 23:00, кроме каналов с ограниченным доступом, в рекламе, мобильном контенте, в компьютерных играх и других играх для детей, в издательской продукции, рассчитанной на детей, а также в детской видео-и аудиопродукции, фильмах, не имеющих ограничения зрительской аудитории, или рассчитаны на зрительскую аудиторию до 16 лет.
Со ссылкой из 11 статьи на которую я обращал внимание
> Запрещается размещение **и распространение в телекоммуникационных сетях **продукции**, определенной статьей 10 настоящего Закона.** | https://habr.com/ru/post/131338/ | null | ru | null |
# Сколько математики нужно, чтобы подписать многоугольник в JS API Яндекс.Карт
В JS API Яндекс.Карт существует возможность создавать различные объекты на карте. Один из их них – многоугольник, с помощью которого можно улучшить интерактивность пользовательской карты: выделить отдельные области или отобразить местоположение неточечного объекта. К примеру, так можно показать план строительства нового квартала или зоны доставки пиццы.
У пользователей API Яндекс.Карт давно появился вопрос о добавлении подписей поверх многоугольников. Люди предлагали хитрые решения, чтобы добавить подпись на объект в нужном месте, скрыть ее, перекрасить и т.п., но такие решения получались сложными и негибкими.
К примеру, к нам пришел отдел исследований Яндекса с просьбой написать удобный инструмент для подписи многоугольников после того, как они сделали несколько исследований на карте мира.
*Отображения региональных слов из словаря Даля, т.е слова которые ищут значительно чаще, чем в среднем по России*
В действительно задача оказалась нетривиальной. Только представьте, для каждого многоугольника нужно определить хорошо подходящий центр для отображения подписи, на каждом масштабе определить вмещается ли подпись, нужно ли ее скрывать на выбранном зуме, менять стили на каждом зуме, опять все перерассчитывать. То есть, чтобы сделать не особо сложную инфографику, нужно сильно попотеть и подготовить много дополнительных данных.
Создать подписи к многоугольникам — одна из рутинных задач. Можно сидеть и отрисовывать все в фотошопe, но это получается максимально не гибко:
* Любые изменения содержимого (значения в подписях, цвет) поведут за собой изменение всех подписей, надо будет отрисовывать каждую заново.
* Полноценное взаимодействие с картой включает в себя смену масштабов, для которых не всегда можно разместить читаемый текст на карте в многоугольнике. Размера многоугольника может не хватить для полного отображения подписи на определенных масштабах, следовательно необходимо для каждого отрисовывать подписи разных размеров.
В редакторах изображений довольно сложно сделать подпись интерактивной, намного проще задать массив точек для многоугольников, шаблон будущей подписи и получить готовую визуализацию.
*Отображения самых популярных слов в запросах о разных странах*
В итоге мы решили сделать модуль, который решит проблемы пользователей с подписыванием многоугольников и предоставит свободу в его кастомизации.
Выбор алгоритма для определения подходящего центра для подписи
--------------------------------------------------------------
Одной из основных задач, стоявших перед нами, было определение наиболее подходящего центра для отображения подписи, чтобы пользователь мог получить готовый результат без дополнительных настроек.
Для решения задачи поиска центра существует несколько алгоритмов:
### Расчет положения по центроиду
Это самое первое, что приходит на ум. В математике и физике центроид (геометрический центр плоской фигуры) представляет собой среднее арифметическое положение всех точек.
Реализовать поиск [центроида](http://www.skycoyote.com/cntr/) достаточно просто и сам алгоритм работает быстро. Казалось бы на этом все, но если фигура — не выпуклый многоугольник или имеет отверстие, то точка может выпасть за пределы фигуры или попасть в неподходящее для отображения подписи место.
*Так выглядит результат определения центроида. Видно, что точки на Хабаровском и Камчатском краях попали в неблагоприятное для отображения подписи место.*
### Полюс недоступности или точка самого большого вписанного круга
Задача нахождения такой точки возникала уже у многих, следовательно, существуют различные алгоритмы для нахождения полюса недоступности, но, к сожалению, опубликованные решения требуют сложных реализаций и работают слишком медленно, чтобы можно было применить их на практике.
Первым делом, после изучения теории, всегда ищешь готовые решения. Так, нам повезло найти интересное у разработчиков из [Mapbox](https://github.com/mapbox/polylabel).
Они просмотрели несколько вариантов решений для нахождения полюса недоступности, столкнулись с рядом проблем и, вдохновившись одним из алгоритмов, смогли создать свой, который исключает ошибки, ускоряет поиск и увеличивает точность получения качественного результата.
### Как происходит поиск
Алгоритм построен на основе [дерева квадрантов](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D1%80%D0%B5%D0%B2%D0%BE_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D0%BD%D1%82%D0%BE%D0%B2). То есть для исследуемого многоугольника строится область (квадрант), в которую полностью помещается многоугольник. Далее эта область делится на четыре равные части и так далее рекурсивно с каждым квадрантом.
Исследование продолжается только в удовлетворяющих условию ячейках. Ячейка считается подходящей, если сумма расстояния от ее центра до ребра многоугольника и радиус окружности, описывающей ячейку, больше предыдущих вычислений в квадрантах.
Внутри этого модуля также используется алгоритм нахождения центроида, как запасной вариант: если найденный полюс недоступности не будет удовлетворять нужной точности.
Подробная информация [описана здесь](https://blog.mapbox.com/a-new-algorithm-for-finding-a-visual-center-of-a-polygon-7c77e6492fbc).
### Результат работы алгоритма
Видно как отличается точность алгоритмов: “центр” на “проблемных” многоугольниках стал подходить намного лучше для расположения подписи:
* Красные точки — центроид
* Зеленые — полюс недоступности
После выбора алгоритма для нахождения “центра” многоугольника, мы начали работу над модулем подписывания.
Алгоритм работы модуля
----------------------
Подписывание многоугольника происходит в несколько этапов.
На вход модулю отдается коллекция, в которой находятся вершины многоугольников для подписывания.
Вначале координаты каждого многоугольника пропускаются через модуль нахождения полюса недоступности и на выходе получаются координаты точки, в которой будет находиться подпись. Этот центр модуль применит на все зумы, если не было переопределения центра с помощью специальной опции. Значения центра многоугольника кешируются вместе с состоянием о вместимости подписи, чтобы не вычислять их больше одного раза на один и тот же зум.
Далее перед нами стоит задача понять, вмещается ли подпись в многоугольник.
Модуль достает шаблон подписи и на его основе создается [HtmlElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement).
```
objectManager.add({
...
options: {
labelLayout: '{{properties.name}}
===================
'
},
properties: {
name: 'nameOfMyPolygon'
}
});
```
Далее модуль дожидается загрузки картинок из тегов , если таковые присутствуют, и с помощью [getBoundingClientRect()](https://developer.mozilla.org/ru/docs/Web/API/Element/getBoundingClientRect) вычисляются размеры этой подписи. К сожалению, не существует методов, которые могли бы сказать о размере не вставленного в DOM элемента. Поэтому сначала надо подпись отрендерить. А для того, чтобы при получении размера не было “миганий” (показа и скрытия подписи), она отрисовывается в специальном контейнере, который скрыт от глаз пользователей.
Так как модуль поддерживает различные опции, такие как смещение центра или погрешность отображения, то сначала применяются они, а затем проверяется, вмещается ли подпись.
```
objectManager.add({
...
options: {
labelLayout: '{{properties.name}}
===================
',
labelOffset: [80, -50]
},
properties: {
name: 'nameOfMyPolygon'
}
});
```
Центр подписи представлен в виде географических координат, а размеры элемента подписи в пикселях, следовательно, происходит перевод географических координат центра.
Далее от этого центра откладывается ширина и высота элемента, применяется погрешность в вычислении, если она была указана.
```
objectManager.add({
...
options: {
labelLayout: '{{properties.name}}
===================
',
labelOffset: [80, -50],
labelPermissibleInaccuracyOfVisibility: 10
},
properties: {
name: 'nameOfMyPolygon'
}
});
```
Полученные координаты переводятся в географические и проверяется, поместилась ли подпись в многоугольник.
Все это происходит для каждого зума и для двух видов подписей, о которых подробнее описано в следующей части.
Возможности модуля
------------------
Посмотрев на самые неприятные проблемы, с которыми сталкиваются веб-мастеры, мы сделали ряд опций, которые помогут удобно настраивать работу модуля под личные нужды.
Одной из важных задач была — сделать удобный способ вставки макета в многоугольник. С помощью специальной опции можно задать в виде строки [html-макет](https://tech.yandex.ru/maps/doc/jsapi/2.1/ref/reference/Template-docpage/), который поддерживает базовый синтаксис языков шаблонов Twig/Django Templates.
У каждого многоугольник существует два вида подписи: основная и маленькая.
Это сделано для того, чтобы отобразить уменьшенную копию основной подписи, в случае если она не помещается.
Каждая подпись принадлежит одному многоугольнику, через который происходит управление параметрами подписи.
Для того чтобы можно было управлять параметрами подписи на различных масштабах, были введены дополнительные опции. Если пользователя не устраивает стандартное определение центра подписи, то можно задать необходимые координаты, в которых хочется увидеть подпись.
*Слева — автоматический центр, справа — установлен на координаты [72, 92]*
Также можно задать отступы от положения подписи и погрешность отображения, значение которой означает, на сколько подписи разрешено выходить за границы многоугольника.
*Отступ по 30px сверху и слева*
*Погрешность в 25px*
Не обошлось дело и без стилей, есть возможность менять размер и цвет текста или же задавать значение атрибута class.
Все эти параметры подписи можно настроить на каждый зум или же задать одно значения на все масштабы.
Все это необходимо для того, чтобы пользователь мог кастомизировать поведение модуля.
[Здесь](https://github.com/yandex/mapsapi-polylabeler#polygon-options) представлен весь список возможных опций.
Не остались без внимания [события](https://github.com/yandex/mapsapi-polylabeler#events). Все события, произошедшие с подписью (нажатие, наведение...) пробрасываются на родительский многоугольник и соответствуют базовым событиям в API, нужно только добавить перед ними **“label”**.
Для оперативного изменения видимости подписи, был создан специальный [state](https://github.com/yandex/mapsapi-polylabeler#state), который есть у каждого многоугольника. Получив его через экземпляр модуля, мы можем поменять тип подписи, либо вовсе спрятать еe. К примеру, вы хотите, чтобы на многоугольниках, в которых не поместилась основная подпись, при наведении на ее уменьшенную копию, она появлялась.
Также через это состояние можно получить текущий тип отображаемой подписи или координаты, в которых находится подпись.
Дизайн и интерфейс решения
--------------------------
Зачастую, текст является одной из основных частей подписи, поэтому мы уделили ему отдельное внимание.
Чтобы подпись хорошо читалась при пересечении с границами регионов и на полупрозрачных многоугольниках, понадобилось отделить его от фона обводкой. Сделали два стандартных стиля, которые подойдут в большинстве случаев:
*Изображения сверху: обычный текст, без обводки*
*Изображения снизу: два стандартных стиля модуля*
Многострочные подписи не очень хорошо читаются при выравнивании текста по левому краю, поэтому было поставлено центральное выравнивание дефолтным.
Поскольку макет подписи можно задавать как произвольный html, не составит труда добавить к подписям изображения — это пригодится, например, для создания прогноза погоды на карте или для визуализации данных с диаграммами.
Гибкий макет подписей пригодится и для инфографики, например, показать флаги стран мира или гербы областей.
### Итак, что у нас получилось
* Модуль может принимать любого вида подпись.
* Модуль может сам определять подходящее место для подписи и позволяет пользователю управлять ее позицией с помощью отступов или точных координат.
* У подписи может настраиваться стиль, цвет и размер текста.
* Пользователь может менять видимость подписей.
* Пользователь может задавать настраиваемые параметры как для всех допустимых масштабов, так и для отдельных.
### Заключение
Мы решили остановиться на базовых сценариях использования, которые смогли бы удовлетворить основные потребности в удобном создании подписи, но если у вас есть пожелания к работе модуля, мы обязательно рассмотрим их.
### Для тех кому стало интересно
Чтобы начать использовать модуль, необходимо выполнить пару пунктов из инструкции в [данном репозитории](https://github.com/yandex/mapsapi-polylabeler).
### Пример
[jsfiddle.net/51qtdx3a/5](https://jsfiddle.net/51qtdx3a/5/)
Мы всегда рады предложениям и фидбеку, по всем вопросам пишите нам в техподдержку или оставьте пожелания в комментариях. Надеемся, что наши инструменты сделают жизнь вебмастера чуть легче и откроют для вас новые горизонты в визуализации данных на карте. | https://habr.com/ru/post/353498/ | null | ru | null |
# Chef за 21 день. Часть третья. Chef и AWS
Здравствуй, хабраюзер. Вот и подоспела **третья** часть моей статьи, которая подытожит цикл ([часть 1](http://habrahabr.ru/company/epam_systems/blog/208542) и [часть 2](http://habrahabr.ru/company/epam_systems/blog/209368)) статей для начинающих. Эта часть будет посвящена конкретному примеру применения Chef в облаке **Amazon**. Как я уже упоминал – это достаточно популярный сценарий.  Для простоты понимания, будет рассмотрен случай с двумя **ec2-instance** (виртуальные сервера Amazon), один из которых будет выполнять роль Chef-сервера, а второй – узла.
AWS и Chef
----------
Сразу же уточню, что запускать instance мы будем используя **AWS CloudFormation**. Можно было бы, конечно, запустить и управлять ними вручную, но какой смысл в такой автоматизации?
**CloudFormation** можно разделить на 2 *понятия*:
— *template*, представляющий собой json-файл, в котором описываются все ресурсы, которые необходимы нам для запуска instance;
— *stack*, представляющий собой сами ресурсы AWS, описанные в template.
Для тех, кто начинает знакомство с AWS, Amazon предоставляет уже готовые *sample template*, которые освещают большинство аспектов, необходимых при работе с AWS. Ссылка на шаблоны будет приведена в конце статьи.
Рассмотрим, что собой представляет **template**. В базовом случае он состоит из 4 блоков: *Parameters, Mappings, Resources, Outputs*.
Блок **Parameters** описывает переменные и их значения, которые будут переданы в stack во время создания оного. Значения параметров можно вводить при создании ресурсов, а можно задавать при помощи поля default в описании параметра. Параметром может быть любая информация, начиная от пароля и кончая сетевым портом или путем к директории. Для получения значения параметра, в шаблоне используется функция Ref.
Блок **Mappings** содержит в себе набор ключей с соответствующими параметрами и их значениями. Чаще всего можно видеть, как mapping-и используются для определения регионов AWS и соответствующих им виртуальным образам (instance). Для получения значения того или иного mapping – используется функция Fn::FindInMap, в которой указывается ключ и параметры, по которым производится поиск того или иного значения.
Блок **Resources** описывает наши *ec2-instance* либо другие ресурсы AWS. Именно в этом разделе объявляются образы для Chef-сервера и клиентского узла. В описании необходимо указать тип ресурса (например, AWS::EC2::Instance), также возможно указать metadata, в которой можно указать описание нашего узла или директивы по pre-install процедуре (например, если необходимо установить какой-либо пакет при запуске образа). Основной частью блока является блок **Properties**, в котором детально описывается запускаемый образ. В этом блоке можно задать тип образа, который будет запущен (например, Amazon Linux 32-bit), принадлежность запускаемого образа к той или иной **Security Group** (по сути, это *firewall*, с определяемыми правилами для трафика, в котором действие по умолчанию — deny). Однако, самой главной частью блока Properties – является **User Data**. Именно тут мы опишем скрипт, который будет превращать наш безликий instance в Chef-сервер или Chef-клиент.
**Template**, который я использую, приведен ниже под катом, рассмотрим его и я прокомментирую его.
**Template**
```
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "Template for stack",
"Parameters" : {
"KeyName" : {
"Description" : "Name of an existing EC2 KeyPair to enable SSH access to the instances",
"Type" : "String",
"MinLength" : "1",
"MaxLength" : "255",
"AllowedPattern" : "[\\x20-\\x7E]*",
"ConstraintDescription" : "can contain only ASCII characters."
},
"HostKeys" : {
"Description" : "Public Key",
"Type" : "String"
},
"SecretAccessKey" : {
"Description" : "Name of an existing EC2 KeyPair to enable SSH access to the instances",
"Type" : "String"
},
"InstanceType" : {
"Description" : "Chef Server EC2 instance type",
"Type" : "String",
"Default" : "m1.small",
"AllowedValues" : [ "t1.micro","m1.small"],
"ConstraintDescription" : "must be a valid EC2 instance type."
},
"SSHLocation" : {
"Description" : " The IP address range that can be used to SSH to the EC2 instances",
"Type": "String",
"MinLength": "9",
"MaxLength": "18",
"Default": "0.0.0.0/0",
"AllowedPattern": "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})",
"ConstraintDescription": "must be a valid IP CIDR range of the form x.x.x.x/x."
}
},
"Mappings" : {
"AWSInstanceType2Arch" : {
"t1.micro" : { "Arch" : "64" },
"m1.small" : { "Arch" : "64" }
},
"AWSRegionArch2AMI" : {
"us-east-1" : { "32" : "ami-d7a18dbe", "64" : "ami-bba18dd2", "64HVM" : "ami-0da96764" },
"us-west-2" : { "32" : "ami-def297ee", "64" : "ami-ccf297fc", "64HVM" : "NOT_YET_SUPPORTED" },
"us-west-1" : { "32" : "ami-923909d7", "64" : "ami-a43909e1", "64HVM" : "NOT_YET_SUPPORTED" }
}
},
"Resources" : {
ChefClient" : {
"Type" : "AWS::EC2::Instance",
"Metadata" : {
"Description" : "Chef Client",
"AWS::CloudFormation::Init" : {
"config" : {
"packages" : {
"yum" : {
"git" : []
}
}
}
}
},
"Properties": {
"ImageId" : { "Fn::FindInMap" : [ "AWSRegionArch2AMI", { "Ref" : "AWS::Region" }, { "Fn::FindInMap" : [ "AWSInstanceType2Arch", { "Ref" : "InstanceType" }, "Arch" ] } ] },
"InstanceType" : { "Ref" : "InstanceType" },
"SecurityGroups" : [ {"Ref" : "WebServerSecurityGroup"} ],
"KeyName" : { "Ref" : "KeyName" },
"UserData" : { "Fn::Base64" : { "Fn::Join" : ["", [
"#!/bin/bash -v\n",
"yum update -y aws-cfn-bootstrap\n",
"function error_exit\n",
"{\n",
" cfn-signal -e 1 -r \"$1\" '", { "Ref" : "WaitHandle" }, "'\n",
" exit 1\n",
"}\n",
"yum update -y\n",
"yum install git -y\n",
"/sbin/service iptables stop\n",
"/sbin/service ip6tables stop\n",
"/sbin/chkconfig iptables off\n",
"/sbin/chkconfig iptables off\n",
"yum install git -y\n",
"/usr/bin/curl -L https://www.opscode.com/chef/install.sh | bash\n",
"cd /root/\n",
"/usr/bin/git git://github.com/opscode/chef-repo.git\n",
"/bin/mkdir -p /root/chef-repo/.chef\n",
"/bin/mkdir -p /etc/chef\n",
"/bin/mkdir /root/.aws\n",
"/bin/touch /root/.aws/config\n",
"/bin/echo '[default]' >> /root/.aws/config\n",
"/bin/echo 'region = ", {"Ref" : "AWS::Region" }, "' >> /root/.aws/config\n",
"/bin/echo 'aws_access_key_id = ", { "Ref" : "HostKeys" }, "' >> /root/.aws/config\n",
"/bin/echo 'aws_secret_access_key = ", { "Ref" : "SecretAccessKey" }, "' >> /root/.aws/config\n",
"/usr/bin/aws s3 cp s3://storage/admin.pem /root/chef-repo/.chef\n",
"/usr/bin/aws s3 cp s3://storage/chef-validator.pem /root/chef-repo/.chef\n",
"/usr/bin/aws s3 cp s3://storage/knife.rb /root/chef-repo/.chef\n",
"/usr/bin/aws s3 cp s3://storage/client.rb /etc/chef\n",
"/usr/bin/aws s3 cp s3://storage/json_attribs.json /etc/chef\n",
"/bin/cp -p /root/chef-repo/.chef/chef-validator.pem /etc/chef/validation.pem\n",
"/usr/sbin/ntpdate -q 0.europe.pool.ntp.org\n",
"/bin/echo '\nchef_server_url \"", { "Ref" : "ChefServerURL" }, "\"' >> /etc/chef/client.rb\n",
"/bin/echo '\nchef_server_url \"", { "Ref" : "ChefServerURL" }, "\"' >> /root/chef-repo/.chef/knife.rb\n",
"/usr/bin/chef-client\n",
"/opt/aws/bin/cfn-signal -e 0 -r \"ChefClient setup complete\" '", { "Ref" : "WaitHandle" }, "'\n"
]]}}
}
},
"WaitHandle" : {
"Type" : "AWS::CloudFormation::WaitConditionHandle"
},
"WaitCondition" : {
"Type" : "AWS::CloudFormation::WaitCondition",
"DependsOn" : "ChefClient",
"Properties" : {
"Handle" : {"Ref" : "WaitHandle"},
"Timeout" : "1200"
}
},
"ChefServer" : {
"Type" : "AWS::EC2::Instance",
"Metadata" : {
"Description" : "Bootstrap ChefServer",
"AWS::CloudFormation::Init" : {
"config" : {
"packages" : {
"yum" : {
"wget" : []
}
}
}
}
},
"Properties": {
"ImageId" : { "Fn::FindInMap" : [ "AWSRegionArch2AMI", { "Ref" : "AWS::Region" }, { "Fn::FindInMap" : [ "AWSInstanceType2Arch", { "Ref" : "InstanceType" }, "Arch" ] } ] },
"InstanceType" : { "Ref" : "InstanceType" },
"SecurityGroups" : [ {"Ref" : "WebServerSecurityGroup"} ],
"KeyName" : { "Ref" : "KeyName" },
"UserData" : { "Fn::Base64" : { "Fn::Join" : ["", [
"#!/bin/bash\n",
"cfn-init --region ", { "Ref" : "AWS::Region" },
" -s ", { "Ref" : "AWS::StackId" }, " -r ChefServer ", " -c orderby ",
" --access-key ", { "Ref" : "HostKeys" },
" --secret-key ", {"Ref" : "SecretAccessKey"}, " || error_exit 'Failed to run cfn-init'\n",
"yum update -y aws-cfn-bootstrap\n",
"function error_exit\n",
"{\n",
" cfn-signal -e 1 -r \"$1\" '", { "Ref" : "WaitHandle" }, "'\n",
" exit 1\n",
"}\n",
"yum update -y\n",
"/sbin/service iptables stop\n",
"/sbin/service ip6tables stop\n",
"/sbin/chkconfig iptables off\n",
"/sbin/chkconfig ip6tables off\n",
"#Install ChefServer package\n",
"cd /root/\n",
"/usr/bin/wget https://opscode-omnibus-packages.s3.amazonaws.com/el/6/x86_64/chef-server-11.0.10-1.el6.x86_64.rpm\n",
"/bin/rpm -ivh /root/chef-server-11.0.10-1.el6.x86_64.rpm\n",
"/usr/bin/wget https://s3.amazonaws.com/storage/default.rb\n",
"/bin/cp -f default.rb /opt/chef-server/embedded/cookbooks/runit/recipes/default.rb\n",
"#Configure ChefServer\n",
"su - -c '/usr/bin/chef-server-ctl reconfigure'\n",
"su - -c '/usr/bin/chef-server-ctl restart'\n",
"#AWS creds installation\n",
"/bin/mkdir /root/.aws\n",
"/bin/touch /root/.aws/config\n",
"/bin/echo '[default]' >> /root/.aws/config\n",
"/bin/echo 'region = ", {"Ref" : "AWS::Region" }, "' >> /root/.aws/config\n",
"/bin/echo 'aws_access_key_id = ", { "Ref" : "HostKeys" }, "' >> /root/.aws/config\n",
"/bin/echo 'aws_secret_access_key = ", { "Ref" : "SecretAccessKey" }, "' >> /root/.aws/config\n",
"#Upload files for client\n",
"/usr/bin/aws s3 cp /etc/chef-server/admin.pem s3://storage/\n",
"/usr/bin/aws s3 cp /etc/chef-server/chef-validator.pem s3://storage/\n",
"#Chef client and dirs for it\n",
"/usr/bin/curl -L https://www.opscode.com/chef/install.sh | /bin/bash\n",
"/bin/mkdir /root/.chef\n",
"/bin/mkdir /etc/chef\n",
"/bin/mkdir /etc/chef/cookbooks\n",
"/bin/mkdir /etc/chef/roles\n",
"#Knife client config files from S3\n",
"/bin/cp /etc/chef-server/admin.pem /etc/chef/client.pem\n",
"/usr/bin/aws s3 cp s3://storage/knife_admin.rb /root/.chef/knife.rb\n",
"#Roles and cookbooks from S3\n",
"/usr/bin/aws s3 cp s3://storage/roles/ /etc/chef/roles/ --recursive\n",
"/usr/bin/aws s3 cp s3://storage/cookbooks/ /etc/chef/cookbooks/ --recursive\n",
"#Cookbooks from community\n",
"/usr/bin/knife cookbook site download cron\n",
"/usr/bin/knife cookbook site download jenkins\n",
"/usr/bin/knife cookbook site download ntp\n",
"/usr/sbin/ntpdate -q 0.europe.pool.ntp.org\n",
"yum remove ruby -y\n",
"yum install ruby19 -y\n",
"#Unpack and move cookbooks\n",
"/bin/mv /root/*.tar.gz /etc/chef/cookbooks\n",
"for i in `/bin/ls /etc/chef/cookbooks/*.tar.gz`; do /bin/tar zxf $i -C /etc/chef/cookbooks/; /bin/rm -f $i; done\n",
"for i in `/bin/ls /etc/chef/cookbooks`; do /usr/bin/knife cookbook upload $i; done\n",
"#Upload cookbooks and roles\n",
"/usr/bin/knife cookbook upload * -c '/root/.chef/knife.rb'\n",
"/usr/bin/knife role from file /etc/chef/roles/*.rb\n",
"/bin/echo -e \"*/5 * * * * root /usr/bin/knife exec -E 'nodes.find(\\\"!roles:BaseRole\\\") { |n| puts n.run_list.add(\\\"role[BaseRole]\\\"); n.save}' -c '/root/.chef/knife.rb'\" >> /etc/crontab\n",
"/bin/echo -e \"*/5 * * * * root /usr/bin/knife exec -E 'nodes.find(\\\"env_role:master AND !roles:master\\\") { |n| puts n.run_list.add(\\\"role[master]\\\"); n.save}' -c '/root/.chef/knife.rb'\" >> /etc/crontab\n",
"/bin/echo -e \"*/5 * * * * root /usr/bin/knife exec -E 'nodes.find(\\\"env_role:slave AND !roles:slave\\\") { |n| puts n.run_list.add(\\\"role[slave]\\\"); n.save}' -c '/root/.chef/knife.rb'\" >> /etc/crontab\n",
"/opt/aws/bin/cfn-signal -e 0 -r \"ChefServer setup complete\" '", { "Ref" : "WaitHandle" }, "'\n"
]]}}
}
},
"WaitHandle" : {
"Type" : "AWS::CloudFormation::WaitConditionHandle"
},
"WaitCondition" : {
"Type" : "AWS::CloudFormation::WaitCondition",
"DependsOn" : "ChefServer",
"Properties" : {
"Handle" : {"Ref" : "WaitHandle"},
"Timeout" : "1200"
}
},
"WebServerSecurityGroup" : {
"Type" : "AWS::EC2::SecurityGroup",
"Properties" : {
"GroupDescription" : "Enable HTTP access via port 80 and SSH access",
"SecurityGroupIngress" : [
{"IpProtocol" : "tcp", "FromPort" : "80", "ToPort" : "80", "CidrIp" : "0.0.0.0/0"},
{"IpProtocol" : "tcp", "FromPort" : "8080", "ToPort" : "8080", "CidrIp" : "0.0.0.0/0"},
{"IpProtocol" : "tcp", "FromPort" : "443", "ToPort" : "443", "CidrIp" : "0.0.0.0/0"},
{"IpProtocol" : "tcp", "FromPort" : "22", "ToPort" : "22", "CidrIp" : { "Ref" : "SSHLocation"}}
]
}
},
}
```
Из template видно, что у нас объявлены *пять* параметров. Два из них имеют в себе значения по умолчанию – тип создаваемого *instance* (в данном случае это m1.small) и подсеть IP адресов, с которых будет разрешен **SSH**-доступ к узлу. При создании stack-а необходимо будет указать 3 **параметра** – ключ для SSH-доступа к узлам (создается отдельно в AWS Console), ключ доступа и секретный ключ (оба формируются при регистрации учетной записи доступа к AWS).
В **mapping**-ах описаны два типа instance, оба с архитектурой *64-bit*. А также, в AWSRegionArch2AMI – описаны ID виртуальных образов, которые соответствуют instance с ОС Amazon Linux (данные ID можно получить в AWS Console).
Далее, у нас описываются **ресурсы** Chef-сервера и Chef-клиента. В обоих случаях через раздел **Metadata**, прежде чем запускать команды из **User Data** раздела, устанавливается *wget* (на всякий случай, на самом деле образы Amazon Linux должны содержать такие пакеты). Создаваемые ресурсы определяются переменными *ImageId* и *InstanceType* (в данном случае это заданные ранее параметры, в данном случае Amazon Linux, m1.small и 64-bit архитектура). Далее идет основное тело ресурса – **User Data**. Она представляет собой тело bash-скрипта конфигурации, который исполняется пошагово после того, как наш instance инициализируется.
Вкратце, для узла, который будет **Chef-сервером** проводятся следующие действия:
* отключение iptables (дабы не возникали проблемы с drop-ом пакетов);
* установка Open Source Chef Server;
* подмена default.rb (да уж, баг Amazon Linux образов в том, что они представляются не как redhat, чем являются по сути, а как amazon, и сервис Chef-server не может полноценно работать);
* авто-конфигурация и перезапуск сервера;
* создание файла конфигурации для работы AWS консоли;
* загрузка файлов admin.pem и chef-validator.pem на хранилище (они понадобятся нам на клиенте);
* установка chef-client на узле (да-да, Chef-сервер не имеет своего knife);
* получение файлов client.pem и knife.rb для knife, работающего на сервере (эдакий starter-kit из первой части статьи);
* воссоздание структуры директории chef-repo, в которой хранятся наши cookbook-и, файлы ролей и т.п.;
* загрузка и установка cookbook-ов на сервер (наши cookbook-и находится в хранилище, а часть берется с community);
* загрузка и установка ролей на сервер;
* добавление периодического задания, которое будет каждые 5 минут опрашивать все узлы и устанавливать базовую роль на каждый новый.
Я понимаю, что это может выглядеть сумбурным и непонятным объяснением, однако на детальное рассмотрение каждой части скрипта ушло бы много места. Поэтому – если есть вопросы – смело пишите мне в ЛС или же в комментарии.
Возвращаемся к нашему template-у. Для узла, который будет **Chef-клиентом**, проводятся следующие действия:
* отключение iptables (дабы не возникали проблемы с drop-ом пакетов);
* установка Chef Client;
* создание файла конфигурации для работы AWS консоли;
* загрузка файлов конфигурации клиента с хранилища;
* добавление в конфигурацию клиента адреса Chef-сервера (он может изменятся даже при перезапуске образов, либо при запуске stack заново);
* добавление периодического задания для запуска Chef client.
Стоит отметить, что благодаря такой опции, как *json\_attribs*, мы можем создать метку для узла, которая будет определять его **роль** в инфраструктуре. Это сделано для того случая, когда среди Chef-клиентов могут быть узлы, принимающие различные инфраструктурные роли.
Следующие ресурсы – **WaitHandle** и **WaitCondition** – описывают условия, при которых процесс создания stack может быть приостановлен. Если WaitHandle получает сигнал об успешном завершении процесса в течении тайм-аута, указанного в WaitCondition – то процесс создания stack продолжается/завершается.
Следующий объявляемый ресурс – это **Security Group** – firewall для наших узлов. В группе описывается пробрасываемые порты и source address пакетов.
Последний блок – **Outputs** – служит для того, чтобы после успешного запуска stack и instance получить на выходе какие-либо переменные, интересующие нас. Например, доменное имя для того, чтобы получить доступ к instance.
В итоге мы получаем универсальный **template** и возможность «развернуть» нашу скромную инфраструктуру (если же интересует большее количество instance — используйте Auto-Scaling Group) исполнением одной команды в консоли управления AWS. Результат запуска можно посмотреть в разделе **CloudFormation**.
Что дальше? Дальше Вы получаете возможность контролировать узлы путем knife, cookbook-ов и ролей. Можно использовать *community cookbook*, писать свои, писать *wrapper*-ы к другим *cookbook*-ам. Возможностей много и зависит все от конечной задачи.
В этом цикле статей я постарался, пусть и поверхностно, описать процесс автоматизации управления парком ПК и взаимодействии с облачными ресурсами AWS. Надеюсь, для начинающих *DevOps* эти статьи будут интересны.
Если буду возникать вопросы и предложения – смело пишите в диалоги или комментарии к моим статьям. Спасибо всем, кто уделил время прочтению статей.
**До скорых встреч!**
**Ссылки**:
* Документация по AWS — [aws.amazon.com/documentation](http://aws.amazon.com/documentation/)
* AWS CloudFormation — [aws.amazon.com/documentation/cloudformation](http://aws.amazon.com/documentation/cloudformation/)
* AWS EC2 — [aws.amazon.com/documentation/ec2](http://aws.amazon.com/documentation/ec2/)
* AWS Sample Templates — [aws.amazon.com/cloudformation/aws-cloudformation-templates](http://aws.amazon.com/cloudformation/aws-cloudformation-templates/)
* AWS Console — [docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/getting-started.html](http://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/getting-started.html) | https://habr.com/ru/post/211050/ | null | ru | null |
# Внедряем оплату BTC куда угодно (Python)
Предыстория
-----------
Полгода назад взялся за один проект с возможностью оплаты биткойном. Так как проект делали на языке python, то и оплату хотелось реализовать на нем же. Сразу же взялся анализировать готовые решения, доступные библиотеки и Rest API Blockchain.com. С апи блокчейна я моментально обломался, так как их токен для использования апи довольно не просто получить.
Затем решил юзать различные библиотеки (block-io, bitcoinlib, blockchain и др.) После пару ночей попыток реализовать нормальную оплату, остановился на bitcoinlib, так как она более менее стабильно работала, и я спокойно переводил с одного кошелька на другой. Беда наступила когда появились первые 100 пользователей и вся оплата внезапно рухнула. Возможно я криво написал или что-то не так понял с работой библиотеки, но любые попытки восстановить работу оплаты были безуспешны, только если обнулять бдшку, но и так неизвестно сколько бы она продержалась.
В итоге решили оставить без BTC оплаты. Я опечалился и не связывался с оплатой биткойном полгода.
К чему я пришел
---------------
На днях я все-таки решил добить этот вопрос для себя, надеюсь кому-то еще пригодятся мои наработки.
Все начинается с **seed** фразы. Мнемоническая фраза (англ. Mnemonic phrase или Seed фраза) - это список слов, которые хранят всю информацию, необходимую для восстановления биткоин-кошелька. Существуют несколько стандартов генерации фраз BIP 32, BIP 39, BIP 44, и еще BIP 49. Самый распространенный - это BIP 44 (12 слов).
**Пример seed фразы:**
vivid area able second bicycle advance demand alpha flip stable drift route
Чтобы сгенерировать фразу будем использовать библиотеку **bipwallet**. Чтобы ее установить воспользуемся командой **pip install bipwallet**.
```
from bipwallet import wallet
# generate 12 word mnemonic seed
seed = wallet.generate_mnemonic()
print(seed)
```
Если мы хотим получить напрямую доступ к биткойн кошельку, то, зная фразу, можем сразу восставновить кошелек в blockhain.com:
https://login.blockchain.com/#/recover
Следующим шагом мы будем преобразовывать нашу seed фразу до получения нужного адреса кошелька биткойна.
Чтобы во всем не запутаться и знать какие данные мы должны получить, я использовал сайт https://iancoleman.io/bip39/
Генерация дочернего адреса кошелька для каждого пользователя:
-------------------------------------------------------------
Чтобы получить наш нулевой адрес Биткойн кошелька на основе seed фразы (12VeK1eRgPHRUikNLXq3Nuz99gS2S46QMD), нам нужно пройти всю цепочку преобразований. Методом проб и ошибок мне все-таки удалось получить адрес кошелька следующим кодом:
```
from bipwallet.utils import *
def gen_address(index):
# Наша seed фраза
seed = 'vivid area able second bicycle advance demand alpha flip stable drift route'
# Мастер ключ из seed фразы
master_key = HDPrivateKey.master_key_from_mnemonic(seed)
# Public key из мастер ключа по пути 'm/44/0/0/0'
root_keys = HDKey.from_path(master_key, "m/44'/0'/0'/0")[-1].public_key.to_b58check()
# Extended public key
xpublic_key = str(root_keys, encoding="utf-8")
# Адрес дочернего кошелька в зависимости от значения index
address = Wallet.deserialize(xpublic_key, network='BTC').get_child(index, is_prime=False).to_address()
rootkeys_wif = HDKey.from_path(master_key, f"m/44'/0'/0'/0/{index}")[-1]
# Extended private key
xprivatekey = str(rootkeys_wif.to_b58check(), encoding="utf-8")
# Wallet import format
wif = Wallet.deserialize(xprivatekey, network='BTC').export_to_wif()
return address, str(wif, 'utf-8')
print(gen_address(0))
```
Данная функция возвращает адрес кошелька и **wif** в зависимости номера. Максимальное число с которым удалось получить адрес это 999999999.
**wif (Wallet import format)** - это просто кодирование байтов ключа в кодировку Base58 + контрольная сумма. Он нам понадобится в дальнейшем при генерации транзакции.
Это все значит, что имея только одну seed фразу мы можем создать 1 млрд дочерних адресов. Каждому пользователю при регистрации мы будем выдавать новый адрес, через который он сможет оплачивать по BTC. Появляется ограничение на 1 млрд пользователей, но нам никто не запрещает использовать несколько seed фраз или генерировать каждому юзеру новую фразу, но тогда каждая оплата будет кидаться не в общий ваш кошелек, а по разным.
Проверка баланса и транзакции:
------------------------------
Теперь когда у каждого пользователя свой личный адрес биткойн кошелька, нужно проверить баланс этого адреса. Для этого мы будем обращаться к сайту Blockchain.com дабы получить нужную информацию.
```
import requests
# Адрес кошелька пользователя
wallet = '12VeK1eRgPHRUikNLXq3Nuz99gS2S46QMD'
# wallet = gen_address(0)
url = f'https://blockchain.info/rawaddr/{wallet}'
x = requests.get(url)
wallet = x.json()
print('Итоговый баланс:'+str(wallet['final_balance']))
print('Транзакции:'+str(wallet['txs']))
if wallet['total_received']==0:
print('баланс пустой')
```
Вот таким простым кодом мы можем получить всю информацию по балансу и транзакциях пользователя. Дальше все зависит от логики самого приложения.
Транзакции
----------
На данном этапе мы дали каждому пользователю свой адрес кошелька и знаем все транзакции с данным адресом, но этого недостаточно. Нам нужно чтобы мы могли отправить его же деньги обратно. Для этого воспользуемся библотекой **bit**. Чтобы ее установить воспользуемся командой **pip install bit**.
```
from bit import PrivateKey
# Приватный ключ из wif
my_key = PrivateKey(wif='L46ixenNSu8Bqk899ZrH8Y96t8DHqJ1ZyxzQBGFTbh38rLHLaPoY')
# Количество долларов перевода, можно поменять на btc
money=0.1
# Кошелек куда будут переведены деньги
wallet='17ya3bCpPioyPH8kAyFkEDBUqdjF6wwPxo'
# Коммисия перевода, если поставить слишком маленькую, то транзакцию не примут
# И чем больше коммисия, тем быстрее пройдет перевод
fee=2000
# Генерация транзакции
tx_hash = my_key.create_transaction([(wallet, money, 'usd')],fee=fee,absolute_fee=True)
print(tx_hash)
```
В итоге мы получили вот такую транзакцию:
0100000001fe64490fce5e85d5eb00865663a3d44f4108549fdb2840b086cfc781390d4a2d010000006a47304402202dc1496d28bb10d50d94d70870e2a79ea472c5960de8f7418bb30f9b96643efc02204691547c98edad3181a056bf6404601efe289200ba8e3073a2f5b7c0c7f4fec10121026516c551584b484ce3ca7bb71bbf24cce133bf40bdf4e2ce5a3936bc7e66a2abffffffff02e3020000000000001976a9144c83a20250ccb62ce2b3b1ea80c6082b634fdf9f88ac08f40200000000001976a9144c83a20250ccb62ce2b3b1ea80c6082b634fdf9f88ac00000000
Выглядит красиво, но что с этим делать?
Можно зайти на сайт https://www.blockchain.com/btc/pushtx
и вручную отправить эту транзакцию.
Также можем декодировать эту транзакцию и проверить все ли верно мы указали https://www.blockchain.com/btc/decode-tx
Но нам нужно это автоматизировать, поэтому напишем несколько строк:
```
import requests
url = 'https://blockchain.info/pushtx'
tx='0100000001fe64490fce5e85d5eb00865663a3d44f4108549fdb2840b086cfc781390d4a2d010000006a47304402202dc1496d28bb10d50d94d70870e2a79ea472c5960de8f7418bb30f9b96643efc02204691547c98edad3181a056bf6404601efe289200ba8e3073a2f5b7c0c7f4fec10121026516c551584b484ce3ca7bb71bbf24cce133bf40bdf4e2ce5a3936bc7e66a2abffffffff02e3020000000000001976a9144c83a20250ccb62ce2b3b1ea80c6082b634fdf9f88ac08f40200000000001976a9144c83a20250ccb62ce2b3b1ea80c6082b634fdf9f88ac00000000'
x = requests.post(url, data = {'tx':tx})
result = x.text
print(result)
```
Выполним пост запрос, если получаем ответ: **Transaction Submitted**. Это значит, что через несколько секунд транзакция появится в сети и деньги спишутся с пользователя.
Применение
----------
Ну чтож, написав всего несколько десятков строк, мы можем генерировать для каждого пользователя свой адрес кошелка, проверять его баланс, переводить биткойны с одного кошелька на любой другой.
Для демонстрации работы BTC оплаты, я напишу простенького телеграм бота, который будет выполнять роль клиента Blockchain.com, то есть вы сможете хранить в нем свои биткойны и от туда же переводить другим людям. Ссылка на исходники бота будут в конце.
Проверить работу бота можно тут: [**https://t.me/Blockchain\_client\_bot**](https://t.me/Blockchain_client_bot)
Задеплоил на heroku, так что надеюсь не будет падать)
### Функционал бота
### Регистрация пользователя
В качестве БД я использовал sqlite3 и создал одну таблицу пользователей:
```
import sqlite3
conn = sqlite3.connect("my.db") # или :memory: чтобы сохранить в RAM
cursor = conn.cursor()
cursor.execute("CREATE TABLE users (chatid INTEGER , name TEXT, balance INTEGER, btc_wallet TEXT, wif TEXT, btc_sent TEXT, state INTEGER)")
conn.commit()
```
При нажатии start мы регистрируем пользователя, генерируем для него адрес биткойн кошелька, wif и добавляем данные в БД:
```
sql = "SELECT COUNT(*) FROM users "
cursor.execute(sql)
user = cursor.fetchone()
address, wif= gen_address(user[0]+1)
sql_insert = "INSERT INTO users VALUES ({}, '{}', 0,'{}','{}','no',0)".format(message.chat.id,
message.chat.first_name,address,wif)
cursor.execute(sql_insert)
conn.commit()
```
### Проверка баланса
```
if message.text == '? Ваш баланс':
url = f'https://blockchain.info/rawaddr/{data[3]}'
x = requests.get(url)
wallet = x.json()
await bot.send_message(message.chat.id, f'''? *Итоговый баланс:* {format(wallet['final_balance'] / 100000000, '.9f')} BTC
*Всего получено:* {format(wallet['total_received'] / 100000000, '.9f')} BTC
*Всего отправлено:* {format(wallet['total_sent'] / 100000000, '.9f')} BTC
https://www.blockchain.com/ru/btc/address/{data[3]}''', parse_mode= "Markdown")
```
Получить BTC
------------
Для создания qr-кода я использовал библиотеку qrcode и на вход передал ранее сгенерированный адрес биткойн кошелька из БД.
```
if message.text == '? Получить BTC':
img = qrcode.make(data[3])
img.save('qr.jpg')
await bot.send_message(message.chat.id, f'''? Ваш адрес биткойн кошелька:
*{data[3]}*''', parse_mode= "Markdown")
await bot.send_photo(message.chat.id,photo=open('qr.jpg', 'rb'))
```
### Отправить BTC
```
try:
sum = float(message.text)
url = f'https://blockchain.info/rawaddr/{data[3]}'
x = requests.get(url)
wallet = x.json()
if sum + 10000 <= wallet['final_balance'] / 100000000:
try:
my_key = PrivateKey(wif=data[4])
# Коммисия перевода, если поставить слишком маленькую, то транзакцию не примут
# И чем больше коммисия, тем быстрее пройдет перевод
fee = 10000
# Генерация транзакции
tx_hash = my_key.create_transaction([(data[5], sum, 'btc')], fee=fee, absolute_fee=True)
print(tx_hash)
url = 'https://blockchain.info/pushtx'
x = requests.post(url, data={'tx': tx_hash})
result = x.text
sql = "UPDATE users SET state = {} WHERE chatid = {}".format(0, message.chat.id)
cursor.execute(sql)
conn.commit()
await bot.send_message(message.chat.id, result)
except Exception:
await bot.send_message(message.chat.id, "⚠ Ошибка при выолнении транзакции")
else:
await bot.send_message(message.chat.id, '⚠️ На вашем балансе недостаточно средств.')
except ValueError:
await bot.send_message(message.chat.id, '⚠️Неправильно введена сумма отправления, попробуйте еще раз')
```
Проверим через сайт, что транзакция отправилась:
Исходники и как запустить
-------------------------
Скачать исходники бота можно тут github.com/Lil-hack/blockchain-client
Склонировав репозиторий, устанавливаем необходимые пакеты:
**pip install -r requirements.txt**
Некоторые библиотеки у меня не заработали на windows, так что лучше сразу запускать на linux.
В файле **main.py** заменяем ваш **токен телеграм** бота:
```
# Ваш токен от BotFather
TOKEN = 'YOUR TOKEN'
```
В файле **btc\_core.py** заменяем на вашу **seed** фразу:
```
# Ваша seed фраза
seed = 'YOUR SEED'
```
И запускаем бота командой: **python main.py**
Работает на python 3.7.0 и выше. Бот написан за один вечер, так что просьба строго не судить ^^
Итого
-----
Как оказалось, все довольно не сложно, и в несколько десятков строк можно добавить оплату BTC в любой python проект. Я не профи в криптографии, так что скорее всего многие моменты упустил, но надеюсь кому-то эта статья будет полезна. | https://habr.com/ru/post/525638/ | null | ru | null |
# Как обновить October CMS до Laravel 6?
*Продолжаем рассматривать October CMS, вокруг которой мы в LOVATA построили разработку веб-проектов и в особенности интернет-магазинов. Сегодня мы подготовили для вас инструкцию по обновлению вашей текущей установки October до долгожданной версии 1.1.x с Laravel 6 “под капотом”.*
Прошло больше года с момента выхода шестой версии фреймворка Laravel. А некоторое время назад и October CMS, для которой мы разработали e-commerce-платформу Shopaholic, выпустила долгожданный релиз под номером 1.1.0 с поддержкой Laravel 6. Как вы, возможно, заметили, принцип нумерации версий тоже изменился, он стал лучше отражать текущее положение вещей.
Предвосхищая возможные комментарии по поводу актуальной мажорной версии Laravel, поясняю, что до сих пор October CMS базировался исключительно на LTS-релизах. Это кажется разумным выбором в свете того факта, что ранее имели место случаи сломанной обратной совместимости даже при повышении очередной минорной версии фреймворка.
Переход на Laravel 6
--------------------
### Общие сведения
Ядро October претерпело [много серьёзных изменений](https://github.com/octobercms/october/issues/4381), что и стало причиной достаточно длительного ожидания. При этом релиз Laravel 6 отмечен как LTS (Long Term Support), что означает увеличенный жизненный цикл и длительное сохранение актуальности.
Изменились некоторые из системных требований:
* минимально PHP 7.2, рекомендуется PHP 7.4 (версии, начиная с 7.0, также будут работать, но не смогут обновляться);
* минимально SQLite 3.7.11, рекомендуется 3.8.8+.
[Версия 1.1.0](https://github.com/octobercms/october/releases/tag/v1.1.0) была доступна в качестве тестового обновления с 16 августа, а релиз стабильной версии состоялся 7-го сентября.
### Установка October CMS v1.1.x “с нуля”
Для того, чтобы установить “чистый” October версии 1.1.x воспользуйтесь установкой с помощью Composer:
1. Выполнить команду `composer create-project october/october .`.
2. Открыть файл `config/cms.php`и активировать настройку `disableCoreUpdates`, которая отключит обновления ядра CMS через шлюз October: `'disableCoreUpdates' => true,`.
3. Завершить установку с помощью терминала, выполнив команду `php artisan october:install`.
Корректно установленный October версии 1.1.x в настройках админки не будет отображать свой номер.
Если после установки вы попытаетесь обновить ядро из админки не включив настройку `disableCoreUpdates`, то на неопределённый срок получите следующую картину.
### Обновление October CMS v1.0.x
Для того, чтобы обновить существующую установку October до ветки 1.1.x она должна быть изначально установленной с помощью Composer. Если это не так, то наиболее беспроблемное обновление будет выглядеть следующим образом (при наличии October уже установленной с помощью Composer сразу переходите к шагу 6):
1. Установить в отдельную директорию October CMS версии 1.469 с помощью команды `composer create-project october/october . "1.0.469"`.
2. Открыть файл `config/cms.php`и активировать настройку `disableCoreUpdates`, которая отключит обновления ядра CMS через шлюз October: `'disableCoreUpdates' => true,`.
3. Скопировать папки `plugins`и `themes`в эту директорию.
4. Применить миграции с помощью команды `php artisan october:up`.
5. Разрешить возникшие конфликты.
6. Поднять версии зависимостей в `composer.json`:\*
7. ```
"repositories": [
{
"type":"vcs",
"url":"https://github.com/octoberrain/composer-merge-plugin"
}
],
"require": {
"php": "^7.2",
"october/rain": "~1.1",
"october/system": "~1.1",
"october/backend": "~1.1",
"october/cms": "~1.1",
"laravel/framework": "~6.0",
"wikimedia/composer-merge-plugin": "dev-feature/composer-v2 as 1.5.0"
},
"config": {
"preferred-install": "dist",
"platform": {
"php": "7.2.9"
}
},
```
8. Если вы начинали с шага 6, следует убедиться, что шаг 2 выполнен.
9. Обновить зависимости с помощью команды `composer update`.
10. Применить миграции с помощью команды `php artisan october:up`.
*\*Обратите внимание на нестандартный* `wikimedia/composer-merge-plugin`*, это форк Люка Тауэрса (одного из основных разработчиков ядра October) для обеспечения совместимости с Composer v2.*
Поздравляем, теперь вам доступны самые последние возможности платформы October CMS!
### Затронутая функциональность
Как мы уже отмечали, переход на Laravel 6 глубоко затронул функциональность October CMS. Поэтому, некоторые части вашего кода также могут потребовать изменений:
* [Configuration files (/config/\*.php)](https://octobercms.com/support/article/RN-11#upgrade-config)
* [Environment variables (.env files)](https://octobercms.com/support/article/RN-11#upgrade-env)
* [Server configuration (.htaccess files)](https://octobercms.com/support/article/RN-11#upgrade-server-config)
* [Any packages made for Laravel](https://octobercms.com/support/article/RN-11#upgrade-laravel-packages)
* [Laravel package auto-discovery](https://octobercms.com/support/article/RN-11#laravel-package-autodiscovery)
* [Interacting with Cache repositories](https://octobercms.com/support/article/RN-11#upgrade-cache)
* [String-based primary keys in models](https://octobercms.com/support/article/RN-11#upgrade-string-keys)
* [Use of $guarded in models](https://octobercms.com/support/article/RN-11#guarded-in-models)
* [Wildcard event listeners](https://octobercms.com/support/article/RN-11#upgrade-wildcard-listeners)
* [Catch-all routing](https://octobercms.com/support/article/RN-11#catchall-routing)
* [Using Carbon directly](https://octobercms.com/support/article/RN-11#upgrade-carbon)
* [Using Jenssegers\Date directly](https://octobercms.com/support/article/RN-11#upgrade-jenssegers-date)
* [Using Symfony directly](https://octobercms.com/support/article/RN-11#upgrade-symfony)
* [Using League\Csv directly](https://octobercms.com/support/article/RN-11#upgrade-league)
* [Unit Testing](https://octobercms.com/support/article/RN-11#upgrade-unit-testing)
Также не забудьте обновить все установленные плагины до актуальных версий. Например, если у вас установлен RainLab.Translate, убедитесь, что его версия не ниже 1.7.3. С более ранними версиями вы столкнетесь с проблемой его использования.
Новая система версионирования
-----------------------------
Помимо поддержки Laravel 6, October перешла на новую, более подходящую для текущих реалий разработки этой CMS. Основное изменение — теперь в номер версии будет включён номер минорного релиза.
October CMS по-прежнему в «вечнозеленой» стадии, где версии различаются лишь номерами сборок. Это является результатом соглашения команды разработчиков, принятого с самого первого дня работы над проектом.
Предыдущая LTS-версия Laravel имела достаточно долгий срок жизни. На данный момент её использует множество сайтов. Поэтому необходим способ и далее предоставлять обновления безопасности для этих веб-сайтов, особенно если они не могут обновиться до последней версии CMS или PHP.
В итоге October CMS перешла к новой схеме управления версиями. В которой мажорный номер (v1) останется равным 1, чтобы отразить приверженность стабильности обновлений. Минорный номер (v1.x) теперь будет увеличиваться при выпуске обновлений, которые могут повлиять на зависимости (например, обновления фреймворка Laravel). Номер патча (v1.0.x) будет по-прежнему отражать текущие обновления или сборки, но будет сбрасываться каждый раз при изменении дополнительной версии.
Теперь будет три основных типа релизов этой CMS:
* *Develop* — версия, находящаяся в активной разработке;
* *1.0* — стабильный билд на базе Laravel 5.5 (ранее эта была ветка *master*);
* *1.1* — стабильный билд на базе Laravel 6.
Напоминаем, October CMS все ещё находится в «вечнозеленой» стадии. Поэтому даже после выхода минорного обновления все предыдущие версии лишаются обновлений, за исключением патчей критических уязвимостей безопасности. Так что мы рекомендуем всегда поддерживать вашу October CMS в наиболее актуальном состоянии. | https://habr.com/ru/post/531936/ | null | ru | null |
# Новое в Symfony 5.2: атрибуты PHP 8
> В преддверии старта [курса «Symfony Framework»](https://otus.pw/WMg5/) предлагаем будущим студентам и всем желающим посмотреть запись вебинара на тему [«Микрофреймворки: сравнение производительности Symfony и Symlex»](https://otus.pw/NKv3/).
>
> Также делимся переводом полезного материала.
>
>
---
В PHP 8 были добавлены новые интересные фичи, такие как [типы объединения](https://wiki.php.net/rfc/union_types_v2), [match-выражения](https://wiki.php.net/rfc/match_expression_v2) и [constructor property promotion](https://wiki.php.net/rfc/constructor_promotion). Однако наиболее востребованной новой фичей являются **встроенные атрибуты** (также называемые аннотациями).
Symfony 5.2 будет включать поддержку атрибутов PHP 8 для определения роутов и необходимых зависимостей. Если вы уже используете аннотации, переход будет бесшовным:
```
// ДО: аннотации определенные с помощью библиотеки Doctrine Annotations
use Symfony\Component\Routing\Annotation\Route;
class SomeController
{
/**
* @Route("/path", name="action")
*/
public function someAction()
{
// ...
}
}
```
```
// ПОСЛЕ: аннотации, определенные с помощью атрибутов PHP 8
use Symfony\Component\Routing\Annotation\Route;
class SomeController
{
#[Route('/path', name: 'action')]
public function someAction()
{
// ...
}
}
```
Тот же класс `Route` обеспечивает поддержку аннотаций Doctrine и атрибутов PHP, поэтому вам не нужно изменять импорт класса. Единственное необходимое изменение — обновить синтаксис аннотаций, который теперь выглядит так: `#[…]` Вот и все! Ваше приложение теперь использует нативные атрибуты PHP, и вы можете удалить зависимости, такие как `doctrine/annotations`, если вы не используете их где-либо еще.
Мы также добавили атрибут `#[Required]`, чтобы заменить аннотацию `@Required` и сообщить Symfony, что свойство/метод содержит требуемую зависимость:
```
use Symfony\Contracts\Service\Attribute\Required;
class SomeService
{
#[Required]
public Bar $bar;
#[Required]
public function setFoo(Foo $foo): void
{
// ...
}
}
```
PHP вступает в новую золотую эру с выпуском PHP 8, и Symfony будет полностью с ним совместим с первого дня. Эти атрибуты — только начало, и в ближайшие недели мы добавим еще больше (например, для валидации).
---
> [***Узнать подобнее о курсе***](https://otus.pw/WMg5/) ***«Symfony Framework».***[***Смотреть запись вебинара***](https://otus.pw/NKv3/) ***«Микрофреймворки: сравнение производительности Symfony и Symlex».***
>
>
---
[**ЗАБРАТЬ СКИДКУ**](https://otus.pw/6sRG/) | https://habr.com/ru/post/538482/ | null | ru | null |
# Повышаем безопасность стека web-приложений (виртуализация LAMP, шаг 4/6)
Настройка web-сервера Apache на работу с HTML+PHP5 файлами сетевой файловой системы (NFS)
=========================================================================================
В четвертом уроке [цикла статей о настройке стека web-приложений](http://habrahabr.ru/post/147864/) мы поговорим о сервере Apache.
Web-сервер Apache отвечает за предоставление доступа к динамическому контенту по HTTP или HTTPS протоколу. В этом примере мы установим и будем использовать web-сервер Apache2 + php5, а так же установим DocumentRoot на *vm**05:/exports**/html*, смонтировав его в */var/www/html*. Для этого мы введем следующие команды на нашем виртуальном сервере **vm02** с IP-адресом **192.168.1.11**.
Настройка NFS- клиента
----------------------
С помощью [yum-менеджера](http://www.cyberciti.biz/faq/rhel-centos-fedora-linux-yum-command-howto/) установим пакеты NFS-клиента:
```
# yum groupinstall "Network file system client"
```
Или чуть проще:
```
# yum install nfs-utils nfs4-acl-tools
```
Включим службы NFSv4-клиента:
```
# chkconfig rpcbind on
# chkconfig rpcidmapd on
# chkconfig nfslock on
```
### /etc/idmapd.conf настройки nfs-клиента
Отредактируем файл конфигурации nfs-клиента
```
# vi /etc/idmapd.conf
```
Убедитесь, что параметры выставлены в соответствии с доменным именем NFS-сервера:
```
Domain = cyberciti.biz
[Mapping]
Nobody-User = nobody
Nobody-Group = nobody
```
Сохраните и закройте файл. Запустим все службы NFS-клиента:
```
# /sbin/service rpcbind start
# /sbin/service rpcidmapd start
# /sbin/service nfslock start
```
Монтирование файловой системы
-----------------------------
Введите следующую команду
```
# showmout -e vm05
```
Или:
```
# showmout -e 192.168.1.14
```
Пример вывода команды:
```
Export list for v.txvip1:
/exports/html 192.168.1.10,192.168.1.11
/exports/static 192.168.1.10,192.168.1.11
```
Смонтируем */exports/html* файловую систему в */var/www/html*, введя следующую команду:
```
# /bin/mount -t nfs4 -orsize=32768,wsize=32768,intr,hard,proto=tcp,sync vm05:/exports/html /var/www/html/
```
Или:
```
# /bin/mount -t nfs4 -orsize=32768,wsize=32768,intr,hard,proto=tcp,sync 192.168.1.14:/exports/html /var/www/html/
```
### Монтирование файловой системы через /etc/fstab
Отредактируем /etc/fstab:
```
# vi /etc/fstab
```
Добавим следующую строку:
```
vm05:/exports/html /var/www/html nfs4 orsize=32768,wsize=32768,intr,hard,proto=tcp,sync
```
Сохраним и закроем файл. Убедимся, что netfs-служба включена:
```
# chkconfig netfs on
```
Убедимся, что пользователь apache видит наши файлы
```
# su - apache
$ ls /var/www/html/
$ exit
#
```
Обратите внимание, что root-пользователь или любой другой пользователь не видит */**var**/www**/html* из-за установленной нами политики безопасности. Только apache-пользователь должен получить доступ к DocumentRoot. Это наши настройки по умолчанию.
Установка программного обеспечения Apache
-----------------------------------------
[Установим пакеты Apache2](http://www.cyberciti.biz/faq/linux-install-and-start-apache-httpd/) через yum-менеджер:
```
# yum install httpd
```
### Установка php5 и необходимых модулей
Введите следующие команды, что бы установить php5, модули, предоставляющие доступ к mysql, модули работы с графическими файлами и все остальные, необходимые в работе вашего приложения модули:
```
# yum install -y php-pear php-common php-bcmath php-mbstring php-cli php-pdo php-php-gettext php-mcrypt php-gd php-xml php-pecl-apc php php-mysql php-xmlrpc
```
### Установка поддержки memcached для php5
Для того чтобы получить доступ к memcached-серверу, установленному на **vm03** необходимо установить php кэш- сервер:
```
# yum install -y php-pecl-memcache
```
### Настройка Apache
Отредактируем файл конфигурации сервера Apache */etc**/httpd**/conf**/httpd**.conf*:
```
# vi /etc/httpd/conf/httpd.conf
```
Добавьте или отредактируйте следующие настройки (DocumentRoot должен указывать на nfs-раздел, смонтированный в */**var**/www**/html*):
```
# Разрешить прокси-серверу коммуникации по локальной сети
Listen 192.168.1.11:80
# Безопасности по умолчанию во избежание утечки информации
ServerTokens Prod
ServerSignature Off
# Установка DocumentRoot
DocumentRoot "/var/www/html"
Indexes Includes FollowSymLinks SymLinksifOwnerMatch ExecCGI MultiViews
Options Indexes FollowSymLinks
AllowOverride All
Order allow,deny
Allow from all
```
Сохраните и закройте файл.
### Конфигурирование PHP5
PHP is a widely used server-side scripting language («*Москва,* *столица* *нашей* *родины»* *прим.**пер.*)
Отредактируем файл */**etc**/httpd**/conf**.d**/php**.conf* следующей командой:
```
# cat /etc/httpd/conf.d/php.conf
```
Приблизительный вывод команды:
```
# PHP is an HTML-embedded scripting language which attempts to make it
# easy for developers to write dynamically generated webpages.
LoadModule php5\_module modules/libphp5.so
LoadModule php5\_module modules/libphp5-zts.so
# Присобачиваем PHP-интерпретатор к файлам с расширением .php
AddHandler php5-script .php
AddType text/html .php
# Add index.php to the list of files that will be served as directory
# indexes.
DirectoryIndex index.php
# Uncomment the following line to allow PHP to pretty-print .phps
# files as PHP source code:
#
#AddType application/x-httpd-php-source .phps
```
Смотрите и читайте о том, [как защитить и оптимизировать PHP5](http://www.google.com/url?q=http%3A%2F%2Fwww.cyberciti.biz%2Ftips%2Fphp-security-best-practices-tutorial.html&sa=D&sntz=1&usg=AFQjCNFP7_prx70ldhVIyuhE4v9-mmDC6w) в дополнительной статье по теме (*или просите перевод, — прим.пер.*)
### Извлечение реальных IP для перенаправленных HTTP-запросов
Установим пакет **mod\_extract\_forwarded**, чтобы получить реальный IP источника направленного HTTP-запроса (подключаем EPEL-репозиторий):
```
# yum -y install mod_extract_forwarded package
```
Редактируем */etc/httpd/conf.d/mod\_extract\_forwarded.conf*:
```
# vi /etc/httpd/conf.d/mod_extract_forwarded.conf
```
Добавим или изменим настройку следующим образом:
```
## Accept real ip from our nginx reverse proxy at 192.168.1.1 ##
MEFaccept 192.168.1.1
```
Сохраним/закроем файл и перезапустим web-сервер:
```
# service httpd reload
```
### Настройка iptables для доступа к web-серверу
Отредактируйте файл */**etc**/sysconfig**/Iptables*, добавив следующие параметры (убедитесь, что они прописаны до окончательных LOG и DROP настроек INPUT-цепочки):
```
## разрешить доступ только из локальной сети ##
-A INPUT -m state --state NEW -p tcp -s 192.168.1.0/24 --dport 80 -j ACCEPT
```
Сохраняем, закрываем. [Перезапускаем iptables](http://www.google.com/url?q=http%3A%2F%2Fwww.cyberciti.biz%2Ffaq%2Fhowto-start-iptables-under-rhel-centos-linux%2F&sa=D&sntz=1&usg=AFQjCNFvFhqYFfxijENg-ua8KiJexDK4Ug):
```
# /sbin/service iptables restart
# /sbin/iptables -L -v -n
```
### Включаем Apache
[Запускам Apache2 web-сервер](http://www.cyberciti.biz/faq/restart-httpd/) следующей командой:
```
# chkconfig httpd on
# service httpd start
```
Врубаем браузер и ломимся на наш сервер:
```
http://192.168.1.11/
```
Примечания к MySQL и Memcached серверу
--------------------------------------
Если вам нужно использовать mysql в вашем приложении – IP-адрес **192.168.1.13** и tcp-порт **3306**:
```
/* Пример php-конфигурации приложения */
/* Имя БД для WordPress */
define('DB_NAME', 'foo');
/* MySQL database username */
define('DB_USER', 'bar');
/* MySQL database password */
define('DB_PASSWORD', 'mypassword');
/* MySQL hostname */
define('DB_HOST', '192.168.1.13');
```
Если вам нужен memcached-сервер – IP-адрес **192.168.1.12** и tcp-порт **11211**:
```
/* пример php-кода */
if ( isset($memcached_servers) )
$buckets = $memcached_servers;
else
$buckets = array('default' => array('192.168.1.12:11211'));
```
Или:
```
$config['Datastore']['class'] = 'myApp_MemCached;
$i = 0;
$i++;
$config['Misc']['memcacheserver'][$i] = '192.168.1.12';
$config['Misc']['memcacheport'][$i] = 11211;
$config['Misc']['memcachepersistent'][$i] = true;
$config['Misc']['memcacheweight'][$i] = 1;
$config['Misc']['memcachetimeout'][$i] = 1;
$config['Misc']['memcacheretry_interval'][$i] = 15;
```
* [Вводная часть](http://habrahabr.ru/post/147864/)
* [Шаг №1: Настройка / Установка: NFS файловый сервер](http://habrahabr.ru/post/148004/)
* [Шаг №2: Настройка / установка: сервер баз данных MySQL](http://habrahabr.ru/post/148077/)
* [Шаг №3: Настройка / Установка: Memcached сервера кэширования](http://habrahabr.ru/post/148488/)
* [Шаг №4: Настройка / Установка: Apache + php5 приложение веб-сервера](http://habrahabr.ru/post/148489/)
* [Шаг №5: Настройка / Установка: веб-сервер Lighttpd для статических активов](http://habrahabr.ru/post/148490/)
* [Шаг №6: Настройка / Установка: Nginx обратный (reverse) прокси-сервер](http://habrahabr.ru/post/148491/) | https://habr.com/ru/post/148489/ | null | ru | null |
# Юмор в Cisco Systems
Конфигурировал Cisco PIX 501 в режиме ROMMON. Забавно вышло.
`monitor> ping 192.168.1.2
Sending 5,100-byte 07642 ICMP Echoes to 192.168.1.2, timeout is 4 seconds:
AXXXXAXXXXXXXAAAXAAAAAXAAAAAAAAA!!!!!
Success rate is 100 percent (5/5)`
Очень понравилась эта шутка, когда пытался восстановить устройство. | https://habr.com/ru/post/91912/ | null | ru | null |
# Let's Encrypt и nginx: настройка в Debian и Ubuntu
Если вдруг вся эта история прошла мимо вас, [Let's Encrypt](https://letsencrypt.org/) — центр сертификации от некоммерческой организации ISRG, существующий [при поддержке EFF](https://www.eff.org/ru/deeplinks/2014/11/certificate-authority-encrypt-entire-web) и многих компаний, взявшей на себя миссию дать людям бесплатные SSL/TLS сертификаты для сайтов и серверов. Сертификаты от Let's Encrypt уже используются [на более чем 10 миллионах доменов](https://letsencrypt.org/stats/).
Кроме очевидной бесплатности у сертификатов от Let's Encrypt есть особое, отсутствующее у любых других коммерческих сертификационных центров, достоинство: если вы однажды получили сертификат от Let's Encrypt, то, при прочих равных, это навсегда. Не нужно раз в год-два вручную обновлять сертификаты. Не нужно вообще вспоминать что сертификаты где-то есть. Получил, настроил и забыл!
Внимательный читатель сразу захочет возразить: как же так, ведь известно что сертификаты выдаются со сроком действия в три месяца? Всё дело в автоматическом обновлении сертификатов, которое возможно при полном отсутствии действий со стороны человека.
Организации автоматического обновления сертификатов в статье уделено пристальное внимание, с тем чтобы вы могли в полной мере оценить это принципиальное преимущество Let's Encrypt.
Почему эта статья
-----------------
На сайте EFF есть [краткие инструкции по использованию Certbot](https://certbot.eff.org/), рекомендуемой программы для получения сертификатов, но они скорей рассчитаны на тех, кто заходит на свой сервер по SSH лишь по острой необходимости. Более [подробная документация тоже есть](https://certbot.eff.org/docs/using.html#), но пока всю ее прочитаешь и найдешь всё то, что действительно нужно знать… К тому же, в ней не рассмотрены некоторые важные стратегические вопросы использования сертификатов.
Очевидно, нужна короткая и понятная инструкция для тех, кто привычен к серверной консоли, но хочет во всём разобраться без излишних трат времени.
Содержание
----------
Из этой статьи вы узнаете...
1. Как установить и [настроить Certbot](#ustanovka-certbot) для регулярного использования.
2. Что требуется от nginx и [как настроить nginx для получения сертификатов](#podgotovim-nginx-k-polucheniyu-sertifikatov).
3. [Как получать сертификаты](#poluchaem-sertifikaty) и [как проверить полученный сертификат](#proverim-poluchennyy-sertifikat).
4. [Как установить сертификат](#ustanovka-i-ispolzovanie-sertifikatov) от Let's Encrypt в nginx.
5. Как автоматически [обновлять сертификаты](#prodlenie-sertifikatov).
Caveat emptor
-------------
*Всё знаете про SNI? [Читайте сразу про установку.](#ustanovka-certbot)*
В инструкциях ниже я исхожу из того что ваши сайты будут использовать SNI. Это расширение протокола TLS позволяет браузерам сообщить желаемое имя сайта до получения и проверки SSL сертификата от сервера. Благодаря SNI вы можете разместить сколько угодно сайтов за HTTPS на одном IP. Но не всё так просто — иначе бы зачем я об этом писал?
Есть ряд старых браузеров в принципе не поддерживающих SNI. В их число входят любые версии IE в [уже заброшенном Windows XP](https://support.microsoft.com/en-us/help/14223/windows-xp-end-of-support), встроенный браузер в [Android 2.3 и 2.2 из 2010 года](https://ru.wikipedia.org/wiki/%D0%98%D1%81%D1%82%D0%BE%D1%80%D0%B8%D1%8F_%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B9_Android), а также некоторые другие более экзотические браузеры и библиотеки типа [Java версии 1.6](http://bugs.java.com/view_bug.do?bug_id=6985179) и [Python до версии 2.7.9](https://docs.python.org/2/library/ssl.html#ssl.HAS_SNI).
Если вы всё-таки хотите чтобы ваш сайт открывался в IE в Windows XP, то одним отказом от SNI эта проблема не решается. Нужно специальным образом [подбирать шифры](https://github.com/client9/sslassert/wiki/IE-Supported-Cipher-Suites#internet-explorer-7-8-windows-xp), уже отказываясь от [forward secrecy](#perfect-forward-secrecy) и рискуя получить [низкую оценку от SSL Labs](https://www.ssllabs.com/ssltest/). Как можно догадаться, этот вопрос заслуживает отдельного обсуждения хотя бы потому что пользователям IE под XP можно посочувствовать — у них уже не открывается половина интернета!
Еще год назад от перехода на SNI вас могла бы удержать ограниченная поддержка этой технологии некоторыми поисковыми ботами типа Bing, но сейчас, с появлением десятков сайтов с бесплатными сертификатами от Cloudflare, что без SNI не открываются, бот Bing ([что легко проверить](https://www.bing.com/webmaster)), и [боты других основных поисковиков](https://www.ssllabs.com/ssltest/clients.html), пришли в согласие с реальностью. Сейчас за это можно не волноваться. Отмечу, что у Googlebot таких проблем не было никогда.
Другим поводом для волнений могут быть различные средства доступа к API вашего сайта. Если у вас давно есть API, то есть небольшой шанс что среди ваших клиентов есть какие-то, использующие устаревшие версии Java или Python. Если у вас таких нет, то не о чем переживать. Если же есть — мои соболезнования.
### Почему лучше рассчитывать на SNI?
1. Это просто. Вам не нужно постоянно держать в голове факты о выданных сертификатах. Для какого домена сертификат был выдан первым. К какому сертификату нужно [добавлять еще домены](#esli-nuzhno-dobavit-poddomen-ili-domen-v-sertifikat). И так далее… Ни о чем таком со SNI не нужно думать.
2. Секреты остаются секретами. Если у вас для всех доменов один сертификат, то любой сможет очень легко увидеть весь список, независимо от вашего желания. Если же для каждого сайта свой сертификат, то такой проблемы нет.
Например, так можно посмотреть домены в сертификате Тематических Медиа:
```
true | openssl s_client -showcerts -connect habrahabr.ru:443 2>&1 |
openssl x509 -text | grep -o 'DNS:[^,]*' | cut -f2 -d:
```
На момент написания статьи эта команда выведет подробный список всевозможных доменов ТМ:
```
habrastorage.org
api.geektimes.ru
api.habrahabr.ru
geektimes.ru
habrahabr.ru
id.tmtm.ru
lab.geektimes.ru
m.geektimes.ru
m.habrahabr.ru
special.geektimes.ru
special.habrahabr.ru
www.geektimes.ru
www.habrahabr.ru
```
Никакой секретности и никаких тайн. Вы этого хотите?
Установка Certbot
-----------------
Если вы читаете этот текст из будущего, когда Certbot уже есть в Debian stable и Ubuntu без обиняков и оговорок, то всё просто:
```
apt-get install certbot
```
Либо используйте `aptitude` или другой пакетный менеджер вашего дистрибутива.
### Установка в Jessie
Если у вас еще в ходу актуальный на конец 2016 года Debian stable "jessie", то всё лишь немного сложнее.
1. Нужно подключить Debian Backports, добавив строчку в `/etc/apt/sources.list`:
```
deb http://ftp.debian.org/debian/ jessie-backports main contrib non-free
```
2. Теперь можно устанавливать с указанием источника:
```
apt-get update
apt-get install certbot -t jessie-backports
```
(Раздел актуален пока только *stretch* не стал stable.)
### Ubuntu версий ниже 16.10 (yakkety)
```
sudo add-apt-repository ppa:certbot/certbot
sudo apt-get update
sudo apt-get install --upgrade letsencrypt
```
Дальше везде вместо `certbot` используйте `letsencrypt`.
### Другой дистрибутив
Если у вас какой-то другой дистрибутив, то дополнительные инструкции по установке есть [на официальном сайте Certbot](https://certbot.eff.org/). Если обходиться без пакетного менеджера, то обычно установка сводится к...
```
wget -O /usr/local/bin/certbot-auto https://dl.eff.org/certbot-auto
chmod +x /usr/local/bin/certbot-auto
ln -s /usr/local/bin/certbot-auto /usr/local/bin/certbot
```
Везде ниже вместо команды `certbot` можно использовать команду `certbot-auto`.
Certbot и webroot
-----------------
Мы будем получать сертификаты по методу *webroot* без перенастройки или остановки веб-сервера, под которым подразумевается nginx. Нам нужен какой-то каталог, в который `certbot` будет писать свои файлы, и какой должен быть доступен из сети удостоверяющему серверу согласно протокола [ACME](https://en.wikipedia.org/wiki/Automated_Certificate_Management_Environment).
Чтобы не писать каждый раз длинную строку из опций, а еще лучше — не вспоминать о них, запишем основные настройки в файл конфигурации, который `certbot` ожидает найти в `/etc/letsencrypt/cli.ini`:
```
authenticator = webroot
webroot-path = /var/www/html
post-hook = service nginx reload
text = True
```
Последняя директива нужна чтобы избавить нас от прелестей и красивостей ncurses, что нужно чтобы вы могли сравнить вывод команд здесь, в этой статье, и у себя.
Также нам нужно мягко перезагрузить nginx (без перерыва в обслуживании) при успешном обновлении сертификатов. Ничего не мешает в этот же момент перезапускать и другие сервисы вроде Postfix, использующие полученные сертификаты. Команды указываются через точку с запятой.
**Если точка с запятой вызывает ошибку**Если вы видите такую ошибку:
```
letsencrypt: error: Unexpected line 14 in /etc/letsencrypt/cli.ini: post-hook = service nginx reload; service postfix reload
```
То вам нужно обновить `python-configargparse`. Ошибка была [исправлена в 0.11.0](https://github.com/bw2/ConfigArgParse/commit/8a22034bbd0c74d55e869782d35efe939695fc73).
### Что будет делать Certbot
Ожидается что `certbot` будет создавать необходимые для проверки прав на домен файлы в подкаталогах ниже по иерархии к указанному. Вроде таких:
```
/var/www/html/.well-known/acme-challenge/example.html
```
Эти файлы должны будут быть доступны из сети на целевом домене по крайней мере по HTTP:
```
http://www.example.com/.well-known/acme-challenge/example.html
```
Для следующих проверок создадим какой-то такой файл:
```
mkdir -p /var/www/html/.well-known/acme-challenge
echo Success > /var/www/html/.well-known/acme-challenge/example.html
```
### Регистрация в Let's Encrypt
Регистрацию нужно сделать только один раз:
```
certbot register --email me@example.com
```
Здесь ничего сложного.
Подготовим nginx к получению сертификатов
-----------------------------------------
В общем случае для получения сертификата необходимо во всех блоках `server` добавить следующий блок до других блоков `location`:
```
location /.well-known {
root /var/www/html;
}
```
Понятно, что вписывать для каждого сайта такой блок явно — это моветон, потому создадим файл `/etc/nginx/acme` с содержанием блока выше.
```
# cat /etc/nginx/acme
location /.well-known {
root /var/www/html;
}
```
Затем для каждого домена и поддомена, для которых нужно получить сертификаты, в блоке `server` перед всеми блоками `location` укажем:
```
include acme;
```
Хосты-редиректоры (например, с голого домена на www) можно пропустить. ACME сервер обязан учитывать стандартную переадресацию. [Подробней об этом ниже.](#o-pereadresacii-s-kodami-301-i-302)
Перезагрузим nginx и проверим что наш тестовый файл виден:
```
# service nginx reload
# curl -L http://www.example.com/.well-known/acme-challenge/example.html
Success
```
После проверки лучше удалить тестовый файл — `certbot` любит удалять за собой всё лишнее, а такой файл будет мешать и вызывать сообщение об ошибке (Unable to clean up challenge directory).
```
rm /var/www/html/.well-known/acme-challenge/example.html
```
Теперь у нас всё готово чтобы [получить наш первый сертификат](#poluchaem-sertifikaty).
### О переадресации с кодами 301 и 302
Как было уже сказано, ACME сервер Boulder учитывает переадресацию [с кодами 301 и 302](https://github.com/letsencrypt/boulder/blob/d4902820ca212aeb0f4e14aea72a2b2d410d1a46/va/va.go#L217). В этом смысле не имеет значения где, в конечном счете, находятся файлы, требуемые для прохождения проверок. Переадресация возможна даже [на нестандартные порты](https://github.com/letsencrypt/boulder/blob/d4902820ca212aeb0f4e14aea72a2b2d410d1a46/va/va.go#L231), без ограничений по конечному протоколу HTTP или HTTPS. Сами [Let's Encrypt рекомендуют использовать переадресацию для создания единой точки проверки прав на домены](https://letsencrypt.org/docs/integration-guide/#picking-a-challenge-type).
Если вы можете получить эти файлы с помощью `curl` с ограничением в десять переадресаций, то и Boulder эти файлы увидит. Не должно быть [никаких ограничений по IP адресам](https://letsencrypt.org/docs/integration-guide/#lets-encrypt-ips).
```
curl --location --max-redirs 10 http://example.com/.well-known/acme-challenge/example.html
```
Это удобно если у вас сложная структура переадресаций между разными версиями сайтов. Должно быть достаточно подключить тот блок с `location` только на основном сайте для получения сертификатов для всех остальных.
```
$ curl --head --silent --location --max-redirs 10 http://somewhere.example.net/... | grep ^HTTP
HTTP/1.1 301 Moved Permanently
HTTP/1.1 301 Moved Permanently
HTTP/1.1 200 OK
```
Проверка всегда начинается с запроса по протоколу HTTP на 80 порту.
### Если у вас уже всё зашифровано...
Если у вас уже все сайты работают по HTTPS, то вся схема будет работать если у вас настроен переадресующий сервер на 80 порту, сохраняющий `$request_uri` в ответе.
Другое дело что можно сократить путь и подключить наш блок с `location` в умолчальном сервере для 80 порта, который делает переадресацию на HTTPS. Тогда не нужно будет ничего дописывать в конфиги отдельных сайтов.
Пример конфигурации такого переадресующего всё-подряд-на-HTTPS сервера:
```
server {
listen server.example.com:80 default_server;
include acme;
location / {
return 301 https://$host$request_uri;
}
}
```
Такой конфиг стоит определить в `/etc/nginx/conf.d/default.conf`, в стороне от конфигов конкретных сайтов.
Сервер запускаем явно на внешнем IP чтобы не перенастраивать Apache на другой порт. Если для вас это не проблема, то указание имени сервера в директиве `listen` можно пропустить.
### Если нужно получить сертификат для домена без сайта...
Типичный пример — сертификат для выделенных под SMTP или IMAP серверов, на которых вообще нет каких-то сайтов. Либо используйте универсальный переадресатор что выше, либо...
```
server {
server_name smtp.example.com imap.example.com;
listen server.example.com:80;
include acme;
location / {
return 404;
}
}
```
К сожалению, протокол ACME требует чтобы такой сервер был доступен во время каждой проверки. Это практически эквивалентно постоянной доступности, ввиду требования получения и обновления сертификатов без перезагрузки сервера. Не удаляйте такой конфиг после получения сертификата.
### Если у вас только Apache2...
Если у вас Apache2, а перейти на всеми любимый nginx возможности нет, то… Добавьте следующие строчки в `/etc/apache2/conf-available/certbot.conf`:
```
Alias /.well-known/ /var/www/html/.well-known/
Satisfy any
```
Затем
```
a2enconf certbot
mkdir -p /var/www/html/.well-known
service apache2 reload
```
И обязательно проверьте, так:
```
mkdir -p /var/www/html/.well-known/acme-challenge
echo Success > /var/www/html/.well-known/acme-challenge/example.html
curl -L http://localhost/.well-known/acme-challenge/example.html &&
rm /var/www/html/.well-known/acme-challenge/example.html
```
Существует много причин почему такая схема может у вас в Apache2 не заработать. Пары экранов текста не хватит чтобы описать их все. Не серчайте — статья про nginx.
Получаем сертификаты
--------------------
У Let's Encrypt есть [лимиты на количество обращений за сертификатами](https://letsencrypt.org/docs/rate-limits/), потому сначала попробуем получить необходимый сертификат в режиме для тестов:
```
certbot certonly --dry-run -d example.com -d www.example.com
```
В конце программа должна отчитаться об успешной работе:
```
The dry run was successful.
```
Теперь можно смело получать сертификат уже в самом деле. Не забудьте явно указать все необходимые поддомены, такие как www.
```
# certbot certonly -d example.com -d www.example.com
Saving debug log to /var/log/letsencrypt/letsencrypt.log
Starting new HTTPS connection (1): acme-v01.api.letsencrypt.org
Obtaining a new certificate
Performing the following challenges:
http-01 challenge for example.com
http-01 challenge for www.example.com
Using the webroot path /var/www/html for all unmatched domains.
Waiting for verification...
Cleaning up challenges
Generating key (2048 bits): /etc/letsencrypt/keys/0001_key-certbot.pem
Creating CSR: /etc/letsencrypt/csr/0001_csr-certbot.pem
IMPORTANT NOTES:
- Congratulations! Your certificate and chain have been saved at
/etc/letsencrypt/live/example.com/fullchain.pem. Your cert will
expire on 2017-04-01. To obtain a new or tweaked version of this
certificate in the future, simply run certbot again. To
non-interactively renew *all* of your certificates, run "certbot
renew"
```
Ура! С получением сертификата закончено!
### Если нужно добавить поддомен или домен в сертификат
Если вы вдруг забыли указать поддомен `www`, или вам нужно добавить другой домен или поддомен в сертификат (которых может быть [до 100 в одном сертификате](https://letsencrypt.org/docs/rate-limits/)), то это легко сделать после получения сертификата. Просто запустите команду еще раз, добавив требуемое имя:
```
certbot certonly -d example.com -d www.example.com -d shop.example.com
```
Вам будет безальтернативно предложено добавить этот домен в сертификат. Если хочется избежать вопросов, то можно сразу указать одобряющий такое поведение ключ:
```
certbot certonly --expand -d example.com -d www.example.com -d shop.example.com
```
Операцию можно повторять.
Проверим полученный сертификат
------------------------------
Убедимся что полученный сертификат — именно тот, что нам нужен:
```
# openssl x509 -text -in /etc/letsencrypt/live/example.com/cert.pem
Certificate:
Signature Algorithm: ...
Validity
Not Before: Jan 3 06:00:00 2017 GMT
Not After : Apr 3 06:00:00 2017 GMT
X509v3 extensions:
...
X509v3 Subject Alternative Name:
DNS:example.com, DNS:www.example.com
```
Или, если подробности вам не нужны:
```
cat /etc/letsencrypt/live/*/cert.pem | openssl x509 -text |
grep -o 'DNS:[^,]*' | cut -f2 -d:
```
Команда должна вывести список доменов в сертификате.
Установка и использование сертификатов
--------------------------------------
Certbot не перезаписывает сертификаты, а заменяет их ссылками на самые актуальные варианты сертификатов в определенном каталоге, одноименном с первым доменом сертификата (т.е. `CN`).
Давайте посмотрим что за файлы у нас есть:
```
# find /etc/letsencrypt/live/ -type l
/etc/letsencrypt/live/example.com/fullchain.pem
/etc/letsencrypt/live/example.com/chain.pem
/etc/letsencrypt/live/example.com/privkey.pem
/etc/letsencrypt/live/example.com/cert.pem
```
С этим знанием мы можем задать настройки SSL для nginx:
```
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;
```
Как видите, `cert.pem` нигде в конфиге не используется, и это не ошибка. Для nginx он не нужен.
Полный рабочий пример конфига:
```
server {
server_name www.example.com;
listen www.example.com:443 ssl; # default_server;
# выше можно добавить default_server для клиентов без SNI
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;
ssl_stapling on;
ssl_stapling_verify on;
resolver 127.0.0.1 8.8.8.8;
# исключим возврат на http-версию сайта
add_header Strict-Transport-Security "max-age=31536000";
# явно "сломаем" все картинки с http://
add_header Content-Security-Policy "img-src https: data:; upgrade-insecure-requests";
# далее всё что вы обычно указываете
#location / {
# proxy_pass ...;
#}
}
```
Конфиг для переадресации с голого домена без www:
```
server {
server_name example.com;
listen example.com:443 ssl;
access_log off;
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;
ssl_stapling on;
ssl_stapling_verify on;
resolver 127.0.0.1 8.8.8.8;
add_header Strict-Transport-Security "max-age=31536000";
expires max;
return 301 https://www.example.com$request_uri;
}
```
Подразумевается что вы используете какой-то локальный сервер для кеширования DNS запросов. Если это не так, то `127.0.0.1` в директиве `resolver` нужно заменить на IP используемого DNS сервера.
Настройки шифров и прочее подобное (`ssl_dhparam`, `ssl_session_cache`) лучше держать вне конфигов отдельных серверов.
Perfect Forward Secrecy
-----------------------
Если вы переживаете что Certbot может утащить ключи от вашего сертификата не смотря на [открытые исходные коды](https://github.com/certbot/certbot), а значит, в теории, какие-то злодеи смогут расшифровать весь трафик, то спешу вас успокоить. Если для соединения с вашим сайтом используются [шифры из семейств DHE и ECDHE](https://ru.wikipedia.org/wiki/Perfect_forward_secrecy), то утечка ключа не позволит расшифровать трафик. В этих шифрах ключ сертификата используется только для подтверждения подлинности, и не используется в качестве ключа для шифрования. Все современные браузеры поддерживают эти шифры.
Если для ECDHE на эллиптических кривых ничего не нужно делать, то для DHE можно было бы использовать усиленные параметры. [Лучше всего будет отключить DHE вообще.](https://habrahabr.ru/post/325230/)
**Если по какой-то причине без DHE вы не можете обойтись**Если по какой-то причине без DHE вы не можете обойтись, то сначала создадим параметры:
```
openssl dhparam -out /etc/ssl/private/dhparam.pem 2048
```
Потом пропишем в `/etc/nginx/conf.d/ssl_dhparam.conf` одной строкой:
```
ssl_dhparam /etc/ssl/private/dhparam.pem;
```
Продление сертификатов
----------------------
Сертификаты выдаются *на три месяца*. Не на полгода, не на год, а лишь на три месяца. Естественно это вызывает вопросы. Нужно ли проходить всю эту процедуру через три месяца? Нужно ли это делать всегда до искончания веков? Может стоит всё-таки вложиться в платный сертификат чтобы забыть об этом всем и не воспоминать пару лет?
Но нет, не спешите искать платежные средства! Как и было обещано в начале статьи, с обновлением сертификатов проблем нет.
Если у вас Debian, то нужно лишь дописать к вызову `certbot` в `/etc/cron.d/certbot` ключ `--allow-subset-of-names`:
```
# последняя строка в /etc/cron.d/certbot
# было certbot -q renew, а надо
certbot -q renew --allow-subset-of-names
```
Если у вас Debian и systemd, то [посмотрите эти инструкции](https://www.alexeykopytko.com/2017/free-ssl-from-letsencrypt/#part-359f55eef5e0cece).
Если у вас не Debian или нет файла, то добавим в `crontab` от `root` одну лишь строчку (`sudo crontab -e`):
```
42 */12 * * * certbot renew --quiet --allow-subset-of-names
```
Согласно рекомендаций Let's Encrypt следует пытаться обновить сертификаты два раза в день. Делать это нужно в случайным образом выбранную минуту того часа, а значит вам нужно заменить `42` в этой строке на другое число в диапазоне между `0` и `59`. Либо вы можете поступить так как это делается в `/etc/cron.d/certbot`.
### Как это работает
В этой команде ключ `--allow-subset-of-names` нужен чтобы Certbot пытался получить сертификаты для частичного набора доменов.
Например, были у вас на сервере были сайты *www.example.com* и *shop.example.com*, проходящие под одним сертификатом, но потом вы перенесли *shop.example.com* на другой сервер. Если такой ключ не указать, то Certbot упадет с ошибкой при попытке подтвердить владение *shop.example.com*, не получив для вас вообще никакого сертификата. Сертификат истечет и ваш сайт уйдет в оффлайн. С этим ключом вы всё же получите сертификаты хотя бы для частичного набора доменов, оставив ваши сайты в сети.
Вот и всё
---------
Если вам близки по духу `tee` и `sed`, то есть гораздо более короткая [инструкция по настройке связки Let's Encrypt и nginx](https://www.alexeykopytko.com/2017/free-ssl-from-letsencrypt/), при условии корректно настроенного `hostname`. Только копируй команды и вставляй.
---
Нашли ошибку? [Напишите в личку, пожалуйста.](https://habrahabr.ru/conversations/alexkbs/) | https://habr.com/ru/post/318952/ | null | ru | null |
# Анимация фотографии. Раскрытие рта
### Описание проблемы
В настоящее время существуют программы,позволяющие анимировать статические фотографии. Прежде всего, речь идёт об анимации лица и создании определённой мимики. Теоретически задача решается достаточно просто. Берём 3Д модель черепа и добавляем к ней основные лицевые мускулы. Фотография рассматривается как текстура, помещаем текстуру на 3Д модель и и проводим эксперименты с сокращениями определённых групп мышц. При реализации данной схемы возникает большое количество проблем. Одна из основных -- изменение текстуры при сокращении заданных мышц. Известны и удачные решения этой задачи, реализованные, в приложениях, ссылки на которые можно найти в Интернете. При этом существенно используются нейронные сети либо анимация осуществляется по определенным шаблонам. В данной статье рассматривается простейший случай, когда надо открыть рот на фотографии, сделанной анфас. Оказывается, что в этой ситуации достаточно обычной квадратичной интерполяции. Ссылка на ролик, где реализована данная схема помещена в конец статьи.
### Открывание рта тигром
Всю используемую технику проиллюстрируем с помощью фотографии головы тигра, который должен открыть рот. Оригинал представлен на Fig.1.
 Fig.1 Голова тигра с отмеченными точками Преобразования основаны на выборе 6 точек: три точки, определяющие положение верхней челюсти (точки r0,r1,r2) и три точки, задающие положение нижней челюсти (u0,u1,u2). Все точки отмечены крестиками на рисунке. Следует сразу отметить, что мы работаем с растровым изображением, представленным матрицей, и все рассматриваемые точки имеют целочисленные координаты,совпадающие с номерами строк и столбцов матрицы. Точки r0, r2 расположены в уголках рта. Схема точек представлена на Fig.2.
 Fig.2 Взаимное расположение точек в задаче моделирования раскрытия рта Кривые на Fig.2 строятся с помощью квадратичной аппроксимации. Каждая точка r имеет координаты Y,X в форме r[0] и r[1]. Например кривая, построенная по точкам r0,r1,r2, задается с помощью фрагмента кода
```
from scipy.interpolate import interp1d
List = [r0,r1,r2]
Args = [Pr[0] for Pr in List]
Values = [Pr[1] for Pr in List]
F1 = interp1d(Args,Values,kind='quadratic')
```
Функция F1(Y) вычисляет по номеру Y столбца матрицы значение координаты X (номер строки), в которой расположена точка кривой. Аналогично строится строится функция F2 для второй кривой, но теперь List=[r0,u0,u1,u2,r2]. С помощью этих двух функций строится новый список, состоящий из всех интервалов вида A,B матрицы расположенных между верхней и нижней челюстями (см. Fig.2. )
 Fig.3 Построение раскрытого рта С помощью указанных построений процедура раскрытия рта теперь выглядит следующим образом:
* Верхняя губа, заданная списком [r0,r1,r2], остаётся неподвижной
* Нижняя губа определяется списком [r0,r1',r2] путём смещения точки r1 вниз на величину Shift в положение r1'
* По списку [r0,r1',r2] строится функция F3(Y)
* Каждый интервал A,B в столбце матрицы изображения с номером Y смещается вниз на величину F3(Y)-F1(Y) и занимает положение A',B' (см.Fig.3)
Дополнив полученное изображение зубами и языком, получим результат:
 Fig.4 Голова тигра с раскрытым ртом Очевидно, каким образом данная процедура распространяется на анимацию раскрытия рта другими объектами.
Посмотреть на работу алгоритма можно здесь [Пример анимации](https://www.youtube.com/watch?v=LdUlLxSX51g) . | https://habr.com/ru/post/649465/ | null | ru | null |
# Как сжать загрузчик для STM8 до размера 8 байт в памяти FLASH
Со времени написания предыдущей статьи [” Как сжать загрузчик для STM8 до размера 18 байт в памяти FLASH”](https://habr.com/post/417493/) появились две версии загрузчика [STM8uLoader](http://nflic.ru/STM8/STM8uLoader/000.html) . Загрузчик STM8uLoader версии [$36](https://sourceforge.net/projects/ovsp) научился передавать управление прикладной программе по любому адресу в памяти RAM без участия хост-программы. Размер 18 байт загрузчика в памяти FLASH не изменился, в области OPTION Bytes размер увеличился до 53 байта (занял все доступное пространство).
В отдельную ветку выделилась версия [$0D](https://github.com/ovsp/STM8uLoader) загрузчика. Основное требование к этой версии: максимально сжать код. На сегодняшний день размер кода во FLASH памяти 8 байт в EEPROM памяти 35 байт.
Напомню аритектуру загрузчика STM8uLoader. Загрузчик состоит из хост программы boot\_PC и кода загрузчика boot\_uC в памяти STM8. Последний делится на код начального копировщика boot\_FLASH, находящийся в памяти FLASH, и код начального загрузчика boot\_EEPROM (или boot\_OPTION), находящийся в памяти EEPROM (или области OPTION Bytes).
После события RESET запускается начальный копировщик boot\_FLASH, переносит образ кода начального загрузчика boot\_EEPROM (или boot\_OPTION) в оперативную память RAM и передает ему управление. Начальный загрузчик настраивает UART передает хост программе байт с номером своей версии и, если не получает в течении таймаута от хост программы информации, передает управление прикладной программе во FLASH памяти. Либо переносит код прикладной программы из памяти EEPROM (или области OPTION Bytes) в память RAM и передает ему управление.
Если после отправки хост программе байта с номером версии начальный загрузчик принимает по UART дамп с кодом, то размещает его в памяти RAM и передает управление. Принятый дамп с кодом выполняет свою текущую задачу: чтение / копирование / стирание / запись ячеек STM8, передача управления по заданному адресу с предварительной инициализацией регистров ядра STM8, передача управления начальному загрузчику для смены текущего дампа в памяти RAM хост программой.
Начальный копировщик boot\_FLASH rev. $0D находится в адресах $8000…$8007 и полностью занимает векторы RESET и TRAP (Software interrupt). Все остальное пространство $8008…$9FFF памяти FLASH полностью доступно прикладной программе. Таблица векторов прерываний также находится на своем месте.
Рассмотрим код копировщика:
```
; начальный копировщик boot_FLASH версия $0D($88)
; копирует код начиная с конечного адреса $4087($4187)
; в стек до первого нулевого байта $00
; и передает управление коду
segment byte at 8000-8007 'bootF_rev0D'
; $8000 RESET Reset vector
dc.b $AE, $40 ; [AE 40 88] ldw X,#$4088
; dc.b $AE, $41 ; [AE 41 88] ldw X,#$4188
cycle:
; при первом вхождении в цикл
; команда push A затеняется командой ldw X,#$4088($4188)
push A ; [88]
decw X ; [5A]
; $8004 TRAP Software interrupt
ld A, (X) ; [F6]
jrne cycle ; [26 FB]
ret ; [81]
; $8008 TLI IRQ0 External top level interrupt
```
Здесь пересекается код двух команд: команды ldw X,#$4088 (ldw X,#$4188) и команды push A. При первом вхождении в цикл команда ldw X,#$4088 (ldw X,#$4188) выполняется, а команда push A не выполняется. Такое решение сэкономило один байт, но привело к сужению области хранения таблицы с образом кода начального загрузчика. Младший байт $88 адреса таблицы не позволяет разместить ее в области OPTION Bytes. Для модели STM8S103F3 доступны только адреса $4088 и $4188 в памяти EEPROM для размещения указанной таблицы. Для владельцев STM8S003F3 с EEPROM памятью 128 байт ($4000…$407F) и эти адреса не доступны. Для них все же есть лазейка.
Необходимо только поменять местами команды push A и decw X:
```
; начальный копировщик boot_FLASH версия $0D($5A)
; копирует код начиная с конечного адреса $405A($415A, $425A)
; в стек до первого нулевого байта $00
; и передает управление коду
segment byte at 8000-8007 'bootF_rev0D'
; $8000 RESET Reset vector
dc.b $AE, $40 ; [AE 40 5A] ldw X,#$405A для STM8S003F3
; dc.b $AE, $41 ; [AE 41 5A] ldw X,#$415A
; dc.b $AE, $41 ; [AE 42 5A] ldw X,#$425A
cycle:
; при первом вхождении в цикл
; команда decw X затеняется командой ldw X,#$405A($415A, $425A)
decw X ; [5A]
push A ; [88]
; $8004 TRAP Software interrupt
ld A, (X) ; [F6]
jrne cycle ; [26 FB]
ret ; [81]
; $8008 TLI IRQ0 External top level interrupt
```
Здесь при первом вхождении в цикл команда ldw X,#$405A($415A, $425A) выполняется, а команда decw X не выполняется.
Напомним, что событием RESET указатель вершины стека SP аппаратно инициализируется величиной $03FF. Стек растет в сторону уменьшения адресов. Для заполнения стека с хвоста таблицу с кодом начального загрузчика также будем читать с хвоста, отсюда команда decw X. Соответствующим образом расположен образ кода начального загрузчика в памяти EEPROM.
Для экономии отказались от счетчика цикла. Условились, что образ кода начального загрузчика будет иметь нулевой байт только в начале таблицы, а адрес передачи управления прикладной программе (который может иметь нулевой байт) вынесем за пределы таблицы. При каждой итерации читаем байт из таблицы и если он не равен нулю проталкиваем его в стек. Прочитанный нулевой байт – условие выхода из цикла.
Команда ret здесь означает передать управление по адресу, который содержится в двух байтах, которые последними попали в стек. Рассмотрим теперь код начального загрузчика:
```
; начальный загрузчик boot_EEPROM версия $0D($88)
segment byte at 4067-4089 'bootE_rev0D_88'
; segment byte at 417B-4189 'bootE_rev0D_88'
; $4067 terminator не переносится в RAM
dc.b $00 ; [00]
; $4068 ($03E0) {RAM END - 31}
; {$0400 - (bootE_go_adr - bootE_start) }
dc.w $03E2 ; [03 E2] $4067 - $3C85 = $03E2
; настраивает UART 96001N8
; отправляет BREAK и номер версии $0D
bootE_start:
; $406A ($03E2) {RAM END - 29}
ld A, #%00001101 ; [A6 0D]
ld UART1_BRR1, A ; [C7 52 32]
ld UART1_CR2, A ; [C7 52 35]
ld UART1_DR, A ; [C7 52 31]
; принимает первый дамп размером 243 байта
; и помещаеn его в стек
; $4075 ($03ED) {RAM END - 18}
bootE_rx_byte:
incw X ; [5C]
jreq bootE_exit ; [27 0C]
btjf UART1_SR, #5, bootE_rx_byte ; [72 0B 52 30 F8]
push UART1_DR ; [3B 52 31]
; clrw X ; [5F]
inc A ; [4C]
jrne bootE_rx_byte ; [26 F2]
; передает управление принятому дампу
; по адресу $02F1 (последние два байта в дампе $FE $02)
ret ; [81]
; $4084 ($03FC) {RAM END - 3}
bootE_exit:
jp [bootE_go_adr] ; [72 CC 40 88] RAM END
; адрес передачи управления прикладной программе
; $4088 не переносится в RAM
bootE_go_adr:
dc.w main_flash ; [80 08]
```
В скобках показаны адреса кода после копирования в стек. Первым идет нулевой байт, в память RAM не копируется. Следом идет адрес передачи управления начальному загрузчику, фактически это адрес следующей ячейки в памяти RAM. Эта пара в стек попадает, но потом затирается за ненадобность кодом очередного дампа из хост программы. Весь последующий код также копируется в стек, кроме пары с адресом передачи управления прикладной программе
Следом идет инициализация UART. Здесь во все три регистра помещается одно и то же число $0D. В первом случае это скорость UART (16000000/8/9600/16=13). Во втором случае это разрешение передачи/приема, здесь паровозом зацепилась однократная генерация события BREAK. В последнем случае это отправка хост программе версии загрузчика. Фактически хост программа получит два байта $00 (событие BREAK) и $0D (номер версии загрузчика) – это сигнал, что можно отправлять дамп с кодом.
Регистр A с содержимым $0D далее выполняет функции счетчика принятых байтов и считает он их с инкрементом до нуля, что эквивалентно 243 принятым байтам. Именно с таким размером хост программа должна отправлять дампы с кодом.
Индексный регистр X в начальном копировщике досчитал до $4068. Теперь он с инкрементом также будет считать до нуля (осталось еще 49048) отсчитывая время, отведенное на работу начальному загрузчику. За это время начальный загрузчик должен успеть принять дамп с кодом размером 243 байт поместить его дальше в стек и передать ему управление. Иначе управление будет передано прикладной программе и придется опять нажимать кнопку сброса и перезапускать хост программу.
После передачи управления принятому дампу код начального загрузчика остается в стеке и повторно принимает управление, когда хост программа решит заменить дамп с кодом. Любой принятый дамп с кодом располагается в стеке в адресах $02ED...$03DF и принимает управление по адресу $02F0. Код начального загрузчика располагается в стеке в адресах $03E0...$03FF, первоначально принимает управление по адресу $03E0, а при необходимости заменить дамп с кодом вызывается по адресу $03E8.
Команда передачи управления прикладной программе находится в стеке по адресу $03FB.
Ячейка с адресом $03FF может использоваться текущим дампом.
Целиком исходный код начального копировщика и начального загрузчика в STM8 версии $0D с таблицей в EEPROM памяти в адресах $4039...$405C ($4139...$415C, $4239...$425C).
**Файл bootF\_rev0D\_5A.asm:**
```
stm8/ TITLE “bootF_rev0D_5A.asm”
MOTOROLA
WORDS
.NOLIST
; #include "STM8S003F.inc"
#include "STM8S103F.inc"
.LIST
; начальный загрузчик boot_EEPROM версия $0D($5A)
segment byte at 4039-405C 'bootE_rev0D_405A' ; STM8S003F
; segment byte at 4139-415C 'bootE_rev0D_415A'
; segment byte at 4239-425C 'bootE_rev0D_425A'
; $403A9 ($03DD) {RAM END - 34} terminator переносится в RAM ?????
dc.b $00 ; [00]
; $403A ($03DE) {RAM END - 33}
; {$0400 - (bootE_go_adr - bootE_start - 1) }
dc.w $03E0 ; [03 E0]
; настраивает UART 96001N8
; отправляет BREAK и номер версии $0D
bootE_start:
; $403C ($03E0) {RAM END - 31}
ld A, #%00001101 ; [A6 0D]
ld UART1_BRR1, A ; [C7 52 32]
ld UART1_CR2, A ; [C7 52 35]
; $4044 ($03E8) {RAM END - 23}
ld UART1_DR, A ; [C7 52 31]
; принимает дамп размером 243 байта
; и помещаеn его в стек
; $40487 ($03EB) {RAM END - 20}
bootE_rx_byte:
incw X ; [5C]
jreq bootE_exit ; [27 0C]
btjf UART1_SR, #5, bootE_rx_byte ; [72 0B 52 30 F8]
push UART1_DR ; [3B 52 31]
clrw X ; [5F]
inc A ; [4C]
jrne bootE_rx_byte ; [26 F2]
; передает управление принятому дампу
; по адресу $02EF (последние два байта в дампе $EF $02)
; $4056 ($03FA) {RAM END - 5}
ret ; [81]
; $4057 ($03FB) {RAM END - 4}
bootE_exit:
jp [bootE_go_adr] ; [72 CC 40 5B] {RAM END - 1}
; ($03FF) RAM END может использоваться текущим дампом
; адрес передачи управления прикладной программе
; $405B не переносится в RAM
bootE_go_adr:
dc.w main_flash ; [80 08]
; начальный копировщик boot_FLASH версия $0D($5A)
; копирует код начиная с конечного адреса $405A($415A,$425A)
; в стек до первого нулевого байта $00
; и передает управление коду
segment byte at 8000-8007 'bootF_rev0D'
; $8000 RESET Reset vector
dc.b $AE, $40 ; [AE 40 5A] ldw X,#$405A ; STM8S003F
; dc.b $AE, $41 ; [AE 41 5A] ldw X,#$415A
; dc.b $AE, $42 ; [AE 42 5A] ldw X,#$425A
cycle:
; при первом вхождении в цикл
; команда dec X затеняется командой ldw X,#$405A($415A,$425A)
decw X ; [5A]
push A ; [88]
; $8004 TRAP Software interrupt
ld A, (X) ; [F6]
jrne cycle ; [26 FB]
ret ; [81]
; $8008 TLI IRQ0 External top level interrupt
; прикладная программа
segment byte at 8008 'main_flash'
main_flash:
jra * ; [20 FE]
; end
; bootF_rev0D_5A.asm
```
Целиком исходный код начального копировщика и начального загрузчика в STM8 версии $0D с таблицей в EEPROM памяти в адресах $4065...$4088 ($4165...$4188).
**Файл bootF\_rev0D\_88.asm:**
```
stm8/ TITLE “bootF_rev0D_88.asm”
MOTOROLA
WORDS
.NOLIST
; #include "STM8S003F.inc"
#include "STM8S103F.inc"
.LIST
; начальный загрузчик boot_EEPROM версия $0D($88)
segment byte at 4065-4088 'bootE_rev0D_88'
; segment byte at 4165-4188 'bootE_rev0D_88'
; $4065 terminator не переносится в RAM
dc.b $00 ; [00]
; $4066 ($03DE) {RAM END - 33}
; {$0400 - (bootE_go_adr - bootE_start) }
dc.w $03E0 ; [03 E0]
; настраивает UART 9600 1N8
; отправляет BREAK и номер версии $0D
bootE_start:
; $4068 ($03E0) {RAM END - 31}
ld A, #%00001101 ; [A6 0D]
ld UART1_BRR1, A ; [C7 52 32]
ld UART1_CR2, A ; [C7 52 35]
; $4070 ($03E8) {RAM END - 23}
ld UART1_DR, A ; [C7 52 31]
; принимает дамп размером 243 байта
; и помещаеn его в стек
; $4073 ($03EB) {RAM END - 20}
bootE_rx_byte:
incw X ; [5C]
jreq bootE_exit ; [27 0C]
btjf UART1_SR, #5, bootE_rx_byte ; [72 0B 52 30 F8]
push UART1_DR ; [3B 52 31]
clrw X ; [5F]
inc A ; [4C]
jrne bootE_rx_byte ; [26 F2]
; передает управление принятому дампу
; по адресу $02EF (последние два байта в дампе $EF $02)
; $4082 ($03FA) {RAM END - 5}
ret ; [81]
; $4083 ($03FB) {RAM END - 4}
bootE_exit:
jp [bootE_go_adr] ; [72 CC 40 87] {RAM END - 1}
; ($03FF) RAM END может использоваться текущим дампом
; адрес передачи управления прикладной программе
; $4087 ($4088 не) переносится в RAM
bootE_go_adr:
dc.w main_flash ; [80 08]
; начальный копировщик boot_FLASH версия $0D($88)
; копирует код начиная с конечного адреса $4087($4187)
; в стек до первого нулевого байта $00
; и передает управление коду
segment byte at 8000-8007 'bootF_rev0D'
; $8000 RESET Reset vector
dc.b $AE, $40 ; [AE 40] ldw X,#$4088
; dc.b $AE, $41 ; [AE 41] ldw X,#$4188
cycle:
; при первом вхождении в цикл
; команда push A затеняется командой ldw X,#$4088($4188)
push A ; [88]
decw X ; [5A]
; $8004 TRAP Software interrupt
ld A, (X) ; [F6]
jrne cycle ; [26 FB]
ret ; [81]
; $8008 TLI IRQ0 External top level interrupt
; прикладная программа
segment byte at 8008 'main_flash'
main_flash:
jra * ; [20 FE]
end
; bootF_rev0D_88.asm
```
Набросаем простейшую прикладную программу для выполнения во FLASH памяти STM8.
**Файл main\_rev0D.asm:**
```
stm8/ TITLE “main_rev0D.asm”
MOTOROLA
WORDS
.NOLIST
#include "STM8S103F.inc"
.LIST
; прикладная программа
segment byte at 8008-9FFF 'main_flash'
main_flash:
main_cycle:
; включаем светодиод
bset PB_DDR,#5 ;
bset PB_CR1,#5 ;
callr flash_delay
; выключаем светодиод
bres PB_DDR,#5 ;
bres PB_CR1,#5 ;
callr flash_delay
jra main_cycle
flash_delay:
ldw X, #35000
flash_delay_cycle:
decw X
jrne flash_delay_cycle
ret
end
; main_rev0D.asm
```
Прошьем программатором загрузчик в STM8. Подключаем плату к переходнику USB-TTL(UART). Запускаем пакетный файл [runSTM8uLoader.bat](http://nflic.ru/STM8/habr_loader/boot_PC_rev0D.zip). Нажимаем кнопку сброса на плате. Наблюдаем результат:
Код прикладной программы прошивается загрузчиком во FLASH память, устройство перезагружается. Начинает моргать светодиод.
Примеры исходных кодов дампов, которые хост программа посылает загрузчику для выполнения в памяти RAM:
**Файл Read\_128000v0D.asm:**
```
stm8/ TITLE "Read_128000v0D.asm"
MOTOROLA
WORDS
.NOLIST
#include "STM8S103F3P.inc"
.LIST
; размер дампа должен быть 243 байта
; при этом дамп будет находится в адресах $02EE...$03DF
; (затирает адеса $03DF:$03E0 с адресом перехода к начальному загрузчику)
; и вызываться по адресу $02F0
; вызвавший дамп начальный загрузчик находится в адресах $03E1...$03FE
; и повторно может быть вызван по адресу $03E1 (переключит скорость на 9600, надо A<=$0D SP<=$03E0 X<=$0000)
; или по адресу $03E9 (скорость не переключит, надо A<=$0D SP<=$03E8 X<=$0000)
; команда перехода к прикладной программе здесь $03FB
segment byte at 0000-00F2 'ram0'
dc.w $02F0
start:
; настраиваем UART1 на прием/передачу на скорости 9600, остальные настройки по умолчанию (8 бит, нет бита четности, 1 стоповый бит)
mov UART1_BRR2, #0 ; [35 00 52 33] для Fmaster=16/8=2МГц и 128000
mov UART1_BRR1, #1 ; [35 0D 52 32] для Fmaster=16/8=2МГц и 128000
mov UART1_CR2, #%00001100 ; [35 0C 52 35] UART1_CR2.TEN <- 1 UART1_CR2.REN <- 1 разрешаем передачу/прием
main_cycle:
wait_byte_adrH_cmnd:
btjf UART1_SR, #5, wait_byte_adrH_cmnd
ld A, UART1_DR
cp A, #$EF
JRUGT wait_byte_cmd_test ; Relative jump if Unsigned Greater Than
ld XH, A ; старший байт адреса в XH
ld UART1_DR, A ; эхо старшего байта адреса
tx_echo_adrH:
btjf UART1_SR, #7, tx_echo_adrH ; skip if UART1_SR.TXE = 0 TXE: Transmit data register empty
wait_byte_adrL:
btjf UART1_SR, #5, wait_byte_adrL
ld A, UART1_DR
ld XL, A ; младший байт адреса в XL
wait_byte_cntr:
btjf UART1_SR, #5, wait_byte_cntr
ld A, #$00
ld YH, A ;
ld A, UART1_DR
ld YL, A ; счетчик
; включаем светодиод
bset PB_DDR,#5 ;
bset PB_CR1,#5 ;
;
read_block_cycle:
ld A, (X)
ld UART1_DR, A
wait_tx:
btjf UART1_SR, #7, wait_tx ; skip if UART1_SR.TXE = 0 TXE: Transmit data register empty
incw X
decw Y
jrne read_block_cycle
; выключаем светодиод
bres PB_DDR,#5 ;
bres PB_CR1,#5 ;
jra main_cycle
; если первый байт $F0 и более
wait_byte_cmd_test:
cp A, #$F5 ; команда перехода
jreq echo_F5cmd
wait_tx_err:
mov UART1_DR, #$F1 ; неизвестная команда
btjf UART1_SR, #7, wait_tx_err ; skip if UART1_SR.TXE = 0 TXE: Transmit data register empty
jra main_cycle
echo_F5cmd:
ld UART1_DR, A ; эхо команды перехода
wait_tx_echo_F5cmd:
btjf UART1_SR, #7, wait_tx_echo_F5cmd ; skip if UART1_SR.TXE = 0 TXE: Transmit data register empty
; GoAdr
wait_byte_adrH_toM;
btjf UART1_SR, #5, wait_byte_adrH_toM
mov $03E7, UART1_DR
wait_byte_adrL_toM;
btjf UART1_SR, #5, wait_byte_adrL_toM
mov $03E8, UART1_DR
; SP
wait_byte_adrH_toSP;
btjf UART1_SR, #5, wait_byte_adrH_toSP
ld A, UART1_DR
ld XH, A
wait_byte_adrL_toSP;
btjf UART1_SR, #5, wait_byte_adrL_toSP
ld A, UART1_DR
ld XL, A
ldw SP, X
; Y
wait_byte_adrH_toY;
; btjf UART1_SR, #5, wait_byte_adrH_toY
; ld A, UART1_DR
; ld YH, A
wait_byte_adrL_toY;
; btjf UART1_SR, #5, wait_byte_adrL_toY
; ld A, UART1_DR
; ld YL, A
; X
wait_byte_adrH_toX;
btjf UART1_SR, #5, wait_byte_adrH_toX
ld A, UART1_DR
ld XH, A
wait_byte_adrL_toX;
btjf UART1_SR, #5, wait_byte_adrL_toX
ld A, UART1_DR
ld XL, A
; A
wait_byte_cntr_toA;
btjf UART1_SR, #5, wait_byte_cntr_toA
ld A, UART1_DR
jp [$03E7.w]
SKIP 59, $00
; ячейки для адреса перехода
dc.b $00
dc.b $00
end
; Read_128000v0D.asm
```
**Файл WriteBlocks\_FLASH\_128000v0D.asm:**
```
stm8/ TITLE "WriteBlocks_FLASH_128000v0D.asm"
MOTOROLA
WORDS
.NOLIST
#include "STM8S103F3P.inc"
.LIST
; размер дампа должен быть 243 байта
; при этом дамп будет находится в адресах $02EE...$03DF
; (затирает адеса $03DF:$03E0 с адресом перехода к начальному загрузчику)
; и вызываться по адресу $02F0
; вызвавший дамп начальный загрузчик находится в адресах $03E1...$03FE
; и повторно может быть вызван по адресу $03E1 (переключит скорость на 9600, надо A<=$0D SP<=$03E0 X<=$0000)
; или по адресу $03E9 (скорость не переключит, надо A<=$0D SP<=$03E8 X<=$0000)
; команда перехода к прикладной программе здесь $03FB
segment byte at 0000-00F2 'ram0'
dc.w $02F0
start:
; настраиваем UART1 на прием/передачу на скорости 9600, остальные настройки по умолчанию (8 бит, нет бита четности, 1 стоповый бит)
mov UART1_BRR2, #0 ; [35 00 52 33] для Fmaster=16/8=2МГц и 128000
mov UART1_BRR1, #1 ; [35 0D 52 32] для Fmaster=16/8=2МГц и 128000
mov UART1_CR2, #%00001100 ; [35 0C 52 35] UART1_CR2.TEN <- 1 UART1_CR2.REN <- 1 разрешаем передачу/прием
main_cycle:
wait_byte_adrH_cmnd:
btjf UART1_SR, #5, wait_byte_adrH_cmnd
ld A, UART1_DR
cp A, #$F0
JRUGE wait_byte_cmd_test ; Relative jump if Unsigned Greater or Equal
ld XH, A ; старший байт адреса в XH
ld UART1_DR, A ; эхо старшего байта адреса
tx_echo_adrH:
btjf UART1_SR, #7, tx_echo_adrH ; skip if UART1_SR.TXE = 0 TXE: Transmit data register empty
wait_byte_adrL:
btjf UART1_SR, #5, wait_byte_adrL
ld A, UART1_DR
ld XL, A ; младший байт адреса в XL
wait_byte_cntr:
btjf UART1_SR, #5, wait_byte_cntr ; количество блоков
mov $03FF, UART1_DR
write_block_cycle:
ldw Y, #64 ; размер блока
; unlock FLASH memory (writing the correct MASS keys)
mov FLASH_PUKR, #$56 ; Write $56 then $AE in FLASH_PUKR($5062)
mov FLASH_PUKR, #$AE ; If wrong keys have been entered, another key programming sequence can be issued without resetting the device.
; FLASH Block programming mode после записи блока последовательность надо повторить
mov FLASH_CR2, #$01
mov FLASH_NCR2, #$FE ;
; FLASH Word programming mode после записи слова последовательность надо повторить
; mov FLASH_CR2, #$40
; mov FLASH_NCR2, #$BF
; else FLASH byte programming
; включаем светодиод
bset PB_DDR,#5 ;
bset PB_CR1,#5 ;
; при записи блоками нет необходимости создавать буфер
; так как запись начинается только после копирования целого буфера
wait_rx_byte:
btjf UART1_SR, #5, wait_rx_byte
ld A, UART1_DR
ld (X), A
incw X
decw Y
jrne wait_rx_byte
mov UART1_DR, #$FA ; OK
wait_tx_OK_FA:
btjf UART1_SR, #7, wait_tx_OK_FA ; skip if UART1_SR.TXE = 0 TXE: Transmit data register empty
; выключаем светодиод
bres PB_DDR,#5 ;
bres PB_CR1,#5 ;
dec $03FF
jrne write_block_cycle
jra main_cycle
; если первый байт $F0 и более
wait_byte_cmd_test:
cp A, #$F5 ; команда перехода к boot_OPTION
jreq echo_F5cmd
wait_tx_err:
mov UART1_DR, #$F1 ; неизвестная команда
wait_tx_err_F1:
btjf UART1_SR, #7, wait_tx_err_F1 ; skip if UART1_SR.TXE = 0 TXE: Transmit data register empty
jra main_cycle
echo_F5cmd:
ld UART1_DR, A ; эхо команды перехода к boot_OPTION
wait_tx_echo_F5cmd:
btjf UART1_SR, #7, wait_tx_echo_F5cmd ; skip if UART1_SR.TXE = 0 TXE: Transmit data register empty
; GoAdr
wait_byte_adrH_toM;
btjf UART1_SR, #5, wait_byte_adrH_toM
mov $03E7, UART1_DR
wait_byte_adrL_toM;
btjf UART1_SR, #5, wait_byte_adrL_toM
mov $03E8, UART1_DR
; SP
wait_byte_adrH_toSP;
btjf UART1_SR, #5, wait_byte_adrH_toSP
ld A, UART1_DR
ld XH, A
wait_byte_adrL_toSP;
btjf UART1_SR, #5, wait_byte_adrL_toSP
ld A, UART1_DR
ld XL, A
ldw SP, X
; Y
wait_byte_adrH_toY;
; btjf UART1_SR, #5, wait_byte_adrH_toY
; ld A, UART1_DR
; ld YH, A
wait_byte_adrL_toY;
; btjf UART1_SR, #5, wait_byte_adrL_toY
; ld A, UART1_DR
; ld YL, A
; X
wait_byte_adrH_toX;
btjf UART1_SR, #5, wait_byte_adrH_toX
ld A, UART1_DR
ld XH, A
wait_byte_adrL_toX;
btjf UART1_SR, #5, wait_byte_adrL_toX
ld A, UART1_DR
ld XL, A
; A
wait_byte_cntr_toA;
btjf UART1_SR, #5, wait_byte_cntr_toA
ld A, UART1_DR
jp [$03E7.w]
SKIP 28, $00
; ячейки для адреса перехода
dc.b $00
dc.b $00
end
; WriteBlocks_FLASH_128000v0D.asm
```
**Файл Reset\_128000v0D.asm:**
```
stm8/ TITLE "Reset_128000v0D.asm"
MOTOROLA
WORDS
.NOLIST
#include "STM8S103F3P.inc"
.LIST
; размер дампа должен быть 243 байта
; при этом дамп будет находится в адресах $02EE...$03DF
; (затирает адеса $03DF:$03E0 с адресом перехода к начальному загрузчику)
; и вызываться по адресу $02F0
; вызвавший дамп начальный загрузчик находится в адресах $03E1...$03FE
; и повторно может быть вызван по адресу $03E1 (переключит скорость на 9600, надо A<=$0D SP<=$03E0 X<=$0000)
; или по адресу $03E9 (скорость не переключит, надо A<=$0D SP<=$03E8 X<=$0000)
; команда перехода к прикладной программе здесь $03FB
segment byte at 0000-00F2 'ram0'
dc.w $02F0
start:
; Инициализируем регистры и передаем управление на вектор RESET
ldw X, #$03FF
ldw SP, X
clrw X
clrw Y
clr A
jp $8000
SKIP 230, $00
end
; Reset_128000v0D.asm
```
В исходном коде хост программы эти же дампы присутствуют в следующим виде:
```
public readonly static byte[] Read_128000v0D = { 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE7, 0x03, 0xCC, 0x72,
0x31, 0x52, 0xC6, 0xFB, 0x30, 0x52, 0x0B, 0x72, 0x97, 0x31, 0x52, 0xC6, 0xFB, 0x30, 0x52, 0x0B,
0x72, 0x95, 0x31, 0x52, 0xC6, 0xFB, 0x30, 0x52, 0x0B, 0x72, 0x94, 0x97, 0x31, 0x52, 0xC6, 0xFB,
0x30, 0x52, 0x0B, 0x72, 0x95, 0x31, 0x52, 0xC6, 0xFB, 0x30, 0x52, 0x0B, 0x72, 0xE8, 0x03, 0x31,
0x52, 0x55, 0xFB, 0x30, 0x52, 0x0B, 0x72, 0xE7, 0x03, 0x31, 0x52, 0x55, 0xFB, 0x30, 0x52, 0x0B,
0x72, 0xFB, 0x30, 0x52, 0x0F, 0x72, 0x31, 0x52, 0xC7, 0xA5, 0x20, 0xF7, 0x30, 0x52, 0x0F, 0x72,
0x31, 0x52, 0xF1, 0x35, 0x0B, 0x27, 0xF5, 0xA1, 0xB4, 0x20, 0x08, 0x50, 0x1B, 0x72, 0x07, 0x50,
0x1B, 0x72, 0xF2, 0x26, 0x5A, 0x90, 0x5C, 0xFB, 0x30, 0x52, 0x0F, 0x72, 0x31, 0x52, 0xC7, 0xF6,
0x08, 0x50, 0x1A, 0x72, 0x07, 0x50, 0x1A, 0x72, 0x97, 0x90, 0x31, 0x52, 0xC6, 0x95, 0x90, 0x00,
0xA6, 0xFB, 0x30, 0x52, 0x0B, 0x72, 0x97, 0x31, 0x52, 0xC6, 0xFB, 0x30, 0x52, 0x0B, 0x72, 0xFB,
0x30, 0x52, 0x0F, 0x72, 0x31, 0x52, 0xC7, 0x95, 0x40, 0x22, 0xEF, 0xA1, 0x31, 0x52, 0xC6, 0xFB,
0x30, 0x52, 0x0B, 0x72, 0x35, 0x52, 0x0C, 0x35, 0x32, 0x52, 0x01, 0x35, 0x33, 0x52, 0x00, 0x35,
0xF0, 0x02 };
```
```
public readonly static byte[] WriteBlocks_FLASH_128000v0D = { 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE7, 0x03, 0xCC,
0x72, 0x31, 0x52, 0xC6, 0xFB, 0x30, 0x52, 0x0B, 0x72, 0x97, 0x31, 0x52, 0xC6, 0xFB, 0x30, 0x52,
0x0B, 0x72, 0x95, 0x31, 0x52, 0xC6, 0xFB, 0x30, 0x52, 0x0B, 0x72, 0x94, 0x97, 0x31, 0x52, 0xC6,
0xFB, 0x30, 0x52, 0x0B, 0x72, 0x95, 0x31, 0x52, 0xC6, 0xFB, 0x30, 0x52, 0x0B, 0x72, 0xE8, 0x03,
0x31, 0x52, 0x55, 0xFB, 0x30, 0x52, 0x0B, 0x72, 0xE7, 0x03, 0x31, 0x52, 0x55, 0xFB, 0x30, 0x52,
0x0B, 0x72, 0xFB, 0x30, 0x52, 0x0F, 0x72, 0x31, 0x52, 0xC7, 0x86, 0x20, 0xFB, 0x30, 0x52, 0x0F,
0x72, 0x31, 0x52, 0xF1, 0x35, 0x0B, 0x27, 0xF5, 0xA1, 0x95, 0x20, 0xBF, 0x26, 0xFF, 0x03, 0x5A,
0x72, 0x08, 0x50, 0x1B, 0x72, 0x07, 0x50, 0x1B, 0x72, 0xFB, 0x30, 0x52, 0x0F, 0x72, 0x31, 0x52,
0xFA, 0x35, 0xF2, 0x26, 0x5A, 0x90, 0x5C, 0xF7, 0x31, 0x52, 0xC6, 0xFB, 0x30, 0x52, 0x0B, 0x72,
0x08, 0x50, 0x1A, 0x72, 0x07, 0x50, 0x1A, 0x72, 0x5C, 0x50, 0xFE, 0x35, 0x5B, 0x50, 0x01, 0x35,
0x62, 0x50, 0xAE, 0x35, 0x62, 0x50, 0x56, 0x35, 0x40, 0x00, 0xAE, 0x90, 0xFF, 0x03, 0x31, 0x52,
0x55, 0xFB, 0x30, 0x52, 0x0B, 0x72, 0x97, 0x31, 0x52, 0xC6, 0xFB, 0x30, 0x52, 0x0B, 0x72, 0xFB,
0x30, 0x52, 0x0F, 0x72, 0x31, 0x52, 0xC7, 0x95, 0x5F, 0x24, 0xF0, 0xA1, 0x31, 0x52, 0xC6, 0xFB,
0x30, 0x52, 0x0B, 0x72, 0x35, 0x52, 0x0C, 0x35, 0x32, 0x52, 0x01, 0x35, 0x33, 0x52, 0x00, 0x35,
0xF0, 0x02 };
```
```
public readonly static byte[] Reset_128000v0D = { 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xCC, 0x4F, 0x5F, 0x90, 0x5F, 0x94, 0xFF, 0x03, 0xAE,
0xF0, 0x02 };
```
Предыдущая статья: [” Как сжать загрузчик для STM8 до размера 18 байт в памяти FLASH”](https://habr.com/post/417493/) .
Сайт с проектом <http://nflic.ru/STM8/STM8uLoader/000.html>.
Проект на <https://sourceforge.net/projects/ovsp>.
Проект на <https://github.com/ovsp/STM8uLoader>.
Прошу от читателей целевой критики и предложений по дальнейшему уменьшению кода. | https://habr.com/ru/post/418483/ | null | ru | null |
# Рецепты хорошей типографики
Судя по результатам [голосования](http://nobr.habrahabr.ru/blog/57137/), которое я проводил в своём блоге, большинство пользователей никак не типографируют тексты перед публикациями (НЛО не считается). Те, кто работают над текстами, в большинстве своём делают это вручную, поэтому я решил попробовать собрать воедино рецепты экранной типографики, дабы не забывать самому и напомнить другим. Не думаю, что статья будет чем‐то новым для опытных верстальщиков. Новички узнают, профи исправят :)
#### Содержание
1. Дефисы, тире, минусы и другие палочки
2. Кавычки и чёрточки
3. Скобки
4. Многоточие
5. Заголовки, списки
Прежде всего, хочу напомнить, что типографирование текста идёт с учётом национальных стандартов аудитории сайта (а не используемого языка). Например, на сайте клуба русских американцев рекомендуется использовать правила русской типографики, даже если все тексты написаны на английском. Также не следует забывать про внешний вид текста: иногда лучше пожертвовать правилами для того, чтобы текст смотрелся действительно красиво (касается, прежде всего, длинного тире).
Почему‐то не работает тег `…`, поэтому рекомендую набирать все коды символов вручную, а не копировать из текста.
#### 1. Дефисы, тире, минусы и другие палочки
**Дефис** (‐) — это символ U+2010 (`&#х2010;` в HTML).
| Правильно | Неправильно |
| --- | --- |
| * Кое‐кто
* Что‐нибудь
* Светло‐серый
* Никотинамидадениндинуклеотид‐фосфат (предпочтительней писать названия химических веществ так: никотинамидадениндинуклеотид фосфата)
* Сами‐Знаете‐Кто
| * Кое ‐ кто (отбивка пробелами)
* Светло-серый (другой, похожий по начертанию знак)
|
Слова с дефисом не разрываются, т. к. это не два разных слова, а одно, чаще всего с двумя корнями. Дефисом частицы ‐то, ‐либо, ‐ка, ‐таки, ‐нибудь, кое‐.
**Цифровая черта** (figure dash, ‒) — служит для разделения цифр в телефонных номерах. По своей сути это не минус, т.к. в номере телефона не производятся математические действия. Это символ U+2012 (`&#х2012;</code> в HTML).<br/>
<br/>
Правильное написание телефонных номеров:<br/>
<table>
<tr>
<th>Местные номера</th>
<th>С кодом города</th>
<th>С кодом страны и города</th>
<th>Мобильные телефоны</th>
</tr>
<tr>
<td>123‒45‒67<br/>
12‒34‒56<br/>
1‒23‒45<br/>
12‒34</td>
<td>(123) 123‒45‒67<br/>
(1234) 12‒34‒56<br/>
(12345) 1‒23‒45<br/>
(123456) 12‒34</td>
<td>+7 123 123‒45‒67<br/>
+7 (123) 123‒45‒67</td>
<td>8 123 456‒78‒90</td>
</tr>
</table><br/>
<br/>
Неправильное употребление:<br/>
<ul>
<li>123—45—67 (использование тире или других похожих по начертанию знаков)</li>
<li>123 45 67 (использование пробелов)</li>
<li>123 ‒ 45 ‒ 67 (отбивка пробелами)</li>
</ul>Также нельзя отбивать скобками код оператора в номере мобильного телефона: 8 (987) 123‒45‒67<br/>
<br/>
<b>Символ переноса</b> (мягкий дефис, <code>&shу;</code> в HTML) — расставляется в словах между слогами, отображается лишь в том случае, если слово попадает на конец строки. Этим символом рекомендуется разбивать длинные слова, которые могут не поместиться в конце строки, а также составные части химических веществ.<br/>
<br/>
Пример:<br/>
<ul>
<li>эн<code>&shу;</code>цик<code>&shу;</code>ло<code>&shу;</code>пе<code>&shу;</code>дия</li>
<li>никотин<code>&shу;</code>амид<code>&shу;</code>аденин<code>&shу;</code>динуклеотид фос<code>&shу;</code>фатa</li>
</ul><br/>
<br/>
<b>Короткое тире</b> (–, en dash, чёрточка шириной с букву «n», <code>&ndаsh;</code>) и <b>длинное тире</b> (—, em dash, чёрточка шириной с букву «M», <code>&mdаsh;</code>) — символы всем известны. Отмечу лишь, что в русской типографике рекомендуется использовать только длинное тире.<br/>
<br/>
Статья по теме: <a href="http://habrahabr.ru/blogs/typography/20588/">Чёрточки: только ли тире, минус и дефис?</a><br/>
<br/>
<h4>2. Кавычки и чёрточки</h4><br/>
<b>Кавычка</b> (", U+0022, <code>&#х0022;</code> в HTML) — в Unicode имеет название «QUOTATION MARK». Не является ни кавычкой, ни знаком дюйма, ни знаком угловых секунд. Используется в программировании. Разрешается использовать только в том случае, если нет возможности заменить на другой знак. Соответственно любое употребление в тексте ошибочно.<br/>
<br/>
<b>Апостро́ф</b> (', U+0027, <code>&#х0027;</code> в HTML) — на самом деле не является апострофом, в Unicode имеет название «APOSTROPHE», но его употребление в тексте также не рекомендуется. Этот знак не является знаком фута или знаком угловых минут. Используется в программировании.<br/>
<br/>
<b>UPD:</b> Спасибо хабраюзеру <a href="https://habrahabr.ru/users/qbit/" class="user_link">Qbit</a> за подробную справку:<blockquote>>Почему кавычка — не кавычка, а апостроф — не апостроф?<br/>
<br/>
По историческим причинам. Во времена телетайпов кодировки были маленькими, клавиатурные раскладки бедными. Один и тот же символ заменял открывающую английскую двойную кавычку, закрывающую английскую двойную кавычку, дюймы, etc. При переходе к Юникоду обратную совместимость не стали ломать, и клавиша рядом с Enter'ом по прежнему печатает этот «усреднённый» символ. А для правильных знаков введены самостоятельные code points. Популярность старого «искусственного» недосимвола вызвана тем, что он есть на клавиатурной раскладке, а правильных знаков — нет. Поэтому в быту (в аське, в постах, в SMS) используется «программистская кавычка». Но серьёзная типографика должна учитывать различия этих знаков — как разницу в семантике, так и во внешнем виде.<br/>
<br/>
Например, в гарнитуре Times New Roman эти символы имеют совершенно разное начертание:<br/>
открывающая английская двойная кавычка: «две-шестёрки-вверху»<br/>
закрывающая английская двойная кавычка: «две-девятки-вверху»<br/>
дюймы: два наклонных штриха в виде клина (не закорючки)<br/>
«программистская кавычка»: два прямых клина, утолщённых сверху.</blockquote><br/>
<br/>
<b>Французские кавычки</b> («ёлочки», U+00AB и U+00BB, <code>&lаquо;</code> и <code>&rаquо;</code> в HTML) — традиционные кавычки в русской типографике.<br/>
<br/>
<table>
<tr>
<th>Правильно</th>
<th>Неправильно</th>
</tr>
<tr>
<td><ul>
<li>Книга «Мёртвые души»</li>
<li>Образовательное учреждение «Центр образования «Звёздочка»</li>
<li>Толстый кот любил поговаривать: «Ребята, давайте жить дружно!»</li>
</ul><br/>
</td>
<td><ul>
<li>Книга Мёртвые души</li>
<li>Книга <i>Мёртвые души</i></li>
<li>Образовательное учреждение «Центр образования «Звёздочка»»</li>
<li>Толстый кот любил поговаривать: " Ребята, давайте жить дружно!"</li>
</ul><br/>
</td>
</tr>
</table><br/>
<br/>
<b>Немецкие кавычки</b> („лапки“, U+201E и U+201C, <code>&bdquо;</code> и <code>&ldquо;</code> в HTML) — традиционные вложенные кавычки, или кавычки второго рисунка.<br/>
<table>
<tr>
<th>Правильно</th>
<th>Неправильно</th>
</tr>
<tr>
<td>НИИ «РНЦ „РусАтом“»</td>
<td>НИИ „РНЦ «РусАтом»“</td>
</tr>
</table><br/>
<br/>
<b>Английские одинарные кавычки</b> (‘ма́рровские’, U+2018 и U+2019, <code>&lsquо;</code> и <code>&rsquо;</code> в HTML) — используются филологами при составлении словарей (как показывает практика, используются не всегда). В обычных текстах не употребляются.<br/>
<br/>
Правильно:<ul>
<li>От латинского <i>appellatio</i> ‘сообщение’</li>
<li>Со словом ‘посёлок’ не склоняется</li>
</ul><br/>
<br/>
<b>Апостро́ф</b> (’, U+2019, <code>&rsquо;</code> в HTML) — английская одинарная закрывающая кавычка. Чаще всего используется в иностранных именах и наращениях.<br/>
<table>
<tr>
<th>Правильно</th>
<th>Неправильно</th>
</tr>
<tr>
<td><ul>
<li>Д’Артаньян, Сара О’Коннор</li>
<li>Intel’овский процессор</li>
</ul><br/>
</td>
<td><ul>
<li>Д'Артаньян, Сара О'Коннор</li>
<li>Intel'овский процессор</li>
</ul><br/>
</td>
</tr>
</table><br/>
<br/>
<b>Знак ударения, аку́т</b> (´, U+0301, <code>&асutе;</code> в HTML) — используется только в тех случаях, когда от ударения зависит смысл слова. Также употребляется с любыми словами в букварях. Символ ставится после ударной гласной.<br/>
<br/>
Пример:<ul>
<li>Река у́же. Бо́льшая часть.</li>
</ul><br/>
<b>UPD:</b> Шрифты Verdana плохо обрабатывает знак ударения, но в версии 5.01 глюк с акутом исправлен. Если вы видите знак ударения не над ударной гласной, обновите шрифт. Можно <a href="http://www.fileqube.com/shared/eLtwskFC27386">скачать целиком</a> или <a href="http://www.microsoft.com/downloads/details.aspx?FamilyID=0ec6f335-c3de-44c5-a13d-a1e7cea5ddea&DisplayLang=en">обновить для Win</a>.<br/>
<br/>
<b>Знаки минуты и секунды, фута и дюйма</b> (′и ″, U+2032 и U+2033, <code>&рrimе;</code> и <code>&Рrimе;</code> в HTML) — употребляются только для обозначений угловых минут и секунд, в русской типографике футы и дюймы рекомендуется обозначать словами.<br/>
<table>
<tr>
<th>Правильно</th>
<th>Неправильно</th>
</tr>
<tr>
<td>59° 57′ 00″</td>
<td>59° 57' 00"</td>
</tr>
</table><br/>
<br/>
Статья по теме: <a href="http://habrahabr.ru/blogs/typography/25531/">Штрихи, штришки и штришочки</a><br/>
<br/>
<h4>3. Скобки</h4><br/>
Скобки, слава богу, не делятся на типографские и программистские. Но и тут не обошлось без определённых правил:<ul>
<li>После открывающей и перед закрывающей скобками пробелы не ставятся.</li>
<li>Знаки препинания ставятся после скобок, причём пробелом отделяется только тире.</li>
<li>Скобки не могут стоять в начале предложения, кроме случаев, когда перед скобками предложение закончилось. В таком случае после скобок ставится точка. Исключение: в оформлении пьес для описания состояний героев скобки могут стоять в начале предложения, но после указания актёра.</li>
<li>Если изменяется начертание текста внутри скобок, то начертание самих скобок остаётся неизменным.</li>
</ul><br/>
<table>
<tr>
<th>Правильно</th>
<th>Неправильно</th>
</tr>
<tr>
<td><ul>
<li>Сегодня в Москве (утром) шёл снег.</li>
<li>Река вышла из берегов (навсегда).</li>
<li>Кролики (такие животные) — это не только ценный мех…</li>
<li>Река вышла из берегов. (В этом году выпало рекордное количество осадков.)</li>
<li><b>КОТ:</b> (<i>осторожно</i>) Аня, что ты задумала?</li>
</ul><br/>
</td>
<td><ul>
<li>Сегодня в Москве ( утром ) шёл снег.</li>
<li>Кролики (такие животные)— это не только ценный мех…</li>
<li>(В этом году выпало рекордное количество осадков).</li>
<li><b>КОТ:</b> <i>(осторожно)</i> Аня, что ты задумала?</li>
</ul><br/>
</td>
</tr>
</table><br/>
<br/>
<h4>4. Многоточие</h4><br/>
Есть отличная статья: <a href="http://habrahabr.ru/blogs/typography/25135/">«Всё ли так просто с многоточием?»</a>. Правил и примеров употребления очень много, а в этой статье они достаточно освещены. Самое главное: используйте знак многоточия, а не три точки подряд. Обычная точка практически во всех шрифтах сделана жирнее и больше, чем точки в восклицательном или вопросительном знаке. Поэтому три точки по сравнению с многоточием смотрятся грязно и неряшливо.<br/>
<br/>
<h4>5. Заголовки, списки</h4><br/>
<h5>5.1. Заголовки</h5><br/>
Существует несколько правил оформления заголовков:<ul>
<li>Заголовок должен выделяться на фоне основного текста</li>
<li>Должна существовать чёткая иерархия: шрифт основного заголовка больше, чем шрифт любого вложенного</li>
<li>Нельзя подчёркивать заголовки, если они не являются ссылками</li>
</ul><br/>
<table>
<tr>
<th>Правильно</th>
<th>Неправильно</th>
</tr>
<tr>
<td><h4>Верхний заголовок</h4><br/>
<h5>Подзаголовок</h5><br/>
Основной текст.<br/>
</td>
<td><h5><u>Верхний заголовок.</u></h5><br/>
<h4><u>Подзаголовок.</u></h4><br/>
<h6>Основной текст.</h6><br/>
</td>
</tr>
</table><br/>
<br/>
<h5>5.2. Списки</h5><br/>
Как ни крути, маркированные списки вошли в нашу жизнь, и стали появляться не только на экранах компьютеров, но и в печатной продукции. Поэтому не стоит кривить душой и говорить, что «никаких буллитов в русской типографике нет». Раньше не было, но сейчас — есть. И мы стали свидетелями этого проникновения. Чтобы сверстать красивый маркированный список, следует придерживаться следующих рекомендаций:<ul>
<li>В любом списке должна соблюдаться иерархия. Для этого перед каждой строкой вложенного списка добавляется символ табуляции и меняется буллит или способ нумерации.</li>
<li>Начальным маркером или символом нумерации может служить любой знак. </li>
<li>Если список является продолжением незаконченного предложения, где каждая строка — альтернативное окончание, то в конце строки ставится точка с запятой.</li>
<li>Если строка списка является самостоятельным предложением, то в конце ставится точка.</li>
<li>Если строка списка состоит из множества символов, не объединённых в предложение, или слов, объединённых в словосочетание, то знак в конце строки не ставится.</li>
<li>В нумерованном списке после каждой цифры или буквы маркера ставится точка, независимо от уровня вложенности.</li>
</ul><br/>
Хабр предлагает только один тип нумерованного списка и один тип маркированного. Даже при таком раскладе можно добиться верного построения вложенных списков путём их смешивания:<br/>
<table>
<tr>
<td><ul>
<li>Lorem</li>
<li>Ipsum<br/>
<ol>
<li>Dolor</li>
<li>Sit</li>
</ol></li>
<li>Amet</li>
</ul><br/>
</td>
<td><ol>
<li>Lorem</li>
<li>Ipsum<br/>
<ul>
<li>Dolor</li>
<li>Sit</li>
</ul></li>
<li>Amet</li>
</ol><br/>
</td>
</tr>
</table><br/>
<br/>
Помимо привычных маркеров‐кругов и квадратов есть так называемый «чёрточный буллит»: <code>&#х2043;</code>, «⁃». Вообще не существует определённого правила, каким должен быть маркер, поэтому вы можете поставить даже картинку.<br/>
<br/>
<h4>Заключение</h4><br/>
Вот и подошёл к концу обзор основных рецептов грамотной вёрстки текста. Типографика, конечно, этим не ограничивается. Надеюсь что вся информация в одном месте сохранит вам время и нервы.<br/>
<br/>
Красивых вам текстов :)</div>` | https://habr.com/ru/post/57351/ | null | ru | null |
# Electron: от мотивации до публикации
*— Хотел бы я иметь приложение, которое умеет что-то такое, что мне надо. Жаль такого нет.
— А почему бы тебе его самому не написать?
— Это сложно, мне потребуется куча времени, чтобы понять теорию, приступить к практике и, скорее всего, ничего хорошего не выйдет. А вообще я frontend-разработчик и привык к HTML, CSS и JS. Этот стек не позволяет писать десктопные приложения.
— Electron!*
Уверен, большинство из нас обмениваются скриншотами. Существует большое количество приложений, способных делать скриншоты и как-то их редактировать (обрезать, рисовать что-то итд). Первые 3, которые мне приходят на ум: Joxy, Monosnap, Gyazo.
Казалось бы, чего ещё желать, когда есть задача и инструменты для неё? Но нет, всё не так просто.
Критерии, по которым я искал приложение
---------------------------------------
### Сохранение скриншота на сервере
Намного удобнее скинуть ссылку на скриншот, чем искать, куда приложение сохранило картинку, а потом прикреплять её. Конечно, некоторым не понравится идея хранить скриншоты неизвестно где. Но, с другой стороны, это позволяет быстро решить задачу — поделиться скриншотом. Такая модель поведения приложения мне вполне подходит.
### Рисование на скриншоте
По своему опыту могу сказать, что стрелка у меня присутствует чуть ли не на каждом скриншоте. Намного проще указать на какую-то деталь, чем писать что-то вроде: «Вот эта вот штука между...». Также в стандартный набор инструментов для рисования на скриншоте, по моему мнению, должны входить карандаш, прямоугольник и текст. При этом должна присутствовать возможность переместить, перевернуть и удалить нарисованный элемент.
### Версия для Linux
Как оказалось, не так и много приложений существует для этой задачи под Linux. Долгое время я использовал Gyazo и использовал бы дальше, если бы за «рисовашки» на скриншоте не приходилось платить.
### Из коробки
Приложение должно сразу работать так как мне надо. Я не хочу что-либо настраивать, регистрироваться на всяких Imgur и т. д. Просто хочу захватить скриншот, кропнуть, сохранить и поделиться ссылкой на него.
На протяжении года я периодически занимался поиском, но в итоге так и не нашёл приложение, удовлетворяющее моим требованиям.
Electron
--------
Время шло и я решил поближе познакомиться с Electron, чтобы понять что он умеет в принципе. Для тех кто не в курсе, Electron — технология, позволяющая создавать десктопные приложения, используя HTML, CSS и JavaScript.
И вот одной из демок демонстрировалось получение скриншота экрана пользователя. Это означало следующее:
* можно наконец-то написать приложение, отвечающее моим требованиям,
* появилась возможность познакомиться с новой для себя технологией на реальном проекте
### Куда идти, с чего начать, как оно работает
Эти вопросы я задаю себе каждый раз, когда хочу изучить что-то новое. Зачастую решение одно и то же — документация и какой-нибудь официальный «Get started». У Electron и с тем, и с другим всё в полном порядке. По крайней мере они так пишут на сайте проекта — «It's easier than you think». Это действительно так! Единственное, что надо сразу понять — приложение составляют 2 процесса: Main и Renderer. В Main мы работаем с окнами приложения, меню и т.д., а в Renderer у нас по-сути просто наша страничка.
#### С чего начать приложение
Сперва давайте создадим проект со следующей структурой:
— package,json
— main.js
— scripts
— renderer.js
Для начала нам этого вполне достаточно. В main.js у нас будет содержаться код, относящийся к главному процессу, а в scripts -> renderer.js рендер. Теперь необходимо создать само приложение. Для этого в main.js пишем:
```
const electron = require('electron');
const app = electron.app;
app.on('ready', () => {
createWindow();
});
app.on('window-all-closed', function() {
app.quit();
});
```
Что в итоге мы сделали? Мы подключили Electron, создали само приложение и описали два обработчика. Когда наше приложение будет готово, мы вызовем функцию создания нового окна. А в тот момент, когда все окна будут закрыты — убьём процесс приложения.
### Окно
Окей, теперь у нас есть сам процесс приложения. Теперь хотелось бы создать для него окно. Помните мы вызывали функцию createWindow();? Так вот пришла пора описать её.
```
function createWindow() {
appWindow = new BrowserWindow({
width: 300,
height: 300
});
};
```
Также необходимо подключить:
```
const BrowserWindow = electron.BrowserWindow;
```
Таким образом мы создали окно с заданными размерами. Очень просто, не правда ли?
У окна есть очень много свойств, методов и событий, связанных с ним. К примеру: title, icon, x, y, show(), hide(), close(), minimize, closed, restore, resize. Перечислять весь список бесполезно, поэтому вот ссылка на [Browser WIndow.](http://electron.atom.io/docs/api/browser-window/)
Но смотреть на пустое окошко не очень весело, да? Давайте подгрузим туда какую-нибудь простую страничку, которая содержит заголовок «Hello, world!». На уровне с `main.js` создаём файл index.html, который выглядит как самая обычная страница с `Hello, World!
=============`. Теперь только остаётся расширить функцию createWindow(), дописав
```
appWindow.loadURL(`file://${__dirname}/index.html`);
```
Запускаем наше приложение и видим:
Прям какая-то магия :) Но на секундочку о грустном.
### Дебаг
А как же собственно отлавливать ошибки? Всё максимально просто! Если ошибка в главном процессе, то она и вывалится вам в консоль, из которой вы запускаете приложение. Для ловли ошибок на самой странице мы будем использовать браузерную консоль. Да, именно так! Наше приложение по факту является страничкой, запущенной в браузере. Чтобы включить консоль давайте допишем в `createWindow();` строчку: `appWindow.webContents.openDevTools();`. Теперь при запуске приложения мы сразу же увидим консоль.
### Меню
Пока что всё что мы получили — это страничка в окне. Хочется как-то взаимодействовать с ней, к примеру, с помощью меню. Для этого в Electron есть специальный класс Menu. Поставим себе задачу — создать меню из одного элемента, при нажатии на который мы увидим системное всплывающее окно с тайтлом «Hello», сообщением: «Do you like this?» и вариантами ответа ['Yes', 'No'].
В main.js пишем:
```
const appMenu = require('./scripts/appMenu');
```
И создаём файл appMenu.js в директории scripts. Внутри себя он содержит следующий код:
```
const { shell } = require('electron');
const dialog = require('electron').dialog;
const newShotDialog = {
type: 'info',
title: 'Hello',
message: 'Do you like this?',
buttons: ['Yes', 'No']
};
module.exports = function appMenu(app, appWindow) {
return (
[
{
label: 'File',
submenu: [
{
label: 'Click me',
click() {
dialog.showMessageBox(newShotDialog, function(index) {
})
},
},
],
},
]
);
};
```
Идём далее. В `app.on('ready'...` дописываем:
```
const template = appMenu(app, appWindow);
const menu = electron.Menu.buildFromTemplate(template);
electron.Menu.setApplicationMenu(menu);
```
После запуска приложения мы увидим, что наше меню стало меньше и теперь содержит один элемент. Нажав на него, мы увидим следующее:
Собственно, мы решили поставленную задачу. Я мог бы посвятить всю статью созданию какого-либо абстрактного приложения (например, аудио-плеера), но тогда бы она вся состояла из «какой-то код» -> «результат», что, согласитесь, не очень интересно (лично я бы закрыл вкладку и пошёл писать что-то своё). Поэтому остальную часть статьи я уделю обзору некоторых важных, на мой взгляд, возможностей Electron на примере моего проекта --shots. Не беспокойтесь, приложение, создание которого я описал выше, можно найти по [ссылке](https://github.com/binjospookie/electron_example/)
Больше возможностей Electron на примере --shots
-----------------------------------------------
Согласитесь, не очень удобно каждый раз заходить в меню за инструментами которые вы часто используете (кроп, стрелка и т.д.). Решить данную проблему можно созданием панельки в области страницы, на которую их и вынести. Уже удобнее (не надо пробираться через громоздкое меню), но всё ещё не идеально (тянуться-то надо).
Можно лучше?
------------
Конечно, можно! Давайте использовать контекстное меню. Его будет вызывать клик правой кнопкой мыши в области окна. Такое меню будет состоять из пунктов, каждый из которых при нажатии вызовет свою функцию. К примеру, я разместил в этом меню следующие элементы:
* New shot
* Save
* Default
* Crop
* Arrow
* Rect
* Pen
* Blur
Этот набор инструментов даст воспользоваться практически всеми возможностями приложения.
### А может ещё лучше?
Да, можно ещё больше упростить доступ к возможностям приложения. Добьёмся мы этого при помощи хоткеев. Хоткеи регистрируются при помощи модуля globalShortcut и метода register. Необходимо помнить о различиях клавиатур в различных ОС. Так, например, слушать Command на Linux и Windows бесполезно. Поэтому разработчики Electron предлагают слушать CommandOrControl.
Хоткей в стандартном случае состоит из модификатора (CommandOrControl, Alt, Option...) и кода клавиши (0 — 9, A — Z, Space, Tab...). Стоит отметить, что он не обязательно должен состоять из комбинации двух клавиш. Может встретиться как одна, так и три (возможно и больше, но я не проверял). Например, для вызова модального окна со списком хоткеев я использую F2, а для того, чтобы увеличить масштабирование (zoom in) — `CommandOrControl+shift+Plus`. Мне пришлось добавить в эту цепочку shift, потому что иначе комбинация `CommandOrControl+shift+Plus` преобразуется в `сontrol+shift+=`.
### Общение процессов
Скорее всего, вы столкнётесь с необходимостью передать сообщение из одного процесса в другой (вызови мне такую-то функцию, к примеру). Для этого существуют ipcRenderer и ipcMain. Поставим себе простую задачу, чтобы разобраться как это работает. Допустим, при нажатии на пункт в меню мы хотим вызвать некую функцию, которая выведет нам alert. В обработчике клика пропишем что-то вроде `appWindow.webContents.send('show');`. Это означает следующее: при нажатии на пункт меню в renderer-процесс будет послано асинхронное сообщение по каналу 'show'. Также можно передать дополнительные аргументы, так что пусть наш alert выведет и переданный аргумент. Немного модифицируем написанное ранее `appWindow.webContents.send('show', 'content');`.
Теперь в renderer-процессе напишем:
```
ipcRenderer.on('show', (event, message) => {
alert(message) // Alerts 'content'
});
```
Как видите, всё очень просто!
### Tray
Полезно чтобы приложение не висело свёрнутым или, что хуже, было просто открыто. Для решения этой проблемы существует трей. И Electron даёт возможность поработать и с ним через класс Tray.
Что по сути такое приложение в трее? Это иконка и меню, вызываемое кликом правой клавиши мыши. Интересно подметить, что конструктор класса Tray принимает ровно один параметр — иконку. Если этот параметр отсутствует, то будет выброшена ошибка. Сначала это ничуть меня не удивило. Есть в конструкторе обязательный параметр, будь добр — передай. Чуть позже расскажу почему в дальнейшем обязательность этого параметра мне показалась странной.
### Иконка приложения
Давайте ещё немного поговорим об украшательствах. Как же наше приложение будет жить без иконки?! Добавляется она там же, где мы создавали новое окно, дописыванием в конец icon: \_\_dirname + '/icon.png'. Стоит отметить, что для Windows рекомендуется использовать иконку в формате \*.ico. Не страшно, ведь можно воспользоваться `os.platform()`.
### Моя страничка может достучаться до системы?
Да, конечно. На момент написания этой статьи актуальная версия Electron — 1.4.6, которая работает с NodeJS 6.5. К примеру, у --shots есть возможность локального сохранения файла. Для этого я использую `fs.writeFile`. И каждый раз перед таким сохранением проверяю есть ли директория для скриншотов (я назвал её «--shots»). Если она отсутствует, то просто её создаю.
Очень важно понимать, что ваше приложение на Electron — это не просто страничка в стандартном окошке, а вполне себе полноценное приложение.
Дополнительные возможности, которых нет в --shots
-------------------------------------------------
Естественно, работая над --shots, я использовал не все возможности Electron.
Например, можно загрузить своё приложение в AppStore и WindowsStore. Но --shots задумывался как приложение для LInux, поэтому особо я не влезал во все эти дебри публикации приложения. Но знаю, что для того чтобы выложить приложение в AppStore, необходимо его подписать. Каждый раз при сборке новой версии --shots я вижу этот warning в консоли и скрещиваю пальцы, чтобы он ни на что не повлиял в дальнейшем.
Ещё на сайте Electron можно встретить один замечательный пункт: «Automatic updates». Но и его я не смог прикрутить к --shots, т.к. открыл статью и увидел:
> «There is no built-in support for auto-updater on Linux, so it is recommended to use the distribution’s package manager to update your app».
Проще говоря, на LInux это не работает, ~~так что выкручивайтесь.~~ Например, я делаю запрос на сервер, который возвращает мне номер текущей актуальной версии и, если он не совпадает с версией приложения, вывожу сообщение с просьбой его обновить.
Подводные камни
---------------
Вроде, звучит всё круто, должен же быть подвох. Безусловно, есть некоторые неприятные моменты:
### Не всё кроссплатформенно
Это заметно даже на примере того же самого авто-апдейта. С прозрачным окном тоже не всё так просто. К примеру, на Linux нужно вбить в командную строку `--enable-transparent-visuals --disable-gpu`, а иначе никакого прозрачного окна вы не увидите. Согласитесь, приложение, которое после установки просит пользователя вбить что-то в терминал, уже начинает вызывать подозрение.
### Minimize
Очень много времени я потратил на разрешение проблемы с этим. Суть её такова: когда мы сворачиваем окно приложения — срабатывает событие minimize, и окно сворачивается. Вроде всё окей. Но приложение, висящее и в трее, и в доке — это уже странно. Поэтому хотелось бы отлавливать minimize и как-то убирать приложение из дока, оставляя лишь в трее. Для этого есть метод hide(). Пишем обработчик для minimize, вызываем hide — всё отлично. Затем я захотел добавить возможность из меню трея развернуть приложение обратно, и сразу же нашёл метод show(). Всё логично show/hide, но нет. Когда я пытаюсь развернуть приложение из трея, оно намертво зависает. Очень долго я думал, что упускаю что-то важное, но никаких ошибок в консоли не видел. В том числе, выводил само окно перед тем как вызывать show() — окно существует. В общем, отказался от подобного механизма работы приложения и решил попробовать вызвать hide(), когда окно приложения открыто. И да, чудо свершилось. Всё заработало ровно так, как надо. Несколько часов было потрачено на поиск ответа на вопрос: «Да почему ты не работаешь?», а в итоге решение мне подсказал Telegram. Я просто добавил в меню пункт «minimize to tray», а заодно и хоткей повесил на него.
В общем-то для меня подводные камни Electron’а закончились. Скорее всего, мне просто повезло…
Сборка
------
Настало время поговорить об ещё одной достаточно занимательной вещи — сборке. Electron даёт вам возможность собрать своё приложение и потом проинсталлировать его в различных ОС. Пользователь даже может не догадываться что вы написали своё приложение на web-технологиях. Давайте приступим!
### Стандартный подход
На официальном сайте в разделе документации есть 3 ссылки на инструкции по сборке (Linux, MacOS, WIndows). Так как приложение изначально затачивалось под Linux, то сначала я открыл ссылку для него. Первое системное требование сразу же напугало меня: «At least 25GB disk space and 8GB RAM» (не менее 25GB свободного места и 8GB оперативки). «Ладно, что поделать?» — подумал я и начал пытаться собрать приложение из примера. В итоге, сам процесс сборки занял у меня минут 20-30, более того, пользоваться компьютером было невозможно! Я очень рад, что не продолжил работать с этим сборщиком, т.к. узнал об одной пренеприятнейшей вещи: чтобы собрать приложение под какую-то ось, его надо собирать именно из под этой оси!
«Должен быть другой способ,» — говорил я себе. И да, действительно он существует.
### Electron builder
Достаточно было просто загуглить «electron builder» и перейти по первой ссылке. С тех самых пор я и использую это сборщик, и вот почему:
* сборка --shots для Linux стала занимать ~ минуту,
* из-под Linux можно собрать и .exe-шник (надо ещё Wine ставить, но ок),
* в процессе сборки можно смотреть мемы, ничего не тормозит.
Всё что вам остаётся — правильно дополнить свой проект.
#### Подготовка проекта
Этот процесс можно разбить на 2 этапа:
* подготовка иконок,
* подготовка package.json.
##### Иконки
Приложения, будучи установленными, хотят иметь свои иконки. Для этого в корневой директории проекта необходимо создать директорию «build», которую заполнить по следующей схеме:
— build
—— icons
——— 32x32.png
——— 32x32.png.ico
—— icon.icns
—— icon.ico
##### Package.json
Если вы просто попробуете собрать свой проект, то консоль начнёт плеваться в вас ошибками. Это происходит по той причине, что в файле должны содержаться стандартные строки:
* name,
* description,
* version,
* author.
Затем надо описать «build» и «scripts». Я намеренно быстро пробежался по этим двум пунктам, т.к. запоминать, что внутри, не требуется, да и вряд ли возможно, особенно если учесть, что есть огромное количество настроек (для «build»), которые могут зависеть от ОС, к которой он и собирается. Например, для Windows можно собрать portable-версию своего приложения и указать gif-файл, который будет отображаться в момент запуска.
В общем, рекомендую использовать именно Electron builder для сборки. Это сэкономит вам кучу нервов, поверьте.
Добавляем своё приложение на сайт Electron
------------------------------------------
Я считаю неплохой идеей рассказать о своём проекте на Electron на сайте самого Electron. Для этого достаточно послать им pull request, содержащий:
* отредактированный «\_data/apps.yml» (добавив ваше приложение в конец);
* иконку приложения 256px на 256px в формате png;
* сообщение о том, что вы связаны с проектом и все члены вашей команды согласны с тем, что приложение появится на сайте Electron.
Опять же, в этом нет ничего сложного. После отправки pr необходимо лишь запастись терпением и ждать когда его примут (в моём случае это заняло около недели).
Подробную инструкцию по добавлению можно найти [здесь](https://github.com/electron/electron.atom.io/blob/gh-pages/CONTRIBUTING.md#adding-an-app-or-project-to-the-site).
Подводя итог
------------
Нет, Electron не вытеснит нативщиков с рынка, так же как и React Native не убьёт Swift. Electron годится для создания простых приложений и является достаточно интересным проектом. И он чертовски прост! Мне удалось написать --shots, используя стандартный стек технологий frontend-разработчика:
* HTML
* CSS
* PostCSS
* JavaScript
* NodeJS
* PHP
Первый коммит был сделан 24 сентября 2016 года, а первый релиз вышел 17 октября того же года. Это значит, что спустя всего 24 дня я получил версию приложения, которую уже можно было использовать. Это достаточно быстро, если учесть, что я работаю и люблю отдыхать. Так что вперёд, всё в ваших руках!
Полезные ссылки
---------------
* [Официальный сайт](http://electron.atom.io)
* [Приложения на Electron](http://electron.atom.io/apps/)
* [Документация](http://electron.atom.io/docs/)
* [Atom discuss](https://discuss.atom.io/c/electron)
* [Electron builder](https://github.com/electron-userland/electron-builder)
* [Awesome Electron](https://github.com/sindresorhus/awesome-electron)
* [--shots на Github](https://github.com/binjospookie/--shots) | https://habr.com/ru/post/316880/ | null | ru | null |
# Porting packages to buildroot using the Zabbix example
The basics of porting
---------------------
Originally, Buildroot offers a limited number of packages. It makes sense — there is everything you need, but any other packages can be added.
To add a package, create 2 description files, an optional checksum file, and add a link to the package in the general package list. There are hooks at different stages of the build. At the same time, Buildroot can recognize the needed type of packages:
* General — the general type packages. In this case, all the commands for the Assembly/installation are written on your own.
* Autotools, CMake, Python, Lua, Perl, rebar, waf, meson, cargo(rust), go — easy to collect packages corresponding to their names.
* Virtual-packages. This is a type of package that allows you to add functionality provided by one or more packages. For example, OpenGL ES is an API for 2D and 3D graphics in embedded systems. The implementation of this API differs for Allwinner, Tech Sunxi, and Texas Instruments OMAP35xx platforms. Thus, libgles will be a virtual package, and sunxi-mali and ti-gfx will be suppliers.
* CKonfig — packages. These are packages that support configuration via kconfig. For example, busybox and Linux-kernel.
* Kernel module — a separate type of package for creating your own kernel modules.
* Asciidoc — a type of packages for rendering documents from aciidoc to PDF, HTML, and other formats.
There is also an infrastructure for building Linux-kernel-extensions and Linux-kernel-extensions.
All package types are well documented in the Buildroot guide. You can specify different options for getting package source — git, svn, local storage, and others. It's easy to get sources from GitHub. When porting the slim and GitHub packages, we will do so. There is a division into host packages (used only for building other packages that do not fall into the target file system) and packages that fall into the system being built. You can combine this functionality in one package.
Adding patches to the source packages
-------------------------------------
Sometimes, you need to apply patches to the source packages. There are two ways to do this:
* By adding the patch directly to the folder with the package description (${buildroot\_root\_dir}/package/${packagename}/${patch\_file}). It's not very handy if the package is not your own.
* By using the directory with global patches. In this case, the patches are stored in a separate folder in my external-tree.
It's the second method that I'll use. The path to the global folder is set in the section Build options → global patch directories. You can set multiple directories. Note that to apply patches to the kernel, it's recommended to use the item Kernel → custom kernel patches. There, you can specify a list of patches as an URL or path to a file/catalog.
You can apply a patch to a single version of the package, or all versions. The difference in the path to the patch:
* /// — apply a patch to a specific version of the package.
* / overlay the package on all versions of the package.
Package dependencies
--------------------
The important point is to describe the package dependency. It's described in two files: Config.in (Config.in. host for the hosting package) and ${packagename}.mk.
File Config.in (like Config.in.host) adds the package to the KConfig menu. You can set two types of dependencies: depends on and select.
Depends on — displays the package in the menu only if the specified dependencies are already enabled.
Select works the other way around: if our package is selected, enable the dependency.
Both these dependencies work to generate the build configuration (the .config file in the Buildroot root).
The dependency in the ${packagename}.mk file works differently. During the build stage, Buildroot generates a list of packages to build and install in alphabetical order. And it may happen that, to build a package **Apackage**, you need a **Bpackage** package, which will be built, but too late. An error occurs that stops the build.
So, to the file Apackage.mk you need to add this line:
```
APACKAGE_DEPENDENCIES = BPACKAGE
```
When the Buildroot reaches the **Apackage** build and sees the dependency, it'll first build the **Bpackage** package, and then return to Apackage.
Variables and commands
----------------------
When writing a make-file with the package build/install rules, you can use variables. The following variables helped me:
* $(@D) — the path to the package’s build directory (for example, output/build/demopackage)
* $TOPDIR — the root directory of the Buildroot
* $BASEDIR — the directory output
* \$HOST\_DIR, \$STAGING\_DIR, \$TARGET\_DIR — host fs, staging fs, and target fs build directories
* $BUILD\_DIR — the directory with unpacked and assembled packages
If you run make help in the Buildroot root, you can learn about additional commands:
```
Package-specific:
- Build and install and all its dependencies
-source - Only download the source files for
-extract - Extract sources
-patch - Apply patches to
-depends - Build 's dependencies
-configure - Build up to the configure step
-build - Build up to the build step
-show-info - generate info about , as a JSON blurb
-show-depends - List packages on which depends
-show-rdepends - List packages which have as a dependency
-show-recursive-depends - Recursively list packages on which depends
-show-recursive-rdepends - Recursively list packages which have as a dependency
-graph-depends - Generate a graph of 's dependencies
-graph-rdepends - Generate a graph of 's reverse dependencies
-dirclean - Remove build directory
-reconfigure - Restart the build from the configure step
-rebuild - Restart the build from the build step
```
Hooks
-----
You can add your hooks at different stages of the package build (from downloading to installation). For a complete list, [see the Buildroot documentation](https://buildroot.org/downloads/manual/manual.html#hooks).
For example, after installing the **demopackage** package, I want to run a command that copies the README from the build directory to target-fs. To do this, I make changes to demopackage.mk:
```
vim package/demopackage/demopackage.mk
```
First, I’ll set the section with the necessary commands
```
define DEMOPACKAGE_COPY_README
cp $(@D)/readme.txt $(TARGET_DIR)/var/demopackage/
endef
```
And now, I'll add these commands to execute in the post-install-target hook, which are executed after installing the package in target-fs:
```
DEMOPACKAGE_POST_INSTALL_TARGET_HOOKS += DEMOPACKAGE_COPY_README
```
This example is very artificial. I recommend paying attention to the section of the article, where I ported the Zabbix package, there is a real application.
Adding a package to the overlay
-------------------------------
For convenience, I keep all my developments in the overlay, which is easy to connect to the Buildroot. [Read more here](https://medium.com/@boozlachu/buildroot-part-2-bffac4b0b86a)
Let's look at the file structure in the overlay that is necessary for adding packages (only the necessary ones are shown):
```
../overlay/
├── package
│ ├── rodos
│ │ ├── 0001-MAKEFILE-FIX.patch
│ │ ├── Config.in
│ │ └── rodos.mk
│ └── zabbix
│ ├── Config.in
│ ├── zabbix-agent.service
│ ├── zabbix.hash
│ ├── zabbix.mk
│ └── zabbix-server.service
├── external.mk
├── Config.in
```
Package — the catalog with the packages themselves. There are 2 required files inside — Config.in and ${packagename}.mk. The first is responsible for displaying the KConfig package when configuring the Board; the second contains commands for building the package. It's also helpful to have a ${packagename}.hash file, which contains the hash of the archive with the package sources.
Porting RODOS
-------------
The practical part will start with a relatively simple package for the RODOS-5 thermal sensor. The source code is stored on the manufacturer's website as an archive.
To start, I will create the necessary files:
```
../overlay/
├── package
│ ├── rodos
│ │ ├── 0001-MAKEFILE-FIX.patch
│ │ ├── Config.in
│ │ └── rodos.mk
```
Config.in — the file from which the menu will be built.
```
[alexey@comp monitor]$ cat overlay/package/rodos/Config.in
config BR2_PACKAGE_RODOS
bool "rodos"
select BR2_PACKAGE_LIBUSB
help
rodos 5-6 usb termometer software
```
* The first line specifies the variable associated with the package.
* The second sets the type of variable. In my case, this is a Boolean variable. If you add a package to the Board configuration, its value will be equal to y. String variables are also often used for string parameter tasks (for example, paths).
* The third adds the LIBUSB package if the RODOS package is being built.
* The word help is followed by strings with help output on request.
```
################################################################################
#
# rodos 5 6
#
################################################################################
RODOS_SOURCE = RODOS5_6.tar.gz
RODOS_SITE = https://silines.ru/software/RODOS/RODOS-5_6
RODOS_DEPENDENCIES += libusb host-libusb
define RODOS_INSTALL_TARGET_CMDS
$(INSTALL) -D -m 0755 $(@D)/RODOS5_6 $(TARGET_DIR)/usr/bin/RODOS5_6
endef
define RODOS_BUILD_CMDS
$(TARGET_MAKE_ENV) $(MAKE) $(TARGET_CONFIGURE_OPTS) CFLAGS="$(TARGET_CFLAGS)" -C $(@D)
endef
$(eval $(generic-package))
```
**IMPORTANT** The names of the set variables must match the package name. In this case, RODOS.
This package is simple; let's look at the structure:
The last line, \$(eval $(generic-package)), sets the package type. In this case, we'll have to set the commands for building and installing the package ourselves. In the case of a cmake package (for example), these commands would follow the rules of the cmake file in the package.
RODOS\_SOURCE — the name of the archive that will be downloaded. If you don't specify it, Buildroot will generate the archive name for downloading by its own rules.
RODOS\_SITE — the address of the source with source codes. In this case, it's the website address, but it can also be the address of ftp, git, gitlab, svn, and others.
RODOS\_DEPENDENCIES — the dependencies required for building the package.
define RODOS\_INSTALL\_TARGET\_CMDS — the section with commands that are used to install the collected files in target-fs.
define RODOS\_BUILD\_CMDS — commands with package compilation rules. It's important to pay attention to the use of variables.
Special attention should be paid to the 0001-MAKEFILE-FIX.patch file. As previously mentioned, Buildroot can apply patches to packages. In this case, I put the patch directly in the package directory. Between unpacking and building a package, the system applies patches in alphabetical order.
Adding the Zabbix package
-------------------------
The ZABBIX package turned out to be more difficult to port. The package is complex and requires dependency. Below is the version that works. This version not in builroot master branch, but already submitted. It's mandatory to set zabbix-agent; zabbix-server if necessary.
So first, I created the package structure:
```
tree overlay/package/zabbix/
overlay/package/zabbix/
├── Config.in
├── zabbix-agent.service
├── zabbix.hash
├── zabbix.mk
└── zabbix-server.service
```
To Config.in and make-file files with the build rules were added the following files:
**zabbix.hash** This is the file with the checksum of the source archive
```
cat overlay/package/zabbix/zabbix.hash
# Locally computed
sha256 22bb28e667424ad4688f47732853f4241df0e78a7607727b043d704ba726ae0e zabbix-4.4.6.tar.gz
sha256 a823e00bc7f0844874f90fee97136f178e7debc76bace5f09e15ee8ed55f04c3 README
```
The first line indicates that the checksums were not taken from the manufacturer, but calculated independently.
The next 2 lines give the checksums themselves: for the source file and the license file (located inside the source files). This is the requirement of Buildroot itself.
**zabbix-agent.service, zabbix-server.service** — systemd- the units for starting the agent and server.
Let’s look inside the Config.in:
```
cat overlay/package/zabbix/Сonfig.in
config BR2_PACKAGE_ZABBIX
bool "zabbix"
# Zabbix requires glibc, musl; any other alternative won't work
# If the condition is not met, the package won't be shown in the Board settings menu
depends on BR2_TOOLCHAIN_USES_GLIBC=y || BR2_TOOLCHAIN_EXTERNAL_GLIBC=y || BR2_TOOLCHAIN_EXTERNAL_CUSTOM_GLIBC=y
# Adds the pcre package to the system
select BR2_PACKAGE_PCRE
help
Zabbix is an enterprise-class open source distributed
monitoring solution. Zabbix is free of cost. Zabbix
is written and distributed under the GPL General Public
License version 2.
# if glibc is not used, a warning about its necessity is displayed
if (!BR2_TOOLCHAIN_USES_GLIBC && !BR2_TOOLCHAIN_EXTERNAL_GLIBC && !BR2_TOOLCHAIN_EXTERNAL_CUSTOM_GLIBC)
comment "zabbix need glibc"
endif
# If the zabbix package is selected for the build
if BR2_PACKAGE_ZABBIX
# Similar to glibc, but only for zabbix-server
if (!BR2_PACKAGE_POSTGRESQL && !BR2_PACKAGE_MYSQL)
comment "zabbix server needs postgresql or mysql support"
endif
config BR2_PACKAGE_ZABBIX_SERVER
bool "zabbix server"
# this way, you can select one of the dependencies
depends on BR2_PACKAGE_POSTGRESQL || BR2_PACKAGE_MYSQL
select BR2_PACKAGE_ZLIB
select BR2_PACKAGE_LIBEVENT
# If the server is selected for the build
if BR2_PACKAGE_ZABBIX_SERVER
# This way, you can select one of the options
choice
prompt "server database backend"
config BR2_PACKAGE_ZABBIX_SERVER_MYSQL
bool "mysql"
depends on BR2_PACKAGE_MYSQL
config BR2_PACKAGE_ZABBIX_SERVER_POSTGRESQL
bool "postgresql"
depends on BR2_PACKAGE_POSTGRESQL
endchoice
# This is optional. After this, you can use the variable
BR2_PACKAGE_ZABBIX_SERVER_COPY_DUMPS
# during the building process. For example, you can call a hook at a certain value of this variable.
if BR2_PACKAGE_ZABBIX_SERVER_POSTGRESQL || BR2_PACKAGE_ZABBIX_SERVER_MYSQL
config BR2_PACKAGE_ZABBIX_SERVER_COPY_DUMPS
bool "install sql dumps"
help
Copy initial database dumps to /usr/zabbix/
endif
# This part is the requirements for the server's web interface.
if (!BR2_PACKAGE_PHP || (!BR2_PACKAGE_PHP_EXT_MYSQLI && !BR2_PACKAGE_PHP_EXT_PGSQL) || \
!BR2_PACKAGE_PHP_EXT_MBSTRING || !BR2_PACKAGE_PHP_EXT_BCMATH || \
!BR2_PACKAGE_PHP_EXT_SOCKETS || !BR2_PACKAGE_PHP_EXT_GD || \
!BR2_PACKAGE_PHP_EXT_LIBXML2 || !BR2_PACKAGE_PHP_EXT_CTYPE || \
!BR2_PACKAGE_PHP_EXT_SESSION || !BR2_PACKAGE_PHP_EXT_XMLREADER || \
!BR2_PACKAGE_PHP_EXT_XMLWRITER )
comment "zabbix-frontend need php with extensions(bc, sockets, "
comment "mbstring, gd, libxml2, ctype, session, xmlreader, xmlwriter, mysql or postgresql"
endif
choice
prompt "server ssl/tls backend"
config BR2_PACKAGE_ZABBIX_SERVER_NOTLS
bool "none"
config BR2_PACKAGE_ZABBIX_SERVER_OPENSSL
bool "openssl"
depends on BR2_PACKAGE_OPENSSL
config BR2_PACKAGE_ZABBIX_SERVER_GNUTLS
bool "gnutls"
depends on BR2_PACKAGE_GNUTLS
endchoice
# also optional. These variables will also be used during the build.
# allows you to change the list of dependencies, build rules, call hooks, and redefine them.
# commands for different build stages.
config BR2_PACKAGE_ZABBIX_SERVER_OPENIPMI
bool "openipmi support"
select BR2_PACKAGE_OPENIPMI
config BR2_PACKAGE_ZABBIX_SERVER_LIBSSH2
bool "libssh2 support"
select BR2_PACKAGE_LIBSSH2
config BR2_PACKAGE_ZABBIX_SERVER_LDAP
bool "openldap support"
select BR2_PACKAGE_OPENLDAP
if (!BR2_USE_MMU)
comment "netsnmp support need MMU"
endif
config BR2_PACKAGE_ZABBIX_SERVER_NETSNMP
bool "net-snmp support"
depends on BR2_USE_MMU # netsnmp
select BR2_PACKAGE_NETSNMP
config BR2_PACKAGE_ZABBIX_SERVER_LIBCURL
bool "libcurl support"
select BR2_PACKAGE_LIBCURL
config BR2_PACKAGE_ZABBIX_SERVER_LIBXML2
bool "libxml2 support"
select BR2_PACKAGE_LIBXML2
# Copying files for the web interface. Many dependencies with complex rules. depends on adds a load on the developer since you need to manually set all the necessary Board settings. At the same time, it guarantees the accuracy of settings and the presence of these packages in the built system.
config BR2_PACKAGE_ZABBIX_SERVER_COPY_FRONTEND
bool "copy php-frontend to target"
depends on BR2_PACKAGE_PHP
depends on BR2_PACKAGE_PHP_EXT_MYSQLI || BR2_PACKAGE_PHP_EXT_PGSQL
depends on BR2_PACKAGE_PHP_EXT_BCMATH
depends on BR2_PACKAGE_PHP_EXT_SOCKETS
depends on BR2_PACKAGE_PHP_EXT_MBSTRING
depends on BR2_PACKAGE_PHP_EXT_GD
depends on BR2_PACKAGE_PHP_EXT_LIBXML2
depends on BR2_PACKAGE_PHP_EXT_CTYPE
depends on BR2_PACKAGE_PHP_EXT_SESSION
depends on BR2_PACKAGE_PHP_EXT_XMLREADER
depends on BR2_PACKAGE_PHP_EXT_XMLWRITER
help
copy web-frontend to /usr/zabbix/php-frontend
endif
endif
```
How it looks in the menu:
```
[*] zabbix
[*] zabbix server
server database backend (postgresql) --->
[ ] install sql dumps (NEW)
*** zabbix-frontend need php with extensions(bc, sockets, ***
*** mbstring, gd, libxml2, ctype, session, xmlreader, xmlwriter, mysql or postgresql ***
server ssl/tls backend (none) --->
[ ] openipmi support (NEW)
[ ] libssh2 support (NEW)
[ ] openldap support (NEW)
[ ] net-snmp support (NEW)
[ ] libcurl support (NEW)
[ ] libxml2 support (NEW)
```
And the choice of database (within the zabbix server database backend):
```
( ) Use mysql support
(X) Use postgresql support
```
Then, you'll need an explanation of what, how, and why I did it.
**zabbix** — installing the Zabbix package. Initially, the agent is set, and if necessary, the server is set.
**zabbix server** — installing the Zabbix server — an important point. The server requires a database (postgresql or mysql), but it may be on a different host. However, you'll need the package to build it. TK is a mandatory requirement; I added the option *depends on*.
**install sql dumps** — this option allows you to copy the sql dumps needed to create a Zabbix database.
ZABBIX can support various features, such as working with ldap, openipmi, and so on. For all this, it needs header files and/or a library of corresponding packages — openldap, openipmi.
Make-file with build instructions (note that the variable names start with the package name and match the variable names I used above):
```
################################################################################
#
#zabbix
#
################################################################################
# Package version. This is important because it's used to build the file name for downloading
# Learn more here https://buildroot.org/downloads/manual/manual.html#generic-package-reference
ZABBIX_VERSION = 4.4.6
# Source where the source codes will be downloaded from
ZABBIX_SITE = https://sourceforge.net/projects/zabbix/files
# License type and file with it
ZABBIX_LICENSE = GPL-2.0
ZABBIX_LICENSE_FILES = README
# Dependencies
ZABBIX_DEPENDENCIES = pcre
# List of options for configuration and build.
ZABBIX_CONF_OPTS = --with-libpcre=$(STAGING_DIR)/usr/bin/ \
--enable-agent
# An interesting point is an example of using hooks.
# To change the configuration file, I need to run sed after installing the files.
# First, you need to declare a set of commands, then add their call to hooks.
# I'll declare the commands first. Note that the sed call is from the toolchain, not the system.
define ZABBIX_CLIENT_CHANGE_PIDFILE_LOCATION
$(SED) 's%\#\ PidFile=/tmp/zabbix_agentd.pid%PidFile=/run/zabbix/zabbix_agentd.pid%g' $(TARGET_DIR)/etc/zabbix_agentd.conf
endef
# And now I'll add this set of commands to the hook that is executed after installation in the target
ZABBIX_POST_INSTALL_TARGET_HOOKS += ZABBIX_CLIENT_CHANGE_PIDFILE_LOCATION
# Canonical method for installing systemd units and autorun them in multi-user.targer
# To add UNIT, just add the file name to the ZABBIX_SYSTEMD_UNITS variable
# For example, ZABBIX_SYSTEMD_UNITS += zabbix-agent.service
# First, I'll add the file to the list
ZABBIX_SYSTEMD_UNITS += zabbix-agent.service
# Then I'll install them.
define ZABBIX_INSTALL_INIT_SYSTEMD
$(foreach unit,$(ZABBIX_SYSTEMD_UNITS),\
$(INSTALL) -D -m 0644 $(ZABBIX_PKGDIR)/$(unit) $(TARGET_DIR)/usr/lib/systemd/system/$(unit) && \
mkdir -p $(TARGET_DIR)/etc/systemd/system/multi-user.target.wants && \
ln -fs -r $(TARGET_DIR)/usr/lib/systemd/system/$(unit) $(TARGET_DIR)/etc/systemd/system/multi-user.target.wants/$(unit)
)
endef
# This is the correct way to add a user to the system
define ZABBIX_USERS
zabbix -1 zabbix -1 !- /var/lib/zabbix - zabbix zabbix user
endef
# An example of using a variable from Config.in. If the server is selected for installation, the following steps are performed
ifeq ($(BR2_PACKAGE_ZABBIX_SERVER),y)
# Adding another systemd unit-file
ZABBIX_SYSTEMD_UNITS += zabbix-server.service
# Adding build options to existing ones
ZABBIX_CONF_OPTS += --enable-server \
--with-libevent \
--with-libpthread=$(STAGING_DIR)/usr \
--with-zlib=$(STAGING_DIR)/usr
# Also, add the dependencies
ZABBIX_DEPENDENCIES += libevent zlib
# Using hooks again - adding another set of commands to the list
ZABBIX_POST_INSTALL_TARGET_HOOKS += ZABBIX_SERVER_CHANGE_PIDFILE_LOCATION
# Support for one of the options, particularly openipmi.
# I also check the value of the variable, add build options and dependencies, and call hooks
# Need openipmi in staging dir. Patch submitted in 2019.12.16
# Before this patch is enabled, use this crutch
ifeq ($(BR2_PACKAGE_ZABBIX_SERVER_OPENIPMI),y)
ZABBIX_CONF_OPTS += --with-openipmi=$(STAGING_DIR)/usr
ZABBIX_DEPENDENCIES += openipmi
ZABBIX_PRE_CONFIGURE_HOOKS += BR2_PACKAGE_ZABBIX_SERVER_OPENIPMI_FIX_LIBS
define BR2_PACKAGE_ZABBIX_SERVER_OPENIPMI_FIX_LIBS
if [ ! -f $(STAGING_DIR)/usr/lib/libOpenIPMI.so ]; then \
cp -rf $(TARGET_DIR)/usr/lib/libOpenIPMI* $(STAGING_DIR)/usr/lib/ ;\
cp -rf $(TARGET_DIR)/usr/include/OpenIPMI $(STAGING_DIR)/usr/include/ ;\
fi
endef
endif
ifeq ($(BR2_PACKAGE_ZABBIX_SERVER_LIBCURL),y)
ZABBIX_CONF_OPTS += --with-libcurl=$(STAGING_DIR)/usr/bin/curl-config
ZABBIX_DEPENDENCIES += libcurl
endif
ifeq ($(BR2_PACKAGE_ZABBIX_SERVER_LIBXML2),y)
ZABBIX_CONF_OPTS += --with-libxml2=$(STAGING_DIR)/usr/bin/xml2-config
ZABBIX_DEPENDENCIES += libxml2
endif
ifeq ($(BR2_PACKAGE_ZABBIX_SERVER_NETSNMP),y)
ZABBIX_CONF_OPTS += --with-net-snmp=$(STAGING_DIR)/usr/bin/net-snmp-config
ZABBIX_DEPENDENCIES += netsnmp
endif
ifeq ($(BR2_PACKAGE_ZABBIX_SERVER_LDAP),y)
ZABBIX_CONF_OPTS += --with-ldap=$(STAGING_DIR)/usr
ZABBIX_DEPENDENCIES += openldap
endif
ifeq ($(BR2_PACKAGE_ZABBIX_SERVER_LIBSSH2),y)
ZABBIX_CONF_OPTS += --with-ssh2=$(STAGING_DIR)/usr
ZABBIX_DEPENDENCIES += libssh2
endif
ifeq ($(BR2_PACKAGE_ZABBIX_SERVER_OPENSSL),y)
ZABBIX_CONF_OPTS += --with-openssl=$(STAGING_DIR)/usr
ZABBIX_DEPENDENCIES += openssl
else ifeq ($(BR2_PACKAGE_ZABBIX_SERVER_GNUTLS),y)
ZABBIX_CONF_OPTS += --with-gnutls=$(STAGING_DIR)/usr
ZABBIX_DEPENDENCIES += gnutls
endif
ifeq ($(BR2_PACKAGE_ZABBIX_SERVER_COPY_FRONTEND),y)
ZABBIX_POST_INSTALL_TARGET_HOOKS += ZABBIX_SERVER_COPY_FRONTEND
define ZABBIX_SERVER_COPY_FRONTEND
mkdir -p $(TARGET_DIR)/usr/zabbix/php-frontend/
cp -r $(@D)/frontends/php/* $(TARGET_DIR)/usr/zabbix/php-frontend/
endef
endif
define ZABBIX_SERVER_CHANGE_PIDFILE_LOCATION
$(SED) 's%\#\ PidFile=/tmp/zabbix_server.pid%PidFile=/run/zabbix/zabbix_server.pid%g' $(TARGET_DIR)/etc/zabbix_server.conf
endef
ifeq ($(BR2_PACKAGE_ZABBIX_SERVER_MYSQL),y)
ZABBIX_DEPENDENCIES += mysql
ZABBIX_CONF_OPTS += --with-mysql=$(STAGING_DIR)/usr/bin/mysql_config
# Need package/mariadb/0003-add-sysroot-path-to-mariadb_config.patch by Ryan Coe
# While this patch is not included, use this crutch
ZABBIX_PRE_CONFIGURE_HOOKS += ZABBIX_DISABLE_MARIADB_CONFIG
ZABBIX_POST_CONFIGURE_HOOKS += ZABBIX_ENABLE_MARIADB_CONFIG
define ZABBIX_DISABLE_MARIADB_CONFIG
if [ -f "$(STAGING_DIR)/usr/bin/mariadb_config" ]; then \
mv $(STAGING_DIR)/usr/bin/mariadb_config $(STAGING_DIR)/usr/bin/mariadb_config_save; \
fi
endef
define ZABBIX_ENABLE_MARIADB_CONFIG
if [ -f "$(STAGING_DIR)/usr/bin/mariadb_confi_save" ]; then \
mv $(STAGING_DIR)/usr/bin/mariadb_config_save $(STAGING_DIR)/usr/bin/mariadb_config; \
fi
endef
ifeq ($(BR2_PACKAGE_ZABBIX_SERVER_COPY_DUMPS),y)
ZABBIX_POST_INSTALL_TARGET_HOOKS += ZABBIX_SERVER_PREPARE_MYSQL
endif
define ZABBIX_SERVER_PREPARE_MYSQL
mkdir -p $(TARGET_DIR)/usr/zabbix/mysql_schema/
cp -r $(@D) $(@D)/database/mysql/*\.sql $(TARGET_DIR)/usr/zabbix/mysql_schema/
endef
endif
ifeq ($(BR2_PACKAGE_ZABBIX_SERVER_POSTGRESQL),y)
ZABBIX_DEPENDENCIES += postgresql
ZABBIX_CONF_OPTS += --with-postgresql=$(STAGING_DIR)/usr/bin/pg_config
define ZABBIX_SERVER_PREPARE_POSTGRESQL
mkdir -p $(TARGET_DIR)/usr/zabbix/postgresql_schema
cp -r $(@D)/database/postgresql/*\.sql $(TARGET_DIR)/usr/zabbix/postgresql_schema/
endef
ifeq ($(BR2_PACKAGE_ZABBIX_SERVER_COPY_DUMPS),y)
ZABBIX_POST_INSTALL_TARGET_HOOKS += ZABBIX_SERVER_PREPARE_POSTGRESQL
endif
endif
endif
# I set the package type. In this case, autotools will be used.
$(eval $(autotools-package))
```
When installing the package, zabbix-agent and its dependencies will also be installed. The location of its pid-file will be changed, and the systemd UNIT file will be installed with its autorun in multi-user.target.
Optionally, you can also install zabbix-server. But then DBMS will be selected for installation, and the dump files with initial data (optional), as well as the web-frontend files (also optional), will be copied to the target system.
I specifically didn't add a web server installation. First, it can be located on another computer. Secondly, there are a lot of options for a web server; if you'll need it — you'll install the right one with the necessary php modules.
Conclusion
----------
As you can see from the text above, it's quite possible to port packages to the Buildroot by yourself. There are powerful mechanisms that automate the build. At the same time, it's possible to intervene in the build process at any time and change the necessary moments. | https://habr.com/ru/post/500122/ | null | en | null |
# Телефония на Cisco (Call Manager Express) — Часть 2
Во второй части речь пойдет об использовании цифровых транков Е1 которые можно использовать для подключения маршрутизатора к АТС
1. Компоненты схемы
-------------------
Имеем маршрутизатор Сisco2811 с установленным в NM-слот модулем NM-HDV2 и карточкой VWIC2-1MFT-T1/E1, в этом же модуле установлен 8-канальный PVDM.
Также в маршрутизатор установлен модуль VIC2-2FXS для подключения аналоговых телефонов.
В качестве АТС использовалась цифровая АТС Samsung iDCS-500 с платой TEPRI для подключения по Е1 и платой 8-DLI, к которой подключены 2 телефона OfficeServ KPDP-14SED.
2. Базовая конфигурация маршрутизатора
--------------------------------------
Для активации модуля определяем, в каком режиме (Е1 или Т1) он будет работать
> `Router(config)#card type e1 1 0
>
> #e1 - режим работы, 1 - номер NM-модуля, 0 - номер wic-слота в модуле
>
>
>
> #после этого работает команда
>
> Router#show controller e1
>
> E1 1/0/0 is down.
>
> Applique type is Channelized E1 - balanced
>
> Transmitter is sending remote alarm.
>
> Receiver has loss of signal.
>
> alarm-trigger is not set
>
> Version info Firmware: 20040802, FPGA: 13, spm_count = 0
>
> Framing is CRC4, Line Code is HDB3, Clock Source is Line.
>
> Current port master clock:local osc on this network module
>
> Data in current interval (365 seconds elapsed):
>
> 0 Line Code Violations, 0 Path Code Violations
>
> 0 Slip Secs, 0 Fr Loss Secs, 0 Line Err Secs, 0 Degraded Mins
>
> 0 Errored Secs, 0 Bursty Err Secs, 0 Severely Err Secs, 365 Unavail Secs`
Для проверки работоспособности интерфейса можно сделать следующее:
> `определить Е1 как serial interface
>
> Router(config)#controller E1 1/0/0
>
> Router(config-controller)#channel-group 0 timeslots 1-31
>
> где 0 - номер serial-cабинтерфейса, 1-31 - таймслоты, входящие в этот интерфейс`
При желании можно создать несколько serial-сабинтерфейсов с разной пропускной способностью (в зависимости от количества таймслотов)
после этой операции у нас появляется новый интерфейс **Serial1/0/0:1**
Далее нужно сделать hardware loopback, берем RJ-45 коннектор и 2 проводка из витой пары длиной около 10 см. первый провод вставляем в пины 1 и 4, а второй в пины 2 и 5. Обжимаем все это добро и получаем loopback-заглушку.
Вставляем ее в Е1 интерфейс, светодиод CD (Carrier detect) загорается зеленым, интерфейс Serial1/0/0:1 переходит в состояние up, интерфейс работает
Конфигурация аналоговых портов была рассмотрена в первой части, подробно останавливаться не буду. Для аналоговых телефонов добавим:
> `dial-peer voice 1 pots
>
> destination-pattern 101
>
> port 0/1/0
>
> !
>
> dial-peer voice 2 pots
>
> destination-pattern 102
>
> port 0/1/1`
3. Конфигурация PRI-транка
--------------------------
Переводим контроллер E1 в режим PRI:
> `controller E1 1/0/0
>
> pri-group timeslots 1-10,16`
Количество тайм-слотов зависит от доступных PVDM, в случае нехватки ресурсов появится сообщение об ошибке. Введенная выше команда разрешает использовать для голоса первые 10 таймслотов, т.е. в нашем транке может быть не более 10 одновременных разговоров. 16-й таймслот используется для сигнализации.
Конфигурируем канал сигнализации — это 15-й сабинтерфейс интерфейса Serial1/0/0, который появляется после конфигурации контроллера
> `interface Serial1/0/0:15
>
>
>
> #определяем тип сигнализации для PRI
>
> isdn switch-type primary-net5
>
> #разрешаем входящие соединения
>
> isdn incoming-voice voice`
Конфигурируем номерной план для исходящих звонков:
> `dial-peer voice 3 pots
>
> #dial-peer срабатывет на все номера, начинающиеся с "3" с последующим донабором еще двух цифр
>
> destination-pattern 3..
>
> #вызовы маршрутизируем в сигнальный канал PRI, при этом передаем все набранные цифры
>
> port 1/0/0:15
>
> forward-digits all
>
> #добавляем direct-inward-dial для обработки входящих вызовов
>
> direct-inward-dial`
Конфигурацию маршрутизатора на этом можно считать оконченной, для подключения к АТС нужно использовать кросс-кабель с двумя RJ45 и распиновкой
> `1-4
>
> 2-5
>
> 4-1
>
> 5-2`
Кроме того, нужно убедиться, что плата TEPRI правильно сконфигурирована, она должна быть установлена в режим Network (станционная часть, по-умолчанию плата находится в режиме User для подключения к вышестоящей АТС) и выставить режим работы E1.
Для этого необходимо снять корпус с платы и выставить перемычки согласно таблицы:
На АТС также должен быть сконфигурирован внутренний номерной план (в моем случае, 3хх)
Если все сконфигурировано верно, то при наборе должен зазвонить соответствующий телефон на АТС, на экране телефона должен отобразиться номер аналогового телефона, с которого совершен звонок.
При исходящем вызове подымается один из саб-интерфейсов:
> `Nov 16 16:21:58.799: %ISDN-6-CONNECT: Interface Serial1/0/0:9 is now connected to 302 N/A`
4. Проверка и отладка
---------------------
После звонка можно проверить состояние сигнального канала командой **show isdn status**:
> `Router#show isdn status
>
> Global ISDN Switchtype = primary-net5
>
> ISDN Serial1/0/0:15 interface
>
> dsl 0, interface ISDN Switchtype = primary-net5
>
> Layer 1 Status:
>
> ACTIVE
>
> Layer 2 Status:
>
> TEI = 0, Ces = 1, SAPI = 0, State = MULTIPLE_FRAME_ESTABLISHED
>
> Layer 3 Status:
>
> 1 Active Layer 3 Call(s)
>
> #один активный звонок
>
> CCB:callid=8004, sapi=0, ces=0, B-chan=10, calltype=VOICE
>
> Active dsl 0 CCBs = 1
>
> The Free Channel Mask: 0x800001FF
>
> Number of L2 Discards = 0, L2 Session ID = 1
>
> Total Allocated ISDN CCBs = 1`
Пробуем 2 одновременных звонка:
> `Nov 17 15:41:43.447: %ISDN-6-CONNECT: Interface Serial1/0/0:9 is now connected to 302 N/A
>
> Nov 17 15:42:03.675: %ISDN-6-CONNECT: Interface Serial1/0/0:8 is now connected to 310 N/A`
Кладем трубки:
> `Nov 17 15:42:51.979: %ISDN-6-DISCONNECT: Interface Serial1/0/0:9 disconnected from 310 , call lasted 68 seconds
>
> Nov 17 15:42:59.467: %ISDN-6-DISCONNECT: Interface Serial1/0/0:8 disconnected from 302 , call lasted 55 seconds`
Список активных звонков можно посмотреть командой **show isdn active**
> `Router#sh isdn active
>
> --------------------------------------------------------------------------------
>
> ISDN ACTIVE CALLS
>
> --------------------------------------------------------------------------------
>
> Call Calling Called Remote Seconds Seconds Seconds Charges
>
> Type Number Number Name Used Left Idle Units/Currency
>
> --------------------------------------------------------------------------------
>
> Out 101 302 104 Unavail - 0
>
> --------------------------------------------------------------------------------`
Также можно посмотреть состояние PRI-канала, для этого используем команду **show isdn service**
> `Router#sh isdn service
>
> PRI Channel Statistics:
>
> ISDN Se1/0/0:15, Channel [1-31]
>
> Configured Isdn Interface (dsl) 0
>
> Channel State (0=Idle 1=Proposed 2=Busy 3=Reserved 4=Restart 5=Maint_Pend)
>
> Channel : 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
>
> State : 0 0 0 0 0 0 0 0 0 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
>
> Service State (0=Inservice 1=Maint 2=Outofservice 8=MaintPend 9=OOSPend)
>
> Channel : 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
>
> State : 0 0 0 0 0 0 0 0 0 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2`
Видно, что при одном активном звонке 9-й таймслот находится в состоянии Busy (2)
Детальную отладку звонка можно произвести командами **debug dial-peer** и **debug isdn q931**
Для проверки входящих вызовов можно на цифровом телефоне набрать номер выхода на соответствующий канал в PRI-транке, а затем донабрать номер одного из аналоговых телефонов, при входящем вызове должен подняться саб-интерфейс, соответствующий выбранному каналу в PRI-транке.
На этом все, спасибо за внимание.
Продолжение следует…
p.s. нашел для схемы прикольные значки под visio, скачать можно [тут](http://www.visiocafe.com/vsdfx.htm) | https://habr.com/ru/post/107903/ | null | ru | null |
# Опыт публикации в AppGallery
> *Привет. Меня зовут*[*Кирилл Розов*](http://twitter.com/kirill_rozov)*и если вы интересуетесь разработкой под Android, то скорее всего слышали о*[*Telegram канале "Android Broadcast"*](https://t.me/android_broadcast)*, с ежедневными новостями для Android разработчиков, и*[*одноимённом YouTube канале*](http://youtube.com/androidBroadcast)*. Этот пост является текстовой расшифровкой нового видео на канале*
>
>
Всем привет. Я опубликовал приложение [Android Broadcast](https://appgallery.huawei.com/#/app/C104509969) в [AppGallery](https://appgallery.huawei.com/) и расскажу вам о своём опыте работы с этим магазином, а также сравню его с [Google Play](https://play.google.com/store). Практически всё к чему я привык в магазине от Google и смог найти в AppGallery. Помимо этого нашёл ещё кое-что интересное, что позволит вам быстрее опубликовать своё приложение и проверить интерес аудитории к вашему продукту.
[AppGallery](https://appgallery.huawei.com/) - это основной магазин на устройствах от Huawei, хотя на некоторых моделях вы найдёте также и Google Play. AppGallery можно установить на Android устройства и использовать его для установки и покупок, правда не все возможности [HMS](https://huaweimobileservices.com) будут доступны, что может привести к тому что часть функций у вас не будет работать.
> *Все устройства, которые обновятся до* [*HarmonyOS 2*](https://consumer.huawei.com/en/harmonyos/) *или будут выходить с ней будут иметь возможность работы только с AppGallery и* [*Huawei Mobile Services*](https://huaweimobileservices.com/)*.*
>
>
Давайте немного статистики. На момент выхода этого ролика AppGallery - это
* **20 миллионов** зарегистрированных пользователей
* **13 миллионов** активных ежемесячно
* Количество скачиваний уже перевалило за **1.7 миллиарда**.
* Уже сейчас в магазине более **1 миллиона** приложений.
> *Статистика приведена для России*
>
>
Количество приложений в популярных магазинах мобильных приложенийЧто в других магазинах? Google Play - это 2.7 миллиона приложений, а App Store - 1.8 миллиона, ну и Amazon Store, который стал основой Android приложений в Windows 11, содержит всего 450 тысяч. Пользователи легко найдут популярные приложения, а тех, что еще нет в магазин, встроенный в магазин поиск найдет на популярных площадках, таких как [APKPure](https://apkpure.com). Магазин работает в более двухсот стран по всему миру, включай Китай. Для тех кто не знает - Google Play не работает в этой стране и наличие такой возможности в AppGallery упрощает вам задачу выхода на рынок Китая.
Аналогом Google Play Console в AppGallery является [AppGallery Connect](https://developer.huawei.com/consumer/en/service/josp/agc/index.html), через которую распространяются приложения, получается аналитика и вся информация о жизни вашего приложения в магазине. Интерфейс консоли отличается от решения Google и поэтому вам понадобится немного времени, чтобы адаптироваться к нему, но у меня это не вызвало сложностей. В отличие от Google экосистемы, где часть сервисов управляется через Firebase консоль, а часть через Google Play Console у Huawei для всего это служит AppGallery Connect. Это мне очень понравилось, так как не надо ходить на несколько ресурсов за сбором информации о приложении и делать связи между ними. Если вам не нравится загружать сборки руками, то можно воспользоваться [Publishing API](https://developer.huawei.com/consumer/en/doc/20501) и автоматизировать процесс.
Возможности публикации по сравнению с Google Play аналогичны. Можно опубликовать APK или [App Bundle](https://developer.android.com/platform/technology/app-bundle), который сейчас не является обязательным для новых или существующих приложений, а соответственно и ваш ключ подписи может остаться у вас. Также есть [Quick App](https://developer.huawei.com/consumer/en/huawei-quickApp/), которые напоминает [Google Play Instant](https://developer.android.com/topic/google-play-instant). Такие приложения можно запускать без необходимости установки. Вы можете писать их используя нативные технологии разработки, либо HTML5. Например, я прямо из AppGallery Connect обернул [сайт Android Broadcast](https://androidbroadcast.dev/) в QuickApp (посмотреть приложение можно [здесь](https://appgallery.huawei.com/#/app/C104509969)). Выглядит это не как нативное приложение, но зато есть возможность организовать присутствие в магазине за короткий срок и проверить интерес аудитории.
Процесс публикации у меня не вызвал сложностей, за исключением того, что обязательным является указать ссылку на политику конфиденциальности, что заставит индивидуальных разработчиков напрячься, чтобы сделать это.
Также важным отличием от гугловского магазина является, что все приложения проходят ручную модерацию как в AppStore на iOS. Занимает она до 5 рабочих дней, но может происходить и быстрее. Например, когда я опубликовал своё приложение, то меньше чем за сутки прошёл ревью. Если вдруг про вас забыли, то вы можете послать напоминание, что ваше приложение ожидает проверки слишком долго.
В AppGallery вы можете раскатывать приложения поэтапно, чтобы проверить, как оно работает у реальных пользователей и не получить сразу огромное количество жалоб, если что-то пойдет не так. Кстати, я так всегда делаю в Google Play и настоятельно рекомендую вам делать также! Помимо этого вы можете организовать предзаказы до выхода вашего приложения или игры, а также предоставить ранний доступ. Разработчики могут поддержать и организовать отложенную доставку частей приложения с помощью [Dynamic Ability](https://developer.huawei.com/consumer/en/doc/development/AppGallery-connect-References/android-dynamicability-overview-0000001057492591).
Важный момент, что если вы хотите публиковать своё приложение в Google Play и App Gallery, то сейчас его можно сделать универсальным т.е. вложить сервисы от Google и Huawei в одном APK и реализовать у себя в коде динамическое переключение в зависимости от доступности сервисов Требований от магазинов касательно разных подписей приложений или отсутствия сервисов из стороннего магазина на момент записи этого видео нет, вполне возможно в будущем Google или Huawei могут поменять свою политику. Единственно известное мне требование - игры, публикуемые в AppGallery, должны содержать в пакет префикс `.huawei`
Также меня разочаровало отсутствие [треков "Alpha", "Beta", "Release" и "Open Beta"](https://developers.google.com/android-publisher/tracks) как в Google Play, что здорово позволяет упростить раздачу сборок внутри компании и давать пользователям получать доступ к ранним сборкам вашего продукта. Надеюсь, что в будущем аналогичный функционал появится в AppGallery.
Заключение
----------
Резюмируя мой опыт работы с AppGallery как индивидуальный разработчик, который захотел опубликовать приложение, то могу сказать что на текущем этапе я остался доволен опытом. Разобраться с консолью разработчика было несложно и я у меня получилось сделать это быстро. Правда процесс регистрации как разработчика занял время на верификацию, на зато был бесплатный. Да, пока я не могу дать полноценного отзыва о работе аналитике и сервисах, но в будущем расскажу о них больше.
Полезные ссылки
---------------
* [Huawei AppGallery](https://appgallery.huawei.com)
* [AppGallery Connect](https://developer.huawei.com/consumer/en/service/josp/agc/index.html#/)
* [Android Broadcast в AppGallery](https://appgallery.huawei.com/#/app/C104509969) | https://habr.com/ru/post/567974/ | null | ru | null |
# Исследуем сопоставление с образцом в C# 7
В C# 7 наконец появилась долгожданная возможность под названием «сопоставление с образцом» (**pattern matching**). Если вы знакомы с функциональными языками, такими как F#, вы можете быть немного разочарованы этой возможностью в ее текущем виде, но даже сегодня она может упростить ваш код в самых разных сценариях.
Каждая новая возможность чревата опасностью для разработчика, работающего в критическом для производительности приложении. Новые уровни абстракций хороши, но для того, чтобы эффективно использовать их, вы должны знать, что происходит под капотом. Сегодня мы собираемся изучить внутренности сопоставления с образцом, чтобы понять, как это реализовано.
Язык C# ввел понятие образца, которое может использоваться в is-выражении и внутри блока **case** оператора **switch**.
Существует 3 типа шаблонов:
* Шаблон const
* Шаблон типа
* Шаблон var
#### Сопоставление с образцом в is-выражениях
```
public void IsExpressions(object o)
{
// Alternative way checking for null
if (o is null) Console.WriteLine("o is null");
// Const pattern can refer to a constant value
const double value = double.NaN;
if (o is value) Console.WriteLine("o is value");
// Const pattern can use a string literal
if (o is "o") Console.WriteLine("o is \"o\"");
// Type pattern
if (o is int n) Console.WriteLine(n);
// Type pattern and compound expressions
if (o is string s && s.Trim() != string.Empty)
Console.WriteLine("o is not blank");
}
```
is-выражение может проверить, равно ли значение константе, а проверка типа может дополнительно создавать переменную образца (**pattern variable**).
Я нашел несколько интересных аспектов, связанных с сопоставлением с образцом в is-выражениях:
* Переменная, введенная в оператор **if**, поднимается во внешнюю область видимости.
* Переменная, введенная в оператор **if**, полностью определена (definitely assigned) только тогда, когда образец сопоставляется.
* Текущая реализация сопоставления const-образцу в is-выражениях не очень эффективна.
Сначала проверим первые два случая:
```
public void ScopeAndDefiniteAssigning(object o)
{
if (o is string s && s.Length != 0)
{
Console.WriteLine("o is not empty string");
}
// Can't use 's' any more. 's' is already declared in the current scope.
if (o is int n || (o is string s2 && int.TryParse(s2, out n)))
{
Console.WriteLine(n);
}
}
```
Первый оператор **if** вводит переменную **s**, и переменная видна внутри всего метода. Это разумно, но усложнит логику, если другие if-операторы в том же блоке будут пытаться повторно использовать одно и то же имя еще раз. В этом случае вам **нужно** использовать другое имя, чтобы избежать коллизий.
Переменная, введенная в is-выражении, полностью определена только тогда, когда предикат является **истинным**. Это означает, что переменная **n** во втором операторе **if** не определена в правом операнде, но поскольку эта переменная уже объявлена, мы можем использовать ее как переменную **out** в методе **int.TryParse**.
Третий аспект, упомянутый выше, является наиболее важным. Рассмотрим следующий код:
```
public void BoxTwice(int n)
{
if (n is 42) Console.WriteLine("n is 42");
}
```
В большинстве случаев, is-выражение преобразуется в **object.Equals (constValue, variable)** (даже если спецификация говорит, что **оператор ==** должен использоваться для примитивных типов):
```
public void BoxTwice(int n)
{
if (object.Equals(42, n))
{
Console.WriteLine("n is 42");
}
}
```
Этот код вызывает 2 упаковки (boxing), которые могут весьма серьезно повлиять на производительность, если они используются в критическом пути приложения. Когда-то выражение **o is null** так же вызывало упаковку (см. [Suboptimal code for e is null](https://github.com/dotnet/roslyn/issues/13247)) и, я надеюсь, что текущее поведение так же будет исправлено в скором времени (вот соответствующий [тикет](https://github.com/dotnet/roslyn/issues/20642) на гитхабе).
Если **n**-переменная имеет тип **object**, то **o is 42** приведет к одному выделению памяти (для упаковки литерала **42**), хотя подобный код на основе switch не приводит к выделениям памяти.
#### var pattern в is- выражениях
Образец **var** является частным случаем образца типа с одним ключевым отличием: образец будет соответствовать любому значению, даже если значение равно **null**.
```
public void IsVar(object o)
{
if (o is var x) Console.WriteLine($"x: {x}");
}
```
**o is object истинно**, когда **o** не **null**, но **o is var x** всегда **истинно**. Компилятор знает об этом и в режиме Release (\*) полностью удаляет конструкцию if и просто оставляет вызов консольного метода. К сожалению, компилятор не предупреждает, что код недостижим в следующем случае:
**if (!(o is var x)) Console.WriteLine(«Unreachable»)**. Надеюсь, это тоже будет исправлено.
(\*) Непонятно, почему поведение отличается только в режиме Release. Но я думаю, что все проблемы имеют одну природу: первоначальная реализация фичи неоптимальна. Но на основе [этого комментария](https://github.com/dotnet/roslyn/issues/22654#issuecomment-336329881) Нила Gafter это изменится: «Плохой код, соответствующий сопоставлению с образцом, переписывается с нуля (для поддержки рекурсивных шаблонов тоже). Я ожидаю, что большинство улучшений, которые вы ищете здесь, будут „бесплатными“ в новом коде.».
Отсутствие проверки на **null** делает этот случай очень особенным и потенциально опасным. Но если вы знаете, что именно происходит, вы можете найти этот вариант сопоставления полезным. Его можно использовать для введения временной переменной внутри выражения:
```
public void VarPattern(IEnumerable s)
{
if (s.FirstOrDefault(o => o != null) is var v
&& int.TryParse(v, out var n))
{
Console.WriteLine(n);
}
}
```
#### Is-expression и «Элвис»-оператор
Есть другой случай, который я нашел очень полезным. Образец типа соответствует значению, только если значение не равно **null**. Мы можем использовать эту «фильтрующую» логику с **null-propagating** оператором, чтобы сделать код более читабельным:
```
public void WithNullPropagation(IEnumerable s)
{
if (s?.FirstOrDefault(str => str.Length > 10)?.Length is int length)
{
Console.WriteLine(length);
}
// Similar to
if (s?.FirstOrDefault(str => str.Length > 10)?.Length is var length2 && length2 != null)
{
Console.WriteLine(length2);
}
// And similar to
var length3 = s?.FirstOrDefault(str => str.Length > 10)?.Length;
if (length3 != null)
{
Console.WriteLine(length3);
}
}
```
Обратите внимание, что один и тот же шаблон может использоваться как для типов значений, так и для ссылочных типов.
#### Сопоставление с образцом блоках switch
C# 7 расширяет оператор **switch** для использования образцов в **case**-блоках:
```
public static int Count(this IEnumerable e)
{
switch (e)
{
case ICollection c: return c.Count;
case IReadOnlyCollection c: return c.Count;
// Matches concurrent collections
case IProducerConsumerCollection pc: return pc.Count;
// Matches if e is not null
case IEnumerable \_: return e.Count();
// Default case is handled when e is null
default: return 0;
}
}
```
В примере показан первый набор изменений в операторе switch.
1. В операторе **switch** может использоваться переменная любого типа.
2. Предложение **case** может указывать шаблон.
3. Важен порядок предложений в **case**. Компилятор выдает ошибку, если предыдущий **case** соответствует базовому типу, а следующий **case** – соответствует производному типу.
4. Все **case**-блоки содержат неявную проверку на **null** (\*\*). В предыдущем примере, последний **case**-блок правилен, поскольку он будет срабатывать только тогда, когда аргумент не равен **null**.
(\*\*) В последнем **case**-блоке показана еще одна возможность, добавленная в C# 7, называемая шаблоном «**discard**». Имя **\_** является специальным и сообщает компилятору, что переменная не нужна. Шаблон типа в предложении **case** требует имени переменной, и если вы не собираетесь ее использовать, то вы можете ее проигнорировать с помощью **\_**.
Следующий фрагмент показывает еще одну особенность сопоставления с образцом на основе **switch** — возможность использования предикатов:
```
public static void FizzBuzz(object o)
{
switch (o)
{
case string s when s.Contains("Fizz") || s.Contains("Buzz"):
Console.WriteLine(s);
break;
case int n when n % 5 == 0 && n % 3 == 0:
Console.WriteLine("FizzBuzz");
break;
case int n when n % 5 == 0:
Console.WriteLine("Fizz");
break;
case int n when n % 3 == 0:
Console.WriteLine("Buzz");
break;
case int n:
Console.WriteLine(n);
break;
}
}
```
**Switch** может иметь более одного **case**-блока с одним и тем же типом. В этом случае, компилятор объединяет все проверки типов в один блок, чтобы избежать избыточных вычислений:
```
public static void FizzBuzz(object o)
{
// All cases can match only if the value is not null
if (o != null)
{
if (o is string s &&
(s.Contains("Fizz") || s.Contains("Buzz")))
{
Console.WriteLine(s);
return;
}
bool isInt = o is int;
int num = isInt ? ((int)o) : 0;
if (isInt)
{
// The type check and unboxing happens only once per group
if (num % 5 == 0 && num % 3 == 0)
{
Console.WriteLine("FizzBuzz");
return;
}
if (num % 5 == 0)
{
Console.WriteLine("Fizz");
return;
}
if (num % 3 == 0)
{
Console.WriteLine("Buzz");
return;
}
Console.WriteLine(num);
}
}
}
```
Но нужно иметь в виду две вещи:
1. Компилятор объединяет только последовательные **case**-блоки с одинаковым типом, и если вы будете смешивать блоки для разных типов, компилятор будет генерировать менее оптимальный код:
```
switch (o)
{
// The generated code is less optimal:
// If o is int, then more than one type check and unboxing operation
// may happen.
case int n when n == 1: return 1;
case string s when s == "": return 2;
case int n when n == 2: return 3;
default: return -1;
}
```
Компилятор преобразует его следующим образом:
```
if (o is int n && n == 1) return 1;
if (o is string s && s == "") return 2;
if (o is int n2 && n2 == 2) return 3;
return -1;
```
2. Компилятор делает все возможное, чтобы предотвратить типовые проблемы с неверным порядком **case**-блоков.
```
switch (o)
{
case int n: return 1;
// Error: The switch case has already been handled by a previous case.
case int n when n == 1: return 2;
}
```
Но компилятор не знает, что один предикат сильнее другого и, по сути, делает следующие блоки недостижимыми:
```
switch (o)
{
case int n when n > 0: return 1;
// Will never match, but the compiler won't warn you about it
case int n when n > 1: return 2;
}
```
#### Сопоставление с образцом 101
* В C# 7 были введены следующие образцы: шаблон const, шаблон типа, шаблон var и шаблон **discard**.
* Образцы могут использоваться в is-выражениях и в **case** блоках.
* Реализация шаблона const в is-выражениях для типов значений далека от совершенства с точки зрения производительности.
* Образцу var соответствует любое значение, и вы должны быть с ним осторожны.
* Оператор **switch** может использоваться для набора проверок типа с дополнительными предикатами в предложениях **when**. | https://habr.com/ru/post/347916/ | null | ru | null |
# Расширяем функционал Ansible с помощью плагинов: часть 2
Под капотом сервиса [d2c.io](https://d2c.io/) мы активно используем Ansible – от создания виртуальных машин в облаках провайдеров и установки необходимого программного обеспечения, до управления Docker-контейнерами с приложениями клиентов.
[В первой части](https://habrahabr.ru/company/d2cio/blog/344046/) мы рассмотрели типы плагинов, которые поддерживает Ansible и сделали несколько своих плагинов: test, filter, action и callback. В этой статье попробуем более сложные модификации.
### Callback с «мутацией»
Самым частым применением callback-плагинов являются системы протоколирования и оповещения. Однако, с их помощью можно не только выполнять пассивное наблюдения за событиями, но еще и активно влиять на ход выполнения плейбука.
Чтобы иметь возможность выполнять только некоторые задачи из каких-то ролей, мы в D2C активно используем теги. Например, при запуске роли с тегом `build` произойдет полная сборка сервиса «с нуля», а при запуске с тегом `update-configs` – лишь обновление файлов конфигурации и их применение. В варианте «из коробки» Ansible может применять единый набор тегов ко всему плейбуку.
Разберем задачу запуска Master-Slave репликации для MySQL сервиса:
* необходимо обновить конфигурацию основного сервера
* сделать копию базы для первичного наполнения реплики
* сделать второй сервер, настроить репликацию
* восстановить оригинальную базу на реплике
* удалить временные данные
Каждая из задач имеет свои теги. Чтобы объединить этот процесс в один плейбук мы можем описать три плея (play – единица конфигурации из множества которых состоит playbook): для подготовки мастера, для подготовки реплики, для очистки. Однако, мы не можем указать теги для каждой части по отдельности, так как они задаются через параметр `tags` для всего плейбука целиком. Давайте исправим это, воспользовавшись callback-плагином:
```
from ansible.plugins.callback import CallbackBase
from ansible.parsing.yaml.objects import AnsibleUnicode
from ansible.compat.six import string_types
import json
import os
class CallbackModule(CallbackBase):
CALLBACK_VERSION = 2.0
CALLBACK_NAME = 'use_tags'
def __init__(self):
super(CallbackModule, self).__init__()
self.tmp_context = None
self.warn = False if os.environ.get('ANSIBLE_D2C_NO_WARN') else True
def v2_playbook_on_play_start(self, play):
vm = play.get_variable_manager()
extra_vars = vm.extra_vars
enable_use_tags = False
if 'enable_use_tags' in extra_vars:
if extra_vars['enable_use_tags']:
enable_use_tags = True
play_vars = vm.get_vars(play._loader, play=play)
if enable_use_tags:
tags = self.tmp_context.only_tags
tags.clear()
if 'use_tags' in play_vars:
use_tags = play_vars['use_tags']
if isinstance(use_tags, (string_types, AnsibleUnicode)):
use_tags = [t.strip() for t in use_tags.split(',')]
if isinstance(use_tags, list):
for t in use_tags:
tags.add(t)
else:
tags.add('all')
self._display.display(' [INFO]: "use_tags" variable is set, but unparsable (type "{}" is not a list or a string): {}'.format(type(use_tags),use_tags), color='cyan')
else:
self._display.display(' [INFO]: "use_tags" variable is not set, but "enable_use_tags" is set', color='cyan')
tags.add('all')
if self.warn:
self._display.warning('Tags modified to: {}'.format(json.dumps(list(tags))))
def set_play_context(self, play_context):
self.tmp_context = play_context
```
В нашем плагине главный герой – метод `v2_playbook_on_play_start`. Он вызывается после инициализации плея (наполнения переменными, определения списка хостов и пр.) и перед началом выполнения самих задач (tasks).
Мы используем дополнительную переменную (extra var) `enable_use_tags` как признак того, что будем использовать модификацию тегов «на лету» и переменную уровня плея (play var) `use_tags` для формирования списка необходимых тегов.
Всё бы хорошо, но теги вместе со множеством другой runtime информации во время инициализации копируются в объект `PlayContext`, ссылка на который отстутствует в методе `v2_playbook_on_play_start`. Для борьбы с этим заметим, что менеджер очереди в Ansible [проверяет](https://github.com/ansible/ansible/blob/64db935b25bbaad0fe290e3ef39f34e5a3ac5a9c/lib/ansible/executor/task_queue_manager.py#L249) наличие метода `set_play_context` в подключенных плагинах и, если он есть, вызывает его, передавая этот самый контекст.
Используя те обстоятельства, что `PlayContext` изменяемый (mutable) и что Ansible одновременно работает только с одним плеем (play) реализуем следующий алгоримт в плагине:
* при первичной инициализации плагина обнуляем `tmp_context` внутри плагина
* при каждом вызове `set_play_context` запоминаем текущий контект в `tmp_context`
* при последующем вызове `v2_playbook_on_play_start` анализируем переменные `enable_use_tags` и `use_tags` и изменяем оригинальный объект `PlayContext` (точнее получаем «ссылку» на mutable список тегов через `self.tmp_context.only_tags` и модифицируем список)
* выводим соответствующие предупреждения, что список тегов изменен (чтобы не было неожиданностей для пользователя)
Теперь мы можем запустить такой плейбук:
`ansible-playbook -e enable_use_tags=1 make_mysql_slave.yml`
```
- hosts: master
vars:
use_tags: update-configs, replication-init, replication-sync
roles:
- mysql
- hosts: slave
vars:
use_tags: build, replication-init, replication-sync
roles:
- mysql
- hosts: all
vars:
use_tags: replication-sync-cleanup
roles:
- mysql
```
В этом случае Ansible будет использовать для каждого плея (play) свой набор тегов. Это дает нам возможность компановать оркестрацию сложных конфигураций едиными плейбуками.
### Connection
Connection плагины используется для организации соединения с целевыми хостами. Вкратце: плагин должен предоставлять возможность установить и разорвать соединение, отправить файл, запустить удаленную команду. Примерами плагинов «из коробки» являются: `local`, `ssh` (используется по умолчанию), `winrm`, `docker`.
Если у вас совершенно особенные целевые хосты, например, какая-нибудь проприетарная система виртуализации, то вам придется написать свой плагин с нуля. Но если вам нужно добавить немного функционала к существуюему, можно унаследоваться от плагина «из коробки» и переопределить необходимые методы.
Рассмотрим пример SSH-подключения с использованием [port knoking](https://en.wikipedia.org/wiki/Port_knocking). В основном эти ssh-сессии ничем не отличаются от обычных, но перед попыткой подключения к удаленной машине необходимо «постучать» на определенные порты, чтобы сервер открыл 22 порт и принял ssh-соединение.
Доработаем базовый плагин `ssh` (положить в ./connection\_plugins/ssh\_pkn.py):
```
from ansible.plugins.connection.ssh import Connection as ConnectionSSH
from ansible.errors import AnsibleError
from socket import create_connection
from time import sleep
try:
from __main__ import display
except ImportError:
from ansible.utils.display import Display
display = Display()
class Connection(ConnectionSSH):
def __init__(self, *args, **kwargs):
super(Connection, self).__init__(*args, **kwargs)
display.vvv("SSH_PKN (Port KNock) connection plugin is used for this host", host=self.host)
def set_host_overrides(self, host, hostvars=None):
if 'knock_ports' in hostvars:
ports = hostvars['knock_ports']
if not isinstance(ports, list):
raise AnsibleError("knock_ports parameter for host '{}' must be list!".format(host))
delay = 0.5
if 'knock_delay' in hostvars:
delay = hostvars['knock_delay']
for p in ports:
display.vvv("Knocking to port: {0}".format(p), host=self.host)
try:
create_connection((self.host, p), 0.5)
except:
pass
display.vvv("Waiting for {0} seconds after knock".format(delay), host=self.host)
sleep(delay)
```
Мы используем метод `set_host_overrides`, который дает возможность плагинам изменять свое поведение в зависимости от host/group переменных. Этот метод вызывается при создании нового соединения когда не используется reuse. В нашем случае он не должен лишний раз «простукивать» порты.
Пример inventory файла для использования данного плагина:
```
[pkn]
myserver ansible_host=my.server.at.example.com
[pkn:vars]
ansible_connection=ssh_pkn
knock_ports=[8000,9000]
knock_delay=2
```
Мы указали, что для всех хостов в группе `pkn` будет использоваться connection-плагин `ssh_pkn`. При инициализации нашего плагина внутри метода `set_host_overrides` сработает условие, что определена переменная `knock_ports`. Затем для каждого из портов в списке будет выполнена попытка соединения с интервалом `knock_delay` в 2 секунды. Мы также перехватываем все исключения от `create_connection`, так как скорее всего порты для «простукивания» закрыты и попытки соединения будут безуспешными. Однако для нас это не особо важно – сервер в любом случае увидит попытки.
### Strategy
Плагины типа strategy определяют порядок запуска задач (tasks) и выполняют множество «подкапотной работы»: в том числе динамическое добавление фактов, отслеживание состояния хостов (healty/failed/unreachable) и вызов callback'ов. О strategy-плагинах «из коробки» я писал поробнее в [первой части](https://habrahabr.ru/company/d2cio/blog/344046/).
Такие пользовательские плагины встречаются крайне редко. В непринятом [pull-реквесте 18460](https://github.com/ansible/ansible/pull/18460), например, предлагали плагин с возожностью инъекции задач в произвольное место плейбука, чтобы повысить гибкость распространяемых ролей. Мы же сделаем более приземпленный strategy-плагин.
Положить в ./strategy\_plugins/step\_critical.py:
```
from ansible.plugins.strategy.linear import StrategyModule as LinearStrategyModule
import os
try:
from __main__ import display
except ImportError:
from ansible.utils.display import Display
display = Display()
class StrategyModule(LinearStrategyModule):
def __init__(self, tqm):
super(StrategyModule, self).__init__(tqm)
display.vv('Safenet strategy: will give a prompt at critical tasks!')
force_step = os.environ.get('ANSIBLE_FORCE_STEP', None)
if force_step and force_step.lower() in ['1','y','yes','true','on']:
display.vv('Safenet: "step" option is forced via environment!')
self._step = True
def _take_step(self, task, host=None):
v = task.get_vars()
ret = True
if 'is_critical' in v:
if v['is_critical']:
display.vv('Safenet: critical task detected!')
return super(StrategyModule, self)._take_step(task, host)
return ret
```
Этот плагин изменяет поведение параметра `--step` таким образом, что Ansible спрашивает разрешение только для задач, у которых определена переменная `is_critical` и её значение `True`, а не для всех подряд, как это происходит «из коробки».
Также мы можем принудительно включить режим подтверждения через переменную окружения `ANSIBLE_FORCE_STEP`, а не только через параметр `--step`. В остальном данный плагин наследует поведение плагина `linear`.
Проверить поведение плагина вы можете следующим плейбуком:
```
---
- hosts: localhost
strategy: step_critical
gather_facts: no
tasks:
- name: Ensure user exists
debug:
msg: user_module
- name: Drop database
debug:
msg: db_module
vars:
is_critical: yes
- name: Ensure permissions
debug:
msg: permission_module
```
---
### Итого
В двух статьях о возможностях расширения Ansible мы рассмотрели все типы плагинов, которые поддерживаются в версии Ansible 2.3. А также я привел примеры для большинства из них.
Если какие-то вопросы о плагинах остались не раскрытыми, пишите в комментариях – постараюсь ответить.
А пока я приступаю к подготовке статьи о создании модулей для Ansible. Stay tuned! | https://habr.com/ru/post/345216/ | null | ru | null |
# Создание Push Notification сервиса на основе WCF REST
##### В качестве вступления
Модель [push](http://en.wikipedia.org/wiki/Push_technology)-нотификаций является распространённой моделью для обмена сообщениями. Она подразумевает не получение информации по запросу, а немедленную её передачу отправителю при появлении этой информации на сервере.
##### Стандартный подход с ипользованием wsDualHttpBinding
Возможность создания push-механизма предоставляет и WCF. Этот фреймворк позволяет создать push-сервис с использованием wsDualHttpBinding контракта. Такой контракт позволяет для каждого запроса определить метод обратного вызова, который будет вызван при наступлении какого-либо события.
Если применить этот механизм к системе обмена сообщениями, то получим следующий алгоритм:
— Для каждого запроса на новые сообщения создаётся callback, который сохраняется в списке подписчиков на новые сообщения.
— При получении нового сообщения, система проходит по списку подписчиков и находит нужного нам получателя сообщения (а значит и нужный callback).
— Вызываем нужный нам callback-метод.
Ниже приведён пример использования wsDualHttpBinding для WCF сервиса:
— Создаём метод обратного вызова для запроса на новые сообщения
```
interface IMessageCallback
{
[OperationContract(IsOneWay = true)]
void OnMessageAdded(int senderId, string message, DateTime timestamp);
}
```
— Создаём сервис контракт
```
[ServiceContract(CallbackContract = typeof(IMessageCallback))]
public interface IMessageService
{
[OperationContract]
void AddMessage(int senderId, int recipientId, string message);
[OperationContract]
bool Subscribe();
}
```
— Создаём сам сервис
```
Public class MessageService : IMessageService
{
private static List subscribers = new List();
public bool Subscribe(int id)
{
try
{
IMessageCallback callback =
OperationContext.Current.GetCallbackChannel();
callback.id = id;
if (!subscribers.Contains(callback))
subscribers.Add(callback);
return true;
}
catch
{
return false;
}
}
public void AddMessage(int senderId, int recipientId, string message)
{
subscribers.ForEach(delegate(IMessageCallback callback)
{
if ((((ICommunicationObject)callback).State == CommunicationState.Opened) && (callback.id == recipientId))
{
callback.OnMessageAdded(recipientId, message, DateTime.Now);
}
else
{
subscribers.Remove(callback);
}
});
}
}
```
— Конфигурируем сервис в файле web.config
```
```
Сервис готов.
Однако, эта модель работает только в том случае, когда и сервер, и подписчики являются .NET-приложениями.
##### Использование RESTful подхода
Вышеописанный метод не подходит для случаев, когда подписчик, к примеру, является мобильным устройством и может использовать только запросы в формате REST.
В этом случае на помощь приходят асинхронные REST-запросы.
Итак, создадим сервис, аналогичный по функциональности предыдущему, только на основе REST.
В случае с асинхронной моделью запрос состоит из двух частей: BeginRequestName и EndRequestName.
— Определим ServiceContract для REST-сервиса
```
[ServiceContract]
public interface IMessageService
{
[WebGet(UriTemplate = "AddMessage?senderId={senderId}&recipientId={recipientId}&message={message}")]
[OperationContract ]
bool AddMessage(int senderId, int recipientId, string message);
[WebGet(UriTemplate = "Subscribe?id={id}")]
[OperationContract(AsyncPattern = true)]
IAsyncResult BeginGetMessage(int id, AsyncCallback callback, object asyncState);
ServiceMessage EndGetMessage(IAsyncResult result);
}
```
Обратите внимание: EndGetMessage не помечен аттрибутом OperationContact.
— Создадим класс для асинхронного результата, реализующий интерфейс IAsyncResult
```
public class MessageAsyncResult : IAsyncResult
{
public AsyncCallback Callback { get; set; }
private readonly object accessLock = new object();
private bool isCompleted = false;
private ServiceMessage result;
private int recipientId;
private object asyncState;
public MessageAsyncResult(object state)
{
asyncState = state;
}
public int RecipientId
{
get
{
lock (accessLock)
{
return recipientId;
}
}
set
{
lock (accessLock)
{
recipientId = value;
}
}
}
public ServiceMessage Result
{
get
{
lock (accessLock)
{
return result;
}
}
set
{
lock (accessLock)
{
result = value;
}
}
}
public bool IsCompleted
{
get
{
lock (accessLock)
{
return isCompleted;
}
}
set
{
lock (accessLock)
{
isCompleted = value;
}
}
}
public bool CompletedSynchronously
{
get
{
return false;
}
}
public object AsyncState
{
get
{
return asyncState;
}
}
public WaitHandle AsyncWaitHandle
{
get
{
return null;
}
}
}
```
Помимо реализации интерфейса, в этом классе также хранится Id получателя сообщения (recipientId), а также само сообщение, которое будет доставлено отправителю(result).
— Теперь реализуем сам сервис
```
[ServiceBehavior(
InstanceContextMode = InstanceContextMode.PerCall,
ConcurrencyMode = ConcurrencyMode.Multiple)]
public class MessageService : IMessageService
{
private static List subscribers = new List();
public bool AddMessage(int senderId, int recipientId, string message)
{
subscribers.ForEach(delegate(MessageAsyncResult result)
{
if (result.RecipientId == recipientId)
{
result.Result = new ServiceMessage(senderId, recipientId, message, DateTime.Now);
result.IsCompleted = true;
result.Callback(result);
subscribers.Remove(result);
}
});
return true;
}
public IAsyncResult BeginGetMessage(int id, AsyncCallback callback, object asyncState)
{
MessageAsyncResult asyncResult = new MessageAsyncResult(asyncState);
asyncResult.Callback = callback;
asyncResult.RecipientId = id;
subscribers.Add(asyncResult);
return asyncResult;
}
public ServiceMessage EndGetMessage(IAsyncResult result)
{
return (result as MessageAsyncResult).Result;
}
}
```
Когда приходит запрос на получение нового сообщения, создаётся асинхронный результат, который добавляется в список подписчиков. Как только приходит сообщение для данного подписчика, свойство IsCompleted для данного IAsyncResult устанавливается в true, и вызывается метод EndGetMessage. В EndGetMessage отправляется ответ подписчику.
— Осталось сконфигурировать сервис в файле web.config
```
```
Сервис готов.
Очевидно, что при истечении времени ожидания ответа от сервиса, нужно будет переотправлять запрос на получение новых сообщений.
##### Заключение
Таким образом можно реализовать Push-сервис для обмена сообщениями “в реальном времени”, основываясь на REST запросах. Такой сервис может использоваться с любого клиента, поддерживающиего RESTful реквесты, в том числе и из обычного браузера. | https://habr.com/ru/post/128634/ | null | ru | null |
# Быстрая интеграция Google Chromecast в Android приложение
Добрый день, я Android Team Lead в компании по разработке мобильных приложений Trinity Digital. Наша компания существует на рынке три года и в 2015-м мы вошли в топ-10 лучших разработчиков Москвы. Наш второй офис находится в Петрозаводске, там я и руковожу командой Android-разработчиков. В этой статье хочу рассказать о том, как быстро добавить в приложение возможность взаимодействовать с устройством Google Chromecast, а именно — отправлять один видео-файл на воспроизведение и управлять просмотром. Получить устройство удалось благодаря конкурсу [Device Lab от Google.](https://special.habrahabr.ru/google/lab/)
Если вы не знакомы с устройством Chromecast, то можете почитать обзорную статью [вот тут](https://geektimes.ru/post/187870/). Несмотря на то, что эта статья про первую версию Chromecast, она даст общее представление о всем семействе устройств и принципе их работы.
Приложение, на примере которого я расскажу о технологии — «Рецепты Юлии Высоцкой».
*Статья автора Андрея Хитрого, в рамках конкурса [«Device Lab от Google»](http://special.habrahabr.ru/google/lab)*.
Это один из самых успешных наших проектов, имеющий около полумиллиона пользователей. Приложение представляет собой сборник более чем 1500 рецептов, в том числе в видео-формате, что и позволило мне интегрировать в него Google Chromecast. Итак, начнём.
Первые шаги
-----------
Приступим к интеграции Chromecast в наше Android приложение. Мы рассмотрим простейший случай, когда в приложении имеется Activity, содержащая некоторый видео контент (один видео файл). Для этого воспользуемся библиотекой [CastCompanionLibrary-android](https://github.com/googlecast/CastCompanionLibrary-android), которая упрощает интеграцию до нескольких шагов.
Для начала создадим пустой проект в Android Studio и добавим в файл app/build.gradle зависимость.
```
dependencies {
compile 'com.google.android.libraries.cast.companionlibrary:ccl:2.8.4'
}
```
Библиотека использует синглтон VideoCastManager для организации взаимодействия. В первую очередь, мы должны инициализировать этот синглтон при помощи объекта конфигурации. Большинство опций прокомментировано в коде.
```
// Core.java
public class Core extends Application {
@Override
public void onCreate() {
super.onCreate();
CastConfiguration options = new CastConfiguration.Builder("CC1AD845")
.enableAutoReconnect() // Восстановление соединения после разрыва
.enableDebug() // Разрешаем отладку, чтобы логи были подробными
.enableLockScreen() // Возможность управления на экране блокировки
.enableNotification() // Возможность управления через оповещение + возможные действия
.addNotificationAction(CastConfiguration.NOTIFICATION_ACTION_REWIND, false)
.addNotificationAction(CastConfiguration.NOTIFICATION_ACTION_PLAY_PAUSE, true)
.addNotificationAction(CastConfiguration.NOTIFICATION_ACTION_DISCONNECT, true)
.enableWifiReconnection() // Восстановление, после смены wifi сети
.setForwardStep(10) // Шаг перемотки в секундах
.build();
VideoCastManager.initialize(this, options);
}
}
```
В конструктор CastConfiguration мы передаем идентификатор Media Receiver. Этот идентификатор определяет стилизацию плеера Chromecast. Мы не будем останавливаться на нем, более подробно можно почитать [на официальной странице](https://developers.google.com/cast/docs/registration). Информацию о других опциях VideoCastManager можно найти [в github](https://github.com/googlecast/CastCompanionLibrary-android/blob/master/src/com/google/android/libraries/cast/companionlibrary/cast/CastConfiguration.java).
Изменение манифеста приложения
------------------------------
Стоит отметить, что для корректной работы управления через оповещения и на заблокированном экране. необходимо добавить в манифест приложения объявления необходимых Activities, Services и Receivers.
В примере, который предлагают разработчики, я не нашел этих объявлений, что довольно странно, т.к. без них управление из области оповещений и на заблокированном экране не будет работать или будет работать не корректно.
```
```
Воспроизведение одного файла
----------------------------
Для организации взаимодействия между Chromecast и приложением Android библиотека использует класс VideoCastConsumerImpl. Изначально он рассчитан для работы с очередью видеофайлов, но, т.к. наше приложение не предполагает наличие очереди, мы несколько изменим этот класс.
```
// SingleVideoCastConsumer.java
public abstract class SingleVideoCastConsumer extends VideoCastConsumerImpl {
private AppCompatActivity activity;
private final String videoUrl;
private final String title;
private final String subtitle;
private final String imageUrl;
private final String contentType;
public SingleVideoCastConsumer(AppCompatActivity activity, String videoUrl, String title, String subtitle, String imageUrl, String contentType) {
this.activity = activity;
this.videoUrl = videoUrl;
this.title = title;
this.subtitle = subtitle;
this.imageUrl = imageUrl;
this.contentType = contentType;
}
public abstract void onPlaybackFinished();
public abstract void onQueueLoad(final MediaQueueItem[] items, final int startIndex, final int repeatMode,
final JSONObject customData) throws TransientNetworkDisconnectionException, NoConnectionException;
@Override
public void onMediaQueueUpdated(ListqueueItems, MediaQueueItem item, int repeatMode, boolean shuffle) {
// Если в очереди больше нет элементов, то оповещаем о завершении воспроизведения
if(queueItems != null && queueItems.size() == 0) {
onPlaybackFinished();
}
}
@Override
public void onApplicationConnected(ApplicationMetadata appMetadata, String sessionId,
boolean wasLaunched) {
// Изменить состояние кнопки Cast
activity.invalidateOptionsMenu();
// Создаем метаданные типа видеофайл
MediaMetadata movieMetadata = new MediaMetadata(MediaMetadata.MEDIA\_TYPE\_MOVIE);
// Заголовок
movieMetadata.putString(MediaMetadata.KEY\_TITLE, title);
// Подзаголовок
movieMetadata.putString(MediaMetadata.KEY\_SUBTITLE, subtitle);
// Картинка, которая будет показана при загрузке
movieMetadata.addImage(new WebImage(Uri.parse(imageUrl)));
// Создаем информацию о медиа контенте
MediaInfo info = new MediaInfo.Builder(videoUrl)
.setStreamType(MediaInfo.STREAM\_TYPE\_BUFFERED)
.setContentType(contentType)
.setMetadata(movieMetadata)
.build();
// Создаем элемент очереди медиафайлов
MediaQueueItem item = new MediaQueueItem.Builder(info).build();
try {
// Обновляем очередь Chromecast, она всегда содержит 1 элемент, т.к. у нас всего 1 видеофайл
onQueueLoad(new MediaQueueItem[]{item}, 0, MediaStatus.REPEAT\_MODE\_REPEAT\_OFF, null);
} catch (TransientNetworkDisconnectionException e) {
e.printStackTrace();
} catch (NoConnectionException e) {
e.printStackTrace();
}
}
@Override
public void onDisconnected() {
// Изменить состояние кнопки Cast
activity.invalidateOptionsMenu();
}
}
```
Основными методами, на которых стоит заострить внимание являются onApplicationConnected и onQueueLoad. Как в могли заметить, библиотека использует MediaInfo, MediaMetadata и MediaQueueItem для работы с медиа данными. в методе onApplicationConnected, который будет вызван как только приложение подключится к Chromecast, мы создадим объект очереди и вызовем абстрактный метод onQueueLoad, который позже реализуем в Activity. Описание работы методов можно найти в комментариях к коду.
Использование в Activity
------------------------
Следующим (и последним) шагом будет реализация нашей Activity.
```
ublic class MainActivity extends AppCompatActivity {
private VideoCastManager castManager;
private VideoCastConsumer castConsumer;
private Toolbar toolbar;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
castManager = VideoCastManager.getInstance();
castConsumer = new SingleVideoCastConsumer(this,
http://example.com/somemkvfile.mkv", // ссылка на файл
"Jet Packs Was Yes", "Periphery", // подзаголовок и заголовок
"http://fugostudios.com/wp-content/uploads/2012/02/periphery720p-600x338.jpg", // картинка
"video/mkv" // тип файла
) {
@Override
public void onPlaybackFinished() {
// Отключаем устройство
disconnectDevice();
}
@Override
public void onQueueLoad(MediaQueueItem[] items, int startIndex,
int repeatMode, JSONObject customData)
throws TransientNetworkDisconnectionException, NoConnectionException {
// Простой проброс очереди из нашего SingleVideoCastConsumer в castManager
castManager.queueLoad(items, startIndex, repeatMode, customData);
}
};
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.main, menu);
// Добавляем кнопку Cast в toolbar
castManager.addMediaRouterButton(menu, R.id.media_route_menu_item);
return true;
}
@Override
public boolean dispatchKeyEvent(@NonNull KeyEvent event) {
// Даем возможность управлять громкостью воспроизведения при помощи
// физических кнопок
return castManager.onDispatchVolumeKeyEvent(event, 0.05)
|| super.dispatchKeyEvent(event);
}
@Override
protected void onResume() {
// Подключаем castConsumer и увеличиваем счетчик подключений
if (castManager != null) {
castManager.addVideoCastConsumer(castConsumer);
castManager.incrementUiCounter();
}
super.onResume();
}
@Override
protected void onPause() {
// Уменьшаем счетчик подключений и отключаем castConsumer
castManager.decrementUiCounter();
castManager.removeVideoCastConsumer(castConsumer);
super.onPause();
}
// По непонятной мне причине отключение устройства без задержки
// не работало, но если использовать 100-500 мс задержку, то устройство
// отключается нормально.
private void disconnectDevice() {
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
castManager.disconnect();
}
},500);
}
}
```
В нашей Activity нет ничего сложного, мы получаем VideoCastManager в методе onCreate. В методах onResume и onPause управляем жизненным циклом нашего подключения к Chromecast. А методы onCreateOptionsMenu и dispatchKeyEvent организуют UX часть нашей интеграции. К сожалению, я так и не понял, почему castManager.disconnect() выбрасывал ошибку, но какая программа обходится без костылей.
Design Checklist
----------------
Теперь обратимся к дизайну. Большинство из Design Guidelines за нас реализует выше описанная библиотка, но некоторые пункты нужно реализовать вручную.
* Стилизация диалогов
* Показ интро для пользователя
Мы выполняли интеграцию с Google Chromecast в приложении «Рецепты Юлии Высоцкой». В этом приложении присутствуют видео-рецепты и было бы неплохо добавить возможность показывать их через Chromecast.
Если к рецепту прикреплен видео-файл, то мы даем возможность пользователю просмотреть его через приложение на его выбор. Это выглядит вот так:
После интеграции с Chromecast и при наличии в нашей сети настроенного Chromecast экран будет выглядеть так:
Показ интро пользователю
------------------------
Теперь нам необходимо показать пользователю информацию о том, что Chromecast доступен для стриминга и он может просмотреть видео-рецепт через него. Для показа этой информации мы воспользуемся IntroductoryOverlay из той же библиотеки. Я не буду описывать параметры этого класса, т.к. они очевидны и нам нужно указать только сопровождающий текст. Выглядит это вот так:
**Стилизация диалогов**
После того, как пользователь нажмет на иконку Cast, помимо показа видео у него должна появиться возможность управлять воспроизведением через диалоги. Этот функционал также реализовал в используемой нами библиотеке и все что нам нужно, это просто стилизовать диалоги.
Для этого мы будем использовать CastConfiguration.Builder и метод setMediaRouteDialogFactory.
```
options.setMediaRouteDialogFactory(new MediaRouteDialogFactory() {
@NonNull
@Override
public MediaRouteChooserDialogFragment onCreateChooserDialogFragment() {
return new MediaRouteChooserDialogFragment() {
@Override
public MediaRouteChooserDialog onCreateChooserDialog(Context context, Bundle savedInstanceState) {
return new MediaRouteChooserDialog(context, R.style.Theme_MediaRouter_Light);
}
};
}
@NonNull
@Override
public MediaRouteControllerDialogFragment onCreateControllerDialogFragment() {
return new MediaRouteControllerDialogFragment(){
@Override
public MediaRouteControllerDialog onCreateControllerDialog(Context context, Bundle savedInstanceState) {
return new MediaRouteControllerDialog(context, R.style.Theme_MediaRouter_Light);
}
};
}
})
```
Здесь мы указали два стиля, для диалога выбора устройства и для диалога управления воспроизведением.
```
<item name="android:windowNoTitle">false</item>
<item name="mediaRouteButtonStyle">@style/Widget.MediaRouter.Light.MediaRouteButton</item>
<item name="MediaRouteControllerWindowBackground">@drawable/mr\_dialog\_material\_background\_light</item>
<item name="mediaRouteOffDrawable">@drawable/ic\_cast\_off\_light</item>
<item name="mediaRouteConnectingDrawable">@drawable/mr\_ic\_media\_route\_connecting\_mono\_light</item>
<item name="mediaRouteOnDrawable">@drawable/ic\_cast\_on\_light</item>
<item name="mediaRouteCloseDrawable">@drawable/mr\_ic\_close\_light</item>
<item name="mediaRoutePlayDrawable">@drawable/mr\_ic\_play\_light</item>
<item name="mediaRoutePauseDrawable">@drawable/mr\_ic\_pause\_light</item>
<item name="mediaRouteCastDrawable">@drawable/mr\_ic\_cast\_light</item>
<item name="mediaRouteAudioTrackDrawable">@drawable/mr\_ic\_audiotrack\_light</item>
<item name="mediaRouteDefaultIconDrawable">@drawable/ic\_cast\_grey</item>
<item name="mediaRouteBluetoothIconDrawable">@drawable/ic\_bluetooth\_grey</item>
<item name="mediaRouteTvIconDrawable">@drawable/ic\_tv\_light</item>
<item name="mediaRouteSpeakerIconDrawable">@drawable/ic\_speaker\_light</item>
<item name="mediaRouteSpeakerGroupIconDrawable">@drawable/ic\_speaker\_group\_light</item>
<item name="mediaRouteChooserPrimaryTextStyle">@style/Widget.MediaRouter.ChooserText.Primary.Light</item>
<item name="mediaRouteChooserSecondaryTextStyle">@style/Widget.MediaRouter.ChooserText.Secondary.Light</item>
<item name="mediaRouteControllerTitleTextStyle">@style/Widget.MediaRouter.ControllerText.Title.Dark</item>
<item name="mediaRouteControllerPrimaryTextStyle">@style/Widget.MediaRouter.ControllerText.Primary.Light</item>
<item name="mediaRouteControllerSecondaryTextStyle">@style/Widget.MediaRouter.ControllerText.Secondary.Light</item>
```
Параметры стиля имеют говорящие названия, вы можете экспериментировать с ними, чтобы добиться наилучшего результата для вашего приложения. У нас получилось вот так:
Вот еще несколько скриншотов из приложения, которые показывают управление из области оповещений и на заблокированном экране:
Надеюсь, что вы нашли статью полезной, полный исходных код демо проекта лежит [на github](https://github.com/arkty/caster). Задавайте вопросы в комментариях, в следующей статье я постараюсь собрать ответы на часто задаваемые вопросы и рассказать о Media Receivers, управлении очередью воспроизведения и стилизации MediaReceivers. Более полную информацию об интеграции с другими платформами, а также примеры вы можете найти на [официальной странице](https://developers.google.com/cast/).
Более подробные примеры кода, в том числе и для других платформ, можно найти [здесь](https://developers.google.com/cast/docs/downloads). Подробную информацию о принципах взаимодействия с пользователем можно найти в [Design Checklist](https://developers.google.com/cast/docs/design_checklist/). | https://habr.com/ru/post/310498/ | null | ru | null |
# Настраиваем сервер с Chef (Быстро и просто)
> The best way to learn Chef is to use Chef
>
> — getchef.com
Chef — это инструмент для конфигурирования серверов в концепции Infrastructure as a Code(IaaC).
Лично для меня, Chef — это, в первую очередь, возможность хранить архитектуру сервиса в виде ролей, и модифицировать её, избегая рутинных действий по установке пакетов и конфигурации.
Chef позволяет выполнять любые скрипты на сервере, предоставляя свой собственный синтаксис для их описания. Кроссплатформенно и структурировано.
Обладает довольно высоким порогом вхождения. Причинами являются: запутанная на первый взгляд терминология и разница в использовании Chef и Chef solo.
Solo — простой путь для начинающих работать с Chef, позволяет управлять конфигурацией без необходимости иметь дополнительный служебный сервер, что ограничивает функционал. Однако, эти ограничения дают о себе знать при управлении большим парком серверов.
*Эту статью можно назвать «конспектом Chef».
Возможно, текст будет похож на переведенный промптом, но, я думаю что, термины используемые в тексте лучше не переводить, буду рад узнать ваше мнение на этот счёт.*
##### Термины
* knife — консольная утилита, позволяющая выполнять скрипты с локальной машины на удаленном севере. Главный инструмент настоящего повара.
* recipe — скрипт, выполняемый на сервере. Может выполнять любые задачи: от создания директорий, до установки и настройки Nginx.
* cookbook — коллекция скриптов (recipes). Существует множество готовых cookbooks (например, для установки MySQL и т.п.), которые можно применять, не залезая внутрь скрипта.
* role — Роль сервера. Например mysql или nginx. Роль может иметь произвольное количество cookbooks. Сервер может иметь несколько ролей.
* node — сервер с указанным IP адресом.
##### Использование
Пришло время собрать все термины в логичную цепочку и понять, как же используется Chef.
Для настройки сервера вы описываете recipes внутри cookbooks, и выполняете их утилитой knife на node имеющего одну или несколько roles.
##### А теперь, практика
*Вам необходимо иметь Ruby, а если у вас его нет, то самое время установить [Ruby-lang.org](https://www.ruby-lang.org/ru/downloads/)*
**Установим и настроим Nginx на свежем сервере.**
Создаём директорию, например chef-test и переходим в нее.
Устанавливаем необходимые инструменты для работы: chef, knife-solo и berkshelf.
> Berkshelf — менеджер поваренных книг, аналог bundler
Создаём файл Gemfile со следующим содержанием:
```
source "https://rubygems.org"
gem 'knife-solo'
gem 'berkshelf'
```
Командой bundle заканчиваем установку
```
bundle
```
В текущей директории создаём кухню
```
knife solo init .
berks init .
```
В созданный Berksfile добавляем необходимые нам cookboks
```
cookbook 'nginx'
```
И скачиваем их
```
berks install
```
Описываем конфигурацию сервера (node)
В директории nodes создаем файл и называем его следующим образом: *.json*
Файл описывает: какие именно скрипты (recipes) необходимо выполнить на заданном сервере (node)
```
{
"nginx": {
"version": "1.6.0",
"install_method": "source",
"default_site_enabled": true,
},
"run_list": [
"recipe[nginx]"
]
}
```
**run\_list** указывает, какие именно рецепты или группы рецептов (role) необходимо выполнить.
В данном варианте, выполняется рецепт из [Nginx cookbook](https://github.com/miketheman/nginx/blob/master/recipes/default.rb)
Запускаем Chef и наслаждаемся работой машины за человека
```
knife solo bootstrap username@host -i ~/.ssh/ssh_key.pem
```
Результатом будет готовый сервер с работающим веб-сервером.
Если необходимо внести изменения, например сменить версию Nginx, достаточно поменять конфигурацию в **node** файле и выполнить
```
knife solo cook username@host -i ~/.ssh/ssh_key.pem
```
Chef применяет только рецепты, в которые были внесены изменения, так что можно не опасаться за сохранность конфигурации сервера.
Надеюсь эта статья помогла преодолеть барьер Chef, т.к. дальше вас ждёт только радость от простоты использования этого отличного инструмента.
Если данная тема вам интересна, в следующей статье я хотел бы описать процесс создания типичной инфраструктуры для rails приложения в Amazon AWS.
###### Альтернативы Chef
* [Ansible](http://www.ansible.com/home)
* [Puppet](http://puppetlabs.com)
###### Полезные ссылки
* [Get Chef](https://www.getchef.com/chef/)
* [Cooking Infrastructure by Chef](http://chef.leopard.in.ua/)
* [Стартовый шаблон Chef репозитория](https://github.com/opscode/chef-repo)
* [Поваренные книги от 37signals](https://github.com/priestjim/37s-cookbooks)
Мы используем эти инструменты в проекте [Staply](https://staply.co).
О нём мы расскажем уже совсем скоро!
[](http://drbl.in/nauq) | https://habr.com/ru/post/244111/ | null | ru | null |
# Excel, SQL и легендарный барометр — решаем простую задачу разными способами
На прошлой неделе в каком-то обсуждении всплыл старый хабротекст «[Стратегия для технического интервью](https://habrahabr.ru/company/luxoft/blog/152505/)». Точнее, приведённая в нём задача №4
> Дано: .xls (Excel) файл с одним листом в 4 числовых колонки и 1000 строк.
>
> Требуется: Загрузить его в SQL базу данных, таблица с соответствующими колонками имеется. Ну и, сперва, оценить время на решение.
Ну и мне стало интересно, сколькими максимально разнообразными и простыми способами я могу решить эту задачу, используя только то что есть у меня на компьютере.
**Update:** В коментариях рассказывают методы заполнения столбцов без «протягивания»: [раз](https://habrahabr.ru/post/312834/#comment_9862850), [два](https://habrahabr.ru/post/312834/#comment_9862854)
### 0. Прежде чем приступить к работе
В условиях задачи есть два очень важных пункта:
* нам дают готовый файл с данными
* таблица в базе данных уже создана
Оба эти пункта влияют на успешность решения поставленной задачи, состоящей в перемещении данных их XLS в SQL.
Начну со второго. Находящиеся в таблице данные могут не дать записать те данные что есть у Вас. Ну, например, если какой-то столбец это unique id, а в имеющейся таблице такой id уже есть. Тут всё просто. Узнаёте что делать с данными и либо первой операцией очищаете таблицу, либо вместо INSERT делаете REPLACE.
А теперь про полученный файл. Вы вот прямо так будете гнать его в базу? Уверены? А вы уверены что вам туда ничего лишнего не напихали? Все 1000 строк глазами проглядывать будете?
Я сделал просто — прямо в редакторе XLS-файла (в моём случае — LibreOffice Calc) применил регулярные выражения для удаления всего кроме числовых значений.
В результате остались только цифры, разделитель «запятая» и знак «минус».
Дальше я сделал замену «запятая» на «точка» и при сохранении в CSV получал данные вот такого вида:
> 11,4667.25,6874573,21336
>
> 12,466726,-6874574,21337
Теперь данные безопасны и SQL-friendly.
Я этому так много времени уделяю не из природного занудства, а потому что если данные не будут загружены из-за уже имеющихся или уничтожены из-за инъекции, то поставленная задача не будет выполнена.
Как говорил известный эксперт: «Лучше день потерять, зато потом за пять минут долететь!»
Итак, подготовительный этап завершён — полетели. В смысле, приступаем к выполнению задания различными способами.
**Update 2:** в комментариях навели на идею. Данные могут быть безопасны, но состоять из бессмысленного набора цифр, "-" и ",". В этом случае импорт сработает неполностью. Как поступаем:
— сперва делать прогон на тестовой таблице
— сразу в рабочую, но с роллбэком
?
### 1. Загружаю CSV в phpMyAdmin
Если есть phpMyAdmin (или аналог для используемого SQL), то:
* обеззараживаем данные (см. п.0)
* первой строкой в файле прописываем имена полей в SQL
* сохраняем CSV
* загружаем
### 2. SQL в веб-форму
Если нет веб-морды принимающей CSV, но есть принимающая просто SQL запросы то, казалось бы, это указанный в исходном тексте вариант:
> Добавлю колонку в excel файле, куда во всех ячейках вставлю (растяну) «insert into» и дополнительные колонки с запятыми, получу sql скрипт. Сразу плюс, даже в оценке не нуждаемся.
А вот и нет. Ну правда же, протягивать колонку с INSERT INTO ещё можно, но протягивать запятые. На 1000 строк. И так три раза. Нафиг-нафиг.
Тут вариантов два.
Во-первых, можно:
* обеззараживаем данные (см. п.0)
* сохранить данные в CSV, используя разделитель «запятая»
* открыть CSV в code-based текстовом редакторе (в моём случае — Notepad++ )
* заменить перевод строк на
```
);
INSERT INTO … (
```
* поправить первую и последнюю строчку файла
* пульнуть через форму
Во-вторых, можно не сохранять в CSV, а через буфер вставить содержимое таблицы в Notepad++ (предварительно выполнив п.0). Потом заменяем «табуляция» на «запятая», переносы строка на инсёрты, правим начало и конец файла. Постим через веб-форму.
### 3. Клиент SQL
Виндового клиента MySQL у меня нет уже давно (ни гуёвого, ни консольного). Да и доступ извне к нему врядли дадут. Поэтому заливаю файл полученный в п. 2 на сервер и делаю там в консоли.
```
mysql ... < ...sql
```
### 4. PHP-скрипт
Конечно же, идеальным вариантом будет написать скрипт на 10 строк, который будет делать fgetcsv(), формировать INSERT INTO и пулять всё это в базу.
Ну правда же, тот кто даёт Вам это тестовое задание в любой момент скажет «Ой, а мне надо что бы строчки у которых в третьем столбце стоят нечётные целые числа шли в другую таблицу» или «а в пятый столбец нужно было записывать кубический корень из произведения значений данных из всех 4 столбцов».
И у него не будет ответа на вопрос «чувак, а чё ты сам эти расчёты в Excel не сделал?». Всё что он сможет сказать «не я такой — жизнь такая».
Кстати, в этот скрипт можно вставить веб-форму с загрузкой CSV-файла, сделать обеззараживание данных и пусть автор задания сам всё грузит.
Хотя, конечно же, такой вариант не подходит. Этот скрипт с формочкой потом останется на сайте, про него забудут и будет какая-никакая, а дырка.
Поэтому, решаем задание так же как в п.2, только сохраняем всё в php-файл и вместо
```
);
INSERT INTO … (
```
делаем:
```
)",$connect);
mysql_query("INSERT INTO … (
```
Ну и mysql\_connect в начале
### 5. У меня же теперь есть Linux!
После обретения Windows Subsystem for Linux жизнь прям заиграла новыми красками.
Поэтому:
* обеззараживаем данные (см. п.0)
* сохранить данные в CSV, используя разделитель «запятая»
* и….
```
cat test.csv | awk '{ gsub("\r", ""); print "INSERT INTO … ( ... ) VALUES (" $0 ");"; }' | ssh ... mysql ..
```
Готово.
\* \* \*
А вот сейчас будет кусок из-за которых этот текст не только в хабе «[MySQL](https://habrahabr.ru/hub/mysql/)», но и в хабе «[Разработка веб-сайтов](https://habrahabr.ru/hub/webdev/)».
Кроме приведённых ранее очевидных вариантах решения поставленной задачи есть ещё 3:
* нанять суб-подрядчика
* поставить задачу подчинённому
* свалить эту хрень на другой отдел
Не надо, из-за желания доказать себе и окружающим, что ты ещё торт, делать эту фигню и отвлекаться от решения других задач. Есть случаи, когда человек не то что бы «может», а вот просто «обязан» переделегировать задачу.
Пора уже научиться расставлять приоритеты. | https://habr.com/ru/post/312834/ | null | ru | null |
# Результаты конкурса на лучшую #codejoke
Больше месяца назад [Microsoft User Group Винница](http://msug.vn.ua) [объявила конкурс](http://habrahabr.ru/blogs/crazydev/85317/), суть которого была в том, чтобы рассказать анекдот или историю с помощью программного кода. Призы были более чем стимулирующими — это Windows 7 Ultimate.
Время шло и накопилось достаточно много шуток-прибауток, спасибо всем участникам. Сегодня MSUG объявляет результаты конкурса.
**Первое место** и первый счастливый обладатель Windows 7 Максимальной — Виталий Домников ([dotCypress](https://habrahabr.ru/users/dotcypress/)). Виталий написал очень много интересных примеров, но большей популярности у общественности достиг следующий код.
> `if (Measure())
>
> {
>
> if (Measure())
>
> {
>
> if (Measure())
>
> {
>
> if (Measure())
>
> {
>
> if (Measure())
>
> {
>
> if (Measure())
>
> {
>
> if (Measure())
>
> {
>
> Cut();
>
> }
>
> }
>
> }
>
> }
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Второе место** — Colwin и [его исполнение](http://msug.vn.ua/forums/p/1124/3155.aspx#3155) хита Beatles, которому отправляется Windows 7 Максимальная.
> `class LetItBe
>
> {
>
> private Author I;
>
> private Author me;
>
> private MotherMary MotherMary;
>
> private MotherMary she;
>
>
>
> public LetItBe()
>
> {
>
> I = Author.instance();
>
> me = I;
>
> MotherMary = MotherMary.instance();
>
> she = MotherMary;
>
> }
>
>
>
> public static void main(String[] args)
>
> {
>
> if (I.FindMyself() && timesOfTrouble())
>
> {
>
> MotherMary.comesTo(me);
>
> MotherMary.speak(WordType.WORDS\_OF\_WISDOM, "Let it be");
>
> }
>
> if (I.isHourOfDarkness()) {
>
> assert (she.isStanding(Position.IN\_FRONT\_OF, me));
>
> she.speak(WordType.WORDS\_OF\_WISDOM, "Let it be");
>
> }
>
> letItBe();
>
> letItBe();
>
> I.whisper(WordType.WORDS\_OF\_WISDOM, "Let it be");
>
> }
>
> }`
Но и на этом мы не остановимся, поощрительные призы получают:
[Painkiller](http://msug.vn.ua/forums/p/1124/3684.aspx#3684) за украинскую классику.
> procedure Salo;
>
> var arrSaloLocations : array [0..25] of OleVariant;
>
> var oUkrNight, oSalo : OleVariant;
>
> var oOldSaloLocation : OleVariant;
>
> var ixSaloLocationsArray : integer;
>
> begin
>
> if (not oUkrNight.Noise) then
>
> if (oSalo.Exists) then
>
> begin
>
> oOldSaloLocation := oSalo.Location;
>
>
>
> repeat
>
> ixSaloLocationsArr := Random(VarArrayLowBound(arrSaloLocations), VarArrayHighBound(arrSaloLocations));
>
> until (oOldSaloLocation <> arrSaloLocations[ixSaloLocationsArray]);
>
>
>
> oSalo.Location := arrSaloLocations[ixSaloLocationsArray];
>
> end;
>
>
Антон aka [ant99](https://habrahabr.ru/users/ant99/) за его [шутку](http://habrahabr.ru/blogs/crazydev/85317/#comment_2547580):
> SELECT name FROM european\_proletarians
>
> UNION
>
> SELECT name FROM asian\_proletarians
>
> UNION
>
> SELECT name FROM african\_proletarians
>
> UNION
>
> SELECT name FROM american\_proletarians
>
> UNION
>
> SELECT name FROM australian\_proletarians
А также: [orange\_guard](http://msug.vn.ua/members/orange_5F00_guard/default.aspx), [Mezomish](http://habrahabr.ru/blogs/crazydev/85317/#comment_2547568), [Varnak](http://habrahabr.ru/blogs/crazydev/85317/#comment_2547488), [Mikant](http://msug.vn.ua/blogs/akrakovetsky/archive/2010/02/23/win-windows-7-codejoke-itfairytale-camp.aspx)
Все они получат любые 3 книги из [следующего списка](http://msug.vn.ua/blogs/techbooks/archive/2010/03/21/white-post-and-get-free-ebook-from-apress-and-msug-vinnitsya.aspx). Просьба победителей связаться с нами для получения призов.
Мы благодарим всех участников и предлагаем всем принять участие в акции [«книга за статью»](http://msug.vn.ua/blogs/techbooks/archive/2010/03/21/white-post-and-get-free-ebook-from-apress-and-msug-vinnitsya.aspx).
P.S. Приятно, что наша идея [пошла в массы](http://habrahabr.ru/special/microsoft/vs2010/konkurs/). | https://habr.com/ru/post/89717/ | null | ru | null |
# POS-terminal VeriFone Tranz 460 и его программирование
Приветствую всех.
Сегодня речь пойдёт о совершенно нетипичном для раздела ретро-железа оборудовании. Встречаются такие девайсы достаточно редко, а интересующихся ими ещё меньше.
Итак, сегодня мы вам расскажем об антикварном представителе банковского оборудования — POS-terminal'е VeriFone TRANZ 460. Постараемся собрать вместе всю информацию по данным устройствам.
### О чём я?
Загуглив «VeriFone Tranz», можно найти немало материалов по теме. Различные демки, фотографии внутренностей, даже полный реверс-инжиниринг прошивки. Но большинство проектов так или иначе связаны с написанием собственной прошивки и её загрузкой в EPROM терминала или даже с разборкой устройства и использованием только части компонентов от него. Тем не менее, если этот вариант вам нравится больше, ссылки будут представлены в конце поста.
Я же хочу рассказать вам о том, как написать что-либо под данное устройство без потери аутентичности, используя штатные программные средства производителя. Попутно узнаем, как выглядело типичное платёжное приложение, как загрузить программу в POS-terminal, где ещё применялись эти устройства, кроме как в платёжных решениях, и ещё много чего интересного.
Также рекомендую прочитать вот эту статью товарища [begoon](https://habr.com/ru/users/begoon/): [Платёжный терминал OMNI-395 изнутри](https://habr.com/ru/post/164693/).
### Немного истории
Компания VeriFone появилась в 1981 году и является детищем Уильяма «Билла» Мелтона. Первым её продуктом стало некое устройство, позволявшее проверять подлинность чеков по телефону (отсюда и название компании — Verification Telephone). А уже в 1984 был выпущен POS-terminal VeriFone ZON. Позже появились и другие аналогичные модели — ZON JR XL, ZON II, TRANZ. Их всех объединяло очень многое: процессор от Zilog, небольшой объём памяти, вакуумно-люминесцентный сегментный индикатор, идентичная раскладка клавиатуры. А также и методика программирования, о которой и пойдёт речь в данной статье. TRANZ 330 и ZON JR XL стали едва ли не самыми массовыми и наиболее долго эксплуатировавшимися POS-terminal'ами в истории: появившись в середине восьмидесятых, полностью исчезли они лишь в конце нулевых.
### Обзор оборудования
Ни ZON JR XL, ни TRANZ 330 найти мне так и не удалось. Объявлений достаточно много на eBay, однако с учётом доставки в Россию это будет не совсем дешёвым удовольствием. Вообще, выпускалось много моделей: TRANZ 380 (с увеличенным объёмом памяти) TRANZ 380 X2 (с поддержкой двух приложений и переключения между ними), TRANZIT и PNC (для работы в локальной сети проприетарной системы), TRANZ 340 (тоже что-то околосетевое).
Я раздобыл TRANZ 460. По сути он представляет собой TRANZ 380 с интегрированным принтером. Была также модель 420, это такая же модификация TRANZ 330.
Устройство в весьма средненьком состоянии: после списания аппарат несколько дней валялся на улице под дождём, но до электроники вода так и не добралась, что очень радует.
Спереди у него находятся клавиатура и экран (ВЛИ, на шестнадцать знакомест). Сверху индикатор питания и кнопка протяжки бумаги.
Сзади ничего интересного, лишь выштамповка в корпусе, выполняющая роль ручки для переноски. В отдельных модификациях TRANZ 460 там располагался свинцово-кислотный аккумулятор для резервного питания.
Сзади разъёмы для телефонной линии и БП (в хлам окисленные). Изначально терминал работал от двадцати четырёх вольт переменного тока, но опыт показал, что двенадцать вольт тоже отлично подойдут, даже при печати не было никаких проблем.
Разбираем. На обратной стороне платы микросхемы конвертеров уровней RS-232 и чуть-чуть дискретной логики.
Материнская плата отдельно. В панельке, собственно, сам процессор Zilog Z180. Из других микросхем тут есть:
* Z86C1112PSC — микроконтроллер семейства Z8;
* Z84C4006PEC — контроллер последовательных портов;
* Z84C3006PEC — системный таймер;
* Z84C2006PEC — контроллер параллельных портов;
* 73K224L — модем;
* OKI M6242B — часы реального времени.
На верхней части находится плата с ВЛИ, динамиком, клавиатурой и F/2F-декодером магнитного считывателя. Чуть выше — принтер.
Магнитный считыватель достаточно простой, читает только вторую дорожку.
Плата с кнопками отдельно. Микросхема от Micrel — контроллер ВЛИ.
Сбоку два порта RS-232 с разъёмами MDN-8P и MDN-6. В отличие от TRANZ 330, распиновка их в мануале скромно опущена. Распиновка тут такая:
DTR GND TX
RX CTS RTS
DCD GND
Принтер, разумеется, матричный. VeriFone продавала для него свои картриджи (с собственным P/N), но мы таки нашли, как называется оригинальный: Epson ERC-09B. Новый такой был без проблем приобретён в «Ситилинке», на момент написания статьи они были в свободной продаже.
Новый картридж Cactus CS-ERC09.
Снимем пластмассовую крышку. Принтер здесь не совсем типичной конструкции: иглы в головке расположены горизонтально. Мотор протяжки бумаги — обычный коллекторник. На его валу находится червячная муфта, рассчитанная так, чтобы при полном проходе головки бумага сдвигалась на расстояние одной точки. В качестве датчика нулевого положения головки — обычный геркон. Шестерни обмазаны густой липкой смазкой.
### Первое включение
Скорее всего, ваш аппарат будет с разряженной батарейкой, поэтому при включении на экране загорится **PROGRAMING ERR0**. Зажимаем Function+1, терминал должен запуститься. Далее жмём \*+3, загорится **DIAGNOSTICS**, на что нажимаем ALPHA. Выставляем дату и время. Или просто нажимаем CLEAR, этого достаточно для инициализации памяти и RTC.
При желании можно разобрать аппарат и припаять новую батарейку, в противном случае эти действия придётся производить каждый раз при включении аппарата.
### Пароли
Возможно, что этот пункт никогда вам не понадобится, но не будет лишним указать.
Стандартный пароль: *Z66831* (вводится как *1 ALPHA ALPHA 66831*).
Очистка памяти: зажать \*+CLEAR, ввести следующую комбинацию: *8 ALPHA 0 ALPHA 8 ALPHA 5361041 ALPHA ENTER*.
Других паролей в терминале нет (но они могут быть предусмотрены прошивкой).
### Меню
Без прошивки можно воспользоваться следующими функциями:
Function+7 — просмотр содержимого памяти;
Function+8 — редактирование содержимого памяти;
Function+ALPHA — изменить пароль;
Function+\* — выгрузка ПО;
Function+0 — загрузка по модему
Function+# — локальная загрузка.
Сочетания клавиши Function с цифрами от 1 до 6 не используются и могут быть задействованы в программе.
### На чём вообще под них писали?
Нее. Если вы думали, что для него были компиляторы для C, вы глубоко ошибаетесь. Такого для него не предоставлялось. Как, впрочем, для BASIC, Pascal или какого-то другого языка общего пользования. Программа для любого устройства серии ZON или TRANZ писалась на проприетарном языке TCL (Terminal control language). К более известному в широких кругах Tcl (Tool command language) никакого отношения он, понятное дело, не имеет.
По сути TCL является скриптовым языком. Программу можно набивать прямо с клавиатуры терминала, хоть это и очень неудобно. Сама VeriFone рекомендует для этого использовать свой софт для ПК, который загружает программу в память. При этом интерпретацией занимается всё равно сам POS-terminal, никаких действий с кодом на компьютере не производится.
Язык специально создан с учётом предельно малых объёмов памяти: каждая команда занимает один-два символа. Это очень неудобно, а также нисколько не интуитивно, но другого выхода тогда не было.
### TCLOAD
Существует три основных варианта загрузки ПО в терминал.
* Удалённый. На сервере банка установлено ПО ZonTalk. Терминал совершает звонок на модемный пул и получает прошивку. Собственно, этот способ и был самым распространённым: достаточно разместить короткую инструкцию с требованием ввести номер телефона и ID терминала, и пользователь сможет без труда загрузить прошивку сам.
* Локальный. Самой компанией VeriFone он позиционировался как вариант для разработчиков. Терминал подключается к компьютеру кабелем (распиновка была приведена чуть ранее), а загрузка производится при помощи ПО TCLOAD.
* От устройства к устройству. Два терминала соединяются нуль-модемным кабелем, после чего один передаёт свою прошивку на другой.
Наибольший интерес представляет, конечно, второй вариант. Для него нам понадобятся только кабель, компьютер с COM-портом и само ПО (разумеется, под DOS).
Первоначально в поисках проги я отправился на сайт VeriFone. Точнее, конечно, на его архивную копию из конца девяностых, где был раздел с материалами для ZON/TRANZ. Увы, TCLOAD'а там не обнаружилось, зато «всплыли» мануалы: руководства пользователя для Tranz'ов, TCLOAD Reference Manual, TCL Terminal Control Language Programmer's Manual. В принципе, ПО для загрузки прошивки можно написать самому, так как в мануалах описан формат пакетов данных и значение полинома для расчёта CRC-16. Но я хотел найти тот самый, аутентичный софт.
Далее я отправился на Yahoo.com, где после непродолжительных поисков TCLOAD был найден.
Если что, валялся он на файлообменнике 4shared.com, где также обнаружился TCLOAD.DBS — вспомогательный файл к данной программе, представляющий собой базу моделей терминалов.
И вот эта находка подводит нас к ещё одной области применения данных устройств.
### Что такое PunchPlus?
TRANZ — это по сути программируемый контроллер. Не самый мощный, но идеально подходящий для целого ряда задач. Помимо платёжных решений он также использовался, к примеру, в системах контроля доступа на объект или в качестве таймера учёта рабочего времени. Одной из таких систем стал PunchPlus от компании Service Info-Rapide (inforap.com). На её сайте (если открыть французскую версию) были обнаружены и оригинальный TCLOAD, и TCL-файл с программой. Скачать дистрибутив можно тут: [ссылка на дистрибутив](http://inforap.com/punchplus/download/ajaxplorer423/index.php) (все ссылки будут продублированы в конце поста).
Программа предназначена для работы с TRANZ 330, но прекрасно запускается на любых устройствах этой серии.
### А как насчёт банковского ПО?
Всё печально. Увы. Локальная загрузка вообще не была распространена, так что всё распространялось исключительно через модем. Каких-либо прямых ссылок на скачивание текста программы найдено не было.
Также следует отметить, что с завода терминалы поставлялись уже с прошивкой (она описывается в мануале к терминалу). Для большинства банков она полностью подходила и в модификации не нуждалась. Прошивку легко считать (опять таки потому что формат пакетов данных описан в TCLOAD Reference Manual), другое дело, что терминалов с прошивкой уже не осталось из-за разряда внутренней батарейки.
На момент написания статьи ничего подходящего найти так и не вышло (но был бы очень рад что-либо найти).
Впрочем, для желающих посмотреть, что представляло собой это самое ПО, вариант один таки есть. О нём будет рассказано чуть позже.
### TCL-файлы
TCLOAD не требует никакой установки (достаточно просто закинуть в рабочую папку), а также ничуть не критичен к процессору (ошибками типа Runtime error при запуске не сыпет). Запускать можно хоть в DOSbox с пробросом портов. Каких-то специальных режимов работы порта тоже не выставляется.
TCL-файл состоит из заголовка (номер модели, без которого TCLOAD не будет ничего загружать, список есть в мануале) и строчек с командами. Каждая строка представляет собой номер ячейки памяти, после которой стоят сами команды, отделённые знаком равенства. Если вместо "=" написать "$", команды можно писать с переводом строки, что сильно облегчает работу со скриптом. Также поддерживаются комментарии, выделяемые точкой с запятой в начале.
Перед выбором ячейки памяти откройте мануал и посмотрите её предназначение: некоторые из них зарезервированы и для размещения в них команд или данных не подходят.
Итак, открываем папку с ПО, где создаём текстовый документ, скажем, 1111.txt. Название и расширение значения не имеют. Открываем наш файл и пишем там:
`%9EAEU123
0030=HELLO WORLD`
Подключаем девайс кабелем к ПК, запускаем режим загрузки (на дисплее должно гореть **UNIT RECEIVE**), вводим команду:
`tcload 1111.txt /t1`
После этого файл должен немедленно загрузиться в память устройства. И после нажатия на «Cancel» на экране появится указанная в файле строка.
Разумеется, данный файл — это не совсем программа. В данном файле мы просто записали строку в ячейку памяти №30. Это IDLE PROMPT, то есть строка, отображающаяся на экране в режиме ожидания (если оставить её пустой, будут выводиться дата и время).
О значении других зарезервированных ячеек памяти можно посмотреть в документе TCLOAD Reference Manual.
Всего в Tranz 380/460 две тысячи ячеек памяти (0000-1999), в Tranz 330/420 их в два раза меньше (000-999). ZON имеет всего 478. Каждая ячейка памяти, в зависимости от версии ПО в EPROM устройства, вмещает в себя шестьдесят или сто двадцать байт, при этом «лишние» байты при загрузке отбрасываются.
### Начало исполнения
Начальным адресом для выполнения программы является ячейка памяти № 981. В ней могут быть прописаны какие-либо команды или же перенаправление на другую ячейку памяти. То, что записано в данной ячейке повторяется постоянно. При нажатии кнопки Clear и выходе из программы или же при её завершении она будет запущена заново через N секунд, где N — число, записанное в ячейке № 980. Если эти две ячейки памяти останутся пустыми, терминал будет показывать просто дату и время или строку IDLE PROMPT.
Также программу можно запустить сочетанием клавиш Function+N, где N — кнопки от 1 до 6. За это отвечают ячейки 31-36. Принцип их использования точно такой же.
Помимо функций, выполняют команды и простые нажатия клавиш в нормальном состоянии. Для этого служат ячейки N07, где N — номер кнопки от 1 до 9.
Если не задействовать ни одну из указанных ячеек, программа работать не будет.
### Пишем первую программу
Итак, ознакомившись со структурой TCL-файлов, можно и написать что-то своё.
Создаём текстовый документ и пишем там примерно следующее:
`%9EAEU123
231=HELLO HABRAHABR
31$ L446
446$
B.5
G
A231
V
G`
Загружаем программу, жмём Function+1. После чего на экране появится примерно следующее:
Теперь разберёмся, что тут вообще происходит. В отдельной ячейке памяти указана наша строка. Нажатие Function+1 выполняет команду L446 — переход к адресу 446, где и находится наша программа (следует отметить, что если программа занимает больше одной ячейки памяти, в конце каждого блока нужно указывать адрес следующего при помощи команды L).
На всякий случай отмечу: адреса для строки и команд взяты произвольно из списка таковых общего пользования, который есть в мануале. Можно использовать и другие подходящие, никаких проблем это не вызовет.
По адресу 446 находится, собственно, программа, состоящая из следующих команд:
B.5 — выбрать буфер №5;
G — удалить его содержимое;
A231 — поместить в буфер содержимое ячейки памяти № 231 (где и лежит наша строка);
V — вывести буфер на экран;
G — очистить буфер.
Достаточно просто, хоть и неудобно. Правда, из-за такого языка справиться с чтением программы на пару сотен строк (особенно если все ячейки памяти записаны в одну строчку) неподготовленному пользователю решительно невозможно.
### Печать
Ну, где дисплей, там и принтер. И программа, в общем-то, похожа:
`%9EAEU123
231=HELLO HABRAHABR
31$ L446
446$
B.5
G
A231
N
G`
Итак, за печать отвечает команда N. В терминалах со встроенным принтером печатается выбранный буфер, а в экземплярах без такового — буфер отправляется в последовательный порт, после чего туда же кидается управляющий символ Line Feed.
Более правильным вариантом будет такой:
`%9EAEU123
231=HELLO HABRAHABR
31$ L446
446$
B.5
G
A231
Z40.2
W
N1.1.2
G`
Здесь также используются команды Z и W (дополнить буфер пробелами для его выравнивания и приостановить выполнение программы до конца печати).
Итак, загружаем, нажимаем Function+1, после чего ~~на дисплее загорится **OUT OF PAPER**~~ наша строка будет распечатана.
У команды N здесь также используются несколько аргументов: один отступ при печати, печатать немедленно и при печати выводить на экран **PRINTING**, при отсутствии бумаги печатать через полсекунды после вставки (последний аргумент — число секунд / 2).
Аргументы разделяются между собой точками.
### Спикер
Ну, тут вообще всё очень и очень просто:
`%9EAEU123
31$ *G0
32$ *G1`
Аргумент «0» команды \*G позволяет вызвать высокий звук, аргумент «1» — низкий.
### Клавиатура
Для ввода данных с клавиатуры существует команда K.
Собственно, пример:
`%9EAEU123
231=ENTER DATA
31$ L446
446$
B.5
G
A231
V
G
K
N
G`
Вначале мы выводим строку «ENTER DATA». После нажатия клавиши Enter начнётся ожидание ввода с клавиатуры. А после подтверждения введённое значение будет занесено в буфер и отправлено на принтер.
### Магнитный считыватель
Теперь попробуем прочитать карту:
`%9EAEU123
231=SWIPE CARD
31$ L446
446$
B.5
G
A231
V
G
M
N
G`
Для ввода данных с магнитного считывателя существует команда M.
Также можно использовать команду E, позволяющую задействовать сразу магнитный считыватель или клавиатуру. Например, чтобы обеспечить возможность ввести номер или сразу провести картой.
### Предустановленные сообщения
Разумеется, в VeriFone понимали, что куча сообщений для всех пунктов меню займёт кучу памяти, которую можно было бы использовать более рационально. Поэтому в EPROM зашит целый ряд системных сообщений, которые можно выводить на экран командой F. Полный список приведён в мануале.
### DDSTRANZ
«Это, конечно, хорошо, но что делать, если такого терминала под рукой нет?» — скажете вы. Кое-что в данном случае можно предложить. На просторах был обнаружен [некий](https://dunfield.themindfactory.com/dds/tranztcl.htm) DDSTRANZ — ПО за авторством Dave Dunfield, представляющее собой симулятор терминала, пин-пада и процессингового центра. Свободно распространяемая версия имеет некоторые ограничения, но вполне подходит, чтобы вдоволь наиграться. Также в комплекте имеются и тестовые прошивки. Для запуска потребуется DOSbox и программа наподобие Virtual Serial Port Driver.
Я записал видео с демонстрацией работы тестовой прошивки:
Также демо-режим есть и в самом терминале — нажимаем \*+3, на экране загорится **DIAGNOSTICS**, затем жмём 9.
### Ну и что же теперь делать?
Собственно, практического применения всё это уже давно не имеет. Сами терминалы в этой стране уже являются достаточной редкостью (впрочем, на eBay их ещё полно), да и какими-то невероятными возможностями они не обладают. Тем не менее, попробовать что-то написать под них или посмотреть, как устроены имеющиеся прошивки, может быть интересно.
Такие дела.
### Ссылки
* [DDSTRANZ, TCLOAD, мануалы](http://old-dos.ru/index.php?page=files&mode=files&do=show&id=101047)
* [TRANZ/TCL Information](https://dunfield.themindfactory.com/dds/tranztcl.htm)
* [рекламный каталог целого модельного ряда антикварных POS-terminal'ов](http://posnetwork.net)
* [система контроля рабочего времени на базе TRANZ](http://inforap.com/)
* [дистрибутив этой системы](http://inforap.com/punchplus/download/ajaxplorer423/index.php)
* [типичная инструкция по загрузке ПО через телефонную линию](http://mail.globalcheck.com/vtdload.html) (самого ПО не нашлось. Увы)
* [материалы по реверс-инжинирингу TRANZ 330 и демка для него](https://www.bigmessowires.com/category/tranz330/)
* [обзор внутренностей ZON JR XL](http://jhallenworld.com/verifone.html)
* [ещё реверс-инжиниринг](https://github.com/al177/tranz330_re)
* [разборка TRANZ 330](https://www.youtube.com/watch?v=TDYfl-vJvY4)
* [разборка TRANZ 330](https://www.youtube.com/watch?v=2zv2nkrTh9Y)
* [разборка ZON JR XL](https://www.youtube.com/watch?v=-oXHjcfNYuc) | https://habr.com/ru/post/689878/ | null | ru | null |
# Глубокое обучение с подкреплением: пинг-понг по сырым пикселям
Это давно назревшая статья об обучении с подкреплением Reinforcement Learning (RL). RL – крутая тема!
Вы, возможно, знаете, что компьютеры теперь могут [автоматически учиться играть в игры ATARI](http://www.nature.com/nature/journal/v518/n7540/abs/nature14236.html) (получая на вход сырые игровые пиксели!). Они бьют чемпионов мира в игру [Го](http://googleresearch.blogspot.com/2016/01/alphago-mastering-ancient-game-of-go.html), виртуальные четвероногие учатся [бегать и прыгать](https://www.cs.ubc.ca/~van/papers/2016-TOG-deepRL/index.html), а роботы учатся выполнять сложные задачи манипуляции, которые бросают вызов явному программированию. Оказывается, что все эти достижения не обходятся без RL. Я также заинтересовался RL в течение прошлого года: я работал с книгой [Ричарда Саттона (прим.пер.: ссылка заменена)](https://www.google.com/search?q=richard+sutton+rl), читал курс [Дэвида Сильвера](http://www0.cs.ucl.ac.uk/staff/d.silver/web/Teaching.html), смотрел [лекции Джона Шульмана](https://www.youtube.com/watch?v=oPGVsoBonLM), написал [библиотеку RL на Javascript](http://cs.stanford.edu/people/karpathy/reinforcejs/), летом проходил практику в DeepMind, работая в группе DeepRL, и совсем недавно — в разработке [OpenAI Gym](https://gym.openai.com/), – нового инструментария RL. Так что я, конечно, был на этой волне, по крайней мере, год, но до сих пор не удосужился написать заметку о том, почему RL имеет большое значение, о чем он, как все это развивается.
*Примеры использования Deep Q-Learning. Слева направо: нейросеть играет в ATARI, нейросеть играет в AlphaGo, робот складывает Лего, виртуальный четвероногий бегает по виртуальным препятствиям.*
Интересно поразмышлять о характере недавнего прогресса в RL. Мне хочется отметить четыре отдельных факторах, влияющих на развитие ИИ:
1. Скорость вычислений (GPU, специальные устройства ASIC, закон Мура)
2. Достаточное количество данных в пригодном виде (например, ImageNet)
3. Алгоритмы (исследования и идеи, например, backprop, CNN, LSTM)
4. Инфраструктура (Linux, TCP/IP, Git, ROS, PR2, AWS, AMT, TensorFlow и т. д.).
Так же, как и в компьютерном зрении, прогресс в RL движется, …хотя но не так сильно, как может показаться. Например, в компьютерном зрении нейросеть AlexNet 2012 является увеличенной в глубину и ширину версией нейросети ConvNets 1990-х годов. Точно так ATARI Deep Q-Learning 2013 года представляет собой реализацию стандартного алгоритма Q-Learning, который вы можете найти в классической книге Ричарда Саттона 1998 года. Далее, AlphaGo использует технику Policy Gradient и поиск по дереву Монте-Карло (MCTS) — это также старые идеи или их комбинации. Конечно, требуется много навыков и терпения, чтобы заставить их работать, и было разработано множество хитрых настроек поверх старых алгоритмов. **Но в первом приближении основным драйвером недавнего прогресса являются не новые алгоритмы и идеи, а – интенсификация вычислений, достаточные данные, зрелая инфраструктура.**
Теперь вернемся к RL. Много людей не могут поверить, что мы можем научить компьютер играть в игры ATARI на человеческом уровне по сырым пикселями с нуля и используя один и тот же самообучающийся алгоритм. При этом всякий раз я ощущаю разрыв – каким оно кажется волшебным, и как просто оно устроено внутри на самом деле.
Основной подход, который мы используем, на самом деле довольно тупой. Как бы то ни было, я бы хотел познакомить вас с техникой Policy Gradient (PG), – нашим любимым выбором по умолчанию для решения проблем с RL на данный момент. Вам может быть любопытно, почему я вместо этого не представляю DQN, который является альтернативным и более известным алгоритмом RL, который тоже используется при [обучении ATARI](http://www.nature.com/nature/journal/v518/n7540/abs/nature14236.html). Оказывается, хоть Q-Learning известен, но не так уж идеален. Большинство людей предпочитают использовать Policy Gradient, включая авторов оригинальной [статьи по DQN](http://arxiv.org/abs/1602.01783), которые показали, что при хорошей настройке Policy Gradient работает даже лучше, чем Q-Learning. PG предпочтительнее, потому что он явный: есть четкая политика и внятный подход, который напрямую оптимизирует ожидаемое вознаграждение. В качестве примера мы научимся играть в ATARI Pong: с нуля, из сырых пикселей через Policy Gradient с нейронной сетью. И все это уложим в 130 строк Python. ([Gist link](https://gist.github.com/karpathy/a4166c7fe253700972fcbc77e4ea32c5) )Давайте разберем, как это делается.
*Выше: Пинг-Понг. Ниже: Представление Пинг-понга, как специальный случай [марковского процесса принятия решений (MDP)](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%80%D0%BA%D0%BE%D0%B2%D1%81%D0%BA%D0%B8%D0%B9_%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81_%D0%BF%D1%80%D0%B8%D0%BD%D1%8F%D1%82%D0%B8%D1%8F_%D1%80%D0%B5%D1%88%D0%B5%D0%BD%D0%B8%D0%B9) : Каждая вершина графа соответствует определенному состоянию игры, а ребра определяют вероятности перехода в другие состояния. Каждое ребро так же определяет вознаграждение. Целью является нахождение оптимального пути из любого состояния чтобы максимизировать награду*
Игра в Пинг-Понг является отличным примером задачи RL. В версии ATARI 2600 мы будем играть одной ракеткой сами. Другая ракетка контролируется встроенным алгоритмом. Нам нужно отбивать мяч так, чтобы другой игрок не успел его отбить. Надеюсь, что нет необходимости объяснять, что такое Пинг-Понг. На низком уровне игра работает следующим образом: мы получаем кадр изображения — массив байтов 210x160x3, и решаем, – хотим ли мы перемещать ракетку ВВЕРХ или ВНИЗ. То есть имеем всего два выбора по управлению игрой. После каждого выбора игровой симулятор выполняет свое действие и дает нам вознаграждение: либо +1 вознаграждение, если мяч прошел мимо ракетки соперника, либо -1, если мы пропустили мяч. В противном случае 0. И, конечно же, наша цель состоит в том, чтобы перемещать ракетку, чтобы мы получили как можно большее вознаграждение.
При рассмотрении решения помните, что мы попытаемся сделать ооочень мало предположений о понге, потому что он сам по себе не особо важен на практике. Мы намного больше вещей учитываем в масштабных задачах, таких как манипуляции с роботами, сборка и навигация. Понг — это просто забавный игрушечный тестовый пример, с которым мы играем, пока разбираемся, как писать очень общие системы ИИ, которые однажды могут выполнять произвольные полезные задачи.
**Нейросеть в качестве политики RL**. Во-первых, мы собираемся определить так называемую политику, которая реализует наш игрок (или «агент»). ((\*)«Агент», «среда» и «политика агента» — это стандарные термины из теории RL). Функция политики в нашем случае — это нейросеть. Она примет на вход состояние игры и на выходе решит, что нам делать – двигаться вверх или вниз. В качестве нашего любимого простого блока вычислений мы будем использовать двухслойную нейронную сеть, которая берет сырые пиксели изображения (всего 100 800 чисел (210 \* 160 \* 3)) и выдает одно число, указывающее вероятность двигать ракетку вверх. Обратите внимание, что использование стохастической политики является стандартным, что означает, что мы производим только вероятность движения вверх. Чтобы получить фактический ход мы будем использовать эту вероятность. Причина этого станет более понятной, когда мы поговорим о тренировках.
*Наша функция политики, состоящая из 2х слойной полносвязанной нейросети*
Говоря конкретнее, предположим, что на вход мы полчаем вектор Х, который содержит набор предобработанных пикселей. Тогда мы должны вычислить с помощью python\numpy:
```
h = np.dot(W1, x) # compute hidden layer neuron activations
h[h<0] = 0 # ReLU nonlinearity: threshold at zero
logp = np.dot(W2, h) # compute log probability of going up
p = 1.0 / (1.0 + np.exp(-logp)) # sigmoid function (gives probability of going up)
```
В этом фрагменте W1 и W2 – это две матрицы, которые мы инициализируем случайным образом. Мы не используем смещения (bias), потому что так захотелось. Обратите внимание, что в конце мы используем нелинейность сигмоида, которая сводит выходную вероятность к диапазону [0,1]. Интуитивно понятно, что нейроны в скрытом слое (веса которых расположены в W1) могут обнаруживать различные игровые сценарии (например, мяч находится сверху, а наша ракетка находится посередине), а веса в W2 могут затем решить, должны ли мы в каждом случае идти вверх или вниз. Начальные случайные W1 и W2, конечно, поначалу будут вызывать у нашего нейро-игрока спазмы и конвульсии, что приравнивает его к имбицилу-аутисту за штурвалом самолета. Так что единственной задачей сейчас является найти W1 и W2, которые ведут к хорошей игре!
Имеется замечание о предварительной обработке пикселей, – в идеале надо передать как минимум 2 кадра в нейросеть, чтобы она могла обнаруживать движение. Но чтобы упростить ситуацию, мы будем подавать разность двух кадров. То есть будем вычитать текущий и предыдущий кадры и только затем подавать разницу на вход нейросети.
**Звучит как нечто невозможное.** На этом этапе я бы хотел, чтобы вы оценили, насколько сложна проблема RL. Мы получаем 100 800 чисел (210х160х 3) и пересылаем в нашу нейросеть, реализующую политику игрока (которая, кстати, легко включает порядка миллиона параметров в матрицах W1 и W2). Предположим, что мы в какой-то момент решили пойти вверх. Симулятор игры может ответить, что на этот раз мы получим 0 наград и дадим нам еще 100 800 чисел для следующего кадра. Мы можем повторить этот процесс сотни раз, прежде чем получим ненулевое вознаграждение! Например, предположим, мы наконец получили награду +1. Это замечательно, но как тогда мы можем сказать, – что к этому привело? Было ли это то действие, что мы сделали только сейчас? Или, может быть, 76 кадров назад? Или, может быть, это было связано сначала с кадром 10, а затем мы что-то правильно сделали в кадре 90? И как мы выясним, – какую из миллиона «ручек» крутить, чтобы добиться еще большего успеха в будущем? Мы называем это задачей определения коэффициента доверия к тем или иным действиям. В конкретном случае с понгом мы знаем, что получаем +1, если мяч прошел мимо соперника. Истинная причина в том, что мы случайно пнули мяч по хорошей траектории несколько кадров назад, а каждое последующее действие, которое мы выполняли, никак не влияло. Другими словами, мы столкнулись с очень сложной вычислительной проблемой, и все выглядит довольно мрачно.
**Обучение с учителем.** Прежде чем мы углубимся в градиент политики (PG), я хотел бы кратко вспомнить про обучении c учителем, потому что, как мы увидим, RL очень похож. В обучении с учителем есть функция потерь, которую мы минимизируем.При этом всегда используем градиентный спуск по одной и той-же схеме. В обучении с подкреплением схема меняется. Иногда мы делаем градиентный спуски. Иногда градиентный подъем. Если выиграли, — значит спуск. Если проиграли, — значит подъем.
Обратитесь к диаграмме ниже. В обычном обучении с учителем мы будем передавать изображение в сеть и получать на выходе некоторые числовые вероятности для классов. Например, в нашем случае имеем два класса: ВВЕРХ и ВНИЗ. Я использую логарифмические вероятности (-1,2, -0,36) вместо вероятностей в формате 30% и 70%, потому что мы оптимизируем логарифмическую вероятность правильного класса (или метки). Это делает математические выкладки элегантнее и эквивалентно оптимизации просто вероятности, потому что логарифм является монотонным.
В обучении с учителем у нас будет мгновенный доступ к правильному классу (метке). На этапе обучения нам точно скажут, какой именно сейчас нужно сделать правильный шаг (допустим это ВВЕРХ, метка 0), хотя нейросеть возможно думает иначе. Поэтому вычисляем градиент , чтобы подправить параметры сети. Этот градиент как раз и подсказывает, как мы должны изменить каждый из наших миллионов параметров, чтобы сеть немного с большей вероятностью предсказывала ВВЕРХ в такой же ситуации. Например, один из миллиона параметров в сети может иметь градиент -2.1, что означает, что если бы мы увеличили этот параметр на небольшую положительную величину (например, 0,001), то логарифмическая вероятность UP снизилась бы на 2,1 \* 0,001. (уменьшение из-за отрицательного знака). Если мы применим градиент и затем обновим параметр с помощью алгоритма обратного распространения, то, да, наша сеть будет выдавать большую вероятность ВВЕРХ, когда увидит такое же или очень похожее изображение в будущем.
**Градиенты политики (PG)**. Хорошо, но что нам делать, если у нас нет правильной метки обучения подкреплению? Вот решение для PG (снова обратитесь к диаграмме ниже). Наша нейросеть рассчитала вероятность подъема на 30% (logprob -1.2) и ВНИЗ на 70% (logprob -0.36). Теперь мы делаем выборку из из этого распределения и конкретизируем, какое именно действие сделаем. Например, выбрали ВНИЗ и послали это действие игровому симулятору. В этот момент обратите внимание на один интересный факт: мы могли бы сразу вычислить и применить градиент для действия ВНИЗ, как мы это делали в обучении с учителем, и тем самым побудить сеть с большей вероятностью выполнить действие ВНИЗ в будущем. Таким образом, мы можем сразу оценить и запомнить этот градиент. Но проблема в том, что на данный момент мы еще не знаем, – хорошо ли идти ВНИЗ? **Но самое интересно то, что мы можем просто немного подождать и применить градиент позже!** В Понге мы можем подождать до конца игры, затем взять полученное вознаграждение (либо +1, если мы выиграли, либо -1, если мы проиграли), и ввести его в качестве множителя к градиенту. Так что, если мы введем -1 для вероятности ВНИЗ и сделаем обратное распространение, то перестроим параметры сети, чтобы менее вероятно выполнять действие ВНИЗ будущем, когда встретит такую же картинку, так как принятие этого действия привело к тому, что мы проиграли игру. То есть нам надо будет как-то запомнить все действия (входы и выходы нейросети) в одном эпизоде игры и на основании этого массива подкрутить нейросеть почти так же, как и в обучении с учителем.
И это все, что надо: у нас есть стохастическая политика, которая выбирает действия, а затем в будущем поощряются действия, которые в конечном итоге приводят к хорошим результатам, а действия, которые приводят к плохим результатам, не поощряются. Кроме того, награда даже не должна быть +1 или -1, если мы в конечном итоге выиграем игру. Это может быть произвольная величина такого же смысла. Например, если все получится действительно хорошо, то награда может быть 10.0, которую мы затем используем как градиент, чтобы начать обратное распространение backprop. В этом красота нейронных сетей. Их использование может показаться обманом: вам разрешено иметь 1 миллион параметров, встроенных в 1 терафлоп вычислений, и вы можете заставить программу обучаться делать произвольные вещи со стохастическим градиентным спуском (SGD). Это не должно работать, но забавно, что мы живем во вселенной, где это работает.
Если бы мы играли в простые настольные игры, типа шашек, то порядок был бы примерно таким же. При этом есть заметное отличие от алгоритмов минимакса или альфа-бета отсечения. В этих алгоритмах программа заглядывает на несколько шагов вперед, зная правила игры, и анализирует миллионы позиций. В подходе же RL анализируются только фактически сделанные ходы. При этом нейросеть не заглядывает вперёд, так как ничего не знает о правилах игры.
**Порядок тренировки в деталях.** Мы создаем и инициализируем нейросеть с некоторыми W1, W2 и сыграем в 100 игр понга (мы называем это «обкатка» политики, policy rollouts). Предположим, что каждая игра состоит из 200 кадров, так что в общей сложности мы приняли 100\*200 = 20 000 решений идти вверх или вниз. И для каждого из решений мы знаем градиент, который говорит нам, как должны изменится параметры, если мы хотим поощрять или запрещать это решение в этом состоянии в будущем. Все, что остается сейчас, — это маркировать каждое принятое нами решение как хорошее или плохое. Например, предположим, что мы выиграли 12 игр и проиграли 88. Мы примем все 200 \* 12 = 2400 решений, которые мы приняли в играх-победителях, и сделаем положительное обновление (заполняя градиент +1.0 для каждого действия, выполняя backprop, и обновление параметров, поощряющее действия, которые мы выбрали во всех этих состояниях). И мы примем другие 200 \* 88 = 17600 решений, которые мы приняли в проигрышных играх, и сделаем негативное обновление (не одобряя того, что мы сделали). И это все, что надо. Сеть теперь станет с большей вероятностью повторять действия, которые сработали, и немного с меньшей вероятностью повторять действия, которые не сработали. Теперь мы играем еще 100 игр с нашей новой, немного улучшенной политикой, а затем повторяем применение градиентов.
*Мультипликационная схема из 4 игр. Каждый черный круг — это какое-то игровое состояние (три примера состояний показаны внизу), а каждая стрелка — это переход, помеченный действием, которое было выбрано. В этом случае мы выиграли 2 игры и проиграли 2 игры. Мы брали две выигранные нами игры и слегка поощряли каждое действие, которое мы сделали в этом эпизоде. И наоборот, мы также возьмем две проигранные игры и слегка отговорим от каждого отдельного действия, которое мы сделали в этом эпизоде.*
Если вы поразмышляете над этим, вы начнете находить несколько забавных свойств. Например, что если мы сделали хорошее действие в 50 кадре, правильно пиная мяч, но затем пропустили мяч в 150 кадре? Так как мы проиграли партию, то каждое отдельное действие теперь помечено как плохое, и разве это не помешает правильному удару на 50 кадре? Вы правы — так и будет для этой партии. Однако, когда вы рассматриваете процесс в тысячах / миллионах игр, то правильное выполнение отскока повышает вашу вероятность выиграть в будущем. В среднем вы увидите больше положительных, чем отрицательных обновлений для правильного удара ракеткой. И нейросеть, реализующая политику, будет в конечном итоге выдавать правильные реакции.
*Обновление: 9 декабря 2016 г.* — альтернативный взгляд. В своем объяснении выше я использую такие термины, как «определение градиента и обратное распространение backprop», что является определенным искусным приемом. Если вы привыкли писать собственный код обратного распространения backprop или используете Torch, когда вы можете полностью управлять градиентами. Однако, если вы привыкли к Theano или TensorFlow, вы будете немного озадачены, потому что код backprop полностью автоматизирован и его трудно настроить под себя. В этом случае следующий альтернативный взгляд может быть более продуктиным. В обучении с учителем обычная цель состоит в том, чтобы максимизировать , где  — обучающие примеры (такие как изображения и их метки). Применение градиента к функции политики в точности совпадает с обучением с учителем, но с двумя небольшими отличиями: 1) у нас нет правильных меток , поэтому в качестве «поддельной метки» мы используем действие, которое мы получили для выборки из политики, когда она увидела , и 2 ) Мы вводим еще коэффициент целесообразности (advantage) для каждого действия. Таким образом, в итоге наша потеря теперь выглядит как , где  — это действие, которое мы провели с выборкой, а  — это число, которое мы называем коэффициентом целесообразности. Например, в случае с понгом значение  может быть равно 1.0, если мы в конечном итоге выиграем в эпизоде, и -1.0, если мы проиграли. Это гарантирует, что мы максимизируем вероятность регистрации действий, которые привели к хорошему результату, и минимизируем вероятность регистрации тех действий, которые этого не сделали. А нейтральные действия в результате многих заходов не будут особо влиять на функцию политики. Таким образом, обучение с подкреплением точно такое же, как обучение с учителем, но на постоянно меняющемся наборе данных (эпизодах), с дополнительным коэффициентом.
**Более продвинутые функции целесообразности.** Я также обещал немного больше информации. До сих пор мы оценивали правильность каждого отдельного действия, основываясь на том, выиграем мы или нет. В более общей настройке RL мы будем получать «зависящее от условий вознаграждение»  за каждый шаг в зависимости от номера шага или времени. Одним из распространенных вариантов является использование дисконтированного коэффициента, поэтому «возможное вознаграждение» на приведенной выше диаграмме будет , где  — это число от 0 до 1, называемое коэффициентом дисконтирования (например, 0,99). Выражение говорит, что сила, с которой мы поощряем действие, представляет собой взвешенную сумму всех наград, но последующие награды экспоненциально менее важны. То есть лучше поощряются короткие цепочки действий, а хвост у длинных цепочек действий становится менее важным. На практике также бывает нужно их нормализовать. Например, предположим, что мы вычисляем для всех 20 000 действий в серии из 100 эпизодов игры. Очень хорошая идея — нормализировать эти значения (вычесть среднее, разделить на стандартное отклонение), прежде чем мы подключим их к алгоритму backprop. Таким образом, мы всегда поощряем и препятствуем примерно половине выполненных действий. Это уменьшает флуктуации и делает политику более сходимой. Более глубокое исследование можно найти по [[ссылке](http://arxiv.org/abs/1506.02438)].
**Производная от функции политики.** Я также хотел кратко рассказать, как градиенты берутся математически. Градиенты функции политики являются частным случаем более общей теории. Общий случай состоит в том, что когда у нас есть выражение вида ![$E_{x \sim p(x \mid \theta)} [f(x)]$](https://habrastorage.org/getpro/habr/formulas/148/46b/3eb/14846b3eb7a4a54ef61f4181cf02ada8.svg), то есть матожидание некоторой скалярной функции  при некотором распределении её параметра , параметризованного некоторым вектором . Тогда  станет нашей функцией вознаграждения (или функцией целесообразности в более общем смысле), а дискретное распределение  будет нашей политикой, которая на самом деле имеет вид , давая вероятности того или иного действия a для картинки . Затем нас интересует, как нам сместить распределение p через его параметры , чтобы увеличить  (т.е. как мы изменим параметры сети, чтобы действия получили более высокое вознаграждение). У нас есть это:
![$\begin{align} \nabla_{\theta} E_x[f(x)] &= \nabla_{\theta} \sum_x p(x) f(x) & \text{определение матожидания} \\ & = \sum_x \nabla_{\theta} p(x) f(x) & \text{меняем сумму и градиент местами} \\ & = \sum_x p(x) \frac{\nabla_{\theta} p(x)}{p(x)} f(x) & \text{умножаем и делим на } p(x) \\ & = \sum_x p(x) \nabla_{\theta} \log p(x) f(x) & \text{используем факт, что} \nabla_{\theta} \log(z) = \frac{1}{z} \nabla_{\theta} z \\ & = E_x[f(x) \nabla_{\theta} \log p(x) ] & \text{определение матожидания} \end{align}$](https://habrastorage.org/getpro/habr/formulas/1e4/155/d52/1e4155d521cfb70adbfc198fb2f7e5a7.svg)
Постараюсь объяснить это. У нас есть некоторое распределение  (я использовал сокращение , из которого мы можем произвести выборку конкретных значений. Например, это может быть гауссово распределение, из которого генератор случайных чисел производит выборку. Для каждого примера мы также можем вычислить функцию оценки , которая по текущему примеру дает нам некоторую скалярную оценку. Полученное уравнение говорит нам о том, как мы должны сдвинуть распределение через его параметры , если мы хотим, чтобы дальнейшие примеры действий на его основе получали более высокие показатели . Берем несколько примеров действий  и их оценки , и также для каждого x также оцениваем второй член . Что это за множитель? Это как раз и есть вектор — градиент, который дает нам направление в пространстве параметров, которое приведет к увеличению вероятности конкртетного действия . Другими словами, если бы мы подтолкнули θ в направлении , мы бы увидели, что новое вероятность этого действия немного возрастет. Если вы оглянетесь на формулу, она говорит нам о том, что мы должны взять это направление и умножить на него скалярное значение . Это сделает так, что примеры действий с более высокой оценкой (в нaшем случае вознаграждением) будут «тянуть» сильнее, чем примеры с более низким показателем, поэтому, если бы мы делали обновление на основе нескольких выборок из , плотность вероятности сместилась бы в направление более высоких результирующих баллов игры, что повышает вероятность получения примеров действий с высоким вознаграждением. Важно, что градиент не берется от функции , так как она вообще может быть недифферинцируемой и непредсказуемой. А  дифференцируема по . То есть  является плавно настраиваемым дискретным распределением, где можно регулировать вероятности отдельных действий. Так же будем считать, что  нормализовано.
*Визуализация градиента. Слева: Гауссово распределение и несколько примеров из него (синие точки). На каждой синей точке мы также наносим градиент логарифмической вероятности относительно среднего параметра. Стрелка указывает направление, в котором следует сместить среднее значение распределения, чтобы увеличить вероятность этого примера действий. В середине: Добавлена некоторой функции оценки, дающей -1 везде, кроме +1 в некоторых небольших регионах (обратите внимание, что это может быть произвольная и не обязательно дифференцируемая скалярная функция). Стрелки теперь имеют цветовую кодировку, потому что из-за умножения мы собираемся усреднить все зеленые стрелки с положителной оценкой и отрицательные красные стрелки. Справа: после обновления параметров зеленые стрелки и перевернутые красные стрелки подталкивают нас влево и вниз. Образцы из этого распределения теперь будут иметь более высокую ожидаемую оценку, по желанию.*
Я надеюсь, что связь с RL ясна. Наша политика дает нам примеры действий, и некоторые из них работают лучше, чем другие (судя по функции целесообразности). Способ изменить параметры политики состоит в том, надо выполнить прогон, взять градиент выбранных действий, умножить его на оценку и добавить все, что мы и сделали выше. Для более тщательного вывода я рекомендую лекцию [Джона Шульмана.](http://www.youtube.com/watch?v=oPGVsoBonLM)
**Обучение.** Хорошо, мы разработались в принципах градиентов функции политики. Я реализовал весь подход в [130-строчном скрипте Python](http://gist.github.com/karpathy/a4166c7fe253700972fcbc77e4ea32c5), который использует готовый эмулятор ATARI 2600 Pong от [OpenAI Gym](http://gym.openai.com/). Я обучил двухслойную нейросеть с 200 нейронами скрытого слоя, используя алгоритм RMSProp для серий из 10 эпизодов (каждый эпизод по правилам состоит из нескольких розыгрышей мяча и эпизод продолжается до счета 21). Я не слишком настраивал гиперпараметры и проводил эксперимент на своем медленном Macbook, но после трехдневной тренировки я получил политику, которая играет чуть лучше, чем у встроенного игрока. Общее количество эпизодов составило приблизительно 8 000, поэтому алгоритм сыграл примерно 200 000 игр в понг, что довольно много, и произвел в общей сложности ~ 800 обновлений весов. Если бы я тренировался на GPU с ConvNets, то в течение нескольких дней, смог бы добиться больших результатов, а если оптимизировал бы гиперпараметры, то можно было бы побеждать всегда. Тем не менее, я не тратил слишком много времени на вычисления или настройку, поэтому вместо этого мы получили Pong AI, который иллюстрирует основные идеи и работает достаточно хорошо:
[](https://www.youtube.com/watch?v=YOW8m2YGtRg)
*Видео по ссылке. Обучающийся агент играет против алгоритмического агента*
**Выученные веса.** Мы также можем взглянуть на полученные веса нейросети. Благодаря предварительной обработке каждый из наших входов представляет собой разностное изображение 80x80 (текущий кадр минус предыдущий кадр). Каждый нейрон из слоя W1 соединен со скрытым слоем W2, состоящим из 200 нейронов. Количество связей равно 80\*80\*200. Попробуем проанализировать эти связи. Будем перебирать все нейроны слоя W2 и визуализировать, какие веса к нему ведут. Из весов, которые ведут к одному нейрону W2 от нейронов W1 сделаем картинки 80x80. Ниже представлены 40 таких картинок W2 (всего их 200). Белые пиксели — это положительные веса, а черные — отрицательные. Обратите внимание, что несколько нейронов W2 настроились на летящего мяча, закодированные пунктирными линиями. В игре мяч может находиться только в одном месте, поэтому эти нейроны являются многоцелевыми и будут «стрелять», если мяч окажется где-то внутри этих линий. Чередование черного и белого интересно, потому что, когда шар движется вдоль трассы, активность нейрона будет колебаться как синусоида. И из-за ReLU он будет «стрелять» только в отдельные позиции. На изображениях наблюдается много шума, который, был бы меньше, если бы я использовал регуляризацию L2.
**Чего не происходит.** Итак, мы научились играть в понг по картинкам используя градиент функции политики, и это работает довольно хорошо. Этот подход представляет собой причудливую форму «предположить и проверить», где «предположение» относится к прогонке нашей политики на нескольких эпизодах игры, а «проверка» приводит к поощрению действий, которые приводят к хорошим результатам. В целом это представляет собой современный уровень того, как мы в настоящее время подходим к проблемам обучения с подкреплением. Если вы поняли алгоритм интуитивно и знаете, как он работает, вы должны быть по крайней мере немного разочарованы. В частности, когда это не работает?
Сравните это с тем, как человек может научиться играть в понг. Вы сами показываете им игру и говорите что-то вроде: «Вы управляете ракеткой, и вы можете перемещать его вверх и вниз, и ваша задача – отбросить мяч мимо другого игрока, контролируемого встроенной программой», и вы готовы к работе. Обратите внимание на некоторые различия:
* На практике мы сообщаем правила и задачу игрока каким-либо образом, например, устно или письменно, на русском или английском языках. Но в стандартной задаче RL у вас имеется заранее неизвестная функция вознаграждения, которую вы должны обнаружить посредством взаимодействия с окружением. Если бы человек начал играть в понг, при этом ничего не зная о вознаграждении (особенно если бы функция вознаграждения включала бы элемент случайности), то человеку было бы очень трудно узнать, что делать. Но методика с градиентом функции политики к этому безразлична. Точно так же, если бы мы случайным образом взяли кадры и переставили пиксели, то люди, скорее всего, ничего не поймут, но наше решение с градиентом функции политики даже не смогло бы различить, особенно, если сеть полносвязанная, как тут.
* Человек носит огромное количество предварительных знаний, таких как интуитивная физика (мяч подпрыгивает, он вряд ли телепортируется, он вряд ли внезапно остановится, он поддерживает постоянную скорость и т.д.), И интуитивная психология (противник «хочет» «Чтобы выиграть, скорее всего, следует, бить по мячу так-то и так-то и т. д.). Вы также сразу понимаете концепцию «управления» ракеткой и как она реагирует на команды клавиш ВВЕРХ / ВНИЗ. Напротив, наши алгоритмы начинаются с нуля, что одновременно впечатляет (потому что он работает) и удручает (потому что у нас нет конкретных идей, как этого не делать).
* Градиенты функции политики — это грубое решение (brute force), в котором правильные действия в конечном итоге обнаруживаются и внедряются в политику, даже если они интуитивно непонятны для человека. Люди же строят богатую абстрактную модель и планируют и предугадывают действия исходя из модели. Увидя и проанализоровав понг мы можем рассуждать, что противник довольно медленный, поэтому хорошей тактикой может быть заброс мяча с высокой вертикальной скоростью, чтобы он не успел его поймать. Мы также чувствуем, что со временем мы «внедряем» хорошие решения в то, что больше похоже на политику реактивной мышечной памяти. Вы часто чувствуете, что вначале много думаете, но в конечном итоге задание становится автоматическим и безсознательным.
* С нашей абстрактной моделью игры люди могут предугадать, что может дать вознаграждение, даже не делая практических телодвижений. Эволюция научила человека тому, что ему нет уже необходимости несколько сотен раз врезаться в стену своей машиной, прежде он постепенно начнет объезжать препятствие. Он может в уме предугадать последствия того или иного действия заранее.
*Слева: Месть Монтесумы: сложная игра для наших алгоритмов RL. Игрок должен спрыгнуть, взобраться наверх, достать ключ и открыть дверь. Человек понимает, что приобретение ключа полезно. Компьютер отбирает миллиарды случайных движений, и 99% времени падает и разбивается или его убивает монстр. Другими словами, трудно «столкнуться» с положительной ситуацией. Справа: еще одна сложная игра под названием «Обморожение», в которой человек понимает, что что-то движется, что-то хорошо трогать, что-то плохо трогать, и цель состоит в том, чтобы строить иглу по кирпичику. Хороший анализ этой игры и обсуждение различий между человеческим и компьютерным подходом можно найти в статье «Создание машин, которые учатся и думают как люди».*
Я также хотел бы подчеркнуть тот факт, что, наоборот, во многих играх градиенты политики довольно легко победили бы человека. В частности, это касается игр с частыми вознагражденими, которые требуют точной и быстрой реакции и без долгосрочного планирования. Краткосрочные корреляции между вознаграждениями и действиями могут быть легко «замечены» подходом с PG. Вы можете видеть подобное в нашем агенте Понг. Он разрабатывает стратегию, когда он просто ждет мяч, а затем быстро движется, чтобы поймать его только на самом краю, из-за чего мяч отскакивает с высокой вертикальной скоростью. Агент набирает несколько выигрышей подряд, повторяя эту незамысловатую стратегию. Есть много игр (Pinball, Breakout), в которых Deep Q-Learning уделывает и втаптывает человека в грязь своими простыми и точными действиями.
Как только вы поймете «хитрость», с помощью которой работают эти алгоритмы, вы сможете понять их сильные и слабые стороны. В частности, эти алгоритмы далеко отстают от людей в построении абстрактных представлений об играх, которые люди могут использовать для быстрого обучения. Однажды компьютер посмотрит на массив пикселей и заметит ключ, дверь и подумает про себя, что, вероятно, было бы неплохо взять ключ и добраться до двери. На данный момент нет ничего близкого к этому, и попытка попасть туда является активной областью исследований.
**Недифференцируемые вычисления в нейронных сетях.**Я хотел бы упомянуть еще одно интересное применение градиентов политики, не связанных с играми: оно позволяет нам проектировать и обучать нейронные сети с помощью компонентов, которые выполняют (или взаимодействуют) с недифференцируемыми вычислениями. Эта идея была впервые представлена в [Williams 1992 г](http://www-anw.cs.umass.edu/~barto/courses/cs687/williams92simple.pdf). и недавно была популяризирована в [Рекуррентных моделях визуального внимания](http://arxiv.org/abs/1406.6247) под названием «пристальное внимание» в контексте модели, которая обрабатывает изображение с последовательностью узких центрированных (foveal) взглядов низкого разрешения, подобно тому, как наш глаз осматривает предметы с помощью бегающего центрального зрения. На каждой итерации RNN получит небольшой фрагмент изображения и выберет местоположение, которое нужно посмотреть дальше. Например, RNN может посмотреть на положение (5,30), получить небольшой фрагмент изображения, затем принет решение посмотреть (24, 50) и т. д. Существует участок нейросети, который выбирает, где искать дальше, а затем осматривает его. К сожалению, эта операция недифференцируема, потому что, мы не знаем, что произошло бы, если бы мы взяли образец в другом месте. В более общем случае рассмотрим нейронную сеть, имеющую несколько входов и выходов:
Обратите внимание, что большинство синих стрелок дифференцируемы как обычно, но некоторые преобразования представления могут также включать недифференцируемую операцию выборки, которые выделены красным цветом. Мы можем просто пройти через синие стрелки в обратном направлении, но красная стрелка представляет собой зависимость, через которую мы не можем выполнить обратное распространение backprop.
Политика градиентов на помощь! Давайте подумаем о той части сети, которая выполняет выборку, что она может быть представлена как функция стохастической политики, встроенную в большую нейросеть. Поэтому во время обучения мы произведем несколько примеров(обозначенных ветвями ниже), а затем мы будем поощрять выборки, которые в конечном итоге привели к хорошим результатам (в данном случае, например, измеренным по потерям в конце). Другими словами, мы будем обучать параметры, включенные в синие стрелки, с помощью backprop, как обычно, но параметры, включенные в красную стрелку, теперь будут обновляться независимо от обратного прохода с использованием градиентов политики, поощряя выборки, которые привели к низким потерям. Эта идея была также недавно хорошо оформлена в [оценке градиентов с использованием стохастических графов вычислений.](http://arxiv.org/abs/1506.05254)
Тренируемый ввод/вывод в оперативную память. Вы также найдете эту идею во многих других статьях. Например, у [Neural Turing Machine](https://arxiv.org/abs/1410.5401) есть лента памяти, с которой они читают и пишут. Чтобы выполнить операцию записи, нужно выполнить что-то вроде m [i] = x, где i и x предсказываются нейросетью RNN. Однако нет никакого сигнала, сообщающего нам, что случилось бы с функцией потерь, если бы мы записали в другое место j! = I. Поэтому NTM может выполнять «мягкие» операции чтения и записи. Он предсказывает функцию распределения внимания a, а затем выполняет for all i: m[i] = a[i]\*x. Это теперь дифференцируемо, но мы должны заплатить высокую вычислительную цену, перебирая все ячейки.
Однако мы можем использовать градиенты политик, чтобы теоретически обойти эту проблему, как это сделано в [RL-NTM](http://arxiv.org/abs/1505.00521). Мы по-прежнему прогнозируем распределение внимания a, но вместо полного перебора мы случайно выбираем места для записи: i = sample(a); m[i] = x. Во время обучения мы могли бы делать это для небольшого набора i и, в конце концов нашли бы набор, который работал бы лучше других. Большим вычислительным преимуществом является то, что во время тестирования можно читать/писать из одной ячейки. Однако, как указано в документе, эту стратегию очень трудно заставить работать, потому что нужно перебрать много вариантов и практически случайно выйти на рабочие алгоритмы. В настоящее время исследователи согласны с тем, что PG хорошо работает только в тех случаях, когда существует несколько дискретных вариантов, когда не надо прочесывать огромные пространства поиска.
Однако с помощью градиентов политики и в тех случаях, когда доступно большое количество данных и вычислительным мощностей, мы в принципе можем мечтать о многом. Например, мы можем проектировать нейронные сети, которые учатся взаимодействовать с большими недифференцируемыми объектами, такими как Latex компиляторы. Например, чтобы char-rnn генерировал бы готовый код Latex, или систему SLAM, или решатели LQR, или что-то еще. Или, например, суперинтеллект может захотеть научиться взаимодействовать с Интернетом по TCP/IP (который, тоже не дифференцируем) для доступа к информации, необходимой для захвата мира. Это отличный пример.
#### Выводы
Мы увидели, что градиенты политики являются мощным общим алгоритмом, и в качестве примера мы обучили агента ATARI Pong из необработанных пикселей с нуля в [130 строках Python](http://gist.github.com/karpathy/a4166c7fe253700972fcbc77e4ea32c5). В целом, тот же алгоритм можно использовать для обучения агентов для произвольных игр и, надеюсь, когда-нибудь сможем использовать для решения задач управления в реальном мире. В заключение я хотел добавить еще несколько замечаний:
**О развитии AI**. Мы увидели, что алгоритм работает посредством поиска методом «грубой силы», при котором вы сначала случайно колеблетесь и должны случайно натолкнуться на полезные ситуации хотя бы один раз, а в идеале часто и многократно, прежде чем функция политики изменит свои параметры. Мы также увидели, что человек подходит к этим решению этих задач совершенно по-другому, что напоминает быстрое построение абстрактной модели. Поскольку эти абстрактные модели очень сложно (если не невозможно) явно представить, это также является причиной того, что в последнее время так много интереса к генеративным моделям и программной индукции.
**Об использовании в робототехнике.** Алгоритм не применяется там, где трудно получить огромное количество исследований. Например, можно иметь одного (или нескольких) роботов, взаимодействующих с миром в режиме реального времени. Этого недостаточно для наивного применения алгоритма. Одним из направлений работы, предназначенным для смягчения этой проблемы, являются [детерминированные градиенты политики](http://jmlr.org/proceedings/papers/v32/silver14.pdf). Вместо того, делать реальные попытки, этот подход получает информацию о градиенте из второй нейросети (называемой критиком), который моделирует функцию оценки. Этот подход в принципе может быть эффективным с высокоразмерными действиями, где случайные выборки обеспечивают плохое покрытие. Другой связанный с этим подход заключается в расширении масштабов робототехники, что мы начинаем видеть на [ферме роботов-манипуляторов Google](http://googleresearch.blogspot.com/2016/03/deep-learning-for-robots-learning-from.html) или, возможно, даже на модели [Tesla S+ с автопилотом.](http://qz.com/694520/tesla-has-780-million-miles-of-driving-data-and-adds-another-million-every-10-hours/)
Существует также направление работы, которое пытается сделать процесс поиска менее безнадежным, добавив дополнительный контроль. Например, во многих практических случаях можно получить начальное направление развития непосредственно от человека. Например, [AlphaGo](http://deepmind.com/alpha-go) сначала использует обучение с учителем, чтобы всего лишь предугадывать действия человека (например [удаленное управление роботами](http://www.youtube.com/watch?v=kZlg0QvKkQQ), [ученичество](http://ai.stanford.edu/~pabbeel//thesis/thesis.pdf), [оптимизация траектории](http://people.eecs.berkeley.edu/~igor.mordatch/policy/index.html), [полный поиск политики](http://arxiv.org/abs/1504.00702)). А получающаяся в результате политика позже настраивается с помощью PG для достижения реальной цели – для победы в игре.
В некоторых случаях может быть меньше предустановок (например, для [удаленного управления роботами](https://www.youtube.com/watch?v=kZlg0QvKkQQ)), и существуют методы для использования этих данных [предварительной стажировки](http://ai.stanford.edu/~pabbeel//thesis/thesis.pdf). Наконец, если люди не предоставляют конкретные данные или установки, они также могут в некоторых случаях получены путем расчета с использованием довольно дорогих методов оптимизации, например, путем [оптимизации траектории](http://people.eecs.berkeley.edu/~igor.mordatch/policy/index.html) в известной динамической модели (такой как F = ma в физическом симуляторе) или в случаях, когда создается приблизительная локальная модель (как видно в очень многообещающей структуре управляемого поиска политики).
**Об использовании PG на практике.** Я хотел бы еще поговорить о RNN. Я думаю, что могло сложиться впечатление, что RNN являются магическими и автоматически решают задачи, связанные произвольными последовательностями. Правда в том, что заставить работать эти модели может быть совсем непросто. Требуется осторожность и опыт, а так же знать, когда более простые методы могут помочь вам на 90%. То же самое касается градиентов политики. Они не работают автоматически просто так: вам нужно иметь много примеров, они могут тренироваться вечно, их трудно отлаживать, когда они не работают. Всегда нужно пробовать стрелять из маленького пистолетика, прежде чем дотянуться до Базуки. Например, в случае обучения с подкреплением всегда следует проверять в первую очередь [метод кросс-энтропии (CEM)](http://en.wikipedia.org/wiki/Cross-entropy_method), простой стохастический подход «предположи и проверь», вдохновленный эволюцией. И если вы настаиваете на том, чтобы опробовать градиенты политики для вашей задачи, убедитесь, что вы знаете опеределенные трюки. Сначала начните с простого и используйте вариант PG под названием [TRPO](http://arxiv.org/abs/1502.05477), который почти всегда работает лучше и последовательнее, [чем классически PG](http://arxiv.org/abs/1604.06778). Основная идея состоит в том, чтобы избежать обновления параметров, которые слишком сильно изменяют вашу политику, что обусловлено использованием расстояния Ку́льбака-Ле́йблера между старой и новой политикой.
На этом все! Надеюсь, я дал вам представление о том, где мы находимся с Reinforcement Learning, каковы проблемы, и если вы хотите помочь в продвижении RL, я приглашаю вас сделать это в нашем [OpenAI Gym](http://gym.openai.com/) :) До следующих встреч!
---
Andrej Karpathy,
исследователь, разработчик, директор подразделения ИИ и автопилота Тесла
***Доп информация:**
Курс о Deep Learning на пальцах 2018
<https://habr.com/ru/post/414165/>
Открытый курс «Deep Learning на пальцах» 2019
<https://habr.com/ru/company/ods/blog/438940/>
Физический Факультет НГУ
<http://www.phys.nsu.ru/>* | https://habr.com/ru/post/439674/ | null | ru | null |
# Недокументированная возможность в WebSphere Portal 5.1 (общая сессия для портлета и сервлета)
#### Была следующая задача:
написать портлет, который отображает график отчета, хранящегося в Когносе. Отчет Когноса может строиться очень и очень долго, от нескольких секунд до 20.
Заставлять ждать пользователя столько времени — ужасное решение.
Я решил положить в портлетное приложение сервлет. При загрузке портлет посылает *xmlHttpRequest* с путем до отчета, а в ответ ему приходит относительная ссылка на картинку отчета, которую сервлет получил от Когноса и сохранил на сервере.
Казалось бы, все очень и очень просто, но проблема заключается в том, что при рефреше страницы или обращению к любому портлету на странице, Когнос-портлет отправит новый запрос к сервлету. Этого делать не надо, т.к. картинка уже загружена и обновлять её каждые пять минут не надо.
Не секрет, что у посетителя портала (любого другого контейнера) есть сессия. В сессию обычно кладут так называемый StateBean, бин, в котором хранится всякий хлам, который может понадобиться пользователю во время работы с порталом. Сделаем в бине поле
`String pathToImage;`
и два метода:
`public String getPathToCognosImage(){ return pathToImage}
public void setPathToCognosImage(String path){ pathToImage = path;}`
Проблема заключается в том, что при приёме ответа сервлета, JavaScript не сможет вызвать метод бина. Думаю, вы понимаете почему.
Есть только один выход — писать в бин на Сервлете. Но разве это возможно? Как говорят, на портале 5.0 таких штук вытворять было нельзя. К сожалению, портал 5.0 я не застал и не имею возможности проверить этот слух.
Способ обращения к бину сессии выглядит следующим образом:
`public class GetPathToChartImageServlet extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet {
//bla-bla-bla
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//getting aditional parameters for Cognos.
//Try to get it from StateBean
Enumeration en = request.getSession().getAttributeNames();
while(en.hasMoreElements()){
attrName = (String)en.nextElement();
Object o = request.getSession().getAttribute(attrName);
System.out.println("attr name " + attrName + " = " + o.toString());
if(o instanceof ru.habr.bean.ChartDataStateBean){
System.out.println("attr name = " + attrName + ". Is my StateBean");
statebean = (ru.habr.bean.ChartDataStateBean)o;
break;
}
}
}//doPost
}//class`
В консоли можно обнаружить следующие строки:
##### [04.06.08 11:04:25:495 MSD] 5a9899ea SystemOut O attr name PC\_PRIVATE\_5\_0\_CSI\_PortletSessionData = { caiid = 5\_0\_CSI [PORTLET\_ENTITY:13202], creationTime = 1212562835246, lastAccessedTime = 1212563065417 }
##### [04.06.08 11:04:25:495 MSD] 5a9899ea SystemOut O attr name PC\_5\_0\_CSI\_ru.habr.bean.ChartDataStateBean = ru.habr.bean.ChartDataStateBean@7dc1d9b7
##### [04.06.08 11:04:25:495 MSD] 5a9899ea SystemOut O attr name = PC\_5\_0\_CSI\_ru.habr.bean.ChartDataStateBean. Is my StateBean
Ура, бин доступен!
Перед тем, как тело метода закончится, нужно не забыть записать изменения:
`String newRelativePathToImageFromCognos = CognosFacadeAdapter.getInstance().runReport(reportStringForCognos);
statebean.setPathToImage(newRelativePathToImageFromCognos);
request.getSession().setAttribute(attrName, statebean);`
Такая возможность легко объяснятся тем, что:
[](http://picasaweb.google.com/Serega.Sheypak/Technical/photo#5207928518124907794)
Внешне, это выглядит так:
[](http://picasaweb.google.com/Serega.Sheypak/Technical/photo#5207928514582593026)
P.S.
habracut text=«Что же делать?» выводится не один раз, а несколько. Это глюк или такой прикол? | https://habr.com/ru/post/26790/ | null | ru | null |
# Регулярные выражения. Сборник рецептов
Мы каждый день работаем с текстом, решая разные задачи. Проверяем текст на правильность ввода некоторых данных, ищем, заменяем некоторые значения, выделем некоторые данные из текста. Порой объём этих данных значительно возрастает и справиться с такими объёмами текстовой информации за актуальный промежуток времени не получается.
Нам на помощь прийдут регулярные выражение. Этот мощный инструмент многие специалисты уже давно используют очень успешно. Я говорю не только о разработчиках программного обеспечения, но и о людях других профессий, которым приходится работать с текстом (редакторы, маркетологи, копирайтеры).
Сегодня я хотел бы познакомить вас с книгой Яна Гойвертса и Стивена Левитана «Регулярные выражения. Сборник рецептов», которая поможет вам понять как работать с регулярными выражениями.
Давайте разберёмся что же за такой полезный инструмент эти регулярные выражения.
> Регуля́рные выраже́ния (англ. regular expressions, сокр. RegExp, RegEx, жарг. регэ́кспы или ре́гексы) — система синтаксического разбора текстовых фрагментов по формализованному шаблону, основанная на системе записи образцов для поиска. Образец (англ. pattern), задающий правило поиска, по-русски также иногда называют «шаблоном», «маской».
>
>
>
> *Википедия*
>
>
Немного трудно понять из описания что это такое, но постараюсь объяснить простым языком. У нас есть текст, который нужно обработать и есть требование как нам нужно его обработать. По требованию мы строим некоторый шаблон. Передаём наш шаблон и текст программе, которая сделает разбор. Так намного проще?
### О книге
В книге показаны решения, основанные на использовании регулярных выражений, применённые к широкому кругу практических задач, связанных с обработкой текста, возникающих в различных приложениях.
Книга как бы разделена на две больших логические части. Первая часть посвещена теории регулярных выражений, синтаксису и описанию разных диалектов.
Глава 1. Введение в регулярные выражения;
Глава 2. Основные навыки владения регулярными выражениями;
Глава 3. Программирование с применением регулярных выражений.
Вторая часть посвещена решению разных задач, которые могут возникнуть.
Глава 4. Проверка и форматирование;
Глава 5. Слова, строки и специальные символы;
Глава 6. Числа;
Глава 7. URL, пути и адреса в Интернете;
Глава 8. Разметка и обмен данными.
Книга читается очень легко и понятна будет даже тем людям, которые никогда не имели навыков программирования. Все примеры построены по принципу — ставится задача, решается и после этого разбирается более подробно.
### Об авторах
Ян Гойвертс является основателем компании Just Great Software, где занимается проектированием и разработкой некоторых популярнейших программных продуктов для работы с регулярными выражениями. Он является автором приложения RegexBuddy, единственного в мире редактора регулярных выражений, имитирующего особенности 15 диалектов, и PowerGREP, самого мощного инструмента grep для Microsoft Windows.
Стивен Левитан является ведущим экспертом по регулярным выражениям в JavaScript. Он ведет популярный блог, посвященный регулярным выражениям, по адресу <http://blog.stevenlevithan.com>. Расширение знаний о диалектах регулярных выражений и библиотеках поддержки было для него одним из увлечений на протяжении нескольких последних лет.
### Пример
Я хотел бы остановиться на одном примере в книге. В нём рассмотрена проверка правильности ввода ISBN. Его я выбрал по некоторым причинам — он прост, он достаточно нагляден и по случайности в пример, который приведён в книге, написаный на Python закралась ошибка. Я решил переписать этот пример.
Для начала давайте убедимся, что страшный шаблон `^(?:ISBN(?:-1[03])?:? )?(?=[-0-9 ]{17}$|[-0-9X ]{13}$|[0-9X]{10}$)(?:97[89][- ]?)?[0-9]{1,5}[- ]?(?:[0-9]+[- ]?){2}[0-9X]$` действительно работает. Я проведу проверку в текстовом редакторе Espresso.
Редактор нашёл одно совпадение. Шаблон правильный и мы можем приступить к написанию программы на Python (я использовал версию 2.6.1).
`> 1. # -\*- coding: utf-8 -\*-
> 2. # file: isbn\_check.py
> 3.
> 4. import re
> 5. import sys
> 6.
> 7. # регулярное выражение проверяте соответствие формату ISBN-10 или ISBN-13
> 8. regex = re.compile("^(?:ISBN(?:-1[03])?:? )?(?=[-0-9 ]{17}$|[-0-9X ]{13}$|[0-9X]{10}$)(?:97[89][- ]?)?[0-9]{1,5}[- ]?(?:[0-9]+[- ]?){2}[0-9X]$")
> 9.
> 10. subject = sys.argv[1]
> 11.
> 12. if regex.search(subject):
> 13. # Удаляем символы, не имеющие отношения к ISBN
> 14. cbuf = re.sub("[^0-9X]", "", subject)
> 15.
> 16. # Создаём массив
> 17. chars = list()
> 18.
> 19. # Разбиваем номер на части и добавляем в массив
> 20. for item in cbuf[:]:
> 21. chars.append(item)
> 22.
> 23. # Перемещаем последнюю цифру из массива chars в переменную last
> 24. last = chars.pop()
> 25.
> 26. if len(chars) == 9:
> 27. # Вычисляем конторольную цифру ISBN-10
> 28. val = sum((x + 2) \* int(y) for x, y in enumerate(reversed(chars)))
> 29.
> 30. check = 11 - (val % 11)
> 31.
> 32. if check == 10:
> 33. check = "X"
> 34. elif check == 11:
> 35. check = "0"
> 36. else:
> 37. # Вычисляем конторольную цифру ISBN-13
> 38. val = sum((x % 2 \* 2 + 1) \* int(y) for x, y in enumerate(chars))
> 39.
> 40. check = 10 - (val % 10)
> 41.
> 42. if check == 10:
> 43. check = "0"
> 44.
> 45. if (str(check) == last):
> 46. print u"Корректный ISBN"
> 47. else:
> 48. print u"Некорректная контрольная цифра ISBN"
> 49. else:
> 50. print u"Некорректный ISBN"
>`
Проверим работу нашей программы, которая проверят правильность ISBN.
Программа работает корректно, а подробное обсуждение того, как это работает и некоторую справку можно прочитать в книге (§4.13). Хочу лишь добавить, что каждый рецепт, который дан в книге, подробно разбирается. Разбирается алгоритм и сам шаблон. Как пример возьмём рассмотрение этого шаблона в книге:
`> ^ # Проверка совпадения с началом строки
>
> (?: # Группировка, но нисходящая
>
> ISBN # Соответствует фрагменту ISBN
>
> (?:-1[03])? # Необязательное совпадение с фрагментом "-10" или "-13"
>
> :? # Необязательное совпадение с фрагментом ":"
>
> \ # Соответствует фрагменту пробела (экранирован)
>
> )? # Повторить группу ноль или один раз
>
> (?= # Опережающая проверка возможности следующих совпадений
>
> [-0-9 ]{17}$ # Соответствует 17 дефисам, цифрам или пробелам
>
> | # за которыми следует конец строки. Или
>
> [-0-9X ]{13}$ # Соответствует 13 дефисам, цифрам, "X" или пробелам
>
> | # за которыми следует конец строки. Или
>
> [0-9X]{10}$ # Соответствует 10 цифрам или "X", с последующем концом строки
>
> ) # Конец позитивной опережающей проверки
>
> (?: # Группировка, но нисходящая
>
> 97[89] # Соответствует фрагменту "978" или "979"
>
> [-\ ]? # Необязательное совпадение с "-" или пробелом (экранирован)
>
> )? # Повторить группу ноль и один раз
>
> [0-9]{1,5} # Соответствует от 1 до 5 цифр
>
> [-\ ]? # Необязательное совпадение с "-" или пробелом (экранирован)
>
> (?: # Группировка, но нисходящая
>
> [0-9]+ # Цифра, которая соответствует 1 или более раз
>
> [-\ ]? # Необязательное совпадение с "-" или пробелом (экранирован)
>
> ){2} # Повторить группу точно 2 раза
>
> [0-9X] # Соответствует цифре или "X"
>
> $ # Проверка с концом строки`
### Заключение
Регулярные выражения — это очень мощный инструмент, который может упростить решения многих задач. Данная книга поможет в полной мере овладеть регулярными выражениями.
«Регулярные выражения. Сборник рецептов»
Ян Гойвертс и Стивен Левитан
Издательство «Символ-Плюс», 2010, 608 страниц
ISBN 978-5-93286-181-3
Спасибо за предоставленную книгу издательству «[Cимвол-Плюс](http://www.symbol.ru/)». В интернет-магазине издательства книгу можно [приобрести](http://www.books.ru/shop/books/713161?partner=514730). | https://habr.com/ru/post/80430/ | null | ru | null |
# Подключение bootstrap в Next.js
Категорически приветствую.
Столкнулся я тут с необходимостью подключить Bootsrtap в Next.js. Беглый гуглёж дал несколько тем на stackoverflow, парочку монструозных (всё в одном и все пакеты устарели ) шаблонов на гитхабе, и немножечко оффдоков. На деле же всё оказалось довольно тривиально, но, надеюсь, эта заметка сэкономит кому-то время.
Если кто еще не в курсе, Next.js это фреймворк, предлагающий из коробки возможность создания универсальных/изоморфных приложений с React. Есть даже аналог create-react-app — create-next-app.
На Хабре уже [было несколько статьей про него](https://habr.com/search/?q=%5Bnext.js%5D&target_type=posts).
Стартуем новый проект. Если не установлен create-next-app, то ставим его:
```
sudo npm install -g create-next-app
```
Далее, создаём новый проект:
```
create-next-app bs_exapmle
```
Ставим reactsrap и bootsrap:
```
cd bs_exapmle
npm install --save reactstrap bootstrap
```
Итак, нам надо подключить Bootstrap. Попытка сделать это в лоб ничего не даст, кроме ошибки в консоли. Из коробки фреймворк поддерживает только styled-components. Чтобы подключить что-то еще надо ставить css-загрузчик [zeit](https://habr.com/users/zeit/)/next-css.
```
npm install --save @zeit/next-css
```
И настраиваем его в next.config.js
```
const withCSS = require('@zeit/next-css')
module.exports = withCSS()
```
Осталось чуть-чуть! Создаем файл pages/\_documents.js Здесь будут подключаться скомпиленые стили
```
import Document, { Head, Main, NextScript } from 'next/document'
export default class MyDocument extends Document {
render() {
return (
)
}
}
```
Всё. теперь мы можем использовать компоненты reactstrap. Главное, не забыть импортировать bootstrap.min.css. Смело правим pages/index.js
```
import 'bootstrap/dist/css/bootstrap.min.css';
import { Card, CardText, CardHeader, CardBody, Button } from 'reactstrap';
export default () => (
Hello Next.js!
Bootstrap 4 power!
OK
)
}
```
[Ссылка на рабочий пример](https://github.com/frostspb/bootstrap_nextjs_example) | https://habr.com/ru/post/417979/ | null | ru | null |
# Salt. О славном pillar'е замолвите слово
В одной из наших прошлых статей [Just add some Salt](https://habr.com/ru/company/timeweb/blog/521370/) мы рассказывали, как мигрировали 700+ серверов на Salt. Мы поделились нашим опытом оптимизации Salt: как его применить и настроить без лишних усилий. Тогда мы только затронули тему пилларов, а сегодня хотели бы остановиться на ней подробнее.
### Пиллары разные нужны
Пиллары — это защищенное (безопасное) хранилище данных внутри Salt'а. Поэтому, в первую очередь, они используются для разграничения доступа к критичным данным (сертификаты, логины, пароли).
Кроме дефолтных пилларов у Salt'а есть также модуль **ext\_pillar**, который предоставляет интерфейс подключения к внешним источникам данных и генерирует пиллары из этих источников в один общий словарь.
Например, можно брать данные из **mysql, postgres, redis, mongo, git**, да хоть из вывода скрипта / команды — **cmd\_json**, **cmd\_yaml**.
Полный список модулей опубликован на [официальном сайте SaltStack](https://docs.saltstack.com/en/master/ref/pillar/all/index.html).
Если у вас нестандартная ситуация и имеющиеся модули не устраивают, можно написать свой и положить его в **/usr/lib/python3/dist-packages/salt/pillar/**, после чего необходимо перезапустить мастер.
Пример такого модуля:
```
#/etc/salt/master/conf.d/pillar.conf
ext_pillar:
- dummy: dummy
```
```
#/usr/lib/python3/dist-packages/salt/pillar/dummy.py
def ext_pillar(minion_id, pillar, *args, **kwargs):
dummy = {'dummy': 'what u want mann?'}
return dummy
```
Из всех доступных модулей **pillarstack** оказался для нашей команды наиболее интересным и актуальным. Сейчас расскажем почему.
### Знакомство с PillarStack
**Stack** или **pillarstack** — это «простой и гибкий YAML пиллар, который умеет читать пиллары из пилларов», согласно официальной документации на [сайте](https://docs.saltstack.com/en/latest/ref/pillar/all/salt.pillar.stack.html).
Он позволяет использовать внутри пилларов пиллары, прочитанные ранее. Это значит, что мы можем использовать пиллар из предыдущего конфига. И это мегаудобно! Покажем, как это работает:
```
Допустим, у нас конфигурация из трёх конфигов:
#/etc/salt/conf.d/pillarstack.conf
ext_pillar:
- stack:
- /srv/pillar/stack1.cfg
- /srv/pillar/stack2.cfg
- /srv/pillar/stack3.cfg
#/srv/pillar/stack1.cfg
# с каждой строкой stack начинает "накапливать" пиллары,
# и уже после 2й строки его можно использовать в yml файлах, но не в конфиге
core.yml
common/*.yml
osarchs/{{ __grains__['osarch'] }}.yml
oscodenames/{{ __grains__['oscodename'] }}.yml
hosts/{{ minion_id }}/roles.yml
#/srv/pillar/stack2.cfg
# здесь в stack уже есть все пиллары из stack1.cfg
# и можно их использовать в конфиге, например, roles
# также stack доступен в yml файлах
{% for role in stack.roles %}
roles/{{ role }}/*.yml
{% endfor %}
#/srv/pillar/stack3.cfg
# а здесь в stack "накопились" пиллары из stack1.cfg и stack2.cfg
# используем их как часть пути к пилларам
creds/{{ stack.db.host }}/*.yml
```
Каждый конфиг можно представить как слой. В каждом таком слое мы можем использовать данные из предыдущих слоев.
При настройке пилларов доступны следующие переменные:
* *grains* — таргетирование конфигов по grains
* *opts* — таргетирование конфигов по опциям в конфиге
* *pillar* — пиллары, которые сформировались **до** начала обработки **текущего** ext\_pillar:stack
```
# Допустим, у нас пиллары только в stack
# Если у нас только один stack в котором конфиги включаются по grains и по pillar
# stack.cfg не будет задействован, так как переменная pillar пустая
ext_pillar:
- stack:
grains:cpuarch:
x86_64:
- /srv/pillar/stack1.cfg
- /srv/pillar/stack2.cfg
pillar:environment:
dev: /srv/pillar/dev/stack.cfg
prod: /srv/pillar/prod/stack.cfg
# Если предыдущую конфигурацию разбить на два stack: первый включает конфиги по grains, второй по pillar
# то здесь pillar уже содержит данные из stack1.cfg, stack2.cfg
# и если в них есть 'environment', то stack.cfg будет задействован
ext_pillar:
- stack:
grains:custom:grain:
value:
- /srv/pillar/stack1.cfg
- /srv/pillar/stack2.cfg
- stack:
pillar:environment:
dev: /srv/pillar/dev/stack.cfg
prod: /srv/pillar/prod/stack.cfg
```
В yml файлах можно использовать:
* *\_\_opts\_\_*: опции конфига
* *\_\_grains\_\_*: грейны миньона
* *pillar*: пиллары из других ext\_pillar или из дефолтных пилларов (те, что в top.sls)
* *stack*: накопленный стек пилларов, включая текущий конфиг.
Если вы только собираетесь перейти на pillarstack, то ниже пара моментов, на которые стоит обратить внимание:
1. Рекурсивное включение работает только в pillar. Stack не включает каталоги, только файлы.
```
# pillar
# top.sls
base:
'*':
- dir1.* # прочитает /dir1/dir2/dir3/*
# stack нужно указывать каждый каталог
# stack.cfg
/dir1/*
/dir1/dir2/*
/dir1/dir2/dir3/*
```
2. Дефолтное поведение при слиянии списков:
* pillar — списки перезаписываются
* stack — используется стратегия merge-last (списки складываются).
Стратегии слияния пилларов позволяют очень гибко настроить пиллары.
Подробное описание с примерами есть в документации.
Если вкратце описать каждую из стратегий:
* merge-last (используется по умолчанию): рекурсивное слияние, приоритет у последнего словаря/списка
* merge-first: рекурсивное слияние, приоритет у первого словаря/списка
* remove: удаление указанных элементов
* overwrite: переопределение словаря / списка.
Пояснение: в каждом слиянии участвует два словаря/списка назовем их первый и последний
Стратегия указывается как первый элемент словаря / списка, к которому ее надо применить.
Главное — не увлекаться чрезмерным использованием стратегий, так как это усложнит конфигурацию. Возможно, в таком случае стоит пересмотреть организацию пилларов.
### Заключение
Пиллары позволяют ограничить доступ к чувствительным данным. Данных становится всё больше, сценарии их применения становятся всё изощреннее, поэтому важно использовать удобный инструмент для их организации. На данный момент для нашей команды это pillarstack, в будущем мы планируем развернуть vault.
Нам кажется, удивительно, почему pillarstack до сих пор не вытеснил дефолтный пиллар, ведь он гораздо удобнее и гибче, а стратегии очень выручают, когда надо точечно изменить поведение переменной stack. А вы что думаете? Используете ли pillarstack в своей работе? | https://habr.com/ru/post/532184/ | null | ru | null |
# Новогодние приколы от проекта Arduino Mega Server
Разработка проекта [Arduino Mega Server](http://hi-lab.ru/arduino-mega-server) идёт полным ходом и в процессе работы возникают неожиданные препятствия, которые приходится героически преодолевать. О некоторых из них вам сегодня расскажу и, возможно, это сэкономит вам немного вашего времени и нервов.
Прикол первый: и на старуху бывает проруха или зри в корень!
------------------------------------------------------------
Готовлю к выходу 0.14 версию системы для Arduino Due и адаптирую эту версию для работы с Power Monitor. Для тех, кто не знает, Power Monitor это программно-аппаратный комплекс контроля сетевого электропитания, который позволяет контролировать уровень сетевого напряжения и потребляемой мощности по 14 каналам и имеет встроенный контроль частоты сетевого тока и даже сетевой осциллограф, которой прямо на веб-страничке показывает форму тока и напряжения в реальном времени.
Схему собрал, всё проверил, запускаю — не работает. Ну что же — бывает, дело привычное. Начинаю проверять код — всё в порядке, проверяю железо — всё окей, проверяю соединения — тоже всё в порядке. В глубокой задумчивости сажусь в кресло и начинаю соображать, где может быть ошибка. После долгих размышлений прихожу к выводу, что всё сделано правильно. Почему же не работает? Чудес не бывает, поэтому проверяю всё во второй раз.
Код, железо, соединения. Всё, вроде, правильно. Опять много думаю. Перелопачиваю код ещё раз, с пристрастием — результат — ноль. Поскольку все поликлинические методы исчерпаны, перевожу пациента в хирургическое отделение и достаю тестер и паяльник. Пациент опасливо косится на меня, но дара речи он лишён и не может мне ничего подсказать. После недолгих манипуляций выясняется, что питание на Power Monitor не подаётся вообще! Как же так? Ясно видны проводники подачи питания, а питания нет!
И тут до меня доходит, что, оказывается, бывают макетные платы такие,
которые мне обычно попадались и к которым я привык и считал их единственно возможными, а бывают и вот такие (найдите десять отличий, как говорится)
и именно такая плата мне попалась в этот раз. Это кажется пустяком и само-собой разумеющимся только когда вы об этом уже знаете, а когда не знаете, то можете себе всю голову сломать, пока сообразите, почему не работает ваше устройство.
Тут ещё присутствует психологический момент — если вы считаете шину целой, то не обращаете внимания на пропуск в маркировке (мало ли что там вздумалось нарисовать изготовителю). Вот такие приколы иногда случаются в разработке — зри, как говорится, в корень!
Прикол второй: привет от нашей любимой команды arduino.cc
---------------------------------------------------------
Как я уже сказал, разработка идёт полным ходом и AMS стал уже довольно объёмным проектом и, естественно, в проекте невозможно обойтись без очень полезных директив условной компиляции. Это мощный инструмент управления работой кода, тем более, что Arduino Mega Server имеет модульную структуру и директивами условной компиляции включаются и отключаются различные модули системы.
```
#define
#ifdef
#endif
```
Это сделано для того, чтобы можно было отключить ненужные вам модули и сэкономить драгоценную память микроконтроллера. И я ещё не встречался в своей практике (на разных языках программирования), чтобы директивы условной компиляции не работали или «глючили». Это нонсенс! До последнего времени я считал, что это невозможно, но (весёлые) разработчики среды программирования Arduino не дают нам скучать, но обо всём по порядку.
Итак, пытаемся отключить ненужный нам модуль, в данном случае, модуль работы с MajorDoMo (и до сих пор это работало как и положено).
```
//#define MAJORDOMO_FEATURE
```
По идее, всё, что находится между директивами
```
#ifdef MAJORDOMO_FEATURE
...
#endif
```
должно быть выключено из компиляции. Но не тут то было!
```
#ifdef MAJORDOMO_FEATURE
char majorMegaObject[] = "ncMega01";
char majorCommObject[] = "comm_mega01";
// MajorDoMo net settings
byte MAJOR_IP[] = {192, 168, 2, 8};
int MAJOR_PORT = 80;
// <-------------------------------------- ВОТ ЗДЕСЬ ЕЩЁ ОТКЛЮЧАЕТСЯ КОМПИЛЯЦИЯ
// EthernetClient object
EthernetClient mclient;
// <-------------------------------------- А ВОТ ЗДЕСЬ УЖЕ НЕТ! ВСЁ, ЧТО НИЖЕ КОМПИЛИРУЕТСЯ, НЕСМОТРЯ НА ЗАПРЕТ!
void majordomoInit() {
initStart("MajorDoMo");
timeStamp();
Serial.print("Connect to MajorDoMo... ");
if (mclient.connect(MAJOR_IP, MAJOR_PORT)) {
Serial.println("OK");
//mclient.println("GET /search?q=arduino HTTP/1.0");
mclient.println();
} else {
Serial.println("failed");
}
delay(200);
mclient.stop();
modulMajor = MODUL_ENABLE;
initDone();
}
…
```
Как вы можете заметить, условная компиляция не просто не работает (это плохо, но еще куда не шло), а работает «как Бог на душу положит», то есть где хочет — компилирует, где не хочет — не компилирует! И это совсем плохо, потому, что такие непредсказуемые «глюки» очень трудно отловить и они могут приводить к совершенно непредсказуемым последствиям.
Кстати, в данной статье идёт речь о Arduino IDE версии 1.6.5. Но, судя по всему, версия среды разработки не имеет особого значения, все они достаточно глючны. О чём я узнал только в последнее время, до тех пор, пока я компилировал маленькие скетчи и небольшие проекты, всё было в порядке.
Прикол третий: опять наша любимая arduino.cc и совершенно фантастический баг
----------------------------------------------------------------------------
Не буду тут долго описывать, на мой взгляд, совершенно из ряда вон выходящий баг в компиляторе среды Arduino, а сразу приведу код, чтобы вы сами могли оценить это чудо.
Объявляем переменную:
```
long errorsHttpSend = 0;
```
В цикле печатаем:
```
Serial.println(errorsHttpSend);
```
Результат:
```
808333615
```
Переименовываем, добавляя 2:
```
long errorsHttpSend2 = 0;
```
В цикле печатаем:
```
Serial.println(errorsHttpSend2);
```
Результат:
```
0
```
Встаёт вопрос как вообще можно вести разработку в такой системе? Тут ещё можно упомянуть совершенно неадекватную работу различных версий Arduino IDE. Код, который прекрасно работает в одной версии среды, отказывается компилироваться в другой. Одна среда компилирует проект, другая «не видит» одну из библиотек. После переустановки среды разработки перестаёт компилировать проект та же версия 1.6.5 (которая до переустановки компилировала).
Так что имейте в виду, с чем вам придётся столкнуться, работая с Arduino. Здесь есть только один положительный момент: с такой системой вы волей-неволей станете гуру программирования и мастером системного администрирования.
Позволю себе высказать новогоднее пожелание для команды разработчиков Arduino: дорогие вы наши! Поздравляем вас с Новым Годом и желаем в новом году выпустить нормально работающую среду разработки!
С Новым Годом!
--------------
Друзья! Поздравляю вас с наступающим 2016 годом и надеюсь, что информация из этой статьи поможет вам сэкономить немного времени и нервов в новом году! И удачных разработок!
P.S.
Несмотря на все происки врагов, в ближайшее время всё-таки выйдет новая версия [Arduino Mega Server](http://hi-lab.ru/arduino-mega-server) под номером 0.14 для Arduino Mega и Arduino Due со множеством новых возможностей.
**Дополнение**. Открыт канал на Youtube и вот [промо ролик](http://www.youtube.com/watch?v=jmu0MkIlywU) Arduino Mega Server, который демонстрирует работу с реальной системой. | https://habr.com/ru/post/388623/ | null | ru | null |
# «Ленивый сахар» PostgreSQL
Блиц, Блиц, скорость без границ!SQL - декларативный язык - то есть вы описываете **"что"** хотите получить, а СУБД сама решает, **"как"** именно она будет это делать. Некоторые из них при этом [позволяют им "подсказывать"](https://docs.oracle.com/cd/B19306_01/server.102/b14211/hintsref.htm), как именно лучше выполнять запрос, но PostgreSQL - нет.
Тем не менее, **"синтаксический сахар"** некоторых языковых конструкций позволяет не только писать меньше кода (учите матчасть!), но и добиться, что ваша база будет делать **часть вычислений "лениво"**, только при фактической необходимости.
* [TABLE](#table)
* COALESCE
+ [управление порядком вычислений](#coalesce-1)
+ [сравнение с NULL](#coalesce-2)
* [ANY/ALL](#any)
* CASE
+ [отсечка простым условием](#case-1)
+ [подстановка по значению](#case-2)
* [AND/OR-цепочки запросов](#and)
* [UNION ALL + LIMIT](#union)
* [LATERAL и порядок JOIN'ов](#lateral)
* [WITH ORDINALITY-нумерация](#ordinality)
* [ROW-конструктор](#row)
TABLE
-----
Наверное, самый часто используемый "в быту", он же - наиболее простой способ вывести все поля таблицы или выборки - оператор [TABLE](https://postgrespro.ru/docs/postgresql/14/sql-select#SQL-TABLE):
```
TABLE my_table; -- эквивалентно SELECT * FROM my_table;
```
Увы, его нельзя комбинировать с `WHERE` или `GROUP`, зато отлично можно использовать для передачи CTE вида "одна строка - один столбец" в функции:
```
WITH src AS(
SELECT ARRAY[1, 2, 3]
)
SELECT
unnest((TABLE src));
```
COALESCE - выполняем шаг за шагом
---------------------------------
Иногда бывает необходимо выполнить несколько сложных запросов, чтобы потом взять первый не-`NULL`'овый из них:
```
SELECT
CASE
WHEN a IS NOT NULL THEN a
ELSE b
END r
FROM
(
SELECT
(SELECT CASE WHEN random() < 0.5 THEN 1 END) a -- в половине случаев тут NULL
, (SELECT 2) b
) T;
```
В половине случаев значение `a` у нас будет не-`NULL`, но в [плане](https://explain.tensor.ru/archive/explain/7553eadeadbb2836f10f9fe81ba95f27:0:2022-05-26) мы **каждый раз** все равно увидим вычисление `InitPlan 2` для второго вложенного запроса:
Оба вложенных запроса выполняются всегдаПерепишем, использовав оператор [coalesce](https://postgrespro.ru/docs/postgresql/14/functions-conditional#FUNCTIONS-COALESCE-NVL-IFNULL):
```
SELECT
coalesce(
(SELECT CASE WHEN random() < 0.5 THEN 1 END)
, (SELECT 2)
) r;
```
Теперь [в половине случаев](https://explain.tensor.ru/archive/explain/e69d692e041100ed6c700e4af6fe8ce2:0:2022-05-26), как и ожидалось, для второго вложенного запроса **вычисление происходить не будет** (`never executed` на узле плана):
Второй вложенный запрос тут не выполнялсяCOALESCE и "невозможное значение"
---------------------------------
Иногда возникает необходимость проверить совпадение некоторого значения с определенным набором или с `NULL`, но "просто" сравнивать через оператор `=` с `NULL` нельзя - поэтому нельзя просто написать `v IN (1, 3, NULL)`.
> Подробнее о проблемах сравнения с `NULL` и помощи оператора `IS DISTINCT FROM` в этом деле - в статье ["PostgreSQL Antipatterns: сражаемся с ордами «мертвецов»"](/ru/post/491366/).
>
>
Это приводит к появлению разных не очень красивых конструкций:
```
SELECT
v IS NULL OR v = 1 OR v = 3 cond
FROM
(
VALUES
(1)
, (2)
, (3)
, (NULL)
) T(v);
```
Но если использовать `coalesce` и точно знать **значение, которого "не может быть"** по прикладной логике, то запрос можно переписать:
```
SELECT
coalesce(v, -1) IN (-1, 1, 3) cond -- coalesce + IN
FROM
(
VALUES
(1)
, (2)
, (3)
, (NULL)
) T(v);
```
ANY/ALL
-------
Раз уж мы затронули оператор `IN`, который сам является "синтаксическим сахаром" к `OR`-цепочке значений, стоит вспомнить и про родственные ему операторы `ANY` и `ALL`.
Их можно использовать для проверки присутствия значения в выборке:
```
SELECT 'a' = ANY(
(
SELECT 'a'
UNION
SELECT 'b'
UNION
SELECT 'c'
)
);
```
... или массиве:
```
SELECT 'a' = ANY(ARRAY['a', 'b', 'c']);
```
... или отсутствия там же:
```
SELECT 'x' <> ALL('{a,b,c}'::text[]);
```
### LIKE ANY
Но помимо операторов `=` и `<>`, `ANY/ALL` могут комбинироваться и с `LIKE`:
```
SELECT
*
FROM
pg_class
WHERE
relname LIKE ANY('{pg_publication%,pg_subscription%}'::text[]);
-- NOT LIKE ALL(...)
```
CASE WHEN <простое условие> THEN <сложный запрос>
-------------------------------------------------
В более общей ситуации, когда условие подразумевает не просто проверку на `NULL`, можно **"заизолировать" внутри** [CASE](https://postgrespro.ru/docs/postgresql/14/functions-conditional#FUNCTIONS-CASE) выполнение сложных операций более легко вычислимыми [простыми условиями](https://explain.tensor.ru/archive/explain/d93ddae5daf83e9b1773a4c15d967c27:0:2022-05-26):
```
SELECT
CASE
WHEN random() < 0.5 THEN (SELECT 1)
WHEN random() < 0.5 THEN (SELECT 2)
ELSE (SELECT 3)
END r;
```
Из трех вложенных запросов выполнялся всего один
> Прикладной пример использования такой конструкции для ускорения запроса можно увидеть в статье ["PostgreSQL Antipatterns: редкая запись долетит до середины JOIN"](/ru/post/484670/).
>
>
CASE <сложный запрос> WHEN <значение>
-------------------------------------
Если нам необходимо вычислить некоторое значение на основании результата какого-то сложного запроса, то предыдущий вариант уже будет выглядеть не очень хорошо:
```
SELECT
CASE
WHEN (SELECT ...A) = 1 THEN 'one'
WHEN (SELECT ...A) = 2 THEN 'two'
WHEN (SELECT ...A) = 3 THEN 'three'
END;
```
Однако, если вложенный запрос возвращает значение `3`, то и выполняться он тут будет трижды. Мало того, в некоторых случая (например, при использовании `random()` или любой другой не-`STABLE`-функции) это просто нельзя использовать, поскольку приведет к ошибке.
Тем не менее, если воспользоваться `CASE`-конструкцией проверки значения выражения, можно записать и короче, и правильнее:
```
SELECT
CASE (SELECT ...A)
WHEN 1 THEN 'one'
WHEN 2 THEN 'two'
WHEN 3 THEN 'three'
END;
```
### Подстановка по словарю
К сожалению, такой подход требует прописывания всех пар значение-результат еще на этапе создания запроса или его [динамической генерации, что нехорошо](/ru/post/573214/) почти всегда.
Но есть способ обойти это ограничение - использовать **словарь соответствий**, который можно собирать и при выполнении запроса или передавать в качестве параметра:
```
SELECT
(
'{"1" : "one", "2" : "two", "3" : "three"}'::json
) ->> (SELECT ...A)::text;
```
> Сравнение разных вариантов "ословаривания" данных можно увидеть в ["PostgreSQL Antipatterns: ударим словарем по тяжелому JOIN"](/ru/post/485398/).
>
>
AND/OR-цепочки запросов
-----------------------
Поскольку порядок вычисления условий в SQL не определяется и отдается на откуп оптимизатору, мы **не можем гарантировать зависимость** выполнения одного запроса от другого, как это делается в обычных ЯП:
```
... = condA() && condB() // condB выполняется только при истинности condA
... = condA() || condB() // condB выполняется только при ложности condA
```
> О проблемах работы со сложными условиями можно ознакомиться в статьях ["PostgreSQL Antipatterns: вычисление условий в SQL"](/ru/post/494776/) и ["PostgreSQL Antipatterns: скованные одной цепью EXISTS"](/ru/post/532852/).
>
>
### OR-цепочка
Фактически, приведенный выше прием с `CASE` позволяет преобразовать `OR`-цепочку запросов с неопределенным порядком выполнения:
```
(SELECT ...A) OR (SELECT ...B) OR (SELECT ...C)
```
... к заведомо определенному порядку:
```
CASE
WHEN (SELECT ...A) THEN TRUE
WHEN (SELECT ...B) THEN TRUE -- выполнится только при ложности ...A
WHEN (SELECT ...C) THEN TRUE -- выполнится только при ложности ...A и ...B
END
```
В качестве условия тут может использоваться любой запрос, возвращающий `boolean` - например, `EXISTS(SELECT ...)`.
### AND-цепочка
А что если у нас условия связаны не через `OR`, а через `AND`?
```
(SELECT ...A) AND (SELECT ...B) AND (SELECT ...C)
```
В этом случае нам помогут **вложенные CASE**:
```
CASE
WHEN (SELECT ...A) THEN
CASE
WHEN (SELECT ...B) THEN
(SELECT ...C)
END
END
```
А в процедурном коде того же можно добиться с помощью **вложенных IF**:
```
IF (SELECT ...A) THEN
IF (SELECT ...B) THEN
IF (SELECT ...C) THEN
...
END IF;
END IF;
END IF;
```
UNION ALL + LIMIT
-----------------
Еще один способ заставить PostgreSQL не выполнять часть запроса - ограничить размер целевой выборки для блока `UNION ALL`:
```
(
SELECT 1
WHERE
random() < 0.5
)
UNION ALL
(
SELECT 2
)
LIMIT 1;
```
В [половине случаев](https://explain.tensor.ru/archive/explain/913aba4ac9a898d4c9120ffa9783a3ca:0:2022-05-27) второй вложенный запрос не станет выполняться:
UNION ALL + LIMIT
> Интересные прикладные задачи, ускоряемые таким способом, разобраны в статьях ["PostgreSQL Antipatterns: вредные JOIN и OR"](/ru/post/479508/) и ["PostgreSQL Antipatterns: сказ об итеративной доработке поиска по названию, или «Оптимизация туда и обратно»"](/ru/post/491162/) - например, как вовсе избавиться от сортировки при выполнении запроса.
>
>
LATERAL
-------
Посмотрим на простом примере, где мы хотим нагенерировать "вложенный цикл":
```
SELECT
a
, b
FROM
(
SELECT
generate_series(1, 4)
) X(a)
JOIN
(
SELECT
generate_series(1, 4)
) Y(b)
ON b <= a;
```
Генерация "вложенного цикла" через JOINЧем плох [этот план](https://explain.tensor.ru/archive/explain/d965a240be936269d926b11fc3fb0cbe:0:2022-05-27)? Как минимум, мы тут **нагенерили и сразу отфильтровали лишних** 6 записей, поскольку условие `a <= b` применяли только к результату. А ведь `a` можно передать во второй запрос с помощью `LATERAL` - обратимся к [мануалу](https://postgrespro.ru/docs/postgresql/14/sql-select):
> Ключевое слово `LATERAL` может предварять вложенный запрос `SELECT` в списке `FROM`. Оно позволяет **обращаться** в этом вложенном `SELECT` **к столбцам** элементов `FROM`, **предшествующим** ему в списке `FROM`. (Без `LATERAL` все вложенные подзапросы `SELECT` обрабатываются независимо и не могут ссылаться на другие элементы списка `FROM`.)
>
>
То есть, помимо штатной цели, использование `LATERAL` заставляет планировщик запроса обеспечить вычисление тех его частей, на которые мы будем ссылаться - то есть так мы можем **управлять порядком выполнения** `JOIN`:
```
SELECT
a
, b
FROM
(
SELECT
generate_series(1, 4)
) X(a)
, LATERAL
(
SELECT
generate_series(1, a)
) Y(b);
```
Тут уже [более эффективный план](https://explain.tensor.ru/archive/explain/dcf72fce7b5d7f30e803f96a5cd76fa6:0:2022-05-27) без лишних фильтраций:
Генерация "вложенного цикла" через LATERAL### А можно попроще?
Но не будем останавливаться на достигнутом и прочитаем мануал дальше:
> Слово `LATERAL` можно также добавить перед вызовом функции в списке `FROM`, но в этом случае оно **будет избыточным**, так как **выражения с функциями могут ссылаться на предыдущие элементы** списка `FROM` в любом случае.
>
>
```
SELECT
a
, b
FROM
generate_series(1, 4) X(a)
, generate_series(1, a) Y(b);
```
Функция за функциейИнтересно, что несмотря на [облегчение плана](https://explain.tensor.ru/archive/explain/60d747d36cbbba73fb7f50e77a0e5488:0:2022-05-27), время его выполнения оказалось вдвое хуже предыдущего варианта на таких микро-выборках, хоть и лучше исходного.
> Более сложные варианты оптимизации через `LATERAL` - ["PostgreSQL Antipatterns: «где-то я тебя уже видел...»](/ru/post/574330/)" и ["PostgreSQL Antipatterns: редкая запись долетит до середины JOIN"](/ru/post/484670/).
>
>
WITH ORDINALITY-нумерация
-------------------------
Раз уж коснулись особенностей работы с функциями, не стоит забывать про такую замечательную возможность как **встроенная нумерация строк** с помощью `WITH ORDINALITY`.
То есть, конечно, можно это делать и с помощью `row_number()`:
```
SELECT
id
, row_number() OVER() ord
FROM
unnest('{1,2,4,8,16}'::integer[]) id;
```
```
WindowAgg (actual time=0.014..0.019 rows=5 loops=1)
-> Function Scan on unnest id (actual time=0.009..0.009 rows=5 loops=1)
```
А можно "стильно, модно, молодежно" - с тем же результатом, но чуть быстрее:
```
SELECT
*
FROM
unnest('{1,2,4,8,16}'::integer[])
WITH ORDINALITY T(id, ord);
```
```
Function Scan on unnest t (actual time=0.008..0.008 rows=5 loops=1)
```
> А еще `WITH ORDINALITY` можно использовать для связывания элементов массивов. Или не использовать, если вы прочитали ["PostgreSQL Antipatterns: сизифов JOIN массивов"](/ru/post/479920/).
>
>
ROW-конструктор
---------------
Читаем в [мануале](https://postgrespro.ru/docs/postgresql/14/sql-expressions#SQL-SYNTAX-ROW-CONSTRUCTORS), что это такое:
> Конструктор табличной строки — это выражение, создающее строку или кортеж (или составное значение) из значений его аргументов-полей. Конструктор строки состоит из ключевого слова `ROW`, открывающей круглой скобки, нуля или нескольких выражений (разделённых запятыми), определяющих значения полей, и закрывающей скобки.
>
>
### Перебор индекса
Допустим, нам требуется найти **следующее по порядку индекса значение** в таблице - на этом способе основан алгоритм "быстрого `DISTINCT`", рассмотренный в статье ["PostgreSQL Antipatterns: убираем медленные и ненужные сортировки"](/ru/post/522114/).
Рассмотрим на примере системной таблицы `pg_attribute` и ее индекса `(attrelid, attnum)`, где попытаемся найти первое поле таблицы `pg_class` с положительным номером, если оно есть, или следующее за ним по индексу:
```
SELECT
*
FROM
pg_attribute
WHERE
(
attrelid = 'pg_class'::regclass AND -- если таблица есть
attnum > 0 -- надо взять "следующее" поле
) OR
attrelid > 'pg_class'::regclass -- если вдруг нету - "следующую" таблицу
ORDER BY
attrelid, attnum
LIMIT 1;
```
Пришлось прочитать [161 лишнюю запись](https://explain.tensor.ru/archive/explain/2acff2f905910df8b966fe7dd0cf351f:0:2022-05-27). А теперь - то же самое через эквивалентное условие для `ROW`:
```
SELECT
*
FROM
pg_attribute
WHERE
(attrelid, attnum) > ('pg_class'::regclass, 0)
ORDER BY
attrelid, attnum
LIMIT 1;
```
Теперь уже [никакой фильтрации](https://explain.tensor.ru/archive/explain/a62ce2b32a37ef51a71993db16af8a93:0:2022-05-27), все по индексу!
### Проверка наличия в списке
Выше мы сложное условие заменили на простое, но с `ROW`. И точно так же, как целостное значение, его можно воспринимать для оператора `IN`:
```
SELECT
(1, 2) IN ((1, 2), (3, 4), (5, 6));
```
```
SELECT
('pg_class'::regclass, 0) IN (
SELECT
attrelid, attnum -- тут не нужно оборачивать в ROW
FROM
pg_attribute
);
```
Правда, по описанным в начале статьи причинам, нужно гарантировать, что нигде не возникнут `NULL`'ы.
---
Ссылки на все упомянутые статьи (и даже много больше!) с разбивкой по темам можно найти в [моем профиле](/ru/users/Kilor/).
Будь как Блиц! | https://habr.com/ru/post/667998/ | null | ru | null |
# Обработка всех исключений в контроллерах с помощью атрибута
Всё мы знаем, что в ASP.NET MVC есть такой атрибут `HandleErrorAttribute`, который как сказано в MSDN
> Представляет атрибут, используемый для обработки исключения, вызываемого методом действия.
>
>
Но нигде, в том же MSDN не сказано (~~ткните меня носом~~ дайте ссылку где это написано, если я просмотрел), что он обрабатывает только исключения, устанавливающие код ответа сервера в 500.
Посмотрев на исходный код `HandleErrorAttribute` легко убедиться в этом. Там имеются следующие строки:
```
// If this is not an HTTP 500 (for example, if somebody throws an HTTP 404 from an action method),
// ignore it.
if (new HttpException(null, exception).GetHttpCode() != 500) {
return;
}
```
Не знаю, как вам, а мне удобнее при возникновении исключения, чтобы пользователи видели специальную страницу для этого, а не «жёлтую страницу смерти» или вообще как браузер отображает стандартную для него страницу с кодом ответа сервера (зависит от настроек в Web.config, но об этом позже).
#### Создание собственного аналога `HandleErrorAttribute`
Итак, мы выяснили, что стандартный `HandleErrorAttribute` нам не подходит, ну что же, создадим свой.
Можно конечно, создать класс наследуя его от интерфейса `IExceptionFilter`, но нас в общем то устраивает поведение стандартного `HandleErrorAttribute`, если бы он обрабатывал все исключения. А раз нас почти всё устраивает, будет наследовать наш класс от неугодного нам `HandleErrorAttribute`.
```
public class HandleAllErrorAttribute : HandleErrorAttribute
{
public override void OnException(ExceptionContext filterContext)
{
if (filterContext == null)
{
throw new ArgumentNullException("filterContext");
}
// If custom errors are disabled, we need to let the normal ASP.NET exception handler
// execute so that the user can see useful debugging information.
if (filterContext.ExceptionHandled || !filterContext.HttpContext.IsCustomErrorEnabled)
{
return;
}
Exception exception = filterContext.Exception;
if (!ExceptionType.IsInstanceOfType(exception))
{
return;
}
string controllerName = (string)filterContext.RouteData.Values["controller"];
string actionName = (string)filterContext.RouteData.Values["action"];
HandleErrorInfo model = new HandleErrorInfo(filterContext.Exception, controllerName, actionName);
filterContext.Result = new ViewResult
{
ViewName = View,
MasterName = Master,
ViewData = new ViewDataDictionary(model),
TempData = filterContext.Controller.TempData
};
filterContext.ExceptionHandled = true;
filterContext.HttpContext.Response.Clear();
filterContext.HttpContext.Response.StatusCode = new HttpException(null, exception).GetHttpCode();
// Certain versions of IIS will sometimes use their own error page when
// they detect a server error. Setting this property indicates that we
// want it to try to render ASP.NET MVC's error page instead.
filterContext.HttpContext.Response.TrySkipIisCustomErrors = true;
}
}
```
Для начала скажу, что это код стандартного `HandleErrorAttribute`, за исключением нескольких строк, проверяющих на `HttpStatusCode`.
Собственно, что он делает:
* Проверяет входные параметры на валидность
* Проверяет включены ли `customErrors`
* Заполняет данными класс `HandleErrorInfo`
* Создаёт новый `ViewResult`, заполняет данными и присваивает вместо текущего
* Очищает ошибки сервера и устанавливает код ответа сервера
Класс наш готов, теперь заменим стандартный атрибут на наш. Сделаем это через глобальные фильтры, чтобы нам не писать его каждому контроллеру или действию контроллера. В данном случае это не критично, но в реальности может пригодиться. Итак, идём в *Global.asax.cs* и прописываем вместо стандартного фильтра, наш только что созданный атрибут:
```
filters.Add(new HandleAllErrorAttribute());
```
#### Испытание
Теперь, чтобы убедится, что наш фильтр работает и передаёт необходимые данные во `View`, несколько изменим стандартный *~/Views/Shared/Error.cshtml*:
```
@model System.Web.Mvc.HandleErrorInfo
@{
ViewBag.Title = "Error";
}
Sorry, an error occurred while processing your request.
---------------------------------------------------------
### @Model.Exception.Message
```
И добавим в *Web.config* (который находится в корне) в секцию `System.Web` следующую строку:
```
```
Этой строчкой мы включаем пользовательскую обработку ошибок, точнее пользовательские страницы для ошибок.
Теперь нам необходимо вызвать исключение, я сделаю это в действии стандартного контроллера (созданного студией):
```
public ActionResult About()
{
throw new HttpException(403, "Доступ запрещён!");
return View();
}
```
Всё! Запускаем проект, переходим в раздел «About» и видим, что наш атрибут отработал корректно.
 | https://habr.com/ru/post/137672/ | null | ru | null |
# Сборка Qt 5.1 приложений под Android на Mac, seriously?
Привет, QHabr.
Сегодня хотел бы рассказать вам про адъ, который кроется за сборкой Qt 5.1 приложения для андрюши на Mac OS X. Чтобы никто их хабралюдей ни в коем случае не попал туда на 7-8 часов, я решил сделать подробный step-by-step гайд. Ну что, приступим к делу.
Совсем недавно, Qt Project анонсировал Qt 5.1 RC1. Это пока достаточно рабочий свежак, но с неплохими нововведениями. Одно из них — поддержка кросс-компиляции Android. Замечательно, не так ли? Они даже любязно предоставили нам сборку кьюта под android… для Linux. Но как же быть тем, кто использует Mac, или куда более ущербный Windows для разработки? А ничего, собирайте сами.
Но сборка последнего Qt из Git, с нужными параметрами под маком, не говоря о Windows — это адъ. Сегодня я помогу вам спасти свои души!
#### Шаг 1. Подготавливаем систему
На данный момент в PATH должны лежать:
* Git >= 1.6
* Perl >= 5.14
* Python >= 2.6
* Самый последний XCode с его Command Line Tools
* Последний Android SDK
* Последний Android NDK
* Могучая горсть терпения
Может быть, я что-то пропустил, но все же мы продолжаем.
#### Шаг 2. Получение и конфигурация Qt
Сейчас открываем консольку, переходим в удобную вам пустую папку и выполняем:
```
git clone git://gitorious.org/qt/qt5.git qt5
cd qt5
```
Теперь пора сконфигурировать нашу локальную версию:
```
perl init-repository --no-webkit # вебкит зачастую никому не нужен, к тому же эта жирная скотина долго собирается
```
А теперь самое сложное — конфигурация. Я использовал такие ключи:
```
./configure -prefix -release -shared -opensource -nomake examples -nomake tests -nomake tools -confirm-license -developer-build -xplatform android-g++ -android-ndk -android-sdk -android-ndk-host darwin-x86\_64 -skip qttranslations -skip qtserialport
```
Поздравляю, товарищи! Локальная копия Qt from Git сконфигурирована!
#### Шаг 3. Сборка Qt from Git
Тут все куда интереснее — нужно задать несколько переменных окружения (у меня такие пути):
```
export JAVA_HOME=/Library/Java/Home
export ANDROID_HOME=/usr/local/Android/sdk
export ANDROID_NDK_ROOT=/usr/local/Android/ndk
export ANDROID_NDK_HOST=darwin-x86_64
export ANDROID_NDK_PLATFORM=android-17
export ANDROID_NDK=/usr/local/Android/ndk
export MAKE=/usr/bin/make
```
Теперь стоит собрать и установить Qt 5.1 выполнением комманд
```
make
make install
```
#### Шаг 4. Нам нужен последний Qt Creator
Возвращаемся в папку, где мы выполняли git clone (в самом начале статьи) и делаем следующее:
```
git clone git://gitorious.org/qt-creator/qt-creator.git qtc
cd qtc
qmake # кумейк нормального десктопного кьюта
make
```
Запускаем его и уходим в Preferences -> Android. Настраивам пути и создаем Android Virtual Device.
Теперь переходим в Compilers и мы должны увидеть примерно такую картину (у меня немного больше компиляторов вроде как должно быть):
Наступил черед Qt Version, заходим и создаем Qt for Android, указывая путь на qmake в папке установки кьюта, которого мы сегодня собрали
И под чечетку и фанфары модифицируем, уже созданный автоматически Kit
#### Шаг 5. Собираем приложение!
Создаем обычное Qt GUI приложение, задаем Kit — Qt 5.1 Android, или как он у вас там называется. Работаем в пределах MainWindow и нажимаем Command+R.
[](https://habrastorage.org/storage2/514/9de/4aa/5149de4aa1b109478e52b7d474436a59.png)
[](https://habrastorage.org/storage2/693/f65/758/693f65758562cdcf1623c194ac5650c5.png)
[](https://habrastorage.org/storage2/829/a81/6aa/829a816aa4018d64c4b5d7c20ba29481.png)
[](https://habrastorage.org/storage2/d02/4fb/f35/d024fbf355323d157126eb5535a48e80.png)
[](https://habrastorage.org/storage2/e97/c83/356/e97c833569162cc7f5688cdc7693f84a.png)
[](https://habrastorage.org/storage2/c9c/818/03a/c9c81803a00f1d0649a99a58d9c29a0f.png)
Скорее всего вам придется пошаманить с настройками деплоя
[](https://habrastorage.org/storage2/69c/22b/2b2/69c22b2b267c3a8d75f1c1d3f76d715a.png)
и манифестом приложения
[](https://habrastorage.org/storage2/5ba/aac/1cd/5baaac1cd02108d448d6296056c27ff6.png)
#### Послесловие
```
Habrahabr::Reader *reader = this->reader();
reader->thankYou();
``` | https://habr.com/ru/post/185140/ | null | ru | null |
# Особенности настройки коммутаторов ExtremeXOS
Данная статья призвана сократить количество времени, необходимое для понимания принципов работы с **ExtremeXOS (XOS)**. Когда я начинал знакомство с XOS, мне очень не хватало такой статьи на Хабре.
Ниже я расскажу о конфигурации Экстримов и о проблемах, с которыми я сталкивался. Надеюсь, поможет сетевым инженерам, которые только начинают работать с XOS. Вне зависимости от модели коммутатора, – синтаксис CLI абсолютно одинаковый.
*Стенд коммутаторов Extreme*
К делу
------
Для виртуализации оборудования я использую [Eve-Ng](http://eve-ng.net/) и образ [Virtual ExtremeOS (XOS)](https://github.com/extremenetworks/Virtual_EXOS). Можно также использовать GNS3.
Как же выглядит настройка коммутаторов В XOS нет необходимости переключения режимов работы, все команды вводятся из обычного режима, отмеченного **#**, в случае админского аккаунта; и **>** в случае пользователя.
Для начала хотелось бы обозначить «основные» принципы команд в EOS. Всё строится на трех командах и их антонимов: **create**, **configure**, **enable** (**delete**, **unconfigure**, **disable** соответственно). То есть: создаем, настраиваем, активируем. Выглядит логично.
```
create vlan 10
configure vlan 10 ipaddress 192.168.1.1/24
```
Также следует понимать, что большинство конфигураций настраивается на **VLAN**. То есть в XOS почти все привязано к VLAN’ам. Даже назначение VLAN на порт происходит в настройке VLAN, то есть порт вешается на vlan.
Особое внимание хочется уделить виртуальным маршрутизаторам (*VR*), которые есть по умолчанию в коммутаторе. Есть VR-Default, которому принадлежат все порты, и VR-mgmt, которому принадлежит mgmt. порт. В XOS для всех команд, которые куда-то отправляют трафик (ping, ssh, telnet, download, etc.) необходимо указывать VR.
```
ping vr "VR-Default" 192.168.1.1
```
Обновление коммутаторов XOS
---------------------------
В XOS есть два раздела (partition) под ОС: primary и secondary. Функционально они ничем не различаются, только названиями. Устанавливать обновления можно только в неактивный на данный момент раздел. Для этого можно использовать аргумент inactive. После обновления требуется перезагрузка, и коммутатор загрузится с другого (только что обновленного) раздела. Это оставляет возможность быстрого отката, в случае проблем, просто выбрав другой раздел при загрузке (тот, где осталась старая ОС). Также замечу, что все образы с патчами представляют собой полноценный образ, то есть не надо ставить мажорную версию, а потом несколько минорных. При загрузке используется tftp:
```
download image 192.168.1.1 summitX-21.1.4.4-patch1-3.xos vr "VR-Default" inactive
```
Узнать, какой сейчас раздел используется, можно при помощи:
```
show system
…
Image Selected: primary
Image Booted: secondary
Primary ver: 22.3.1.4
Secondary ver: 21.1.1.4
```
Стекирование коммутаторов
-------------------------
Для стекирования коммутаторов XOS необходимо включить поддержку стекирования и перезагрузить коммутатор:
```
enable stacking-support
reboot
```
Очень удобно, что в стек можно объединять коммутаторы разных моделей, при этом мастером будет коммутатор, с наибольшей производительностью. Например, это может быть необходимо для стека 10G коммутаторов на 16 портов для серверов, к которым добавляется 48-портовый 1G коммутатор, в который включаются mgmt.-интерфейсы.
Для стекирования коммутаторы должны иметь одинаковую версию ОС. Стекирование производится через определенные Ethernet порты, для каждой модели разные, которые можно найти в документации. В случае, если вы соберете коммутаторы по схеме портов 1 в 2, 2 в 1, то коммутаторы Extreme можно будет собрать в стек по упрощенной процедуре easy-stack, которая сама привяжет мак-адреса к номеру слота и другие настройки. При этом первым станет коммутатор, на котором вы примените enable stacking, остальным будут присвоены номера по цепочке. Это довольно удобный способ, позволяющий сэкономить много времени. После стекирования порты будут иметь вид SLOT:PORT (1:1, 2:35).
```
X440G2-48p-10G4.1 # show stacking
Stack Topology is a Ring
This node is not in an Active Topology
Node MAC Address Slot Stack State Role Flags
------------------ ---- ----------- ------- ---
*00:04:96:xx:xx:xx - Disabled Master ---
00:04:96:xx:xx:xx - Disabled Master ---
00:04:96:xx:xx:xx - Disabled Master ---
00:04:96:xx:xx:xx - Disabled Master ---
00:04:96:xx:xx:xx - Disabled Master ---
* - Indicates this node
Flags: (C) Candidate for this active topology, (A) Active Node
(O) node may be in Other active topology
X440G2-48p-10G4.2 # enable stacking
You have not yet configured all required stacking parameters.
Would you like to perform an easy setup for stacking operation? (y/N) Yes
Executing "configure stacking easy-setup" command...
For every node in the 5-node stack, this command will:
- enable stacking
- configure a stack MAC address
- choose and configure a slot number (this node will be assigned to slot 1)
- configure redundancy to minimal (slot 1 will be the master node)
- configure the stacking protocol to enhanced
Upon completion, the stack will automatically be rebooted into the new configuration.
Warning: If stacking is already configured, this command will alter that configuration.
Do you wish to proceed? (y/N) Yes
Stacking configuration is complete. Rebooting...
```
Обновление стека заключается в том, что обновляется master, а дальше он сам по очереди разливает новую версию на остальные слоты. **Перезагрузка необходима**.
Лицензирование
--------------
Каждый коммутатор идет с предустановленной лицензией (edge, advanced edge, core, и т.д.). Каждая лицензия имеет свой набор функций, которые могут быть активированы на коммутаторе, например, количество портов, которые могут быть использованы в OSPF. Также есть лицензии на отдельные feature. Подробнее можно прочитать [здесь](https://gtacknowledge.extremenetworks.com/articles/Q_A/ExtremeXOS-Feature-Licensing).
Одна из самых частых лицензий – лицензия на feature: *Dual-10GB-Uplink*. Данная лицензия на edge коммутаторе-1G позволяет использовать 2x 10GbE порта. Например, на X440-G2-48p.
Лицензии доступны в личном кабинете на сайте Extreme, после чего активируются (без перезагрузки) и проверяются командой.
```
enable license XXXX-XXXX
show licenses
```
В случае, если в стеке коммутаторов используются разные лицензии, будет использована наименьшая.
Настройка
---------
Небольшое отступление: Чтобы посмотреть результаты команд, которые будут ниже, а также любую другую информацию, в большинстве случаев можно использовать show, заменяя create и configure. Например, show vlan.
Hint: При использовании show ports – XOS построит обновляемую раз в несколько секунд таблицу, которая позволяет в реальном времени отслеживать состояние интерфейсов. Для того, чтобы получить вывод без обновления, необходимо использовать “show ports no-refresh”.
Первое, что приходит в голову, что нужно бы настроить это *hostname*. Казалось бы, должно быть как-то так:
~~configure hostname Ex\_sw\_1~~
Но не все так просто, на самом деле делается это так:
```
configure snmp sysName Ex-sw-1
```
Создаем VLAN:
```
create vlan My_Vlan_Five tag 5
```
Или так, причем именно так будет отображено в конфиге:
```
create vlan My_Vlan10
configure vlan My_Vlan10 tag 10
```
Учитывая практический опыт и реалии вывода команд и настройки XOS, я создал для себя правило: в названии vlan в конце дописывать его тег, что облегчает восприятие и настройку:
```
create vlan users-10 tag 10
```
В XOS нет как таковых trunk и access портов. Вместо этого используются понятия: тегированный и нетегированный трафик на интерфейсе с привязкой к vlan. Может быть один нетегированный и много тегированных vlan. Порты нумеруются цифрами (или slot:port в стеке), все очень просто.
```
configure vlan My_Vlan-5 add ports 1 tagged
configure vlan My_Vlan1 add ports 1 untagged
```
Соответственно, весь трафик без тега, приходящий на интерфейс будет тегироваться как “*My\_Vlan1*”.
При этом vlan можно задавать как через <*Name*>, так и через <*tag*>, причем в любых комбинациях (используя *vlan\_list*, то есть числовой по тегам). Без указания атрибута в конце используется <*untagged*>:
```
сonfigure vlan 1,5-10,15-20 add ports 1-8, 48 tagged
configure vlan web-110 add ports 5
сonfigure vlan 20 add ports 30-40,45 untagged
```
Так как большинство коммутаторов серии SummitX это **L3** коммутаторы, то вот так настраиваются SVI:
```
configure vlan 125 ipaddress 192.168.125.1/24
```
После этого необходимо применить данную команду, иначе vlan останется немаршрутизируемым:
```
enable ipforwarding vlan 125
enable ipforwarding vlan 10-50,60
```
Чтобы посмотреть, какие vlan есть на интерфейсе, можно использовать команду:
```
show ports 2 vlan
```
Для просмотра и сохранения конфигурации используются следующие команды и имеются primary и secondary конфигурационные файлы:
```
save
save secondary
show configuration
```
Агрегация каналов
-----------------
Один из неудобных моментов, которые я встретил, — это агрегация каналов. (port-channel). Общая суть выглядит так: вы назначаете мастер-порт и к нему до семи вторичных интерфейсов. Далее все настройки производятся лишь на конкретном мастер-порте, нет никаких логических интерфейсов вида *po1*. Минус же в том, что если Вы хотите изменить мастер порт, то необходимо руками переносить все настройки на другой порт, так как при удалении агрегированного канала весь конфиг на нём слетает. Решение этого неудобства есть в [этой статье](https://habr.com/company/ivi/blog/264527/), однако все равно получается не идеально. В XOS агрегация называется **sharing**.
Для включения такого порта необходимо применить команду вида:
```
enable sharing [MASTER_PORT] grouping [PORT_LIST] [lacp]
enable sharing 1 grouping 1-2 lacp
```
На версии ниже чем 22.X необходимо дописывать алгоритм «балансировки»:
```
enable sharing 1 grouping 1-2 algorithm address-based L2 lacp
```
Защита от петель второго уровня OSI
-----------------------------------
На коммтутаторах Summit-X до-мажорной версии 22.2 по умолчанию был **отключен** протокол защиты от петель второго уровня. (STP и другие). На момент написания статьи, рекомендованный вендором софт — это 21.1.5.2.
### ELRP
В одном из своих проектов я использовал проприетарный протокол ELRP, который предназначен для обнаружения и предотвращения петель. В ходе тестов он показал хорошие результаты (скорость отключения порта при петле и др.). Данный протокол отправляет мультикастом PDU, и если отправитель его снова получает, то значит есть петля.
Интервал отвечает за частоту рассылки PDU, в данном случае — 2 секунды. В случае петли порт будет заблокирован на 180 секунд, после чего будет снова послана PDU. Варианты оповещения: log, trap, log-and-trap. В случае trap, соответственно, посылается snmp trap.
Настраивается данный протокол per-vlan, также, как и большинство конфигураций в XOS.
```
enable elrp-client
configure elrp-client periodic Buh-123 ports all interval 2 log disable-port ingress duration 180
```
Чтобы протокол ELRP не блокировал аплинки коммутаторов доступа или критично-важные соединения, используется команда исключения портов из блокировки.
```
configure elrp-client disable-port exclude 35
configure elrp-client disable-port exclude 1:1
```
### STP
STP настраивается чуть мудренее, но в целом особых проблем не возникает. В XOS данный протокол именуется “stpd”, во всех командах для настройки STP, используется именно он. Можно его сделать per-vlan, используя разные STP-домены. “domain-id” и “vlan-id” должны совпадать. Порты в STP можно добавлять либо вручную, либо используя vlan auto-bind. Как только к vlan’у добавляется порт, то этот порт автоматически добавляется в STP. Такая вот логика. Настройка режима: dot1d STP, dot1w – RSTP:
```
configure stpd "s0" priority 4096
configure stpd s0 mode dot1w
enable stpd s0
enable stpd "s0" auto-bind "VLAN_0005"
```
VRRP
----
VRRP — это один из видов FHRP, аналог HSRP в Cisco. Для каждой сети(vlan’а) необходимо использовать vrid, который может быть от 1 до 255. Приятно порадовала возможность маршрутизации трафика с backup-vrrp-L3-коммутатора с использованием опции fabric-routing. По умолчанию приоритет равен 100. У кого из коммутаторов приоритет выше, тот становится «Master».
```
create vrrp vlan test1 vrid 125
configure vrrp vlan test1 vrid 125 priority 50
configure vrrp vlan test1 vrid 125 fabric-routing on
enable vrrp vlan test1 vrid 125
```
MLAG
----
Про то, что это такое и зачем, очень хорошо рассказано [здесь](https://habr.com/company/muk/blog/225479/): это, по сути, аналог Cisco VPC. **ISC** – соединение между коммутаторами mlag-пары.
В моем случае обычно использовалась такая схема:
Необходимо создать соседа(peer), для того чтобы можно было относить конкретные порты с mlag к конкретному соседу, так как Extreme поддерживает возможность использования нескольких соседей. Для ISC нужен vlan, используемый только для ISC и имеющий IP адрес. Соответственно, peer для X670-1 у нас будет X670-2, а mlag порты будут x440. Для функционирования необходимо создать канал аггрегации, причем на x670 для одного порта в сторону x440, и агреггированный канал в сторону X670-2, в котором будут **ВСЕ** Vlan’ы, участвующие в mlag.
На x670:
```
Enable sharing 1 grouping 1 lacp
create mlag peer "mlag1"
configure mlag peer "mlag1" ipaddress 10.255.255.2 vr VR-Default
enable mlag port 1 peer "mlag1" id 1
```
На х440-stack:
```
enable sharing 1:51 grouping 1:51,2:51 lacp
```
MLAG+VRRP
---------
Во время тестирования коммтуаторов на стенде была найдена проблема, что VRRP забирает Master-роль до того, как поднимутся все остальные интерфейсы (ISC поднимается первым) и протоколы, что приводило к даунтайму сети порядка минуты.
Данная проблема решилась следующими командами, однако они доступны только с “EXOS 21.1.3.7-patch1-4” и “EXOS 22.3”:
```
configure mlag ports reload-delay 60
enable mlag port reload-delay
```
Маршрутизация
-------------
Статичные маршруты задаются следующим образом, тут проблем быть не должно. Можно маску задавать в любом варианте.
```
configure iproute add 10.0.66.0 255.255.255.0 172.16.1.1
configure iproute add 10.0.0.1/32 10.255.255.255
configure iproute add default 172.16.0.1
```
### OSPF
Для маршрутизации, в моей практике, использовался OSPF с одной зоной. Для обеспечения работоспособности необходимо задать router-id, а также добавить каждый vlan, который необходимо анонсировать (по аналогии в Cisco: network).
```
configure ospf routerid 192.168.1.1
enable ospf
configure ospf add vlan routing-5 area 0.0.0.0
configure ospf add vlan Voip-32 area 0.0.0.0 passive
```
Остальные мелочи
----------------
### DHCP Relay
Настраивается следующим образом:
```
configure bootprelay add 192.168.12.5 vr VR-Default
enable bootprelay ipv4 vlan servers-500
```
При создании нового vlan необходимо добавлять его вручную в список vlan с DHCP Relay.
### SSH + ACL для SSH
Ssh включается следующим образом:
```
enable ssh2
```
Для ограничения доступа к ssh необходимо создать отдельный файл политики вида NAME.pol и повесить его на SSH.
```
vi ssh.pol
```
Политика:
```
Entry AllowTheseSubnets {
if match any {
source-address 192.168.0.0 /16;
source-address 10.255.255.34 /32;
}
Then
{
permit;
}
}
```
Команда для применения политики:
```
enable ssh2 access-profile ssh.pol
```
### Description + display-string
Для удобства настройки и последующей эксплуатации можно задавать «имя» и «описание» интерфейса.
```
сonfigure port 1 description “this is port number one”
```
Описание интерфейса будет выводится только в командах вида:
```
show ports description
```
Имя интерфейса заменит практически везде его номер в выводе команд. Имя не должно содержать пробела и ограничено длинной в 20 символов.
```
сonfigure port 1 display-string UserPort
EXOS-VM.8 # sh port vlan
Untagged
Port /Tagged VLAN Name(s)
-------- -------- ------------------------------------------------------------
UserPort Untagged Default
2 Untagged Default
3 Untagged Default
```
Заключение
----------
**XOS** также позволяет автоматизировать многие действия и подстраивать систему под свои нужды, так как нативно поддерживает Python и встроенный механизм создания и запуска скриптов, используя команды командной строки(*CLI-Scripting*).
Я открыт для пожеланий по улучшению статьи и исправлению неточностей/ошибок, а также вопросов.
**UPD**: LLDP для IP-телефонов настраивается с использованием команд [из данного комментария](https://habr.com/post/419965/#comment_18988285). | https://habr.com/ru/post/419965/ | null | ru | null |
# Делаем минимальную отладочную плату на STM32G030F6P6 и шьем в Arduino IDE
В разработке оказалось несколько устройств в составе которых кроме прочего планируется использовать F030F6P6. Они маленькие и достаточно производительные. Для мониторинга вполне достаточно. Программист я так себе, занимаюсь в основном железом. Но пощупать некоторые функции приходится, и тогда на помощь приходит Arduino IDE.
Эх, даже флюс не отмылSTM32G030F6P6
-------------
32х битный МК на ядре CORTEX M0+ , доступен в корпусах SO8, TSSOP20, LQFP32. В этой статье речь пойдет о втором варианте.
В линейке есть версии от 32 до 64кб флэш. Оперативной памяти у всех 8кб.
Рабочая частота до 64МГц, но в корпусе TSSOP20 доступно только внешнее либо внутреннее тактирование. Использовать кварц возможности нет.
Куча интерфейсов, таймеров и прочих плюшек, как и бывает у STM. Впрочем подробнее вы можете посмотреть в [даташите](https://www.st.com/resource/en/datasheet/stm32g030c8.pdf).
И такое бывает...
-----------------
Иногда такое случается, что в процессе отладки появляются сюрпризы. Например у ESP32 при использовании модема не работает второй порт АЦП. У STM32 подобных недоразумений я не встречал, но бывает что перепутаешь ногу, и окажется вдруг например что ШИМ на него повесить нельзя. Это может стать большой проблемой, если устройство уже начали готовить к серии, а может даже заказали производство плат. К тому-же отладка тех же БП, если управление на МК, без хотя бы какой-то тестовой прошивки невозможна.
Так вот наиболее быстро написать тестовую прошивку можно в Arduino IDE. Способствует этому большое количество поддерживаемых архитектур и бесконечное множество доступных библиотек.
Есть конечно готовые модули на том же алиэкспресс. Но не всегда есть возможность ждать, да и собрать такую небольшую плату не составляет труда, и не отнимает много времени.
От слов к делу
--------------
Для тестов именно этого МК я нарисовал простейшую схему и плату. Как бы я не любил кварцевые резонаторы, в данном корпусе этот вид тактирования недоступен. А значит и обвязки у нас 6 элементов- 2 конденсатора по питанию, безопасный USART1, подтяжка на Reset и на BOOT0.
СхемаСкомпоновано это в форм-фактор рассчитанный на установку в беспаечную макетную плату. Рисунок платы кстати можно использовать как шпаргалку по портам.
ПлатаПосле ЛУТаПрограммирование
----------------
В конкретно данном случае мне было необходимо проверить работу датчика температуры DS18B20 на порту PA5.
Настройки среды остались стандартные.
Ядро используется самое распространенное [Arduino Core STM32](https://github.com/stm32duino/Arduino_Core_STM32).
Программирование по SWD при помощи ST Link. Не забудьте установить [прошивальщик](https://www.st.com/en/development-tools/stm32cubeprog.html), к нему будет обращаться Arduino IDE при прошивке.
При программировании STM32 из Arduino IDE есть конечно свои нюансы. Например для UART нужно назначать пины явно, особенно в тех случаях когда он может мультиплексироваться.
Тут например пришлось заглянуть в файл [PeripheralPins.c](https://github.com/stm32duino/Arduino_Core_STM32/blob/b8756be9e028dfa1651591e2d2ca956773189669/variants/STM32G0xx/G030F6P/PeripheralPins.c)
```
#ifdef HAL_UART_MODULE_ENABLED
WEAK const PinMap PinMap_UART_TX[] = {
{PA_2, USART2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART2)},
{PA_9_R, USART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART1)},
{PA_14, USART2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART2)},
{PB_6, USART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_USART1)},
{NC, NP, 0}
};
#endif
#ifdef HAL_UART_MODULE_ENABLED
WEAK const PinMap PinMap_UART_RX[] = {
{PA_3, USART2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART2)},
{PA_10_R, USART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART1)},
{PA_15, USART2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART2)},
{PB_7, USART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_USART1)},
{NC, NP, 0}
};
#endif
```
Т.к. 1 нога нашего МК может назначаться как PB7 или PB8, а 20я- PB3/PB4/PB5 или PB7, то взглянув в этот файлик можно понять что маппинг будет выглядеть так:
```
HardwareSerial Serial1(PB7,PB6);
```
Код для работы с датчиком был позаимствован [здесь](https://how2electronics.com/interfacing-ds18b20-temperature-sensor-with-stm32/). Итого на копипасту прошивки и легкую подгонку ушло минут 10-15. А отладочная плата мне пригодится и в будущем при работе с данным МК.
Весь код
```
int DSPIN = PA5;
// RX TX
HardwareSerial Serial1(PB7, PB6); //привязываем порты к USART
void setup() {
Serial1.begin(9600); //инициализация USART1
}
void loop() {
delay(500);
double temp = TempRead();
temp = temp * 0.0625; // conversion accuracy is 0.0625 / LSB
Serial1.print("Temperature: ");
Serial1.print(temp);
Serial1.println(" °C");
Serial1.println("");
}
boolean DS18B20_Init()
{
pinMode(DSPIN, OUTPUT);
digitalWrite(DSPIN, HIGH);
delayMicroseconds(5);
digitalWrite(DSPIN, LOW);
delayMicroseconds(750);//480-960
digitalWrite(DSPIN, HIGH);
pinMode(DSPIN, INPUT);
int t = 0;
while (digitalRead(DSPIN))
{
t++;
if (t > 60) return false;
delayMicroseconds(1);
}
t = 480 - t;
pinMode(DSPIN, OUTPUT);
delayMicroseconds(t);
digitalWrite(DSPIN, HIGH);
return true;
}
void DS18B20_Write(byte data)
{
pinMode(DSPIN, OUTPUT);
for (int i = 0; i < 8; i++)
{
digitalWrite(DSPIN, LOW);
delayMicroseconds(10);
if (data & 1) digitalWrite(DSPIN, HIGH);
else digitalWrite(DSPIN, LOW);
data >>= 1;
delayMicroseconds(50);
digitalWrite(DSPIN, HIGH);
}
}
byte DS18B20_Read()
{
pinMode(DSPIN, OUTPUT);
digitalWrite(DSPIN, HIGH);
delayMicroseconds(2);
byte data = 0;
for (int i = 0; i < 8; i++)
{
digitalWrite(DSPIN, LOW);
delayMicroseconds(1);
digitalWrite(DSPIN, HIGH);
pinMode(DSPIN, INPUT);
delayMicroseconds(5);
data >>= 1;
if (digitalRead(DSPIN)) data |= 0x80;
delayMicroseconds(55);
pinMode(DSPIN, OUTPUT);
digitalWrite(DSPIN, HIGH);
}
return data;
}
int TempRead()
{
if (!DS18B20_Init()) return 0;
DS18B20_Write (0xCC); // Send skip ROM command
DS18B20_Write (0x44); // Send reading start conversion command
if (!DS18B20_Init()) return 0;
DS18B20_Write (0xCC); // Send skip ROM command
DS18B20_Write (0xBE); // Read the register, a total of nine bytes, the first two bytes are the conversion value
int temp = DS18B20_Read (); // Low byte
temp |= DS18B20_Read () << 8; // High byte
return temp;
}
```
Файлы
-----
Схема и ПП нарисованы в DipTrace.
[Файлы проекта на гитхаб](https://github.com/ENGIN33RRR/STM32G030F6P6).
---
Такой вот немного ленивый пост. Может кому такому же ленивому как я пригодится плата, ведь можно сэкономить минут 20 на ее рисовании :) | https://habr.com/ru/post/710984/ | null | ru | null |
# Магия макросов для объединения объявления и реализации
Одна из неприятных проблем — при внесении даже простых изменений приходится править код в нескольких местах. Например, если в класс добавляется поле данных, его нужно добавить в объявление класса, инициализировать в конструкторе(ах), а если переопределены операторы копирования или сравнения — то и в них тоже. Это отнимает время и приводит к ошибкам, если забыть про одно из мест (особенно неприятно забыть инициализировать, такие ошибки могут жить годами, и вызывать неожиданные, трудновоспроизводимые проблемы).
Обычно, если класс предполагает активную модификацию полей, то пишется макрос, который берёт реализацию действий с полем (инициализацию, копирование, сериализацию, reflection) на себя.
В результате переменная должна прописываться всего в двух местах — объявляться в классе и реализовываться (или регистрироваться для последующего использования в реализации).
Получается что-то вроде:
```
class TData
{
public:
int Number;
float Factor;
BEGIN_FIELDS
FIELD(Number, 0)
FIELD(Factor, 1.0f)
END_FIELDS
};
```
Реализацию макросов не привожу, это может быть, например, регистрация указателей на поля данных, их имён и начальных значений для последующего использования.
Ещё один пример, попроще. Нужно сделать отражение перечисления, например, сопоставить варианту перечисления строку его имени. Обычно это делается как-то так:
```
enum TModelType
{
Car,
Weapon,
Human
};
#define REFLECT_MODEL_TYPE(mac_value) Register(mac_value, #mac_value);
void TModelTypeReflection::RegisterTypes()
{
REFLECT_MODEL_TYPE(Car)
REFLECT_MODEL_TYPE(Weapon)
REFLECT_MODEL_TYPE(Human)
}
```
Объявление **TModelTypeReflection** и реализацию **Register** предоставлю воображению читателя.
Довольно долго я довольствовался таким положением дел. Но недавно подумал, что можно сделать и получше, обойдясь единственным объявлением. Сделать это можно с помощью всё тех же макросов.
Для последнего примера это будет выглядеть так:
```
#define DECLARE_MODEL_TYPE(mac_value, mac_next) \
mac_value, \
mac_next \
Register(mac_value, #mac_value);
#define END_MODEL_TYPE \
}; void TModelTypeReflection::RegisterTypes() {
enum TModelType
{
DECLARE_MODEL_TYPE(Car,
DECLARE_MODEL_TYPE(Weapon,
DECLARE_MODEL_TYPE(Human,
END_MODEL_TYPE)))
}
```
Макросы **DECLARE\_MODEL\_TYPE** развернутся сначала в элементы перечисления, затем код из **END\_MODEL\_TYPE** закроет блок перечисления и вставит заголовок функции, дальше в тело функции вставятся вызовы **Register** для элементов, только в обратном порядке, и наконец фигурная скобка закроет блок функции (поэтому она и без точки с запятой).
Похожий код можно написать и для полей класса.
Осталось только сказать о недостатках:
* регистрация в обратном порядке, но если порядок всё же важен, можно это учесть в реализации **Register**, например, добавлять очередное поле в начало списка, а не в конец;
* проблемы с системами автоматической генерацией документации вроде DOxygen, они не догадаются развернуть макросы;
* необходимость при добавлении поля добавлять ещё одну закрывающую скобку после **END\_MODEL\_TYPE**. Неприятный недостаток, т.к. править код приходится всё равно в двух местах. Немного радует, что забыть о скобке не позволит препроцессор.
Альтернативное решение, позволяющее объединить объявление с реализацией — использование кодогенератора, но и этот подход тоже имеет свои недостатки. | https://habr.com/ru/post/148494/ | null | ru | null |
# Как выдать Золушку за принца и не сойти с ума. Паттерн Декоратор
Всем привет, я [Максим Кравец](https://www.facebook.com/my.kravets) из Holyweb, и мы продолжаем разговор о паттернах (первую статью о Singleton можно [почитать вот тут](https://habr.com/ru/post/552600/)). Героя нашего сегодняшнего сюжета порой называют «wrapper» или «обертка», поскольку он оборачивает исходный код, но мне больше нравится название «декоратор» — оно точнее отражает не механику, а суть происходящего. Приступим.
А кто у нас муж? Волшебник? Предупреждать же надо!
--------------------------------------------------
Хорошо Золушке — у нее тетя не просто так крестная, а целая добрая фея. Взмах волшебной палочки — и тыква превращается в карету. Еще взмах — и рабочая одежда становится бальным платьем. Две минуты волшебства — и у любого принца шансы отвертеться устремляются к нулю.
Мы, конечно, не волшебники. Мы программисты. Но творить чудеса для нашего кода обязаны! Так что создаем класс «Золушка», наделяем ее ангельским характером и пытаемся выдать ее замуж, по возможности — удачно.
```
class Cinderella {
aboutMe() {
return `ангельский характер`;
};
}
```
Пришла пора посмотреть на потенциальных супругов:
1. **Принц Филипп**. Обожает скачки, охоту, экстремальный отдых.
2. **Принц Эдвард**. Страстный поклонник танцев и бальных нарядов.
3. **Принц Артур**. Любитель сладостей и выпечки.
Давайте представим нашу Золушку принцу **Филлипу**:
```
class Cinderella {
aboutMe() {
return `ангельский характер`;
};
}
const whatPrinceFilippKnows = new Cinderella()
console.log('У Золушки', whatPrinceFilippKnows.aboutMe())
```
Результат выполнения нашего кода:
```
У Золушки ангельский характер
```
Хм… маловато будет. Принц Филипп экстремал, с ним и встретиться-то можно только во время прыжка с тарзанки. На всякий случай добавим:
```
class Cinderella {
aboutMe() {
return `ангельский характер`;
};
}
class ExtremeCinderella extends Cinderella {
aboutMe() {
return `
любовь к экстремальному отдыху
5 комплектов альпинистского снаряжения под кроватью
ангельский характер
`
};
}
const whatPrinceFilippKnows = new ExtremeCinderella()
console.log('У Золушки', whatPrinceFilippKnows.aboutMe())
```
Пожалуй, такой результат нашего принца удовлетворит:
```
У Золушки
любовь к экстремальному отдыху
5 комплектов альпинистского снаряжения под кроватью
ангельский характер
```
А вот принцу **Эдварду** экстрим — до лампочки. Он обожает танцы. Сделаем и ему Золушку его мечты, заодно немного поправим вывод в консоль, чтобы понимать, какому принцу какое счастье достанется:
```
class Cinderella {
aboutMe() {
return `ангельский характер`
};
}
class ExtremeCinderella extends Cinderella {
aboutMe() {
return `
любовь к экстремальному отдыху
5 комплектов альпинистского снаряжения под кроватью
ангельский характер
`
};
}
class DanceCinderella extends Cinderella {
aboutMe() {
return `
свой магазин платьев и обуви "Все для бала"
ангельский характер
`
};
}
const whatPrinceFilippKnows = new ExtremeCinderella()
const whatPrinceEdvardKnows = new DanceCinderella()
console.log('Принц Филипп знает, что у Золушки', whatPrinceFilippKnows.aboutMe())
console.log('Принц Эдвард знает, что у Золушки', whatPrinceEdvardKnows.aboutMe())
```
Результат выглядит вроде бы неплохо:
```
Принц Филипп знает, что у Золушки
любовь к экстремальному отдыху
5 комплектов альпинистского снаряжения под кроватью
ангельский характер
Принц Эдвард знает, что у Золушки
свой магазин платьев и обуви «Все для бала»
ангельский характер
```
Хьюстон, у нас проблема! Даже две
---------------------------------
Первая — идеологическая. Вернемся ненадолго к опыту тети-феи, которая собирала свою крестницу на бал. Золушка — какой была изначально, такой и оставалась. В нее саму никаких изменений не вносилось! Изменялся только антураж, декорирование. Добавлялась одежда, карета, кучер, туфельки. Но Золушка оставалась Золушкой. Мы же — плодим новые классы с помощью наследования.
Вторая проблема — принцев на свете многовато. И запросы у них порой... самые причудливые. Устанешь для каждого создавать отдельный класс. Хочется как в сказке: Золушка отдельно, платье отдельно, тыква, пардон, карета — тем более отдельно. Сложить все в коробку да и выдать ее принцу, пусть сам собирает тот комплект, что его устроит! Золушка и туфельки, Золушка и образование, Золушка и месть гномов…
Впрочем, это уже про другое, нас же интересует, как реализовать задуманное. Для начала, давайте вынесем все «дополнительные опции» в отдельные функции. Вторым шагом (волшебники мы или погулять вышли?) прикажем этим функциям обернуть — задекорировать — свойства нашей исходной Золушки, чтобы при обращении к классу Cinderella возвращался не только ее ангельский характер, но и обертка.
Согласно Википедии, Декоратор — структурный шаблон проектирования, предназначенный для динамического подключения дополнительного поведения к объекту. Шаблон Декоратор предоставляет гибкую альтернативу практике создания подклассов с целью расширения функциональности.
На первый взгляд — вроде бы то, что доктор прописал! Осталось понять, как это реализовать. Наследование не подошло, может быть получится с агрегацией (в более строгой форме — композицией)?
Давайте еще раз внимательно взглянем на базовый класс Золушки и передадим в нашу функцию-обертку ссылку на базовый класс, а также реализуем точно такой же интерфейс. В итоге мы не будем наследовать поведение, мы добавим в обертке ее функционал, а базовую работу попросим выполнить переданную ссылку на класс.
```
class Cinderella {
aboutMe() {
return `ангельский характер`
};
}
function extremeSet(cinderella) {
this.aboutMe = function () {
return `
любовь к экстремальному отдыху
5 комплектов альпинистского снаряжения под кроватью
${cinderella.aboutMe()}
`
}
}
function danceShop(cinderella) {
this.aboutMe = function () {
return `
свой магазин платьев и обуви "Все для бала"
${cinderella.aboutMe()}
`
}
}
function pastryСhef(cinderella) {
this.aboutMe = function () {
return `
диплом кондитера высшей категории
${cinderella.aboutMe()}
`
}
}
const whatPrinceFilippKnows =new extremeSet(new Cinderella())
const whatPrinceEdvardKnows = new danceShop(new Cinderella())
const whatPrinceArturKnows = new pastryСhef(new Cinderella())
const whatPrinceAliKnows = new extremeSet(new danceShop(new pastryСhef(new Cinderella())))
console.log('Принц Филипп знает, что у Золушки', whatPrinceFilippKnows.aboutMe())
console.log('Принц Эдвард знает, что у Золушки', whatPrinceEdvardKnows.aboutMe())
console.log('Принц Артур знает, что у Золушки', whatPrinceArturKnows.aboutMe())
console.log('Принц Али знает, что у Золушки', whatPrinceAliKnows.aboutMe())
```
Пока мы пытались разобраться, что к чему, подъехал четвертый принц по имени **Али**, которому нравится все сразу. Но благодаря паттерну Декораторов мы просто собрали ему нужный набор:
```
Принц Филипп знает, что у Золушки
любовь к экстремальному отдыху
5 комплектов альпинистского снаряжения под кроватью
ангельский характер
Принц Эдвард знает, что у Золушки
свой магазин платьев и обуви "Все для бала"
ангельский характер
Принц Артур знает, что у Золушки
диплом кондитера высшей категории
ангельский характер
Принц Али знает, что у Золушки
любовь к экстремальному отдыху
5 комплектов альпинистского снаряжения под кроватью
свой магазин платьев и обуви "Все для бала"
диплом кондитера высшей категории
ангельский характер
```
Ах эта свадьба, свадьба пела и плясала
--------------------------------------
И это — работает! Смело отправляемся в школу волшебства за дипломом. Хотя… мало познакомить, свадьба-то тоже на наших плечах! Так что давайте не мешкая вооружимся все тем же паттерном Декоратор и посчитаем, во что нам это все обойдется.
```
class Cinderella {
aboutMe() {
return `ангельский характер`
};
}
function extremeSet(cinderella) {
this.aboutMe = function () {
return `
любовь к экстремальному отдыху
5 комплектов альпинистского снаряжения под кроватью
${cinderella.aboutMe()}
`
}
}
function danceShop(cinderella) {
this.aboutMe = function () {
return `
свой магазин платьев и обуви "Все для бала"
${cinderella.aboutMe()}
`
}
}
function pastryСhef(cinderella) {
this.aboutMe = function () {
return `
диплом кондитера высшей категории
${cinderella.aboutMe()}
`
}
}
// минимальная стоимость свадьбы, просто посидеть с гостями
class Wedding {
price() {
return 1000
}
}
// добавить свадебный торт
function weddingCake(wedding) {
this.price = function () {
return wedding.price() + 200
}
}
// пригласить оркестр
function jazzBand(wedding) {
this.price = function () {
return wedding.price() + 500
}
}
// приглашенная звезда из соседнего королевства
function superStar(wedding) {
this.price = function () {
return wedding.price() + 100500
}
}
const whatPrinceFilippKnows = new extremeSet(new Cinderella())
const whatPrinceEdvardKnows = new danceShop(new Cinderella())
const whatPrinceArturKnows = new pastryСhef(new Cinderella())
const whatPrinceAliKnows = new extremeSet(new danceShop(new pastryСhef(new Cinderella())))
const weddingPrice = new superStar(new Wedding())
console.log('Принц Филипп знает, что у Золушки', whatPrinceFilippKnows.aboutMe())
console.log('Принц Эдвард знает, что у Золушки', whatPrinceEdvardKnows.aboutMe())
console.log('Принц Артур знает, что у Золушки', whatPrinceArturKnows.aboutMe())
console.log('Принц Али знает, что у Золушки', whatPrinceAliKnows.aboutMe())
console.log('Бюджет свадьбы', weddingPrice.price())
```
Остается только собраться с родственниками принца и вдумчиво обсудить необходимость торта, звезды и гостей. Благо для пересчета надо просто собрать новый набор оберток.
```
Принц Филипп знает, что у Золушки
любовь к экстремальному отдыху
5 комплектов альпинистского снаряжения под кроватью
ангельский характер
Принц Эдвард знает, что у Золушки
свой магазин платьев и обуви "Все для бала"
ангельский характер
Принц Артур знает, что у Золушки
диплом кондитера высшей категории
ангельский характер
Принц Али знает, что у Золушки
любовь к экстремальному отдыху
5 комплектов альпинистского снаряжения под кроватью
свой магазин платьев и обуви "Все для бала"
диплом кондитера высшей категории
ангельский характер
Бюджет свадьбы 101500
```
...и жили они долго…
--------------------
Сказочные истории принято завершать фразой про долго и счастливо. Свою задачу — организовать процесс презентации нашей Золушки потенциальному принцу — мы выполнили. Не отвертится. И даже возможные расходы посчитали! Насколько удалось при этом донести смысл и механику работы паттерна Декоратор, решать вам.
Если есть интерес, пишите в комментариях — или ответим сразу, или развернем тему еще в одной статье. А если хотите познакомиться с нашей командой ближе, я всегда на связи в Телеграме @maximkravec. | https://habr.com/ru/post/554930/ | null | ru | null |
# Haskell, как что-то очень близкое, или получаем комиты из github api
> Too late — 'cause I got it now
>
> there are monads all around
>
> IO, State and lists abound
>
> It's easy, like those people say
>
> but my program got abstracted all away!
>
> Maybe — o o o,
>
> It's a monad too, I know
>
> Why should I use another language at all?
>
>
Снова безумный адепт Haskell, и еще одна попытка доказать его практичность. Нестареющая классика.
Я постараюсь рассказать шикарную историю ~~(не ведитесь на пафосную рекламу)~~, в которой будут все необходимые компоненты блокбастера ~~(я серьезно, не ведитесь)~~ — знакомые герои, хорошо продуманная вселенная и открытая концовка ~~(ну что ж...)~~.
Немного серьезности никогда не помешает. Поэтому сначала, без малейшего намека на юмор, расскажу логику написания этого текста. Мне хотелось (прежде всего, для себя, но надеюсь, кому-нибудь тоже будет интересно) реализовать на Haskell некую до боли близкую, неимоверно практичную задачу. Положительный результат решения этой задачи дал бы лишний повод гордиться собой, скилы и еще один довод в пользу выбора этого языка программирования. В качестве подопытной задачи я выбрал получение и обработку информации о коммитах в репозиторий на github. Собственно, она будет содержать в себе работу с github api — загрузка и парсинг json.
Полагаю, что решать ее стоит по шагам, поэтому начнем с исходной позиции, а именно пустой директории в файловой системе.
Создание модуля
---------------
Для начала, создадим новый модуль для наших целей
```
cabal init
```
Пытливый **cabal** задаст несколько вопросов, а в результате вы получите заготовку модуля с конфигурационным файлом **project\_name.cabal**. Для большей эстетики добавим в модуль директорию **src**, и укажем ее в конфигурации
```
executable project-name
hs-source-dirs: src
main-is: Main.hs
```
Конечно, **Main.hs** необходимо создать)
Дальше пару слов о [dependency hell](http://www.yesodweb.com/blog/2011/09/limitations-of-haskell). Это больная тема Haskell, в которой намечается прогресс. Вариантов решения проблемы зависимостей несколько, но мы молоды и любим все модное, поэтому будем использовать свежую фичу cabal-1.18 — sandoxes.
Собственно, для использования необходимо инициализировать песочницу и установить зависимости
```
cabal sandbox init
cabal install --only-dependencies
```
В дальнейшем для сборки модуля можно, как обычно, воспользоваться командой
```
cabal build
```
Если возникло острое желание что-нибудь поотлаживать, да и вообще, посмотреть, как оно работает изнутри (а, по законам жанра, такое желание обязательно возникнет), можно запустить **ghci** в созданной песочнице командой
```
cabal repl
```
Все, боязнь пустого каталога преодолена, двигаемся дальше.
http-conduit
------------
Первая задача, которую необходимо решить — это загрузка информации о комитах в json формате. Собственно, источник [очевиден](https://api.github.com/repos/erthalion/github-parser/commits), но на этом простые вещи заканчиваются. Итак, на этом этапе будем использовать пакет [http-conduit](http://hackage.haskell.org/package/http-conduit) за авторством солнцеликого ~~Edward Snow~~ Michael Snoyman. В целом, conduit — это замечательное решение для работы с потоками данных. У меня врядли получится хорошо об этом рассказать, поэтому добро пожаловать в блог человека по фамилии [eax](http://eax.me/haskell-conduits/). Я расскажу совсем чуть-чуть и по периферии.
Для начала, надо добавить нужные зависимости в раздел build-depends конфигурационного файла
```
bytestring >= 0.10,
conduit >= 1.0,
http-conduit >= 1.9,
```
и обновить песочницу описанной выше командой.
Вот теперь можем трепетно приступить к коду. Для начала, чтобы упростить себе жизнь и работу со строками, добавим [extension](https://www.fpcomplete.com/school/to-infinity-and-beyond/pick-of-the-week/guide-to-ghc-extensions/basic-syntax-extensions#overloadedstrings)
```
{-# LANGUAGE OverloadedStrings #-}
```
Подключаем нужные модули
```
import Data.Conduit
import Network.HTTP.Conduit
import qualified Data.Conduit.Binary as CB
import qualified Data.ByteString.Char8 as BS
```
Весь код загрузки json будет выглядеть примерно так
```
main = do
manager <- newManager def
req <- parseUrl "https://api.github.com/../.."
let headers = requestHeaders req
req' = req {
requestHeaders = ("User-agent", "some-app") :
headers
}
runResourceT $ do
res <- http req' manager
responseBody res $$+- CB.lines =$ parserSink
```
Насколько я помню, api github требует наличия заголовка **User-agent**, поэтому пришлось немного расширить request. Основное действо происходит в последних двух строках, где мы получает ответ с json. Т.к. результат завернут в трансформер **ResourceT**, то функции для его получения должны быть вызваны с использованием runResourceT. После получения тела ответа мы отправляем его в сток, который предназначен для разбора json и выглядит он так
```
parserSink :: Sink BS.ByteString (ResourceT IO) ()
parserSink = do
md <- await
case md of
Nothing -> return ()
Just d -> parseCommits d
```
Сток в случае успеха будет просто разбирать полученный json и выводить его на экран (эта часть магии скрыта в функции parseCommits).
Aeson
-----
Продолжаем коверкать мышление программистов и переходим к парсингу. Для него будем использовать чрезвычайно могучий пакет под названием [Aeson](http://hackage.haskell.org/package/aeson-0.6.1.0/docs/Data-Aeson.html). На самом деле, здесь все достаточно просто, но есть несколько моментов, которые с непривычки вводят в ступор:
* Т.к. Haskell строго типизирован, то нам потребуются типы, которые будут описывать заложенную в json структуру данных
* Если я ничего не перепутал, то Aeson использует lazy bytestring, в то время как в стоке оказывается strict bytestring, поэтому придется продемонстрировать навыки жонглирования типами
Итак, сначала определим типы. Можно не заморачиваться, и определить их лишь частично, отправив часть информации из json в топку. Себе оставим только url, хэш и commit message.
```
import qualified Data.ByteString.Char8 as BS
import Data.Aeson (FromJSON(..))
data CommitInfo = CommitInfo {
message :: BS.ByteString
} deriving (Show)
data Commit = Commit {
sha :: BS.ByteString,
url :: BS.ByteString,
commit :: CommitInfo
} deriving (Show)
```
Дальне нам было бы канонично использовать аппликативные функторы для сопоставления json и полей из структур данных, но мы всех обманем и воспользуемся Generic'ом.
```
{-# LANGUAGE DeriveGeneric #-}
import GHC.Generics (Generic)
```
и добавим к имеющимся структурам данных наследование от Generic
```
deriving(Show, Generic)
```
Останется только заявить о возможности создания Commit & CommitInfo из json
```
instance FromJSON Commit
instance FromJSON CommitInfo
```
Осталось всего несколько шагов до финиша, мы почти у цели
```
parseCommits :: BS.ByteString -> Sink BS.ByteString (ResourceT IO) ()
parseCommits rawData = do
let parsedData = decode $ BL.fromChunks [rawData] :: Maybe [Models.Commit]
case parsedData of
Nothing -> liftIO $ BS.putStrLn "Parse error"
Just commits -> liftIO $ printCommits commits
```
Как видите, приходится создавать lazy bytestring для отдачи на декодирование. Если парсинг прошел успешно, с помощью **liftIO** поднимаем полученные значения и выводим в консоль.
Finish
------
Все, красная дорожка, фанфары и торжественное завершение вечера. Полный пример расположен [здесь](https://github.com/erthalion/github-parser). Код не является примером торжества идеалов computer science, поэтому замечания от гуру приветствуются. Надеюсь, все остальные чему-нибудь научились, или хотя бы получили удовольствие и стали ближе к миру Haskell. Да пребудет с вами сила! | https://habr.com/ru/post/205830/ | null | ru | null |
# Микроконтроллеры Megawin серии MG32F02 на базе ядра Cortex-M0
### Вступление
Компания Megawin Technology Co., Ltd. была основана в Тайване в 1999 году. Первые разработки компании были в области создания встроенной flash-памяти и контроллеров ввода-вывода. С 2004 г. было запущено массовое производство 8-битных микроконтроллеров (МК). На российском рынке компания известна прежде всего своими МК серий MG82 и MG84 на ядре 80C51.
Однако сегодня наш интерес привлекли 32-разрядные микроконтроллеры Megawin Technology серии MG32F02 на базе ядра Cortex-M0, которые компания с 2019 г. массово производит и поставляет в Россию. Отличное соотношение цены и качества, богатый набор встроенных периферийных модулей делают эти микроконтроллеры серьезным конкурентом в своем классе аналогичным чипам таких мировых брендов как Microchip, STM32, NXP и пр. Особенно актуальными микроконтроллеры становятся сегодня в условиях беспрецедентных экономических санкций и фактического прекращения поставок большинства западных электронных компонентов.
Этой статьей на хабре мы открываем цикл публикаций, в котором постараемся всесторонне рассмотреть все возможности микроконтроллеров Megawin серии MG32F02. Глубоких знаний по архитектуре ARM или большого опыта разработки на Cortex-M от читателя не потребуется. В то же время предлагаемый материал будет интересен разработчикам устройств на 8-разрядных ядрах 80C51 или AVR, планирующим переход на 32-разрядные системы, где любой МК на ядре Cortex-M0 — первый кандидат на замещение 8-разрядных МК.
В первой статье цикла мы сделаем функциональный обзор микроконтроллеров серии MG32F02, рассмотрим общую структуру МК, центральный процессорный модуль, адресное пространство, подсистемы питания, сброса, тактирования и прерываний. В последующих публикациях будут рассмотрены:
* разработка на основе gcc на Linux или Windows;
* инструменты разработки и прошивки от производителя (программатор-отладчик MLink и среда Keil µVision IDE);
* алгоритм программирования flash-памяти;
* отладка кода в ОЗУ без записи и стирания flash-памяти;
* периферийные устройства: GPIO, АЦП, ЦАП, компараторы, таймеры;
* интерфейсы UART, I2C, SPI;
* применение DMA;
* аппаратная логика модуля General Purpose Logic для расчета CRC8/16/32, манипуляции битами;
* конфигурируемая логика модуля Configurable Custom Logic
и многое другое.
### Документация
На момент написания данной статьи какой-либо русскоязычной документации или обсуждений МК серии MG32F02 в рунете обнаружено не было. То же самое можно сказать и про информацию на английском. Основным и практически единственным источником информации остается [официальная документация](http://www.megawin.com.tw/en-global/product/index/Cortex_M0) от Megawin Technology, доступная на китайском и английском языках. Для освоения микроконтроллеров потребуются следующие PDF-документы:
* Datasheet *на конкретный тип МК* — общее описание возможностей МК и цоколевка (можно скачать из раздела Documents для конкретного типа МК),
* User\_Guide – полное описание всех МК семейства, версия на момент публикации статьи — 4.1.1 (доступен по [этой ссылке](http://www.megawin.com.tw/en-global/support/downloadDocument/218/696)),
* Registers *на конкретный тип МК* — полный справочник по регистрам периферии (входит в общий архив User\_Guide).
В связи с отсутствием русскоязычной литературы, в цикле публикаций будет приводиться необходимая техническая информация, основанная на User Guide и даташитах, а также на описаниях регистров.
### Состав серии MG32F02
Серия MG32F02 включает линейку МК общего назначения MG32F02Axxx и линейку МК с USB-интерфейсом MG32F02Uxxx. Размер flash-памяти в зависимости от типа МК варьируется в пределах от 32 до 128 кбайт, размер ОЗУ — от 4 до 16 кбайт. Минимальное число выводов составляет 20 (корпус TSSOP20), максимальное — 80 (корпус LQFP80).
Максимальная тактовая частота всех МК серии MG32F02 составляет 48 МГц, что является практически типовым значением для большинства реализаций ядер Cortex-M0 и Cortex-M0+. Нельзя сказать что это много, но в то же время МК на ядре Cortex-M0(+) призваны прежде всего заменить 8-ми и 16-ти разрядные микроконтроллеры в новых разработках, и, конечно, не могут конкурировать, например, с топовыми кортексами M4-M7 линейки High Performance STM32. Однако МК от Megawin, например, могут стать достойной заменой контроллерам серий SAMD09/10/11/20/21 от Microchip, LPC800 от NXP.
МК серии MG32F02 имеют расширенный индустриальный диапазон температур эксплуатации от -40 до +105 °C. Особенностью микросхем является также широкий диапазон напряжений питания от 1,8 до 5,5 В, что сегодня встречается редко у 32-разрядных контроллеров.
На данный момент серия включает следующие типы микроконтроллеров:
* MG32F02A032 — младшая модель с минимальными возможностями и числом выводов,
* MG32F02A064 и MG32F02A128 — МК с максимальными функциональными возможностями,
* MG32F02U064 и MG32F02U128 — аналогичные линейке MG32F02Axxx микроконтроллеры с интерфейсом USB, имеют дополнительное ОЗУ объемом 512 байт для буферов USB.
Следует также упомянуть МК MG32F02A072, MG32F02A132 и MG32F02V032, которые сняты с производства, однако описываются в общем руководстве User Guide. Данные типы МК в статье рассматриваться не будут. Основные параметры и функциональные возможности серии MG32F02 приведены в таблице.
| Параметр или функциональный блок | MG32F02A032 | MG32F02A064/U064 | MG32F02A128/U128 |
| --- | --- | --- | --- |
| Объем Flash | 32 кбайт | 64 кбайт | 128 кбайт |
| Объем ОЗУ | 4 кбайт | 8/16 кбайт | 16/16 кбайт |
| Корпус | TSSOP20, QFN32, LQFP48 | LQFP64/48 | LQFP80/64 |
| Число контактов ввода-вывода | 17, 29, 44 | 59/44 | 73/59 |
| Максимальное число линий внешнего прерывания | 17, 29, 44 | 59/44 | 73/59 |
| Детектор снижения напряжения | LVR+BOD0/1 | LVR+BOD0/1/2 | LVR+BOD0/1/2 |
| Таймеры 16 бит | 2 (TM00,TM01) | 2 (TM00,TM01) | 2 (TM00,TM01) |
| Таймеры 32 бита | 3 (TM10,TM16, TM36) | 5 (TM10,TM16,TM20,TM26,TM36) | 5 (TM10,TM16,TM20,TM26,TM36) |
| Число каналов захвата/сравнения/ШИМ | 4 16-разрядных или 8 8-разрядных | 8 16-разрядных или 16 8-разрядных | 8 16-разрядных или 16 8-разрядных |
| Число комплементарных ШИМ-каналов | 3 | 7 | 7 |
| Счетчик повторений | - | 8 бит | 8 бит |
| АЦП | 12 бит, 12 каналов, 800 кс/с | 12 бит, 16 каналов, до 1,5 Мс/с | 12 бит, 16 каналов, до 1,5 Мс/с |
| ЦАП | - | 12 бит, 1 канал, 1 Мс/с | 12 бит, 1 канал, 1 Мс/с |
| Модуль UART | 2 расширенных (URT0,URT1) | 3 расширенных (URT0-URT2), 4 базовых (URT4-URT7) | 3 расширенных (URT0-URT2), 4 базовых (URT4-URT7) |
| Модуль SPI (master/slave) | 1 | 1 | 1 |
| Модуль I2C | 1 | 2 | 2 |
| Контроллер внешней памяти EMB | - | шина 16/8 бит | шина 16/8 бит |
| Число каналов DMA | 1 | 5 | 5 |
| 32-битный аппаратный делитель | нет | есть | есть |
| Модуль конфигурируемой логики CCL | - | 2 | 2 |
| Детектор последовательностей SDT | - | 1 | 1 |
Все микроконтроллеры также включают следующие модули:
* независимый сторожевой таймер IWDT;
* оконный сторожевой таймер WWDT;
* 32-разрядные часы реального времени RTC;
* два независимых скоростных аналоговых компаратора со встроенным 6-разрядным ЦАП для задания пороговых значений;
* модуль вычисления CRC типа CRC8/CRC16/CCITT16/CRC32 с фиксированным полиномом;
* два модуля прерывания и модуляции сигналов OBM.
Также стоит отметить, что таймеры TM26 и TM36 включают интерфейс квадратурного энкодера.
### Структурная схема микроконтроллера
На следующем рисунке представлена структурная схема микроконтроллеров MG32F02A128/U128/A064/U064.
Структурная схема МК MG32F02A128/U128/A064/U064Центральный процессорный модуль включает:
* центральное процессорное устройство (ЦПУ) Cortex-M0 `CPU` с поддержкой умножения целых чисел,
* контроллер вложенных (приоритетных) векторных прерываний `NVIC` (Nested Vectored Interrupt Controller) с поддержкой 32-х внешних прерываний с четырьмя уровнями приоритета,
* 24-разрядный системный таймер (System Tick Timer),
* блок отладки и программирования DAP SWD (Debug Access Port for Serial Wire Debug) с двумя точками наблюдения и четырьмя точками остановки,
* мультиплексор-коммутатор BusMatrix высокопроизводительной шины `AHB` (Advanced High-Performance Bus).
К шине AHB подключены следующие узлы:
* контроллер внешней памяти `EMB` (External Memory Bus), позволяющий подключать к МК микросхемы статической оперативной или постоянной памяти типа NOR/NAND flash, а также ЖКИ с интерфейсом 8080;
* контроллер встроенной памяти Memory Control, взаимодействующий со статической оперативной памятью SRAM, flash-памятью, включая отдельную область системной конфигурации Hardware Option (префикс названий регистров контроллера — `MEM`);
* блок логики для специальных побитовых манипуляций и вычисления CRC `GPL` (General Purpose Logic);
* подсистема управления питанием Power Control (префикс названий регистров модуля — `PW`);
* подсистема управления сбросом МК Reset Control (префикс названий регистров модуля — `RST`);
* подсистема тактирования Clock Control (префикс названий регистров — `CSC` (Clock Source Controller));
* контроллер прямого доступа к памяти `DMA` (Direct Memory Access);
* модуль `GPIO` (General Purpose IO), позволяющий программно управлять произвольными выводами портов Port A - Port E;
* блок выбора альтернативных функций выводов микроконтроллера `AFS` (Alternate Function Select), связанный с GPIO;
* мост AHB/APB Bridge для связи шины AHB c шиной периферийных устройств `APB` (Advanced Peripheral Bus).
К шине APB подключены следующие узлы:
* контроллер внешних прерываний `EXIC` (External Interrupt Controller), позволяющий использовать произвольные выводы МК для сигналов внешний прерываний;
* независимый сторожевой таймер `IWDT` (Independent WatchDog Timer);
* оконный сторожевой таймер `WWDT` (Window WatchDog Timer);
* 32-разрядные часы реального времени `RTC` (Real Time Clock);
* таймеры TM0x-TM3x;
* последовательные интерфейсы: асинхронные `URTx`, трехпроводные `SPIx` и двухпроводные `I2Cx` (`x` — номер интерфейса);
* интерфейс `USB` (для линейки MG32F02Uxxx);
* аналого-цифровой преобразователь `ADC` с температурным сенсором;
* аналоговые компараторы COMPx (префикс названий регистров — `CMP`);
* цифро-аналоговый преобразователь `DAC`;
* дополнительные функциональные модули (на схеме обозначены как `APX`): модули конфигурируемой логики `CCL` (Configurable Custom Logic), двухвходовый модуль выделения последовательностей `SDT` (Sequential State Detector), интерфейс управления адресуемыми RGB-светодиодами `ASB` (ARGB Serial Bus).
В микроконтроллерах также имеются следующие узлы:
* генератор с внешним резонатором `OSC`;
* LDO-регулятор напряжения для питания внутренней логики МК на 1,5 В (1,8 В для MG32F02A032);
* детекторы снижения напряжения питания `BOD0`, `BOD1` и `BOD2`.
Микроконтроллер MG32F02A032 отличается отсутствием следующих блоков:
* контроллер подключения внешней памяти (External Memory Bus, EMB),
* порт E (Port E),
* цифро-аналоговый преобразователь (DAC),
* устройства шины APX,
* таймеры T2x, T3x,
* температурный сенсор в модуле АЦП,
* дополнительные функциональные модули `APX`.
### Центральный процессорный модуль
На следующем рисунке представлена структура центрального процессорного модуля микроконтроллеров серии MG32F02.
Центральный процессорный модульЯдро Cortex-M0 представляет собой архитектуру ARMv6-M, включающую только набор инструкций Thumb. Коды всех инструкций Thumb имеют длину 16 бит, при этом позволяют оперировать 32-битными данными и использовать все доступные 32-разрядные регистры ядра ARM. В принципе, размер инструкций сокращен с 32 до 16 бит за счёт:
* исключения возможности непосредственного использования старшей половины регистров R8-R15 в большинстве арифметических и логических операций (номер регистра кодируется в этих инструкциях тремя битами), но они остаются доступны в операциях пересылки,
* исключения машинных инструкций с тремя регистрами.
Отметим, что ядро Cortex-M0 не включает блок защиты памяти MPU (Memory Protection Unit).
Ядро имеет аппаратную поддержку умножения целых 32-разрядных чисел за один машинный цикл (инструкция `MUL`). Аппаратная возможность деления целых 32-разрядных чисел предоставляется в МК через отдельный периферийный блок Divider в модуле GPL (кроме MG32F02A032). Операции с вещественными числами аппаратно не поддерживаются.
Более подробно о ядре Cortex-M0 можно почерпнуть информацию из книги Джозефа Ю
"The Definitive Guide to ARM ® Cortex ® -M0 and Cortex-M0+ Processors. Second Edition", а также из официальной документации ARM:
* [ARMv6-M Architecture Reference Manual](https://developer.arm.com/documentation/ddi0419/c/)
* [Cortex-M0 Devices Generic User Guide](https://developer.arm.com/documentation/dui0497/a/)
"Пробуждение" ядра по какому-либо прерыванию и выход из спящего режима осуществляется контроллером пробуждения WIC (Wake-up Interrupt Controller), который всегда находится *во включенном состоянии*.
*Режим отладки* МК через интерфейс SWD реализован через блок отладки DAP согласно спецификации ARM Cortex-M0. Таким образом, для отладки данных МК может применяться любой SWD-совместимый программатор или отладчик и стандартное ПО.
Более подробно функционирование процессорного модуля будет рассматриваться по ходу изложения материала.
### Организация адресного пространства
На следующем рисунке представлена организация адресного пространства микроконтроллеров серии MG32F02.
Адресное пространство МКПервые 132 кбайт адресного пространства (адреса 0x00000000-0x00020FFF) жестко не привязаны к какой-либо физической памяти. В зависимости от значения поля `BOOT_MS` конфигурационных ячеек OB0 (см. ниже) эта область отображается во flash-память или в SRAM. В любом случае первые 192 байта этой области должны содержать таблицу векторов прерываний (48 слов по 4 байта), начальный адрес которой не может быть изменен в архитектуре Cortex-M0.
Физическая flash-память адресуется в пределах первых 512 Мбайт адресного пространства (адреса 0x180000000-0x1FFFFFFF). Вся flash-память логически разделена на следующие секции:
* основной машинный код программы МК AP (Application Program) (начальный адрес 0x18000000),
* область хранения постоянных данных основной программы IAP (In-Application-Programming data) (начальный адрес 0x1A000000),
* машинный код программного загрузчика ISP (In-System-Program), другими словами, область бутлоадера (начальный адрес 0x1C000000),
* область хранения постоянных данных загрузчика ISPD (In-System-Programming data) (начальный адрес 0x1FF00000),
* системные конфигурационные ячейки OB0-0B2 (hardware Option Byte) — области памяти по 32 байта.
Области AP, IAP и ISP разделяют *основное пространство* flash-памяти. В это пространство не входят области ISPD и OBx. Настройка областей выполняется путем изменения системных конфигурационных ячеек OB0. Размер секции IAP задается в поле `IAP_SIZE`, размер секции ISP — в поле `ISP_SIZE` ячеек OB0 в единицах по 1024 байт для MG32F02A032 и в единицах по 512 байт для остальных МК.
По-умолчанию, область IAP не выделяется, а для ISP выделяется 2 кбайт. Соответственно доступная область AP уменьшается на это значение. Размер страницы flash-памяти составляет 1 кбайт для MG32F02A032 и 512 байт для остальных МК. Ячейки памяти OBx могут быть изменены только с помощью внешнего программатора.
Для встроенной оперативной памяти SRAM отводится 512 Мбайт адресного пространства, начиная с адреса 0x20000000. Для внешней оперативной памяти (RAM) отводится пространство размером 1 Гбайт, начиная с адреса 0x60000000.
Все регистры периферийных модулей шин AHB и APB расположены в области размером 512 Мбайт начиная с адреса 0x40000000. Конкретные базовые адреса модулей и смещения для регистров можно найти в официальном документе Registers по конкретному типу МК.
Область памяти размером 1 Гбайт начиная с адреса 0xA0000000 зарезервирована для внешних периферийных устройств.
Самая верхняя область, начиная с адреса 0xE0000000, предназначена для системных регистров ядра Cortex-M0, имеющих в названии префикс `CPU`.
Все области памяти, за исключением тех, которые помечены `XN`, могут использоваться для исполнения машинного кода. Таким образом, *можно запускать программы из ОЗУ* (встроенного или внешнего), что удобно для отладки небольших фрагментов кода, поскольку загрузка данных в ОЗУ выполняется через интерфейс SWD значительно быстрее, чем программирование flash-памяти, и при этом не расходуется её ресурс.
За большинство функций управления памятью отвечает контроллер памяти Internal Memory Controller (префикс названий регистров — `MEM`). Например, настройками его регистров определяется возможность исполнения кода или возможность записи в той или иной области flash-памяти. Для стирания или записи flash-памяти используется определенная последовательность действий по модификации управляющих регистров группы `MEM`.
### Питание МК
Все микроконтроллеры требуют один источник питания напряжением от 1,8 В до 5,5 В. Для питания внутренней логики на кристалле имеется встроенный LDO-регулятор напряжения на 1,8 В для MG32F02A032 и 1,5 В — для остальных МК. Для нормальной работы LDO-регулятора требуется подключение к его выходу (вывод `VR0` МК) параллельно двух внешних конденсаторов: электролитического и керамического емкостью 4,7 мкФ и 0,1 мкФ соответственно. В версиях МК с USB имеется еще один LDO-регулятор с выходным напряжением 3,3 В, к которому также требуется подключение конденсатора 4,7 мкФ (вывод `V33`).
Все МК имеют три основных режима работы:
* основной режим работы ON,
* спящий режим SLEEP,
* режим остановки STOP.
Поддерживается режим "пробуждения" от следующих источников: выводы GPIO, сторожевой таймер IWDT, часы RTC, аналоговый компаратор, модуль I2C, модули BODx, а также от модуля USB.
Для перевода МК в режимы SLEEP или STOP используются машинные инструкции `WFE` (ожидать прерывания или события) или `WFI` (ожидать прерывания). В зависимости от значения поля `SLEEPDEEP` регистра `CPU_SCR` МК переходит в тот или иной режим энергосбережения согласно таблице.
| Режим МК | Режим ЦПУ | Значение`SLEEPDEEP` | Описание |
| --- | --- | --- | --- |
| ON | run | x | Нормальный режим работы |
| SLEEP | sleep | 0 | ЦПУ в спящем режиме, остальные модули работают согласно настройкам |
| STOP | deep sleep | 1 | все модули отключены, за исключением IWDT, RTC, и CMP |
Условия "пробуждения" зависят от машинной инструкции и приведены в таблице. В любом случае должны быть разрешены прерывания.
| Инструкция | Условие пробуждения |
| --- | --- |
| WFE | Внешнее прерывание, прерывание отладки, сброс ЦПУ в спящем режиме, произошло событие до обработки инструкции WFE. |
| WFI | Внешнее прерывание, прерывание отладки, сброс ЦПУ в спящем режиме. |
Возможность работы какого-либо встроенного периферийного модуля в режиме SLEEP определяется разрешением его тактирования в этом режиме (см. ниже).
На следующем рисунке представлена функциональная схема контроллера питания.
Контроллер питания (Power Controller)Контроль напряжения питания внутренней логики VDDC (на выходе основного LDO) выполняют блоки POR (Power-On Reset) и LVR (Low-Voltage Reset), управляя сбросом МК при включении питания и снижении напряжения питания соответственно.
В МК присутствуют также детекторы снижения напряжения BOD0, BOD1 и BOD2 (Brown-Out Detector) (последнего нет в MG32F02A032), активизируемые независимо друг от друга установкой полей `PW_BODx_EN` в регистре `PW_CR0`. Блок BOD0 предназначен для контроля напряжения питания flash-памяти и имеет фиксированный порог 1,7 В для MG32F02A032 и 1,4 В для остальных МК. Блок BOD1 предназначен для общего контроля напряжения и имеет настраиваемый порог из ряда 2,0; 2,4; 3,7 и 4,2 В. Блок BOD2 аналогичен предыдущему блоку, но имеет фиксированный порог 1,7 В. Блоки BOD1 и BOD2 могут быть настроены на генерацию события по спаду, по нарастанию или по обоим фронтам. Каждый из блоков устанавливает соответствующие статусы событий в полях `PW_PORF`, `PW_BODxF` и `PW_BODxS` в регистре статуса `PW_STA`. Каждый из блоков может быть настроен в качестве источника сброса (см. далее).
Возможность пробуждения МК из режима STOP при наступлении событий в периферийных модулях определяется соответствующими битами регистров `PW_WKSTP0` и `PW_WKSTP1`.
Контроллер питания может вырабатывать сигнал прерывания INT\_PW в случае срабатывания одного из блоков BOD0-BOD2, а также в случае появления события пробуждения от контроллера WIC. Разрешение прерывания по каждому из событий задается соответствующими битами регистра `PW_INT`.
### Подсистема сброса
В МК за сброс отвечает отдельный модуль Reset Source Controller, работающий совместно с контроллером питания и подсистемой тактирования.
Различают *сброс отдельных периферийных модулей* или же *сброс МК* в целом.
На следующем рисунке показана функциональная схема подсистемы сброса МК MG32F02A128/U128/A064/U064.
Схема модуля сбросаИмеются следующие ситуации сброса МК:
* сброс при включении питания POR (Power-On Reset), имеет максимальный приоритет;
* "холодный" сброс (Cold Reset), имеет средний приоритет;
* "горячий" сброс (Warm Reset), имеет низший приоритет.
POR-сброс приводит к генерации "холодного" сброса, который, в свою очередь, вызывает "горячий" сброс. Таким образом, "горячий" сброс выполняется в любом случае.
POR-сброс возникает при включении МК после достижения необходимого уровня напряжения питания.
"Холодный" сброс происходит при возникновении событий в модулях BODx, сторожевых таймерах IWDR, WWDT, и другой периферии, если имеются соответствующие настройки. "Холодный" сброс вызывает считывание конфигурационных ячеек OBx и загрузку их значений в регистры аппаратной конфигурации `CFG_ORx` (Option Register), а также блокирует запись в регистры настройки периферии, которые требуют для своей модификации специальной разблокировки.
"Горячий" сброс вызывает сброс всех периферийных модулей, сброс всех флагов в регистрах их состояний, а также возвращает все их настройки в значения по-умолчанию.
Возможность "холодного" или "горячего" сброса от каждого из периферийных модулей определяется значениями соответствующих полей регистров `RST_CE` и `RST_WE`. Причину сброса при старте программы МК можно узнать через регистр статуса `RST_STA`. Тип сброса ("холодный" или "горячий") можно узнать через поля `RST_CRF` и `RST_WRF`.
Программно можно инициировать "горячий" сброс отдельного периферийного модуля путем установки соответствующего бита `RST_XXX_EN` в регистрах `RST_AHB`, `RST_APB0` или `RST_APB1` в зависимости от шины, на которой расположен модуль.
### Подсистема тактирования
На следующем рисунке показана общая схема тактирования МК MG32F02A128/U128/A064/U064.
Схема тактированияВ МК для тактирования могут быть использованы следующие источники:
* встроенный низкочастотный RC-генератор ILRCO (Internal Low-frequency RC Oscillator),
* встроенный высокочастотный RC-генератор IHRCO (Internal High-frequency RC Oscillator),
* встроенный кварцевый генератор XOSC,
* вход для внешнего генератора EXTCK (External Input Clock).
Встроенный генератор ILRCO вырабатывает импульсы CK\_ILRCO с частотой 32 кГц и может быть использован, например, для тактирования часов реального времени RTC, таймеров IWDT, WWDT, GPIO или интерфейса I2C. Заявленная в Datasheet точность генератора составляет 4 % при температуре +25 °C.
Встроенный генератор IHRCO в зависимости от значения поля `CSC_IHRCO_SEL` регистра `CSC_CR0` может генерировать импульсы CK\_IHRCO частотой 12,0000 МГц или 11,0592 МГц. Выбор частоты 11,0592 МГц удобен при использовании модуля UART, когда нужно получить точные стандартные значения скорости обмена данными 115200 бод или ниже (коэффициент деления 96). При включении питания по-умолчанию тактирование МК осуществляется от данного генератора с частотой 12,0000 МГц. Заявленная точность генератора составляет 1 % при температуре +25 °C, а ток потребления — 350 мкА.
Встроенный кварцевый генератор XOSC может работать на низкой частоте 32 кГц (удобно для подключения часового кварцевого резонатора номиналом 32768 Гц), либо на высокой частоте от 4 до 25 МГц. Резонатор подключается к выводам `XIN` (PC13) и `XOUT` (PC14) порта C, отдельных выводов для резонатора в МК не предусмотрено. Кварцевый генератор формирует сигнал CK\_XOSC.
Внешний тактовый вход EXTCK допускает подключение генератора частотой до 36 МГц (используется вывод `XIN`), который формирует сигнал CK\_EXT.
Любой из указанных четырех источников с помощью мультиплексора может быть использован для получения сигнала CK\_HS (High Speed clock), который используется для последующего формирования сигналов тактирования различных узлов. Активный вход мультиплексора определяется значением поля `CSC_HS_SEL` регистра управления тактированием `CSC_CR0`. При "горячем" сбросе МК это значение может соответствовать либо CK\_IHRCO, либо CK\_ILRCO и считывается из поля `CFG_HS_SEL` регистра `CFG_OR05`, в который оно загружается из ячеек аппаратной конфигурации OB0.
Сигнал CK\_HS подается далее на вход блока умножения частоты на основе ФАПЧ PLL (Phase-Locked Loop). В МК MG32F02A032 сигнал подается напрямую, в остальных МК — через дополнительный мультиплексор (сигнал CK\_PLLIX).
Параллельно с CK\_HS формируется также сигнал CK\_HS2 (кроме MG32F02A032) из одного из высокочастотных источников, задаваемых полем `CSC_HS2_SEL` регистра `CSC_CR0`. Сигнал может использоваться для модуля USB.
На следующем рисунке показана функциональная схема блока PLL МК MG32F02A128/U128/A064/U064.
Функциональная схема блока PLLБлок PLL включается путем установки бита `CSC_PLL_EN` регистра `CSC_CR0`. Частота входного сигнала для блока PLL должна быть в пределах 5-7 МГц для MG32F02A032 и в пределах 4-8 МГц для остальных МК. Если входная частота сигнала CK\_HS (CK\_HS2) выше указанных допустимых значений, необходимо задействовать входной делитель PLLI
и задать коэффициент деления из множества 1, 2, 4 и 6 в поле `CSC_PLLI_DIV` регистра `CSC_DIV`.
В МК реализовано два типа умножения частоты. Настройка блока PLL осуществляется через регистр `CSC_PLL`. Если значение бита `CSC_PLL_MDS` регистра равно 0, блок может умножать частоту в 16 или 24 раза согласно установкам в поле `CSC_PLL_MUL`.
Если значение бита `CSC_PLL_MDS` регистра равно 1, блок может умножать частоту с коэффициентом в диапазоне 4-32 согласно установкам в поле `CSC_PLL_MULX`. В этом случае частота выходного сигнала CK\_PLL будет определяться выражением
F(CK\_PLL) = F(CK\_PLLI) \* (`CSC_PLL_MULX` + 1)
Частота сигнала CK\_PLL может достигать 144 МГц для MG32F02A032 и 180 МГц для остальных МК. Сигнал CK\_PLL также подается на выходной делитель PLLO, выходной сигнал которого CK\_PLLO вместе с сигналами CK\_PLLI и CK\_HS подается на следующий мультиплексор, формирующий конечный тактовый сигнал CK\_MAIN. Коэффициент делителя PLLO может быть равным 1, 2, 3 или 4 и задается в поле `CSC_PLLO_DIV` регистра `CSC_DIV`. Активный вход мультиплексора определяется значением поля `CSC_MAIN_SEL` регистра `CSC_CR0`.
Основной тактовый сигнал CK\_MAIN подается далее на предделитель APB Prescaler для формирования тактового сигнала CK\_APB шины APB (а также системного сигнала CK\_SYS). Коэффициент деления предделителя может принимать значения 1, 2, 4, 8 или 16 и определяется полем `CSC_APB_DIV` регистра `CSC_DIV`.
Тактовый сигнал CK\_AHB шины AHB получается делением частоты сигнала CK\_APB предделителем AHB Prescaler. Коэффициент деления предделителя может принимать значения 1, 2, 4, ..., 512 и определяется полем `CSC_AHB_DIV` регистра `CSC_DIV`.
Сигналы CK\_IHRCO, CK\_PLL, CK\_MAIN и CK\_SYS используются во внутренней логике МК. Сигнал CK\_AHB используется для тактирования центрального процессорного модуля, включая ЦПУ, NVIC, блок отладки DAP SWD, контроллера питания, памяти.
Сигналы CK\_ILRCO, CK\_XOSC и CK\_EXT подаются на мультиплексор для формирования низкочастотного сигнала тактирования CK\_LS (Low Speed clock). Активный вход данного мультиплексора определяется значением поля `CSC_LS_SEL` регистра `CSC_CR0`. Сигнал CL\_LS может использоваться для тактирования модуля RTC, таймеров TMx, последовательных асинхронных интерфейсов URTx.
Сигнал CK\_ILRCO, проходя через дополнительный делитель частоты, формирует еще один тактирующий сигнал CK\_UT, предназначенный для модулей WWDT, RTC, I2Cx. Коэффициент деления может принимать значения 8, 16, 32 или 128 и задается полем `CSC_UT_DIV` регистра `CSC_DIV`.
Сигнал тактирования CK\_ST для стандартного 24-разрядного системного таймера процессорного модуля System Tick Timer формируется либо из тактового сигнала ЦПУ HCLK путем деления частоты на 8, либо из сигнала CK\_LS с делением частоты на 2. Источник сигнала CK\_ST определяется битом `CSC_ST_SEL` регистра `CSC_CR0`.
В МК имеется возможность вывода некоторых сигналов тактирования на внешний вывод МК ICKO, соответствующий выводу PC0 (без альтернативного варианта). Данный выходной сигнал CK\_ICKO формируется на выходе делителя, на вход которого можно подключить следующие сигналы: CK\_MAIN, CK\_AHB, CK\_APB, CK\_HS, CK\_LS, CK\_XOSC. Выбор сигнала определяется значением поля `CSC_CKO_SEL`, а коэффициент деления (1, 2, 4 или 8) задается полем `CSC_CKO_DIV` регистра `CSC_CKO`. Разрешение коммутации сигнала на внешний вывод определяется битом `CSC_CKO_EN`.
Подсистема тактирования также включает детектор пропадания тактовых сигналов CK\_XOSC и CK\_EXT MCD (Missing Clock Detector). Детектор включен по-умолчанию и может быть отключен установкой бита `CSC_MCD_DIS` в регистре `CSC_CR0`. Интервал времени определения колебаний задается в поле `CSC_MCD_SEL` регистра `CSC_CR0`.
Регистр статуса `CSC_STA` подсистемы тактирования содержит поля, позволяющие определить статус первичных источников сигналов тактирования ("источник готов, частота стабильная"), а также состояния некоторых мультиплексоров, определяющих источники для вторичных сигналов.
Тактирование каждого встроенного периферийного модуля в режиме SLEEP может быть разрешено отдельно установкой соответствующих полей в регистрах `CSC_SLP0` и `CSC_SLP1`.
Подсистема тактирования может вырабатывать сигнал прерывания INT\_CSC при его разрешении в случае пропадания одного из используемых тактовых сигналов от источников XOSC, ILRCO, IHRCO, PLL. Разрешение прерывания от конкретных источников определяется соответствующими битами регистра `CSC_INT`.
Подсистема тактирования вырабатывает сигнал сброса RST\_CSC в случае обнаружения пропадания сигналов CK\_XOSC и CK\_EXT детектором MCD.
### Прерывания
Ядро Cortex-M0 включает развитую поддержку прерываний на основе контроллера вложенных (приоритетных) векторных прерываний NVIC. В архитектуре ARM прерывание является частным случаем *исключения* (exception). Исключения обрабатываются отдельными подпрограммами обработки, и, как правило, асинхронно по отношению к выполнению основной программы (задачи). Подпрограммы обработки часто именуются *ISR* (Interrupt Service Routine) или просто *хендлерами* (handler).
Каждая ISR имеет свой стартовый адрес, или *вектор*, который хранится в *таблице векторов (прерываний)*. При наступлении исключения (прерывания) в регистр `PC` (Program Counter) загружается его вектор из таблицы, в результате чего управление передается ISR. В общее число поддерживаемых исключений входит 32 внешних прерывания от периферийных устройств IRQ#x (Interrupt Request). Каждое исключение имеет свой номер (от 1 до 47), который определяет смещение своего вектора в таблице векторов (в 32-битных словах). В следующей таблице приведены все поддерживаемые в МК исключения и прерывания.
| Номер исключения | Название | Приоритет | Описание |
| --- | --- | --- | --- |
| 1 | Reset | -3 | Исключение "Сброс" |
| 2 | NMI | -2 | Немаскируемое прерывание (Non Maskable Interrupt) |
| 3 | HardFault | -1 | Аппаратное исключение, вызванное ошибкой в программе (неверный код инструкции, неверный адрес обращения и т.д.) |
| 4-10 | - | - | Зарезервированные номера |
| 11 | SVCall | настраиваемый | Системный вызов по машинной инструкции `SVC` |
| 12-13 | - | - | Зарезервированные номера |
| 14 | PendSV | настраиваемый | Системный вызов с возможностью отложения |
| 15 | SysTick | настраиваемый | Прерывание таймера System Tick Timer |
| 16 | WWDT (IRQ#0) | настраиваемый | Прерывание от модуля WWDT |
| 17 | SYS (IRQ#1) | настраиваемый | Общесистемное прерывание |
| 18 | (IRQ#2) | - | Зарезервировано |
| 19 | EXINT0 (IRQ#3) | настраиваемый | Внешнее прерывание EXINT0 (порт PA) |
| 20 | EXINT1 (IRQ#4) | настраиваемый | Внешнее прерывание EXINT1 (порт PB) |
| 21 | EXINT2 (IRQ#5) | настраиваемый | Внешнее прерывание EXINT2 (порт PC) |
| 22 | EXINT3 (IRQ#6) | настраиваемый | Внешнее прерывание EXINT3/EXINT4 (порты PD/PE) |
| 23 | COMP (IRQ#7) | настраиваемый | Общее прерывание от аналогового компаратора |
| 24 | DMA (IRQ#8) | настраиваемый | Прерывание модуля DMA |
| 25 | (IRQ#9) | - | Зарезервировано |
| 26 | ADC (IRQ#10) | настраиваемый | Прерывание от АЦП |
| 27 | DAC (IRQ#11) | настраиваемый | Прерывание от ЦАП |
| 28 | TM0x (IRQ#12) | настраиваемый | Общее прерывание таймеров TM0x |
| 29 | TM10 (IRQ#13) | настраиваемый | Прерывание таймера TM10 |
| 30 | TM1x (IRQ#14) | настраиваемый | Общее прерывание таймеров TM1x |
| 31 | TM20 (IRQ#15) | настраиваемый | Прерывание таймера TM20 |
| 32 | TM2x (IRQ#16) | настраиваемый | Общее прерывание таймеров TM2x |
| 33 | TM3x (IRQ#17) | настраиваемый | Общее прерывание таймеров TM3x |
| 34 | (IRQ#18) | - | Зарезервировано |
| 35 | (IRQ#19) | - | Зарезервировано |
| 36 | URT0 (IRQ#20) | настраиваемый | Прерывание модуля URT0 |
| 37 | URT123 (IRQ#21) | настраиваемый | Общее прерывание модулей URT1, URT2, URT3 |
| 38 | URT4x (IRQ#22) | настраиваемый | Общее прерывание модулей URT4, URT5, URT6, URT7 |
| 39 | (IRQ#23) | - | Зарезервировано |
| 40 | SPI0 (IRQ#24) | настраиваемый | Прерывание модуля SPI0 |
| 41 | (IRQ#25) | - | Зарезервировано |
| 42 | (IRQ#26) | - | Зарезервировано |
| 43 | (IRQ#27) | - | Зарезервировано |
| 44 | I2C0 (IRQ#28) | настраиваемый | Прерывание модуля I2C0 |
| 45 | I2Cx (IRQ#29) | настраиваемый | Общее прерывание модулей I2Cx |
| 46 | USB (IRQ#30) | настраиваемый | Прерывание модуля USB |
| 47 | APX (IRQ#31) | настраиваемый | Прерывание дополнительных модулей APX |
Первое 32-битное слово в таблице векторов содержит начальное значение регистра указателя стека `MSP` (Main Stack Pointer) и не связано с исключением. Первые пятнадцать исключений 1-15 являются стандартными для ядра Cortex-M0. Исключения 16-47 соответствуют прерываниям IRQ#0-31 периферийных модулей и определяются в конкретной реализации МК. Все указанные исключения асинхронны, кроме HardFault (3) и SVCall (11).
Каждое исключение имеет свой приоритет (чем меньше число, тем выше приоритет). Исключения 1-3 имеют фиксированный приоритет, приоритет остальных исключений в любом случае будет ниже и выбирается еще из четырех уровней, поддерживаемых контроллером NVIC ядра Cortex-M0. Таким образом, всего получается семь уровней приоритета. В архитектуре Cortex-M0 значение приоритета задается 8-битовым числом, в котором используются только старшие биты 6 и 7, младшая часть читается как 0.
На следующем рисунке показана общая функциональная схема подсистемы прерываний.
Функциональная схема подсистемы прерыванийПрерывания IRQ#0-31 для блока NVIC формируются контроллером внешних прерываний EXIC и контроллером пробуждения WIC, который получает сигналы прерываний от всех периферийных модулей.
Каждое из 32-х прерываний может быть *разрешено* путем записи слова *с установленным* битом в поле `SETENA` в регистр `CPU_ISER` (поле занимает весь регистр), соответствующим номеру прерывания. Аналогично, каждое из 32-х прерываний может быть *запрещено* путем записи слова *с установленным* соответствующим битом в поле `CLRENA` в регистр `CPU_ICER`. Чтение из этих регистров дает одинаковый результат: состояние разрешения (1) или запрета (0) соответствующего прерывания.
С помощью системных регистров `CPU_ISPR` (весь регистр — поле `SETPEND`) и `CPU_ICPR` (весь регистр — поле `CLRPEND`) можно соответственно установить или сбросить статус прерывания "отложено". Чтение из этих регистров дает статус соответствующего прерывания: "отложено" (1) или "нет" (0). Статус "отложено" возникает у прерывания, если оно происходит, например, в процессе обработки прерывания с более высоким приоритетом.
Регистры `CPU_SHPR2` и `CPU_SHPR3` (System Handler Priority Registers) определяют приоритет исключений SVCall (11), PendSV (14) и SysTick (15). Регистры `CPU_IPR0` - `CPU_IPR7` (Interrupt Priority Registers) определяют приоритет прерываний IRQ#0-31 (исключения 16-47).
Для каждого периферийного модуля имеется отдельная возможность разрешить или запретить генерацию им прерывания, а также определить конкретные события в этом модуле, которые приведут к генерации прерывания. Эти настройки осуществляются через управляющие регистры соответствующих модулей. Например, чтобы разрешить прерывания от модуля URT0, необходимо установить бит `URT0_IEA` в регистре `RT0_INT` (UART interrupt enable register).
В МК также имеется общее системное прерывание INT\_SYS, которое происходит при возникновении прерываний в модулях:
* RTC (INT\_RTC),
* IWDT (INT\_IWDT),
* памяти (INT\_MEM),
* подсистеме тактирования (INT\_CSC),
* подсистеме питания (INT\_PW),
* на шинах APB (INT\_APB) и EMB (INT\_EMB).
Разрешение или запрещение этого прерывания определяет бит `SYS_IEA` в регистре `SYS_INT`. В свою очередь, каждый из перечисленных модулей также имеет собственный регистр настроек и разрешения прерывания. Например, модуль RTC для разрешения своего общего прерывания имеет бит `RTC_IEA` в регистре `RTC_INT`.
Контроллер внешних прерываний EXIC позволяет обрабатывать внешние прерывания, сигналы о которых поступают на выводы портов PA-PE МК (для MG32F02A032 только PA-PD). Разрешением прерывания от порта Px (где x — A,B,C,D,E) управляет бит `EXIC_Px_IEA` регистра `EXIC_INT`.
Поля `EXIC_Pxn_TRGS` регистров `EXIC_Px_TRGS` позволяют задать одно из правил срабатывания триггеров для каждого вывода отдельно:
* вывод не приводит к срабатыванию,
* срабатывание по уровню,
* срабатывание по фронту,
* срабатывание по обоим фронтам.
Низкий или высокий уровень, передний или задний фронт импульса срабатывания триггера определяются включением или отключением инверсии соответствующих выводов в настройках самих портов. Биты `EXIC_Pxn_PF` регистров `EXIC_Px_PF` являются флагами срабатывания триггеров для каждого сконфигурированного вывода.
С помощью установки битов регистров маски `EXIC_Px_MSK` для каждого из портов можно организовать генерацию прерывания по схеме "ИЛИ" или по схеме "И", подключая необходимые выводы портов в качестве входов.
Регистры `EXIC_SRC0` - `EXIC_SRC7` позволяют выяснить, какое из внешних прерываний контроллера EXIC сработало, причем в поле `EXIC_ID1` регистра `EXIC_SRC0` указывается, какой именно модуль вызвал общее прерывание INT\_SYS.
Отдельно обрабатывается сигнал немаскируемого прерывания NMI (исключение 2). Его источником может служить системное прерывание CPU\_NMI от одноименного вывода МК (если бит `EXIC_NMI_SEL` регистра `EXIC_CR0` сброшен) или любое из прерываний IRQ#x (если бит `EXIC_NMI_SEL` установлен). Номер прерывания IRQ#x во втором случае определяется полем `EXIC_NMI_MUX` регистра `EXIC_CR0`.
ЦПУ поддерживает *коммуникационный интерфейс событий*, включающий входной сигнал CPU\_RXEV и выходной сигнал CPU\_TXEV, передаваемые через одноименные выводы МК. Если бит `EXIC_EM_RXEV` регистра `EXIC_CR0` установлен, активный сигнал CPU\_RXEV заставляет ЦПУ "проснуться", если он до этого был переведен в состояние "sleep" или "deep sleep" инструкцией `WFE`. Сигнал CPU\_TXEV активируется процессорной инструкцией `SEV` (Send Event).
### Инициализация и загрузка МК
При включении питания в МК выполняется POR-сброс, включающий "холодный" сброс, в результате которого значения конфигурационных ячеек OB0 загружаются в соответствующие разряды регистров аппаратной конфигурации `CFG_ORx`. Большая часть разрядов этих регистров имеет нулевое значение по-умолчанию. Поскольку ячейки flash-памяти имеют обычно начальное значение 0xFFFFFFFF, в МК принята схема инвертирования загружаемых данных из ячеек OBx в регистры `CFG_ORx`, чтобы пользователь мог что-то "включить", не прибегая к процедуре стирания. Это необходимо учитывать при программировании ячеек OBx.
Согласно настройкам по-умолчанию, источником тактирования выбирается генератор HRCO с частотой 12,0000 МГц, блок PLL отключается, а большая часть делителей частоты имеет коэффициент 1.
В зависимости от значения поля `BOOT_MS` ячеек OB0 на адрес 0x00000000 отображается одна из следующих областей памяти:
* flash-секция AP (вариант конфигурации без бутлоадера с максимальным размером прикладной части flash-памяти),
* flash-секция ISP (бутлоадер),
* встроенное ОЗУ SRAM.
Далее происходит сброс настроек всех выводов МК на значения по-умолчанию и выполняется сброс всех модулей и блоков. Затем процессор считывает таблицу векторов с адреса 0x00000000, инициализирует регистр стека `MSP`, загружает в `PC` адрес вектора Reset (смещение 0x00000004) и начинает выполнение инструкций. Отметим, что согласно настройкам по-умолчанию, в МК отключены практически все периферийные модули (отключено тактирование и запрещена их работа), а также отключены прерывания. Следовательно, на начальном этапе инициализации МК в программе необходимо предусмотреть выбор конфигурации тактирования подсистем МК, разрешить работу требуемых модулей, разрешить необходимые прерывания.
В следующей статье будут рассмотрены: контроллер flash-памяти, методика программирования МК на основе OpenOCD, разработка программы на gcc, управление GPIO. | https://habr.com/ru/post/674788/ | null | ru | null |
# Первые впечатления от перехода с Ubuntu 16.04 LTS на Ubuntu 18.04 LTS
Как известно, основное визуальное изменение в релизе 18 — это отказ от Unity и переход на Gnome 3. Здесь хочу поделиться своими впечатлениями от перехода с 16 на 18
### Сначала о хорошем...
Релиз 18 принёс нам новое ядро Linux (4.15) с заплатками от Meltdown и Spectre, которые включены по умолчанию и, по предсказаниям специалистов, должны сильно деградировать производительность компьютера. Однако несмотря на то, что мой процессор (Intel Core i5) и входит в список уязвимых, а значит заплатки для него включены, что подтверждают логи загрузки, в своих обычных задачах какого-то ощутимого падения производительности я не заметил. Поэтому, если ваш компьютер не является сервером, работающим под постоянной высокой нагрузкой на пределе его возможностей, вряд ли стоит сразу кидаться отключать эти заплатки только из-за боязни «тормозов».
Сам графический интерфейс гнома по моим ощущениям работает ощутимо быстрее юнити. Полагаю, что это связано с тем, что в нём на открытие окошек и т.д. и т.п. просто навешано меньше эффектов, которые можно отключить и в юнити. Но поскольку моя работа заключается не в изучении интерфейсов убунты, а по своей инициативе мне это делать лень, то приходится пользоваться тем, что есть «из коробки». «Из коробки» же гном работает шустрее юнити (или, если точнее, гном 3 на убунте 18.04.01 против юнити на убунте 16.04). Впрочем, это «ощутимо шустрее» не означает, что интерфейс юнити монструозен и тормозной. Отнюдь. Скорость его работы вполне приемлема. Просто гном шустрее.
Ещё очень понравился аналог меню Пуск (квадрат из девяти кружков в левом нижнем углу). Несмотря на то, что он тоже плиточный, открывается шустро и показывает все установленные в системе приложения. Работать с ним просто и удобно. В юнити им практически вообще не пользовался из-за того, что именно этот компонент действительно очень тормозной и показывает как-то не совсем то, что я ожидаю увидеть.
### С плюсами закончили, переходим к минусам...
**1. Сторонние репозитории**
При переходе на новую версию убунта обычно отключает сторонние репозитории, и их потом нужно опять включить. Делалось это обычно из оконного интерфейса. Однако в этот раз сколько я ни жал на галочки включения, окно просто серело, и ничего не происходило. Пришлось вручную править файлы в /etc/apt/. Мелочь, конечно…
**2. Исчезли нотификации приложений**
Когда в юнити мне приходило новое письмо на почту или сообщение в слак, в верхнем правом углу выскакивали постоянно висящие значки, при нажатии на которые открывалось соответствующее приложение. Аналог system tray в windows. При переходе на гном, все подобные уведомления исчезли. То есть в гноме есть некий механизм уведомлений, когда при приходе нового письма на 10 секунд почти в центре экрана выскакивает окошко с сообщением. Но что, если в данный момент я был не у компьютера? Или даже просто в течение этих 10 секунд смотрел в другую сторону? Да и приходили они тоже не понятно как. Такое ощущение, что уведомляло только о первом письме, а все последующие игнорировались.
После некоторых плясок с бубном мне удалось добиться того, что Thunderbird таки стал выводить на своей иконке в панели задач красный кружок с количеством новых писем. Хоть это и не system tray, но вполне равноценная замена. Причём у меня есть основания предполагать, что этот красный кружочек как бы должен был заработать сразу после установки, так как ничего особенного в своих плясках с бубном я не делал и в конце концов вернулся к тому, с чего начал. Да и почтовый клиент таки не какой-нибудь сторонний, а дефолтный, должен быть вылизан вдоль и поперёк. Но у меня почему-то сразу не заработал.
Уведомления же для слака так и не удалось настроить. А с учётом того, что это наше основное средство корпоративной коммуникации, то беда-беда (Если кто-то знает, как справиться с этой бедой, буду благодарен за помощь)
В общем, за нотификации ОГРОМНЫЙ минус
UPDATE: Нотификации слака загадачным образом появились сами по себе, спустя полтора суток после установки и нескольких перезагрузок, не связанных со слаком. Вверху в центре правого монитора, прямо перед датой. Так что нотификации в гноме всё-таки есть, ура! одной проблемой меньше)))
**3. Очередные «мудрения» в gnome-terminal**
gnome-terminal был терминалом по умолчанию и в юнити, так что это не проблема перехода от юнити к гному. Это проблема перехода от убунты 16 к 18.
Суть в том, что если раньше я мог создать скрипт, воссоздающий моё рабочее окружение, вида
```
gnome-terminal --maximize \
--tab --working-directory=$HOME/workspace/project1 -e "script" \
--tab -e "top" \
--tab -e "ssh -t user@host.ru" \
...
gnome-terminal --maximize \
--tab ...
```
то теперь такая конструкция работает вкривь и вкось, так как вкладки обоих терминалов будут открываться во вкладках вызывающего окна, то есть будут свалены все в одну кучу. Плюс терминал засыпет вас сообщениями, что параметр -e устарел и скоро будет убран. Что вместо -e «command» следует использовать конструкцию — command. То есть одним вызовом открыть две вкладки с подключением по ssh к двум разным хостам станет проблемой. И вообще станет проблемой создать из коммандной строки новое окно с набором своих собственных вкладок (на самом деле, думаю, можно создать новое окно и уже в команде к нему прописать серию вызовов к терминалам с отдельными табами, но на мой взгляд это ...)
Для большинства пользователей данная проблема, конечно, мелочь, но для тех, кто gnome-terminal использует напрямую, уже неприятно…
**4. Панель задач при двух мониторах**
Есть два монитора. Работают в режиме, когда у каждого своё содержимое. Панель задач настраиваем так, чтобы отображалась на обоих. Теперь открываем два окна, например, браузера или среды разработки и растаскиваем их на разные экраны. Важно, чтобы оба окна были одного и того же приложения. Пусть это будет браузер хром. В панели задач справа от иконки хрома мы увидим два маленьких кружочка, обозначающих, что открыто два экземпляра хрома.
Как было в юнити?
Если я в левой панели задач нажму на иконку хрома, система автоматически переключит меня на окно хрома на левом экране. Если нажму на иконку в правой, то соответственно на то, что на правом. Если же в левом окне я открою ещё одно окно хрома, третье, то при нажатии на иконку в левой панели система предоставит мне выбор, какое окно я хочу. Правая панель всё так же будет сразу переключать в своё единственное окно, без лишних вопросов. Архиудобно!
Как сейчас в гноме?
Панели на обоих экранах являются полностью идентичными и всегда выводят запрос в виде уменьшенных картинок, какое окно выбрать. Причём из этого запроса проблематично понять, какое окно к какому экрану относится. И при работе с несколькими окнами одного и того же приложения приходится совершать массу ненужных кликов.
Таким образом, если задача активной работы на двух (и более) мониторах для вас актуальна, я бы рекомендовал десять раз подумать, прежде чем отказываться от юнити в пользу гнома.
### Резюме
В целом юнити и гном вполне сопоставимы по своим возможностям и функционалу. Что выбрать — скорее вопрос личных предпочтений. Я привёл то, что сразу бросилось мне в глаза и «усложнило» лично мне жизнь при переходе на гном. Что из приведённого актуально для вас и актуально ли вообще, решать только вам. | https://habr.com/ru/post/421935/ | null | ru | null |
# Отключение профиля DEP и MDM на Mac OS Big Sur
ДисклеймерОписанные ниже действия лишают компанию или организацию, которая выдала вам компьютер, возможности следить за вашим устройством и получать дистанционно доступ к данным на нем.
Если обязательства перед компанией или закон ограничивает вас от выполнения подобных действий - НЕ ИСПОЛЬЗУЙТЕ приведенные ниже инструкции.
Если ваши этические принципы или иные убеждения не позволяют вам избавиться от контроля компании или организации - НЕ ИСПОЛЬЗУЙТЕ приведенные ниже инструкции.
В описанном методе не применяется какой-либо внешний инструментарий и используются только штатные средства Mac OS.
При использовании данного метода ОТКЛЮЧАЕТСЯ ШИФРОВАНИЕ FileVault накопителя. Если такое действие неприемлемо – НЕ ИСПОЛЬЗУЙТЕ данный метод. Тестирование с последующей активацией шифрования не проводилось.
Автор с уважением относится к компаниям и администраторам, которые настраивают системы контроля DEP и MDM.
Также **автор уважает свободный осознанный выбор конечных пользователей по снятию систем слежения и дистанционного доступа к данным, если это не нарушает их обязательств перед компанией и закон.**
Все инструкции пользователь выполняет на свой страх и риск. Автор не несет никакой ответственности на нанесенный вред или ущерб, в результате выполняемых действий, равно как не призывает к их выполнению.
Немного про DEP и MDM
---------------------
Update: Спасибо [@agafon\_aga](/users/agafon_aga) за существенные замечания:
> Описанная здесь ситуация актуальна при использовании Apple Device Enrollment Program (DEP). Смысл ее — привязка устройств на аккаунт компании для облегчения управления, инвентаризации и прочего.
>
> Внутри системы DEP имеет самый высокий приоритет (после Apple, разумеется).
>
> Mobile Device Management (MDM) системы, имеют приоритет ниже чем AppleID пользователя устройства. Удалить профиль именно MDM (а не DEP) пользователь может легко. Для этого достаточно быть админом в системе.
>
> Итого, уровень приоритетов выстраивается (от высшего к низшему):
>
> *Apple — DEP — User AppleID — MDM Profile*
>
>
Профили DEP (Device Enrollment Program) и MDM (англ. Mobile Device Management), как правило, устанавливается пользователям на устройства, которые выданы им крупными компаниями, а также некоторыми школами и университетами в пользование. Профиль позволяет автоматизировать настройку практически всех программных компонентов устройства. При этом он также позволяет полностью контролировать устройство дистанционно. Возможности контроля ограничены лишь фантазией администратора, который его настраивал.
Короче, в общем для компании - это хорошо, в частности для конкретного пользователя - не очень. Иногда совсем не хочется, чтобы кто-то мог в любой момент дистанционно выкинуть тебя из компьютера или просто его заблокировать.
Корпоративный профиль устанавливается на заводе во время заказа партии для того или иного крупного заказчика и не может быть удален окончательно программно. Как правило, после полного сброса во время активации устройства профиль загружается из интернета и снова пробует себя развернуть на устройстве. Назойливость этих попыток может быть разной, и наша сегодняшняя задача избавиться от этого.
Решение с обходом блокировки на Mac OS Catalina достаточно прямолинейное и без труда находится в интернете. С Big Sur все намного сложнее. В новой операционной системе реализован новый механизм защиты целостности системы. Поэтому весь алгоритм действий усложнился.
Установка чистой системы
------------------------
Будем предполагать, что мы в состоянии сами установить чистую систему Mac OS Big Sur с флешки. В случае с MDM устройством главное правило - **проводим чистую установку с отключенным интернетом,** чтобы система не могла получить данные по имеющемуся MDM идентификатору.
После завершения установки к интернету подключаться можно. К сожалению, система тут же начнет предлагать загрузить и установить тот самый MDM профиль, который по ее мнению должен быть настроен в системе. Настойчивость таких предложений - примерно раз в 10 минут. Жить можно, но мы не согласны на полумеры.
Отключение MDM профиля
----------------------
1. На устройстве должен быть снят пароль на включение и выключено шифрование диска:
*Настройки -> Безопасность -> FileVault - выключить*
2. Перезагружаемся в режиме восстановления:
*Удерживаем (Command+R) во время загрузки до появления полосы загрузки.*
3. В режите восстановления запускаем терминал:
*"Утилиты" -> "Терминал"*
4. Смотрим индентификатор тома:
```
mount
```
5. Если вы не трогали название разделов во время установки, то название по умолчания должно остаться "Macintosh HD". Здесь и далее будем использовать его.
Записываем на листик индентификатор тома "/Volumes/Macintosh HD"
**Внимание!** Не перепутать с диском "/Volumes/Macintosh HD - Data"
Идентификатор выглядит примерно так **dev/disk4s5** - в вашем случае цифры могут быть другие.
**Внимание!** Индентификатор тома и название тома в последующих примерах команд подставляем свои!
6. Отключаем том и копируем файлы агентов в отдельную папку bak:
```
umount /Volumes/Macintosh\ HD
mkdir /Volumes/Macintosh\ HD
mount -t apfs -rw /dev/disk2s5 /Volumes/Macintosh\ HD
cd /Volumes/Macintosh\ HD/System/Library/LaunchAgents
mkdir bak
mv com.apple.ManagedClientAgent.* bak/
mv com.apple.mdmclient.* bak/
cd ../LaunchDaemons
mkdir bak
mv com.apple.ManagedClient.* bak/
mv com.apple.mdmclient.* bak/
```
7. Отключаем Signed System Volume (SSV):
```
csrutil authenticated-root disable
```
8. Сохраняем текущий статус диска в снепшот, чтобы система не ругалась на изменение системных файлов:
```
bless --folder /Volumes/Macintosh\ HD/System/Library/CoreServices --bootefi --create-snapshot
```
9. Закрываем терминал и перезагружаемся.
Готово. Агенты MDM профиля больше системой не видятся.
Обновления будут работать. Если сделать чистую переустановку - процедуру придется повторить сначала. Иногда фикс слетает после установки мажорных обновлений.
Работоспособность метода проверена на Mac OS Big Sur до версии 11.1. | https://habr.com/ru/post/535468/ | null | ru | null |
# Интеграционные возможности easla.com
Ни одна современная система электронного документооборота немыслима без возможности интеграции ее в существующее информационное пространство организации с помощью API или протоколов связи.
Не исключение и [easla.com](http://easla.com).
#### Авторизация и импорт пользователей
Прежде всего, [easla.com](http://easla.com) позволяет сотрудникам организации авторизоваться несколькими способами. Первый, разумеется, авторизация с помощью учетной записи [easla.com](http://easla.com). Второй, авторизация с помощью социальных сетей. И третий, авторизация с помощью домена организации. Да-да, онлайн система позволяет авторизоваться через домен! Не шучу.
Очевидно, что для авторизации через домен организации, администратор должен произвести соответствующую настройку в [easla.com](http://easla.com) и в самом домене. В домене рекомендуется создать доп. пользователя, который обладает ограниченным набором прав достаточных для чтения данных о пользователях и только. Открыть порт или прокинуть туннель к домену. Администратор домена должен сам решить для себя, что проще, удобнее и безопаснее.
На стороне [easla.com](http://easla.com) необходимо прописать IP домена, логин и пароль, а также путь для доступа к пользователям. Проверить соединение и, если оно удачно, то осуществить импорт пользователей из домена. Если пользователи уже созданы, то можно не импортировать, хотя импорт упрощает жизнь администратору на порядок.
Кстати, при импорте пользователей, импортируется не только фамилия, имя, отчество, логин и эл. почта, но и все необходимые атрибуты, а также должность и отдел.
Импорт из LDAP наглядно отображает ранее импортированных пользователей, их состояние (заблокирован или нет). Кроме этого, содержит гиперссылку на существующий аккаунт в [easla.com](http://easla.com). В случае, когда на стороне домена произведено много изменений, скажем, произошла «массовая миграция» пользователей из одних кабинетов в другие и изменились их номера телефонов и номера кабинетов, обновить данные в системе можно одной кнопкой «Обновление всех импортированных пользователей».
Все с заботой об администраторе!
#### Почтовый сервер
Конечно, [easla.com](http://easla.com) обладает своим почтовым сервером, но отправленные с его помощью письма будут от имени одного и того же виртуального пользователя. Но большинство сотрудников приучены или привыкли отвечать на входящие сообщения не глядя на адрес отправителя и невзирая на предупреждение, что этого делать ненужно. В итоге, письма уходят в никуда.
Можно научить пользователей адекватно воспринимать почтовые сообщения от системы, но можно поступить иначе – использовать почтовый сервер организации. Настройка easla.com позволяет указать имя почтового сервера организации, порт, логин и пароль. После чего, если в функции [sendEmail](http://easla.com/ru/manual/page/view/script#function_sendEmail) будет заполнен параметр *from*, то письмо будет уходить от почтового сервера организации, а если параметр *from* не указан, то от почтового сервера [easla.com](http://easla.com).
#### SOAP
Система [easla.com](http://easla.com) предоставляет всем зарегистрированным администраторам и пользователям доступ к данным по протоколу [SOAP](https://ru.wikipedia.org/wiki/SOAP). Описание функций можно найти по ссылкам (только для авторизованных пользователей и администраторов):
<https://easla.com/ru/admin/soap>
<https://easla.com/ru/user/soap>
Разумеется, доступ к данным для администратора и пользователя – разный. Пользователь даже через SOAP не сможет обратиться к объекту, к которому у него нет прав доступа, а администратор обладает полномочиями получить данные обо всех объектах.
Использовать SOAP можно самыми разными способами. Например, с помощью скрипта на VBScript:
**Получение списка исходящих писем из easla.com**
```
Function EaslaSoapLogin(userName, password)
Dim strSoap
strSoap = "" & Chr(13) & \_
"" & Chr(13) & \_
"" & Chr(13) & \_
"" & userName & "" & Chr(13) & \_
"" & password & "" & Chr(13) & \_
"" & Chr(13) & \_
"" & Chr(13) & \_
""
EaslaSoapLogin = strSoap
End function
Function EaslaSoapLogout()
Dim strSoap
strSoap = "" & Chr(13) & \_
"" & Chr(13) & \_
"" & Chr(13) & \_
"" & Chr(13) & \_
""
EaslaSoapLogout = strSoap
End function
Function EaslaSoapOutgoings()
Dim strSoap
strSoap = "xml version=""1.0"" encoding=""UTF-8""?" & Chr(13) & _
"" & Chr(13) & \_
"" & Chr(13) & \_
"" & Chr(13) & \_
"" & Chr(13) & \_
"234" & Chr(13) & \_
"118" & Chr(13) & \_
"" & Chr(13) & \_
"" & Chr(13) & \_
"crs\_management\_outgoing\_regnum" & Chr(13) & \_
"crs\_management\_outgoing\_document" & Chr(13) & \_
"crs\_management\_outgoing\_attachments" & Chr(13) & \_
"" & Chr(13) & \_
"" & Chr(13) & \_
"" & Chr(13) & \_
"status" & Chr(13) & \_
"" & Chr(13) & \_
"crs\_management\_outgoing\_created" & Chr(13) & \_
"" & Chr(13) & \_
"" & Chr(13) & \_
"" & Chr(13) & \_
"" & Chr(13) & \_
"" & Chr(13) & \_
""
EaslaSoapOutgoings = strSoap
End function
Function EaslaLogin(login, password)
Dim URL
URL = "https://easla.com/ru/user/soap/ws/1"
Dim strSoapReq
strSoapReq = EaslaSoapLogin(login, password)
Dim oHttp
Set oHttp = CreateObject("Msxml2.XMLHTTP")
oHttp.open "POST", URL, false
oHttp.setRequestHeader "Content-Type", "application/soap+xml"
oHttp.setRequestHeader "charset", "utf-8"
oHttp.send strSoapReq
Dim strResult
strResult = oHttp.responseText
'проверка, ошибка или корректный результат?
dim regExp
Set regExp = CreateObject("VBScript.RegExp")
regExp.Multiline = True
regExp.Pattern = "(.\*)"
'Wscript.Echo strResult
Set matches = regExp.Execute(strResult)
if matches.count = 0 then
EaslaLogin = false
Exit Function
end if
EaslaLogin = (matches(0).SubMatches(0) = "true")
End Function
Function EaslaLogout
Dim URL
URL = "https://easla.com/ru/user/soap/ws/1"
Dim strSoapReq
strSoapReq = EaslaSoapLogout()
Dim oHttp
Set oHttp = CreateObject("Msxml2.XMLHTTP")
oHttp.open "POST", URL, false
oHttp.setRequestHeader "Content-Type", "application/soap+xml"
oHttp.setRequestHeader "charset", "utf-8"
oHttp.send strSoapReq
Dim strResult
strResult = oHttp.responseText
'проверка, ошибка или корректный результат?
dim regExp
Set regExp = CreateObject("VBScript.RegExp")
regExp.Multiline = True
regExp.Pattern = "(.\*)"
'Wscript.Echo strResult
Set matches = regExp.Execute(strResult)
if matches.count = 0 then
EaslaLogout = false
Exit Function
end if
EaslaLogout = (matches(0).SubMatches(0) = "true")
End Function
Function EaslaOutgoings(ByRef ids, ByRef descriptions)
Dim URL
URL = "https://easla.com/ru/user/soap/ws/1"
Dim strSoapReq
strSoapReq = EaslaSoapOutgoings()
Dim oHttp
Set oHttp = CreateObject("Msxml2.XMLHTTP")
oHttp.open "POST", URL, false
oHttp.setRequestHeader "Content-Type", "application/soap+xml"
oHttp.setRequestHeader "charset", "utf-8"
oHttp.send strSoapReq
Dim strResult
strResult = oHttp.responseText
'проверка, ошибка или корректный результат?
dim regExp
Set regExp = CreateObject("VBScript.RegExp")
regExp.Multiline = True
regExp.Pattern = "(.\*)"
Set matches = regExp.Execute(strResult)
if matches.count = 1 then
EaslaOutgoings = false
Exit Function
end if
EaslaOutgoings = ParseXMLToOutgoingsArray(Progress, strResult, ids, descriptions)
End function
Sub Reverse( ByRef myArray )
Dim i, j, idxLast, idxHalf, strHolder
idxLast = UBound( myArray )
idxHalf = Int( idxLast / 2 )
For i = 0 To idxHalf
strHolder = myArray( i )
myArray( i ) = myArray( idxLast - i )
myArray( idxLast - i ) = strHolder
Next
End Sub
Function ParseXMLToOutgoingsArray(progress, strXML, ByRef ids, ByRef descriptions)
Dim xmlDoc
Set xmlDoc = CreateObject("Microsoft.XMLDOM")
xmlDoc.async = false
Dim ret
ret = xmlDoc.loadXML(strXML)
if (xmlDoc.parseError.errorCode <> 0) then
Dim myErr
Set myErr = xmlDoc.parseError
ThisApplication.AddNotify "Ошибка при разборе XML " + myErr.reason
end if
dim nodeList
Set nodeList = xmlDoc.SelectNodes("//getObjectrefsResult/item")
Dim cnt, q, n
cnt = nodeList.length
q = 0
For Each node In nodeList
dim id
'id = id_node.getElementsByTagName("value").item(0).Text
id = node.getElementsByTagName("id").item(0).Text
dim description
description = node.getElementsByTagName("description").item(0).Text
n = UBound(ids)
if (n < 0) Then n = 0
ReDim Preserve ids(n + 1)
ReDim Preserve descriptions(n + 1)
ids(UBound(ids)) = id
descriptions(UBound(descriptions)) = description
q = q + 1
Next
Call Reverse(ids)
Call Reverse(descriptions)
ParseXMLToOutgoingsArray = q
End Function
Dim auth
auth = EaslaLogin("ORGANIZATION_CODE\User_login", "User_password")
if (auth = false) then
MsgBox "Авторизация на easla.com не пройдена. Неверное имя пользователя или пароль!", vbCritical
Exit Sub
end if
Dim ids
Dim descriptions
Dim success
success = EaslaOutgoings(ids, descriptions)
Call EaslaLogout
```
#### С#
Используя [EaslaAgent](http://easla.com/ru/site/page/view/tools) установленный на рабочем месте пользователя можно писать модули и самостоятельные приложения на C# — ныне очень популярный язык программирования. Авторизацию пользователя агент возьмет на себя, что упрощает жизнь программисту. Все обращения к [easla.com](http://easla.com) агент тоже преобразует в правильные запросы.
Кстати, агент предоставляет возможность отображения диалогового окна с перечнем полученных объектов, чтобы не «городить» его в каждом приложении снова и снова. Выглядит окошко примерно так:
Фрагмент кода, который получает перечень объектов из easla.com и показывает их в диалоговом окне:
```
var result = EaslaApp.getObjectrefs(object_def,
new string[] { "crs_management_incoming_contragent_regnum" },
new Easla.KeyValuesPairSoap[]
{
new Easla.KeyValuesPairSoap() {key = "status", values = new string[] {"crs_management_incoming_created"} },
new Easla.KeyValuesPairSoap() {key = "isdeleted", values = new string[] {"0"} }
});
var m = EaslaApp.ShowSelectObjectDialog(result,
new Easla.KeyValuePairSoap[]
{
new Easla.KeyValuePairSoap() { key = "Описание", value = "description"},
new Easla.KeyValuePairSoap() { key = "Дата создания", value = "createtime"},
new Easla.KeyValuePairSoap() { key = "Статус", value = "status.name"},
new Easla.KeyValuePairSoap() { key = "Регистрационный номер отправителя", value = "attributerefs[0].values[0].values[0]"}
}) as Easla.ObjectrefComplexSoap;
```
#### SQL
Напоследок добавлю, что [easla.com](http://easla.com) умеет интегрироваться в MS SQL с помощью CLR-модуля. Установив [Easla.com module for MS SQL](http://easla.com/ru/site/page/view/tools), можно прямо из SQL запроса запрашивать данные из [easla.com](http://easla.com), обрабатывать и передавать, скажем, в локально используемые системы или в отчеты.
Простой пример:
```
select @logined = [master].[dbo].[EASLAlogin](пользователь,пароль)
IF (@logined = 1) BEGIN
-- получение идентификаторов организации, процесса и объекта по их обозначениям
SELECT @organization_id = organization.id, @process_id = process.id, @objectdef_id = objectdef.id
FROM [master].[dbo].[EASLAgetOrganization] ('TNGP') AS organization
LEFT JOIN [master].[dbo].[EASLAgetAllProcesses] () AS process ON process.oid = organization.id
LEFT JOIN [master].[dbo].[EASLAgetAllObjectdefs] () AS objectdef ON objectdef.pid = process.id
WHERE process.code = 'crs_management' AND objectdef.code = 'crs_management_outgoing';
SELECT attributerefs.value('(ArrayOfAttributerefSimpleSoap[1]/AttributerefSimpleSoap[1]/values/item/node())[1]','varchar(30)') as letternum ,attributerefs.value('(ArrayOfAttributerefSimpleSoap[1]/AttributerefSimpleSoap[2]/values/item/node())[1]','varchar(30)') as regdate ,cast(attributerefs.query('(ArrayOfAttributerefSimpleSoap[1]/AttributerefSimpleSoap[3]/values/item/consist/item/revdata)')as varchar(max)) as revguid ,cast([status].query('(StatusSimpleSoap[1]/name[1]/node())')as varchar(max)) as sentstatus
FROM master.[dbo].[EASLAgetobjectrefs]( @process_id, @objectdef_id,CAST(' crs\_management\_outgoing\_regnum crs\_management\_outgoing\_sentdate crs\_management\_outgoing\_attachments ' AS XML) ,
' status crs\_management\_outgoing\_created ',
@user_id –- какой-то пользователь
);
END
IF (@logined = 1) BEGIN
select @logined = 1 - [master].[dbo].[EASLAlogout]()
END
```
#### Итоги
Резюмируя, повторюсь, только по-настоящему открытая система имеет право на жизнь в нынешних условиях и [easla.com](http://easla.com) позволяет пользователю (в данном случае, скорее, администратору) почувствовать всю гибкость ее эксплуатации и независимость при доступе к данным. Никаких ограничений! | https://habr.com/ru/post/300894/ | null | ru | null |
# EBU R128/BS.1770-3: Пакетная нормализация громкости аудио/видео файлов
Всем привет!
Решил поделиться опытом автоматизации контроля громкости вещания своего СМИ. Думаю, у всех профильных технарей давно болит голова, точно продолжает болеть. Введенная Минкомсвязи рекомендация в области нормирования громкости звуковых сигналов вызвала волны возмущения.
Не было предоставлено ни средств контроля, ни средств производства. Крутитесь как хотите.
Впрочем, уже давно, задолго до того знакового события существуют различные плагины к монтажным программам.
Но как быть если уже накоплена огроменная медиабаза?
[](http://redmine.digispot.ru/projects/digispot/wiki/LUFS)
Побродил я по просторам интернета и наткнулся на очень, по моему мнению, элегантное решение. Причем, к радости моей, это оказалось свободное ПО. Проект называется [r128gain](http://r128gain.sourceforge.net/).
r128gain измеряет громкость аудио файлов в единицах измерения [LUFS](http://redmine.digispot.ru/projects/digispot/wiki/LUFS). Понимает она, насколько я выяснил, два формата:
* FLAC
* PCM signed 16 bit little endian (Microsoft WAVE)
После измерения предлагается применить громкость к дорожке двумя способами:
**1.** Используя утилиту [SoX — Sound eXchange](http://sox.sourceforge.net/), получить причесанный звук:
```
r128gain "--command=sox %TRACK% out.wav|flac gain %TGDB%" in.wav|flac -o .
```
**2.** Используя утилиту [FFmpeg](https://ffmpeg.org/) заменить/добавить аудиодорожку к фидеофайлу:
```
r128gain "--command=ffmpeg -i %TRACK% -vcodec copy -acodec flac -af volume=%TG% -y out.mkv" in.wav|flac -o.
```
Я выбрал первый вариант. Чтобы выделить звук из моих видеофайлов, я использую ffmpeg:
```
ffmpeg -i in.avi -vn -c:a pcm_s16le -ac 2 in.wav -y
```
Нормализация:
```
r128gain "--command=sox %TRACK% out.wav|flac gain %TGDB%" in.wav|flac -o .
```
Сборка готового видео файла. Так как кроме старых файлов имеется постоянный поток сторонних, приводим к единому формату. У меня используется такой стандарт:
```
video: MPEG2 PAL 720x576
audio: MPEG1 Layer II
```
Сборка:
```
ffmpeg -i in.avi -i out.wav -c:v mpeg2video -b 30000k -s pal -r pal -aspect 4:3 -vf scale=min(576*15*sar*iw/ih/16\,720):min(720*16*ih/15/sar/iw\,576),pad=720:576:(ow-iw)/2:(oh-ih)/2 -flags +ilme+ildct -movflags faststart -c:a mp2 -map 0:v:0 -map 1:a:0 out.mpg -y
```
На выходе получаем продукт в едином формате.
Спасибо за помощь [arteast](https://habrahabr.ru/users/arteast/)
Спасибо за внимание! Надеюсь, моя статья окажется для вас полезной.
[Читать вторую часть про реализацию](https://habrahabr.ru/post/333686/) | https://habr.com/ru/post/311758/ | null | ru | null |
# Построение простого flow в IBM App Connect (Integration Bus)
Make legacy great again
Для начала запускаем IBM App Connect Entrerprise Toolkit (в десятой версии - IBM Integration Toolkit), слева во вкладке "Application Development" нажимаем New -> Start by creating an application:
Назовём наше приложение "Increment Integer"Приложения в IBM Integration Bus (далее - IIB) служат как логические контейнеры для flow. Flow в интеграционной шине всегда должно иметь начало и конец. Наш flow должен уметь принимать HTTP запросы, поэтому в начало мы поставим HTTP Input:
Далее, нужно создать Message Flow. Приложение может содержать несколько flow, в данном примере создадим один и назовем его Incrementor. Для этого в приложении нажимаем на (New...) -> Message Flow:
На flow размещаются компоненты из палитры:
Палитра компонентовКаждый flow для работы должен иметь как минимум входной компонент. Такие компоненты в палитре отмечаются зелёной полоской слева. В нашем случае мы будем использовать компонент HTTPInput. Для его размещения на flow выбираем в палитре вкладку HTTP, зажимаем правую кнопку мыши на HTTPInput и перетаскиваем компонент на flow editor:
Flow editor с HTTPInputНастройки компонента:
Path suffix for URL - нужно указать путь для эндпоинта. Следует указывать только путь, адрес и порт указывать не нужно
Вкладка "Input Message Parsing"Message domain - тут нужно указывать формат тела запроса, который будет приходить на эндпоинт. Часто используются три формата:
* XMLNSC - для XML сообщений, позволяет использовать валидацию и потребляет мало памяти
* JSON - для JSON сообщений
* BLOB - для набора байтов, после это сообщение можно распарсить в ESQL
В данном случае будем использовать JSON.
Вкладка "Error Handling"Maximum client wait time (sec)\* - время ожидания клиента в секундах. Если время обработки сообщения займёт больше указанного, то IIB сгенерирует сообщение об ошибке и вернёт клиенту.
Fault format\* - формат ошибки после таймаута. Можно выбрать SOAP 1.1, SOAP 1.2m, HTML и JSON. В данном случае выбираем JSON.
Остальные настройки оставляем по умолчанию. После получения сообщения необходимо его обработать. За это отвечает компонент Compute, который находится на палитре во вкладке Transofmation:
После сохранения редактора компонент Compute будет показывать ошибку, так как к нему не привязан файл ESQL.
ESQL - это язык программирования, который используется в IIB для обработки сообщений и построения сложной логики. Подробнее тут:<https://www.ibm.com/docs/en/integration-bus/10.0?topic=esql-overview>. Для создания и привязки ESQL файла к Compute дважды на нём щёлкаем. После этого открывается редактор кода с сгенерированным шаблоном:
Вернёмся во flow. Чтобы передать сообщение из HTTPInput в Compute, их необходимо соединить через терминалы.
Каждый компонент в палитре IIB имеет терминалы. Терминалы - это точки соединения компонентов друг с другом, они подразделяются на входные и выходные. Входные компоненты имеют только выходные терминалы. Например, HTTPInput имеет 4 выходных терминала, а именно:
Справа - выходные терминалы* Failure - присутствует практически в каждом компоненте. Если в компоненте происходит Exception, сообщение выходит из этого терминала
* Out - если всё успешно, сообщение выходит тут
* HTTP Timeout - если flow долго отрабатывает, в нём генерируется ошибка
* Catch - сюда приходят Exception с flow
Чтобы вернуть ответ клиенту, ставим компонент HTTPReply:
Теперь заходим в Compute и в функции Main пишем следующий код:
`SET OutputRoot.JSON.Data.testNumber = InputRoot.JSON.Data.testNumber + 1;`
Здесь OutputRoot - исходящее сообщение, InputRoot - входящее, JSON - domain сообщения.
Приложения деплоят на интеграционные сервера, которые, в свою очередь, поднимаются на Integration Nodes. Если тулкит показывает, что ноды у вас нет, нужно её создать. Для этого запускаем IBM Integration Console (IBM App Connect Enterprise Console) и вбиваем там команду:
`mqsicreatebroker IB10NODE -i wbrkuid -a wbrkpw`
Где IB10NODE - имя ноды, wbrkuid - логин пользователя Windows, wbrkpw - пароль от него.
Затем,уже в интерфейсе создаём внутри ноды интеграционный сервер через щелчок правой кнопкой мыши на ноде -> New Integration Server. В итоге должно выглядеть так:
Чтобы задеплоить приложение, его необходимо запаковать в BAR. Для этого жмём правой кнопкой мыши на приложении -> New -> BAR file. Как Container выбираем само приложение, имя ставим какое угодно:
Далее жмём на барник и выбираем внутри него приложение, которое хотим задеплоить:
Далее надо сбилдить барник, для этого жмём кнопку “Build and Save…”.
Деплоим на интеграционный сервер, для этого жмём правой кнопкой мыши на Incrementntreger.bar -> Deploy и выбираем нужный сервер. Также можно просто перенести барник мышкой на нужный интеграционный сервер, через Drag n Drop.
Для того, чтобы протестировать приложение, надо сначала найти, какой http порт использует нода. Существует два типа http listener - на всю ноду и встроенный в интеграционный сервер. По умолчанию для http запросов используется первый. Чтобы узнать, какой именно порт используется, в Integration Console вбиваем команду:
`mqsireportproperties IB10NODE -b httplistener -o HTTPListener -r`
Порт находится в параметре HTTPListener->HTTPConnector->ListenerPort
Проверяем в SoapUI:
Готово! В следующий раз опишу обработку исключений и логирование в IIB. | https://habr.com/ru/post/578234/ | null | ru | null |
# Мобильные устройства изнутри. Изменение разметки памяти планшета
Изменение разметки памяти планшета
----------------------------------
**ОГЛАВЛЕНИЕ**[1.Введение.](#1)
[2.Планирование изменений разметки памяти.](#2)
[3.Внесение изменений в прошивку планшета.](#3)
[3.1.Внесение изменений в GPT-файл.](#31)
[3.2.Прошивка GPT-файла в МУ.](#32)
[4.Проверка результатов проделанной работы.](#4)
[5.Заключение.](#5)
[6.Источники информации.](#6)
1.Введение.
-----------
Как-то попался мне в руки планшет **YB1-X90L** от **Lenovo**, выполненный на чипе от **Intel**:
**Рис.1**. Планшет YB1-X90
Я попытался выполнить над ним некоторые, в принципе, я бы сказал, стандартные модификации для мобильного устройства (МУ), попавшего в руки разработчика:
* разблокировать загрузчик;
* установить custom recovery;
* получить ROOT;
* посмотреть разметку памяти;
* ну и общие исследования возможностей работы.
Все пункты плана были успешно выполнены. Одним из незапланированных пунктов стало исследование раздела разметки, который я назвал **GPT-разделом Intel-типа**.
Тем не менее, на многих сайтах очень популярна тема по изменению разметки **МУ**, выполненной по **GPT**-схеме, тем более, если это **GPT**-раздел [Intel-типа](https://habrahabr.ru/post/347738/). Получается, что этот вопрос, несмотря на теоретические выкладки, так и остается до сих пор не закрытым… Вот я и решил воспользоваться моментом, что у меня на руках имеется свободное **МУ**, которое можно немного «помучать», и провести натурные испытания своих теоретических познаний. Короче, я задумал изменить разметку памяти…
Перед началом выполнения работ я снял все, что можно по существующей разметке: файлы **partitions**, **dev/block/by-name/** и образ **GPT**-раздела.
Что мы имеем:
* планшет, имеющий [стоковую прошивку](https://forum.xda-developers.com/showpost.php?p=71040707&postcount=2);
* образ **GPT**-раздела **Intel**-типа;
* файл partitions, снятый с реально работающего **МУ**.
Что надо: для своих экспериментов мне понадобился отдельный раздел памяти размером 512Мб.
Соответственно, для его размещения нужно где-то в памяти планшета найти эти мегабайты…
2.Планирование изменений разметки памяти.
-----------------------------------------
Давайте внимательно рассмотрим файл **partitions**:
```
major minor #blocks name
179 0 30535680 mmcblk0
179 1 102400 mmcblk0p1
179 2 102400 mmcblk0p2
179 3 30720 mmcblk0p3
179 4 30720 mmcblk0p4
179 5 1024 mmcblk0p5
179 6 16384 mmcblk0p6
179 7 1024 mmcblk0p7
179 8 1024 mmcblk0p8
179 9 8192 mmcblk0p9
179 10 10240 mmcblk0p10
179 11 1048576 mmcblk0p11
179 12 262144 mmcblk0p12
179 13 3932160 mmcblk0p13
179 14 24986624 mmcblk0p14
179 48 4096 mmcblk0rpmb
179 32 4096 mmcblk0boot1
179 16 4096 mmcblk0boot0
179 64 1927168 mmcblk1
179 65 1927160 mmcblk1p1
```
«Кандидатами» на «урезание» из-за своих размеров могут быть, например, три раздела: **android\_country** (**mmcblk0p11**), **android\_data** (**mmcblk0p14**) и **android\_system** (**mmcblk0p13**). Они, как правило, имеют размер раздела гораздо больше, чем образ, заливаемый в них, что и позволило бы мне беспрепятственно выделить память под новый раздел. Однако не забывайте, что изменение размеров разделов, соответственно и смещений расположения разделов, потребует возни с восстановлением данных этих разделов, т.е. их резервного сохранения и последующего восстановления… Поэтому проще «откусить» свободное место от раздела data, т.к. он расположен последним. Это позволит нам избежать выполнения пересчета размеров затронутых разделов памяти и восстанавливать придется только один раздел.
Таким образом, нам нужно только добавить новый раздел между разделом **android\_system** и разделом **android\_data**. Этот раздел назовем **win\_tools**, а размер зададим 512Мб. Все параметры нового раздела сведены в таблицу:
```
Табл.1.Параметры нового раздела
====================================================
| № | Смещение | Имя | Значение поля |
| п/п | поля | поля | |
|====================================================|
| 1 | 0x00 | Size | 0x200 |
| 2 | 0x04 | Label | win_tools |
| 3 | 0x4C | GuidType | Оставим прежний |
| 4 | 0x5C | GuidPartition | Оставим прежний |
====================================================
```
3.Внесение изменений в прошивку планшета.
-----------------------------------------
Нам повезло, т.к. если бы **GPT**-раздел был стандартным, то пришлось бы изменять оба раздела: основной и резервный. А так только меняем один **GPT**-раздел **Intel**-типа. Приступаем…
### 3.1.Внесение изменений в GPT-файл.
Сначала внесем изменения непосредственно в **GPT**-файл, хранящий образ GPT-раздела прошивки планшета. Для этого берем из стоковой прошивки файл **gpt.bin** и:
1. Загружаем его в hex-редактор:
**Рис.2. Файл GPT-раздела Intel-типа**
2. Находим запись о разделе **android\_system** и копируем ее полностью в качестве шаблона нового раздела:
**Рис.3. Запись о разделе system**
3. Переходим на начало записи о следующем разделе, т.е. **android\_data**, и вставляем шаблон:
**Рис.4. Добавление записи о новом разделе**
4. Новая запись должна содержать описание нового раздела, возьмем значения параметров описания из табл.1 и заполним поля **Size** (было **0x00000F00**, станет **0x00000200**), **Label** (было **android\_system**, станет **win\_tools**) нового раздела. Все внесенные изменения отмечены красным цветом на рисунке:
**Рис.5. Заполнение полей записи о новом разделе**
5. Переходим на заголовок **GPT**-раздела и внесем изменения в поле **Number** (Число записей о разделах) (смещение **0х08** заголовка). В поле было число **0х000E** (14 разделов), мы запишем туда число **0x000F** (станет 15 разделов), на рисунке ниже оно выделено красным цветом:
**Рис.6. Новое число записей в заголовке GPT-раздела**
6. Сохраняем обновленный файл **GPT**-раздела Intel-типа.
Все, раздел разметки изменили, теперь нужно его поместить в планшет.
### 3.2.Прошивка GPT-файла в МУ.
Т.к. мы решили переместить начало раздела **android\_data**, то, чтобы потом найти данные там сохраненные, выполним backup раздела. После этого можно смело менять разметку памяти…
Прошивка любых образов разделов, снятие/установка блокировки загрузчика и т.п. действия выполняются при помощи флешера фирмы **Intel** **PhoneFlashTools**. Причем использовать нужно тот, версия которого поддерживает Ваше МУ. Исследуемый планшет нужно «препарировать» версией 5.3.2.0. Дополнительным условием для успешного проведения операции является наличие json-файла, управляющего процессом выполнения. С версией флешера разобраться легко, а вот json\_файл пришлось писать самому, т.к. изменять разметку, похоже, еще никто не пробовал.
> **ВНИМАНИЕ!** Перед выполнением любых работ по изменению разметки памяти ОБЯЗАТЕЛЬНО выполните резервное копирование всех разделов памяти.
>
>
>
> Дело в том, что переразметка физически затрагивает только один раздел — раздел разметки. Все Ваши данные, система, IMEI сохраняются на прежних местах. Только МЕНЯЮТСЯ указатели на эти места, которые и хранятся в разделе разметки. Это приводит к тому, что Вы средствами МУ (операционной системой) просто не сможете попасть в места хранения информации.
>
>
4.Проверка результатов проделанной работы.
------------------------------------------
После выполнения работ я снял всю информацию по новой разметке: файлы **partitions** и образ нового GPT-раздела.
Посмотрим содержимое partitions:
```
major minor #blocks name
7 0 65536 loop0
179 0 30535680 mmcblk0
179 1 102400 mmcblk0p1
179 2 102400 mmcblk0p2
179 3 30720 mmcblk0p3
179 4 30720 mmcblk0p4
179 5 1024 mmcblk0p5
179 6 16384 mmcblk0p6
179 7 1024 mmcblk0p7
179 8 1024 mmcblk0p8
179 9 8192 mmcblk0p9
179 10 10240 mmcblk0p10
179 11 1048576 mmcblk0p11
179 12 262144 mmcblk0p12
179 13 3932160 mmcblk0p13
179 14 524288 mmcblk0p14
179 15 24462336 mmcblk0p15
179 48 4096 mmcblk0rpmb
179 32 4096 mmcblk0boot1
179 16 4096 mmcblk0boot0
179 64 1927168 mmcblk1
179 65 1927160 mmcblk1p1
```
Теперь можно сравнить, что было и что стало, с разметкой:
```
===========================================================================
| Было | Стало |
|=====================================|=====================================|
|major minor #blocks name |major minor #blocks name |
|=====================================|=====================================|
| 179 13 3932160 mmcblk0p13 | 179 13 3932160 mmcblk0p13 |
| 179 14 24986624 mmcblk0p14 | 179 14 524288 mmcblk0p14 |
| 179 48 4096 mmcblk0rpmb | 179 15 24462336 mmcblk0p15 |
| | 179 48 4096 mmcblk0rpmb |
===========================================================================
```
Видно, что раздел **mmcblk0p14** размером **24986624** переместился на строчку ниже, уменьшился до размера **24462336** и стал теперь разделом **mmcblk0p15**, а на его месте появился новый раздел **mmcblk0p14** размером **524288**.
Ну и сравним содержимое образов GPT-разделов до и после переразметки. Вот заголовок стокового GPT-раздела:
**Рис.7а. Заголовок стокового образа GPT-раздела**
Вот записи о промежутке разделов system — data этого же образа:
**Рис.7б. Записи о разделах стокового образа GPT-раздела**
А вот заголовок GPT-раздела после переразметки:
**Рис.8а. Заголовок нового GPT-раздела**
Вот записи о том же промежутке разделов system — data GPT-раздела после переразметки:
**Рис.8б. Записи о разделах нового образа GPT-раздела**
Все говорит за то, что раздел действительно существует, кстати, а вот список разделов, снятый из папки **/dev/block/by-name** при помощи **Total Commander**:
**Рис.9**. Список образов разделов МУ
5.Заключение.
-------------
Те, кто внимательно почитали публикацию, поняли, что вносить изменения чисто в разметку памяти совсем несложно, а если учесть, что для этих целей существуют и специализированные редакторы…
Гораздо больше проблем возникает при занесении этой разметки внутрь **МУ**, хотя это уже материал для другой публикации…
6.Источники информации.
-----------------------
[1.Мобильные устройства изнутри. Что такое GPT?](https://habrahabr.ru/post/347738/)
[2.Стоковая прошивка YB1-X90L.](https://forum.xda-developers.com/showpost.php?p=71040707&postcount=2)
[3.Строение GPT-раздела.](https://habrahabr.ru/post/346144/)
[4.«Что такое GPT?»](http://lenovo-forums.ru/topic/9111-razmetka-pamyati-mobilnyh-ustroystv/#comment-253681) | https://habr.com/ru/post/347920/ | null | ru | null |
# Использование DiagnosticSource в .NET Core: теория
DiagnosticSource — это простой, но весьма полезный набор API (доступен в NuGet пакете [System.Diagnostics.DiagnosticSource](https://www.nuget.org/packages/System.Diagnostics.DiagnosticSource/)), который, с одной стороны, позволяет различным библиотекам отправлять именованные события о своей работе, а с другой — позволяет приложениям подписываться на эти события и обрабатывать их.
Каждое такое событие содержит дополнительную информацию (payload), а поскольку обработка событий происходит в том же процессе, что и отправка, эта информация может содержать практически любые объекты без необходимости сериализации/десереализации.
DiagnosticSource уже используется в AspNetCore, EntityFrameworkCore, HttpClient и SqlClient, что фактически даёт разработчикам возможность перехватывать входящие/исходящие http запросы, запросы к базам данных, получать доступ к таким объектам, как `HttpContext`, `DbConnection`, `DbCommand`, `HttpRequestMessage` и многим другим и даже изменять эти объекты при необходимости.
Я решил разделить свой рассказ про DiagnosticSource на две статьи. В этой статье мы на простом примере разберем принцип работы механизма, а в [следующей](https://habr.com/ru/company/ozontech/blog/221037/) я расскажу о существующих в .NET событиях, которые можно обрабатывать с его помощью и покажу несколько примеров его использования в OZON.ru.
Пример
------
Чтобы лучше понять, как работает DiagnosticSource, рассмотрим небольшой пример c перехватом запросов к базе данных. Представим, что у нас есть простое консольное приложение, которое делает запрос в базу данных и выводит полученный результат в консоль.
```
public static class Program
{
public const string ConnectionString =
@"Data Source=localhost;Initial Catalog=master;User ID=sa;Password=Password12!;";
public static async Task Main()
{
var answer = await GetAnswerAsync();
Console.WriteLine(answer);
}
public static async Task GetAnswerAsync()
{
using (var connection = new SqlConnection(ConnectionString))
{
// using Dapper
return await connection.QuerySingleAsync("SELECT 42;");
}
}
}
```
Для простоты я поднял SQL Server в docker контейнере.
**docker run**
```
docker run --rm --detach --name mssql-server \
--publish 1433:1433 \
--env ACCEPT_EULA=Y \
--env SA_PASSWORD=Password12! \
mcr.microsoft.com/mssql/server:2017-latest
```
Теперь представим, что у нас есть задача: нужно измерить время выполнения всех запросов в базу данных с помощью `Stopwatch` и вывести в консоль пары "Запрос" — "Время выполнения".
Конечно, можно просто обернуть вызов `QuerySingleAsync` кодом, который создаст и запустит экземпляр `Stopwatch`, остановит его после выполнения запроса и выведет результат, но тут возникает сразу несколько сложностей:
* Что если в приложении не один запрос, а значительно больше?
* Что если код, который выполняет запрос уже скомпилирован, подключен к приложению в виде NuGet пакета, и у нас нет возможности изменить его?
* Что если запрос в базу данных делается не через Dapper, а например через EntityFramework, и у нас нет доступа ни к объекту `DbCommand`, ни к сгенерированному тексту запроса, который реально будет выполняться?
Попробуем решить эту задачу с использованием DiagnosticSource.
### Использование NuGet пакета System.Diagnostics.DiagnosticSource
Первое, что нужно сделать после подключения NuGet пакета [System.Diagnostics.DiagnosticSource](https://www.nuget.org/packages/System.Diagnostics.DiagnosticSource/) — создать класс, который будет обрабатывать интересующие нас события:
```
public sealed class ExampleDiagnosticObserver
{ }
```
Для того, чтобы начать обрабатывать события, нужно создать экземпляр данного класса и зарегистрировать его наблюдателем в статическом объекте `DiagnosticListener.AllListeners` (находится в пространстве имён `System.Diagnostics`). Сделаем это в самом начале функции `Main`:
```
public static async Task Main()
{
var observer = new ExampleDiagnosticObserver();
IDisposable subscription = DiagnosticListener.AllListeners.Subscribe(observer);
var answer = await GetAnswerAsync();
Console.WriteLine(answer);
}
```
При этом компилятор справедливо скажет нам, что класс `ExampleDiagnosticObserver` должен реализовывать интерфейс `IObserver`. Давайте реализуем его:
```
public sealed class ExampleDiagnosticObserver : IObserver
{
void IObserver.OnNext(DiagnosticListener diagnosticListener)
{
Console.WriteLine(diagnosticListener.Name);
}
void IObserver.OnError(Exception error)
{ }
void IObserver.OnCompleted()
{ }
}
```
Если мы сейчас запустим этот код, то увидим, что в консоль будет выведено следующее:
```
SqlClientDiagnosticListener
SqlClientDiagnosticListener
42
```
Это означает, что где-то в .NET зарегестрировано два объекта типа `DiagnosticListener` с названием `"SqlClientDiagnosticListener"` которые сработали при выполнении этого кода.
**Вот они на github.com**На самом деле их три, но поскольку мы не использовали `SqlTransaction`, сработало только два:
* <https://github.com/dotnet/corefx/blob/v2.2.1/src/System.Data.SqlClient/src/System/Data/SqlClient/SqlConnection.cs#L50>
* <https://github.com/dotnet/corefx/blob/v2.2.1/src/System.Data.SqlClient/src/System/Data/SqlClient/SqlCommand.cs#L31>
* <https://github.com/dotnet/corefx/blob/v2.2.1/src/System.Data.SqlClient/src/System/Data/SqlClient/SqlTransaction.cs#L16>
Метод `IObserver.OnNext` будет вызываться **один раз при первом использовании** для каждого экземпляра `DiagnosticListener` который создан в приложении (обычно они создаются как статические свойства). Сейчас мы просто вывели в консоль название экземпляров `DiagnosticListener`, но на практике в этом методе необходимо проверить это название и, если нам интересно обрабатывать события от этого экземпляра, подписаться на него с использованием метода `Subscribe`.
Также хочу отметить, что при вызове `DiagnosticListener.AllListeners.Subscribe` мы в качестве результата получим объект `subscription`, который реализует интерфейс `IDisposable`. Вызов метода `Dispose` у этого объекта приведёт к отписке, которую надо реализовать в методе `IObserver.OnCompleted`.
Давайте реализуем`IObserver` ещё раз:
```
public sealed class ExampleDiagnosticObserver : IObserver
{
private readonly List \_subscriptions = new List();
void IObserver.OnNext(DiagnosticListener diagnosticListener)
{
if (diagnosticListener.Name == "SqlClientDiagnosticListener")
{
var subscription = diagnosticListener.Subscribe(this);
\_subscriptions.Add(subscription);
}
}
void IObserver.OnError(Exception error)
{ }
void IObserver.OnCompleted()
{
\_subscriptions.ForEach(x => x.Dispose());
\_subscriptions.Clear();
}
}
```
Теперь компилятор скажет нам, что наш класс `ExampleDiagnosticObserver` должен так же реализовывать интерфейс `IObserver>`. Здесь нам необходимо реализовать метод `IObserver>.OnNext`, который в качесте параметра принимает `KeyValuePair`, где ключём является название события, а значением анонимный объект (обычно) с произвольными параметрами, которые мы можем использовать по своему усмотрению. Давайте добавим реализацию этого интерфекса:
```
public sealed class ExampleDiagnosticObserver :
IObserver,
IObserver>
{
// IObserver implementation
// ...
void IObserver>.OnNext(KeyValuePair pair)
{
Write(pair.Key, pair.Value);
}
void IObserver>.OnError(Exception error)
{ }
void IObserver>.OnCompleted()
{ }
private void Write(string name, object value)
{
Console.WriteLine(name);
Console.WriteLine(value);
Console.WriteLine();
}
}
```
Если мы теперь запустим полученный код, то в консоль будет выведено примерно следующее:
```
System.Data.SqlClient.WriteConnectionOpenBefore
{ OperationId = 3da1b5d4-9ce1-4f28-b1ff-6a5bfc9d64b8, Operation = OpenAsync, Connection = System.Data.SqlClient.SqlConnection, Timestamp = 26978341062 }
System.Data.SqlClient.WriteConnectionOpenAfter
{ OperationId = 3da1b5d4-9ce1-4f28-b1ff-6a5bfc9d64b8, Operation = OpenAsync, ConnectionId = 84bd0095-9831-456b-8ebc-cb9dc2017368, Connection = System.Data.SqlClient.SqlConnection,
Statistics = System.Data.SqlClient.SqlStatistics+StatisticsDictionary, Timestamp = 26978631500 }
System.Data.SqlClient.WriteCommandBefore
{ OperationId = 5c6d300c-bc49-4f80-9211-693fa1e2497c, Operation = ExecuteReaderAsync, ConnectionId = 84bd0095-9831-456b-8ebc-cb9dc2017368, Command = System.Data.SqlClient.SqlComman
d }
System.Data.SqlClient.WriteCommandAfter
{ OperationId = 5c6d300c-bc49-4f80-9211-693fa1e2497c, Operation = ExecuteReaderAsync, ConnectionId = 84bd0095-9831-456b-8ebc-cb9dc2017368, Command = System.Data.SqlClient.SqlComman
d, Statistics = System.Data.SqlClient.SqlStatistics+StatisticsDictionary, Timestamp = 26978709490 }
System.Data.SqlClient.WriteConnectionCloseBefore
{ OperationId = 3f6bfd8f-e5f6-48b7-82c7-41aeab881142, Operation = Close, ConnectionId = 84bd0095-9831-456b-8ebc-cb9dc2017368, Connection = System.Data.SqlClient.SqlConnection, Stat
istics = System.Data.SqlClient.SqlStatistics+StatisticsDictionary, Timestamp = 26978760625 }
System.Data.SqlClient.WriteConnectionCloseAfter
{ OperationId = 3f6bfd8f-e5f6-48b7-82c7-41aeab881142, Operation = Close, ConnectionId = 84bd0095-9831-456b-8ebc-cb9dc2017368, Connection = System.Data.SqlClient.SqlConnection, Stat
istics = System.Data.SqlClient.SqlStatistics+StatisticsDictionary, Timestamp = 26978772888 }
42
```
Всего мы увидим шесть событий. Два из них выполняются до и после открытия подключения к базе данных, два — до и после выполнения команды и ещё два — до и после закрытия подключения к базе данных.
Каждое событие содержит набор параметров, таких как `OperationId`, `ConnectionId`, `Connection`, `Command`, которые обычно передаются как свойства анонимного объекта. Получить типизированные значения этих свойств можно, например, с помощью reflection. (На практике использование reflection может быть не очень желательно. Мы для получения параметров событий используем DynamicMethod.)
Теперь у нас всё готово, чтобы решить изначальную задачу — измерить время выполнения всех запросов в базу данных и вывести его в консоль вместе с исходным запросом.
Изменим реализацию метода `Write` следующим образом:
```
public sealed class ExampleDiagnosticObserver :
IObserver,
IObserver>
{
// IObserver implementation
// ...
// IObserver> implementation
// ...
private readonly AsyncLocal \_stopwatch = new AsyncLocal();
private void Write(string name, object value)
{
switch (name)
{
case "System.Data.SqlClient.WriteCommandBefore":
{
// Этот код будет выполняться до выполнения запроса в базу данных
\_stopwatch.Value = Stopwatch.StartNew();
break;
}
case "System.Data.SqlClient.WriteCommandAfter":
{
// Этот код будет выполняться после выполнения запроса в базу данных
var stopwatch = \_stopwatch.Value;
stopwatch.Stop();
var command = GetProperty(value, "Command");
Console.WriteLine($"CommandText: {command.CommandText}");
Console.WriteLine($"Elapsed: {stopwatch.Elapsed}");
Console.WriteLine();
break;
}
}
}
private static T GetProperty(object value, string name)
{
return (T) value.GetType()
.GetProperty(name)
.GetValue(value);
}
}
```
Здесь мы перехватываем события начала и окончания запроса в базу данных. Перед выполнением запроса мы создаём и запускаем секундомер, сохраняя его в переменной типа `AsyncLocal`, чтобы позже получить его обратно. После выполнения запроса мы получаем ранее запущенный секундомер, останавливаем его, получаем выполненную команду из параметра `value` через reflection и выводим полученный результат в консоль.
Если мы теперь запустим полученный код, то в консоль будет выведено примерно следующее:
```
CommandText: SELECT 42;
Elapsed: 00:00:00.0341357
42
```
Казалось бы, что мы уже решили нашу задачу, но осталась одна маленькая деталь. Дело в том, что когда мы подписываемся на события `DiagnosticListener` мы начинаем получать от него даже те события, которые нам не интересны, а поскольку при отправке каждого события создаётся анонимный объект с параметрами, это может создавать лишнюю нагрузку на GC.
Чтобы избежать этой ситуации и сообщить, какие именно события от `DiagnosticListener` мы собираемся обрабатывать, мы можем при подписке указать специальный делегат типа `Predicate` который в качестве параметра принимает название события и возвращает `true`, если это событие должно быть обработано.
Немного изменим метод `IObserver.OnNext` в нашем классе:
```
void IObserver.OnNext(DiagnosticListener diagnosticListener)
{
if (diagnosticListener.Name == "SqlClientDiagnosticListener")
{
var subscription = diagnosticListener.Subscribe(this, IsEnabled);
\_subscriptions.Add(subscription);
}
}
private bool IsEnabled(string name)
{
return name == "System.Data.SqlClient.WriteCommandBefore"
|| name == "System.Data.SqlClient.WriteCommandAfter";
}
```
Теперь наш метод `Write` будет вызываться только для событий `"System.Data.SqlClient.WriteCommandBefore"` и `"System.Data.SqlClient.WriteCommandAfter"`.
### Использование NuGet пакета Microsoft.Extensions.DiagnosticAdapter
Поскольку параметры события, которые мы получаем от `DiagnosticListener`, обычно передаются в виде анонимного объекта, извлекать их через reflection может быть слишком затратно. К счастью, существует NuGet пакет [Microsoft.Extensions.DiagnosticAdapter](https://www.nuget.org/packages/Microsoft.Extensions.DiagnosticAdapter/), который может сделать это за нас, используя runtime кодогенерацию из пространства имён `System.Reflection.Emit`.
Для того, чтобы использовать этот пакет при подписке на события от экземпляра `DiagnosticListener` вместо метода `Subscribe` необходимо использовать метод-расширение `SubscribeWithAdapter`. Реализовывать интерфейс `IObserver>` в этом случае больше не требуется. Вместо этого для каждого события, которое мы хотим обрабатывать нам необходимо оъявить отдельный метод, пометив его атрибутом `DiagnosticNameAttribute` (из пространства имён `Microsoft.Extensions.DiagnosticAdapter`). Параметрами этих методов будут параметры обрабатываемого события.
Если мы перепишем наш класс `ExampleDiagnosticObserver` с использованием данного NuGet пакета, то получим следующий код:
```
public sealed class ExampleDiagnosticObserver : IObserver
{
private readonly List \_subscriptions = new List();
void IObserver.OnNext(DiagnosticListener diagnosticListener)
{
if (diagnosticListener.Name == "SqlClientDiagnosticListener")
{
var subscription = diagnosticListener.SubscribeWithAdapter(this);
\_subscriptions.Add(subscription);
}
}
void IObserver.OnError(Exception error)
{ }
void IObserver.OnCompleted()
{
\_subscriptions.ForEach(x => x.Dispose());
\_subscriptions.Clear();
}
private readonly AsyncLocal \_stopwatch = new AsyncLocal();
[DiagnosticName("System.Data.SqlClient.WriteCommandBefore")]
public void OnCommandBefore()
{
\_stopwatch.Value = Stopwatch.StartNew();
}
[DiagnosticName("System.Data.SqlClient.WriteCommandAfter")]
public void OnCommandAfter(DbCommand command)
{
var stopwatch = \_stopwatch.Value;
stopwatch.Stop();
Console.WriteLine($"CommandText: {command.CommandText}");
Console.WriteLine($"Elapsed: {stopwatch.Elapsed}");
Console.WriteLine();
}
}
```
Таким образом мы теперь можем измерить время выполнения всех запросов в базу данных из нашего приложения, практически не изменяя при этом код самого приложения.
Создание собственных экземпляров DiagnosticListener
---------------------------------------------------
При использовании DiagnosticSource на практике вы в большинстве случаев будете подписываться на уже существующие события. Создавать собственные экземпляры `DiagnosticListener` и отправлять собственные события вам скорее всего не придётся (только если вы не разрабатываете какую-нибудь библиотеку), поэтому я не буду долго останавливаться на этом разделе.
Для создания собственного экземпляра `DiagnosticListener` вам необходимо будет объявить его как статическую переменную где-то в коде:
```
private static readonly DiagnosticSource _myDiagnosticSource =
new DiagnosticListener("MyLibraty");
```
После этого для отправки события можно использовать конструкцию вида:
```
if (_myDiagnosticSource.IsEnabled("MyEvent"))
_myDiagnosticSource.Write("MyEvent", new { /* parameters */ });
```
Более подробную информацию о создании собственных экземпляров `DiagnosticListener` можно найти в [DiagnosticSource User's Guide](https://github.com/dotnet/corefx/blob/master/src/System.Diagnostics.DiagnosticSource/src/DiagnosticSourceUsersGuide.md), где подробно описаны Best Practices по использованию DiagnosticSource.
Заключение
----------
Пример, который мы рассмотрели, безусловно, очень абстрактный и вряд ли пригодится в реальном проекте. Но он отлично показывает, как этот механизм можно использовать для мониторинга и диагностики ваших приложений.
В следующей статье я приведу список известных мне событий, которые могут быть обработаны через DiagnosticSource, и покажу несколько практических примеров его использования. | https://habr.com/ru/post/435896/ | null | ru | null |
# Часть 4: Всё-таки запускаем Linux на RocketChip RISC-V
 *На картинке Linux kernel шлёт вам привет через GPIO.*
В этой части истории с портированием RISC-V RocketChip на китайскую плату с Cyclone IV мы всё-таки запустим Linux, а также научимся сами конфигурировать IP Core контроллера памяти и чуть подредактируем dts-описание аппаратуры. Эта статья является продолжением [третьей части](https://habr.com/ru/post/458482/), но, в отличие от изрядно разросшейся предыдущей, она будет довольно короткой.
… Поскольку `setup_smp` вызывается, только если ядро сконфигурировано с поддержкой SMP, можно попробовать отключить многоядерность. Будет неприятно, если мне нужно будет ещё и реализовывать в модуле памяти поддержку атомарности (мне казалось, с этим кеш возится самостоятельно), но в одноядерном случае оно нам помешать не должно.
**Всё равно не взлетело...**
```
[ 0.000000] OF: fdt: Ignoring memory range 0x80000000 - 0x80200000
[ 0.000000] Linux version 4.19.0-sifive-1+ (trosinenko@trosinenko-pc) (gcc version 8.3.0 (Buildroot 2019.02-07449-g4eddd28f99)) #1 Thu Jul 4 18:38:10 MSK 2019
[ 0.000000] bootconsole [early0] enabled
[ 0.000000] Initial ramdisk at: 0x(____ptrval____) (16777216 bytes)
[ 0.000000] Zone ranges:
[ 0.000000] DMA32 [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] Normal [mem 0x00000000c0000000-0x00000bffffffffff]
[ 0.000000] Movable zone start for each node
[ 0.000000] Early memory node ranges
[ 0.000000] node 0: [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] Initmem setup node 0 [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] software IO TLB: mapped [mem 0xbb1fc000-0xbf1fc000] (64MB)
[ 0.000000] Unable to find "cpu" devicetree entry
[ 0.000000] Built 1 zonelists, mobility grouping on. Total pages: 258055
[ 0.000000] Kernel command line: debug console=ttySIF0,125200 root=/dev/mmcblk0p2 loglevel=7 rootwait
[ 0.000000] Dentry cache hash table entries: 131072 (order: 8, 1048576 bytes)
[ 0.000000] Inode-cache hash table entries: 65536 (order: 7, 524288 bytes)
[ 0.000000] Sorting __ex_table...
[ 0.000000] BUG: Bad page state in process swapper pfn:80bf7
[ 0.000000] page:ffffffe03f029e08 count:0 mapcount:-65280 mapping:0000000000000000 index:0x1
[ 0.000000] flags: 0x0()
[ 0.000000] raw: 0000000000000000 0000000000000100 0000000000000200 0000000000000000
[ 0.000000] raw: 0000000000000001 0000000000000000 00000000ffff00ff
[ 0.000000] page dumped because: nonzero mapcount
[ 0.000000] Modules linked in:
[ 0.000000] CPU: 0 PID: 0 Comm: swapper Not tainted 4.19.0-sifive-1+ #1
[ 0.000000] Call Trace:
[ 0.000000] [] walk\_stackframe+0x0/0xa0
[ 0.000000] [] show\_stack+0x2a/0x34
[ 0.000000] [] chachachllachachachTradeonachachach\_inachachipachachachachllachachachTradeonachachachdevachachachypachachachllachachachTradeona+0x20/0x28
[ 0.000000] [] bad\_page+0xe4/0x102
[ 0.000000] [] free\_pages\_check\_bad+0x38/0x7a
[ 0.000000] [] free\_pcppages\_bulk+0x106/0x36c
[ 0.000000] [] free\_unref\_page\_commit.isra.23+0x86/0x8e
[ 0.000000] [] free\_unref\_page+0x44/0x58
[ 0.000000] [] \_\_free\_pages.part.28+0xe/0x22
[ 0.000000] [] \_\_free\_pages\_bootmem+0x86/0x90
[ 0.000000] [] free\_all\_bootmem+0x156/0x1ba
[ 0.000000] [] mem\_init+0x36/0x44
[ 0.000000] [] start\_kernel+0x1aa/0x328
[ 0.000000] [] \_sinittext+0x58/0x5c
[ 0.000000] Disabling lock debugging due to kernel taint
[ 0.000000] BUG: Bad page state in process swapper pfn:80bf9
[ 0.000000] page:ffffffe03f029e78 count:0 mapcount:-65280 mapping:0000000000000000 index:0x0
[ 0.000000] flags: 0x0()
[ 0.000000] raw: 0000000000000000 ffffffe03f020080 ffffffe03f020080 0000000000000000
[ 0.000000] raw: 0000000000000000 0000000000000000 00000000ffff00ff
[ 0.000000] page dumped because: nonzero mapcount
[ 0.000000] Modules linked in:
[ 0.000000] CPU: 0 PID: 0 Comm: swapper Tainted: G B 4.19.0-sifive-1+ #1
[ 0.000000] Call Trace:
[ 0.000000] [] walk\_stackframe+0x0/0xa0
[ 0.000000] [] show\_stack+0x2a/0x34
[ 0.000000] [] chachachllachachachTradeonachachach\_inachachipachachachachllachachachTradeonachachachdevachachachypachachachllachachachTradeona+0x20/0x28
[ 0.000000] [] bad\_page+0xe4/0x102
[ 0.000000] [] free\_pages\_check\_bad+0x38/0x7a
[ 0.000000] [] \_\_free\_pages\_ok+0x3fe/0x430
[ 0.000000] [] \_\_free\_pages.part.28+0x1a/0x22
[ 0.000000] [] \_\_free\_pages\_bootmem+0x86/0x90
[ 0.000000] [] free\_all\_bootmem+0x156/0x1ba
[ 0.000000] [] mem\_init+0x36/0x44
[ 0.000000] [] start\_kernel+0x1aa/0x328
[ 0.000000] [] \_sinittext+0x58/0x5c
[ 0.000000] BUG: Bad page state in process swapper pfn:80bfa
[ 0.000000] page:ffffffe03f029eb0 count:0 mapcount:-65280 mapping:0000000000000000 index:0x0
[ 0.000000] flags: 0x0()
[ 0.000000] raw: 0000000000000000 ffffffe03f0200b8 ffffffe03f0200b8 0000000000000000
[ 0.000000] raw: 0000000000000000 0000000000000000 00000000ffff00ff
[ 0.000000] page dumped because: nonzero mapcount
[ 0.000000] Modules linked in:
[ 0.000000] CPU: 0 PID: 0 Comm: swapper Tainted: G B 4.19.0-sifive-1+ #1
[ 0.000000] Call Trace:
[ 0.000000] [] walk\_stackframe+0x0/0xa0
[ 0.000000] [] show\_stack+0x2a/0x34
[ 0.000000] [] chachachllachachachTradeonachachach\_inachachipachachachachllachachachTradeonachachachdevachachachypachachachllachachachTradeona+0x20/0x28
[ 0.000000] [] bad\_page+0xe4/0x102
[ 0.000000] [] free\_pages\_check\_bad+0x38/0x7a
[ 0.000000] [] \_\_free\_pages\_ok+0x3fe/0x430
[ 0.000000] [] \_\_free\_pages.part.28+0x1a/0x22
[ 0.000000] [] \_\_free\_pages\_bootmem+0x86/0x90
[ 0.000000] [] free\_all\_bootmem+0x156/0x1ba
[ 0.000000] [] mem\_init+0x36/0x44
[ 0.000000] [] start\_kernel+0x1aa/0x328
[ 0.000000] [] \_sinittext+0x58/0x5c
[ 0.000000] BUG: Bad page state in process swapper pfn:80bfb
[ 0.000000] page:ffffffe03f029ee8 count:0 mapcount:-65280 mapping:0000000000000000 index:0x0
[ 0.000000] flags: 0x0()
[ 0.000000] raw: 0000000000000000 ffffffe03f0200f0 ffffffe03f0200f0 0000000000000000
[ 0.000000] raw: 0000000000000000 0000000000000000 00000000ffff00ff
[ 0.000000] page dumped because: nonzero mapcount
[ 0.000000] Modules linked in:
[ 0.000000] CPU: 0 PID: 0 Comm: swapper Tainted: G B 4.19.0-sifive-1+ #1
[ 0.000000] Call Trace:
[ 0.000000] [] walk\_stackframe+0x0/0xa0
[ 0.000000] [] show\_stack+0x2a/0x34
[ 0.000000] [] chachachllachachachTradeonachachach\_inachachipachachachachllachachachTradeonachachachdevachachachypachachachllachachachTradeona+0x20/0x28
[ 0.000000] [] bad\_page+0xe4/0x102
[ 0.000000] [] free\_pages\_check\_bad+0x38/0x7a
[ 0.000000] [] \_\_free\_pages\_ok+0x3fe/0x430
[ 0.000000] [] \_\_free\_pages.part.28+0x1a/0x22
[ 0.000000] [] \_\_free\_pages\_bootmem+0x86/0x90
[ 0.000000] [] free\_all\_bootmem+0x156/0x1ba
[ 0.000000] [] mem\_init+0x36/0x44
[ 0.000000] [] start\_kernel+0x1aa/0x328
[ 0.000000] [] \_sinittext+0x58/0x5c
[ 0.000000] BUG: Bad page state in process swapper pfn:80bfc
[ 0.000000] page:ffffffe03f029f20 count:0 mapcount:-65280 mapping:0000000000000000 index:0x0
[ 0.000000] flags: 0x0()
[ 0.000000] raw: 0000000000000000 ffffffe03f020028 ffffffe03f020028 0000000000000000
[ 0.000000] raw: 0000000000000000 0000000000000000 00000000ffff00ff
...
```
Занятно, что после всей отладки я решил посмотреть, как должен выглядеть «референсный» вывод ядра, сказал `make qemu`, и увидел аналогичную ошибку.
Увы, следующий уровень (Linux kernel) сложнее: GDB, подключённый через JTAG к RocketChip, работает, по-видимому, с физическими адресами вне зависимости от того, как настроено MMU, а ядро в интересующий нас момент уже настроило отображение адресов, поэтому просто сказать `display/10i $pc` не получится — увидим лишь много `unimp`. Зато, если мы уже выяснили смещение (похоже, что `0x80200000 -> 0xffffffe000000000`), то можно схитрить:
```
1: x/10i $pc
=> 0xffffffe000002436 : unimp
0xffffffe000002438 : unimp
0xffffffe00000243a : unimp
0xffffffe00000243c : unimp
0xffffffe00000243e : unimp
0xffffffe000002440 : unimp
0xffffffe000002442 : unimp
0xffffffe000002444 : unimp
0xffffffe000002446 : unimp
0xffffffe000002448 : unimp
(gdb) undisplay 1
(gdb) display/10i ($pc - 0xffffffe000002436 + 0x80202436)
2: x/10i ($pc - 0xffffffe000002436 + 0x80202436)
0x80202436: addi sp,sp,-96
0x80202438: sd s0,80(sp)
0x8020243a: sd s1,72(sp)
0x8020243c: sd s2,64(sp)
0x8020243e: sd s3,56(sp)
0x80202440: sd s4,48(sp)
0x80202442: sd s5,40(sp)
0x80202444: sd s6,32(sp)
0x80202446: sd s7,24(sp)
0x80202448: sd s8,16(sp)
```
Брекпоинты проставляются аналогично:
```
(gdb) p setup_smp
$1 = {} 0xffffffe000002436
(gdb) b \*0x80202436
Breakpoint 1 at 0x80202436
(gdb) c
Continuing.
Program received signal SIGTRAP, Trace/breakpoint trap.
setup\_smp () at /home/trosinenko/freedom-u-sdk/linux/arch/riscv/kernel/smpboot.c:58
58 while ((dn = of\_find\_node\_by\_type(dn, "cpu"))) {
(gdb) bt
#0 setup\_smp () at /home/trosinenko/freedom-u-sdk/linux/arch/riscv/kernel/smpboot.c:58
#1 0xffffffe0000022a2 in setup\_arch () at /home/trosinenko/freedom-u-sdk/linux/arch/riscv/kernel/setup.c:253
#2 0x0000000000000000 in ?? ()
Backtrace stopped: frame did not save the PC
```
Вот только их приходится вручную снимать, чтобы пойти дальше — для GDB это какой-то совершенно непонятный trap. Ах да, если вы случайно скажете `s` или `n` вместо `si`, gdb попытается вставить неявный брекпоинт, который по понятным причинам не выставится, но и отговорить GDB уже никак. Но не спешите перезагружать плату — по моим наблюдениям, достаточно перезапустить только gdb (учтите, что старые breakpoint-ы, возможно, не исчезнут).
Собственно, придётся разбираться с изначальной проблемой: расстановка отладочных `printk` в функцию `of_find_node_by_type`, используемую кодом поиска загрузочного процессорного ядра, показывает, что оно видит какой-то мусор вместо названий типов устройств. Например, оно откуда-то берёт строчку «Serial port», хотя такого явно нет в dtb в поле `device_type`. Поискав эти байты в образе ядра, я их нашёл, посмотрел на смещение, и понял очевидное: размер ядра в параметрах загрузки явно недооценён: ему выделено 8Mb, а занимает оно больше десяти. Выделил 16Mb, но странности не прекратились. После плясок с чтением FDT с разных адресов (штатно адрес передаётся ядру в регистре `a1`), я, наконец, решил трассировать, а что же **сейчас** там парсится. К счастью, вместо хождений с отладчиком (а мы помним, что есть нюансы с трансляцией адресов, которые ещё нужно так или иначе решить), можно просто и костыльно в файле `drivers/of/fdt.c` указать `#define pr_debug printk`. В итоге получилось:
**добавление отладочного вывода**
```
diff --git a/arch/riscv/kernel/setup.c b/arch/riscv/kernel/setup.c
index 3db0d71d128b..fac47df9d1db 100644
--- a/arch/riscv/kernel/setup.c
+++ b/arch/riscv/kernel/setup.c
@@ -173,6 +173,7 @@ asmlinkage void __init setup_vm(void)
void __init parse_dtb(unsigned int hartid, void *dtb)
{
+ printk("HART = %u DTB = %lx\n", hartid, dtb);
early_init_dt_scan(__va(dtb));
}
diff --git a/drivers/of/base.c b/drivers/of/base.c
index 74eaedd5b860..c019e4158e1d 100644
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -940,10 +940,12 @@ struct device_node *of_find_node_by_type(struct device_node *from,
unsigned long flags;
raw_spin_lock_irqsave(&devtree_lock, flags);
- for_each_of_allnodes_from(from, np)
+ for_each_of_allnodes_from(from, np) {
+ printk("%lx %lx [%s] | [%s]\n", from, np, np->type, type);
if (np->type && (of_node_cmp(np->type, type) == 0)
&& of_node_get(np))
break;
+ }
of_node_put(from);
raw_spin_unlock_irqrestore(&devtree_lock, flags);
return np;
diff --git a/drivers/of/fdt.c b/drivers/of/fdt.c
index 800ad252cf9c..2b45870ebada 100644
--- a/drivers/of/fdt.c
+++ b/drivers/of/fdt.c
@@ -31,6 +31,8 @@
#include "of_private.h"
+#define pr_debug printk
+
/*
* of_fdt_limit_memory - limit the number of regions in the /memory node
* @limit: maximum entries
@@ -1253,6 +1255,7 @@ bool __init early_init_dt_scan(void *params)
*/
void __init unflatten_device_tree(void)
{
+ printk("INITIAL: %lx\n", initial_boot_params);
__unflatten_device_tree(initial_boot_params, NULL, &of_root,
early_init_dt_alloc_memory_arch, false);
```
**Вывод на железе**
```
SIFIVE, INC.
5555555555555555555555555
5555 5555
5555 5555
5555 5555
5555 5555555555555555555555
5555 555555555555555555555555
5555 5555
5555 5555
5555 5555
5555555555555555555555555555 55555
55555 555555555 55555
55555 55555 55555
55555 5 55555
55555 55555
55555 55555
55555 55555
55555 55555
55555 55555
555555555
55555
5
SiFive RISC-V Core IP
{
#address-cells = <0x00000001>;
#size-cells = <0x00000001>;
compatible = "freechips,rocketchip-unknown-dev";
model = "freechips,rocketchip-unknown";
chosen {
linux,initrd-start = <0x82000000>;
riscv,kernel-end = <0x81200000>;
riscv,kernel-start = <0x80200000>;
#address-cells = <0x00000001>;
#size-cells = <0x00000000>;
bootargs = <0x64656275 0x6720636f 0x6e736f6c 0x653d7474 0x79534946 0x302c3132 0x35323030 0x20726f6f 0x743d2f64 0x65762f6d 0x6d63626c 0x6b307032 0x206c6f67 0x6c657665 0x6c3d3720 0x726f6f74 0x77616974>;
}
firmware {
sifive,uboot = "YYYY-MM-DD";
}
aliases {
serial0 = <0x2f736f63 0x2f736572 0x69616c40 0x36343030 0x30303030>;
}
cpus {
#address-cells = <0x00000001>;
#size-cells = <0x00000000>;
cpu@0 {
device_type = "cpu";
clock-frequency = <0x00000000>;
compatible = "sifive,rocket0", "riscv";
d-cache-block-size = <0x00000010>;
d-cache-sets = <0x00000040>;
d-cache-size = <0x00001000>;
d-tlb-sets = <0x00000001>;
d-tlb-size = <0x00000020>;
i-cache-block-size = <0x00000010>;
i-cache-sets = <0x00000040>;
i-cache-size = <0x00001000>;
i-tlb-sets = <0x00000001>;
i-tlb-size = <0x00000020>;
mmu-type = "riscv,sv39";
next-level-cache = <0x00000001>;
reg = <0x00000000>;
riscv,isa = "rv64imafdc";
status = "okay";
timebase-frequency = <0x000f4240>;
tlb-split;
interrupt-controller {
#interrupt-cells = <0x00000001>;
compatible = "riscv,cpu-intc";
interrupt-controller;
phandle = <0x00000002>;
}
}
}
ram@80000000 {
device_type = "memory";
reg = <0x80000000 0x40000000>;
reg-names = "mem";
phandle = <0x00000001>;
}
soc {
#address-cells = <0x00000001>;
#size-cells = <0x00000001>;
compatible = "freechips,rocketchip-unknown-soc", "simple-bus";
ranges;
clint@2000000 {
compatible = "riscv,clint0";
interrupts-extended = <0x00000002 0x00000003 0x00000002 0x00000007>;
reg = <0x02000000 0x00010000>;
reg-names = "control";
}
debug-controller@0 {
compatible = "sifive,debug-013", "riscv,debug-013";
interrupts-extended = <0x00000002 0x0000ffff>;
reg = <0x00000000 0x00001000>;
reg-names = "control";
}
gpio@64002000 {
#gpio-cells = <0x00000002>;
#interrupt-cells = <0x00000002>;
compatible = "sifive,gpio0";
gpio-controller;
interrupt-controller;
interrupt-parent = <0x00000003>;
interrupts = <0x00000003 0x00000004 0x00000005 0x00000006 0x00000007 0x00000008>;
reg = <0x64002000 0x00001000>;
reg-names = "control";
}
interrupt-controller@c000000 {
#interrupt-cells = <0x00000001>;
compatible = "riscv,plic0";
interrupt-controller;
interrupts-extended = <0x00000002 0x0000000b 0x00000002 0x00000009>;
reg = <0x0c000000 0x04000000>;
reg-names = "control";
riscv,max-priority = <0x00000007>;
riscv,ndev = <0x00000008>;
phandle = <0x00000003>;
}
rom@10000 {
compatible = "sifive,maskrom0";
reg = <0x00010000 0x00002000>;
reg-names = "mem";
}
serial@64000000 {
compatible = "sifive,uart0";
interrupt-parent = <0x00000003>;
interrupts = <0x00000002>;
reg = <0x64000000 0x00001000>;
reg-names = "control";
}
spi@64001000 {
#address-cells = <0x00000001>;
#size-cells = <0x00000000>;
compatible = "sifive,spi0";
interrupt-parent = <0x00000003>;
interrupts = <0x00000001>;
reg = <0x64001000 0x00001000>;
reg-names = "control";
mmc@0 {
compatible = "mmc-spi-slot";
disable-wp;
reg = <0x00000000>;
spi-max-frequency = <0x01312d00>;
voltage-ranges = <0x00000ce4 0x00000ce4>;
}
}
tlclk {
#clock-cells = <0x00000000>;
clock-frequency = <0x017d7840>;
clock-output-names = "tlclk";
compatible = "fixed-clock";
}
}
}
[ 0.000000] HART = 0 DTB = 81200000
[ 0.000000] search "chosen", depth: 0, uname:
[ 0.000000] search "chosen", depth: 1, uname: chosen
[ 0.000000] Looking for initrd properties...
[ 0.000000] Command line is: debug console=ttySIF0,125200 root=/dev/mmcblk0p2 loglevel=7 rootwait
[ 0.000000] dt_root_size_cells = 1
[ 0.000000] dt_root_addr_cells = 1
[ 0.000000] memory scan node ram@80000000, reg size 8,
[ 0.000000] - 80000000 , 40000000
[ 0.000000] OF: fdt: Ignoring memory range 0x80000000 - 0x80200000
[ 0.000000] Linux version 4.19.0-sifive-1+ (trosinenko@trosinenko-pc) (gcc version 8.3.0 (Buildroot 2019.02-07449-g4eddd28f99)) #1 SMP Sat Jul 6 12:14:41 MSK 2019
[ 0.000000] bootconsole [early0] enabled
[ 0.000000] initrd not found or empty - disabling initrd
[ 0.000000] Zone ranges:
[ 0.000000] DMA32 [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] Normal [mem 0x00000000c0000000-0x00000bffffffffff]
[ 0.000000] Movable zone start for each node
[ 0.000000] Early memory node ranges
[ 0.000000] node 0: [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] Initmem setup node 0 [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] INITIAL: ffffffe001000000
[ 0.000000] -> unflatten_device_tree()
[ 0.000000] Unflattening device tree:
[ 0.000000] magic: d00dfeed
[ 0.000000] size: 00001000
[ 0.000000] version: 00000011
[ 0.000000] size is 13512, allocating...
[ 0.000000] unflattening (____ptrval____)...
[ 0.000000] fixed up name for ->
[ 0.000000] fixed up name for chosen -> chosen
[ 0.000000] fixed up name for firmware -> firmware
[ 0.000000] fixed up name for aliases -> aliases
[ 0.000000] fixed up name for cpus -> cpus
[ 0.000000] fixed up name for cpu@0 -> cpu
[ 0.000000] fixed up name for interrupt-controller -> interrupt-controller
[ 0.000000] fixed up name for ram@80000000 -> ram
[ 0.000000] fixed up name for soc -> soc
[ 0.000000] fixed up name for clint@2000000 -> clint
[ 0.000000] fixed up name for debug-controller@0 -> debug-controller
[ 0.000000] fixed up name for gpio@64002000 -> gpio
[ 0.000000] fixed up name for interrupt-controller@c000000 -> interrupt-controller
[ 0.000000] fixed up name for rom@10000 -> rom
[ 0.000000] fixed up name for serial@64000000 -> serial
[ 0.000000] fixed up name for spi@64001000 -> spi
[ 0.000000] fixed up name for mmc@0 -> mmc
[ 0.000000] fixed up name for tlclk -> tlclk
[ 0.000000] <- unflatten_device_tree()
[ 0.000000] software IO TLB: mapped [mem 0xbb1fc000-0xbf1fc000] (64MB)
[ 0.000000] 0 ffffffe03effcab0 [attach() failed for %s with error %d
[ 0.000000] ] | [cpu]
[ 0.000000] 0 ffffffe03eff0020 [(null)] | [cpu]
```
**Вывод в QEMU**
```
SIFIVE, INC.
5555555555555555555555555
5555 5555
5555 5555
5555 5555
5555 5555555555555555555555
5555 555555555555555555555555
5555 5555
5555 5555
5555 5555
5555555555555555555555555555 55555
55555 555555555 55555
55555 55555 55555
55555 5 55555
55555 55555
55555 55555
55555 55555
55555 55555
55555 55555
555555555
55555
5
SiFive RISC-V Core IP
{
#address-cells = <0x00000002>;
#size-cells = <0x00000002>;
compatible = "riscv-virtio";
model = "riscv-virtio,qemu";
chosen {
linux,initrd-start = <0x00000000 0x88000000>;
linux,initrd-end = <0x00000000 0x88442b86>;
riscv,kernel-start = <0x00000000 0x80200000>;
riscv,kernel-end = <0x00000000 0x80c482ac>;
bootargs = "";
stdout-path = <0x2f756172 0x74403130 0x30303030>;
}
uart@10000000 {
interrupts = <0x0000000a>;
interrupt-parent = <0x00000002>;
clock-frequency = <0x00384000>;
reg = <0x00000000 0x10000000 0x00000000 0x00000100>;
compatible = "ns16550a";
}
test@100000 {
reg = <0x00000000 0x00100000 0x00000000 0x00001000>;
compatible = "sifive,test0";
}
virtio_mmio@10008000 {
interrupts = <0x00000008>;
interrupt-parent = <0x00000002>;
reg = <0x00000000 0x10008000 0x00000000 0x00001000>;
compatible = "virtio,mmio";
}
virtio_mmio@10007000 {
interrupts = <0x00000007>;
interrupt-parent = <0x00000002>;
reg = <0x00000000 0x10007000 0x00000000 0x00001000>;
compatible = "virtio,mmio";
}
virtio_mmio@10006000 {
interrupts = <0x00000006>;
interrupt-parent = <0x00000002>;
reg = <0x00000000 0x10006000 0x00000000 0x00001000>;
compatible = "virtio,mmio";
}
virtio_mmio@10005000 {
interrupts = <0x00000005>;
interrupt-parent = <0x00000002>;
reg = <0x00000000 0x10005000 0x00000000 0x00001000>;
compatible = "virtio,mmio";
}
virtio_mmio@10004000 {
interrupts = <0x00000004>;
interrupt-parent = <0x00000002>;
reg = <0x00000000 0x10004000 0x00000000 0x00001000>;
compatible = "virtio,mmio";
}
virtio_mmio@10003000 {
interrupts = <0x00000003>;
interrupt-parent = <0x00000002>;
reg = <0x00000000 0x10003000 0x00000000 0x00001000>;
compatible = "virtio,mmio";
}
virtio_mmio@10002000 {
interrupts = <0x00000002>;
interrupt-parent = <0x00000002>;
reg = <0x00000000 0x10002000 0x00000000 0x00001000>;
compatible = "virtio,mmio";
}
virtio_mmio@10001000 {
interrupts = <0x00000001>;
interrupt-parent = <0x00000002>;
reg = <0x00000000 0x10001000 0x00000000 0x00001000>;
compatible = "virtio,mmio";
}
cpus {
#address-cells = <0x00000001>;
#size-cells = <0x00000000>;
timebase-frequency = <0x00989680>;
cpu@0 {
device_type = "cpu";
reg = <0x00000000>;
status = "okay";
compatible = "riscv";
riscv,isa = "rv64imafdcsu";
mmu-type = "riscv,sv48";
clock-frequency = <0x3b9aca00>;
interrupt-controller {
#interrupt-cells = <0x00000001>;
interrupt-controller;
compatible = "riscv,cpu-intc";
linux,phandle = <0x00000001>;
phandle = <0x00000001>;
}
}
}
memory@80000000 {
device_type = "memory";
reg = <0x00000000 0x80000000 0x00000000 0x40000000>;
}
soc {
#address-cells = <0x00000002>;
#size-cells = <0x00000002>;
compatible = "simple-bus";
ranges;
pci@30000000 {
interrupt-map-mask = <0x00001800 0x00000000 0x00000000 0x00000007>;
interrupt-map = <0x00000000 0x00000000 0x00000000 0x00000001 0x00000002 0x00000020 0x00000000 0x00000000 0x00000000 0x00000002 0x00000002 0x00000021 0x00000000 0x00000000 0x00000000 0x00000003 0x00000002 0x00000022 0x00000000 0x00000000 0x00000000 0x00000004 0x00000002 0x00000023 0x00000800 0x00000000 0x00000000 0x00000001 0x00000002 0x00000021 0x00000800 0x00000000 0x00000000 0x00000002 0x00000002 0x00000022 0x00000800 0x00000000 0x00000000 0x00000003 0x00000002 0x00000023 0x00000800 0x00000000 0x00000000 0x00000004 0x00000002 0x00000020 0x00001000 0x00000000 0x00000000 0x00000001 0x00000002 0x00000022 0x00001000 0x00000000 0x00000000 0x00000002 0x00000002 0x00000023 0x00001000 0x00000000 0x00000000 0x00000003 0x00000002 0x00000020 0x00001000 0x00000000 0x00000000 0x00000004 0x00000002 0x00000021 0x00001800 0x00000000 0x00000000 0x00000001 0x00000002 0x00000023 0x00001800 0x00000000 0x00000000 0x00000002 0x00000002 0x00000020 0x00001800 0x00000000 0x00000000 0x00000003 0x00000002 0x00000021 0x00001800 0x00000000 0x00000000 0x00000004 0x00000002 0x00000022>;
ranges = <0x01000000 0x00000000 0x00000000 0x00000000 0x03000000 0x00000000 0x00010000 0x02000000 0x00000000 0x40000000 0x00000000 0x40000000 0x00000000 0x40000000>;
reg = <0x00000000 0x30000000 0x00000000 0x10000000>;
dma-coherent;
bus-range = <0x00000000 0x000002ff>;
linux,pci-domain = <0x00000000>;
device_type = "pci";
compatible = "pci-host-ecam-generic";
#size-cells = <0x00000002>;
#interrupt-cells = <0x00000001>;
#address-cells = <0x00000003>;
}
interrupt-controller@c000000 {
linux,phandle = <0x00000002>;
phandle = <0x00000002>;
riscv,ndev = <0x00000035>;
riscv,max-priority = <0x00000007>;
reg-names = "control";
reg = <0x00000000 0x0c000000 0x00000000 0x04000000>;
interrupts-extended = <0x00000001 0x0000000b 0x00000001 0x00000009>;
interrupt-controller;
compatible = "riscv,plic0";
#interrupt-cells = <0x00000001>;
#address-cells = <0x00000000>;
}
clint@2000000 {
interrupts-extended = <0x00000001 0x00000003 0x00000001 0x00000007>;
reg = <0x00000000 0x02000000 0x00000000 0x00010000>;
compatible = "riscv,clint0";
}
}
}
[ 0.000000] HART = 0 DTB = 80e00000
[ 0.000000] search "chosen", depth: 0, uname:
[ 0.000000] search "chosen", depth: 1, uname: chosen
[ 0.000000] Looking for initrd properties...
[ 0.000000] initrd_start=0x88000000 initrd_end=0x88442b86
[ 0.000000] Command line is: earlyprintk
[ 0.000000] dt_root_size_cells = 2
[ 0.000000] dt_root_addr_cells = 2
[ 0.000000] memory scan node memory@80000000, reg size 16,
[ 0.000000] - 80000000 , 40000000
[ 0.000000] OF: fdt: Ignoring memory range 0x80000000 - 0x80200000
[ 0.000000] Linux version 4.19.0-sifive-1+ (trosinenko@trosinenko-pc) (gcc version 8.3.0 (Buildroot 2019.02-07449-g4eddd28f99)) #1 SMP Sat Jul 6 12:14:41 MSK 2019
[ 0.000000] bootconsole [early0] enabled
[ 0.000000] Initial ramdisk at: 0x(____ptrval____) (4467590 bytes)
[ 0.000000] Zone ranges:
[ 0.000000] DMA32 [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] Normal [mem 0x00000000c0000000-0x00000bffffffffff]
[ 0.000000] Movable zone start for each node
[ 0.000000] Early memory node ranges
[ 0.000000] node 0: [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] Initmem setup node 0 [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] INITIAL: ffffffe000c00000
[ 0.000000] -> unflatten_device_tree()
[ 0.000000] Unflattening device tree:
[ 0.000000] magic: d00dfeed
[ 0.000000] size: 00000d56
[ 0.000000] version: 00000011
[ 0.000000] size is 14192, allocating...
[ 0.000000] unflattening (____ptrval____)...
[ 0.000000] fixed up name for ->
[ 0.000000] fixed up name for chosen -> chosen
[ 0.000000] fixed up name for uart@10000000 -> uart
[ 0.000000] fixed up name for test@100000 -> test
[ 0.000000] fixed up name for virtio_mmio@10008000 -> virtio_mmio
[ 0.000000] fixed up name for virtio_mmio@10007000 -> virtio_mmio
[ 0.000000] fixed up name for virtio_mmio@10006000 -> virtio_mmio
[ 0.000000] fixed up name for virtio_mmio@10005000 -> virtio_mmio
[ 0.000000] fixed up name for virtio_mmio@10004000 -> virtio_mmio
[ 0.000000] fixed up name for virtio_mmio@10003000 -> virtio_mmio
[ 0.000000] fixed up name for virtio_mmio@10002000 -> virtio_mmio
[ 0.000000] fixed up name for virtio_mmio@10001000 -> virtio_mmio
[ 0.000000] fixed up name for cpus -> cpus
[ 0.000000] fixed up name for cpu@0 -> cpu
[ 0.000000] fixed up name for interrupt-controller -> interrupt-controller
[ 0.000000] fixed up name for memory@80000000 -> memory
[ 0.000000] fixed up name for soc -> soc
[ 0.000000] fixed up name for pci@30000000 -> pci
[ 0.000000] fixed up name for interrupt-controller@c000000 -> interrupt-controller
[ 0.000000] fixed up name for clint@2000000 -> clint
[ 0.000000] <- unflatten_device_tree()
[ 0.000000] software IO TLB: mapped [mem 0xbb1fc000-0xbf1fc000] (64MB)
[ 0.000000] 0 ffffffe03effc808 [] | [cpu]
[ 0.000000] 0 ffffffe03effca78 [] | [cpu]
[ 0.000000] 0 ffffffe03effcd98 [] | [cpu]
[ 0.000000] 0 ffffffe03effd068 [] | [cpu]
[ 0.000000] 0 ffffffe03effd230 [] | [cpu]
[ 0.000000] 0 ffffffe03effd4b8 [] | [cpu]
[ 0.000000] 0 ffffffe03effd740 [] | [cpu]
[ 0.000000] 0 ffffffe03effd9c8 [] | [cpu]
[ 0.000000] 0 ffffffe03effdc50 [] | [cpu]
[ 0.000000] 0 ffffffe03effded8 [] | [cpu]
[ 0.000000] 0 ffffffe03effe160 [] | [cpu]
[ 0.000000] 0 ffffffe03effe3e8 [] | [cpu]
[ 0.000000] 0 ffffffe03effe670 [] | [cpu]
[ 0.000000] 0 ffffffe03effe888 [cpu] | [cpu]
[ 0.000000] ffffffe03effe888 ffffffe03effec00 [] | [cpu]
[ 0.000000] ffffffe03effe888 ffffffe03effeee8 [memory] | [cpu]
[ 0.000000] ffffffe03effe888 ffffffe03efff0b0 [] | [cpu]
[ 0.000000] ffffffe03effe888 ffffffe03efff320 [pci] | [cpu]
[ 0.000000] ffffffe03effe888 ffffffe03efff858 [] | [cpu]
[ 0.000000] ffffffe03effe888 ffffffe03efffd58 [] | [cpu]
[ 0.000000] 0 ffffffe03effc808 [] | [cpu]
[ 0.000000] 0 ffffffe03effca78 [] | [cpu]
[ 0.000000] 0 ffffffe03effcd98 [] | [cpu]
[ 0.000000] 0 ffffffe03effd068 [] | [cpu]
[ 0.000000] 0 ffffffe03effd230 [] | [cpu]
[ 0.000000] 0 ffffffe03effd4b8 [] | [cpu]
[ 0.000000] 0 ffffffe03effd740 [] | [cpu]
[ 0.000000] 0 ffffffe03effd9c8 [] | [cpu]
[ 0.000000] 0 ffffffe03effdc50 [] | [cpu]
[ 0.000000] 0 ffffffe03effded8 [] | [cpu]
[ 0.000000] 0 ffffffe03effe160 [] | [cpu]
[ 0.000000] 0 ffffffe03effe3e8 [] | [cpu]
[ 0.000000] 0 ffffffe03effe670 [] | [cpu]
[ 0.000000] 0 ffffffe03effe888 [cpu] | [cpu]
[ 0.000000] elf\_hwcap is 0x112d
[ 0.000000] percpu: Embedded 17 pages/cpu @(\_\_\_\_ptrval\_\_\_\_) s29400 r8192 d32040 u69632
[ 0.000000] Built 1 zonelists, mobility grouping on. Total pages: 258055
[ 0.000000] Kernel command line: earlyprintk
[ 0.000000] Dentry cache hash table entries: 131072 (order: 8, 1048576 bytes)
[ 0.000000] Inode-cache hash table entries: 65536 (order: 7, 524288 bytes)
[ 0.000000] Sorting \_\_ex\_table...
[ 0.000000] Memory: 949716K/1046528K available (6565K kernel code, 342K rwdata, 2564K rodata, 208K init, 832K bss, 96812K reserved, 0K cma-reserved)
[ 0.000000] SLUB: HWalign=64, Order=0-3, MinObjects=0, CPUs=1, Nodes=1
[ 0.000000] rcu: Hierarchical RCU implementation.
[ 0.000000] rcu: RCU event tracing is enabled.
[ 0.000000] rcu: RCU restricting CPUs from NR\_CPUS=8 to nr\_cpu\_ids=1.
[ 0.000000] rcu: Adjusting geometry for rcu\_fanout\_leaf=16, nr\_cpu\_ids=1
[ 0.000000] NR\_IRQS: 0, nr\_irqs: 0, preallocated irqs: 0
[ 0.000000] plic: mapped 53 interrupts to 2 (out of 2) handlers.
[ 0.000000] clocksource: riscv\_clocksource: mask: 0xffffffffffffffff max\_cycles: 0x24e6a1710, max\_idle\_ns: 440795202120 ns
[ 0.000000] Console: colour dummy device 80x25
[ 0.000000] console [tty0] enabled
[ 0.000000] bootconsole [early0] disabled
[ 0.000000] HART = 0 DTB = 80e00000
[ 0.000000] search "chosen", depth: 0, uname:
[ 0.000000] search "chosen", depth: 1, uname: chosen
[ 0.000000] Looking for initrd properties...
[ 0.000000] initrd\_start=0x88000000 initrd\_end=0x88442b86
[ 0.000000] Command line is: earlyprintk
[ 0.000000] dt\_root\_size\_cells = 2
[ 0.000000] dt\_root\_addr\_cells = 2
[ 0.000000] memory scan node memory@80000000, reg size 16,
[ 0.000000] - 80000000 , 40000000
[ 0.000000] OF: fdt: Ignoring memory range 0x80000000 - 0x80200000
[ 0.000000] Linux version 4.19.0-sifive-1+ (trosinenko@trosinenko-pc) (gcc version 8.3.0 (Buildroot 2019.02-07449-g4eddd28f99)) #1 SMP Sat Jul 6 12:14:41 MSK 2019
[ 0.000000] bootconsole [early0] enabled
[ 0.000000] Initial ramdisk at: 0x(\_\_\_\_ptrval\_\_\_\_) (4467590 bytes)
[ 0.000000] Zone ranges:
[ 0.000000] DMA32 [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] Normal [mem 0x00000000c0000000-0x00000bffffffffff]
[ 0.000000] Movable zone start for each node
[ 0.000000] Early memory node ranges
[ 0.000000] node 0: [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] Initmem setup node 0 [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] INITIAL: ffffffe000c00000
[ 0.000000] -> unflatten\_device\_tree()
[ 0.000000] Unflattening device tree:
[ 0.000000] magic: d00dfeed
[ 0.000000] size: 00000d56
[ 0.000000] version: 00000011
[ 0.000000] size is 14192, allocating...
[ 0.000000] unflattening (\_\_\_\_ptrval\_\_\_\_)...
[ 0.000000] fixed up name for ->
[ 0.000000] fixed up name for chosen -> chosen
[ 0.000000] fixed up name for uart@10000000 -> uart
[ 0.000000] fixed up name for test@100000 -> test
[ 0.000000] fixed up name for virtio\_mmio@10008000 -> virtio\_mmio
[ 0.000000] fixed up name for virtio\_mmio@10007000 -> virtio\_mmio
[ 0.000000] fixed up name for virtio\_mmio@10006000 -> virtio\_mmio
[ 0.000000] fixed up name for virtio\_mmio@10005000 -> virtio\_mmio
[ 0.000000] fixed up name for virtio\_mmio@10004000 -> virtio\_mmio
[ 0.000000] fixed up name for virtio\_mmio@10003000 -> virtio\_mmio
[ 0.000000] fixed up name for virtio\_mmio@10002000 -> virtio\_mmio
[ 0.000000] fixed up name for virtio\_mmio@10001000 -> virtio\_mmio
[ 0.000000] fixed up name for cpus -> cpus
[ 0.000000] fixed up name for cpu@0 -> cpu
[ 0.000000] fixed up name for interrupt-controller -> interrupt-controller
[ 0.000000] fixed up name for memory@80000000 -> memory
[ 0.000000] fixed up name for soc -> soc
[ 0.000000] fixed up name for pci@30000000 -> pci
[ 0.000000] fixed up name for interrupt-controller@c000000 -> interrupt-controller
[ 0.000000] fixed up name for clint@2000000 -> clint
[ 0.000000] <- unflatten\_device\_tree()
[ 0.000000] software IO TLB: mapped [mem 0xbb1fc000-0xbf1fc000] (64MB)
[ 0.000000] 0 ffffffe03effc808 [] | [cpu]
[ 0.000000] 0 ffffffe03effca78 [] | [cpu]
[ 0.000000] 0 ffffffe03effcd98 [] | [cpu]
[ 0.000000] 0 ffffffe03effd068 [] | [cpu]
[ 0.000000] 0 ffffffe03effd230 [] | [cpu]
[ 0.000000] 0 ffffffe03effd4b8 [] | [cpu]
[ 0.000000] 0 ffffffe03effd740 [] | [cpu]
[ 0.000000] 0 ffffffe03effd9c8 [] | [cpu]
[ 0.000000] 0 ffffffe03effdc50 [] | [cpu]
[ 0.000000] 0 ffffffe03effded8 [] | [cpu]
[ 0.000000] 0 ffffffe03effe160 [] | [cpu]
[ 0.000000] 0 ffffffe03effe3e8 [] | [cpu]
[ 0.000000] 0 ffffffe03effe670 [] | [cpu]
[ 0.000000] 0 ffffffe03effe888 [cpu] | [cpu]
[ 0.000000] ffffffe03effe888 ffffffe03effec00 [] | [cpu]
[ 0.000000] ffffffe03effe888 ffffffe03effeee8 [memory] | [cpu]
[ 0.000000] ffffffe03effe888 ffffffe03efff0b0 [] | [cpu]
[ 0.000000] ffffffe03effe888 ffffffe03efff320 [pci] | [cpu]
[ 0.000000] ffffffe03effe888 ffffffe03efff858 [] | [cpu]
[ 0.000000] ffffffe03effe888 ffffffe03efffd58 [] | [cpu]
[ 0.000000] 0 ffffffe03effc808 [] | [cpu]
[ 0.000000] 0 ffffffe03effca78 [] | [cpu]
[ 0.000000] 0 ffffffe03effcd98 [] | [cpu]
[ 0.000000] 0 ffffffe03effd068 [] | [cpu]
[ 0.000000] 0 ffffffe03effd230 [] | [cpu]
[ 0.000000] 0 ffffffe03effd4b8 [] | [cpu]
[ 0.000000] 0 ffffffe03effd740 [] | [cpu]
[ 0.000000] 0 ffffffe03effd9c8 [] | [cpu]
[ 0.000000] 0 ffffffe03effdc50 [] | [cpu]
[ 0.000000] 0 ffffffe03effded8 [] | [cpu]
[ 0.000000] 0 ffffffe03effe160 [] | [cpu]
[ 0.000000] 0 ffffffe03effe3e8 [] | [cpu]
[ 0.000000] 0 ffffffe03effe670 [] | [cpu]
[ 0.000000] 0 ffffffe03effe888 [cpu] | [cpu]
[ 0.000000] elf\_hwcap is 0x112d
[ 0.000000] percpu: Embedded 17 pages/cpu @(\_\_\_\_ptrval\_\_\_\_) s29400 r8192 d32040 u69632
[ 0.000000] Built 1 zonelists, mobility grouping on. Total pages: 258055
[ 0.000000] Kernel command line: earlyprintk
[ 0.000000] Dentry cache hash table entries: 131072 (order: 8, 1048576 bytes)
[ 0.000000] Inode-cache hash table entries: 65536 (order: 7, 524288 bytes)
[ 0.000000] Sorting \_\_ex\_table...
[ 0.000000] Memory: 949716K/1046528K available (6565K kernel code, 342K rwdata, 2564K rodata, 208K init, 832K bss, 96812K reserved, 0K cma-reserved)
[ 0.000000] SLUB: HWalign=64, Order=0-3, MinObjects=0, CPUs=1, Nodes=1
[ 0.000000] rcu: Hierarchical RCU implementation.
[ 0.000000] rcu: RCU event tracing is enabled.
[ 0.000000] rcu: RCU restricting CPUs from NR\_CPUS=8 to nr\_cpu\_ids=1.
[ 0.000000] rcu: Adjusting geometry for rcu\_fanout\_leaf=16, nr\_cpu\_ids=1
[ 0.000000] NR\_IRQS: 0, nr\_irqs: 0, preallocated irqs: 0
[ 0.000000] plic: mapped 53 interrupts to 2 (out of 2) handlers.
[ 0.000000] clocksource: riscv\_clocksource: mask: 0xffffffffffffffff max\_cycles: 0x24e6a1710, max\_idle\_ns: 440795202120 ns
[ 0.000000] Console: colour dummy device 80x25
[ 0.000000] console [tty0] enabled
[ 0.000000] bootconsole [early0] disabled
[ 0.000000] Calibrating delay loop (skipped), value calculated using timer frequency.. 20.00 BogoMIPS (lpj=100000)
[ 0.000000] pid\_max: default: 32768 minimum: 301
[ 0.000000] Mount-cache hash table entries: 2048 (order: 2, 16384 bytes)
[ 0.000000] Mountpoint-cache hash table entries: 2048 (order: 2, 16384 bytes)
[ 0.020000] rcu: Hierarchical SRCU implementation.
[ 0.020000] smp: Bringing up secondary CPUs ...
[ 0.020000] smp: Brought up 1 node, 1 CPU
[ 0.050000] devtmpfs: initialized
[ 0.050000] 0 ffffffe03effc808 [] | [cpu]
[ 0.050000] 0 ffffffe03effca78 [] | [cpu]
[ 0.050000] 0 ffffffe03effcd98 [] | [cpu]
[ 0.050000] 0 ffffffe03effd068 [] | [cpu]
[ 0.050000] 0 ffffffe03effd230 [] | [cpu]
[ 0.050000] 0 ffffffe03effd4b8 [] | [cpu]
[ 0.050000] 0 ffffffe03effd740 [] | [cpu]
[ 0.050000] 0 ffffffe03effd9c8 [] | [cpu]
[ 0.050000] 0 ffffffe03effdc50 [] | [cpu]
[ 0.050000] 0 ffffffe03effded8 [] | [cpu]
[ 0.050000] 0 ffffffe03effe160 [] | [cpu]
[ 0.050000] 0 ffffffe03effe3e8 [] | [cpu]
[ 0.050000] 0 ffffffe03effe670 [] | [cpu]
[ 0.050000] 0 ffffffe03effe888 [cpu] | [cpu]
[ 0.050000] random: get\_random\_u32 called from bucket\_table\_alloc+0x76/0x17a with crng\_init=0
[ 0.050000] clocksource: jiffies: mask: 0xffffffff max\_cycles: 0xffffffff, max\_idle\_ns: 19112604462750000 ns
[ 0.050000] futex hash table entries: 256 (order: 2, 16384 bytes)
[ 0.060000] NET: Registered protocol family 16
[ 0.090000] vgaarb: loaded
[ 0.090000] SCSI subsystem initialized
[ 0.090000] usbcore: registered new interface driver usbfs
[ 0.090000] usbcore: registered new interface driver hub
[ 0.090000] usbcore: registered new device driver usb
[ 0.090000] pps\_core: LinuxPPS API ver. 1 registered
[ 0.090000] pps\_core: Software ver. 5.3.6 - Copyright 2005-2007 Rodolfo Giometti
[ 0.090000] PTP clock support registered
[ 0.100000] Advanced Linux Sound Architecture Driver Initialized.
[ 0.100000] clocksource: Switched to clocksource riscv\_clocksource
[ 0.110000] NET: Registered protocol family 2
[ 0.110000] tcp\_listen\_portaddr\_hash hash table entries: 512 (order: 1, 8192 bytes)
[ 0.110000] TCP established hash table entries: 8192 (order: 4, 65536 bytes)
[ 0.110000] TCP bind hash table entries: 8192 (order: 5, 131072 bytes)
[ 0.110000] TCP: Hash tables configured (established 8192 bind 8192)
[ 0.110000] UDP hash table entries: 512 (order: 2, 16384 bytes)
[ 0.110000] UDP-Lite hash table entries: 512 (order: 2, 16384 bytes)
[ 0.110000] NET: Registered protocol family 1
[ 0.120000] Unpacking initramfs...
[ 0.590000] workingset: timestamp\_bits=62 max\_order=18 bucket\_order=0
[ 0.620000] Block layer SCSI generic (bsg) driver version 0.4 loaded (major 251)
[ 0.620000] io scheduler noop registered
[ 0.620000] io scheduler deadline registered
[ 0.620000] io scheduler cfq registered (default)
[ 0.620000] io scheduler mq-deadline registered
[ 0.620000] io scheduler kyber registered
[ 0.620000] shpchp: Standard Hot Plug PCI Controller Driver version: 0.4
[ 0.690000] Serial: 8250/16550 driver, 4 ports, IRQ sharing disabled
[ 0.690000] 10000000.uart: ttyS0 at MMIO 0x10000000 (irq = 10, base\_baud = 230400) is a 16550A
[ 0.720000] console [ttyS0] enabled
[ 0.720000] [drm] radeon kernel modesetting enabled.
[ 0.720000] [drm] amdgpu kernel modesetting enabled.
[ 0.730000] loop: module loaded
[ 0.730000] libphy: Fixed MDIO Bus: probed
[ 0.740000] e1000e: Intel(R) PRO/1000 Network Driver - 3.2.6-k
[ 0.740000] e1000e: Copyright(c) 1999 - 2015 Intel Corporation.
[ 0.740000] ehci\_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) Driver
[ 0.740000] ehci-pci: EHCI PCI platform driver
[ 0.740000] ehci-platform: EHCI generic platform driver
[ 0.740000] mousedev: PS/2 mouse device common for all mice
[ 0.740000] usbcore: registered new interface driver usbhid
[ 0.740000] usbhid: USB HID core driver
[ 0.740000] usbcore: registered new interface driver snd-usb-audio
[ 0.740000] NET: Registered protocol family 10
[ 0.750000] Segment Routing with IPv6
[ 0.750000] sit: IPv6, IPv4 and MPLS over IPv4 tunneling driver
[ 0.750000] NET: Registered protocol family 17
[ 0.750000] Key type dns\_resolver registered
[ 0.760000] ALSA device list:
[ 0.760000] No soundcards found.
[ 0.770000] Freeing unused kernel memory: 208K
[ 0.770000] This architecture does not have kernel memory protection.
[ 0.770000] Run /init as init process
```
(«Таймстемпнутыми» строчки выводит ядро, перед ними дерево выводит BBL) С одной стороны, FDT успешно читается, с другой — получается какая-то чепуха в распарсенном «объектном» дереве.
В процессе отладки я понял, что BBL не мог прочитать «двойной» адрес не потому, что в конфиге была ошибка, а просто потому, что у корневого узла был выставлен `#address-cells = <1>; #size-cells = <1>;`.
Расширив отладочный вывод, я увидел, что указатели на `type` и `name` «побились», причём довольно странным образом: у них обнулился первый (начиная с нуля) байт, что-то вроде `0xabcdef -> 0xab00ef`. Пришлось воспользоваться знакомой тактикой: зная адреса, по которым находится повреждённая память, дописать в функцию `printk` печать этих данных. Ну и самих вызовов `printk` пораскидать, где их мало. Увы, сильно понятнее не стало. Тогда я стал, сверяясь с дизассемблированной `objdump` версией, вручную расставлять breakpoint-ы и по шагам проходить проблемный участок кода. И тут обнаружилось загадочное и неприятное: если сразу поставить точку останова куда-нибудь относительно далеко от known-good состояния, то, остановившись на ней, я увижу уже повреждённую память. Но если попытаться тихо подкрасться к ней по шагам, то ошибка успевает спрятаться! Дело пахнет битым контроллером памяти и кешом, скрывающим ошибку, если постоянно запрашивать нужное значение. А что если...
Заменяем память
---------------
Цепляясь за возможность решить проблему не на своей стороне, я предположил, что, может, мне просто пришла битая планка памяти. Тут я вспомнил, что нетбук десятилетней давности — это не только портативный компьютер, но и ценный источник DDR2 SO-DIMM. Бонусом, в него можно засунуть вынутую из платы память, и получить почти мгновенное зависание Memtest (Linux, кстати, при этом грузился почти до графической оболочки. **Но лучше не повторяйте такой эксперимент, если вам дорога информация на подмонтированных дисках...**). С одной стороны, можно предположить, что просто память не подошла конкретно к этому нетбуку. С другой стороны, он же смог загрузиться! Появилась надежда, что просто память «битая», и проблема не в моей обёртке.
Значит, нужно попробовать временно запуститься с нетбучной памятью. К сожалению, Quartus 18 не умеет апгрейдить этот IP Core так, чтобы его можно было редактировать. Значит, всё-таки пришло время научиться создавать новые инстансы. Всё оказалось довольно просто: ищем в IP Catalog пункт DDR2 SDRAM Controller with ALTMEMPHY Intel FPGA IP и получаем блок с таким же интерфейсом, как и раньше. Единственная проблема — это выставить правильные настройки памяти.
### Получаем параметры модуля памяти
Есть относительно очевидный способ настроить модуль: прочитать параметры из SPD. Действительно, если обычный компьютер вычитывает данные SPD и настраивает по ним контроллер, то давайте вычитаем эти данные на имеющемся нетбуке и вобьём их в табличку.
На Ubuntu это делается [весьма нехитро](https://unix.stackexchange.com/a/92044/251405): нужно поставить пакет `i2c-tools`, загрузить модули `eeprom` и `i2c-i801` (не уверен, правда, что второй драйвер подойдёт везде), после чего запустить `decode-dimms`:
**Вывод decode-dimms**
```
# decode-dimms version 6231 (2014-02-20 10:54:34 +0100)
Memory Serial Presence Detect Decoder
By Philip Edelbrock, Christian Zuckschwerdt, Burkart Lingner,
Jean Delvare, Trent Piepho and others
Decoding EEPROM: /sys/bus/i2c/drivers/eeprom/0-0050
Guessing DIMM is in bank 1
---=== SPD EEPROM Information ===---
EEPROM Checksum of bytes 0-62 OK (0x00)
SPD Revision Invalid
Fundamental Memory type Unknown (0x00)
---=== Manufacturing Information ===---
Manufacturer Undefined
Part Number Undefined
Decoding EEPROM: /sys/bus/i2c/drivers/eeprom/4-0050
Guessing DIMM is in bank 1
---=== SPD EEPROM Information ===---
EEPROM Checksum of bytes 0-62 OK (0x00)
SPD Revision Invalid
Fundamental Memory type Unknown (0x00)
---=== Manufacturing Information ===---
Manufacturer Undefined
Part Number Undefined
Decoding EEPROM: /sys/bus/i2c/drivers/eeprom/6-0050
Guessing DIMM is in bank 1
---=== SPD EEPROM Information ===---
EEPROM Checksum of bytes 0-62 OK (0x76)
# of bytes written to SDRAM EEPROM 128
Total number of bytes in EEPROM 256
Fundamental Memory type DDR2 SDRAM
SPD Revision 1.2
---=== Memory Characteristics ===---
Maximum module speed 800 MHz (PC2-6400)
Size 1024 MB
Banks x Rows x Columns x Bits 8 x 13 x 10 x 64
Ranks 2
SDRAM Device Width 16 bits
Module Height 30.0 mm
Module Type SO-DIMM (67.6 mm)
DRAM Package Planar
Voltage Interface Level SSTL 1.8V
Module Configuration Type No Parity
Refresh Rate Reduced (7.8 us) - Self Refresh
Supported Burst Lengths 4, 8
tCL-tRCD-tRP-tRAS 6-6-6-18
Supported CAS Latencies (tCL) 6T, 5T, 4T
Minimum Cycle Time 2.50 ns at CAS 6 (tCK min)
3.00 ns at CAS 5
3.75 ns at CAS 4
Maximum Access Time 0.40 ns at CAS 6 (tAC)
0.45 ns at CAS 5
0.50 ns at CAS 4
Maximum Cycle Time (tCK max) 8.00 ns
---=== Timing Parameters ===---
Address/Command Setup Time Before Clock (tIS) 0.17 ns
Address/Command Hold Time After Clock (tIH) 0.25 ns
Data Input Setup Time Before Strobe (tDS) 0.05 ns
Data Input Hold Time After Strobe (tDH) 0.12 ns
Minimum Row Precharge Delay (tRP) 15.00 ns
Minimum Row Active to Row Active Delay (tRRD) 10.00 ns
Minimum RAS# to CAS# Delay (tRCD) 15.00 ns
Minimum RAS# Pulse Width (tRAS) 45.00 ns
Write Recovery Time (tWR) 15.00 ns
Minimum Write to Read CMD Delay (tWTR) 7.50 ns
Minimum Read to Pre-charge CMD Delay (tRTP) 7.50 ns
Minimum Active to Auto-refresh Delay (tRC) 60.00 ns
Minimum Recovery Delay (tRFC) 127.50 ns
Maximum DQS to DQ Skew (tDQSQ) 0.20 ns
Maximum Read Data Hold Skew (tQHS) 0.30 ns
---=== Manufacturing Information ===---
Manufacturer Samsung
Manufacturing Location Code 0x02
Part Number M4 70T2864QZ3-CF7
Revision Code 0x3351
Manufacturing Date 2009-W34
Assembly Serial Number 0x79C64E9A
Number of SDRAM DIMMs detected and decoded: 3
```
Проблема в том, что некоторых таймингов здесь не указано, поэтому пойдём по второму пути.
Что у нас написано на модулях:
В данном случае интереснее надпись на самих микросхемах памяти: K4T1G164QQ-HCF7. Забив эту строчку в Гугл, получаем datasheet на несколько десятков страниц со всеми необходимыми параметрами, которые можно аккуратно перебить в свойства IP Core. Только обращайте внимание на единицы измерения: где-то `ns`, где-то — `ps`, а иногда и вообще доли `tCK`. Учить вас, на что нужно обращать внимание, я не буду — сам многое настраивал методом тыка (не могу при этом гарантировать, что так нельзя «сжечь» память или ПЛИС). Обращу лишь внимание вот на что: я очень долго не мог заставить контроллер работать, и последним шагом было осознание, что нужно проверить ширину всех интерфейсов к памяти на соответствие сгенерированному коду на Verilog: ведь когда в `MemIfBundle` указан `val mem_ba = IO(Output(UInt(2.W)))`, а банков 8 (т.е. адрес шириной 3 бита), то всё, что у нас есть — висящий в воздухе output из контроллера памяти — проблема, но не критическая, поэтому всё синтезируется, но не работает.
Возможно, всё бы завелось и со старым модулем, если обновить контроллер, но пока что мне лень разбираться с потенциальными плавающими багами: мне и своих хватает.
Итак, после перемещения `timebase-frequency` в DTS с уровня конкретного CPU на уровень узла `cpus` (по вполне понятно сказанной просьбе ядра), получаем:
**Скрытый текст**
```
[ 0.000000] OF: fdt: Ignoring memory range 0x80000000 - 0x80200000
[ 0.000000] Linux version 4.19.0-sifive-1+ (trosinenko@trosinenko-pc) (gcc version 8.3.0 (Buildroot 2019.02-07449-g4eddd28f99)) #1 SMP Tue Jul 9 22:42:36 MSK 2019
[ 0.000000] bootconsole [early0] enabled
[ 0.000000] Initial ramdisk at: 0x(____ptrval____) (16777216 bytes)
[ 0.000000] Zone ranges:
[ 0.000000] DMA32 [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] Normal [mem 0x00000000c0000000-0x00000bffffffffff]
[ 0.000000] Movable zone start for each node
[ 0.000000] Early memory node ranges
[ 0.000000] node 0: [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] Initmem setup node 0 [mem 0x0000000080200000-0x00000000bfffffff]
[ 0.000000] software IO TLB: mapped [mem 0xbb1fc000-0xbf1fc000] (64MB)
[ 0.000000] elf_hwcap is 0x112d
[ 0.000000] percpu: Embedded 17 pages/cpu @(____ptrval____) s29400 r8192 d32040 u69632
[ 0.000000] Built 1 zonelists, mobility grouping on. Total pages: 258055
[ 0.000000] Kernel command line: debug console=ttySIF0,125200 root=/dev/mmcblk0p2 loglevel=7 rootwait
[ 0.000000] Dentry cache hash table entries: 131072 (order: 8, 1048576 bytes)
[ 0.000000] Inode-cache hash table entries: 65536 (order: 7, 524288 bytes)
[ 0.000000] Sorting __ex_table...
[ 0.000000] Memory: 937696K/1046528K available (6565K kernel code, 343K rwdata, 2564K rodata, 208K init, 832K bss, 108832K reserved, 0K cma-reserved)
[ 0.000000] SLUB: HWalign=64, Order=0-3, MinObjects=0, CPUs=1, Nodes=1
[ 0.000000] rcu: Hierarchical RCU implementation.
[ 0.000000] rcu: RCU event tracing is enabled.
[ 0.000000] rcu: RCU restricting CPUs from NR_CPUS=8 to nr_cpu_ids=1.
[ 0.000000] rcu: Adjusting geometry for rcu_fanout_leaf=16, nr_cpu_ids=1
[ 0.000000] NR_IRQS: 0, nr_irqs: 0, preallocated irqs: 0
[ 0.000000] plic: mapped 8 interrupts to 1 (out of 2) handlers.
[ 0.000000] clocksource: riscv_clocksource: mask: 0xffffffffffffffff max_cycles: 0x1d854df40, max_idle_ns: 3526361616960 ns
[ 0.000000] Console: colour dummy device 80x25
[ 0.000000] Calibrating delay loop (skipped), value calculated using timer frequency.. 2.00 BogoMIPS (lpj=10000)
[ 0.020000] pid_max: default: 32768 minimum: 301
[ 0.030000] Mount-cache hash table entries: 2048 (order: 2, 16384 bytes)
[ 0.040000] Mountpoint-cache hash table entries: 2048 (order: 2, 16384 bytes)
[ 0.140000] rcu: Hierarchical SRCU implementation.
[ 0.190000] smp: Bringing up secondary CPUs ...
[ 0.190000] smp: Brought up 1 node, 1 CPU
[ 0.220000] devtmpfs: initialized
[ 0.300000] random: get_random_u32 called from bucket_table_alloc+0x76/0x17a with crng_init=0
[ 0.330000] clocksource: jiffies: mask: 0xffffffff max_cycles: 0xffffffff, max_idle_ns: 19112604462750000 ns
[ 0.340000] futex hash table entries: 256 (order: 2, 16384 bytes)
[ 0.380000] NET: Registered protocol family 16
[ 1.850000] vgaarb: loaded
[ 1.870000] SCSI subsystem initialized
[ 1.900000] usbcore: registered new interface driver usbfs
[ 1.910000] usbcore: registered new interface driver hub
[ 1.920000] usbcore: registered new device driver usb
[ 1.930000] pps_core: LinuxPPS API ver. 1 registered
[ 1.940000] pps_core: Software ver. 5.3.6 - Copyright 2005-2007 Rodolfo Giometti
[ 1.950000] PTP clock support registered
[ 1.970000] Advanced Linux Sound Architecture Driver Initialized.
[ 2.010000] clocksource: Switched to clocksource riscv\_clocksource
[ 2.600000] NET: Registered protocol family 2
[ 2.640000] tcp\_listen\_portaddr\_hash hash table entries: 512 (order: 1, 8192 bytes)
[ 2.650000] TCP established hash table entries: 8192 (order: 4, 65536 bytes)
[ 2.670000] TCP bind hash table entries: 8192 (order: 5, 131072 bytes)
[ 2.700000] TCP: Hash tables configured (established 8192 bind 8192)
[ 2.720000] UDP hash table entries: 512 (order: 2, 16384 bytes)
[ 2.730000] UDP-Lite hash table entries: 512 (order: 2, 16384 bytes)
[ 2.750000] NET: Registered protocol family 1
[ 2.770000] Unpacking initramfs...
[ 23.980000] Initramfs unpacking failed: junk in compressed archive
[ 24.030000] workingset: timestamp\_bits=62 max\_order=18 bucket\_order=0
[ 25.020000] Block layer SCSI generic (bsg) driver version 0.4 loaded (major 251)
[ 25.030000] io scheduler noop registered
[ 25.040000] io scheduler deadline registered
[ 25.050000] io scheduler cfq registered (default)
[ 25.060000] io scheduler mq-deadline registered
[ 25.060000] io scheduler kyber registered
[ 25.120000] sifive\_gpio 64002000.gpio: SiFive GPIO chip registered 6 GPIOs
[ 25.150000] shpchp: Standard Hot Plug PCI Controller Driver version: 0.4
[ 28.870000] Serial: 8250/16550 driver, 4 ports, IRQ sharing disabled
[ 28.940000] sifive-serial 64000000.serial: unable to find controller clock
[ 28.950000] sifive-serial: probe of 64000000.serial failed with error -2
[ 28.980000] [drm] radeon kernel modesetting enabled.
[ 28.990000] [drm] amdgpu kernel modesetting enabled.
[ 29.500000] loop: module loaded
[ 29.610000] sifive\_spi 64001000.spi: Unable to find bus clock
[ 29.620000] sifive\_spi: probe of 64001000.spi failed with error -2
[ 29.640000] libphy: Fixed MDIO Bus: probed
[ 29.680000] e1000e: Intel(R) PRO/1000 Network Driver - 3.2.6-k
[ 29.690000] e1000e: Copyright(c) 1999 - 2015 Intel Corporation.
[ 29.700000] ehci\_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) Driver
[ 29.710000] ehci-pci: EHCI PCI platform driver
[ 29.720000] ehci-platform: EHCI generic platform driver
[ 29.750000] mousedev: PS/2 mouse device common for all mice
[ 29.790000] usbcore: registered new interface driver usbhid
[ 29.800000] usbhid: USB HID core driver
[ 29.820000] usbcore: registered new interface driver snd-usb-audio
[ 29.900000] NET: Registered protocol family 10
[ 29.960000] Segment Routing with IPv6
[ 29.960000] sit: IPv6, IPv4 and MPLS over IPv4 tunneling driver
[ 30.020000] NET: Registered protocol family 17
[ 30.020000] Key type dns\_resolver registered
[ 30.070000] bootconsole [early0] uses init memory and must be disabled even before the real one is ready
[ 30.080000] bootconsole [early0] disabled
```
После чего ничего видимого не происходит.
Теперь можно попробовать побороться с тремя проблемами:
```
[ 23.980000] Initramfs unpacking failed: junk in compressed archive
...
[ 28.940000] sifive-serial 64000000.serial: unable to find controller clock
...
[ 29.610000] sifive_spi 64001000.spi: Unable to find bus clock
```
… а также с прекращением вывода в консоль.
С двумя проблемами с частотами побороться совсем несложно: нужно добавить пункты `clocks` в поддеревья требуемых устройств, для удобства дав понятное имя метки для узла `tlclk`:
```
diff --git a/arch/riscv/dts/zeowaa-1gb.dts b/arch/riscv/dts/zeowaa-1gb.dts
index 4b2cebc..1347e76 100644
--- a/arch/riscv/dts/zeowaa-1gb.dts
+++ b/arch/riscv/dts/zeowaa-1gb.dts
@@ -96,6 +97,7 @@
L8: serial@64000000 {
compatible = "sifive,uart0";
interrupt-parent = <&L0>;
+ clocks = <&tlclk>;
interrupts = <2>;
reg = <0x64000000 0x1000>;
reg-names = "control";
@@ -107,6 +109,7 @@
interrupt-parent = <&L0>;
interrupts = <1>;
reg = <0x64001000 0x1000>;
+ clocks = <&tlclk>;
reg-names = "control";
L12: mmc@0 {
compatible = "mmc-spi-slot";
@@ -116,7 +119,7 @@
voltage-ranges = <3300 3300>;
};
};
- L11: tlclk {
+ tlclk: tlclk {
#clock-cells = <0>;
clock-frequency = <25000000>;
clock-output-names = "tlclk";
```
Добавив строчку `#define pr_debug printk` в начало файла `init/initramfs.c`, выводящего сообщение про мусор вместо initramfs получаем чуть более подробное сообщение:
```
[ 2.760000] Unpacking initramfs...
[ 2.770000] Detected gzip compressed data
[ 23.940000] Detected (null) compressed data
[ 23.970000] Initramfs unpacking failed: junk in compressed archive
```
То есть, возможно, мусор не **вместо** initramfs, а **вместе**.
Окей, что-то он нашёл, может, и этого достаточно. А куда делась консоль? Поиск даёт ссылку на issue на Гитхабе: [linux failed to bringup on vc707 board](https://github.com/sifive/freedom-u-sdk/issues/62#issuecomment-403684481) — оказывается, один UART это, по мнению драйвера, даже не стоит разговоров. Но [исправление](https://github.com/sifive/freedom-u-sdk/pull/64) датировано 11 июля 2018 года — год назад. Оказалось, этот коммит так и не попал в дерево, из которого у меня собирается ядро. Вручную применив этот патч, я получил работающий Линукс! Оказалось, с initramfs проблема была, действительно, не критичная.
Залогинившись как user=root, password=sifive, я смог без особых проблем (кроме того, чтобы понять, что у номера GPIO есть base, от которого всё считается, и который просто нужно прочитать из соответствующего псевдо-файла) через `sysfs` зажечь светодиод на плате.
Как и в прошлый раз, прикладываю текстовое видео запуска Linux. В момент переключения консоли с earlyprintk на штатную идёт какой-то мусор, похожий на вывод при неправильно выставленной скорости UART. Что интересно, плеер успешно отработал эту «кашу».
[](https://asciinema.org/a/256637) | https://habr.com/ru/post/459470/ | null | ru | null |
# Аппаратный взлом
[](https://habr.com/ru/company/ruvds/blog/669276/)
Эта статья предназначается для всех, кто имеет опыт в разработке \*nix/ПО/эксплойтов, но не обладает или почти не обладает знаниями оборудования/электроники! Хоть мы и не будем рассматривать все подробности простых схем (для этого есть множество отличных онлайн-ресурсов), информация изложена так, что не требует предыдущего опыта работы.
Основная задача статьи — помочь тем, кто пытается заниматься исследованием уязвимостей и/или разработкой эксплойтов физического устройства без системы отладки, оболочки и прошивки. Иными словами, мы попробуем добраться до root shell без сложностей поиска уязвимостей нулевого дня!
Разведка
--------
Прежде чем переходить к исследуемому устройству, полезно провести предварительное изучение. В США все устройства, использующие радиочастотную связь (RF, Radio Frequency), например, WiFi, Bluetooth и т. п., должны проходить тестирование и проверку FCC. Эти тесты доступны публично, и обычно в них содержатся изображения внутренностей устройства!
Чтобы найти эти тесты FCC, нужно для начала узнать FCC ID. Этот ID всегда указан на корпусе устройства и обычно объединён с другой технической информацией и спецификациями. У данного устройства FCC ID находится на нижней крышке.
Для автоматизации процесса этот ID можно поискать непосредственно на [официальном сайте поиска FCC](https://www.fcc.gov/oet/ea/fccid) или воспользоваться сайтами наподобие [fcc.io](http://fcc.io/) или [fccid.io](http://fcc.io/). На них вы можете найти разнообразные документы: руководства пользователя, информацию о радиочастотном тестировании и фотографии внутренностей и внешнего вида устройства! Эти фотографии могут помочь в поиске возможных интерфейсов отладки оборудования, интересных компонентов, архитектуры ЦП и т. д.
Вскрываем оборудование
----------------------
Обычно детали аппаратных устройств скрепляются вместе винтами, клеем и (почти всегда) пластмассовыми защёлками. Эти защёлки — проклятие любого хакера оборудования, однако их обычно удаётся открыть, аккуратно надавив отвёрткой с плоским шлицем или другим узким инструментом. (Помните, что острые края инструмента всегда должны быть направлены в противоположную от вас сторону!)
Подсказка: если устройство не разбирается, то проверьте под наклейками или резиновыми ножками в нижней части устройства, там могут быть винты.
При изучении документации FCC или внутренностей устройства мы стремимся решить следующие важные задачи:
#### 1. Больше узнать об устройстве
Найдите ЦП. Обычно это самый большой чёрный квадрат на плате. Прочитайте его маркировку и найдите её в поисковом движке, обычно там есть технические описания архитектуры, контактов и многого другого.
Любой другой большой чип на печатной плате тоже может дать полезную информацию об устройстве (ОЗУ, накопитель и т. п.).
#### 2. Получить прошивку устройства
См. подраздел «При помощи оборудования» в разделе «Получение прошивки».
#### 3. Найти оболочки
Процесс получения shell и проведения интерактивной сессии отладки оборудования описан ниже.
Общение с оборудованием
-----------------------
В программировании двоичные файлы могут компилироваться с отладочными символами; аналогично этому, разработчики оборудования могут добавлять в устройства такие элементы, как отладочные разъёмы, позволяющие обмениваться данными с компонентами печатной платы. Эти интерфейсы используются для отладки при разработке и часто необходимы при производстве устройств для загрузки прошивок и/или проведения автоматизированных тестов. Поэтому такие разъёмы не убираются из готового устройства и могут служить замечательными точками входа для любопытного реверс-разработчика.
Отладочные разъёмы (или контакты) обычно состоят из группы соединений, выстроенных в стандартную, легко узнаваемую структуру на печатной плате. Они могут быть уже припаянными к разъёму печатной платы (благодаря чему к ним можно легко подключать внешние устройства), или же вам придётся разогревать паяльник и припаивать к ним новые провода.
Примечание: отладочные разъёмы для встроенных ЦП часто представляют собой непосредственные соединения с контактами на самом ЦП. Если отладочные разъёмы сломаны или отсутствуют, то можно не обращать внимания на остальную часть платы и подключиться напрямую к этим контактам ЦП. С такими мелкими соединениями помогают специальные инструменты наподобие [pcbite](https://sensepeek.com/pcbite_20).
Хотя протоколов связи с оборудованием очень много (JTAG, I2C, SPI, CAN ...), в этой статье мы рассмотрим UART, потому что это один из самых популярных протоколов интерфейсов отладки.
Что за UART?
------------
**U**niversal **A**synchronous **R**eceiver/**T**ransmitter (UART) — это простой, но изящный протокол. Как понятно из названия, он позволяет устройству асинхронно получать и передавать данные. UART-соединение обычно выглядит вот так:
Интерфейс UART состоит из четырёх контактов:
* GND: низкое напряжение, например, 0 В.
* Vcc: высокое напряжение, обычно от 3,3 В до 12 В.
* Rx (приём).
* Tx (передача).
Контакты Rx и Tx имеют высокое напряжение в режиме простоя и колеблются между низким и высоким напряжением при передаче информации.
При помощи анализатора цепей мы можем исследовать реальную передачу UART.
В каждой строке показано изменение напряжения на отдельном контакте UART в процессе передачи. Здесь мы замеряем, как устройство получает данные.
* Канал 0 (GND) постоянно имеет низкое напряжение.
* Канал 1 (Vcc) постоянно имеет высокое напряжение.
* Канал 2 (Rx) попеременно имеет низкое и высокое напряжение в процессе передачи данных.
* Канал 3 (Tx) постоянно имеет высокое напряжение (то есть передача данных отсутствует).
Данные передаются в виде битов (нулей и единиц), закодированных как импульсы низкого и высокого напряжений на контакте Rx. В протоколе UART описывается — как биты упаковываются в кадры размером 5-9 бит, включающие в себя специальные контрольные биты (старт/стоп) и биты коррекции ошибок (чётности). Однако важная особенность заключается в том, что принимающее устройство должно *замерять* эти напряжения с той же скоростью, с которой передающее устройство их *отправляет*. Если принимающее устройство выполняет измерения слишком быстро или слишком медленно, то полученные биты будут неверными. Следовательно, нам нужно сделать так, чтобы оба устройства общались на одной скорости. Поэтому нам нужно упомянуть…
### ▍ Скорости передачи информации (скорость в бодах)
Подробное описание бодов, скорости в бодах, скорости в битах и другого можно прочитать на [stackoverflow](https://stackoverflow.com/questions/20534417/what-is-the-difference-between-baud-rate-and-bit-rate). Однако для наших задач можно принять, что скорость в бодах UART-устройства — это просто количество передаваемых по проводу битов в секунду.
Большинство устройств работает со скоростью 9600 бод (9600 бит/с или 1200 байт/с) или 115200 бод. Существует много стандартных скоростей (обычно кратных 9600), но 9600 и 115200 почти всегда используются по умолчанию. Трюки для определения скоростей будут изложены ниже.
### ▍ Разъём UART
Заглянув внутрь устройства, вы можете увидеть нечто подобное:
Этот безымянный производитель даже любезно промаркировал контакты!
Естественно, каждый инженер может реализовывать проекты по-разному. В первую очередь нужно искать следующее:
#### 1. Маркировку Rx и Tx
Если контакты Rx/Tx промаркированы, то почти всегда в пятидесяти процентах случаев обозначение Rx подразумевает или «здесь можно получать данные», или «отсюда устройство получает данные». (Тоже справедливо и для контакта Tx).
Примечание: Rx и Tx работают под одинаковым напряжением, поэтому ошибка обычно не приводит к проблемам (при необходимости провода можно позже поменять местами).
#### 2. Контакт Vcc
Не всегда понятно, для чего предназначается контакт Vcc. Обычно, если плата уже запитана (например, через USB или блок питания), то необходимость работать с контактом Vcc отсутствует, поскольку он уже подключён к внутреннему Vcc платы. Неправильная работа с эти контактом и попытка подключить к нему другой источник питания может привести к короткому замыканию двух источников питания, сгоранию устройства и повреждению оборудования! (К сожалению, я знаю это по собственному опыту.) Короче, НЕ ПОДКЛЮЧАЙТЕСЬ К ЭТОМУ КОНТАКТУ.
Получаем Root Shell
-------------------
Всё это здорово, но вы читаете эту статью не ради аппаратных протоколов, а чтобы получить root shell!
Как говорилось выше, при работе с UART присутствует некоторая неопределённость. Иногда контакт Vcc вообще отсутствует, иногда маркировка может быть ошибочной и т.п. Однако если вы увидите на плате три или четыре контакта в ряд, то это, скорее всего, UART.
Если на вашей плате отладочные контакты промаркированы, то сразу переходите к разделу «Взаимодействие». В противном случае надо браться за мультиметр!
### ▍ Идентифицируем контакты
Существует множество способов реверс-инжиниринга выводов UART, от простой удачи до оборудования за тысячу с лишним долларов. Мы выберем более дешёвый вариант: мультиметр! Если у вас его нет, то в продаже есть мультиметры ценой от 5 долларов. Для UART не требуется ничего крутого, подойдёт любой мультиметр, который может показывать напряжение в диапазоне 0 — 12 В и имеет режим проверки целостности цепи. (Например, [этот](https://www.amazon.com/Acuty-Multimeter-Resistance-Continuity-Transistor/dp/B097RS8JW9) или [этот](https://www.amazon.com/Neoteck-Ranging-Digital-Multimeter-Counts/dp/B08ZC2C8WC)).
Разобравшись с мультиметром, выполните следующие действия:
* Найдите выводы, которые похожи на UART. (Там может быть два, три или четыре контакта)
* Включите устройство обычным образом.
* Переключите мультиметр в режим проверки целостности цепи. Обычно он выглядит как символ диода ().
* Приложите чёрный щуп мультиметра к заземлённому компоненту (обычно это любой металлический участок — ради безопасности используйте корпуса выводов, радиочастотные экраны и т. п.)
На изображении ниже радиочастотные экраны — это большие прямоугольные металлические крышки компонентов, излучающих радиоволны; экраны почти всегда заземлены.
1. Коснитесь красным щупом каждого контакта предполагаемого UART. Если звучит сигнал (или показания на экране мультиметра меняются), то вы нашли контакт заземления! Примечание: контакт заземления обычно имеет квадратную форму, но не всегда.
2. Переключите мультиметр в режим постоянного тока. Обычно он выглядит как “V” со сплошной горизонтальной линией над пунктирной линией. Если у мультиметра есть фиксированные диапазоны напряжений, выберите ближайший к 12 В (с округлением вверх).
3. Прижмите чёрный щуп мультиметра к найденному ранее контакту заземления.
4. Касайтесь красным щупом каждого контакта предполагаемого UART. Если мультиметр показывает 3,3 В или 5 В, то это, скорее всего, контакт приёма. Это может быть и контакт Vcc, поэтому можно проверить цепь на целостность с запитанным контактом коаксиального разъёма или USB-входа. Если значения колеблются в диапазоне от 3,3 В/5 В до 0 В, то это, скорее всего, контакт передачи. Если мультиметр показывает 0 В (или <0,5 В), то это, скорее всего, контакт заземления.
Контакт заземления — самый важный. Если вам удастся также найти Vcc, то можно просто случайным образом решить, где находятся Rx и Tx, а потом поменять их местами в случае отсутствия соединения.
### ▍ Взаимодействие
Отлично! Теперь, когда мы идентифицировали потенциальные контакты UART, нам нужно каким-то образом начать с ними общаться. Для этого подойдёт любой преобразователь USB-to-serial. Однако самыми простыми являются четырёхконтактные переходники наподобие [такого](https://www.amazon.com/Serial-Adapter-Signal-Prolific-Windows/dp/B07R8BQYW1) или [такого (он лучше)](https://www.adafruit.com/product/954). Эти переходники имеют следующие контакты:
Красный: Vcc (Нам его использовать **не нужно**!)
Чёрный: заземление
Зелёный: передача (со стороны переходника)
Белый: приём (в переходник)
Подключите эти провода к соответствующим контактам UART устройства следующим образом:
* Чёрный провод к заземлению устройства.
* Зелёный провод к контакту приёма устройства.
* Белый провод к контакту передачи устройства.
* Красный провод ни к чему не подключается!
### ▍ Обмен данными
И мы приближаемся к финишу! Подключите USB-кабель и запустите ПО, способное работать с последовательным соединением:
В Linux-подобных системах:
1. `sudo screen /dev/ttyUSB0 [baudrate]`
2. `sudo gtkterm -p /dev/ttyUSB0 -s [baudrate]`
3. minicom/miniterm — тоже отличные специализированные CLI-инструменты для этого
В системах Windows можно использовать для последовательного соединения [PuTTY](https://the.earth.li/~sgtatham/putty/0.76/htmldoc/Chapter3.html#using-serial).
Как говорилось выше, важно подобрать скорость целевого устройства, чтобы правильно общаться с ним. Так как в устройствах обычно используются стандартные скорости, можно воспользоваться скриптом наподобие [baudrate.py](https://github.com/devttys0/baudrate/blob/master/baudrate.py) для циклической проверки всех скоростей.
### ▍ Устранение неполадок
#### ❒ Я не получаю вывод!
1. Убедитесь, что инструменты последовательной связи запущены под root/admin.
2. Снова проверьте контакты (попробуйте поменять местами Rx и Tx).
3. Убедитесь, что на устройство подаётся питание так, как это задумано производителем (т. е. не по красному последовательному проводу).
#### ❒ Вывод представляет собой мусор из поломанных символов и Unicode
Скорее всего, неверно установлена скорость в бодах. Попробуйте пройтись по скрипту [baudrate.py](https://github.com/devttys0/baudrate/blob/master/baudrate.py), возможно, какие-то другие скорости дадут вам нужную информацию.
#### ❒ Устройство не запускается!
Возможно, это особенность работы с кабелем usb-to-serial. Раньше у меня бывало так, что после включения питания кабель посылает 1 В в свою линию передачи, из-за чего некоторые устройства перестают запускаться. Просто отключите кабель, перезапустите устройство, подождите секунду и подключите кабель.
### ❒ А что дальше?
После успешного подключения по UART вы, скорее всего, наткнётесь на лог запуск устройства, выдающий потоки отладочной информации. Если вам повезёт, то подождав несколько секунд и нажав на [ENTER], вы получите доступ к интерактивной оболочке, запущенной под root.
В противном случае придётся использовать различные трюки:
1. Если в начале процесса запуска вы увидите запрос ввода или нажатия определённых клавиш, нажмите их!
* Возможно, вы перейдёте в интерактивную оболочку загрузчика устройства. Хотя операционная система ещё не загрузилась, вы можете изучить содержимое nvram, сдампить прошивку, выполнять произвольную запись в участки памяти и принудительно запускать в устройстве оболочку, изменив аргументы init (см. [этот пост](https://unix.stackexchange.com/questions/428347/how-to-pass-arguments-to-a-linux-kernel-init-bootparam))
2. Если командная строка загрузчика отсутствует или для неё установлена длительность 0 секунд, то есть несколько вариантов:
* Быстро нажимать CTRL+C при запуске. Это странный трюк, но в нескольких случаях он сработал.
* Если устройство использует загрузчик [U-Boot](https://en.wikipedia.org/wiki/Das_U-Boot), то можно заставить оборудование перебросить вас в интерактивную оболочку загрузчика. По умолчанию, если U-Boot не может считать образ прошивки из флэш-памяти в ОЗУ, то он вызовет панику и переключится в режим интерактивной оболочки восстановления. Чтобы вызвать эту панику (прости, U-Boot), на короткое время заземлите линию данных ввода-вывода флэш-чипа во время запуска. В этом вам помогут технические описания (даташиты) производителя!
Получение прошивки
------------------
Теперь, когда у вас есть оболочка с root, вы, вероятно, хотите заняться хакингом, и в этом случае вам пригодится копия прошивки оборудования. Процесс получения прошивки выходит за рамки этой статьи, но вот несколько возможных вариантов действий:
### ▍ 1. Скачивание непосредственно у производителя (самый простой способ):
Некоторые производители оборудования (OEM, Official Equipment Manufacturer) выкладывают сжатые образы прошивок на свои веб-сайты (предназначенные для обновлений вручную). Если не можете найти страницу скачивания, попробуйте ввести в поисковом движке "[название устройства]” “firmware”. Например: [центр скачивания Netgear](https://www.netgear.com/support/download/)
### ▍ 2. Сетевой перехват
К сожалению для безопасности устройства (но к счастью для нас!) многие потребительские устройства общаются с конечными точками OEM по HTTP. Из-за отсутствия SSL/TLS иногда во время обновления прошивки можно перехватить сетевой трафик для получения файлов. При этом есть возможность и загрузки зловредных обновлений прошивок. (См. [этот пост ZDI](https://www.zerodayinitiative.com/blog/2021/5/24/cve-2021-22909-digging-into-a-ubiquiti-firmware-update-bug)).
### ▍ 3. При помощи оборудования
Последовательное соединение: для автоматизации этого процесса существует множество отличных инструментов и руководств, например, [это](https://cybergibbons.com/hardware-hacking/recovering-firmware-through-u-boot/). Из загрузчика устройства обычно можно считывать содержимое флэш-памяти, в котором содержится образ прошивки! (Так как он ещё не был скопирован в ОЗУ.)
Дамп флэш-памяти: существует множество специализированных руководств, например, [это](https://www.riverloopsecurity.com/blog/2020/03/hw-101-emmc/). При помощи специализированных аппаратных инструментов (например, TL866II+) можно физически подключиться к флэш-чипам платы (отпаяв их или специальными зажимами), а затем считать содержимое.
### FIN
[](https://bit.ly/3N6JBGr?utm_source=habr&utm_medium=article&utm_campaign=ru_vds&utm_content=apparatnyj_vzlom_dlya_programmnyx_xakerov) | https://habr.com/ru/post/669276/ | null | ru | null |
# Автоматическое подключение css и js файлов в Yii
Доброго времени суток.
На этот раз хочу, рассказать о способе автоматического подключения css и js файлов в Yii. Идея заключается в том, что бы к каждому файлу вида привязывать соответствующую папку с ресурсами (css, js, images). Это удобно, т.к. в большенстве случаев конкретные «assets» используются для конкретных файлов вида.
И так, ближе к коду. Расширим класс Controller (который наверняка лежит у вас в папке «components» :)), добавив в него следующую функциональность:
```
/**
* Array of paths of assets
* @var array
*/
private $_assetsPaths = array();
/**
* Array of asset Url
* @var array
*/
private $_assetsUrl = array();
/**
* Name of directory for css files
* @var strign
*/
protected $_cssDirName = 'css';
/**
* Default file name of css
* @var string
*/
protected $_defaultCssFile = 'index.css';
/**
* Name of directory for script files
* @var strign
*/
protected $_scriptDirName = 'js';
/**
* Default file name of script
* @var string
*/
protected $_defaultScriptFile = 'index.js';
/**
* Name of directory for images
* @var strign
*/
protected $_imageDirName = 'images';
/**
* This method is invoked at the beginning of {@link render()}.
*
* @param string $view the view to be rendered
* @return boolean whether the view should be rendered.
*/
protected function beforeRender($view)
{
$this->_setupScript($view);
$this->_setupCss($view);
$viewCamelCase = preg_replace_callback(
'/_([a-z0-9])/',
function ($char) {
return strtoupper($char[1]);
},
ucfirst($view)
);
$methodScript = '_setupScript' . $viewCamelCase;
if (method_exists($this, $methodScript)) {
$this->$methodScript($view);
}
$methodCss = '_setupCss' . $viewCamelCase;
if (method_exists($this, $methodCss)) {
$this->$methodCss($view);
}
return true;
}
/**
* Setup script files
*
* @param string $view
* @return void
*/
protected function _setupScript($view)
{
$scriptRealPath = $this->getScriptPath($view, $this->_defaultScriptFile);
if (is_file($scriptRealPath)) {
$scriptPublishedUrl = $this->getScriptUrl($view, $this->_defaultScriptFile);
Yii::app()->clientScript->registerScriptFile($scriptPublishedUrl);
}
}
/**
* Setup css files
*
* @param string $view
* @return void
*/
protected function _setupCss($view)
{
$cssRealPath = $this->getCssPath($view, $this->_defaultCssFile);
if (is_file($cssRealPath)) {
$cssPublishedUrl = $this->getCssUrl($view, $this->_defaultCssFile);
Yii::app()->clientScript->registerCssFile($cssPublishedUrl);
}
}
/**
* Returns the published script URL
*
* @param string $view
* @param string $fileName
* @return string|false
*/
public function getScriptUrl($view, $fileName)
{
if (($publishedUrl = $this->getPublishedAssetsUrl($view))) {
return $publishedUrl . '/' . $this->_scriptDirName . '/' . $fileName;
}
return false;
}
/**
* Returns the real script Path
*
* @param string $fileName
* @param string $view
* @return string|false
*/
public function getScriptPath($view, $fileName)
{
if (($path = $this->getAssetsPath($view))) {
return $path . DIRECTORY_SEPARATOR . $this->_scriptDirName . DIRECTORY_SEPARATOR . $fileName;
}
return false;
}
/**
* Returns the published css URL
*
* @param string $view
* @param string $fileName
* @return string|false
*/
public function getCssUrl($view, $fileName)
{
if (($publishedUrl = $this->getPublishedAssetsUrl($view))) {
return $publishedUrl . '/' . $this->_cssDirName . '/' . $fileName;
}
return false;
}
/**
* Returns the real css path
*
* @param string $view
* @param string $fileName
* @return string|false
*/
public function getCssPath($view, $fileName)
{
if (($path = $this->getAssetsPath($view))) {
return $path . DIRECTORY_SEPARATOR . $this->_cssDirName . DIRECTORY_SEPARATOR . $fileName;
}
return false;
}
/**
* Returns the published image URL
*
* @param string $view
* @param string $fileName
* @return string|false
*/
public function getImageUrl($view, $fileName)
{
if (($publishedUrl = $this->getPublishedAssetsUrl($view))) {
return $publishedUrl . '/' . $this->_imageDirName . '/' . $fileName;
}
return false;
}
/**
* Returns the real image path
*
* @param string $view
* @param string $fileName
* @return string|false
*/
public function getImagePath($view, $fileName)
{
if (($path = $this->getAssetsPath($view))) {
return $path . DIRECTORY_SEPARATOR . $this->_imageDirName . DIRECTORY_SEPARATOR . $fileName;
}
return false;
}
/**
* Returns alias of assets
*
* @param string $view
* @return string|false
*/
protected function getAssetsPath($view)
{
if (!array_key_exists($view, $this->_assetsPaths)) {
$assetPath = false;
$viewPath = $this->getViewFile($view);
if ($viewPath) {
if (($pos = strrpos($viewPath, DIRECTORY_SEPARATOR . 'views' . DIRECTORY_SEPARATOR)) !== false) {
$extension = ($renderer=Yii::app()->getViewRenderer()) !== null ?
$renderer->fileExtension :
'.php';
$assetPath = substr($viewPath, 0, $pos) . DIRECTORY_SEPARATOR
. 'assets'
. substr($viewPath, $pos + 1 + strlen('views'));
$assetPath = dirname($assetPath) . DIRECTORY_SEPARATOR . basename($assetPath, $extension);
}
}
$this->_assetsPaths[$view] = $assetPath;
}
return $this->_assetsPaths[$view];
}
/**
* Returns the published asset URL
*
* @param string $view
* @return string|false
*/
public function getPublishedAssetsUrl($view)
{
if (!array_key_exists($view, $this->_assetsUrl)) {
$assetsUrl = false;
$assetsPath = $this->getAssetsPath($view);
if ($assetsPath) {
$assetsUrl = Yii::app()->assetManager->publish($assetsPath);
}
$this->_assetsUrl[$view] = $assetsUrl;
}
return $this->_assetsUrl[$view];
}
```
Разберем как это работает. В «beforeRender($view)» перед рендерингом вызываются методы:
```
// Подключение скриптов (по умолчанию подключает файл по пути assets/{controllerName}/{viewName}/js/index.js)
_setupScript($view)
// Подключение стилей (по умолчанию подключает файл по пути assets/{controllerName}/{viewName}/css/index.css)
_setupCss($view)
```
В них происходит автоматическое подключение соответствующих css и js файлов для заданного файла вида.
Далее, здесь же в «beforeRender()» запускаются дополнительные методы для подключения стилей и скриптов (если они определены). Отличие этих методов от предыдущих в том, что они привязаны к конкретному файлу вида. Т.е. в формировании названия соответствующего метода участвует имя файла вида, например, имя метода для скриптов складывается из правила: "\_setupScript" + «Имя файла вида в верблюжьей нотации», для стилей: "\_setupCss" + «Имя файла вида в верблюжьей нотации».
Так же теперь нам доступны следующие методы:
Методы возвращающие URL адреса до опубликованных ресурсов:
```
getScriptUrl($view, $fileName) // возвращает URL адрес до js файла
getCssUrl($view, $fileName) // возвращает URL адрес до css файла
getImageUrl($view, $fileName) // возвращает URL адрес до файла изображения
```
Методы возвращающие реальные пути ресурсов (в папке assets в protected):
```
getScriptPath($view, $fileName) // возвращает путь до js файл
getCssPath($view, $fileName) // возвращает путь до css файл
getImagePath($view, $fileName) // возвращает путь до файл изображения
```
И общие методы:
```
getAssetsAlias($view) // возвращает алиас до папки "assets", которая лежит в protected
getPublishedAssetsUrl($view) // возвращает URL адрес до опубликованной директории "assets"
```
Имена директорий (для js, css файлов и изображений) и файлов по умолчанию определены в свойствах класса контроллера.
```
protected $_cssDirName = 'css';
protected $_defaultCssFile = 'index.css';
protected $_scriptDirName = 'js';
protected $_defaultScriptFile = 'index.js';
protected $_imageDirName = 'images';
```
Соответственно вы можете изменить их на нужные вам. По желанию можно вынести их в конфиг приложения, проделав несложные модификации в коде.
##### Использование.
Вы можете либо переопределить метод "\_setupCss($view)", если вам нужно подключать css файлы для всех возможных файлов вида контроллера:
```
/**
* Setup css files
*
* @param string $view
* @return void
*/
protected function _setupCss($view)
{
parent::_setupCss($view);
// будет искать my_css_file.css для каждого файла вида
Yii::app()->clientScript->registerCssFile($this->getCssUrl($view, 'my_css_file.css'));
}
```
Либо определить метод "\_setupCss" + «Имя файла вида в верблюжьей нотации», если вам нужно подключать css файлы для конкретного файла вида:
```
/**
* Setup css files
*
* @param string $view
* @return void
*/
protected function _setupCssRegistration($view)
{
Yii::app()->clientScript->registerCssFile($this->getCssUrl($view, 'my_css_file.css'));
}
```
Данный метод будет вызван только при рендеринге «registration»
Картинки можно получать так:
```
CHtml::image($this->getImageUrl($view));
```
На это всё. Всем спасибо за внимание. | https://habr.com/ru/post/150885/ | null | ru | null |
# Эволюция Java на примере чтения строк из файла
Приведу небольшой и интересный, на мой взгляд, пример, как изменилась жизнь простого крестьянина Java разработчика, на примере задачи чтения и печати строк из файла.
Многие из нас помнят
'до Java 7' мучения:
--------------------
```
BufferedReader reader = null;
try {
reader = new BufferedReader(
new InputStreamReader(
new FileInputStream(FILE_NAME), Charset.forName("UTF-8")));
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
// log error
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
// log warning
}
}
}
```
которые могли облегчить, разве что
Apache [Commons IO](https://commons.apache.org/proper/commons-io/)
------------------------------------------------------------------
```
InputStreamReader in = null;
try {
in = new InputStreamReader(new FileInputStream(new File(FILE_NAME)), Charsets.UTF_8);
LineIterator it = new LineIterator(in);
while (it.hasNext()) {
System.out.println(it.nextLine());
}
} catch (IOException e) {
// log error
} finally {
IOUtils.closeQuietly(in);
}
```
Или даже так:
```
LineIterator it = null;
try {
it = FileUtils.lineIterator(new File(FILE_NAME), "UTF-8");
while (it.hasNext()) {
System.out.println(it.nextLine());
}
} catch (IOException e) {
// log error
} finally {
if (it != null) {
it.close();
}
}
```
Java 7
------
принесла [automatic resource management (ARM)](http://www.journaldev.com/592/try-with-resource-example-java-7-feature-for-automatic-resource-management), [NIO.2](http://www.quizful.net/post/java-nio-tutorial) и [StandardCharsets](http://docs.oracle.com/javase/7/docs/api/java/nio/charset/StandardCharsets.html). Теперь без подключения сторонних библиотек появилась возможность сделать:
```
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(
new FileInputStream(FILE_NAME), StandardCharsets.UTF_8))){
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
// log error
}
```
или еще короче:
```
List lines = Files.readAllLines(Paths.get(FILE\_NAME), StandardCharsets.UTF\_8);
for(String line: lines){
System.out.println(line);
}
```
И, наконец:
Java 8
------
со своим [Stream API](http://prologistic.com.ua/polnoe-rukovodstvo-po-java-8-stream.html) и [Лямбда-выражениями](http://habrahabr.ru/post/224593/) позволила сделать это в одну строчку:
```
Files.lines(Paths.get(FILE_NAME), StandardCharsets.UTF_8).forEach(System.out::println);
```
Мораль: если у вас современная Java — надо делать хорошо, и не надо плохо.
Спасибо за внимание и успехов в кодировании! | https://habr.com/ru/post/269667/ | null | ru | null |
# Как я не написал эксплоит
Приветствую всех читателей. В своем блоге я опубликовал много статей о том, как я находил уязвимости в разных продуктах. Но все истории-исследования заканчиваются победой. В этот раз я решил поделиться историей неуспеха. Небольшое исследование, которое заняло у меня где-то 5-6 часов, в ходе которого я был близок к созданию интересного эксплоита, но магия не случилась.
Как легко заметить, я люблю искать уязвимости на повышение привилегий. Обычно такие уязвимости позволяют подняться с уровня прав обычного пользователя, до уровня прав администратора или системы (**NT AUTHORITY\SYSTEM**). Но в данном случае, я решил рассмотреть другой вариант: поднятие прав с уровня **NT AUTHORITY\LOCAL SERVICE** до **NT AUTHORITY\SYSTEM**.
Начало
------
Все началось со статьи про [уязвимость повышения привилегий в Windows 7](https://itm4n.github.io/windows-registry-rpceptmapper-eop/). Уязвимость состоит в том, что по умолчанию Windows 7 в реестре две ветки имеют интересные права для пользователя ОС. А именно ветки
> HKLM\SYSTEM\CurrentControlSet\Services\Dnscache
>
> HKLM\SYSTEM\CurrentControlSet\Services\RpcEptMapper
позволяют пользователю без прав администратора создавать разделы внутри себя. Исследователь показал, что можно создать раздел Performance, внутри которого указать dll. После некоторых команд эта dll будет загружена в пространство сервиса и тем самым исполнит код от имени NT AUTHORITY\SYSTEM, который предоставит пользователь с низкими правами. В старших версиях Windows такие прав уже нет и, вроде, даже для семерки были выпущены патчи. Запомним саму идею уязвимости.
Теперь посмотрим на сервисы с другой стороны. Обычно сервисы работают от имени одного из трех пользователей: NT AUTHORITY\SYSTEM (максимальные права), NT AUTHORITY\LOCAL SERVICE (права выше, чем у пользователей, но не такие высокие как NT AUTHORITY\SYSTEM) или NT AUTHORITY\NETWORK SERVICE (права как у предыдущего, но может проводить аутентификацию по сети). Иногда в ходе атак можно получить права NT AUTHORITY\LOCAL SERVICE и тут появляется вопрос, что же делать дальше? Вроде и права выше пользовательских (например есть привилегия SeImpersonatePrivilege), но, например, свободно читать файлы пользователей прав нет. Обычно в таких ситуация используют что-то из «картофельного» семейства: [Rotten Potato](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/), [Juicy Potato](https://github.com/ohpe/juicy-potato) и другие. Я решил посмотреть, а не найдется ли что-то свое.
Исследование
------------
Совмещая идеи из предыдущих абзацев, получаем общую канву исследования. Пробуем посмотреть на права в реестре, кому и что разрешено. Я взял свою [утилиту SDDLViewer](https://habr.com/ru/company/pm/blog/442662/), указал ветку реестра HKEY\_LOCAL\_MACHINE\SYSTEM\ControlSet001\Services, убрал пользователей, которые нам не интересны (администраторы, система), убрал права на чтение и получилось вот что:
`HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Services\Dhcp
D:(A;;LC;;;NT SERVICE\Dhcp)(A;CIIO;LC;;;NT SERVICE\Dhcp)
HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Services\W32Time
D:(A;;DCLC;;;NT SERVICE\autotimesvc)(A;CIIO;GW;;;NT SERVICE\autotimesvc)`
Эти строки говорят, что пользователь NT SERVICE\Dhcp может создавать подразделы в своей ветке, а пользователь NT SERVICE\Autotime может делать все что угодно в ветке сервиса W32Time. Имена пользователей вида NT SERVICE\НазваниеСервиса — это специальные пользователи или даже точнее сказать метки, которые получают соответствующие процессы сервисов. Поскольку сервис Dhcp по умолчанию запущен, прав на остановку у нас нет, то и рассматривать его я не стал.
А вот сервис W32Time довольно интересен, поскольку на него может влиять другой процесс, а именно сервис autotimesvc. Более того, не обязательно пользоваться идеей с созданием подраздела. У autotimesvc полные права на всю ветку, а значит можно поставить свой бинарный файл и указать пользователя NT AUTHORITY\SYSTEM. Кроме этого, запрашиваем права самого сервиса в видим:
`Windows Time (W32Time)
D:(A;;RPWP;;;LS)`
На человеческом языке это означает, что NT AUTHORITY\LOCAL SERVICE может останавливать и запускать этот сервис. Все складывается просто идеально. Осталось только попасть в контекст сервиса autotimesvc.
Первые трудности
----------------
Сервис autotimesvc не имеет никаких особых отличий от других сервисов. Плюсы: работает от имени NT AUTHORITY\LOCAL SERVICE, что позволяет нам в него влезть. Минусы: запустить и остановить этот сервис могут только администраторы и NT AUTHORITY\SYSTEM.
Вся наша цепочка действий в итоге завязана на необходимость запуска сервиса autotimesvc. Если права не позволяют запустить сервис, то посмотрим на альтернативные возможности. У некоторых сервисов есть возможность запуска по триггерам. Запрос информации по триггерам сервиса: sc qtriggerinfo autotimesvc:
Хорошая новость: триггер есть. Плохая: это какой-то непонятный триггер.
Тут стоит сделать уточнение, что существует разные триггеры: вход в домен, получение сетевого пакета, событие системы ETW и другие. Я очень надеялся на то, что будет именно ETW, потому что такие события может создавать любой пользователь и так можно было бы запустить сервис. Но вот что такое «СОБЫТИЕ ИЗМЕНЕНИЯ НАСТРАИВАЕМОГО СОСТОЯНИЯ СИСТЕМЫ»?
Полезем смотреть в реестр за более подробными данными.
Смотрим: Action = 1 это значит, что при триггере сервис будет запущен.
Data0 — какие-то данные
GUID — идентификатор триггера
Type = 7 — тип триггера
Идем в [MSDN за пояснениями](https://docs.microsoft.com/en-us/windows/win32/api/winsvc/ns-winsvc-service_trigger). А там нет типа 7, он незадокументирован. Включаем гугл-фу. [Находим хоть что-то](http://www.gaclib.net/CodeIndexDemo/Gaclib/SourceFiles/winsvc.h.html), что показывает, что тип 7 и GUID из реестра связаны между собой.
```
//
// CUSTOM_SYSTEM_STATE_CHANGE_EVENT_GUID is used with SERVICE_TRIGGER_TYPE_CUSTOM_SYSTEM_STATE_CHANGE
//
DEFINE_GUID ( /* 2d7a2816-0c5e-45fc-9ce7-570e5ecde9c9 */
CUSTOM_SYSTEM_STATE_CHANGE_EVENT_GUID,
0x2d7a2816,
0x0c5e,
0x45fc,
0x9c, 0xe7, 0x57, 0x0e, 0x5e, 0xcd, 0xe9, 0xc9
);
/* 2d7a2816-0c5e-45fc-9ce7-570e5ecde9c9 */extern "C" const GUID CUSTOM_SYSTEM_STATE_CHANGE_EVENT_GUID;
```
Но это пока не приближает нас к пониманию как же этот триггер задействовать. Я собрал из реестра все подобные триггеры и стал смотреть на данные в поле Data0. Все они были как-то похожи:
`7518BCA32C0FC641
75D0BEA32E0B8A0D
7530BCA32B188341
7538BCA32F029209
7548BCA32F029209
7558BCA32F029209
7568BCA32F029209
7538BCA32F029209
7548BCA32F029209
7558BCA32F029209
7568BCA32F029209
...`
Погуглив по разным вариантам, я обнаружил, что если взять первые 4 байта в обратном порядке, то начинают появляться интересные [ссылки](http://redplait.blogspot.com/2017/08/wnf-ids-from-perfntcdll.html). Дальнейшие поиски точно показали, что речь идет о подсистеме WNF и ее событиях.
Более того, я наше свой вариант Data0 под названием: WNF\_CELL\_NITZ\_INFO 0xd8a0b2ea3bed075. Ключевое слово NITZ фигурирует и в описании сервиса autotimesvc.
Последний рубеж
---------------
WNF хоть и не очень хорошо документирован, но Алекс Ионеску все же внес огромный вклад и даже подготовил [утилиты по работе с событиями WNF](https://github.com/ionescu007/wnfun/).
Цель уже близка, вся цепочка действий зависит только от возможности изменить событие WNF\_CELL\_NITZ\_INFO. Пробуем сделать это из под обычного пользователя — отказ в доступе. Пробуем из под NT AUTHORITY\LOCAL SERVICE — отказ в доступе.
Запрашиваем очередной SDDL для этого события и получаем:
`D:(A;;CCDC;;;SY)(A;;CCDC;;;NT SERVICE\WwanSvc)(A;;CCDC;;;BA)(A;;CC;;;AU)(A;;CC;;;IU)`
CC — чтение данных, DC — запись. Видим, что изменить состояние могут либо администраторы, либо сервис WwanSvc. Нам не привыкать, смотрим, что еще за сервис появился. А вот тут все — этот сервис работает уже под пользователем NT AUTHORITY\SYSTEM и не имеет каких-то особых вариантов для воздействия. Вот на этом мое исследование и кончилось. Цепочка действий не сложилась — эксплоит я не написал.
Заключение
----------
Здесь можно поставить много слов «если». Если бы сервис WwanSvc работал бы от имени NT AUTHORITY\LOCAL SERVICE… Если бы права были не такими ограничивающими… Если бы еще что-то было, то вот тогда я точно бы все реализовал. Но, как я уже сказал в начале статьи — не всякое исследование обязательно успешное. Я потратил время, но получил новый опыт, узнал о WNF. Возможно я где-то свернул не туда и кто-то другой сумеет реализовать эту идею, а может я сам вернусь к ней спустя время. В любом случае это было интересное путешествие. | https://habr.com/ru/post/556088/ | null | ru | null |
# Делаем дашборды для Grafana из того, что отдает экспортер метрик Prometheus и автоматизируем это
Во время работы с конвеером данных, в результате работы которого у нас появлялись данные в Timescale, [которые мы визуализировали в виде тепловых карт прошлой статье](https://habr.com/ru/post/668468/), у нас было задействовано много разных компонентов, каждый из которых норовил упасть или привнести свою лепту в задержку появления данных в базе и на фронт-энде.
Поэтому в моей обязанности было и ведение мониторинга, причем не только для знакомого мне стека как разработчику Spring Boot (в нашем случае это был Apache Camel), но вообще всего, до чего можно было дотянуться. Если с Timescale, Apollo Nodejs Graphql, MQTT, JMeter (там было постоянное нагрузочное тестирование на тест стенде) и сервисами на Golang проблем не возникло, после настройки экспорта их стандартных метрик в Prometheus в формате Micrometer удалось почти сразу же найти [подходящие готовые дашборды на сайте Grafana](https://grafana.com/grafana/dashboards/), если с дашбордами под метрики k8s было еще проще - они шли как provisioned в helm-chart-е [kube-prometheus-stack](https://github.com/prometheus-community/helm-charts/tree/main/charts/kube-prometheus-stack), то с остальным зоопарком оказалось сложнее.
Так, для Apache Camel и его кастомных метрик, сконфигурированных под каждый маршрут, пришлось существенно допиливать один из готовых дашбордов, приспособленных под визуализацию данных при [включенном Spring Boot Actuator](https://docs.spring.io/spring-boot/docs/current/reference/html/actuator.html) и собираемых с эндпойнта `/actuator/prometheus`. Дашборд по мотивам этого приключения [выложен в галлерею дашбордов](https://grafana.com/grafana/dashboards/16354-data-integration-check/) с краткой инструкцией, как им воспользоваться.
Гораздо хуже была ситуация с Apache Spark. Для него включались метрики [при помощи некой копипасты для его конфига](https://github.com/GoogleCloudPlatform/spark-on-k8s-operator/blob/master/spark-docker/conf/prometheus.yaml), который позволяет отдать в формате Micrometer внутренние метрики "спарка", отфильтровав и немного их переименовав, и которая стала практически промышленным стандартом. В момент, когда эти метрики стали собираться, на нас вывалился огромный массив метрик, на которые надо сначала глазами посмотреть, прежде чем разбираться, о чем конкретная метрика и информативна ли она. Надо было как-то автоматизировать процесс - взять портянку выданных Apache Spark метрик и создать дашборд о десятках панелей, чтобы уже глядя в них разбираться. Это мягко говоря, против того подхода, когда дашборды в Grafana делаются плавно и очень осмысленно, избегая непонятного и лишнего, но нам это нужно было скорее в первую очередь для exploratory testing, чем для промышленного мониторинга.
Был написан код, который создавал JSON-конфиг для импорта данных как нового дашборда в Grafana, анализируя скопированный вывод экспортера метрик для Prometheus в фромате Micrometer. Делал он довольно просто и примитивно - оказалось, что присуствующие человекопонятные имена метрик, которые иногда приходят в разделе `#HELP` формата Micrometer, совершенно неинформативны. Метрики команда запоминала по самому названию и написанию метрик, а если дашборду хотелось дать более "бизнесовое" имя, то это делалось сильно позже, не в момент создания дашборда.
Кроме того, быстро стало понятно, что анализ любой метрики лучше делать, глядя на 2 графика - нормального вида измеряемого показателя и его "первой производной" по времени - функции Grafana `rate()`. При этом в заголовок дашборда, когда в нем много панелей, оказалось удобнее вывести `rate(имя_метрики[5m])` чтобы мнговенно находить глазами сопоставление с ней оригинального графика со значениями.
Впоследствии добавили еще дашборд для наблюдения за Hadoop. К нему никаких плагинов для экспорта метрик не полагалось, поэтому пошли на хитрость. К Grafana можно [подключить в качестве второго](https://stackoverflow.com/questions/68794873/loki-that-is-set-up-as-prometheus-datasource-in-order-to-have-alerts-on-log-coun) "прометеуса"... Loki. Далее, выбрав "именно такое Локи" в качестве "датасорса" (Loki подключенное как Loki не подойдет) можно добавлять алерты на запросы, которые в Loki ходят за счетчиком логов.
Например, можно попросить построить вот такую вот метрику:
`count_over_time({app="hadoop"} |="INFO org.apache.hadoop.hdfs.server.datanode.DataNode: Receiving"[5m])`
Что выдаст некий график, сколько раз за 5 минут лог был записан, а этот лог признак стабильной работы. Затем с графиком можно строить производную, можно вешать оповещение на выставленные для него пороги, в общим, полный функционал метрики от Prometheus. Так удалось сделать алерты и на его работу.
Сделанные дашборды были загружены [в мою скромную галлерею](https://grafana.com/orgs/eljah/dashboards) на grafana.com. Оказалось, что за прошедший год их даже кто-то скачивал, что означало лишь одно: граждане мониторящие продолжают сталкиваться с нехваткой готовых дашборд в ситуации, когда у них появляется целая куча новых метрик, за которыми ранее не следили. Ведь кроме стандартных метрик от приложений и фреймворков, разработчики могут насоздавать великое множество метрик уровня приложения, но делать красивые панели для каждой метрики в ручную им может и не захотеться. Если не сделать нам панель, эдак мы и за своими метриками следить расхотим, надо как-то упростить жизнь и сделать внедрение метрик и наблюдения за ними максимально простым.
Было решено сделать небольшую веб-утилиту, которая позволила бы проделать онлайн то же, что мы проделывали ранее в консольном приложении для метрик "спарка". Попробовать ее можно здесь: <http://eljah.tatar/micrometer2grafana>
* UPD. Да, код ее открыт, если вдруг в вашей компании понадобится развернуть подобное с некоторыми изменениями, то вот, микроскопический java-проект под Tomcat 10 и jakarta.servlet: <https://github.com/Eljah/micrometer2grafana>
Что нужно сделать? Сначала скопируйте у себя текст метрик, как их отдает экспортер интересующего вас приложения
Пример взят для Apache Camel под Spring BootСкопируйте в поле ввода. Выберите, хотите вы оригинальные метрики, "производную по времени" с указанным временем "шага" или оба варианта сразу, также надо ввести название datasource у вас в "графане", уникальный идентификатор и заголовок для нового дашборда (если вас не устраивают предложенные по умолчанию).
С момента публикации, надеюсь, появятся дополнительные поля и настройки, если будет о том обратная связьСкопируйте возвращенный JSON, это ваш конфиг, который нужно импортировать в Grafana.
Делать страницу с особым копирабельным выводом не хватило времени и упорства. По-моему, выделить и скопировать в 1 клик можно и для вывода с text/plain, а больше и не нужно ничегоИменно отсюда надо загружать конфиг-JSONПосле импорта, если вы выбрали одновременно и оригинальную метрику и производную, можно посмотреть, какую порой разную информацию можно получить в каждом случае:
В первом случае видна динамика роста времени коннектов, но это малоинформативно, ведь \_sum всегда будет копиться и расти. Нижняя метрика, показывающая, как менялась скорость роста этой метрики куда информативнее о работе системы. Если вы нашли эту статью, использовали утилиту и у вас появилась обратная связь, напишите в комментариях. Буду мониторить! | https://habr.com/ru/post/711280/ | null | ru | null |
# REACT + JEST = TDD ❤️
Привет, Хабр! Меня зовут Андрей Хижняк, я фронтенд-разработчик в команде, разрабатывающей App Store внутри ManyChat.
Как и моим коллегам, мне нравится пробовать новые подходы, методологии и практики, заниматься повышением качества и скорости разработки. В начале этого года мы с командой решили попробовать одну из техник экстремального программирования — TDD.
От том, что из этого вышло, и будет моя статья, добро пожаловать под кат!
Итак, начнем с определений
--------------------------
* Test-Driven Development (TDD) — одна из техник экстремального программирования, основанная на 3-х шаговом цикле разработки:
1. Пишем тест на функциональность, которую собираемся добавить.
2. Пишем код, чтобы тест прошел.
3. Делаем рефакторинг теста и кода, если нужно.
* Jest — восхитительный (как они сами себя называют) JavaScript framework для тестирования с акцентом на простоту.
* React — думаю, в представлении не нуждается.
Зачем нужен TDD
---------------
Многие разработчики до сих пор сомневаются в практический пользе TDD. Мне, однако, кажутся убедительными [исследования](https://link.springer.com/article/10.1007%2Fs10664-008-9062-z) с тремя группами разработчиков из Microsoft и одной из IBM, которые внедрили TDD. Результаты этих исследований показали, что количество pre-release bugs всех четырех продуктов снизилось на 40–90% по сравнению с аналогичными продуктами, в которых практика TDD не использовалась.
Как и любая другая методология, TDD обладает не только плюсами, но и минусами. Если просто их перечислить, то из основных минусов можно выделить:
1. Высокий порог вхождения — начинающим разработчикам будет труднее понять такой подход к разработке.
2. Перманентная дисциплина — нельзя писать код раньше тестов.
3. Снижение скорости разработки, большие ресурсные инвестиции на старте.
4. Непонимание самой техники, неправильное применение.
Все это действительно имеет место, но каждый из минусов на практике разрешим.
А теперь перейдем к плюсам:
1. Качество — тестопригодный код, заранее покрытый тестами.
2. Архитектура — TDD поощряет модульность (не поощряет связанность).
3. Масштабируемость — модульный код покрытый тестами легко развивать и рефакторить.
4. Устойчивость — коллеги ничего вам незаметно не сломают.
5. Комфорт разработки — сначала пишется весь код, и только потом запускается проект для финального ручного тестирования и верстки.
6. Ваш код делает ровно то, чего вы ожидаете от него в тестах.
Почему мы выбрали TDD, а не просто Unit-тесты
---------------------------------------------
В какой-то момент договоренности о покрытии unit-тестами важной и сложной логики привели нас к тому, что покрытие кодовой базы было минимальным, да и тесты писались очень редко.
Мы решили искать новые практики, которые помогли бы не только снизить количество багов, но и позволяли развивать Tecnhical Excellence. Все продуктовые команды в ManyChat сами выбирают, какие практики использовать в работе; наша команда решила поэкспериментировать и попробовать TDD. Этому выбору также поспособствовала внутренняя инженерная школа, направленная на улучшение процессов и инженерных практик, в рамках которой мы, в том числе, рассматривали TDD.
Чтобы увидеть преимущества TDD (test first) методологии перед обычными unit-тестами (test last), достаточно пошагово сравнить два этих подхода.
#### Первым шагом продумываем то, что собираемся написать
При test last подходе не нужно много думать — можно сразу переходить к написанию кода. Однако разработка через тесты устроена совсем иным образом. Процесс мышления отличается и требует серьезной дисциплины и навыков. В зависимости от своего уровня можно выбрать один из следующих способов начать:
1. Написать код и закомментировать его. Будьте готовы выбросить или переписать его после написания теста (уровень Junior).
2. Представить код, который собираетесь написать, но не писать его (уровень Middle).
3. Представить примерную архитектуру того, к чему собираетесь прикоснуться: как сущности и интерфейсы будут взаимодействовать (уровень Senior).
В начале будут возникать объективные трудности, снизится скорость разработки — это нормально и, более того, неизбежно. Но опыт показывает, что со временем будет и повышаться уровень, и увеличиваться скорость в разработке через тесты. Нам понадобилось два месяца, чтобы вернуться на исходную скорость, но уже с TDD.
Кроме того, хотя можно и сразу перейти к написанию кода при обычном тестировании, нужно понимать, что это то же самое, как действовать, заранее не задумываясь.
#### Вторым шагом пишем Unit-тест
Когда не нужно изучать код, который мы собираемся покрыть, писать тест очевидно проще. Нет кода — нет головной боли. Просто пишем unit-тест так, как хотим.
При test last подходе придется не только потратить значительное время на изучение существующего кода, даже если мы написали его недавно, но и довольно часто его исправлять, чтобы он был пригодным для тестирования. Когда мы пишем код, не всегда удается держать в голове предстоящее написание unit-тестов. Вопрос мотивации также не обойти стороной, ведь когда код написан, еще нужно побороться с прокрастинацией и не заскучать до смерти, чтобы писать unit-тесты для уже работающего кода.
#### Третьим шагом пишем код
С TDD подходом нужно просто «позеленить» тест и не придумывать ничего лишнего. В то же время при test last подходе, вполне вероятно, мы напишем больше кода, чем нужно, тем самым добавив потенциально мертвый код (который, возможно, никогда нам не понадобится). Кроме того, придется покрыть его unit-тестами, тем самым увеличив расходы на тестирование.
#### Четвертым шагом убеждаемся, что Unit-тест проходит
Оба подхода требуют примерно одинаковых усилий для запуска unit-тестов в целях проверки. Однако при test last нужно будет постоянно подстраивать unit-тесты так, чтобы они наконец прошли. Ведь изменение рабочего кода — это последнее, чего мы хотим на этом этапе. Если мы все-таки изменим рабочий код, то нужно будет убедиться, что он все еще работает, а это может быть очень затратно. В то время как с TDD тест уже написан, и мы просто ожидаем, что он пройдет.
#### Пятым шагом запускаем приложение для финальной проверки
Здесь мы получаем еще одно значительное преимущество TDD. С ним необходимо запускать приложение только 1-2 раза и в большинстве случаев оно будет работать так, как мы ожидаем, потому что unit-тесты уже проверили код. Остается только поправить верстку и провести необходимое ручное тестирование.
С другой стороны, при test last нужно запускать приложение множество раз при написании кода. Либо можно написать слишком много кода, а затем отлаживать и исправлять каждый шаг, либо писать небольшими частями и каждый раз их запускать. В любом случае выполнение, отладка и исправление выполняются намного дольше, чем просто запуск готовых unit-тестов, написанных через TDD.
#### И победителем становится...
Преимущество TDD над обычными unit-тестами, на мой взгляд, очевидно. Эта методология разработки мотивирует в первую очередь подумать, а не приступить. Это позволяет глубже погрузиться в задачу и не упустить всевозможные корнер-кейсы. Кроме того, мы экономим время и силы делая только то, что необходимо. В подарок к этому получается чистая модульная архитектура, покрытая тестами. И самое главное — наш код делает ровно то, чего мы от него ожидаем.
TDD на практике
---------------
### От «it('renders component', () ⇒ {...})» до финального решения на примере модального окна с логикой
В этом примере я сознательно откажусь от использования Redux и кастомных решений для react-test-renderer и Jest, чтобы снизить порог вхождения. Однако если эти темы вам интересны, сообщите об этом в комментариях, и мы напишем отдельную статью.
Все тесты мы пишем с использованием [react-test-renderer](https://reactjs.org/docs/test-renderer.html), а не [testing-library](https://testing-library.com), чтобы избежать затраты на зависимость от реального DOM. Это особенно важно, когда число unit-тестов в проекте уже превышает 4000.
#### Задача
Реализовать модальное окно публикации приложения.
#### Критерии приемки
1. Как пользователь, я хочу видеть модальное окно с названием приложения в заголовке.
2. Как пользователь, я хочу отправить приложение на публикацию.
3. Как пользователь, я хочу чтобы модальное окно закрылось после отправки на публикацию.
4. Как пользователь, я хочу отправить public приложение на публикацию повторно.
#### Реализация
Вместе с переходом на TDD мы также перешли на TypeScript, поэтому все примеры будут показаны именно на нем.
**1.1**
Как и полагается, приступаем к решению задачи с обдумывания всего, что собираемся сделать. В первую очередь, нам нужно отрисовать модальное окно определенной ширины.
**1.2**
Первый тест будет проверять, что модальное окно (из нашего UI Kit'a) отрендерилось с заданной шириной:
```
// ApplicationPublishModal.test.tsx
import React from 'react'
import { create } from 'react-test-renderer'
import * as ManyUI from '@manychat/manyui'
// наш компонент - пока пустой
import ApplicationPublishModal from '.'
// нас не интересует реализация самого модального окна, поэтому делаем mock
ManyUI.Modal = jest.fn().mockImplementation(() => null)
describe('ApplicationPublishModal', () => {
it('renders Modal with props open and width', () => {
// arrange
// достаточен mock модалки
// act
const renderer = create()
// assert
const element = renderer.root.findByType(ManyUI.Modal)
expect(element.props.open).toBe(true)
expect(element.props.width).toBe(480)
})
})
```
**1.3**
Код минимально необходимый для того, чтобы «позеленить» наш тест:
```
// ApplicationPublishModal.tsx
import React from 'react'
import { Modal } from '@manychat/manyui'
const ApplicationPublishModal: React.FC = () => {
return
}
export default ApplicationPublishModal
```
**1.4**
На четвертом шаге мы сначала должны убедиться, что тест прошел, при необходимости сделать рефакторинг, и только после этого переходить к следующей итерации.
**2.1**
Второй итерацией добавим в модальное окно заголовок, сформированный из названия приложения, полученного компонентом из props.
**2.2**
Соответственно наш тест будет проверять, что в модальное окно передается правильный заголовок:
```
it('renders Modal with the correct title', () => {
const renderer = create()
const element = renderer.root.findByType(ManyUI.Modal)
expect(element.props.title).toBe('Publish App Name app')
})
```
**2.3**
```
import React from 'react'
import { Modal } from '@manychat/manyui'
const ApplicationPublishModal: React.FC<{ appName: string }> = ({ appName }) => {
const title = `Publish ${appName} app`
return
}
export default ApplicationPublishModal
```
**2.4**
Убеждаемся, что тест прошел, и переходим к третьей итерации.
**3.1**
Теперь мы добавим кнопку, которая при клике будет вызывать метод onPublish, полученный компонентом из props, и закроет модальное окно.
**3.2**
Наш тест в таком случае должен проверять, что при клике по кнопке Publish вызывается метод onPublish и закрывается модальное окно:
```
// события, действия, меняющие состояние компонента, необходимо оборачивать в act
import { create, act } from 'react-test-renderer'
it('calls method onPublish and closes the modal when button Publish is clicked', () => {
const onPublishSpy = jest.fn()
const renderer = create()
const element = renderer.root.findByType(ManyUI.Modal)
// оборачиваем в act вызов события onClick, меняющий состояние компонента
act(() => {
element.props.buttons
.find((button: { label: string }) => button.label === 'Publish')
.onClick()
})
expect(onPublishSpy).toHaveBeenCalledTimes(1)
expect(element.props.open).toBe(false)
})
```
**3.3**
```
import React, { useCallback, useState } from 'react'
import { Modal } from '@manychat/manyui'
const ApplicationPublishModal: React.FC<{ appName: string; onPublish: () => void }> = ({
appName,
onPublish,
}) => {
const [open, setOpen] = useState(true)
const title = `Publish ${appName} app`
const handlePublish = useCallback(() => {
onPublish()
setOpen(false)
}, [onPublish])
return (
)
}
export default ApplicationPublishModal
```
**3.4**
Снова убеждаемся, что тест прошел, и переходим к заключительной итерации.
**4.1**
Итак, нам осталось добавить версионирование. Если в компонент придет prop — isPublic, тогда заголовок и название кнопки должны измениться на Republish.
**4.2**
```
it('renders button and title Republish when isPublic is true', () => {
const renderer = create()
const element = renderer.root.findByType(ManyUI.Modal)
expect(element.props.title).toBe('Republish App Name app')
expect(element.props.buttons[0].label).toBe('Republish')
})
```
**4.3**
```
import React, { useCallback, useState } from 'react'
import { Modal } from '@manychat/manyui'
const ApplicationPublishModal: React.FC<{
appName: string
onPublish: () => void
isPublic?: boolean
}> = ({ appName, onPublish, isPublic }) => {
const [open, setOpen] = useState(true)
const actionLabel = `${isPublic ? 'Rep' : 'P'}ublish`
const title = `${actionLabel} ${appName} app`
const handlePublish = useCallback(() => {
onPublish()
setOpen(false)
}, [onPublish])
return (
)
}
export default ApplicationPublishModal
```
**4.4**
И, наконец, проведем рефакторинг: добавим недостающие props в каждый тест, вынесем повторяющиеся значения в переменные.
**4.5**
Пятым шагом запускаем наше приложение, правим верстку и еще раз убеждаемся, что все работает с помощью ручного тестирования.
В итоге, за 4 итерации по TDD, мы получили следующий код:
```
// ApplicationPublishModal.test.tsx
import React from 'react'
import { create, act } from 'react-test-renderer'
import * as ManyUI from '@manychat/manyui'
import ApplicationPublishModal from '.'
ManyUI.Modal = jest.fn().mockImplementation(() => null)
describe('ApplicationPublishModal', () => {
const appName = 'App Name'
it('renders Modal with props open and width', () => {
const renderer = create()
const element = renderer.root.findByType(ManyUI.Modal)
expect(element.props.open).toBe(true)
expect(element.props.width).toBe(480)
})
it('renders Modal with the correct title', () => {
const renderer = create()
const element = renderer.root.findByType(ManyUI.Modal)
expect(element.props.title).toBe('Publish App Name app')
})
it('calls method onPublish and closes the modal when button Publish is clicked', () => {
const onPublishSpy = jest.fn()
const renderer = create()
const element = renderer.root.findByType(ManyUI.Modal)
act(() => {
element.props.buttons
.find((button: { label: string }) => button.label === 'Publish')
.onClick()
})
expect(onPublishSpy).toHaveBeenCalledTimes(1)
expect(element.props.open).toBe(false)
})
it('renders button and title Republish when isPublic is true', () => {
const renderer = create(
,
)
const element = renderer.root.findByType(ManyUI.Modal)
expect(element.props.title).toBe('Republish App Name app')
expect(element.props.buttons[0].label).toBe('Republish')
})
})
```
```
// ApplicationPublishModal.tsx
import React, { useCallback, useState } from 'react'
import { Modal } from '@manychat/manyui'
const ApplicationPublishModal: React.FC<{
appName: string
onPublish: () => void
isPublic?: boolean
}> = ({ appName, onPublish, isPublic }) => {
const [open, setOpen] = useState(true)
const actionLabel = `${isPublic ? 'Rep' : 'P'}ublish`
const title = `${actionLabel} ${appName} app`
const handlePublish = useCallback(() => {
onPublish()
setOpen(false)
}, [onPublish])
return (
)
}
export default ApplicationPublishModal
```
Заключение
----------
### Что изменилось с момента внедрения TDD
Как и ожидалось, сначала у нас была просадка по скорости, непонимание того, что и как делать, с каких сторон подходить к реализации новой функциональности, а с каких к рефакторингу, как правильно тестировать экшены и редьюсеры, и разные другие трудности.
Однако спустя всего месяц активного применения TDD, вкупе с парным программированием, скорость разработки выровнялась и пошла вверх. Уже был сформирован достаточный фундамент, чтобы для большинства кейсов можно было найти аналогичный пример. Мы ощутили на практике все плюсы раздела «Зачем нужен TDD» уже в первый месяц.
Вот уже десять месяцев мы придерживаемся TDD методологии, и скорость разработки не перестает расти. Качественный код освобождает нас от необходимости тратить большое количество ресурсов на фикс багов, а модульная архитектура позволяет не тратить кучу времени на изучение старого кода и подготовку его к расширению.
Переходите на TDD, пишите качественный и безопасный код. Буду рад ответить на ваши вопросы или подискутировать, если вы все еще сомневаетесь в пользе этого подхода.
А также, выбирайте тему, о которой вам будет интересно прочитать в следующий раз в нашем блоге. | https://habr.com/ru/post/528794/ | null | ru | null |
# Обучаем нейросеть распознавать цифры на выборке от MNIST. Реализация алгоритма обратного распространения на C#
Доброго дня, хабровчане!
В этой статье поговорим о такой современной, модной и очень важной теме как машинное обучение и нейронные сети. О важности этой темы я писать не буду — каждый день об этом говорят по телевизору и пишут в ~~газетах~~ интернетах.
Тема распознавания цифр на основе данных от MNIST уже достаточно заезженная, но я все-таки поделюсь с Вами своим первым опытом в этой области, который привел к определенному результату, правдивость и достоверность которого Вы сможете сами проверить.
Итак, о чем же эта статья?!
В статье я буду с нуля реализовывать классический [алгоритм обратного распространения ошибки](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BE%D1%88%D0%B8%D0%B1%D0%BA%D0%B8) с помощью последовательного (стохастического) режима обучения, чтобы обучить многослойный персептрон (полносвязную нейронную сеть прямого распространения) распознавать рукописные цифры. Каждый свой шаг я буду стараться подробно комментировать, ссылаясь на книгу Хайкина по нейросетям. Я думаю многие, кто занимается машинным обучением профессионально, начинали свой путь именно с этой книги, ну или хотя пару раз заглянули в нее.
Как Вы заметили, эта статья является переводом. Я бы сказал — частичным переводом, так как в оригинальной [статье](https://mmlind.github.io/posts/simple_3-layer_neural_network_for_mnist_handwriting_recognition/) автор пишет алгоритм на языке C. Я же буду писать на C#.
К тому же, точность предсказаний обученной нейросети зависит от очень большого количества параметров: архитектура сети, количество скрытых слоев, количество нейронов на слоях, функции активации, инициализация весовых коэффициентов и т.д. Поэтому в качестве упрощения я буду идти примерно той же дорогой, как и автор оригинала для ускоренного получения более-менее приемлемого результата.
От Вас требуются элементарные знания высшей математики (знать что такое сумма от 1 до n, что такое функция и производная) ну и иметь хотя бы какое-то общее представление о нейронных сетях. Было бы неплохо прочесть первую главу Хайкина.
Содержание
----------
* [Обучающая выборка. MNIST](https://habr.com/ru/post/708928/#training_set_mnist)
* [Результаты](https://habr.com/ru/post/708928/#results)
* [Модель нейрона](https://habr.com/ru/post/708928/#neuron_model)
* [Модель слоя](https://habr.com/ru/post/708928/#layer_model)
* [Модель нейронной сети](https://habr.com/ru/post/708928/#neural_network_model)
* [Подготовка обучающей выборки. Архитектура сети](https://habr.com/ru/post/708928/#training_sample_preparation_and_network_architecture)
* [Инициализация нейросети](https://habr.com/ru/post/708928/#initialization)
* [Прямой проход](https://habr.com/ru/post/708928/#forward_propagation)
* [Алгоритм обратного распространения](https://habr.com/ru/post/708928/#back_propagation_algorithm)
* [Заключение](https://habr.com/ru/post/708928/#conclusion)
Обучающая выборка. MNIST
------------------------
Для тех, кто первый раз видит эту аббревиатуру. В качестве данных для обучения я использовал изображения рукописных цифр из базы данных [MNIST](https://ru.wikipedia.org/wiki/MNIST_(%D0%B1%D0%B0%D0%B7%D0%B0_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85)). Скачать бинарные файлы с изображениями и метками можно [здесь](http://yann.lecun.com/exdb/mnist/). Но на всякий случай я загрузил их в свой [проект](https://github.com/greenDev7/NeuralNetwork/tree/master/MNIST%20Dataset/OriginalFiles).
Пару слов про эти бинарники. Файлы `train-images-idx3-ubyte` и `train-labels-idx1-ubyte` содержат в себе 60К изображений и меток (наименование цифры) в закодированном виде, соответственно. Эта выборка будет служить для обучения нейросети и корректировки весовых коэффициентов. Файлы `t10k-images-idx3-ubyte` и `t10k-labels-idx1-ubyte` содержат 10К картинок и меток, соответственно, для тестирования уже обученной нейросети.
Для работы с этими файлами я использовал библиотеку [MNIST.IO](https://github.com/guylangston/MNIST.IO), которая отлично справилась со своей задачей. Хотя для тренировки нейросети это и не нужно, но мне все-таки захотелось взглянуть на эти картинки "вживую", поэтому я раскодировал все изображения и сохранил их в соответствующие папки проекта. [Здесь](https://github.com/greenDev7/NeuralNetwork/tree/master/MNIST%20Dataset/TrainingImages) находятся 60К из тренировочной выборки, а [тут](https://github.com/greenDev7/NeuralNetwork/tree/master/MNIST%20Dataset/TestImages) 10К для тестирования.
Каждая картинка имеет размер 28\*28 пикселей и представляет из себя черно-белое изображение рукописной цифры от 0 до 9.
Результаты
----------
Пожалуй, начну сразу с результатов. Результатом является обученный персептрон (784-80-10), т.е. нейросеть у которой 784 входа, один единственный скрытый слой с 80-ю нейронами и 10 выходных нейронов. При тестировании на выборке из 10К он показал точность распознавания % (т.е. он удачно распознал 9572 цифры из 10К), остальные 428 ему распознать не удалось. Их я решил сохранить в [отдельную папку](https://github.com/greenDev7/NeuralNetwork/tree/master/IncorrectPredictions) (в названии каждой картинки три числа: порядковый номер, ожидаемый ответ, ответ от нейросети). Обучал в 16 эпох (16\*60К изображений) с параметров обучения =.
Уже готовые, скорректированные весовые коэффициенты скрытого и выходного слоя находятся [здесь](https://github.com/greenDev7/NeuralNetwork/tree/master/AdjustedWeights). Для экспериментов я создал [песочницу](https://codesandbox.io/s/winter-dew-u26xeb) с уже обученной моделью (на основе уже готовых коэффициентов) где на холсте размером 28 на 28 пикселей можно нарисовать свою цифру для распознавания и посмотреть на результат:
Рисунок 1. Распознавание рукописных цифр.Модель нейрона
--------------
Модель [нейрона](https://github.com/greenDev7/NeuralNetwork/blob/master/Main%20Classes/Neuron.cs) в моей реализации имеет следующий вид:
```
public class Neuron
{
///
/// Весовые коэффициенты (синаптические связи)
///
public List Weights { get; }
///
/// Пороговое значение
///
public double Bias { get; }
///
/// Функция активации
///
private Func ActivationFunction { get; }
///
/// Индуцированное локальное поле
///
public double InducedLocalField { get; private set; }
///
/// Локальный градиент
///
public double LocalGradient { get; private set; }
}
```
Везде далее, если необходимо, я буду указывать в скобочках страницу и/или формулу и номер раздела в книге Хайкина, на основе которых я строил свою модель. Модель нейрона была взята со стр. 43, п. 1.3.
Что такое **Weights**, **Bias** и **ActivationFunction** думаю и так понятно. Свойство **InducedLocalField** будет использоваться как при прямом проходе, так и в методе обратного распространения (обратный проход) для корректировки весовых коэффициентов, — поэтому задавать его я буду уже при прямом проходе сигнала через сеть, чтобы на обратном пути брать уже вычисленное значение. **LocalGradient** необходим лишь на обратном проходе для корректировки весовых коэффициентов. Свойство **ActivationFunction** имеет функциональный тип данных, чтобы можно было подставлять разные функции активации.
Все-таки пару слов о **Weights** сказать нужно. На самом деле неправильно утверждать, что весовые коэффициенты принадлежат какому-то конкретному нейрону. Для тех кто знаком с графами — это как вес ребра, связывающего две соседние вершины графа, так и здесь, весовой коэффициент относится к синапсу, который связывает нейрон одного слоя с нейроном (либо входом) соседнего слоя.
Но в моей модели список **Weights** будет относиться к синапсам, которые связывают данный нейрон и нейроны предыдущего (расположенного левее) слоя. Поэтому это свойство включено в класс нейрона.
Забегая наперед, нужно отметить, что, в таком случае, для алгоритма обратного распространения нужно реализовать отдельный метод, который будет находить список весовых коэффициентов, относящихся к синапсам, связывающих данный нейрон и нейроны следующего за ним (расположенного правее) слоя. Я думаю, это станет понятней в дальнейшем в процессе реализации.
Функции активации (и их производные) хранятся отдельно:
ActivationFunctions.cs
```
public static class ActivationFunctions
{
///
/// Параметр для сигмоидальной функции активации
///
private const double a = 1.0;
///
/// Пороговая функция активации (использовалась для тестирования и решения проблемы XOR)
///
/// аргумент функции
///
public static double ThresholdFunction(double x)
{
return x >= 0.0 ? 1.0 : 0.0;
}
///
/// Возвращает значение сигмоидальной функции активации
///
/// аргумент функции
///
public static double SigmoidFunction(double x)
{
return 1.0 / (1.0 + Math.Pow(Math.E, -a * x));
}
///
/// Возвращает значение производной сигмоидальной функции активации (для алгоритма обратного распространения)
///
/// аргумент функции
///
public static double SigmoidFunctionsDerivative(double x)
{
double factor = a * Math.Pow(Math.E, -a * x);
return factor * Math.Pow(SigmoidFunction(x), 2.0);
}
}
```
Модель слоя
-----------
```
public class Layer
{
///
/// Нейроны
///
public List Neurons { get; }
///
/// Входной сигнал
///
public List InputSignals { get; set; }
}
```
Состоит из свойств **Neurons** — список нейронов данного слоя и **InputSignals** — входные сигналы, полученные от предыдущего слоя. **InputSignals** будут также сохраняться при прямом проходе, чтобы использовать их на обратном.
Модель нейронной сети
---------------------
```
public class Network
{
///
/// Скрытые слои
///
public List HiddenLayers { get; }
///
/// Выходной слой
///
public Layer OutputLayer { get; }
}
```
Модель нейросети состоит из списка скрытых **HiddenLayers** слоев и выходного слоя —**OutputLayer**.
Подготовка обучающей выборки. Архитектура сети
----------------------------------------------
Для того чтобы запустить алгоритм обучения, необходимо каждый обучающий пример, а именно изображение с цифрой, преобразовать в сигнал, который будет скормлен нашему персептрону.
Каждое MNIST-изображение представляет из себя матрицу 28\*28 пикселей со значениями в диапазоне от 0 до 255 (оттенок серого цвета). Но для наших целей мы поступим следующим образом — все белые пиксели (со значением 0) мы так и оставим нулем, а все остальные пиксели будем рассматривать как черный цвет, рисунок 2.
Рисунок 2. Преобразование изображения.
Белые пиксели остаются белыми, а все остальные будем считать черными.После этого мы "расслоим" наше изображение:
Рисунок 3. Расслоение изображения.и из полученных слоев составим вектор входного сигнала с набором из элементов. Белые и черные пиксели, будут представлять, соответственно, 0-ки и 1-ки.
Для этих целей был создан вспомогательный [метод](https://github.com/greenDev7/NeuralNetwork/blob/f8fe984d70f9d579d18d03b55e670b87677c8c21/Helper%20Classes/ImageHelper.cs#L41):
ConvertImageToFunctionSignal()
```
public static List ConvertImageToFunctionSignal(byte[,] image)
{
List functionSignal = new List();
for (int i = 0; i < image.GetLength(0); i++)
for (int j = 0; j < image.GetLength(1); j++)
functionSignal.Add(image[i, j] == 0 ? 0.0 : 1.0);
return functionSignal;
}
```
Таким образом, у нас будет полносвязная нейронная сеть прямого распространения, состоящая из 784 входов, 1 скрытого слоя и выходного слоя с 10 нейронами. Все нейроны будут иметь [сигмоидную](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%B3%D0%BC%D0%BE%D0%B8%D0%B4%D0%B0) функцию активации. Количество нейронов на скрытом слое будем варьировать для получения лучшего результата.
Инициализация нейросети
-----------------------
Как оказалось, не только необходимым, но и важным этапом в процессе обучения нейросети является инициализация ее весовых коэффициентов. Как пишет автор оригинала, нейросеть показала более высокую точность когда при ее инициализации всем весовым коэффициентам были присвоены рандомные значения от 0 до 1 с чередованием знаков. Т.е. каждый четный весовой коэффициент был положительным, а каждый нечетный — отрицательным. Тоже самое я решил применить не только к весам, но и к пороговым значениям (Bias), чтобы одна их половина была положительной, а другая — отрицательной.
А теперь — как это реализовано на практике.
В классе **Network** реализовано два конструктора. Один из них инициализирует всю сеть (весовые коэффициенты) рандомными значениями, а смысл другого конструктора в том, чтобы инициализировать сеть по уже скорректированным весовым коэффициентам, которые хранятся в текстовом файле.
Вот листинг кода первого конструктора с комментариями:
Network(). Конструктор для рандомной инициализации
```
///
/// Инициализирует нейросеть с помощью входных параметров
///
/// количество входов нейросети
/// количество нейронов на выходном слое
/// функция активации у нейронов выходного слоя
/// размерности скрытых слоев
/// массив функций активаций нейронов скрытых слоев
/// левая граница для рандомных чисел
/// правая граница для рандомных чисел
public Network(int inputLayerDimension, int outputLayerNeuronsCount, Func outputActivationFunction, int[] hiddenLayersDimensions = null,
Func[] hiddenActivationFunctions = null, double randomMinValue = 0.0, double randomMaxValue = 1.0)
{
Random random = new Random();
// Если есть скрытые слои
if (hiddenLayersDimensions != null)
{
HiddenLayers = new List();
// Сначала инициализируем первый скрытый слой
// Количество весовых коэффициентов у каждого нейрона первого скрытого слоя равно количеству нейронов входного слоя
HiddenLayers.Add(new Layer(CreateNeurons(hiddenLayersDimensions[0], inputLayerDimension, randomMinValue, randomMaxValue, hiddenActivationFunctions[0], random)));
// Если скрытых слоев больше 1
if (hiddenLayersDimensions.Length > 1)
{
// Количество весовых коэффициентов на втором и последующих скрытых слоях равно количеству нейронов на предыдущем скрытом слое
// Еще раз, первый скрытый слой уже проинициализирован, поэтому начинаем со второго (h = 1)
for (int h = 1; h < hiddenLayersDimensions.Length; h++)
HiddenLayers.Add(new Layer(CreateNeurons(hiddenLayersDimensions[h], hiddenLayersDimensions[h - 1], randomMinValue, randomMaxValue, hiddenActivationFunctions[h], random)));
}
}
// Если есть скрытые слои, то количество весовых коэффицинтов у нейронов выходного слоя равно количеству нейронов последнего скрытого слоя
// Если скрытых слоев нет, то количество весовых коэффицинтов у нейронов выходного слоя равно количеству входов сети
int outputWeightsCount = hiddenLayersDimensions != null ? hiddenLayersDimensions.Last() : inputLayerDimension;
OutputLayer = new Layer(CreateNeurons(outputLayerNeuronsCount, outputWeightsCount, randomMinValue, randomMaxValue, outputActivationFunction, random));
}
```
ну и соответствующие методы:
CreateNeurons()
```
///
/// Возвращает список нейронов, инициализированных весовыми коэффициентами
///
/// количество нейронов
/// количество весовых коэффициентов в каждом нейроне
/// левая граница интервала случайных чисел
/// правая граница интервала случайных чисел
/// функция активации
/// экземпляр генератора случайных чисел
///
private List CreateNeurons(int neuronsCount, int weightsCount, double weightsMinValue, double weightsMaxValue, Func activationFunction, Random random)
{
List neurons = new List();
for (int i = 0; i < neuronsCount; i++)
{
List weights = CreateRandomWeights(weightsCount, weightsMinValue, weightsMaxValue, random);
neurons.Add(new Neuron(activationFunction, weights, CreateRandomValue(random, weightsMinValue, weightsMaxValue, i)));
}
return neurons;
}
```
CreateRandomWeights()
```
///
/// Возвращает список весовых коэффициентов инициализированных случайными значениями
///
/// количество весовых коэффициентов
/// левая граница интервала случайных чисел
/// правая граница интервала случайных чисел
/// экземпляр генератора случайных чисел
///
private List CreateRandomWeights(int weightsCount, double minValue, double maxValue, Random random)
{
List weights = new List();
for (int i = 0; i < weightsCount; i++)
weights.Add(CreateRandomValue(random, minValue, maxValue, i));
return weights;
}
```
CreateRandomValue()
```
///
/// Возвращает случайное число в заданном интервале
///
/// экземпляр генератора случайных чисел
/// левая граница интеравала
/// правая граница интеравала
/// текущий индекс генерируемого значения
///
private double CreateRandomValue(Random random, double minValue, double maxValue, int currentIndex)
{
double randomDouble = random.NextDouble() * (maxValue - minValue) + minValue;
if (currentIndex % 2 == 0) // Будем чередовать знаки через один
return -randomDouble;
return randomDouble;
}
```
Метод `CreateRandomValue()` принимает аргумент `currentIndex`, от которого, как было сказано выше, будет зависеть знак рандомного значения.
Второй конструктор просто принимает заранее подготовленные слои:
Network(). Конструктор для инициализации сети подготовленными слоями
```
public Network(List HiddenLayers, Layer OutputLayer)
{
this.HiddenLayers = HiddenLayers;
this.OutputLayer = OutputLayer;
}
```
После обучения нейросети неплохо бы сохранить скорректированные весовые коэффициенты в файлы:
Запись весовых коэффициентов в файл
```
///
/// Записывает данные по скрытым слоям (количество скрытых слоев, их размерности, пороговые значения, весовые коэффициенты) в файл
///
/// имя файла для записи
public void WriteHiddenWeightsToCSVFile(string fileName)
{
if (HiddenLayers == null)
return;
TextWriter textWriter = new StreamWriter(fileName);
textWriter.WriteLine(string.Format("{0};{1}", "hiddenLayersDimensions", string.Join(";", HiddenLayers.Select(x => x.Neurons.Count))));
foreach (Layer hiddenLayer in HiddenLayers)
foreach (Neuron neuron in hiddenLayer.Neurons)
textWriter.WriteLine("{0};{1}", neuron.Bias, string.Join(";", neuron.Weights));
textWriter.Close();
}
///
/// Записывает пороговые значения и весовые коэффициенты выходного слоя сети в файл
///
/// имя файла для записи
public void WriteOutputWeightsToCSVFile(string fileName)
{
TextWriter textWriter = new StreamWriter(fileName);
foreach (Neuron neuron in OutputLayer.Neurons)
textWriter.WriteLine("{0};{1}", neuron.Bias, string.Join(";", neuron.Weights));
textWriter.Close();
}
```
Методы для чтения весовых коэффициентов вынесены в отдельный [класс](https://github.com/greenDev7/NeuralNetwork/blob/master/Helper%20Classes/WeightsReader.cs).
Прямой проход
-------------
Следующий метод класса **Network** запускает алгоритм прямого распространения сигнала по сети и возвращает выходной сигнал:
```
///
/// Запускает алгоритм прямого распространения сигнала и возвращает ответ от сети
///
/// функциональный сигнал (стимул), поступающий на вход нейросети
///
public List MakePropagateForward(List functionSignal)
{
// Если имеются скрытые слои, то передаем сигнал по скрытым слоям
if (HiddenLayers != null)
foreach (Layer hiddenLayer in HiddenLayers)
functionSignal = SetInputSignalAndInducedLocalFieldAndReturnOutputSignal(hiddenLayer, functionSignal);
// Возвращаем сигнал от выходного слоя
return SetInputSignalAndInducedLocalFieldAndReturnOutputSignal(OutputLayer, functionSignal);
}
```
В этом методе входной сигнал, который представляет из себя вектор-изображение из 784 элементов, передается сначала по скрытым слоям (если они есть), а затем от выходного слоя возвращается сигнал из 10 значений. Каждое из этих 10 значений представляет собой вероятность предсказания той или иной цифры.
В процессе передачи сигнала от слоя к слою метод с длинным названием также устанавливает свойства **InputSignals** класса Layer и **InducedLocalField** класса Neuron:
```
///
/// Задает слою входной сигнал, устанавливает локальные индуцированные поля нейронов и возвращает выходной сигнал
///
/// слой
/// входной сигнал
/// выходной сигнал
private List SetInputSignalAndInducedLocalFieldAndReturnOutputSignal(Layer layer, List functionSignal)
{
layer.InputSignals = functionSignal;
foreach (Neuron neuron in layer.Neurons)
neuron.SetInducedLocalField(functionSignal);
return layer.ProduceSignals();
}
```
Алгоритм обратного распространения
----------------------------------
Как было сказано в самом начале статьи, реализовывать я буду последовательный (стохастический) режим обучения:
Описание последовательного режима обучения (гл. 4, раздел 4.3)Рисунок 4. Описание последовательного режима обученияПроцесс обучения начинается с метода `Train()` класса **Network**:
Train()
```
///
/// Запускает алгоритм обучения нейронной сети
///
/// путь к бинарному файлу MNIST с изображениями
/// путь к бинарному файлу MNIST с метками (наименованиями цифр)
/// параметр скорости обучения
/// количество эпох
public void Train(string imagesFileName, string labelsFileName, double learningRateParameter, int numberOfEpochs)
{
for (int e = 0; e < numberOfEpochs; e++)
{
// Получаем изображения
IEnumerable testCases = FileReaderMNIST.LoadImagesAndLables(labelsFileName, imagesFileName);
foreach (TestCase test in testCases)
{
// Конвертируем изображение в функциональный сигнал
List functionSignal = ImageHelper.ConvertImageToFunctionSignal(test.Image);
// Получаем ожидаемый ответ
List desiredResponse = GetDesiredResponse(test.Label);
// Получаем ответ от сети (прямой проход)
List outputSignal = MakePropagateForward(functionSignal);
// Вычисляем сигнал ошибки как разность между ожидаемым и фактическим ответом нейросети
List errorSignal = GetErrorSignal(desiredResponse, outputSignal);
// Запускаем алгоритм обратного распространения ошибки
MakePropagateBackward(errorSignal, learningRateParameter);
}
Console.WriteLine("epoch " + e.ToString() + " finished"); // Выводим в консоль прогресс выполнения
}
}
```
который содержит в себе метод для запуска алгоритма обратного распространения:
```
///
/// Запускает алгоритм обратного распространения ошибки
///
/// сигнал ошибки
/// параметр скорости обучения
private void MakePropagateBackward(List errorSignal, double learningRateParameter)
{
// Вычисляем локальные градиенты для выходного слоя
OutputLayer.CalculateAndSetLocalGradients(errorSignal);
// Корректируем весовые коэффициенты и пороговые значения выходного слоя
OutputLayer.AdjustWeightsAndBias(learningRateParameter);
// Если скрытых слоев нет, то заканчиваем процесс
if (HiddenLayers == null)
return;
// Устанавливаем выходной слой как предыдущий
// (для обратного прохода это тот слой, который расположен правее)
Layer previousLayer = OutputLayer;
// Идем от последнего скрытого слоя к первому
for (int i = HiddenLayers.Count - 1; i >= 0; i--)
{
// Вычисляем локальные градиенты
HiddenLayers[i].CalculateAndSetLocalGradients(previousLayer);
// Корректируем весовые коэффициенты и пороговые значения
HiddenLayers[i].AdjustWeightsAndBias(learningRateParameter);
previousLayer = HiddenLayers[i];
}
}
```
По комментариям я думаю понятно, что тут происходит. Опишу входящие сюда методы подробней.
Зная сигнал ошибки, мы можем вычислить локальные градиенты для нейронов выходного слоя:
```
///
/// Вычисляет и устанавливает нейронам ВЫХОДНОГО слоя локальные градиенты
///
/// сигнал ошибки
internal void CalculateAndSetLocalGradients(List errorSignal)
{
for (int i = 0; i < Neurons.Count; i++)
Neurons[i].SetLocalGradient(errorSignal[i] \* ActivationFunctions.SigmoidFunctionsDerivative(Neurons[i].InducedLocalField));
}
```
по формуле:
Рисунок 5. Вычисление локальных градиентов нейронов выходного слоя.Вычислив локальные градиенты выходного слоя — корректируем весовые коэффициенты и пороговые значения нейронов выходного слоя:
```
///
/// Корректирует весовые коэффициенты и пороговое значение
///
/// параметр скорости обучения
/// входной сигнал нейрона, заданный при прямом проходе
internal void AdjustWeightsAndBias(double learningRateParameter, List inputSignals)
{
for (int i = 0; i < Weights.Count; i++)
{
Weights[i] += learningRateParameter \* LocalGradient \* inputSignals[i]; // Корректируем весовые коэффициенты
Bias += learningRateParameter \* LocalGradient; // Корректируем пороговое значение (inputSignal для него равен 1)
}
}
```
по формуле:
Рисунок 6. Корректировка весовых коэффициентов.Затем вычисляем локальные градиенты скрытых слоев:
```
///
/// Вычисляет и устанавливает нейронам СКРЫТОГО слоя локальные градиенты на основе предыдущего слоя в алгоритме обратного распространения
///
/// предыдущий слой (расположенный правее текущего)
internal void CalculateAndSetLocalGradients(Layer previousLayer)
{
for (int i = 0; i < Neurons.Count; i++)
{
// Получаем весовые коэффициенты, непосредственно связанный с этим нейроном
List associatedWeights = GetAssociatedWeights(previousLayer, i);
// Подсчитываем внутреннюю сумму
double innerSum = GetInnerSum(associatedWeights, previousLayer);
// Вычисляем и устанавливаем нейрону скрытого слоя локальный градиент
Neurons[i].SetLocalGradient(innerSum \* ActivationFunctions.SigmoidFunctionsDerivative(Neurons[i].InducedLocalField));
}
}
```
по формуле:
Рисунок 7. Вычисление локальных градиентов нейронов скрытого слоя. Красным выделена внутренняя сумма, которая подсчитывается в методе GetInnerSum().После того, как локальные градиенты нейронов скрытого слоя вычислены, по формуле (4.25) корректируем весовые коэффициенты и пороговые значения.
Данные вычисления проводятся для всех слоев в обратном направлении. После того, как все весовые коэффициенты и пороговые значения откорректированы, подаем на вход новый обучающий пример, находим сигнал ошибки и запускаем новую итерацию алгоритма обратного распространения ошибки.
Заключение
----------
В результате экспериментов было установлено, что нейросеть неплохо обучается, если на обратном проходе не корректировать пороговые значения, т.е. закомментировать вот эту [строчку](https://github.com/greenDev7/NeuralNetwork/blob/master/Main%20Classes/Neuron.cs#L74):
```
internal void AdjustWeightsAndBias(double learningRateParameter, List inputSignals)
{
for (int i = 0; i < Weights.Count; i++)
{
Weights[i] += learningRateParameter \* LocalGradient \* inputSignals[i]; // Корректируем весовые коэффициенты
// Bias += learningRateParameter \* LocalGradient; // Корректируем пороговое значение (inputSignal для него равен 1)
}
}
```
В общем, как бы там ни было, обучение нейросети — процесс очень творческий и неоднозначный и требует довольно долгих расчетов и экспериментов. И, как утверждает автор оригинальной статьи, вместо тюнинга параметров нейросети и достижения более точных результатов лучше перейти к реализации принципиально нового типа сетей — сверточных нейронных сетей. Но об этом, наверное, в другой раз.
В статье я почти ни слова не сказал о производительности, хотя это и не является главной темой работы. Скажу лишь, что на моем Intel(R) Core(TM) i5-8250U CPU @ 1.60GHz 1.80GHz c 16 ГБ ОЗУ процесс обучения с одним скрытым слоем (80 нейронов) в 16 эпох занял примерно 40 мин (да, не быстро!). Поэтому оставляю за читателем право максимально распараллелить все возможные процессы (Parallel.For, PLINQ и т.п. вам в помощь).
Надеюсь Вам была полезна моя статья!
С наступающим Рождеством!
Мира, добра и чистого кода! | https://habr.com/ru/post/708928/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.