text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Docker Swarm+Consul+Gobetween в виде движка для гео распределенного кластера
Преамбула
---------
Некоторе время назад перед нами стала задача спроектировать и развернуть систему для потокового видео. Суть была в массовом запуске/остановке инстанций, на которых происходит обратная сборка потокового видео и стриминг на множество media cdn провайдеров (youtube, livestream, ustream итд ) а также на собственные rtmp и ts точки назначения. Каждая инстанция требовала настройки перед запуском т.к. содержала специфическую для каждого клиента информацию. Также было понятно, что система должна работать в большом количестве регионов (как минимум во всех точках, где присутствует Амазон, а как максимум — в любом месте где можно арендовать сервер). Также основное требование — запуск инстанции в течении 1-2 секунд максимум, чтобы это было прозрачно для пользователя.
Было это в начале 2015 года уже были разговоры о том что Docker в скором времени выпускает родную систему кластеризации. И 26 февраля 2015 года она таки вышла. Сразу стало понятно что это для нас серебряная пуля и Swarm идеально ложится на наш проект. Проект был запущен в мае 2015.
Через 11 месяцев мы запустили второй, более сложный проект в котором требовалось организовать статические точки входа (ip:port) для оборудования третьих производителей, расширив при этом всю логику работы и запуска инстанций динамически в нужном регионе.
В процессе проектирования и последующей разработки мы использовали Docker swarm довольно нестандартно. И далее появилась идея как динамически управлять и балансировать своей инфраструктурой. Также как часть этого пути появился проект [Gobetween](https://github.com/yyyar/gobetween) который должен был помочь нам в будущем гибко управлять нашей инфраструктурой, а также быть легко реплицируемым.
Задача
------
В данной статье я хотел бы поделится идеей и принципиальной реализацией построения распределенной системы.
Я специально опущу аспект безопасности — тут уж каждый решает как / что лучше строить. Некоторые закрываются паролями/сертификатами и т.д., некоторые выносят менеджмент часть в сети не пересекающиеся напрямую с сетями общего доступа (живут внутри vpc и связаны между собой по-средством тоннелей).
Принципиальная схема докер кластера на Standalone Swarm.
Рассмотрим систему принципиально — как большое колличество регионов и с одним ядром(урпавляющим).
В данном случае рассматривается система с одним мастером и большим количеством докер хостов, которые анонсируют себя в консул кластер. Почему так? да потому что по сути Manage не представляет никакой ценности сам по себе — в нем никаких данных, которые не хотелось бы потерять. В нем даже настроек толком нет — он является планировщиком задач для списка докер нод, который он берет из Consul кластера. Более того — таких Мanagе инстанций при желании можно сделать сколько угодно, но смысла нет — ниже объясню почему.
Самый большой плюс этакой системы — все прозрачно, управляемо, масштабируемо. Итак, начнем с конфигурирования консул кластера.
Установка и настройка Consul Кластера
=====================================
На выходе мы хотим получить такую структуру кластера:
3 ноды в RAFT с авто выбором мастера.
```
sever1.consul.example.com 10.0.0.11 bootstrap consul server, consul agent
sever2.consul.example.com 10.0.0.12 consul server, consul agent
sever3.consul.example.com 10.0.0.13 consul server, consul agent
```
Сначала устрановим Consul на server(N).consul.example.com:
Качаем консул с <https://consul.io>
Никаких контейнеров, консул под UPSTART.
```
$wget https://releases.hashicorp.com/consul/0.6.4/consul_0.6.4_linux_amd64.zip
$unzip *.zip
$mv consul /usr/sbin/consul
```
Проверяем что Consul работает:
```
$consul --version
Consul v0.6.4
Consul Protocol: 3 (Understands back to: 1)
```
После установки на всех трех серверах — подготовим кластер к первичной загрузке:
Генерируем кластерный токен :
```
$consul keygen
ozgffIYeX6owI0215KWR5Q==
```
Создаем пользователя из под которого будет запускаться Consul:
```
$adduser consul
```
Создаем на всех 3 серверах необходимые директории:
```
$mkdir -p /etc/consul.d/{bootstrap,server,client}
```
Создаем директории для хранения данных Консула:
```
$mkdir /var/consul
$chown consul:consul /var/consul
```
На ноде которую мы будем использовать для первичного запуска кластера (sever1.consul.example.com) нужно создать bootstrap конфиг:
```
$vim /etc/consul.d/bootstrap/config.json
```
```
{
"bootstrap": true,
"server": true,
"datacenter": "production",
"data_dir": "/var/consul",
"encrypt": "",
"log_level": "INFO",
"encrypt":ozgffIYeX6owI0215KWR5Q==,
"enable_syslog": true
}
```
На **ВСЕХ** трех серверах нужно создать серверный конфиг /etc/consul.d/server/config.json:
Server1:
```
{
"bootstrap": false,
"server": true,
"datacenter": "production",
"data_dir": "/var/consul",
"encrypt": "ozgffIYeX6owI0215KWR5Q==",
"log_level": "INFO",
"enable_syslog": true,
"start_join": ["10.0.0.12", "10.0.0.13"]
}
```
Server2
```
{
"bootstrap": false,
"server": true,
"datacenter": "production",
"data_dir": "/var/consul",
"encrypt": "ozgffIYeX6owI0215KWR5Q==",
"log_level": "INFO",
"enable_syslog": true,
"start_join": ["10.0.0.11", "10.0.0.13"]
}
```
Server3:
```
{
"bootstrap": false,
"server": true,
"datacenter": "production",
"data_dir": "/var/consul",
"encrypt": "ozgffIYeX6owI0215KWR5Q==",
"log_level": "INFO",
"enable_syslog": true,
"start_join": ["10.0.0.11", "10.0.0.12"]
}
```
Теперь создадим UPSTART скрипт для Consul на всех серверах: /etc/init/consul.conf:
```
description "Consul server process"
start on (local-filesystems and net-device-up IFACE=eth0)
stop on runlevel [!12345]
respawn
setuid consul
setgid consul
exec consul agent -config-dir /etc/consul.d/server
```
Первичный запуск кластера
=========================
Проинициализируем наш кластер (Первичный запуск): на sever1.consul.example.com:
```
#consul agent -config-dir /etc/consul.d/bootstrap -bind="IP_ADDRESS"
```
Сервис должен запустится и захватить терминал. В bootstrap режиме сервер сам назначает себя мастером и инициализирует все нужные структуры данных.
На остальных двух серверах (sever2.consul.example.com, sever3.consul.example.com) просто запускается консул в режиме сервера.
```
#start consul
```
Эти сервера подсоединяются к bootstrap серверу. В данный момент мы имеем кластер из трех серверов, два из которых — работают в обычном режиме сервера, и один — в режиме инициализации, что значит что он сам принимает решения по распространению данных не спрашивая остальных.
Теперь мы можем остановить bootstrap сервер и перезапустить консул в режиме стандартного сервера:
На bootstrap сервере нажмите:
> CTRL-C
Консул остановится и затем перезапустите в режиме стандартного сервера :
sever1.consul.example.com:
```
#consul start
```
Проверьте что все прошло хорошо с помощью такой команды:
```
#consul members -rpc-addr=10.0.0.11:8400
```
Вывод должен быть :
```
Node Address Status Type Build Protocol DC
server1.consul.example.com 10.0.0.11:8301 alive server 0.6.4 2 production
server2.consul.example.com 10.0.0.12:8301 alive server 0.6.4 2 production
server3.consul.example.com 10.0.0.13:8301 alive server 0.6.4 2 production
```
Итак, у нас есть готовый и работоспособный консул кластер.
Балансировщик нагрузки, как фронтенд консул кластера
====================================================
В данном случае мы будем использовать балансировщик нагрузки и все запросы к консул кластеру будут идти через него. В случае Амазона использование консул агентов из разных VPC, не говоря уже о регионах имеет много неразрешенных проблем (анонс своего внутреннего IP вместо указанного при старте внешнего, что рушит второй этап входа ноды/сервера в кластер ), а поднимать консул кластер в каждом регионе и настраивать синхронизацию — с мой точки зрения на данном этапе не рационально.
Устанавливаем Consul Agent
--------------------------
По аналогии — скачаем и установим на сервер, где будет находится наш балансировщик, Consul.
потом создадим конфиг агента :
```
$vim /etc/consul.d/server/config.json
```
```
{
"server": false,
"datacenter": "production",
"data_dir": "/var/consul",
"ui_dir": "/home/consul/dist",
"encrypt": "ozgffIYeX6owI0215KWR5Q==",
"log_level": "INFO",
"enable_syslog": true,
"start_join": ["10.0.0.11", "10.0.0.12", "10.0.0.13"]
}
```
создадим upstart для агента:
```
description "Consul server process"
start on (local-filesystems and net-device-up IFACE=eth0)
stop on runlevel [!12345]
respawn
setuid consul
setgid consul
exec consul agent -config-dir /etc/consul.d/agent
```
стартуем агент :
```
$start consul
```
проверим что у нас вышло:
```
$consul members -rpc-addr=10.0.0.11:8400
```
после запуска вывод должен быть что-то вроде:
```
Node Address Status Type Build Protocol DC
server1.consul.example.com 10.0.0.11:8301 alive server 0.6.4 2 production
server2.consul.example.com 10.0.0.12:8301 alive server 0.6.4 2 production
server3.consul.example.com 10.0.0.13:8301 alive server 0.6.4 2 production
lb.consul.example.com 10.0.0.1:8301 alive client 0.6.4 2 production
```
Настраиваем [Gobetween](https://github.com/yyyar/gobetween) в виде балансировщика.
----------------------------------------------------------------------------------
в [предыдущих](https://habrahabr.ru/users/nickdoikov/topics/) статьях я описывал часть функционала нашего ЛБ.
в данном случае проще всего использовать EXEC discovery вместе с Consul agent установленном локально — это позволяет смотреть на консул кластер изнутри (ведь в будущем вполне может получится что мы добавим/уберем часть нод и тогда лб не придется перенастраивать).
качаем последний релиз(версия может потом сменится, так что следите за релизами ):
```
$wget https://github.com/yyyar/gobetween/releases/download/0.3.0/gobetween_0.3.0_linux_amd64.tar.gz
$tar -xvf gobetween_0.3.0_linux_amd64.tar.gz
$cp gobetween_0.3.0_linux_amd64/gobetween /usr/sbin
```
Итак, давайте создадим скрипт определения списка доступных consul бекенд серверов, который будет возвращать список серверов прошедших проверку и у которые зарегистрированы к консуле и отмечены сервисом CONSUL
создадим директорию для конфигов и дискавери скриптов
```
$mkdir /etc/gobetween/
```
создадим дискавери скрипт :
```
$vim /etc/gobetween/consul_node_discovery.sh
```
такого содержания:
```
#!/bin/bash
curl -Ss http://0.0.0.0:8500/v1/catalog/service/consul |jq '.[] | .Address' |sed 's/"//g'| sed 's/$/:8500/'
```
если запустить от руки вывод скрипта должен быть что-то типа :
```
10.0.0.11:8500
10.0.0.12:8500
10.0.0.13:8500
```
при данном типе получения списка рабочих серверов хелсчеки мы использовать не будем — оставим это самому консул кластеру. Теперь настроим сам [Gobetween](https://github.com/yyyar/gobetween):
```
$vim /etc/gobetween/gobetween.toml
```
```
[logging]
level = "info"
output = "stdout"
[api]
enabled = true
bind = ":8888"
[api.basic_auth]
login = "admin"
password = "admin"
[defaults]
max_connections = 0
client_idle_timeout = "0"
backend_idle_timeout = "0"
backend_connection_timeout = "0"
[servers.consul]
bind = "10.0.0.1:8500"
protocol = "tcp"
balance = "iphash"
max_connections = 0
client_idle_timeout = "10m"
backend_idle_timeout = "10m"
backend_connection_timeout = "5s"
[servers.consul.access]
default = "deny"
rules = [
"allow 99.99.99.1/24", # region1 docker nodes ip`s pool
"allow 199.199.199.1/24", # region 2 docker nodes pool
"allow 200.200.200.200/32", #mage node
"allow 99.99.98.1/32 " #region-1 load balancer
]
[servers.consul.discovery]
failpolicy = "keeplast"
interval = "10s"
timeout = "5s"
kind = "exec"
exec_command = ["/etc/gobetween/consul_node_discovery.sh"]
```
теперь создадим upstart скрипт /etc/init/gоbetween.conf :
```
$vim /etc/init/gоbetween.conf
```
```
# gobetween service
description "gobetween"
env DAEMON=/usr/sbin/gobetween
env NAME=gobetween
env CONFIG_PATH=/etc/gobetween/gobetween.toml
export GOMAXPROCS=`nproc`
start on runlevel [2345]
stop on runlevel [!2345]
kill signal INT
respawn
respawn limit 10 5
umask 022
expect stop
respawn
script
exec $DAEMON -c $CONFIG_PATH 2>&1
end script
post-stop script
pid=`pidof gobetween`
kill -9 $pid
end script
```
и теперь запустим балансировщик:
```
$start gobetween
```
Теперь у нас есть кластер, можно зайти на <http://lb_ip:8888/servers/consul> и проверить что список серверов консула определился успешно.
установка Докер нод (серверов с докером)
========================================
Наши ноды будут жить в 2 подсетях:
```
99.99.99.1/24 - region 1
199.199.199.1/24 -region 2
```
Также внешний ELASTIC IP в Aмазоне — 50.50.50.50
Docker
------
Итак, повторять тут шаги установки докера на сервер не вижу смысла. Их можно прочесть [тут](https://docs.docker.com/engine/installation/linux/ubuntulinux/). Я же остановлюсь только на специфических вопросах. Также следует отметить — данное руководство работает для 12 и 14 веток Ubuntu, для Ubuntu 16 требуются те же настройки докер демона, но делаются они чуть по другому.
Начнем с конфигурации докер демона и его запуска.
отредактируем строку инициализации докер демона:
```
vim /etc/default/docker
```
требуется добавить строку ниже, остальные строки — закомментировать:
```
DOCKER_OPTS="-H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock --label region=region1 "
```
далее перезагрузим Docker:
```
$service docker restart
```
после этого требуется убедиться что докер демон запустился с нужными настройками:
```
$ps ax |grep docker
```
должны увидеть что-то типа этого :
```
10174 ? Ssl 264:59 /usr/bin/docker daemon -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock --label region=region
```
Swarm join
----------
установим [Docker Swarm](https://github.com/docker/swarm) на наш сервер с уже установленным докером. Я не использую Docker Swarm в контейнерах, мне нравится когда все прозрачно и когда я могу инициализировать именно так как хочу и контролировать его по средством простого upstart.
Итак, самый простой способ заполучить бинарный файл со свормом — это скачать его образ себе на локальную машину, потом распакровать образ и извлечь любым возможным способом. Я же предпочитаю собирать его для себя сам. Решать как лучше я оставлю читателю.
Представим что у нас уже есть бинарник с Docker Swarm, мы скопировали его на наш настраиваемый сервер с докером. теперь нам нужно просто настроить Swarm по средством написания upstart-скрипта:
```
$vim /etc/init/swarm.conf
```upstart
description "Consul server process"
start on (local-filesystems and net-device-up IFACE=eth0)
stop on runlevel [!12345]
respawn
setuid root
setgid root
exec bash -c 'swarm join --ttl 20s --heartbeat 4s --advertise=SERVER_IP:2375 consul://50.50.50.50:8500/swarmcluster/ '
```
SERVER\_IP вы можете легко извлечь сами, у меня он вставляется подставляясь из Elastic IP во время создания сервера в Амазон с помощью Ansible. Это именно тот айпи по которому будет соединятся SWARM Manage к этому докер хосту.
теперь стартуем наш swarm join:
```
start swarm
```
проверить можно запросом типа такого
```
$curl -Ss http://50.50.50.50:8500/v1/kv/swarmcluster/docker/swarm/nodes/?keys&seperator=/&dc=production
```
и должны получить ответ :
```
$ ["swarmcluster/docker/swarm/nodes/SERVER_IP:2375"]
```
Теперь так же размасштабируйте кластер в любое колличество регионов. Меняя в настройках докер демона метки (lables) для каждого региона. Также можно добавлять несколько меток на каждый сервер (удобно делить сервера по регионам а также, скажем, производительности процессора, размеру памяти, типа диска).
установка Swarm Manage
----------------------
Итак, теперь перейдем непосредственно к установке нашего сворм менеджера. По сути, его установка мало чем отличается от установки Swarm Join.
опять же повторяем шаги по копированию бинарника на сервер и далее создаем UPSTART скрипт:
```
$vim /etc/init/swarm.conf
```
```
description "Consul server process"
start on (local-filesystems and net-device-up IFACE=eth0)
stop on runlevel [!12345]
respawn
setuid root
setgid root
exec bash -c 'swarm manage -H tcp://$0.0.0.0:2377 -strategy "binpack" consul://50.50.50.50:8500/swarmcluster/'
```
SWARM\_MANAGE\_IP это айпи нашего Manage. В нашем случае — 200.200.200.200. Остановимся на **-strategy** эта опция определяет распределение контейнеров по нодам соответствующим все параметрам выборок. При стратегии binpack — вначале заполняется контейнерами первая нода, только потом — вторая. Если у вас сотни стартов/остановок контейнеров в час — это позволяет избежать фрагментации и позволяет удалять ненужные ноды из кластера.
Существуют 3 вида стратегий распределения контейнеров:
spread — распределение на наименее загруженную ноду
binpack — максимально плотная упаковка контейнеров
random — тут нечего и говорить — все и так понятно :) используется только для дебага.
теперь наконец запустим наш swarm manage:
```
$service swarm start
```
и проверим что у нас вышло :
```
$docker -H 0.0.0.0:2377 info
```
и получим что-то вроде этого :
```
Containers: 1
Images: 3
Server Version: swarm/1.2.4
Role: primary
Strategy: binpack
Filters: health, port, dependency, affinity, constraint
Nodes: 3
host1: 99.99.99.1:2375
└ Status: Healthy
└ Containers: 0
└ Reserved CPUs: 0 / 8
└ Reserved Memory: 0 B / 16.46 GiB
└ Labels: executiondriver=, kernelversion=3.13.0-86-generic, operatingsystem=Ubuntu 14.04.4 LTS, region=region-1, storagedriver=devicemapper
└ Error: (none)
└ UpdatedAt: 2016-08-21T14:40:03Z
host3: 99.99.99.2:2375
└ Status: Healthy
└ Containers: 0
└ Reserved CPUs: 0 / 2
└ Reserved Memory: 0 B / 3.86 GiB
└ Labels: executiondriver=native-0.2, kernelversion=3.13.0-74-generic, operatingsystem=Ubuntu 14.04.3 LTS, region=region-1, storagedriver=devicemapper
└ Error: (none)
└ UpdatedAt: 2016-08-21T14:40:42Z
host3: 199.199.199.1:2375
└ Status: Healthy
└ Containers: 1
└ Reserved CPUs: 0 / 2
└ Reserved Memory: 512 MiB / 3.86 GiB
└ Labels: executiondriver=native-0.2, kernelversion=3.13.0-74-generic, operatingsystem=Ubuntu 14.04.3 LTS, region=region-2, storagedriver=devicemapper
└ Error: (none)
└ UpdatedAt: 2016-08-21T14:40:55Z
Kernel Version: 3.13.0-44-generic
Operating System: linux
CPUs: 12
Total Memory: 24.18 GiB
Name: lb.ourcoolcluster.com
```
по сути можно уже запускать контейнера :
```
$docker tcp://0.0.0.0:2377 run -d -P -e constraint:region==region-1 hello-world
```
Более подробно о фильтрах и политиках можно почитать [тут](https://docs.docker.com/swarm/scheduler/filter/).
Итак, у нас есть кластер, в котором можно запускать контейнера в зависимости от региона, и других данных. Что же дальше? — попробуем организовать по точку входа для каждого региона.
Создание enterypoint для каждого региона
----------------------------------------
Теперь попробуем построить сервис дискавери на исключительно внутренних механизмах Sandalone Swarm. Мы будем пользоваться лейблами при запуске контейнеров. Можно делать это руками, или написать свой движок который будет запускать нужные контейнера и одновременно по rest api работать с Балансировщиком. В данной схеме LB настраивается один раз при старте нового сервиса в регионе, где его до этого не было. после этого можно спокойно запускать реплики сервиса по мере роста нагрузки, а также останавливать контейнера при ее падении — дискавери списка нод предоставляющих сервис сделает сам балансировщик.
Также если это необходимо — можно легко держать реплику консула в регионе и так же реплику Swarm managе. Но мы рассмотрим простейшую схему.
Общая схема как все будет работать :
Установку [Gobetween](https://github.com/yyyar/gobetween) мы опустим, приведем толко конфиг с которым он будет запущен:
```
[logging]
level = "info"
output = "stdout"
[api]
enabled = true
bind = ":8888"
[api.basic_auth]
login = "admin"
password = "admin"
[defaults]
max_connections = 0
client_idle_timeout = "0"
backend_idle_timeout = "0"
backend_connection_timeout = "0"
```
Этого вполне достаточно для старта балансировщика. все последующие процедуры мы будем проводить через rest api — обычно этим занимаются специальные сервисы. Также для упрощения тестирования — на каждом докер сервере создайте файл /tmp/test и пропишите туда уникальную для каждого сервера информацию. Например "host1" и "host2"
Для примера запустим контейнер:
```
$docker run -l service=region-1.nginx -d -p 22001:80 -e constraint:region==region-1 -v /tmp/test:/usr/share/nginx/html:ro nginx
$docker run -l service=region-1.nginx -d -p 22001:80 -e constraint:region==region-1 -v /tmp/test:/usr/share/nginx/html:ro nginx
```
Если у нас в регионе region-1 будет 2 и более нод то контейнера запустятся (Docker Swarm проверяет доступность портов для маппинга). В случае одной докер ноды в регионе можно запустить 2 конейнера таким образом:
```
$docker run -l service=region-1.nginx -d -p 22002:80 -e constraint:region==region-1 -v /tmp/test:/usr/share/nginx/html:ro nginx
$docker run -l service=region-1.nginx -d -p 22001:80 -e constraint:region==region-1 -v /tmp/test:/usr/share/nginx/html:ro nginx
```
Контейнеры запустились в нужном регионе и работают. Теперь настало время настроить наш балансировщик:
```
$curl --user admin:admin -XPOST "http://50.50.50.50:8888/servers/r1nginx" --data '
{
"bind":"LB_IP:LB_PORT",
"protocol": "tcp",
"balance": "weight",
"max_connections": "0",
"client_idle_timeout": "10m",
"backend_idle_timeout": "10m",
"backend_connection_timeout": "1m"
"healthcheck": {
"kind": "ping",
"interval": "2s",
"timeout": "1s"
},
"discovery": {
"kind": "docker",
"docker_endpoint" : "http://50.50.50.50:2377",
"docker_container_private_port" : "80",
"docker_container_label":"service=region-1.nginx"
}
}
'
```
Где:
LB\_IP — IP адрес смотрящий в сторону проверяющего на сервере с запущенным балансировщиком.
LB\_PORT — tcp порт на LB\_IP смотрящий в сторону проверяющего на сервере с запущенным балансировщиком.
Вот теперь можно проверять что у нас вышло:
```
$curl -sS http://LB_IP:LB_PORT
host1
$curl -sS http://LB_IP:LB_PORT
host2
```
Итак, мы рассмотрели один из самых простых, но и при том и довольно таки функциональных способов построения гео распределенного кластера на Docker Swarm standalone. Установка довольно проста и прозрачна, как и поиск и устранение неисправностей. Продумывая данную статью я отдавал себе отчет что не смогу осветить многие аспекты построения и эксплуатации системы данного типа, я преследовал скорее цель заставить читателя взглянуть на проблему под другим углом — необходимой достаточности и аскетичности, ведь сложно сделать легко, а вот легко и стройно — сделать сложно.
Проблемы безопасности и HA я оставил на усмотрение читателей, возможно, если будет интерес я постараюсь их осветить в последующих статьях.
* [вторая обзорная статъя](https://habrahabr.ru/post/304096/)
* [первая обзорная статъя](https://habrahabr.ru/post/303428/)
* [DRAFT Rest API](https://github.com/yyyar/gobetween/wiki/REST-API)
* [Проект на Github](https://github.com/yyyar/gobetween)
* [Вики на Github](https://github.com/yyyar/gobetween/wiki)
* [тесты производительности Gobetween](https://github.com/yyyar/gobetween/wiki/Performance-tests-results)
* [Установка Gobetween под Windows](https://github.com/yyyar/gobetween/wiki/3.3-Windows-specific-notes) | https://habr.com/ru/post/308182/ | null | ru | null |
# MAC OS X Leopard и ASUS Eee PC 1000H
#### **Не без шаманства**
Прежде чем установить на ASUS Eee PC 1000(H) — MAC OS X Leopard, необходимо прошить его BIOS модифицированной версией прошивки, на данный момент доступна модифицированная версия 1103 (на момент написания данных строк на сайте суппорта АСУС также ничего новее версии 1103 не наблюдалось).
Можно конечно попробовать установить MAC OS X без шаманства с БИОСом, но вполне наверняка ни к чему успешному это не приведет, я пробовал 4 разных образа Хакинтошей и во всех случаях дальше «консоли» я не продвинулся. Естественно прошивка БИОСа всё изменила.
Скачать МОД.БИОС можно отсюда:
[http://osrom.net/biosmod/](http://osrom.net/biosmod/ "Клик! Гоу!") — [EeePC1000H1103](http://osrom.net/files/BIOS.mod/NB/ASUS/EeePC/EeePC1000H1103_mod.by.Kabyl.zip "GetIt!")
*После прошивки данным способом вы не получите в БИОСе никаких внешних изменений — новых меню и секретных пунктов управления, можно даже не искать.*
Да кстати, если вам по какой-либо неизвестной никому причине понадобиться «откатить» БИОС, то даже не пытайтесь сделать этого с последними версиями AFUDOS, АСУС решила «вшить» в свои утилитки проверку на уже установленную версию БИОСа, «благодаря» чему при попытке откатить БИОС, утилита радостно сообщает вам что — у вас уже установлен свежачек и вам это вовсе ни к чему.
На помощь придет одна из первых версий AFUDOS которая без лишних слов справится с поставленной задачей. ([Скачать — AFUDOS001](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/AFUDOS001.rar "GetIt!"))
#### **Установка**
В случае с установкой MAC OS X ровно так же как и с [установкой Vista](http://habrahabr.ru/blogs/eeepc/40111/ "Клик! Гоу!") я использовал самый обычный SATA-DVD-привод и Адаптер USB2.0 to SATA+IDE 2.5" + 3.5" (Combo).
После того как БИОС был успешно прошит-модифицирован, я подключил к ноутбуку привод, и после включения выбрал загрузку с DVD.
Я пробовал следующие образы:
***Kalyway 10.5.2 DVD Intel Amd** — (Размер: 3.66 GB)
**iATKOS v4i (10.5.4 Leopard DVD) (Intel only)** — (Размер: 2.64 GB)
**Leo4Allv3 Final Universal (Mac OS X 10.5.2 Intel & AMD SSE2/SSE3)** — (Размер: 4.38 GB)
**Leo4All v.4.0 Beta AMD or INTEL CPU SSE2/SSE3** — (Размер: 4.2 GB)*
Думаю, не стоит объяснять, где стоит искать и откуда скачивать данное «добро».
**Результаты:**
*Kalyway 10.5.2 –*
— инсталляция запустилась сразу и без дополнительных ключей
— легко и без проблем установился
— на стадии установки показал себя лучше всех
— почти(!) без проблем позволил дойти до завершающей стадии установки и запуска MAC OS X.
*iATKOS v4i –*
— инсталляция запустилась сразу и без дополнительных ключей
— не предоставил выбора языка установки
— не предоставил выбора ядра Kernel
— установился на 100%
— после установки при включении впадал в циклические перезагрузки (Проблема известная, ее решение кроется в версии Kernel и особых настройках БИОС, не первое не второе мне доступно не было)
— iATKOS «отправился в корзину».
*Leo4Allv3 Final Universal –*
— инсталляция запустилась сразу и без дополнительных ключей
— с установкой так же как и с Kalyway проблем не возникло, почти(!)
— установился на 100%
— почти(!) без проблем позволил дойти до завершающей стадии установки и запуска MAC OS X.
*Leo4All v.4.0 Beta –*
— инсталляция запустилась сразу и без дополнительных ключей
— с установкой так же как и с Kalyway проблем не возникло, почти(!)
— установился на 100%
— после установки выдал ошибку – «b0 error»
— после решения проблемы «b0 error», появилась проблема «hd() Ethernet PXE Client»
— после решения проблемы «hd() Ethernet PXE Client», появилась проблема «hd() Apple HFS»
— после решения проблемы «hd() Apple HFS», появилась проблема «Error parsing plist file Loading Darwin/x86»
— проблема решена не была, свалил на плохо «пропеченный» DVD
— перезаписал DVD
— проблема решена не была, свалил на битый образ
— Leo4All v.4.0 Beta «был аккуратно отложен до лучших времен»
— На момент написании данных строк уже можно скачать Leo4All v.5 Server 10.5.4 Intel/AMD Released
**Почти(!) раз**
По поводу первого почти(!) в случае с Kalyway, после успешной установки, при первом запуске предлагается — (1) выбрать свой регион, (2) раскладку клавиатуры и при необходимости (3) «сбэкапиться» со старого Мака, вот после процедуры выбора или отказа от бэкапа вместо продолжения я успешно возвращался к выбору региона и в таком вот цикле от (3) к (1) и снова к (3) можно было долго сидеть. Данная проблема является известной и легко решаемой, решение ее я приведу ниже.
Кстати говоря та же проблема была и с Leo4All.
**Почти(!) два**
По поводу почти(!) у iATKOS, Leo4All v.3, Leo4All v.4 — не один из них не мог успешно разделить и отформатировать винт, выдавая одну и ту же ошибку — «нет доступа к диску». Перед Kalyway такой проблемы не стояло, он легко делил, объединял и форматировал.
**Добро пожаловать!**
Итак установка, сам ее процесс с любым из образов практический идентичен, что и не странно, за исключением мелких «эксклюзивных деталей» того или иного образа.
После выбора загрузки с DVD можно увидеть примерно следующее (в зависимости от выбранного образа):
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx1.jpg "Клик! Зуум!")
<Еnter> и пара минут ожиданий (в случае со всеми образами кроме Kalyway, это время несколько больше «пары минут ожиданий»).
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx2.jpg "Клик! Зуум!")
Те, кто впервые устанавливают MAC OS X на Eee PC, должны знать — увидел следующее окошко, и считай что тебе уже почти повезло. Я ждал этого окна несколько суток в надежде установить MAC OS X не модифицируя БИОС.
Выбрав язык который придется по душе можно продолжить установку (в случае с iATKOS v4i такого выбора не будет).
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx3.jpg "Клик! Зуум!")
Добро пожаловать и «эксклюзивные детали» того или иного образа.
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx4.jpg "Клик! Зуум!") [](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx5.jpg "Клик! Зуум!") [](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx23.jpg "Клик! Зуум!")
После успешного приветствия, необходимо подготовить жесткий диск к встрече с MAC OS X Leopard. Для этого надо перейти к «Дисковым утилитам», они ждут пользователей в «Служебных программах».
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx6.jpg "Клик! Зуум!")
Сориентировавшись на месте, необходимо выбрать жесткий диск на который будет установлена MAC OS X. В «Параметрах схемы карты разделов» обязательно необходимо выбрать «Схема разделов GUID». После чего успешно форматнуть область диска куда будет установлена MAC OS X, либо весь диск, в формат — «Mac OS Extended (журнальный)».
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx7.jpg "Клик! Зуум!") [](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx8.jpg "Клик! Зуум!")
Закончив «тереть» жесткий диск закрываем «Дисковую утилиту» и возвращаемся к окну приветствия. Клик! по кнопке «Продолжить». Выбор диска на который будет установлена MAC OS X и снова Клик! по кнопке «Продолжить».
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx9.jpg "Клик! Зуум!")
Перейдя к «Информации об установке» не нужно спешить «Устанавливать». Прежде нужно заглянуть в «Настройки».
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx10.jpg "Клик! Зуум!")
Основное и самое главное это выбор загрузочного ядра, в данном Eee'шном случае — это Vanilla Kernel (чем новее, тем лучше). Далее по вкусу? но без фанатизма. С выбором драйверов можно особо не беспокоиться, практический ни один из низ не подойдет к Eee PC, за исключением Intel'овских чипсета ICHx и видео GMA950. Закругляемся, «Готово» и «Установить».
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx11.jpg "Клик! Зуум!")
«Умный» MAC OS X перед тем как установиться, проверит все ли в порядке с установочным диском, данную процедуру можно конечно пропустить, но лучше дождаться окончания, после проверки он автоматический перейдет к инсталляции. «Устанавливаю!».
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx12.jpg "Клик! Зуум!") [](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx13.jpg "Клик! Зуум!")
Если вам «благоволят звезды» или вы просто все правильно настроили перед установкой, то минут через 30 можно (скажу прямо — не без радости) наблюдать зеленый кружочек с галочкой и надпись «Установка выполнена успешно». Перезагрузка.
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx14.jpg "Клик! Зуум!")
После перезагрузки, MAC OS X встречает новоиспеченного пользователя. «Welcome!».
Собственно вот оно, то самое «почти(!) раз» о котором говорилось выше.
Конечно, есть люди которым те самые «благоволительные звезды» благоволят больше чем мне,
ну или просто они умнее меня, и соответственно, что вполне вероятно не все сталкиваются с подобной проблемой.
Но вот, как-то у меня не сложилось.
И каждый раз после «Do You Already Own a Mac?» я возвращался к «Welcome» в промежутке встречаясь с «Select Your Keyboard».
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx15.jpg "Клик! Зуум!") [](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx16.jpg "Клик! Зуум!") [](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx17.jpg "Клик! Зуум!")
Решается проблема следующим образом. Ноутбук перезагружается, и процессе загрузки беспрерывно и отрывисто, но при этом нежно, жмется . До появления подобного окна.
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx1.jpg "Клик! Зуум!")
Оно будет почти идентично тому что было при установке. После boot: можно ввести ключ с которым можно загрузится, этим ключем будет «-s». Вводим «-s», жмем <Еnter>.
Далее все точ в точ как описано ниже:
`boot: -s`
бегут строчки, много строчек, закончили бежать снова можно что-то ввести
`/sbin/fsck –fy
/sbin/mount –uw /
Touch /var/db/.AppleSetupDone
passwd root`
выбираете себе пароль, вводите его и запоминаете
`quit
reboot`
перезагрузка, после данной процедуры можно будет увидеть окно приветствия где нужно ввести свои логин и пароль
логин: root
пароль тот, что был создан выше
переключение раскладки +
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx18.jpg "Клик! Зуум!") [](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx19.jpg "Клик! Зуум!") [](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx20.jpg "Клик! Зуум!")
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx21.jpg "Клик! Зуум!") [](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosx22.jpg "Клик! Зуум!")
По данной ссылке можно скачать архив с «рабочими» драйверами (кекстами) для ACPI, Intel GMA950 и Realtek R1000:
[http://www.maceee.com/wp-content/uploads/2008/08/maceeedotcompatches.zip](http://www.maceee.com/wp-content/uploads/2008/08/maceeedotcompatches.zip "GetIt!")
Для установки кекстов (kext) используйте «Kext Helper», он как правило уже установлен в самой MAC OS X, более того в данном конкретном случае он добавлен в вышеприведенный архив.
Для установки Wi-Fi нужно скачать и установить вот это:
[http://www.ralinktech.com.tw/data/drivers/Ralink\_CardBusPCI\_D2860-1.0.1.0\_D61-1.0.4.0\_D2560-1.0.9.0%20UI-1.5.1.0\_2008\_03\_13.dmg](http://www.ralinktech.com.tw/data/drivers/Ralink_CardBusPCI_D2860-1.0.1.0_D61-1.0.4.0_D2560-1.0.9.0%20UI-1.5.1.0_2008_03_13.dmg "GetIt!")
**Итоги:**
Все за исключением звука работало практический без нареканий, в случае с установкой Intel GMA950 при работе в разрешении 1024х600px время от времени появляются «артефакты» как правило в верхних частях окон, с дефолтными драйверами с разрешением 800х600px данной проблемы нет.
Драйверы звука (Realtek ALC269) мне найти не удалось, как собственно и многим другим ищущим коих в интернете скопилось уже очень много, в некоторых ветках англоязычных форумов (особо много толковых здесь: [forum.insanelymac.com](http://forum.insanelymac.com/)) люди вроде как близки к решению данной проблемы, все дело времени.
В целом сравнивая сборки, хоть и не смотря на то, что Kalyway при установке вел себя более дружелюбно и отзывчиво, все же в работе Leo4All лично мне показался более «стабильным и работоспособным» что-ли, как то так.
Если бы не проблема с драйверами, возможно я так и остался бы на данной ОС, или хотя бы поставил ее себе как дополнительную, но пока все же Vista.
Делая весь упор на поиск и решение проблемы звука, я совсем забыл о встроенной видео-камере, и вспомнил о ней уже только тогда когда у меня на рабочем столе красовались обои Vista. Поэтому я просто не могу сказать — работает камера или нет, так как не знаю. Но никаких проблем с устройствами USB у меня не возникало.
**Бонус:**
Если кому вдруг нужно, заскринил иконки «X-диска» и «Автоматора».
[](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosxbonus1.jpg "Клик! Зуум!") [](http://www.allofphotoshop.ru/temp/eeepc1000h/macosx/macosxbonus2.jpg "Клик! Зуум!") | https://habr.com/ru/post/41243/ | null | ru | null |
# Firefox будет отображать переводы строк (LF) во всплывающих подсказках (атрибутах title)
Как известно, спецификация HTML 4.01 чёрным по белому [требует](http://www.w3.org/TR/html4/types.html#h-6.2) того, чтобы в строковых атрибутах (CDATA) символы перевода строки (LF) игнорировались, а символы возврата каретки (CR) заменялись пробелами.
А вот в спецификации HTML5, наоборот, символы перевода строки (LF) в атрибуте **title** [считаются значимыми](http://www.whatwg.org/specs/web-apps/current-work/multipage/elements.html#the-title-attribute). Предполагается, что можно набрать код наподобие нижеследующего:
```
[…](… "Первая строка.
Вторая строка.")
```
и ожидать, что при наведении на гиперссылку явится двустрочная всплывающая подсказка.
>
> > Кстати, я-то там набрал «» — но Хабрахабр заменил этот код реальным переводом строки. По меньшей мере, у меня в Файерфоксе. Этакий вот баг хабратэга . Впрочем, согласно HTML5, значимыми являются **обе** эти формы перевода строки. И сам символ, и его entity.
>
>
Internet Explorer как раз так всю дорогу и вёл себя (по меньшей мере, последние шесть лет) — плевать хотел на HTML 4.01, отображал многострочную подсказку. Уместно думать, что именно поведение MSIE послужило источником вдохновения для авторов соответствующего подраздела HTML5.
А несколько дней назад (25 января) эта проблема ([bug 358452](https://bugzilla.mozilla.org/show_bug.cgi?id=358452)) была решена и в Файерфоксе. По-видимому, первой версией Файерфокса с поддержкою многострочных всплывающих подсказок станет **Firefox 12**.
→ При оформлении использована [фотография](http://www.flickr.com/photos/r-butler/5399817871/sizes/s/in/photostream/) клавиши «Enter», автор [ReillyButler](http://www.flickr.com/photos/r-butler/), лицензия [CC BY-SA 2.0](http://creativecommons.org/licenses/by-sa/2.0/). | https://habr.com/ru/post/137232/ | null | ru | null |
# Баг в ESP-IDF: MDNS, Wireshark и при чём тут единороги
Всем привет. Я занимаюсь коммерческой разработкой в IoT, в основном мы используем модули от Espressif - ESP8266 и ESP32.
В рамках "[догфудинга](https://en.wikipedia.org/wiki/Eating_your_own_dog_food)" мы иногда берём свои продукты домой и используем в повседневной жизни. И вот, однажды, от одного из сотрудников поступила жалоба: после установки новой тестовой прошивки на устройстве, его домашняя сеть сначала начала жестоко глючить и зависать, а потом ситуация нормализовалась, но наш девайс более не был виден ни в локальной сети, ни в облаке.
Налицо какой-то коллапс. Но какой? На других сетях мы такого поведения не наблюдали, так что было решено высадить к сотруднику развед-десант в лице меня, экипированного всем необходимым.
### Разведка
Для начала, я решил собрать максимальное количество данных про ситуацию в её терминальной стадии. Не перезагружая устройство, я запустил Wireshark в режиме Monitor Mode, настроив фильтрацию на MAC-адрес устройства. Выяснилось, что девайс уверен, что его сеть в порядке - он упорно слал роутеру какие-то данные, однако роутер ему ничего не отвечал. **Хм, подозрительно.**
В админке роутера девайс тоже был виден как подключенный. Но почему же нету обратной связи? На этот вопрос я получил ответ, когда решил подключить к этому же роутеру ещё одно устройство (точнее, один из своих [devkit](https://www.wemos.cc/en/latest/d1/d1_mini.html)-ов), и убрал фильтрацию в Wireshark. Оказывается, у роутера поменялся MAC-адрес! **Хм, подозрительно**. Поменялся он ровно на один последний бит, при этом вся остальная техника эту подмену осознала, а вот наше устройство - нет, и упорно отсылало данные на старый мак-адрес, который, конечно же, никто уже не слушал.
Ладно, пришло время узнать больше. Перезагружаем роутер. Теоретически, это же должно вернуть его MAC в "обычное" состояние? И действительно, MAC вернулся. Но зависший девайс уже был "в коме", и упорно не хотел ничего делать. Ничего нового мы от него уже не узнаем, так что перезагружаем и его. А заодно, дабы собрать больше данных, пропишем в Wireshark пароль от роутера, чтобы он расшифровал весь трафик.
### Коллапс
Тут произошло что-то странное. Сначала девайс, как положено, вернулся в сеть. А дальше началось... Количество сообщений в окне Wireshark начало расти с невероятной скоростью. Впрочем, через несколько минут всё остановилось - роутер снова решил проявить свою альтернативную, отличающуюся на один бит, сущность. Ладно, у нас есть дамп, давайте посмотрим, что это было.
**And the winner is...** 99% захваченных пакетов были про [MDNS](https://en.wikipedia.org/wiki/Multicast_DNS). Мы действительно используем его, чтобы телефоны могли найти наши девайсы в локальной сети, и работать с ними даже в условиях отсутствия облака (что иногда случается по разным причинам, начиная с "забыли заплатить за интернет", и заканчивая [сбоями у Amazon](https://www.theverge.com/2020/11/25/21719396/amazon-web-services-aws-outage-down-internet)). Но почему так много? Интервал между сообщениями - десятки миллисекунд, и соотношение "входящих/исходящих" (по отношению к девайсу) примерно одинаковое. Что ж, пора раскуривать.
Последовательность пакетов была следующая:
1. Девайс регистрируется в multicast-группе MDNS, чтобы иметь возможность получать запросы на обнаружение.
2. Девайс отправляет collision-query-пакет с запросом ANY на полный адрес своего "сервиса", чтобы узнать, есть ли в сети кто-то, кому он может "помешать".
3. Роутер перенаправляет collision-query-пакет всем устройствам multicast-группы, **включая сам девайс**.
4. Девайс отправляет advertise-пакет с PTR, SRV, TXT и A/AAAA записями multicast-группе MDNS, сообщая, что он появился в сети.
5. Роутер перенаправляет advertise-пакет всем устройствам multicast-группы, **включая сам девайс**.
6. 2-5 пункты начинают повторяться с большой скоростью.
Сразу становится понятно, почему проблема не проявлялась на нашем тестовом окружении в офисе - наши роутеры не перенаправляют multicast самому отправителю. Но почему мы не видели этого поведения на старой прошивке? И действительно, откатив девайс до старой версии, я стабилизировал ситуацию. Начинаем бить в бубен.
Делаем diff. Видим, что немного поменялся код внутренней логики, не влияющий на сетевую часть. Что ж, это можно отмести почти сразу. Ещё поменялся номер версии... Ну да, с 0.9 на 0.10. Не может же это влиять? Или... Ладно, пока оставим эту мысль. Ищем, где отправляются пакеты из MDNS.
### Debugger? printf!
Как поступил бы на моём месте любой профессиональный разработчик? Правильно: начал обмазывать логами все места отправки пакетов в файле [mdns.c](https://github.com/espressif/esp-idf/blob/v4.0.2/components/mdns/mdns.c). Поиск быстро привёл меня к функции [\_mdns\_create\_probe\_packet](https://github.com/espressif/esp-idf/blob/v4.0.2/components/mdns/mdns.c#L1312). Поискав по файлу места, из которых она вызывается (и пройдя по стеку вызовов немного дальше), я остановился на строчке [#2917 в функции mdns\_parse\_packet](https://github.com/espressif/esp-idf/blob/v4.0.2/components/mdns/mdns.c#L2917). В логах это место действительно появлялось очень часто. Подозрение пало на [вызов \_mdns\_check\_txt\_collision](https://github.com/espressif/esp-idf/blob/v4.0.2/components/mdns/mdns.c#L2913). Тут начала вырисовываться картина происходящего: девайс, получая свой же advertise, находил в нём TXT-запись, и сравнивал его со своим TXT. Но ведь он сам его отправил! Ладно, смотрим код [самой функции](https://github.com/espressif/esp-idf/blob/v4.0.2/components/mdns/mdns.c#L2095). Я даже приведу его тут по частям, с описанием происходящего.
```
size_t data_len = 1;
if (len == 1 && service->txt) {
return -1;//we win
} else if (len > 1 && !service->txt) {
return 1;//they win
} else if (len == 1 && !service->txt) {
return 0;//same
}
```
Тут мы создаём переменную `data_len`, а так же проверяем наличие TXT-записи в нашем `service`. Вроде бы всё нормально - тут мы проходим дальше.
```
mdns_txt_linked_item_t * txt = service->txt;
while (txt) {
data_len += 2 + strlen(service->txt->key) + strlen(service->txt->value);
txt = txt->next;
}
if (len > data_len) {
return 1;//they win
} else if (len < data_len) {
return -1;//we win
}
```
Тут мы высчитываем длину буфера, в который должен влезть наш TXT из сервиса, а заодно сравниваем эту длину с тем, что мы получили из эфира.
```
uint8_t ours[len];
uint16_t index = 0;
char * tmp;
txt = service->txt;
while (txt) {
tmp = (char *)malloc(2 + strlen(txt->key) + strlen(txt->value));
if (tmp) {
sprintf(tmp, "%s=%s", txt->key, txt->value);
_mdns_append_string(ours, &index, tmp);
free(tmp);
} else {
HOOK_MALLOC_FAILED;
// continue
}
txt = txt->next;
}
int ret = memcmp(ours, data, len);
if (ret > 0) {
return -1;//we win
} else if (ret < 0) {
return 1;//they win
}
return 0;//same
```
Ну и тут мы кодируем наш TXT в буфер, размер которого уже просчитали (и проверили), и сравниваем его содержимое с полученным.
Уже нашли ошибку? Я тоже заметил её не сразу, поэтому решил пройтись по коду построчно. Опять же, помог мне с этим `printf`.
Когда я "упал" на проверке длины, я немного удивился. Но как? Ведь "правильная" длина (которую 10мс назад отправил сам девайс) точно совпадает с "входящей"! Давайте ещё раз взглянем на её подсчёт.
```
mdns_txt_linked_item_t * txt = service->txt;
while (txt) {
data_len += 2 + strlen(service->txt->key) + strlen(service->txt->value);
txt = txt->next;
}
```
Окей, тут явно виден проход по linked-list. Мы берём очередной элемент, берём длину его `key` и `value`... Стоп. Его или `service->txt`? Так, понятно...
Выходит, из-за бага в коде (который, если верить `git blame`, лежит там уже очень много лет), мы всегда берём длину от первого элемента. Но как это работало всё это время? А вот так: нам повезло. Всё это время TXT-записи, которые мы добавляли, по сумме длин чётко совпадали с длиной первого, умноженного на N. Получается, стоило нам добавить новый элемент, поменять порядок элементов, или изменить длину любого из них - и всё, баг начинал проявляться. Но при чём тут номер версии? Ах да, мы же передаём его в MDNS... Паззл сошёлся.
### И что дальше?
Соответствующий [issue](https://github.com/espressif/esp-idf/issues/6114) в ESP-IDF я отправил, в своих рабочих копиях мы это место исправили, и наши девайсы прекратили сводить с ума бедные роутеры.
Но тут встал правильный вопрос: а сколько ещё таких багов может быть в SDK? Проект большой, кода много (а часть ещё и стороннего - в виде submodule). Наверняка есть что-то интересное, странное, ужасное...? То, что не вылезает у нас на тестировании, но может создать нам проблем в случайный момент времени.
### Так при чём тут единороги?
С этой мыслью я написал [@Andrey2008](/users/andrey2008) вспоминая про PVS-Studio. Он любезно согласился попробовать посмотреть на этот проект, а также поделился триальной версией ключа для PVS-Studio, чтобы я мог попытаться проанализировать код самостоятельно. Забегая вперёд, скажу, что там есть, на что посмотреть... Но об этом - в следующей серии.
А поймал ли единорог этот баг?К сожалению, data flow PVS-Studio не нашёл этой проблемы с linked-list. Но будем справедливы - я тоже обратил внимание на эту ошибку не с первого раза (и даже не с третьей вычитки кода). Андрей говорит, что подобную диагностику добавить можно - а значит, одна из следующих версий может начать ловить такие гейзенбаги. | https://habr.com/ru/post/530466/ | null | ru | null |
# Деплой Docker Image на Dokku с помощью Ansible
Пролог
------
Недавно я узнал о "карманном" PaaS похожем на Heroku с довольно очевидным названием — Dokku. Очень привлекла возможность простого добавления сертификата к приложению и vhost из коробки, поэтому я решил перенести свои docker образы на Dokku. Правда, я был разочарован тем, что в Dokku нет команд подобных Heroku
```
dokku container:push
dokku container:release
// Очень было бы удобно, но еще нет :(
```
Существует команда [`tags`](http://dokku.viewdocs.io/dokku~v0.20.4/deployment/methods/images/) которая позволяет деплоить образы, но сам образ должен быть уже на хосте в этот момент. Иными словами, чтобы выкатить только что сделанный локальный image его нужно сначала скопировать на хост.
```
tags:create # Add tag to latest running app image
tags:deploy # Deploy tagged app image
tags:destroy # Remove app image tag
```
Я знаком с Ansible и даже создавал с его помощью простые пайплайны для доставки бекенда, поэтому выбор был прост. Можно было бы конечно запариться и написать плагин к dokku, но нет, не сейчас.
Playbook
--------
Этот playbook архивирует некий локальный образ, копирует на хост, восстанавливает и деплоит его в dokku. Разместил в Gitlab репе. Возможностей для улучшения еще полно.
### [push-image.dokku.yml](https://gitlab.com/nogipx-oss/docker-preset/-/blob/master/dokku/push-image.dokku.yml)
**push-image.dokku.yml**
```
---
- name: "DEPLOY APP '{{ appname }}' TO DOKKU"
hosts: dokku_hosts
remote_user: root
gather_facts: false
vars:
tarname: "{{ appname }}__{{ image }}.tar"
upload_dir: "/usr/local/src"
upload_path: "{{ upload_dir }}/{{ tarname }}"
apptag: "{{ upload_tag | default('latest') }}"
dokku_image: "dokku/{{ appname }}:{{ apptag }}"
tasks:
- name: "Archive '{{ image }}' to upload"
register: env
delegate_to: localhost
shell:
cmd: docker image save -o "./{{ tarname }}" {{ image }}
- name: "Upload image '{{ image }}' to dokku at '{{ inventory_hostname }}'"
register: upload
copy:
src: "./{{ tarname }}"
dest: "{{ upload_path }}"
- name: "Log - Upload result"
debug:
var: upload.dest
- name: "Restore uploaded docker image"
register: restore
shell:
cmd: docker image load -i "{{ upload_path }}"
- name: "Log - Restore image"
debug:
var: restore.stdout_lines
- name: "Retag image to '{{ dokku_image }}'"
shell:
cmd: docker tag "{{ image }}" "{{ dokku_image }}"
- name: "Create dokku tag for '{{ dokku_image }}'"
shell:
cmd: dokku tags:create "{{ appname }}" "{{ apptag }}"
- name: "Release '{{ appname }}'"
register: release
shell:
cmd: dokku tags:deploy "{{ appname }}" "{{ apptag }}"
- name: "Log - Release"
debug:
var: release.stdout_lines
```
*предполагается что ansible на локальной машине и dokku на хосте уже установлены*
Использовать так
```
ansible-playbook push-image.dokku.yml -i some_inventory -e "appname=DOKKU_APP_NAME image=DOCKER_IMAGE"
```
some\_inventory
```
[dokku_hosts]
your.domain.example
``` | https://habr.com/ru/post/504236/ | null | ru | null |
# PHP 8.1: до и после
[PHP 8.1](https://wiki.php.net/todo/php81) выйдет через несколько месяцев и я в восторге от множества нововведений! Хочу поделиться реальным влиянием PHP 8.1 на мой собственный код.
### Перечисления
Долгожданный функционал, перечисления скоро будут доступны!
О них можно сказать не так много, кроме того, что я с нетерпением жду, когда мне больше не придётся использовать [spatie/enum](https://github.com/spatie/enum) или [myclabs/php-enum](https://github.com/myclabs/php-enum). Спасибо за все годы поддержки этих enum-пакетов, но они будут первыми, от которых я откажусь, когда появится PHP 8.1 и когда я изменю это:
```
/**
* @method static self draft()
* @method static self published()
* @method static self archived()
*/
class StatusEnum extends Enum
{
}
```
На это:
```
enum Status
{
case draft;
case published;
case archived;
}
```
### Распаковка массивов со строковыми ключами
Может показаться незначительным, но меня это не раз беспокоило: до PHP 8.1 можно было распаковывать только массивы с числовыми ключами:
```
$a = [1, 2, 3];
$b = [4, 5, 6];
// Доступно, начиная с PHP 7.4
$new = [...$a, ...$b];
```
В то время как массивы со строковыми ключами распаковать таким образом было нельзя:
```
$a = ['a' => 1, 'b' => 2, 'c' => 3];
$b = ['d' => 4, 'e' => 5, 'f' => 6];
$new = [...$a, ...$b];
// В этом случае необходимо использовать array_merge
$new = array_merge($a, $b);
```
Итак, одна из особенностей PHP 8.1, которая облегчит мне жизнь, заключается в том, что теперь можно также распаковывать массивы со строковыми ключами!
```
$a = ['a' => 1, 'b' => 2, 'c' => 3];
$b = ['d' => 4, 'e' => 5, 'f' => 6];
// :)
$new = [...$a, ...$b];
```
### Свойства класса: инициализаторы и readonly
Ещё одно замечательное улучшение, которое я ждал годами: аргументы по умолчанию в параметрах функции. Представьте, что вы хотите установить класс состояния по умолчанию для объекта `BlogData`. До PHP 8.1 вам необходимо было объявить его допускающим значение `null` и установить в конструкторе:
```
class BlogData
{
public function __construct(
public string $title,
public ?BlogState $state = null,
) {
$this->state ??= new Draft();
}
}
```
PHP 8.1 позволяет вызов `new` непосредственно в определении функции. Это потрясающе:
```
class BlogData
{
public function __construct(
public string $title,
public BlogState $state = new Draft(),
) {
}
}
```
Говоря о грандиозных нововведениях, я уже упоминал, что readonly-свойства теперь стали явью?!?
```
class BlogData
{
public function __construct(
public readonly string $title,
public readonly BlogState $state = new Draft(),
) {
}
}
```
Да, кстати, не беспокойтесь о клонировании, [я о вас позаботился](https://stitcher.io/blog/cloning-readonly-properties-in-php-81).
### First-class callable
Как будто всего этого было недостаточно, теперь также доступен синтаксис First-class callable, который позволяет использовать более чистый код для создания замыканий из вызываемых объектов.
Раньше приходилось писать что-то вроде этого:
```
$strlen = Closure::fromCallable('strlen');
$callback = Closure::fromCallable([$object, 'method']);
```
В PHP 8.1 вы можете написать… так:
```
$strlen = strlen(...);
$callback = $object->method(...);
```
В PHP 8.1 есть ещё [много нового](https://habr.com/ru/company/otus/blog/567710/), но это то, что меня волнует больше всего. | https://habr.com/ru/post/569652/ | null | ru | null |
# Как не проиграть с производительностью в длительном скроллинге
### Привет, хабр!
Меня зовут Михаил Кириченко. Я разрабатываю клиентскую часть в компании Bimeister.
В этой статье хочу поделиться своим опытом и практиками, которые мне приходилось применять в своей работе, а главное, ответить на вопрос: как лучше подходить к построению интерфейсов, чтобы не проиграть с производительностью при скроллинге.
Отмечу, что я не буду детально рассматривать описанные мной подходы и показывать примеры кода, иначе я буду размышлять об избитых темах. Любопытный читатель сможет быстро найти всю необходимую информацию во всемирной паутине, если будет такая необходимость. Моя цель — предоставить вам идеи и мысли в описательно-пояснительном ключе.
### Вместо введения
В современных приложениях используются очень насыщенные интерфейсы с большим количеством элементов на странице. Рендеринг такого объема данных влечет за собой наличие громоздкого DOM-дерева, что является одной из основных причин тормозов на сайте. Если изучить вопрос как браузер рендерит страницу, то становится понятно, что чем больше дерево, тем больше ресурсов требуется механизмам *repaint* и *reflow*. Процитирую информацию с [официального сайта Google](https://web.dev/i18n/ru/dom-size/), который призван помогать веб-разработчикам делать продвинутые интерфейсы
> Разработчики браузеров рекомендуют, чтобы страницы содержали менее **1500** узлов DOM. Рекомендация — это глубина дерева < **32** элемента и менее **60** дочерних/родительских элементов. Большой DOM может увеличить использование памяти, вызвать более длительные вычисления стилей и привести к дорогостоящим перекомпоновкам *layout*.
>
>
Итак, имеем промежуточный вывод: нужно трепетно следить за размером DOM-дерева. Одним из немногих выходов из этой ситуации является использование пагинации. Понятно, что самый простой случай — это использовать пагинацию на кнопках. Если на вашем проекте этот способ рабочий, с ним согласны дизайнеры, тогда считайте, что вам повезло. Однако на практике дела обстоят иначе. Дизайнеры не хотят использовать кнопки для этих целей. Как минимум потому что теряется контекст и приходится постоянно возвращаться к предыдущим страницам, чтобы вспомнить что же там было. Современный веб-дизайн предполагает бесконечную прокрутку, потому что это более естественный сценарий взаимодействия с интерфейсом. В самом деле, одним из самых популярных действий пользователя на сайте является скролл.
Стандартными решениями являются виртуальный и бесконечный скроллинг. Ниже мы сравним эти подходы, чтобы понять их сильные и слабые стороны. Далее я продемонстрирую умный бесконечный скроллинг, который может помочь вам спроектировать более производительный интерфейс.
### Виртуальный скроллинг
Идея виртуального скроллинга состоит в том, чтобы отображать только те элементы в списке, которые непосредственно видны на экране. Тем самым не важно, какой длины у вас список, в DOM-дереве у вас находятся только элементы в зоне видимости.
Virtual ScrollingВиртуальный скроллинг добавляет слайсы данных с одной стороны, а также убирает данные с другой. Чтобы это работало — размеры элементов должны быть предсказуемы. Однако обычно нам это неизвестно, поэтому мы начинаем просить дизайнера рисовать карточки равной размерности, чтобы мы могли применить данный подход.
Если размеры элементов известны/предсказуемы, то это, наверное, лучший способ вывода списков. Примеры, когда размеры действительно можно предугадать:
* Календарь. Размер каждого месяца любого года можно рассчитать.
* PDF-документ. Формат PDF сразу в себе имеет необходимую мета-информацию, в которой числятся все размеры входящих страниц.
Также несомненным плюсом данного подхода является честный скроллбар. Его высота показывает сколько действительно данных находится в этом списке, а также позволяет сразу переместиться в любое место списка.
**Итого:**
* Размеры элементов должны быть предсказуемы ➖
* Честный скроллбар ➕
* Отображается только то, что в зоне видимости ➕
### Бесконечный скроллинг
Наверное, это самый популярный подход к скроллингу на данный момент. Идея заключается в следующем: каждый следующий слайс данных грузится, как только подошли к концу списка.
Infinity ScrollingВ данном подходе нам не важен размер элементов — мы можем рендерить элементы любой размерности. Казалось бы, дизайнеры счастливы, поэтому можно смело внедрять его в свой проект. Но не торопитесь.
В данном подходе мы никак не удаляем из DOM-дерева элементы, которые уже не видны. Поэтому, если немного постараться и поскроллить относительное время, можно перенагрузить дерево. Страница станет тормозить, а в худшем случае браузер попросит ее закрыть.
К тому же, если у нас динамически меняются данные, то придётся заново загружать элементы, вне зависимости от их попадания в область видимости и позиции скроллбара. Что несомненно вызовет рекалькуляцию дерева и уменьшит производительность.
В данном подходе мы имеем нечестный скроллбар. Он не показывает действительное количество элементов в списке, а также у пользователя нет возможности потянуть за ползунок и переместиться в любое место.
**Итого:**
* Размеры элементов могут быть любые ➕
* Нечестный скроллбар ➖
* Элементы не исчезают из DOM-дерева, если они уже не видны ➖
### Что же делать? Умный подход к бесконечному скроллингу
У двух вышеописанных подходов есть свои плюсы и минусы. Предлагаю объединить все лучшее из них, чтобы создать новый скроллинг, который не будет иметь проблем с производительностью, а также позволит нам не задумываться о размерах элементов списка.
Общаясь в одном популярном мессенджере, я обратил внимание как сделан скроллинг. При изучении веб-версии мне удалось обнаружить:
* Сообщения в ленте разной размерности. Что логично.
* Сообщения подгружаются через бесконечный скроллинг.
* Как бы долго я не скроллил, проблем с производительностью не было обнаружено.
И вот почему. Пока ты скроллишь и подгружаешь новые слайсы данных, уменьшается ползунок скроллбара. Но в какой-то момент ползунок скроллбара снова увеличился. Это означает, что раннее загруженные данные были выкинуты из памяти и из DOM-дерева.
Данный подход к скроллингу мне удалось объяснить следующим образом: это обычный бесконечный скроллинг, который подгружает данные. В данном скроллинге мы имеем некоторое значение буфера, например, **500** элементов. Как только мы пересекаем это значение — то выкидываем лишнее из памяти. Значение буфера достаточное, чтобы точно удостовериться, что элементы, которые мы будем выкидывать, точно не видно. Нам все известно, чтобы понять с какой стороны списка выкидывать элементы. Если скроллили вниз — выкидываем сверху. Если скроллили вверх — снизу.
Я буду псевдокодом показывать примерную имплементацию данного скроллинга на **Angular**-е. Такой механизм можно воспроизвести на любом фреймворке, если понятна сама идея.
Для начала необходимо переконструировать привычный бесконечный скроллинг, так чтобы он мог подгружать данные сверху и снизу. Сделать это можно через якоря и `IntersectionObserver`. Проектируем `infinityScrollComponent`. Вот как будет выглядеть его шаблон:
```
```
Как только якорь появился в области видимости — отображаем следующий слайс. При желании якорем может быть любой элемент, например, это может быть спиннер, который будет демонстрировать пользователю, что данные грузятся.
Также в данном компоненте мы следим за скроллом: его позицией, направлением и за всем тем, что нам может помочь в принятии решений. Как за этим можно следить — я оставляю за рамками.
Как будет выглядеть использование компонента снаружи:
```
Some Item {{ item.name }}
```
На вход мы передаем контроллер. Контроллер — это единственный источник принятия решений. Вся бизнес-логика будет обрабатываться там, что позволяет нам сделать наш компонент максимально прозрачным. В таком случае, наш компонент просто рендерит список и сообщает, что с ним происходит: какое состояние скроллбара, направление скролла, сколько элементов отображается и т.д. Что именно будет рендериться в DOM-дереве мы передаем через директиву. Компонент внутри себя следит за этой директивой, забирает темплейт и отображает в нужном месте.
Обработка событий может выглядеть следующим образом:
```
enum ScrollMoveDirection {
FromTopToBottom,
FromBottomToTop,
}
interface SomeItem {
id: string;
name: string;
}
@Component()
export class ClientScrollerComponent {
/**
* Создаем контроллер.Передаем настройки взаимодействия.
* Поле scrollMoveDirection отвечает за направление изначального скролинга.
* По умолчанию значение FromTopToBottom.
*
* Поле useBuffer отвечает за то использовать buffer или нет.
* Если буффер не используется, то компонент работает как обычный скролбар.
*
* Поле trackBy поможет ангуляру понять, какие именно элементы подлежат ререндрингу.
*
* А также еще много опций здесь может передаваться в зависмости от вашей логики.
*/
public readonly controller: InfinityScrollerController = new InfinityScrollerController({
scrollMoveDirection: ScrollMoveDirection.FromBottomToTop,
useBuffer: true,
trackBy: (_: number, item: SomeItem) => item.id,
/**
* Здесь можно прокинуть еще много опций конфигурации.
* Ограничиваясь, лишь вашей логикой использования.
* Например, pullToRefresh. Или кастомную стратегию буферизации.
*/
});
private getNextPageHandler(): Subscription {
return this.controller
.getEvents(InfinityScrollerEvents.GetNextPage)
.subscribe((event: InfinityScrollerEvents.GetNextPage) => {
/**
* Здесь логика дозапроса следующего слайса.
* Когда дозапросили -- необходимо заново положить данные.
*/
this.controller.setData(data);
});
}
private getPrevPageHandler(): Subscription {
return this.controller
.getEvents(InfinityScrollerEvents.GetPrevPage)
.subscribe((event: InfinityScrollerEvents.GetPrevPage) => {
/**
* Здесь логика дозапроса предыдущего слайса. Когда дозапросили -- необходимо заново положить данные.
* Соответственно, если использовать скроллинг без буфера, то это событие не будет приходить.
* Ведь мы ничего не выкидываем из данных.
*/
this.controller.setData(data);
});
}
private applyBufferContaining(): Subscription {
return this.controller
.getEvents(InfinityScrollerEvents.BufferFull)
.subscribe((event: InfinityScrollerEvents.BufferFull) => {
/**
* Здесь логика урезки данных. В событии может приходить сопутствующая информация.
* Например, с какой стороны резать данные: сверху или снизу.
*/
this.controller.setData(data);
});
}
}
```
Здесь создается контроллер, в который прокидываются все необходимые конфигурации. И для примера реализации приведены хендлеры `getNextPageHandler`, `getPrevPageHandler` и `applyBufferContaining`. Работают они на принципе получения событий из контроллера. Контроллер посылает события, которые можно обработать через метод `getEvents(…)`. Хендлеры обрабатывают события и дозапрашивают данные. Их основная цель — это передать новые элементы через метод `setData(…)`, доступным в контроллере.
Вот как может выглядеть примерная реализация контроллера:
```
export class InfinityScrollerController {
/\*\*
\* EventBus -- класс для передачи/получения событий.
\*/
public readonly eventBus: EventBus = new EventBus();
/\*\*
\* Необходимые мета-данные:
\* направление скрола, размер буфера, данные, общее количество данных,
\* функиция трекинга и многие другие
\*/
public readonly scrollMoveDirection: ScrollMoveDirection;
public readonly bufferSize: number | null;
public readonly data$: BehaviorSubject = new BehaviorSubject([]);
public readonly totalCount$: BehaviorSubject = new BehaviorSubject(0);
public readonly trackBy$: BehaviorSubject> = new BehaviorSubject>(
InfinityScrollerController.trackBy
);
constructor(config: InfinityScrollerOptions) {
/\*\*
\* Здесь обрабатываем переданные конфигурации.
\* Сохраняем их для дальнешего использования.
\*/
}
public handleTopAnchorIntersect(): void {
/\*\*
\* Здесь обрабытываем, когда нижний якорь показался в зоне видимости.
\* То есть обрабатываем сценарий дозапроса данных снизу.
\* Отправляем событие, по которому можно выполнить дозагрузку данных.
\*/
this.eventBus.dispatch(InfinityScrollerEvents.GetNextPage);
}
public handleBottomAnchorIntersect(): void {
/\*\*
\* Здесь обрабытываем, когда верхний якорь показался в зоне видимости.
\* То есть обрабатываем сценарий дозапроса данных сверху.
\* Отправляем событие, по которому можно выполнить дозагрузку данных.
\*/
this.eventBus.dispatch(InfinityScrollerEvents.GetPrevPage);
}
public setData(data: T[]): void {
/\*\*
\* Здесь обновляем данные в data$.
\* Также именно здесь можно проверять переполнение буфера
\* и соответственно резать данные.
\*/
}
public getEvent(eventType: Type): Observable {
/\*\* Метод позволяет отлавливать события снаружи. \*/
}
}
```
Стоит немного остановиться на объяснении класса `EventBus`. Это класс-хелпер, который позволяет манипулировать событиями: отправлять и слушать. Можете относиться к этому классу следующем образом: он просто содержит `Subject`, который кеширует последнее событие.
```
private readonly event$: Subject = new Subject();
```
Также этот класс имеет вспомогательные методы, которые позволяют отправлять событие и слушать его появление.
Сам контроллер можно положить рядом с компонентом `infinityScrollerComponent`. По реализации видно, что контроллер создается на месте использования компонента. А это означает, что мы имеем гибкий подход: мы можем передавать на вход компоненту любой свой кастомный контроллер, который будет обрабатывать скролл на свое усмотрение. Если коротко, получили расширяемость и переиспользуемость. Схематично это выглядит так:
#### Что стоит учитывать: привязка скролла
Когда подгружаешь данные через бесконечный скроллинг снизу, то визуально позиция контента не меняется. Ползунок скроллбара автоматически отпрыгивает в нужное место. Это происходит из-за CSS-свойства `overflow-anchor: auto;`. Данное свойство включено по умолчанию почти во всех популярных браузерах, оно позволяет привязать скролл к якорному элементу. Вот [пример](https://codepen.io/chriscoyier/embed/oWgENp), который поможет вам понять, как работает это свойство.
Важно заметить, что привязке скролла могут препятствовать другие CSS-свойства, которые могут влиять на положение и размеры элемента: `top`, `left`, `right`, `bottom`, `margin`, `padding`, `transform`.
Если подгружать данные сверху, то такой трюк перестает работать. Поэтому необходимо закешировать позицию скроллбара и при появлении новых данных подскроллить к этой позиции.
```
const scrollHeight: number = this.scrollable.element.scrollHeight;
const newScrollTop: number = scrollHeight - cacheContentHeight;
this.scrollable.setScrollTop(newScrollTop);
```
#### Оптимизации
Так как внутри скроллящейся области мы постоянно меняем контент, что приводит к изменению DOM, то браузеру приходится пересчитывать *layout.* Это является дорогостоящей операцией. Чтобы помочь браузеру в расчетах, можно добавить CSS-свойство `contain: content;`, которое сообщает браузеру, что скроллящийся блок и все его содержимое не влияет на внешние слои и их компоновку.
Также имеет смысл вынести все содержимое скроллящегося контейнера в отдельный слой, чтобы компоновка и перерасчет стилей был отделен от основного потока. Сделать это можно следующим образом.
```
transform: translateZ(0);
will-change: transform;
```
CSS-свойство `will-change: transform;` позволяет нам дать рекомендацию браузеру, что *“тут будет часто меняться позиционирование, имеет смысл вынести все в отдельный слой”*.
#### Промежуточный итог
Конечно, не обошлось без жертв. В данном подходе не удалось сохранить честный скроллбар, то есть нельзя будет потянуть за ползунок и переместиться в любое место списка. Важно это или нет — зависит от того как к этому относиться. Скорее всего, если пользователь скроллит весь список целиком или ему важно через ползунок перемещаться в любое место, то вы спроектировали интерфейс неправильно. Вам стоит подумать над тем, как организовать фильтрацию таким образом, чтобы нужные элементы были в поисковой выдаче как можно раньше.
Теперь у нас нет проблем с производительностью, ведь элементы удаляются из DOM-дерева. А также мы можем отображать любой контент любой размерности. Дизайнеры довольны.
Кроме оптимизации потребления памяти, мы получили преимущество в передаваемых данных по сети, ведь если нам надо будет обновить список, то мы обновим лишь необходимую видимую часть. Грузить весь список целиком до нужного слайса не придется, как это было с обычным бесконечным скроллингом. Поэтому батарейки на мобильных устройствах будут вам благодарны.
Будьте аккуратны при выборе размера буфера: он должен быть таким, чтобы данные точно смогли бы перекрыть область видимости. Например, если область просмотра `600px` по высоте при вертикальном скролле, элементы высотой `10-20px`, а буфер равен **50**, то данные точно не перекроют всю область. Будут дырки, которые пагубно влияют на отзывчивость интерфейса. Но это решаемая проблема.
Я лишь для демонстрации своей идеи предложил зафиксировать буфер. Конечно, так делать не стоит. Лучше всего сделать его динамическим. Компонент, который выводит элементы списка, можно сказать, знает о них все, что требуется. Чтобы динамически выставлять значение буфера, надо следить за общей габаритной высотой элементов списка и сравнивать ее с высотой области видимости, чтобы гарантировано ее перекрывать. Также следует не забывать, что пользователь может изменять размеры экрана, поэтому вычисления надо будет повторить при ресайзе.
**Итого:**
* Размеры элементов могут быть любые ➕
* Нечестный скроллбар ➖
* Элементы, которое не входят в значения буфера, удаляются из DOM ➕
#### Доступность
Используйте данный вид скроллинга осознанно. Только для тех мест, где он действительно пригоден. Есть несколько проблем, которые стоит учитывать при проектировании интерфейса.
Поиск по странице через комбинацию `ctrl + f`. Так как мы грузим данные по слайсам, то у нас нет всех данных, чтобы браузер смог найти совпадения. Но это решаемая проблема. Необходимо перехватить комбинацию клавиш и обработать до того момента, пока это сделал браузер. Дальше — дело техники.
Стоит учитывать, что вашим сайтом могут пользоваться слабовидящие пользователи. Они пользуются страницей через переключение фокуса. Проблема настанет, когда фокус оказался на последнем элементе списка, а новый слайс еще не загружен. В таком случае скрин-реадер просто скажет, что *страница закончена*, хотя, это не так. Поэтому важно отображать чуть больше, чем умещается в области видимости. Тогда при переключении фокуса будет немножко скроллиться контент, а значит, будет отрабатывать наша логика подгрузки данных.
Если пользователи захотят распечатать страницу, то у них отобразиться только тот слайс, который был загружен. Как с этим быть решайте сами. Например, можно перехватить событие печати и загрузить все данные в DOM-дерево, тогда на печать будет выводиться весь контент.
---
### Выводы
В данной статье был продемонстрирован новый подход к построению интерфейсов благодаря использованию умного бесконечного скроллинга. Бесконечный скроллинг с буфером позволяет отображать списки любой размерности и не засоряет DOM-дерево.
Данный вид скроллинга полезен для того контента, где заранее нельзя предугадать размеры элементов. Например, это могут быть чаты или ленты новостей.
И, конечно же, какой именно скроллинг подходит именно вашему продукту — решайте сами. Но не забывайте следить за размером DOM-дерева, чтобы не проиграть с производительностью! Буферный умный скроллинг может помочь вам выиграть. | https://habr.com/ru/post/686096/ | null | ru | null |
# Матчинг шаблона в Python 3.10
В Python 3.10 имплементирован своего рода оператор `switch` — что-то вроде него. Оператор `switch` в других языках, таких как C или Java, выполняет простой матчинг значения переменной и исполняет код в зависимости от этой величины.
Он может использоваться просто, как обычный оператор `switch`, но способен на гораздо большее.
Возможно, этого было бы достаточно для языка C, но ведь речь о Python, а в Python 3.10 реализована гораздо более мощная и гибкая конструкция, называемая *структурным сопоставлением шаблона*. Она может использоваться как простой оператор `switch`, но способна на гораздо большее.
Давайте рассмотрим несложный пример с оператором `switch`. Ниже приведен сниппет, который осуществляет выбор одного значения. Мы проверим его, запустив в цикле со значениями 1,2,3 и 4.
```
for thing in [1,2,3,4]:
match thing:
case 1:
print("thing is 1")
case 2:
print("thing is 2")
case 3:
print("thing is 3")
case _:
print("thing is not 1, 2 or 3")
```
Первое, что бросается в глаза, — это аккуратность синтаксиса. Он начинается с ключевого слова `match`, за которым следует имя переменной. Затем идет список кейсов, начинающийся с `case` и сопровождающийся значением, которое сопоставляется. Обратите внимание на использование двоеточий и отступов.
Это не отличается от оператора `switch/case` в других языках, но в отличие, например, от языка C, после исполнения кода для конкретного кейса проверка переходит к завершению оператора `match`.
Если совпадения нет, то происходит выполнение кода в случае по умолчанию, обозначенном символом `-`.
И вот результат.
```
thing is 1
thing is 2
thing is 3
thing is not 1, 2 or 3
```
В этом нет ничего удивительного.
Оператор `switch` — это простой кейс матчинга шаблона, но Python идет немного дальше. Взгляните на этот код:
```
for thing in [[1,2],[9,10],[1,2,3],[1],[0,0,0,0,0]]:
match thing:
case [x]:
print(f"single value: {x}")
case [x,y]:
print(f"two values: {x} and {y}")
case [x,y,z]:
print(f"three values: {x}, {y} and {z}")
case _:
print("too many values")
```
Это снова оператор `match` в цикле, но на этот раз в качестве перечня значений, которые цикл будет итерировать, выступают сами списки — сначала [1,2] затем [9,10] и так далее.
Операторы `case` пытаются выполнить матчинг этих списков. Первый `case` соответствует списку с одним элементом, второй — списку с двумя элементами, третий — списку с тремя элементами. Последний case используется по умолчанию.
Но он делает больше, чем это. Он также выполняет биндинг значений, которые сопоставляются с идентификаторами в операторе case. Так, например, первый список — это `[1,2]`, и он соответствует второму случаю `[x,y]`. Таким образом, в выполняемом коде идентификаторы x и y принимают значения 1 и 2, соответственно. Совсем неплохо, правда?
Итак, результат таков:
```
two values: 1 and 2
two values: 9 and 10
three values: 1, 2 and 3
single value: 1
too many values
```
Из нашей первой несложной программы мы знаем, что можно выполнять матчинг значений, а из приведенной выше — матчинг других, более общих шаблонов. Итак, можем ли мы делать матчинг шаблонов, включающих значения? Конечно!
```
for thing in [[1,2],[9,10],[3,4],[1,2,3],[1],[0,0,0,0,0]]:
match thing:
case [x]:
print(f"single value: {x}")
case [1,y]:
print(f"two values: 1 and {y}")
case [x,10]:
print(f"two values: {x} and 10")
case [x,y]:
print(f"two values: {x} and {y}")
case [x,y,z]:
print(f"three values: {x}, {y} and {z}")
case _:
print("too many values")
```
Например, во втором кейсе мы осуществляем матчинг списка, состоящего из двух элементов, первый из которых имеет значение 1.
Вот результат:
```
two values: 1 and 2
two values: 9 and 10
two values: 3 and 4
three values: 1, 2 and 3
single value: 1
too many values
```
Но это еще не все.
Вот программа, которая будет выполнять матчинг списка с любым количеством элементов.
```
for thing in [[1,2,3,4],['a','b','c'],"this won't be matched"]:
match thing:
case [*y]:
for i in y:
print(i)
case _:
print("unknown")
```
В первом `case` индентификатор отмечен звездочкой, и это означает, что к нему можно привязать весь список, который, как мы видим, можно итерировать с помощью цикла.
```
1
2
3
4
a
b
c
unknown
```
Это еще не все, но, надеюсь, данная статья дала вам представление о структурном сопоставлении шаблона в Python 3.10.
Более расширенно о дополнительном способе матчинга шаблона я писал [здесь](https://towardsdatascience.com/more-advanced-pattern-matching-in-python-3-10-2dbd8598302a).
На сайте [Python.org](http://python.org/) есть полное описание структурного сопоставления шаблона, включая учебное руководство, в [PEP 636](https://www.python.org/dev/peps/pep-0636/). Учебник довольно хороший, и я советую вам его прочитать.
В Python 3.10 довольно много новых разработок, помимо структурного матчинга шаблона. О них рассказывается в нескольких статьях, например, см. [Джеймс Бриггс](https://medium.com/u/b9d77a4ca1d1?source=post_page-----6124ff2079f0--------------------------------) [Новые возможности в Python 3.10](https://towardsdatascience.com/new-features-in-python-3-10-66ac05e62fc7).
Однако имейте в виду, что 3.10 еще только бета-версия, и хотя примеры, которые я показал выше, работают отлично, вам не следует использовать Python 3.10 со всей серьезностью до его официального релиза.
---
Приглашаем всех заинтересованных на открытое занятие «**Знакомство с веб разработкой на Flask**». На нем познакомимся с основами веб разработки на Flask, а также научимся создавать и рендерить шаблоны страниц. Попробуем создать Flask приложение, затем создать роуты и в конце обработать различные HTTP методы на Flask. Регистрирация — [**по ссылке.**](https://otus.pw/KFkG/) | https://habr.com/ru/post/664662/ | null | ru | null |
# Сaжаем на диету индексы PostgreSQL для Zabbix
 Недавно мы перевели Zabbix на работу с БД PostgreSQL. Вместе с переездом на сервер с SSD это дало существенный прирост скорости работы. Также решили проблему с дублирующими хостами в базе данных, [bug request](https://support.zabbix.com/browse/ZBX-8612). Здесь статья могла бы закончиться, но мы заметили, что Zabbix использует много дискового пространства, поэтому ниже я расскажу, как это вышло. И как мы с этим разобрались.
У нас Zabbix с относительно большой БД. Он следит почти за 1500 хостами и собирает около 180 тысяч метрик. В базе данных используем партиционирование, что облегчает очистку исторических данных. При этом для каждой партиции есть свой индекс. Ну, вы понимаете, на что я намекаю.
Да, сейчас речь пойдет про индексы. Мы выяснили, что ряд индексов разрастается почти в 2 раза, при наших объемах они занимают 5-7 Gb для каждой партиции. А при условии, что мы храним исторические данные за 10 дней и тренды за 3 месяца, суммарно получается порядка 70 Gb лишних. При общем объеме БД около 220 Gb, и использование SSD — очень ощутимо.
Подход номер один. Решали задачу в лоб и запустили полный reindex. Получилось хорошо, освободили почти 70 Gb, как и ожидалось. Недостаток: время выполнения операции. А точнее даже то, что на это время выставляется lock на таблицу, а reindex занимает около 3 часов.
Подход номер два. Посмотрели в сторону [pg\_repack](https://github.com/reorg/pg_repack). Эта утилита дает произвести vacumm full и reindex без lock на таблицы. Установили ее, настроили, запустили и приготовились ликовать. Каково же было наше разочарование, когда мы увидели, что освободилось меньше гигабайта. Открываем документацию и читаем очень внимательно, там есть пункт — дословно:
«Target table must have a PRIMARY KEY, or at least a UNIQUE total index on a NOT NULL column». Дальше открываем БД и видим, что у таблиц, которые нам нужны, ни того, ни другого нет.
Можно, конечно, было бы их добавить, но это увеличит размер БД и у разработчиков явно была причина не добавлять PRIMARY KEY. Мы поигрались и выяснили, что, например, в таблице, которая содержит информацию по мониторингу логов, могут полностью дублироваться строки. В итоге нам пришлось отказаться от pg\_repack.
Подход третий, победный. Если брать партицию за предыдущий день, то в нее уже никто не пишет, и с ней можно сделать reindex без простоя Zabbix-сервера. Придумано — проверено. Неа, оказывается, lock накладывается на всю таблицу, а не на партицию. Что ж, ну если нельзя сделать reindex, почему бы не сделать новый index, и вот тут мы наконец нащупали решение. Алгоритм простой:
1. Создаем новый индекс с конструкцией: «CREATE INDEX CONCURRENTLY», что позволяет не накладывать долгий lock на БД, поскольку в эту партицию уже никто не пишет, то индекс создается успешно.
2. Удаляем старый индекс.
3. Переименовываем новый индекс в старый.
4. Радостно бьем себя в грудь.
Теперь у нас каждую ночь запускается скрипт, который проходит по таблицам и проделывает все эти операции.
**Скрипт**
```
for i in `seq 1 10`; do
dd=`date +%Y_%m_%d -d "$i day ago"`
index_name="history_p$dd""_1"
index_name_new="history_p$dd""_1_new"
echo "$index_name"
psql -U postgres -d zabbix -c "CREATE INDEX CONCURRENTLY $index_name_new ON partitions.history_p$dd USING btree (itemid, clock); "
echo "Done CREATE"
psql -U postgres -d zabbix -c "DROP INDEX partitions.$index_name"
echo "Done DROP"
psql -U postgres -d zabbix -c "ALTER INDEX IF EXISTS partitions.$index_name_new RENAME TO $index_name"
echo "Done ALTER"
done
echo "Reindex history_uint_p Start \n"
for i in `seq 1 10`; do
dd=`date +%Y_%m_%d -d "$i day ago"`
index_name="history_uint_p$dd""_1"
index_name_new="history_uint_p$dd""_1_new"
echo "$index_name"
psql -U postgres -d zabbix -c "CREATE INDEX CONCURRENTLY $index_name_new ON partitions.history_uint_p$dd USING btree (itemid, clock); "
echo "Done CREATE"
psql -U postgres -d zabbix -c "DROP INDEX partitions.$index_name"
echo "Done DROP"
psql -U postgres -d zabbix -c "ALTER INDEX IF EXISTS partitions.$index_name_new RENAME TO $index_name"
echo "Done ALTER"
done
echo "Reindex trends_p Start \n"
for i in `seq 1 2`; do
dd=`date +%Y_%m -d "1 month ago"`
index_name="trends_p$dd""_1"
index_name_new="trends_p$dd""_1_new"
echo "$index_name"
psql -U postgres -d zabbix -c "CREATE INDEX CONCURRENTLY $index_name_new ON partitions.trends_p$dd USING btree (itemid, clock); "
echo "Done CREATE"
psql -U postgres -d zabbix -c "DROP INDEX partitions.$index_name"
echo "Done DROP"
psql -U postgres -d zabbix -c "ALTER INDEX IF EXISTS partitions.$index_name_new RENAME TO $index_name"
echo "Done ALTER"
done
echo "Reindex trends_uint_p Start \n"
for i in `seq 1 2`; do
dd=`date +%Y_%m -d "1 month ago"`
index_name="trends_uint_p$dd""_1"
index_name_new="trends_uint_p$dd""_1_new"
echo "$index_name"
psql -U postgres -d zabbix -c "CREATE INDEX CONCURRENTLY $index_name_new ON partitions.trends_uint_p$dd USING btree (itemid, clock); "
echo "Done CREATE"
psql -U postgres -d zabbix -c "DROP INDEX partitions.$index_name"
echo "Done DROP"
psql -U postgres -d zabbix -c "ALTER INDEX IF EXISTS partitions.$index_name_new RENAME TO $index_name"
echo "Done ALTER"
done
```
Прошу строго не критиковать скрипт — это черновик для наглядности статьи.
Спасибо за внимание! | https://habr.com/ru/post/310462/ | null | ru | null |
# Раз, два, три и готово! 3 месяца, 1 проект и новая команда
Привет, Хабр! Меня зовут Дмитрий Адмакин, руководитель отдела архитектурных решений и перспективной разработки одного из бизнес-центров в компании «БАРС Груп». Сегодня я расскажу о том, как мы создавали современную систему мониторинга по исполнению государственных программ, и что из этого вышло.
Небольшое введение. На тот момент наши разработчики «пилили» проекты на других технологиях, которые не подходили для реализации нового проекта. Но мы понимали, что понадобится подкрепление в части стека технологий. Открыли вакансии, продумали архитектуру и начали действовать.
Было проведено более 100 собеседований. Старались отойти от традиционных методов подбора персонала. Нам хотелось убедиться, что кандидаты обладают именно практическими навыками. Например, предлагали человеку задать себе вопросы, благодаря этому становилось понятно, как кандидат оценивает себя, и в каких темах он разбирается. Говорили про C#, ReactJS, SQL и noSQL, брокеров сообщений, контейнеризацию и т.д. Интересный опыт.
Оставляю примерный список вопросов. Если хотите, то попробуйте ответить на них. Обратная связь всегда приветствуется. На самом деле, у нас порядка 50-100 вопросов по каждой теме — все зависит от квалификации кандидата.
1. Rest vs gRPC vs GraphQL
2. C#. Сериализация, десериализация
Потоки
3. C#
```
int i = 1;
object o = i;
++i;
Console.WriteLine(i);
Console.WriteLine(o);
Console.WriteLine((short)o);
```
4. React. debounce, throttle.
5. React. package-lock.json для чего используется, что это?
6. JS. Callback, промисы, async/await.
7. SQL. truncate vs delete vs drop.
8. SQL. count(\*) vs count(name) – могут ли отличаться? И если могут, то в каких случаях?
9. Redis. Что это? Почему работает быстро? Как сделать автоудаление данных?
После «мучительных» поисков (2-3 месяца) наша команда пополнилась новыми сотрудниками, в которую вошли:
* TechLead
* FullStack-разработчики
* Frontend-разработчики
* Backend-разработчики
* Аутсорс-разработчики
А теперь о самой команде и задачах, стоящих перед ними:
* Backend-разработчики писали много шарпового кода, взаимодействовали через EF с базой данных, реализовывали сервисы межсетевого взаимодействия (СМЭВ).
* Frontend-разработчики работали над созданием компонентов — фантастических и максимально переиспользуемых.
* FullStack-разработчики помогали направить и подружить между собой frontend и backend.
* TechLead доверили не только управление командой в части технологий, но и CI/CD совместно с DevOps’ом.
* Аутсорс-разработчики занимались реализацией UI-kitа. Заказчик привык к компонентам, написанным и стилизованным на другом фреймворке, и нам пришлось провести большую работу, чтобы переписать эти компоненты на ReactJS.
Кроме того, совместно с аналитиками был изменен подход к созданию и описанию задач. Теперь в задачах необходимо разделять backend и frontend, а не ставить их в общем виде.
Немного о технологиях
---------------------
Не все любят длинные и нудные статьи, поэтому если интересен наш опыт — оставьте фидбэк, расскажем подробнее о технологиях. Здесь я очень кратко пробегусь по ним.
В работе были использованы следующие языки программирования и технологии:
* Front — React JS. Почему React? Лицензия MIT, количество специалистов на рынке, огромное число расширений для фреймворка.
* Front — язык разработки — TypeScript. Видели мемасики про JS? Будь TypeScript раньше, возможно этих мемасиков не было бы.
* Front — стилизация компонентов — Ant Design. Огромная библиотека готовых компонентов, иногда не нужно «изобретать велосипед», когда можно использовать готовое.
* Server side rendering — next.js. Тут я думаю, что вариантов особо нет, юзаем SSR.
* Взаимодействие Back и Front — GraphQL. GraphQL позволяет снижать нагрузку на БД, «гонять» меньше данных по сети, легче организовывать единую точка входа. Что еще нужно?
* Back — .NET 5 (C#). Вы спросите, почему не .NET 6? Уже он. Перешли.
* Microservices — Go. Вы видели сколько ресурсов в ждущем режиме занимают приложения на Go? Модно, быстро.
* БД — PostgreSQL. Один из стандартов для хранения данных. Как приятный бонус, существенная экономия денег.
* ORM — EntityFramework Core, Dapper. Если нам нужен контроль над запросами и скорость, то используем Dapper. Для всего остального — EF.
* NoSQL хранилище — ElasticSearch. Мы храним не только логи в ES, но и полнотекстовый поиск построен также на ES. Один из наших микросервисов «закидывает» в ES данные из БД, по которым будет создан полнотекст.
* Key-Value хранилище — Redis. Сессии, права пользователей, то есть те данные, которые нужно получать быстро и часто, мы храним в Redis.
* Брокер сообщений — Kafka. Знаю, знаю! Kafka - не классический брокер сообщений, но большинство компаний используют его именно как брокер. Мы не стали исключением.
* Контейнеризация — Docker, Kubernetes, Portainer. Стандарт в части контейнеризации. Расскажите, был ли опыт у вас в высоконагруженных системах?
* Хранилище файлов — Ceph (Amazon s3). Хранить файлы просто на сервере в файловой системе — прошлый век. Поэтому стали использовать CEPH, поднятый на инфраструктуре заказчика.
* Для сборки и выкладки — Werf. Про Werf писали на «Хабр». Кстати, нам понравилось. Также мы попробовали на тестовых проектах — «зашло». Решили идти на прод.
Архитектурная схема приложения
------------------------------
Если кратко, у нас есть некий монолит, который взаимодействует с другими системами и микросервисами через GraphQL, REST, gRPC или брокеры сообщений. Все это поднято на Kubernetes.
Про архитектуру можно также долго рассказывать, как и про выбранные технологии — спорить, холиварить. Если интересно — мы расскажем и про взаимодействие между сервисами, и про запросы во внешние системы, и про хранилища данных.
Уверен, что у вас появился вопрос, почему мы выбрали данный стек?
* Популярность.
* Быстродействие.
* Стабильность и поддержка.
* Лицензионная политика, OpenSource.
* Взаимодействие со всеми продуктами.
* Опыт внедрения в других коммерческих приложениях.
* Максимальная автоматизация процессов.
В качестве фреймворка для Frontend был выбран React.
Итог
----
Благодаря данному проекту мы вышли на новый уровень в разработке программного обеспечения.
Для всей компании мы создали UI-kit для ReactJS, благодаря чему разработка новых проектов на похожем стеке становится максимально легкой, не нужно верстать, создавать компоненты — все это у нас уже есть.
Микросервисы на Go. Совсем недавно это казалось фантастикой, так как немногие компании готовы реализовывать на довольно новом языке программирования. Но мы всегда следим за трендами. Если понимаем, что данный язык идеально подходит для решения задачи — мы его используем, так как не боимся открывать что-то новое.
Было ли нам сложно? Сложности были на начале становления проекта. Мы долго решали на чем писать front — собирались, спорили, обсуждали. Сроки были максимально сжатые, а использовать что-то неизведанное было страшно. Но я понимал, что мы найдем отличных специалистов. Спойлер! У нас получилось. Теперь мы знаем, что создать достаточно большой проект с нуля до выкладки на промышленный сервер можно за 3 месяца.
Красивый ли у нас код? Да, есть некоторые погрешности, но в каждый спринт мы закладываем время на рефакторинг. Есть ли у нас документация в коде? Очень мало, так как мы придерживаемся подхода, что код должен быть написан максимально понятно. А есть ли документация на проект? Да, ее очень много.
Если вам было интересно, то с радостью отвечу на любые вопросы и расскажу подробно про все технологии — что с чем сравнивали, почему так архитектуру строили, но это уже в другой статье. | https://habr.com/ru/post/673008/ | null | ru | null |
# Metaobject Protocol для базового Perl 5
Идея создания *Metaobject Protocol* (MOP) для Perl 5 витала достаточно давно. Хорошо известна одна из реализаций — *Class::MOP*, которая используется в *Moose*. Но попасть в базовую поставку Perl 5 может лишь такое решение, которое будет совместимо с существующей объектной моделью и не будет перегружено излишними возможностями и зависимостями. На днях *Stevan Little* опубликовал первый пробный релиз на CPAN возможного кандидата на это вакантное место — модуль [mop](https://metacpan.org/release/STEVAN/mop-0.01-TRIAL). Проект прошёл долгую эволюцию, за процессом внимательно следило сообщество. Давайте же рассмотрим, что получилось и какие последствия это может иметь для Perl 5.
#### Что такое MOP?
*Metaobject Protocol* (метаобъектный протокол) — это программный интерфейс для управления системой объектов в языке. Так же, как объект является экземпляром класса, сам класс представляется объектом (или метаобъектом) с программно задаваемыми свойствами (атрибутами, методами и т.д.). Как выразился Stevan Little, объясняя своей маме что делает Moose:
> Это абстракция для системы абстракций, используемая для создания абстракций
>
>
Имея дело с классами в базовом Perl все мы сталкивалось с простейшей реализацией MOP:
```
no strict 'refs';
*{$foo . '::bar'} = \&baz
```
Эта крипто-запись в процессе работы программы добавляет метод `bar` для класса, указанного в переменной `$foo`, который является ссылкой (алиасом) на функцию `baz`. Если кому-то знаком термин reflections, то это также является одним из его примеров. Отличие же MOP от reflections в том, что он предоставляет удобный и гибкий инструмент для разработчика для метапрограммирования классов без необходимости использования полулегальных хакерских техник. Например так:
```
class Foo {
method bar {
baz
}
}
```
#### Зачем нужен MOP в базовой поставке Perl?
Если обратиться к классической книге о MOP — «The Art of the Metaobject Protocol», которая описывала реализацию метапротокола в CLOS, одной из основных предпосылок создания протокола являлась необходимость решить проблему с многообразием реализаций объектной системы для языка Lisp, которые были несовместимы друг с другом. Метапротокол позволял строить совместимую, гибкую и расширяемую объектную систему, которая удовлетворила бы все запросы Lisp-программистов.
Простая и не обременённая зависимостями реализация MOP в базовой поставке Perl может однозначно решить вопрос с выбором объектной системы для использования при создании программ. Это завершит все религиозные войны в противостоянии ООП-фреймворков и сделает привычным подключением MOP, как `use strict`.
Реализация MOP для базового Perl должна быть лёгкой и достаточно быстрой, по этой причине тот же Moose никогда не сможет туда попасть, но у mop для этого есть все шансы.
Синтаксически красивая и логичная объектная система может вдохновить на переделку множество модулей, авторы которых не решались на использование каких-либо ООП-фреймворков в силу их тяжести или излишних зависимостей, что в свою очередь значительно улучшит читаемость кода и сократит затраты на его поддержку (единый стиль, упрощённый статический анализ кода).
Естественно это может привлечь и молодых разработчиков к Perl, поскольку простота и лаконичность очень важны при освоении языка, который претендует на звание объектно-ориентированного.
Как отмечают некоторые люди сообщества, вполне вероятно, что MOP станет важной частью будущего Perl и будет проложена чёткая граница в истории Perl: до прихода MOP в ядро и после его появления.
#### Эволюция mop
Разработке модуля mop предшествовал очень долгий путь. Stevan Little после участия в работе над объектной системой для Perl 6 в компиляторе *Pugs*, решил перенести полученные наработки в Perl 5. После нескольких попыток появился модуль Class::MOP, который стал основой для создания Moose. Moose стал очень популярен, поскольку дал разработчикам тот инструмент для работы с классами, который они так долго ожидали. Но долгое время старта программ на Moose и большое дерево зависимостей отпугивало потенциальных пользователей. Поэтому два года назад Стивен загорелся идей создания компактной системы MOP, которая могла бы войти в базовую поставку Perl. Так возник проект [p5-mop](https://github.com/stevan/p5-mop), но он оказался раздавлен весом своей собственной сложности, что несколько разочаровало Стивена и привело его к неожиданному эксперименту — проекту [Moe](https://github.com/MoeOrganization/moe), реализации компилятора Perl 5 на языке *Scala*.
Прошло некоторое время и Стивен решил, что надо всё-таки дать p5-mop второй шанс и создал проект [p5-mop-redux](https://github.com/stevan/p5-mop-redux), который не пытался объять необъятное и не ставил целью перетащить все возможности Moose, а лишь стать основой для расширяемой объектной системы в ядре Perl.
Стивен постоянно держал в курсе сообщество о прогрессе работы и публиковал статьи на блог-платформе [blogs.perl.org](http://blogs.perl.org/users/stevan_little/). 15 октября был опубликован первый пробный релиз модуля на CPAN. Сейчас у модуля два активных разработчика: *Stevan Little* и *Jesse Luehrs*, а также несколько контрибьюторов.
#### Работа с mop
##### Установка
Для установки mop можно воспользоваться cpanm:
```
$ cpanm --dev mop
```
Обратите внимание, что mop активно использует новые возможности Perl, такие как *Perl parser API*. Минимальная версия Perl, необходимая для работы модуля, — 5.16.
##### Первый пример
Рассмотрим пример кода с использованием mop:
```
use mop;
class Point {
has $!x is ro = 0;
has $!y is ro = 0;
method clear {
($!x, $!y) = (0,0);
}
}
```
Класс задаётся ключевым словом `class`. Сначала декларируется класс `Point`, в котором определяются атрибуты с помощью ключевого слова `has`. Обратите внимание, что переменные атрибутов для отличия от обычных переменных задаются с помощью *твиджила* (*twigil* или двухсимвольный *sigil*). Это практически полностью копирует синтаксис Perl 6. На данный момент поддерживаются только атрибуты с твиджилом `$!`, которые являются приватными атрибутами.
После указания твиджила следуют описания свойств (*traits*) после ключевого слова `is`. Например, `ro` означает, что атрибут доступен только на чтение. После знака равно задаётся значение атрибута по умолчанию. В классе `Point` задаётся единственный метод `clear`, который сбрасывает значения атрибутов. Видно, что переменные атрибутов `$!x`, `$!y` доступны внутри методов как лексические переменные в области видимости данного класса. Их значения замыкаются в пределах каждого экземпляра класса.
```
class Point3D extends Point {
has $!z is ro = 0;
method clear {
$self->next::method;
$!z = 0
}
}
```
Здесь определяется класс `Point3D`, который становится наследником класса Point с помощью ключевого слова `extends`. Таким образом, полученный класс перенимает все атрибуты и методы класса `Point`. В дополнении к ним в классе задаётся атрибут `$!z`. Также переопределяется метод `clear`, который, как видно из листинга, производит вызов следующего (в иерархии наследования) родительского метода `clear` из класса `Point` с помощью `next::method`. Кроме того, автоматически внутри каждого метода определяется переменная `$self`, являющейся ссылкой на текущий объект.
В случае если не указаны классы для наследования, класс по умолчанию наследуется от класса `mop::object`. Это продемонстрировано в следующем примере:
```
print Dumper mro::get_linear_isa(ref Point->new);
$VAR1 = [
'Point',
'mop::object'
];
```
Атрибуты объекта могут быть заданы при создании экземпляра класса:
```
my $point = Point->new( x => 1, y => 1);
```
Обратите внимание, что мы не задавали метода `new` для класса `Point`. Это метод унаследован из класса `mop::object`.
Для доступа к значению атрибута автоматически создаётся метод-геттер, например:
```
my $point = Point->new( x => 1, y => 1);
print $point->x
```
Будет выведено значение `1`. Поскольку атрибут объявлен как `ro`, то попытка его изменить приведёт к runtime-ошибке:
```
$point->x(2);
Cannot assign to a read-only accessor
```
Тем не менее внутри методов мы можем свободно изменять любые атрибуты, например, можно создать метод-сеттер `set_x`:
```
class Point {
has $!x is ro = 0;
...
method set_x( $x=10 ) {
$!x = $x
}
}
```
В данном примере также наглядно видно как можно задать сигнатуру метода, т.е. описать переменные аргументов, передаваемых в метод, и даже задать значения по-умолчанию, если аргумент опущен.
```
$point->set_x(5); # $!x теперь 5
$point->set_x; # $!x теперь 10
```
В то же время атрибуты находятся в области видимости только для класса Point, т.е. мы не можем напрямую оперировать с ними в классе наследнике
```
class Point3D extends Point{
...
method set_x_broken {
$!x = 10;
}
}
```
Это выдаст ошибку компиляции: `No such twigil variable $!x`
#### Роли
Роли позволяют гибко компоновать классы необходимыми методами и атрибутами, позволяя избегать множественного наследования.
```
role BlackJack {
method win;
method loose ($value) {
not $self->win($value)
}
}
```
Данная роль определяет два метода `win` и `loose`. Метод `win` не имеет тела, значит в этом случае метод должен быть обязательно определён в составе класса, который исполняет данную роль. В этом отношении роль похожа на понятие интерфейса, присутствующего в других языках программирования.
Теперь класс можно скомпоновать с данной ролью с помощью ключевого слова `with`:
```
class LunaPark with BlackJack {
method win ($value){
0
}
}
```
Класс может компоноваться из нескольких ролей, в этом случае названия ролей перечисляется через запятую.
#### Свойства и значения атрибутов
```
has $!foo is rw, lazy = 0
```
Свойства атрибутов записываются через запятую, после ключевого слова is. На данный момент поддерживаются следующие свойства:
* `ro`/`rw` — доступ только на чтение / доступ для чтения и записи
* `lazy` — создание атрибута при первом обращении к нему
* `weak_ref` — атрибут объявляется как «слабая» ссылка
При задании значения по умолчанию следует помнить, что на самом деле после знака равно идёт исполняемая конструкция, т.е. запись:
```
has $!foo = "value"
```
Означает
```
has $!foo = sub { "value" }
```
Т.е. по сути — это функция для создания значения, а не присвоения заданного выражения.
При задании значения по умолчанию можно ссылаться на текущий экземпляр объекта с помощью переменной $\_:
```
has $!foo = $_->set_foo()
```
Если требуется, чтобы при создании объекта с помощью `new` был обязательно задан определённый атрибут, в значении по умолчанию для него можно указать такой код:
```
has $!foo = die '$!foo is required';
```
Соответственно, если значение атрибута `foo` не будет задано при создании объекта, то произойдёт исключение.
Проверки типов, классов у атрибутов и методов не реализованы, чтобы не перегружать ядро mop излишней сложностью. Однако такие проверки легко могут быть выполнены в виде внешней функции:
```
sub type {
# Функция выполняющая проверку типов
...
}
class foo {
has $!bar is rw, type('Int');
method baz ($a, $b) is type('Int', 'Int') {
...
}
}
```
Рабочую реализацию функции `type` можно увидеть в [примере](https://github.com/stevan/p5-mop-redux/blob/master/t/400-traits/003-type-trait.t) для модуля mop.
#### Создание модуля
Типичный файл модуля может выглядеть так:
```
package Figures;
use strict;
use warnings;
use mop;
our $debug = 1;
sub debug {
print STDERR "@_\n" if $debug;
}
class Point {
has $!data is ro;
method draw_point {
debug("draw point")
}
method BUILD {
$!data = "some data";
}
method DEMOLISH {
undef $!data;
}
}
class Point3D extends Figures::Point {}
my $point = Figures::Point3D->new;
$point->draw_point;
```
Как видно из примера, если указан `package`, то имена классов получают соответствующий префикс. Кроме того, класс получают доступ к области видимости модуля. Это значит, что функции и переменные, определённые в области видимости модуля, также доступны для использования внутри классов. При этом такие функции не становятся методами класса. Больше никакого загрязнения пространства имён экспортированными функциями!
Специальный метод `BUILD` может использоваться в том случае, если при создании объекта требуется какая-либо инициализация. Это удобно и позволяет не переопределять метод `new`.
Метод `DEMOLISH` вызывается при уничтожении объекта, т.е. представляет собой деструктор.
#### Внутреннее строение объекта в mop
Объект создаваемый mop не является привычной многим *blessed* ссылкой на хэш. Вместо этого используются так называемые *InsideOut* объекты, где вся внутренняя структура скрыта в коде класса и доступна только через специальные методы. Существует несколько публичных методов в mop, которые позволяют проинспектировать внутреннюю структуру объекта:
* `mop::dump_object` — дамп объекта
```
print Dumper mop::dump_object( Point3D->new )
$VAR1 = {
'$!y' => 0,
'CLASS' => 'Point3D',
'$!x' => 0,
'ID' => 10804592,
'$!z' => 0,
'SELF' => bless( do{\(my $o = undef)}, 'Point3D' )
};
```
* `mop::id` — уникальный идентификатор объекта
```
print mop::id(Point3D->new)
10804592
```
* `mop::meta` — мета-интформация об объекте, для подробной интроспекции объектов
```
print Dumper mop::dump_object( mop::meta( Point3D->new ) )
$VAR1 = {
'$!name' => 'Point3D',
...
# очень длинная простыня с выводом всех свойств объекта
...
}
```
* `mop::is_mop_object` — логическая функция, возвращает истину если объект `mop::object`
```
print mop::is_mop_object( Point3D->new )
1
```
#### Практическое использование
Модуль mop на данный момент проходит активное тестирование сообществом. Основная рекомендация — возьмите любой модуль и попробуйте переписать его с использованием mop. С какими ошибками и проблемами вам придётся столкнуться? Напишите об этом, это здорово поможет в дальнейшем развитии проекта. Например, был успешно портирован модуль [Plack](https://github.com/stevan/Plack), все 1152 теста которого успешно пройдены.
Сейчас трудно сказать будет ли принят mop в состав базового дистрибутива Perl. Если будет принят, то начиная с какой версии: 5.20, 5.22 или более поздней? Это неизвестно, но общий весьма положительный фон вокруг события воодушевляет.
#### Источники
1. [«Perl 5 MOP»](https://speakerdeck.com/stevan_little/perl-5-mop) by Stevan Little
2. [«Why Perl 5 Needs a Metaobject Protocol»](http://modernperlbooks.com/mt/2012/09/why-perl-5-needs-a-metaobject-protocol.html) by chromatic
3. [«p5-mop, a gentle introduction»](http://blogs.perl.org/users/damien_dams_krotkine/2013/09/p5-mop.html) by Damien «dams» Krotkine
4. [Документация модуля mop](https://metacpan.org/module/STEVAN/mop-0.01-TRIAL/lib/mop.pm)
5. [«Mapping the MOP to Moose»](http://blogs.perl.org/users/stevan_little/2013/08/mapping-the-mop-to-moose.html) by Stevan Little
6. [«The Art of the Metaobject Protocol»](http://en.wikipedia.org/wiki/The_Art_of_the_Metaobject_Protocol) AMOP | https://habr.com/ru/post/198274/ | null | ru | null |
# Добавляем места на диске для Linux–сервера в облаке Azure Pack Infrastructure, а заодно и разбираемся с LVM
В этой статье будет рассмотрен процесс увеличения места на диске Linux–сервера в облаке [Azure Pack Infrastructure](https://infoboxcloud.ru/services/azurepack/) от [InfoboxCloud](https://infoboxcloud.ru). Это стандартная процедура, выполняемая с помощью LVM, которая есть в любом Linux–образе в нашем облаке.
Данная инструкция полезна не только для увеличения размера на едином диске, но и для создания общего пространства из подключенных виртуальных дисков, что позволяет преодолеть максимальный размер виртуального диска (для VHD – 2048 гб) и создать единое большое пространство для данных.
Если вы не хотите разбираться в этом, просто напишите нам тикет в техническую поддержку и мы сделаем все за вас.
#### **Что такое LVM?**
LVM — система управления логическими дисками в Linux, высокоуровневое представление подсистемы хранения данных на сервере (более высокоуровневое чем диски и разделы). Эта технология дает системным администраторам гибкие возможности в выделении дискового пространства для приложений и пользователей, включая возможность изменения размера логического тома.
Когда устанавливается Linux на сервер — одна из задач выбора — как разметить диск. С LVM диск включается в группу томов (volume group) и создаются логические тома например для корня диска /. В дальнейшем можно изменять размер логических томов.
#### **Устройство LVM**
Сама по себе высокоуровневая абстракция LVM включает в себя логические тома (LV) и физические тома (PV).
**Физический том (PV, physical volume)** — виртуальный диск сервера или обычный жесткий диск (или таким томом может быть RAID).
**Логический том (LV, logical volume)** — эквивалент раздела. Он представляется ОС как стандартное блочное устройство и может содержать файловую систему.
**Группа томов (VG, volume group)** — логическое объединение томов.
**Физический блок (PE, physical extent)** — кусочки данных на физическом томе, в рамках группы томов имеют идентичный размер **логическому блоку (LE, logical extent)**, размер которого в свою очередь постоянный в рамках группы томов.
*Вид представления LVM с физическими и логическими томами.*
*Вид представления LVM с физическими и логическими блоками, которое одинаково для всей группы томов.*
Пример: Давайте представим, что у нас есть группа томов VG1 и у нее размер физического блока 4 Мб. Внутри группы томов 2 жестких диска /dev/hda1 и /dev/hdb1. Эти диски станут физическими разделами PV1 и PV2. Так как физический размер блока 4 мб — такого же размера будут и логические блоки. Диски имеют различный размер и первый включает в себя 99 блоков, а второй 248 блоков. Теперь мы создадим логический том. Он может быть любого размера между 1 и 347 блоками (248+99 блоков). Когда логический том создается устанавливается связь между логическими и физическими блоками, например логический блок 1 может быть связан с физическим блоком 51 из PV1, а данные записанные в первые 4 мегабайта логического тома фактически будут записаны в 51й блок PV1.
Есть 2 вида связи между физическими и логическими блоками:
* **линейный маппинг** — когда множество физических блоков последовательно будут связаны со множеством логических блоков, например LE1-99 будут связаны с PV1, а LE 100–347 связаны с PV2.
* **маппинг с чередованием** — когда каждый следующий логический блок будет использовать следующий диск, что в физических системах может увеличить производительность, но в облаке не имеет смысла, так как виртуальные диски создаются в СХД, которая уже использует множество дисков параллельно для увеличения производительности на аппаратном уровне.
##### **Снепшоты LVM**
Снепшоты LVM позволяют администратору создать новое блочное устройство, сохраняющее копию логического тома, замороженную на определенный момент времени. Эта возможность может быть использована для пакетной обработки данных, создания бекапов или экспериментов, когда вы не хотите задеть живые данные на системе.
В LVM2, используемой в современных версиях Linux, снепшоты доступны для чтения и записи по-умолчанию. При создании снепшота создается таблица исключений, которая используется для сохранения информации, какой блок был изменен. Если блок изменяется на томе-источнике, откуда создан снепшот, он сначала копируется в снепшот, помечается как скопированный в таблице исключений, затем новые данные записываются на оригинальный том. Если данные записываются на снепшот — блок маркируется в таблице исключений как использованный и никогда не копируется с тома-источника.
#### **Увеличиваем раздел Linux-сервера**
##### **Создание сервера для тестирования**
Если у вас еще нет доступа к Azure Pack Infrastructure, заполните заявку на получение бесплатной пробной версии на главной странице <https://infoboxcloud.ru>.
Создайте сеть с доступом в интернет, сервер с Linux (например с Ubuntu 16.04) и пробросьте его порт 22 на внешний ip, как показано в [этой статье](https://infoboxcloud.ru/community/blog/azurepack/397.html). Подключитесь к серверу [по SSH](https://infoboxcloud.ru/community/blog/linuxvps/304.html).
На всех серверах с Linux в Azure Pack Infrastructure уже предустановлен LVM.
##### **Создание контрольной точки**
Перед увеличением объема диска создание контрольной точки крайне рекомендуется. Если что-нибудь пойдет не так вы сможете восстановить сервер на это состояние. Если в вашей подписке недостаточно места, напишите нам тикет в [панели управления услугами](https://support.infobox.ru) > Центр поддержки > Написать тикет.
Нажмите на имя вашего сервера и перейдите в раздел «Контрольные точки».
Нажмите кнопку «Создать» для создания контрольной точки.
Задайте имя контрольной точки и если необходимо — описание и нажмите галочку «Готово». Контрольная точка будет создана. Теперь вы можете производить дальнейшие операции безопасно.
##### **Увеличиваем раздел диска в панели управления Azure Pack Infrastructure**
Войдите в [панель управления](https://portal.infoboxcloud.com), выберите ваш сервер, на котором требуется увеличить раздел и нажмите кнопку «Остановить». Дождитесь остановки сервера.
Теперь кликните по имени сервера и перейдите в раздел «Настроить». Кликните по имени диска, который требуется увеличить.
Появится кнопка «Развернуть» — нажмите ее.
Укажите желаемый размер диска (доступно только увеличение) и нажмите галочку «Готово». Размер виртуального диска будет увеличен. Однако этого не достаточно — необходимо увеличить LV-раздел на виртуальной машине, об этом читайте далее.
##### **Создаем новый физический раздел на диске (PV)**
Для начала на появившемся свободном месте нужно создать новый физический раздел (PV), который далее можно подключить к LVM. Для этого можно воспользоваться командой:
```
cfdisk
```
Выберите свободное место на диске (Free Space, отмечено зеленым цветом) с помощью стрелочек на клавиатуре и затем нажмите Enter, что запустит команду **New**.
Будет запрошен размер создаваемого раздела. По-умолчанию — максимальный, на все добавленное место, просто нажмите Enter.
Теперь стрелочками на клавиатуре при отмеченном новом разделе выберите пункт **Type**.
Нажмите Enter для выбора типа раздела.
Выберите тип **8e Linux LVM** и нажмите Enter.
Теперь выберите пункт Write и нажмите Enter для того, чтобы изменения были записаны на диск.
Будет запрошено разрешение на применение изменений. Введите **yes** и нажмите Enter.
Будет выведено сообщение о том, что таблица разделов изменена успешно.
Запомните путь Device, в данном случае это **/dev/sda3**. Путь к устройству потребуется в дальнейшем при добавлении раздела в группу томов (VG).
Для выхода из программы разметки диска выберите пункт **Quit** и нажмите Enter.
Перезагрузите сервер командой:
```
reboot
```
и подключитесь к нему по SSH вновь.
##### **Добавляем созданный физический раздел в группу томов (VG)**
Для того, чтобы узнать имя созданной группы томов, воспользуйтесь командой:
```
vgdisplay
```
где в параметре VG name будет указано имя группы томов, в данном случае — **ubuntu-vg**.
Для добавления физического раздела к группе томов воспользуйтесь командой:
```
vgextend ubuntu-vg /dev/sda3
```
, где ubuntu-vg – имя группы томов, а /dev/sda3 – путь к устройству — новому разделу.
Используя команду:
```
pvdisplay
```
вы можете увидеть список дисков подключенных к группе томов.
##### **Увеличиваем размер логического раздела LVM root и файловой системы раздела до максимально доступного**
Используя команду
```
lvdisplay
```
можете увидеть список логических разделов LVM.
Видим, что создано 2 раздела: /dev/ubuntu-vg/swap\_1 и **/dev/ubuntu-vg/root**. Используя команду:
```
vgdisplay
```
Видим параметры группы томов.
Видим, что теперь доступно свободное место для расширения томов LVM (Free PE / Size) в размере 75 гб.
Нам необходимо увеличить раздел **/dev/ubuntu-vg/root** до максимально доступного, a заодно и увеличить размер файловой системы.
Для этого выполните команду:
```
lvextend -r -l +100%FREE /dev/ubuntu-vg/root
```
Теперь выполните команду:
```
df -h
```
для того, чтобы увидеть новый размер системного раздела.
**Мы успешно добавили места на диске для Linux–сервера в облаке Azure Pack Infrastructure, а заодно и научились использовать LVM.**
Если у вас возникли любые вопросы по использованию Azure Pack Infrastructure — с радостью поможем и проконсультируем! Вы можете написать нам через личный кабинет <https://support.infobox.ru> > Центр поддержки > Написать тикет.
Если вы не можете оставлять комментарии на Хабре, напишите нам в [Сообществе InfoboxCloud](https://infoboxcloud.ru/community/blog/azurepack/395.html).
Успешной работы! | https://habr.com/ru/post/313356/ | null | ru | null |
# Как я изобретал велосипед, или мой первый MEAN-проект
Сегодня, в период стремительного развития веб-технологий, опытному фронтэнд-разработчику нужно всегда оставаться в тренде, каждый день углубляя свои познания. А что делать, если Вы только начинаете свой путь в мире веб? Вы уже переболели вёрсткой и на этом не хотите останавливаться. Вас тянет в загадочный мир JavaScript! Если это про Вас, надеюсь данная статья придётся к стати.
Имея за плечами полуторагодовой опыт работы в качестве фронтэнд-разработчика, я, утомившись монотонной вёрсткой очередного рядового проекта, задался целью углубить познания в сфере веб-программирования. У меня возникло желание создать своё первое single page application. Выбор стека технологий был очевиден, так как я всегда был не равнодушен к Node.js, методология MEAN стала тем, что доктор прописал.
Сегодня в интернете существует бесчисленное количество разных туториалов, в которых создают множество приложений helloworld, todo, management agency и т.д. Но просто бездумно следовать шагам туториала — не мой выбор. Я же решил создать некое подобие мессенджера: приложение с возможностью регистрации новых пользователей, созданием диалогов между ними, общения с chat-ботом для тестовых пользователей. И так, тщательно продумав план действий, я приступил к работе.
Далее мой рассказ опишет основные моменты создания данного приложения, а для большей наглядности [демо я оставлю тут](https://chappie-messenger.herokuapp.com/) ([ссылка на github](https://github.com/AndreyKrupskii/chappie-messenger)).
*\*Также хочу отметить, что цель данной статьи, быть может, помочь обучающимся не наступить на грабли, на которые в своё время наступил я, и дать возможность более опытным разработчикам просмотреть код и высказать своё мнение в комментариях.*
Составим план действий:
1. Подготовительные работы
2. Создание системы авторизации
3. Чат на Angular2 и Socket.io
### Подготовительные работы
Подготовка рабочего места — это неотъемлемый процесс любой разработки, а качественное выполнение данной задачи — залог успеха в дальнейшем. Первым делом, нужно установить Express и настроить единую систему конфигурирования нашего проекта. Если с первым и так всё понятно, то на втором я остановлюсь по подробнее.
И так, воспользуемся замечательным модулем **nconf**. Давайте создадим папку с названием config, а в её индексный файл запишем:
```
const nconf = require('nconf');
const path = require('path');
nconf.argv()
.env()
.file({ file: path.join(__dirname, './config.json') });
module.exports = nconf;
```
Далее в этой папке создадим файл с названием config.json и внесём в него первую настройку — порт, который слушает наше приложение:
```
{
"port": 2016
}
```
Чтоб внедрить данную настройку в приложение, нужно всего ничего, написать одну/две строки кода:
```
const config = require('./config');
let port = process.env.PORT || config.get('port');
app.set('port', port);
```
Но стоит отметить, это будет работать в случае, если порт будет задан таким образом:
```
const server = http.createServer(app);
server.listen(app.get('port'));
```
Следующая наша задача — настроить единую систему логгирования в нашем приложении. Как писал автор статьи ["О логгировании в Node.js"](https://habrahabr.ru/post/209436/):
> Писать в логи надо и много, и мало. Настолько мало, чтобы понять в каком состоянии приложение сейчас, и настолько много, чтобы, если приложение рухнуло, понять почему.
Для этой задачи воспользуемся модулем **winston**:
```
const winston = require('winston');
const env = process.env.NODE_ENV;
function getLogger(module) {
let path = module.filename.split('\\').slice(-2).join('/');
return new winston.Logger({
transports: [
new winston.transports.Console({
level: env == 'development' ? 'debug' : 'error',
showLevel: true,
colorize: true,
label: path
})
]
});
}
module.exports = getLogger;
```
Конечно, настройка может быть и более гибкой, но на данном этапе нам этого будет достаточно. Чтоб воспользоваться нашим новоиспечённым логгером, нужно всего-ничего подключить данный модуль в ваш рабочий файл и вызвать его в нужном месте:
```
const log = require('./libs/log')(module);
log.info('Have a nice day =)');
```
Следующей нашей задачей станет настройка правильной обработки ошибок при обычных и ajax запросах. Для этого мы внесём некие изменения в код, который заранее был сгенерирован Express (в примере указан только development error handler):
```
// development error handler
if (app.get('env') === 'development') {
app.use(function(err, req, res, next) {
res.status(err.status || 500);
if(res.req.headers['x-requested-with'] == 'XMLHttpRequest'){
res.json(err);
} else{
// will print stacktrace
res.render('error', {
message: err.message,
error: err
});
}
});
}
```
Мы практически закончили с подготовительными работами, осталась одна маленькая, но отнюдь не маловажная деталь: настроить работу с базой данных. Первым делом настроим подключение к MongoDB с помощью модуля **mongoose**:
```
const mongoose = require('mongoose');
const config = require('../config');
mongoose.connect(config.get('mongoose:uri'), config.get('mongoose:options'));
module.exports = mongoose;
```
В *mongoose.connect* мы передаём два аргумента: *uri* и *options*, которые я заранее прописал в конфиге (подробнее о них можно прочесть в [документации к модулю](http://mongoosejs.com/docs/connections.html)).
Процесс создания моделей пользователей и диалогов я описывать не буду, так как схожий процесс отлично описал автор веб-ресурса [learn.javascript.ru](https://learn.javascript.ru) в своём скринкасте по Node.js в видеоуроке "[Создаём модель для пользователя / Основы Mongoose](https://www.youtube.com/watch?v=E9V1zTGKRfY&list=PLDyvV36pndZFWfEQpNixIHVvp191Hb3Gg&index=35)", лишь упомяну, что каждый пользователь будет иметь такие свойства, как username, hashedPassword, salt, dialogs и created. Свойство dialogs, в свою очередь, будет возвращать объект: ключ — id собеседника, значение — id диалога.
Если кому-то всё-таки интересно взглянуть на код данных моделей:
**users.js**
```
const mongoose = require('../libs/mongoose');
const Schema = mongoose.Schema;
const crypto = require('crypto');
let userSchema = new Schema({
username: {
type: String,
unique: true,
required: true
},
hashedPassword: {
type: String,
required: true
},
salt: {
type: String,
required: true
},
dialogs: {
type: Schema.Types.Mixed,
default: {defaulteDialog: 1}
},
created: {
type: Date,
default: Date.now
}
});
userSchema.methods.encryptPassword = function(password){
return crypto.createHmac('sha1', this.salt).update(password).digest('hex');
};
userSchema.methods.checkPassword = function(password){
return this.encryptPassword(password) === this.hashedPassword;
}
userSchema.virtual('password')
.set(function(password){
this._plainPassword = password;
this.salt = Math.random() + '';
this.hashedPassword = this.encryptPassword(password);
})
.get(function(){
return this._plainPassword;
});
module.exports = mongoose.model('User', userSchema);
```
**dialogs.js**
```
const mongoose = require('../libs/mongoose');
const Schema = mongoose.Schema;
let dialogSchema = new Schema({
data: {
type: [],
required: true
}
})
module.exports = mongoose.model('Dialog', dialogSchema);
```
Осталось всего-ничего — прикрутить сессии к костяку нашего приложения. Для этого создадим файл session.js и подключим в него такие модули, как **express-session**, **connect-mongo**, и созданный нами модуль из файла **mongoose.js**:
```
const mongoose = require('./mongoose');
const session = require('express-session');
const MongoStore = require('connect-mongo')(session);
module.exports = session({
secret: 'My secret key!',
resave: false,
saveUninitialized: true,
cookie:{
maxAge: null,
httpOnly: true,
path: '/'
},
store: new MongoStore({mongooseConnection: mongoose.connection})
})
```
Выносить данную настройку в отдельный файл важно, но не обязательно. Это предоставит возможность в дальнейшем без особого труда помирить сессии и веб-соккеты между собой. Теперь подключим данный модуль в app.js:
```
const session = require('./libs/session');
app.use(session);
```
При чём, *app.use(session)* обязательно нужно указать после *app.use(cookieParser())*, чтобы cookie уже успели быть прочитанными. Всё! Теперь мы имеем возможность сохранять сессии в нашу базу данных.
И на этом подготовительные работы — окончены. Пора приступать к самому интересному!
### Создание системы авторизации
Создание системы авторизации будет делиться на два основных этапа: фронтэнд и бэкэнд. Так как, затеивая данное приложение, я собирался всё время учить что-то новое, а с Angular1.x я уже имел опыт работы, фронтэнд часть решил организовывать на Angular2. Тот факт, что, когда я создавал приложение, уже была выпущена четвёртая (а сейчас пятая) предрелизная версия данного фреймворка, вселил во мне уверенность, что оф-релиз уже не за горами. И так, собравшись с мыслями, я сел за написание авторизации.
Для ребят, которые ещё не сталкивались с разработкой на Angular2, прошу не удивляться, если в коде ниже вы встретите не известный вам ранее синтаксис javascript. Всё дело в том, что весь Angular2 построен на typescript. И нет, это вовсе не означает, что работать с данным фреймворком используя обычный javascript нельзя! Вот к примеру отличная [статья](https://medium.com/angular-2-with-es6/angular-2-with-es6-the-5-minute-quickstart-a9e4eb0bffcc#.xqhkpannx), в ходе которой автор рассматривает разработку на Angular2 с использованием ES6.
Но typescript — это javascript, который масштабируется. Являясь компилируемым надмножеством javascript, этот язык добавляет в него все фичи из ES6 & ES7, настоящее ООП с блэк-джеком и классами, строгую типизацию и ещё много крутейших штук. И пугаться здесь нечего: ведь всё, что валидно в javascript, будет работать и в typescript!
Первым делом создадим файл user-authenticate.service.ts, в нём будет находиться сервис авторизации:
```
import { Injectable } from '@angular/core';
import { Http, Headers } from '@angular/http';
@Injectable()
export class UserAuthenticateService{
private authenticated = false;
constructor(private http: Http) {}
}
```
Далее внутри нашего класса создадим несколько методов: login, logout, singup, isLoggedIn. Все эти методы однотипны: каждый выполняет свою задачу по отправке запроса типа post на соответствующий адрес. Не сложно догадаться, какую логическую нагрузку несёт каждый из них. Рассмотрим код метода login:
```
login(username, password) {
let self = this;
let headers = new Headers();
headers.append('Content-Type', 'application/json');
return this.http
.post( 'authentication/login', JSON.stringify({ username, password }), { headers })
.map(function(res){
let answer = res.json();
self.authenticated = answer.authenticated;
return answer;
});
}
```
Чтоб вызвать данный метод из компонента Angular2, нужно внедрить данный сервис в соответствующий компонент:
```
import { UserAuthenticateService } from '../services/user-authenticate.service';
@Component({ ... })
export class SingInComponent{
constructor(private userAuthenticateService: UserAuthenticateService, private router: Router){ ... }
onSubmit() {
let self = this;
let username = this.form.name.value;
let password = this.form.password.value;
this.userAuthenticateService
.login(username, password)
.subscribe(function(result) {
self.onSubmitResult(result);
});
}
}
```
Стоит отметить: для получения доступа к одному и тому же экземпляру сервиса из разных компонентов, его нужно внедрять в общий родительский компонент.
И на этом мы оканчиваем фронтэнд этап создания системы авторизации.
Приступая к бэкэнд разработке, рекомендую вам ознакомиться с интересным модулем **async** ([документация к модулю](http://caolan.github.io/async/)). Он станет мощным инструментом в вашем арсенале для работы с асинхронными функциями javascript.
Давайте создадим файл authentication.js в уже существующей директории routes. Теперь укажем данный middleware в app.js:
```
const authentication = require('./routes/authentication');
app.use('/authentication', authentication);
```
Далее просто создадим обработчик для запроса пост на адрес authentication/login. Чтоб не писать длинную простыню из различных if...else воспользуемся методом waterfall из вышеупомянутого модуля **async**. Данный метод позволяет выполнять коллекцию асинхронных задач по-порядку, передавая результаты предидущей задачи в аргументы следующей, а на выходе выполнить какой-нибудь полезный колбек. Давайте сейчас и напишем данный колбек:
```
const express = require('express');
const router = express.Router();
const User = require('../models/users');
const Response = require('../models/response');
const async = require('async');
const log = require('../libs/log')(module);
router.post('/login', function (req, res, next) {
async.waterfall([ ... ], function(err, results){
let authResponse = new Response(req.session.authenticated, {}, err);
res.json(authResponse);
})
}
```
Для собственного удобства я заранее подготовил конструктор Response:
```
const Response = function (authenticated, data, authError) {
this.authenticated = authenticated;
this.data = data;
this.authError = authError;
}
module.exports = Response;
```
Нам осталось только записать функции в нужном нам порядке в массив, переданный первым аргументом в async.waterfall. Давайте создадим эти самые функции:
```
function findUser(callback){
User.findOne({username: req.body.username}, function (err, user) {
if(err) return next(err);
(user) ? callback(null, user) : callback('username');
}
}
function checkPassword(user, callback){
(user.checkPassword(req.body.password)) ? callback(null, user) : callback('password');
}
function saveInSession (user, callback){
req.session.authenticated = true;
req.session.userId = user.id;
callback(null);
}
```
Вкратце опишу, что здесь происходит: мы ищем пользователя в базе данных, если такового здесь нет, вызываем колбек с ошибкой 'username', в случае удачного поиска передаём пользователя в колбек; вызываем метод checkPassword, опять же, если пароль верный, передаём пользователя в колбек, в противном случае вызываем колбек с ошибкой 'password'; далее сохраняем сессию в базу данных и вызываем завершающий колбек.
Вот и всё! Теперь пользователи нашего приложения имеют возможность авторизации.
### Чат на Angular2 и Socket.io
Мы подошли к написанию функции, несущей в себе основную смысловую нагрузку нашего приложения. В данном разделе мы организуем алгоритм подключения к диалогам (chat-rooms) и функцию отправки/получения сообщений. Для этого мы воспользуемся библиотекой **Socket.io**, которая позволяет очень просто реализовать обмен данными между браузером и сервером в реальном времени.
Создадим файл sockets.js и подключим данный модуль в bin/www (входной файл Express):
```
const io = require('../sockets/sockets')(server);
```
Так как **Socket.io** работает с протоколом web-sockets, нам необходимо придумать способ передать ей сессию текущего пользователя. Для этого в уже созданный нами файл sockets.js запишем:
```
const session = require('../libs/session');
module.exports = (function(server) {
const io = require('socket.io').listen(server);
io.use(function(socket, next) {
session(socket.handshake, {}, next);
});
return io;
});
```
**Socket.io** построена таким образом, что браузер и сервер всё время обмениваются различными событиями: браузер генерирует события, на которые реагирует сервер, и на оборот, сервер генерирует события, на которые реагирует браузер. Давайте напишем обработчики событий на стороне клиента:
```
import { Component } from '@angular/core';
import { Router } from '@angular/router';
declare let io: any;
@Component({ ... })
export class ChatFieldComponent {
socket: any;
constructor(private router: Router, private userDataService: UserDataService){
this.socket = io.connect();
this.socket.on('connect', () => this.joinDialog());
this.socket.on('joined to dialog', (data) => this.getDialog(data));
this.socket.on('message', (data) => this.getMessage(data));
}
}
```
В коде выше мы создали три обработчика событий: connect, joined to dialog, message. Каждый из них вызывает соответствующую ему функцию. Так, событие connect вызывает функцию joinDialog(), которая в свою очередь генерирует серверное событие join dialog, с которым передаёт id собеседника.
```
joinDialog(){
this.socket.emit('join dialog', this.userDataService.currentOpponent._id);
}
```
Далее всё просто: событие joined to dialog получает массив с сообщениями пользователей, событие message добавляет новые сообщения в выше упомянутый массив.
```
getDialog(data) => this.dialog = data;
getMessage(data) => this.dialog.push(data);
```
Чтоб в дальнейшем уже не возвращаться к фронтэнду, давайте создадим функцию, которая будет отправлять сообщения пользователя:
```
sendMessage($event){
$event.preventDefault();
if (this.messageInputQuery !== ''){
this.socket.emit('message', this.messageInputQuery);
}
this.messageInputQuery = '';
}
```
Данная функция генерирует событие message, с которым и передаёт текст отправленного сообщения.
Дело осталось за малым — написать обработчики событий на стороне сервера!
```
io.on('connection', function(socket){
let currentDialog, currentOpponent;
socket.on('join dialog', function (data) { ... });
socket.on('message', function(data){ ... });
})
```
В переменные currentDialog и currentOpponent мы будем сохранять идентификаторы текущего диалога и собеседника.
Приступим к написанию алгоритма подключения к диалогу. Для этого воспользуемся библиотекой **async**, а именно вышеупомянутым методом watterfall. Очерёдность наших действий:
**Покинуть предидущий диалог:**
```
function leaveRooms(callback){
// Проходим циклом по всем комнатам и покидаем их
for(let room in socket.rooms){
socket.leave(room)
}
// Переходим к выполнению следующей задачи
callback(null);
}
```
**Получить из базы данных пользователя и его собеседника:**
```
function findCurrentUsers(callback) {
// Параллельно выполняем коллекцию асинхронных задач:
// - поиск текущего пользователя
// - поиск текущего собеседника
async.parallel([findCurrentUser, findCurrentOpponent], function(err, results){
if (err) callback(err);
// Передаём пользователей в колбэк, переходим к выполнению следующей задачи
callback(null, results[0], results[1]);
})
}
```
**Подключиться к существующему/создать новый диалог:**
```
function getDialogId(user, opponent, callback){
// Проверяем существование диалога между вышеупомянутыми пользователями
if (user.dialogs[currentOpponent]) {
let dialogId = user.dialogs[currentOpponent];
// Передаём в колбек Id диалога, переходим к выполнению следующей задачи
callback(null, dialogId);
} else{
// Последовательно выполняем коллекцию задач:
// - создание диалога
// - сохранение ссылки на него пользователям
async.waterfall([createDialog, saveDialogIdToUser], function(err, dialogId){
if (err) callback(err);
// Передаём в колбек Id диалога, переходим к выполнению следующей задачи
callback(null, dialogId);
})
}
}
```
**Получить историю сообщений:**
```
function getDialogData(dialogId, callback){
// Выполняем поиск диалога в базе данных
Dialog.findById(dialogId, function(err, dialog){
if (err) callback('Error in connecting to dialog');
// Передаём в колбек диалог, переходим к выполнению глобального колбэка
callback(null, dialog);
})
}
```
**Вызов вышеупомянутых функций, глобальный колбек:**
```
// Последовательно выполняем коллекцию задач
async.waterfall([
leaveRooms,
findCurrentUsers,
getDialogId,
getDialogData
],
// Глобальный колбэк
function(err, dialog){
if (err) log.error(err);
currentDialog = dialog;
// Подключаемся к данной комнате
socket.join(currentDialog.id);
// Генерируем событие joined to dialog, с которым передаём историю сообщений пользователей
io.sockets.connected[socket.id].emit('joined to dialog', currentDialog.data);
}
)
```
На этом алгорим подключения к диалогу закончен, осталось всего ничего написать обработчик для события message:
```
socket.on('message', function(data){
let message = data;
let currentUser = socket.handshake.session.userId;
let newMessage = new Message(message, currentUser);
currentDialog.data.push(newMessage);
currentDialog.markModified('data');
currentDialog.save(function(err){
if (err) log.error('Error in saveing dialog =(');
io.to(currentDialog.id).emit('message', newMessage);
})
})
```
В данном примере кода мы сохранили в переменные текст сообщения и идентификатор пользователя, затем с помощью заранее созданного конструктора Message создали объект нового сообщения, добавили его в массив и, сохранив обновлённый диалог в базу данных, сгенерировали событие message в данной комнате, с которым и передали сообщение.
Вот и всё наше приложение готово!
### Вывод
Хех, вы всё-таки дочитали?! Не смотря на объёмы статьи, я не успел обозреть все детали создания приложения, так как мои возможности ограничены данным форматом. Но выполняя данную работу я не только значительно углубил свои познания в сфере веб-программирования, но и получил море удовольствия от выполненной работы. Ребят, никогда не бойтесь браться за что-то новое, сложное, ведь, если тщательно подойти к делу, постепенно разбираясь с всплывающими вопросами, даже с нулевым опытом на старте, можно создать что-то действительно хорошее! | https://habr.com/ru/post/307896/ | null | ru | null |
# Зачем нам jQuery?
Здравствуйте, дамы и господа! Вот уже без малого десять лет минуло с первого релиза библиотеки jQuery, и мы решили отряхнуть пыль веков с классики. Подумываем о выпуске третьего издания гусарской баллады об этой библиотеке:
Чтобы пояснить, чем она нас привлекает в эпоху Node и ES6 (у нас в ассортименте и этого [добра](http://www.piter.com/collection/new/product/veb-razrabotka-s-primeneniem-node-i-express-polnotsennoe-ispolzovanie-steka-javascript) [навалом](http://www.piter.com/collection/new/product/es6-i-ne-tolko)) предлагаем познакомиться со статьей Коди Линдли, вышедшей вскоре после вышеупомянутого третьего издания
Поскольку [давно](https://www.sitepoint.com/do-you-really-need-jquery/) не [утихают](http://lea.verou.me/2015/04/jquery-considered-harmful/) [разговоры](http://blog.garstasio.com/you-dont-need-jquery/) о ненужности jQuery, я буквально не могу избавиться от мысли, что мы забыли основную ценность jQuery. Время о ней напомнить.
В этой статье хотелось бы всем еще раз рассказать, что же такое jQuery, поскольку сегодня она не менее актуальна, чем на момент появления. Вопрос о ее важности нужно соотнести с исходным назначением всего этого решения (то есть, самого API jQuery), а не с браузерными багами или недостающими возможностями. Если исходить из чего-то другого, то мы рискуем встать на позиции, с которых бракуется любая абстракция, которая может быть не *абсолютно необходимой*, но, все-таки, мощной и полезной.
Прежде чем я начну пылко отстаивать честь jQuery, давайте вернемся к ее истокам, чтобы всем стало понятно, «что» такое jQuery, и «зачем» она нужна.
### Что такое jQuery?
[jQuery](https://en.wikipedia.org/wiki/JQuery) – это библиотека [JavaScript](https://en.wikipedia.org/wiki/JavaScript) (т.e., она написана на JavaScript), предназначенная для абстрагирования, выравнивания, исправления и упрощения скриптинга при работе с узлами HTML-элементов в браузере или для работы в [браузере без графического интерфейса](https://en.wikipedia.org/wiki/Headless_browser).
Итак:
* Абстрагируется интерфейс [объектной модели документа](https://www.w3.org/TR/dom/) (он же DOM API).
* Выравниваются все различия [реализаций](https://www.w3.org/TR/DOM-Level-3-Core/) DOM, существующие между браузерами.
* Исправляются известные [браузерные баги](https://docs.google.com/document/d/1LPaPA30bLUB_publLIMF0RlhdnPx_ePXm7oW02iiT6o/edit), связанные с CSS и DOM.
Все это оборачивается в более простой и менее корявый API, нежели нативный API DOM – вот вам и библиотека jQuery.
Теперь позвольте объяснить, что я понимаю под “скриптингом HTML-элементов”. При помощи jQuery совершенно тривиально решаются задачи вроде «визуально скрыть второй элемент `h2` в документе .html. Код jQuery для такой задачи выглядел бы так:
```
jQuery('h2:eq(1)').hide();
```
Давайте немного разберем эту строку с кодом jQuery. Сначала вызывается функция `jQuery()`, ей мы передаем [специальный](https://api.jquery.com/category/selectors/jquery-selector-extensions/) [CSS-селектор](https://www.w3.org/TR/CSS21/selector.html%23id-selectors) библиотеки jQuery, выбирающий второй элемент `h2` в HTML-документе. Затем вызывается метод jQuery`.hide()`, скрывающий элемент `h2`. Вот как прост и семантически выразителен код jQuery.
Теперь сравним его с нативным DOM-кодом, который потребовалось бы написать, если бы мы не работали с jQuery.
```
document.querySelectorAll('h2')[1].style.setProperty('display','none');
```
Какой вариант было бы удобнее написать? А читать, а отлаживать? Также учтите, что вышеприведенный нативный DOM-код предполагает, что все браузеры поддерживают использованные здесь методы DOM. Однако оказывается, что некоторые старые браузеры не поддерживают `querySelectorAll()` или `setProperty()`. Поэтому вышеприведенный код jQuery вполне нормально работал бы в IE8, а нативный код DOM вызвал бы ошибку JavaScript. Но, все-таки, даже если бы обе строки кода работали повсюду, какую из них было бы проще читать и писать?
Имея дело с jQuery, можно не беспокоиться о том, какой браузер что поддерживает, либо какой DOM API в каком браузере может забарахлить. Работая с jQuery, вы сможете работать быстрее решать задачи на более простом коде, и при этом не беспокоиться, так как jQuery абстрагирует за вас многие проблемы.
### jQuery = JavaScript?
Поскольку jQuery повсеместно распространена, то вы, возможно, не вполне представляете, где заканчивается JavaScript и начинается jQuery. Для многих веб-дизайнеров и начинающих разработчиков HTML/CSS, библиотека jQuery — это первый контакт с языком программирования JavaScript. Поэтому jQuery иногда путают с JavaScript.
Первым делом давайте оговоримся, что JavaScript – это не jQuery и даже не сам DOM API. jQuery – это сторонняя [свободная](https://github.com/jquery/jquery) библиотека, написанная на JavaScript и поддерживаемая целым сообществом разработчиков. Кроме того, jQuery не относится к числу стандартов тех организаций (напр., W3C), которые пишут спецификации HTML, CSS или DOM.
Не забывайте, что jQuery служит прежде всего как «сахар» и используется поверх DOM API. Этот сахар помогает работать с интерфейсом DOM, который печально известен своей сложностью и обилием багов.
jQuery – это просто полезная библиотека, которой можно пользоваться при написании сценариев для HTML-элементов. На практике большинство разработчиков прибегают к ней при DOM-скриптинге, поскольку ее API позволяет решить больше задач меньшим количеством кода.
Библиотека jQuery и ее плагины используются разработчиками так широко, что такой код часто нахваливают как самые востребованные сценарии во всем Вебе.
### Два краеугольных камня jQuery
Две базовые концепции, на которых основана jQuery, таковы: “найди и сделай” и “пиши меньше, делай больше.”
Две этих концепции можно развернуть и переформулировать в виде следующего утверждения: первоочередная задача jQuery заключается в организации выбора (то есть, нахождении) или в [создании HTML-элементов](http://api.jquery.com/jquery/#jQuery2) для решения практических задач. Без jQuery для этого потребовалось бы больше кода и больше сноровки в обращении с DOM. Достаточно вспомнить рассмотренный выше пример с сокрытием элемента `h2`.
Следует отметить, что круг возможностей jQuery этим не ограничивается. Она не просто абстрагирует нативные DOM-взаимодействия, но и [абстрагирует](https://api.jquery.com/jQuery.ajax/) асинхронные HTTP-запросы (т.н. [AJAX](http://api.jquery.com/jquery.ajax/)) при помощи объекта [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest). Кроме того, в ней есть еще [ряд вспомогательных решений на JavaScript и мелких инструментов](https://api.jquery.com/category/utilities/). Но основная польза jQuery заключается именно в упрощении HTML-скриптинга и просто в том, что с ней приятно работать.
Еще добавлю, что польза jQuery – не в успешном устранении браузерных багов. «Краеугольные камни» нисколько не связаны с этими аспектами jQuery. В долгосрочном отношении самая сильная сторона jQuery заключается в том, что ее API абстрагирует DOM. И эта ценность никуда не денется.
### Как jQuery сочетается с современной веб-разработкой
Библиотеке jQuery уже десять лет. Она создавалась для той эпохи веб-разработки, которую мы уже безусловно миновали. jQuery не является незаменимой технологией для работы с DOM или выполнения асинхронных HTTP-запросов. ***Практически все, что можно сделать с jQuery, можно сделать и без нее***. А если вас интересует всего лишь пара мелких простых взаимодействий с DOM в одном-двух современных браузерах, то возможно, [лучше будет воспользоваться нативными DOM-методами, а не jQuery](http://youmightnotneedjquery.com/).
Однако, при любых разработках, связанных с BOM ([браузерной моделью документа](http://www.webbrowsercompatibility.com/bom/desktop/)) или DOM, а не только с косметическими взаимодействиями, следует пользоваться jQuery. В противном случае вы станете изобретать велосипед (т.e. элементы абстракций jQuery), а потом испытывать его на всевозможных дорожках (т.e в мобильных браузерах и браузерах для ПК).
Опытные разработчики знают, что такое «стоять на плечах гигантов», и когда следует избегать излишней сложности. В большинстве случаев нам все равно не обойтись без jQuery, когда нужно в сжатые сроки выполнить нетривиальную работу, связанную с HTML и DOM.
Кроме того, даже если бы jQuery не решала ни единой проблемы с DOM или с разношерстными браузерными реализациями спецификации DOM, важность самого API ничуть бы не уменьшилась, поскольку он так удобен для HTML-скриптинга.
Причем jQuery совершенствуется, и с ее помощью программисты могут работать толковее и быстрее. Такова ситуация сегодня, так было и на момент создания библиотеки. Сказать «мне не нужна jQuery» — все равно, что утверждать «обойдусь без lo-dash или underscore.js». Разумеется, можно без них обойтись. Но об их ценности судят не по этому.
Их ценность — в API. Из-за излишней сложности разработка может замедляться. Поэтому нам и нравятся такие вещи как lo-dash и jQuery – с ними все упрощается. А поскольку jQuery облегчает выполнение сложных задач (например, писать сценарии для HTML), она не устареет.
Если вы по-прежнему сомневаетесь, нужна ли jQuery в современной веб-разработке, предлагаю посмотреть следующую [презентацию](https://youtu.be/OBLvBcGgVQc) от одного из разработчиков библиотеки, где он обосновывает ее нужность безотносительно наворотов [современных браузеров](http://outdatedbrowser.com/en).
### Приложение – важные факты об jQuery
Наконец, перечислю некоторые важные факты, касающиеся jQuery.
* Библиотеку jQuery написал Джон Резиг (John Resig), ее релиз состоялся 26 августа 2006. Джон признавался, что написал этот код, чтобы “произвести революцию во взаимодействии JavaScript с HTML”.
* jQuery считается наиболее популярной и востребованной современной библиотекой JavaScript.
* jQuery – свободное ПО, предоставляемое по [лицензии MIT](https://tldrlegal.com/license/mit-license).
* Существует две версии jQuery. Версия 1.x поддерживает Internet Explorer 6, 7 и 8\, а 2.x поддерживает только IE9+. Если вам требуется поддержка IE8, то придется работать с версией 1.x. **Но это нормально, обе версии по-прежнему активно разрабатываются**.
* [Минимальная версия jQuery 2.x имеет размер 82kb. В архиве Gzip — около 28k](https://mathiasbynens.be/demo/jquery-size).
* [Минимальная версия jQuery 1.x имеет размер 96kb. В архиве Gzip — около 32k.](https://mathiasbynens.be/demo/jquery-size)
* [Исходный код jQuery](https://github.com/jquery/jquery#how-to-build-your-own-jquery) доступен на Github.
* На основе исходного кода с Github можно создать [собственную](https://github.com/jquery/jquery#how-to-build-your-own-jquery) версию jQuery.
* jQuery можно установить при помощи менеджера пакетов [bower](https://bower.io/) или [npm](https://www.npmjs.com/package/jquery) (т.e. `$ bower install jquery or npm install jquery`).
* У jQuery есть официальная сеть [CDN](http://code.jquery.com/jquery/), в которой можно взять различные версии jQuery.
* jQuery имеет простую архитектуру на основе плагинов, поэтому любой желающий может добавлять в нее собственные методы.
* jQuery обладает обширным набором плагинов. Можно приобрести высококачественные плагины для enterprise-разработки (напр. Kendo UI) или воспользоваться не менее классными бесплатными (напр. Bootstrap).
* jQuery можно разбить на категории (в соответствии с [разбиением](http://api.jquery.com/) документации API ).
* ajax
* attributes
* callbacks object
* core
* CSS
* data
* deferred object
* dimensions
* effects
* events
* forms
* internals
* manipulation
* miscellaneous
* offset
* properties
* selectors
* traversing
* utilities | https://habr.com/ru/post/308134/ | null | ru | null |
# События C# по-человечески
Невозможно, просто взять и вникнуть в этот глубокий смысл, изучая События (event) в просторах базового и, на первый взгляд, бесконечного C#.
Когда я изучал События (не в рамках .NET!), потратил много сил, чтобы, наконец-то, разобраться, как они устроены и должны конструироваться. Поэтому, я решил опубликовать свою методику понимания структуры **пользовательского события**, коим представляется ключевое слово **event** в С#.
Не буду цитировать и без того замученную [MSDN](http://msdn.microsoft.com), а постараюсь объяснить понятно и доступно.
Что требуется Вам для изучения:
* 1. Вы не должны испытывать страх перед изучением. Пожалуйста, читайте медленно и вдумчиво.
* 2. Вы должны понимать классы и методы.
* 3. Вы должны ~~знать~~ понимать, что есть делегаты. Хотя, Вы можете попытаться понять их в ходе чтения статьи.
*Событие*, это не что иное, как ситуация, при возникновении которой, произойдет действие или несколько действий. Говоря языком программного моделирования, *Событие* — это именованный делегат, при вызове которого, будут запущены все подписавшиеся на момент вызова события методы заданной сигнатуры. Эта трактовка хоть и раскрывает всю суть структуры события, но не только сбивает с толку начинающих «шарп-прогеров», но и не дает возможность рационально представить в программистской голове весь смысл.
Итак, *Событие*, это ситуация, при возникновении которой, произойдут некоторые действия. Само событие имеет определенную структуру.
Предположим, что стоит такая задача: определено три класса. Первый класс будет считать до 100, используя цикл. Два других класса будут ждать, когда в первом классе счетчик досчитает, например, до 71, и после этого каждый выведет в консоль фразу «Пора действовать, ведь уже 71!». Проще говоря, при обнаружении значения 71, вызовутся по методу, соответственно для каждого класса. Разложим все по полкам.
##### 1. Моделирование ситуации.
Подготовим эти три простейших класса, оставив точку входа в программу **main** нетронутой.
Класс **ClassCounter** и его метод *Count()* в котором будет производится счет. (В коде я опускаю пространства имен *namespace*, ибо это ясно, как день).
```
class ClassCounter //Это класс - в котором производится счет.
{
public void Count()
{
//Здесь будет производиться счет
}
}
```
Два других класса (имена им **Handler\_I** и **Handler\_II**), которые должны реагировать на возникновение события методами public void *Message()*. У каждого по методу, как и договаривались.
```
class Handler_I //Это класс, реагирующий на событие (счет равен 71) записью строки в консоли.
{
public void Message()
{
//Не забудьте using System
//для вывода в консольном приложении
Console.WriteLine("Пора действовать, ведь уже 71!");
}
}
```
```
class Handler_II
{
public void Message()
{
Console.WriteLine("Точно, уже 71!");
}
}
```
Напомню, когда счетчик будет считать до 100 и достигнет 71, должны сработать методы Message() для классов Handler\_I и Handler\_II.
Теперь вернемся к классу ClassCounter и создадим счетчик при помощи цикла **for** c переменной-счетчиком **int i**.
```
class ClassCounter //Это класс - в котором производится счет.
{
public void Count()
{
for (int i = 0; i < 100; i++)
{
}
}
}
```
Первый этап завершен. У нас есть класс счетчик и два класса, которые будут выводить сообщения. Условия задачи: как только **i=71**, должны сработать методы *Message()* для двух классов **Handler\_I** и **Handler\_II**.
##### 2. Оформление события.
Абстрагируемся от программирования. Событие, которое мы хотим создать, будет представлять фразу "… счетчик считает. И как только он будет равен 71, должны выполниться действия". Значит, нам необходимо условие «как только он будет равен 71». Представим его при помощи **условного оператора if**.
```
class ClassCounter //Это класс - в котором производится счет.
{
public void Count()
{
for (int i = 0; i < 100; i++)
{
if (i == 71)
{
}
}
}
}
```
Конструируем событие **event**. Определяем по методам, которые должны сработать при i=71 их **сигнатуру** (или прототип).
**Сигнатура метода** — это так называемая спецификация (или простыми словами «шаблон») какого-л. метода или методов. Представляет собой сочетание названия типа, который метод возвращает, плюс название типов входящих параметров (по порядку! порядок очень важен.)
Например, метод *int NewMethod(int x, char y)* будет иметь сигнатуру **int (int, char)**, а метод *void NewMethod()* — **void (void)**.
[Как толкует MSDN](http://http://msdn.microsoft.com/ru-ru/library/awbftdfh.aspx), события (event) основаны на [делегатах](http://msdn.microsoft.com/ru-ru/library/ms173171.aspx) (delegate), а делегат, говоря очень простым языком — «переменная, хранящая ссылку на метод». Как Вы уже поняли, т.к. наше событие будет ссылаться на два метода void Message(), мы должны определить сигнатуру этих методов, и составить на основе этой сигнатуры делегат. Сигнатура выглядит так: **void (void)**.
Определяем делегат (назовем его MethodContainer):
```
class ClassCounter //Это класс - в котором производится счет.
{
//Синтаксис по сигнатуре метода, на который мы создаем делегат:
//delegate <выходной тип> ИмяДелегата(<тип входных параметров>);
//Мы создаем на void Message(). Он должен запуститься, когда условие выполнится.
public delegate void MethodContainer();
public void Count()
{
for (int i = 0; i < 100; i++)
{
if (i == 71)
{
}
}
}
}
```
Далее, мы создаем событие при помощи ключевого слова **event** и связываем его с этим делегатом (**MethodContainer**), а, следовательно, c методами, имеющими сигнатуру *void (void)*. Событие должно быть public, т.к. его должны использовать разные классы, которым нужно как-то отреагировать (классы Handler\_I и Handler\_II).
Событие имеет синтаксис: public event <НазваниеДелегата> <НазваниеСобытия>;
Название делегата — это имя делегата, на который «ссылаются» наши методы.
```
class ClassCounter //Это класс - в котором производится счет.
{
public delegate void MethodContainer();
//Событие OnCount c типом делегата MethodContainer.
public event MethodContainer onCount;
public void Count()
{
for (int i = 0; i < 100; i++)
{
if (i == 71)
{
}
}
}
}
```
Теперь запустим наше событие onCount, в условии когда i=71:
```
if (i == 71)
{
onCount();
}
```
Все. **Событие создано**. Методы, которые вызовет это событие, определены по сигнатурам и на основе их создан делегат. Событие, в свою очередь, создано на основе делегата. Пора показать событию *onCount*, какие же все-таки методы должны сработать (мы ведь указали только их сигнатуру).
##### 3. Подписка.
Вернемся в точку входа программы main и создадим экземпляр класса **ClassCounter**. А также создадим по экземпляру классов, которые должны запуститься. (Они должны быть *public*).
```
class Program
{
static void Main(string[] args)
{
ClassCounter Counter = new ClassCounter();
Handler_I Handler1 = new Handler_I();
Handler_II Handler2 = new Handler_II();
}
}
```
Теперь укажем событию *onCount*, методы, которые должны запуститься.
Происходит это следующим образом: **<КлассИлиОбъект>.<ИмяСобытия> += <КлассЧейМетодДолженЗапуститься>.<МетодПодходящийПоСигнатуре>**.
Никаких скобочек после метода! Мы же не вызываем его, а просто указываем его название.
```
class Program
{
static void Main(string[] args)
{
ClassCounter Counter = new ClassCounter();
Handler_I Handler1 = new Handler_I();
Handler_II Handler2 = new Handler_II();
//Подписались на событие
Counter.onCount += Handler1.Message;
Counter.onCount += Handler2.Message;
}
}
```
##### Проверка.
Теперь осталось запустить счетчик класса *ClassCounter* и подождать, пока i станет равным 71. Как только i=71, запустится событие *onCount* по делегату *MethodContainer*, который (в свою очередь) запустит методы *Message()*, которые были *подписаны* на событие.
```
class Program
{
static void Main(string[] args)
{
ClassCounter Counter = new ClassCounter();
Handler_I Handler1 = new Handler_I();
Handler_II Handler2 = new Handler_II();
Counter.onCount += Handler1.Message;
Counter.onCount += Handler2.Message;
//Запустили счетчик
Counter.Count();
}
}
```
Результат:
Пора действовать, ведь уже 71!
Точно, уже 71!
##### Заключение.
Постарайтесь понять смысл и порядок создания события.
* 1. Определите условие возникновения события и методы которые должны сработать.
* 2. Определите сигнатуру этих методов и создайте делегат на основе этой сигнатуры.
* 3. Создайте общедоступное событие на основе этого делегата и вызовите, когда условие сработает.
* 4. Обязательно (где-угодно) подпишитесь на это событие теми методами, которые должны сработать и сигнатуры которых подходят к делегату.
Класс, в котором вы создаете событие (генерируете) называется классом-издателем, а классы, чьи методы подписываются на это событие при помощи **"+="** — классами-подписчиками.
**Запомните!** Если Вы не подписались на событие и его делегат пустой, возникнет ошибка.
Чтобы избежать этого, необходимо подписаться, или не вызывать событие вообще, как показано на примере (Т.к. событие — делегат, то его отсутствие является «нулевой ссылкой» **null**).
```
if (i == 71)
{
if (onCount != null)
{
onCount();
}
}
```
Вы всегда можете отписаться, используя оператор "**-=**": <КлассИлиОбъект>.<ИмяСобытия> -= <КлассЧейМетодДолженЗапуститься>.<МетодПодходящийПоСигнатуре>.
Преимущество Событий очевидно: *классу-издателю, генерирующему событие* не нужно знать, сколько *классов-подписчиков подпишется* или отпишется. Он создал событие для определенных методов, ограничив их делегатом по определенной сигнатуре.
События широко используются для составления собственных компонентов управления (кнопок, панелей, и т.д.).
У самых маленьких может возникнуть вопрос: что делать, если методы, которые должны сработать имеют входящий параметр (а то и не один!)?
Ответ: Все дело в делегате, на котором базируется событие. А точнее сигнатура подходящих для делегата методов. Когда Вы сконструируете делегат, «принимающий» метод с параметром, то (!) при запуске событие запросит этот параметр. Естественно, параметр может быть чем угодно.
Пару слов о .NET-событиях. Microsoft упростила задачу конструирования делегатов: .NET предлагает готовый делегат **EventHandler** и т.н. «пакет» входных параметров **EventArgs**. Желаете событие? Берете готовый EventHandler, определяетесь в параметрах, «запихиваете» их в *класс*, а класс наследуете от EventArgs. А дальше — как по расписанию)
Многие разработчики утверждают (и я с ними согласен), что главная проблема «недопонимания» событий — их специфическая область применения, а вследствие — мало доступных примеров. Ну и не забывайте о практике.
P.S. Если вы не ни разу не использовали делегаты, лучше попробуйте потренироваться на делегатах, а затем попытайтесь понять эту статью.
Я надеюсь, что внес небольшое понимание в эту непростую тему. Успехов! | https://habr.com/ru/post/213809/ | null | ru | null |
# Mocking RESP API in 20 minutes via Yakbak
Imagine this: you are an ordinary frontend developer. When you open your mailbox you found a message — tomorrow DevOps team will make an optimization with Kubernetes. You are experienced developer and you know that environment operation test might go sideways. Test environment is crucial for your job as frontend developer and you don’t want to miss a whole day on a job, so there are two possible solutions present:
1. Setup all microservices on your laptop
2. Prepare mocks for API
I will describe how to mock REST API request via Yakbak.
Demo Application
----------------
In order to demonstrate the mocking process for application I created the application that take a name of Lord of the Ring character and check Github’s user with this login and Github’s commits, that have this name.
* I generated Angular application via Anglular-cli;
* The list of characters I found on the [the-one-api.dev](https://the-one-api.dev/);
* I will launch user search and commits following instructions from [Github docs](https://docs.github.com/en/rest/guides/getting-started-with-the-rest-api).
The application's logic is very simple. User select a character and application call GitHub REST API. We will display response via beautiful RPG UI.
If you want to see application itself, please click [here](https://gurov.github.io/lotr_github/).
Mocking API requests
--------------------
Developer runs `yarn start` and application starts at `localhost:4200`. Browser sends API requests to the local proxy that starts on the same address. Obviously I can send requests directly to Github and the proxy needed only for demonstration.
Proxy config:
```
const PROXY_CONFIG = {
context: [
"/users",
"/search"
],
"target": "https://api.github.com/",
// "target": "http://localhost:3111",
"changeOrigin": true,
"secure": true
}
module.exports = PROXY_CONFIG;
```
This picture describes how application works without Yakbak cache:
And this is how application will work with Yakbak cache
I used [Yakbak](https://www.npmjs.com/package/yakbak) library for the preparing the cache layer. Here is how this library work:
1. Library get a request and calculates a hash of them;
2. Library checks if a file with that hash is in a specific directory;
3. If file does not exist Yakbak sends request to target server and received response writen to a file. Afterwards it responds to original request;
4. If the file exists then Yakbak reads the file and responds to the original request.
For use this solution you need to switch `target` in the proxy config from `https://api.github.com/` to `http://localhost:3111` and run `node yakbak-conf.js record`. After that all new responses to the Github will be recorded to the `tapes/` folder. But if you will run command `node yakbak-conf.js` (without the `record` word) Yakbak will only respond with files already written and will not send new requests to Github.
If you will use this solution for a while you will realize that it's better to use readable file names and not necessary put all query parameters to hash. That is a reason I selected the following hash format: `${req.url}__${req.method}__${queryHash}`. In addition, it is always convenient to open recorded file and correct something there as you see fit.
The list of cached files:
```
...
__search__commits__GET__eyJxIjoic2F1cm9uIn0=.js
__search__commits__GET__eyJxIjoidGFudGEifQ==.js
__search__commits__GET__eyJxIjoiZnJvciJ9.js
__users__adaldrida__GET__e30=.js
__users__adalgar__GET__e30=.js
__users__adalgrim__GET__e30=.js
__users__adamanta__GET__e30=.js
...
```
**What's inside each file?**
```
var path = require("path");
/**
* GET /users/adalgar
*
* cookie: Webstorm-7f35e0f0=5cbe6ea7-fbdc-4756-42-b67baf0b74c4; AIOHTTP_SESSION="gAAAAABh4C__bz3aTNe_Podsmatrivay_kq3iCaA=="
* accept-language: ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7
* accept-encoding: gzip, deflate, br
* referer: http://localhost:4200/
* sec-fetch-dest: empty
* sec-fetch-mode: cors
* sec-fetch-site: same-origin
* sec-ch-ua-platform: "Linux"
* user-agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36
* sec-ch-ua-mobile: ?0
* accept: application/vnd.github+json
* sec-ch-ua: "Chromium";v="106", "Google Chrome";v="106", "Not;A=Brand";v="99"
* cache-control: no-cache
* pragma: no-cache
* connection: close
* host: api.github.com
*/
module.exports = function (req, res) {
res.statusCode = 200;
res.setHeader("server", "GitHub.com");
res.setHeader("date", "Wed, 16 Nov 2022 21:26:23 GMT");
res.setHeader("content-type", "application/json; charset=utf-8");
res.setHeader("cache-control", "public, max-age=60, s-maxage=60");
res.setHeader("vary", "Accept, Accept-Encoding, Accept, X-Requested-With");
res.setHeader("etag", "W/\"07c85ce555cf40c22d222e0bfaccc7cccf5528d40312724324341b02e19ba0\"");
res.setHeader("last-modified", "Sat, 06 Apr 2019 16:00:30 GMT");
res.setHeader("x-github-media-type", "github.v3; format=json");
res.setHeader("access-control-expose-headers", "ETag, Link, Location, Retry-After, X-GitHub-OTP, X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Used, X-RateLimit-Resource, X-RateLimit-Reset, X-OAuth-Scopes, X-Accepted-OAuth-Scopes, X-Poll-Interval, X-GitHub-Media-Type, X-GitHub-SSO, X-GitHub-Request-Id, Deprecation, Sunset");
res.setHeader("access-control-allow-origin", "*");
res.setHeader("strict-transport-security", "max-age=31536000; includeSubdomains; preload");
res.setHeader("x-frame-options", "deny");
res.setHeader("x-content-type-options", "nosniff");
res.setHeader("x-xss-protection", "0");
res.setHeader("referrer-policy", "origin-when-cross-origin, strict-origin-when-cross-origin");
res.setHeader("content-security-policy", "default-src 'none'");
res.setHeader("content-encoding", "gzip");
res.setHeader("x-ratelimit-limit", "60");
res.setHeader("x-ratelimit-remaining", "44");
res.setHeader("x-ratelimit-reset", "1668635372");
res.setHeader("x-ratelimit-resource", "core");
res.setHeader("x-ratelimit-used", "16");
res.setHeader("accept-ranges", "bytes");
res.setHeader("content-length", "452");
res.setHeader("x-github-request-id", "7200:EE5F:2342344:207742:111157F");
res.setHeader("connection", "close");
res.setHeader("x-yakbak-tape", path.basename(__filename, ".js"));
res.write(new Buffer("H4sIAAAAAAAAA52TQYvbMBCF7/kVwefuyukmWWIopdDrLgTaUnoJsqy1VWRJSGOHxOx/70jjTRMfWrwn48e8T29GmmGxXGba1spkxTL7UnFdc599", "base64"));
res.write(new Buffer("iKqqUFrvHtabx8ddUoyt5CHJ2dPX/fbHz2ctfu83T+f96vksNmTjPQfuD53Xsa4BcKFgjNRwXytourIL0gtrQBq4F7ZlHXs753P/aU2c2o8kOpDEKdWpkUgYxAZ200QDrZ5moQzJcVP7YrW2R0RMDfwfx7CLixLSrzL1OyDoGpiFRuL4sJXXcRAqwLxIdXQMLH7wukZMwFvxspoVa/RgqKPBPAPz0tk3XlcG4ZUDZc28eOHaST1aX3Ojznw+DJ2BGDHbvCDJQWbZ41uc5ybLwJxXPRencSxeCql6nPM7iBMvJYOTk3GTvuOLICUokAdetWlnX7gOkraTt7HQdFqnf3zfjpvTtVTipkcWcbQVaeDXFbLlKi7uhdIoL3mpb8ilstclcFQA45s1kxCuK7USB5p0scxTslFMzxRBJP7do1sFl+JSIzAL4Gw5xC4+5qvdXb6+y7ffVtsiz4uH/Bd11rnqf3WL18UfF7Fg8fwEAAA=", "base64"));
res.end();
return __filename;
};
```
Below is the full Yakbak config, it is quite short and transparent.
```
const express = require('express');
const yakbak = require('yakbak');
const {pick, omit} = require('ramda');
const record = process.argv.includes('record') || false;
const base64 = (s) => Buffer.from(s).toString('base64');
const getUrlName = (req) => req.url.replace(/\//gi, '__').split('?')[0];
const getQueryHash = (req, queryParams) => base64(JSON.stringify(omit(queryParams, req.query)));
const omittedParameters = [
'start',
'end'
];
const yak = yakbak('https://github/', {
dirname: __dirname + '/tapes',
noRecord: !record,
hash: (req, body) => {
const name = getUrlName(req);
const queryHash = getQueryHash(req, omittedParameters);
return `${name}__${req.method}__${queryHash}`;
}
});
express().use(function (req, res, next) {
yak(req, res);
}).listen(3111);
```
That's actually all. All project sources can be found on my Github [here](https://github.com/gurov/lotr_github).
P.S. I can say that once I used Yakbak to speed up E2E tests for the frontend part — obviously — those tests were not quite E2E afterwards :) | https://habr.com/ru/post/700848/ | null | en | null |
# Как работать с иерархической структурой классов
Задача классификации — одна из самых известных в машинном обучении. Очень многие проблемы, решаемые с помощью ML, так или иначе сводятся к классификации — распознавание изображений, например. И все выглядит просто и понятно, когда нам нужно определить объект в один из нескольких классов. А что если у нас не плоская структура из нескольких классов, а сложная разветвленная иерархия на 683 категории? Именно о таком случае мы сегодня и поговорим. Под катом — рассказ о том, зачем в задачах классификации нужны сложные иерархии и как с ними жить.
В любой задаче классификации есть набор классов и есть модель, которая умеет предсказывать класс для новых данных. Допустим, модель бинарной классификации *Спам/не спам*, модель классификации настроения текста *Хорошо/нейтрально/плохо*. Классы обычно являются абстракцией реальности, а абстракция — это всегда упрощение.
Однако реальность может быть гораздо сложнее, ведь имеется некоторая структура, взаимосвязи между классами. Одна из часто встречаемых в жизни структур это дерево иерархии. Существует множество вещей, которые можно классифицировать по одному принципу, но на разных уровнях абстракции или обобщения. Например, известная со школы классификация животных. На первом уровне это могут быть Млекопитающие и Рептилии, на втором — Дельфины и Ящерицы. Определенный объект можно отнести к одному из классов на каждом уровне, причем все объекты, относящиеся к некоторому классу, также относятся и к родителю этого класса.
Это звучит понятно в школьном учебнике, но в контексте машинного обучения возникает множество вопросов:
* Как с этим всем обращаться?
* Какие классы предсказывать?
* Сколько моделей тренировать для решения задачи?
* Как работать с данными?
* Как вносить изменения в иерархию классов и как реагировать на эти изменения с точки зрения модели?
Все эти проблемы мы разберем на примере задачи классификации, которую мы решаем в Контуре.
### Постановка задачи
Мы работаем с чеками. В каждом чеке может встретиться много разных товаров, которые можно сгруппировать множеством разных способов. На данный момент нам интересно группировать эти товары с помощью дерева категорий, которое мы будем называть **KPC** (Khajiit Product Classification). Это здоровенное дерево, состоящее из 683 категорий.
Для этих категорий у нас есть **Golden Set**, наш размеченный набор данных (штрихкод — категория KPC) для обучения. В датасете почти три миллиона записей и мы постоянно работаем над его дополнением и улучшением разметки.
Именно в этом суть проблемы. Представьте — три миллиона записей, 683 класса. Иерархия очень непостоянная — одни классы добавляются, другие удаляются, а третьи обрастают дочерними категориями. Поддерживать все это в порядке очень непросто.
Давайте разберемся, как выглядят разные этапы классификации с иерархической структурой классов.
### Разметка данных
Как уже упоминалось выше, вся эта огромная структура классов очень волатильна. Классы обновляются, удаляются, разрастаются в сложное дерево или превращаются в свалку из трудноопределяемых в другие категории товаров. Из-за этих постоянных изменений появилась необходимость обрабатывать разные категории по-разному.
Так появились статусы категорий. Они помогают понять, в каком состоянии категория прямо сейчас. Благодаря статусам мы можем отдельно обрабатывать только что появившиеся категории или категории, которые скоро будут удалены. На текущий момент мы выделяем четыре статуса категорий:
* Активный.
* Запланированный — категория, на которую мы хотим классифицировать, но пока не можем (не хватает данных или не почистили разметку).
* Архивный — категория, которую решено было удалить, но товары из категории еще не переразметили.
* Удаленный.
В зависимости от статуса мы решаем, что делать с конкретной категорией на каждом из этапов классификации.
Также стоит упомянуть две отдельные группы категорий:
* «свалка» (например «Одежда (свалка)») — группа для логического удаления некоторых товаров, которые невозможно категоризировать. Например, у нас есть товар «Полное тестирование Тест 2 10шт», у которого из какого-то источника данных стоит категория Одежда. Наш аналитик данных понимает, что по факту категории у такого товара нет, поэтому такой товар отправляется в свалку, которая при обучении не рассматривается.
* «другое/другие» (например «Молочные товары, сыры и яйцо (другое)») — группа для товаров, которые относятся к родительской категории, но не относятся (возможно, пока) ни к одной из дочерних.
А теперь давайте разберемся, как выглядит собственно обновление нашего датасета. Мы можем добавлять категории, удалять, а также разбивать уже существующие категории на несколько новых.
#### Добавление категории
Добавить категорию мы можем в любое время, но для того, чтобы товары начали в неё попадать, необходимо:
* Добавить категорию в KPC.
* Переразметить обучающую выборку в соответствии с новой категорией (если товары новой категории раньше относились к другой категории — проверить, что теперь они относятся к правильной).
* Переобучить модель, чтобы она научилась классифицировать товары в новую категорию.
#### Удаление категории
Как можно догадаться по статусам, удаление категорий в нашем случае исключительно логическое. Мы меняем статус категории сначала на архивный, а затем на удаленный.
Для удаления категории необходимо:
* Перевести категорию в статус Архивная.
* Решить, что мы делаем с товарами, которые относились к удаляемой и дочерним категориям.
* Заменить удаляемую категорию у товаров в Golden Set.
* Указать дочерним категориям новую родительскую категорию или её отсутствие (если дочерняя категория должна стать категорией верхнего уровня).
* Переобучить модель, чтобы она перестала классифицировать товары в удаляемую категорию (и начала классифицировать эти товары в новые категории).
* Перевести категорию в статус Удаленная.
#### Разбиение категории
Если появляется необходимость разбить одну категорию на несколько новых, нужно:
* Обновить категории в Golden Set, чтобы отнести товары к новым категориям.
* Переобучить модель, чтобы она научилась классифицировать товары в новые категории.
Суммируя написанное выше, основные изменения при разметке — это необходимость учитывать родительские и дочерние классы. Например, при удалении мы должны смотреть, чтобы у всех дочерних категорий нашлись новые родительские.
### Обучение модели
На этапе обучения все сводится к обучению одного простого классификатора и иерархичность структуры, на первый взгляд, не добавляет никаких проблем. Однако перед обучением мы должны привести наши классы в порядок, чтобы в обучающей выборке не встречались одновременно дочерние и родительские классы (например, родительская категория *Молочные продукты, яйца и сыры* и дочерняя категория *Яйца*).
Такие коллизии плохо влияют на обучение — товар может одновременно оказаться в обеих категориях и это может смутить нашу модель. Чтобы избежать таких случаев, перед обучением добавлен этап разрешения конфликтов дерева категорий (KPC collisions resolving).
Вспоминая о введенных ранее категориях хочется упомянуть, что в контексте резолвинга архивные категории обрабатываются также, как и активные, а удаленные не обрабатываются вовсе.
#### Алгоритм разрешения конфликтов
Для начала разберемся с тем, что такое конфликт или коллизия. **Коллизией** мы считаем ситуацию, когда пара категорий ребенок/родитель одновременно представлена в KPC. То есть часть товаров размечена родительской категорией, часть — дочерней. Как уже упоминалось выше, такие ситуации плохо влияют на обучение.
Для разрешения этих ситуаций мы будем **маппить** категории (то есть переносить все товары из одной категории в другую), а после **обновлять** наше дерево категорий (оставлять в рассмотрении только те категории, которые представлены в Golden set), проверяя, остались ли коллизии.
Теперь важно понять желаемый конечный результат. Выписать несколько возможных ситуаций из дерева категорий и понять, как мы хотим эти ситуации решать. Понять, какие категории в какую смаппятся, а какие категории в итоге останутся и будут учтены классификатором.
Например, на какой-то итерации работы с алгоритмом мы разбирали вот такую ситуацию. Желаемый результат разрешения конфликта здесь не очевиден и требует продуманного аналитического ответа. При некоторых очевидных решениях этот случай может быть упущен, что впоследствии приведет к неожиданному результату вроде потери категорий.
Future/Active на схеме — это статусы категорий Запланированная/Активная, а present/NOT present in GS — представлена ли категория в Golden set.
Еще один вопрос, который важно разобрать — что мы хотим делать с Запланированными категориями? И что мы хотим делать с их детьми?
Есть несколько вариантов. Мы можем:
* Использовать эти категории в классификации.
* Не классифицировать и выбросить категории из GS.
* Переразмечать эти категории в категорию-родителя.
* Переразмечать эти товары в категорию «другое/другие» (например «*Молочные продукты, сыры и яйцо (другое)»*)
После разбора таких случаев, ответов на архитектурные вопросы и итеративной разработки мы пришли к следующему алгоритму.
1. Убрать удаленные, редко встречающиеся (меньше 10 товаров в golden set) и те категории, у которых в названии есть «свалка».
2. Если все дети категории в статусе «Запланированный», то дочерние категории маппятся в родителя. Это происходит итеративно, так как после первого маппинга может возникнуть аналогичная ситуация на другом уровне дерева.
3. Смаппить запланированные категории в sibling-категорию с «другое/другие» в названии, если такая есть.
4. Удалить из Golden Set категории, у которых есть категории-потомки с товарами в Golden Set. Здесь происходит то самое разрешение конфликтов.
На каждом этапе мы рассматриваем уже обновленное дерево категорий. Важность этого пункта вытекла из разбора неочевидных ситуаций. Например, если не обновлять дерево (не убирать категории без товаров в GS и без потомков с товарами), то правило *Смаппить всех Запланированных детей к родителю* может не сработать из-за пустого, но активного ребенка.
### Валидация модели
На этапе валидации возникает еще один важный вопрос. Как сравнивать разные версии модели, если они обучались на разных наборах классов и разных наборах данных? Какие категории нуждаются в развитии? Как оценить проделанную работу по обогащению, чистке или уточнению категории?
**В первую очередь** мы сравниваем базовые метрики — accuracy (по всем классам) и accuracy/coverage. Необходимо следить за тем, чтобы баланс покрытия и точности не нарушался, а также за возможностью подобрать threshold для новой модели, при котором этот баланс соответствует нашим требованиям.
**Во вторую очередь** будем смотреть на метрики отдельно по каждому классу. Сначала на те, с которыми модель непосредственно знакома. Затем на родительские классы, путем агрегации (взвешенное среднее).
Таким образом, мы сможем сравнить качество по любому классу, даже если новая модель уже его не классифицирует, а, например, классифицирует его детей.
**В третью очередь** мы строим confusion matrix для всех категорий, чтобы понять между какими классами больше всего путается модель. Эти классы помогают задавать направление для дальнейшего развития.
`'errors' - sum of errors of confusing two labels,
'label_1_confuse' - count(true=label_1, pred=label_2) / 'errors',
'label_2_confuse' - count(true=label_2, pred=label_1) / 'errors',
'fraction_of_error_to_label_1' - count(true=label_1, pred=label_2) / total_label_1,
'fraction_of_error_to_label_2' - count(true=label_2, pred=label_1) / total_label_2,
'fraction_of_all_errors' - 'errors' / total_errors,
'fraction_of_all_errors_cumulative'`
### Выводы
1. Для удобной итеративной работы с деревом категорий полезно ввести статусы категорий. Такие статусы позволят обрабатывать категории в разном состоянии разными способами.
2. При валидации стоит агрегировать метрики для родительских категорий, чтобы иметь возможность сравнить две модели с разными наборами классов.
3. Важно следить, чтобы в обучающей выборке не смешивались сэмплы из родительского и из дочернего классов. Также важно продумать желаемый результат разрешения таких конфликтов в разных конфигурациях дерева, статусов и состояния разметки категорий. | https://habr.com/ru/post/553618/ | null | ru | null |
# Canon i-SENSYS LBP6020 в CentOS 6 или никогда не пишите в тех. поддержку
Приветствую дорогие хабражители и хабрагости.
После долгого копания по форумам и решения так и не решённой с их помощью проблемы, решил поделиться рецептом.
Заранее приношу извинения за графоманию, конкретика будет, но не сразу.
*Немного предыстории. У моего старого друга на складе жил и работал МФУ Canon. Вполне справлялся с задачей, но по сроку службы уже начал хандрить — то бумагу не может затянуть, то ещё что-то. Замена сработавшихся деталей стала приближаться к стоимости нового устройства, и было решено купить что-то новое. Не успев особо посоветоваться со мной, товарищ купил себе Canon LBP6020 — на коробке красовалась отметка о поддержке Linux.*
Дано: принтер Canon i-SENSYS LBP6020, компьютер с CentOS.
Требуется: заставить печатать как напрямую, так и по сети с других компьютеров под разными ОС.
Первым сюрпризом от Canon оказалось драйверов ни на диске, ни на сайте нет. Поддержка дала такой ответ:
> Информируем Вас, что выпуск драйвера Canon i-SENSYS LBP6020 для Linux запланирован на июль 2013 года.
Товарищ решил дождаться драйверов, и срок, когда принтер мог быть возвращён в магазин прошёл — появились они на англоязычном сайте только 22-го. На русскоязычной части их нет до сих пор (29 июля).
Итак, драйвера обнаружены, скачаны. Принтер подключен к выступающей сервером машине. В виду того, что склад продолжает работать старый принтер не отключён, все печатают на него.
Распаковываем архив и через yum localinstall --nogpgcheck ставим пакеты с драйверами.
Начинаем пляски с бубном. Первым делом, обнаруживается, что использовать ccpd придётся. Напрямую CUPS печатать не сможет.
Ладно, дело такое. На форумах полно примеров запуска LBP2900 через тот же ccpd.
Дабы не путаться какой принтер есть какой, создаю правила udev.
```
/etc/udev/rules.d/99-capt.rules
SUBSYSTEM=="usb", ATTRS{serial}=="0000B1D25DXZ", ACTION=="add", SYMLINK+="lbp6020", RUN+="/etc/init.d/ccpd restart"
SUBSYSTEM=="usb", ATTRS{serial}=="0000B1D25DXZ", ACTION=="remove", SYMLINK+="lbp6020", RUN+="/etc/init.d/ccpd stop"
```
Данное правило создаёт симлинк /dev/lbp6020 с которым и должен работать ccpd.
Параметр serial был получен так:
```
udevadm info --query=all -n /dev/usb/lp1 --attribute-walk
```
После добавления плагина — udevadm trigger
Следующий пункт, настраиваем непосредственно ccpd и CUPS:
```
/usr/sbin/ccpdadmin -p LBP6020 -o /dev/lbp6020
/usr/sbin/lpadmin -p LBP6020 -m CNCUPSLBP6018CAPTK.ppd -v ccp://localhost:59687 -E
```
Важно не ошибиться, и указать порт который в /etc/ccpd.conf отмечен как PDATA\_Port. Попытки печатать на UI\_Port к успеху не приведут.
*Собственно, на этом техническая часть завершена, дальше идёт отчёт о поддержке производителя, точнее об её отсутствии.*
В CUPS появляется принтер, отправляем ему тестовое задание и… тишина. CUPS радостно отчитывается что задача ушла, но принтер не реагирует ни коим образом.
В /var/log/CCPD/ который указан как путь к журналам ccpd нет ничего. Пишем запрос в тех поддержку:
> Драйвер вышел, установил. Такое впечатление, что печать уходит в /dev/null.
>
> Система CentOS 6 x86\_64, никакой диагностики получить от ccpd не удаётся, CUPS тоже молчит.
>
>
Ответ был стандартным вежливым «посыланием красноглазика по вектору»:
> Просим принять во внимание, что драйвера под операционную систему Linux предоставляются на свободной основе. В связи с тем, что существует огромное множество вариантов системы Linux, компания Canon не сможет предоставить поддержки драйверов и данной операционной системы.
После ещё пары часов гугл-фу, возникла мысль что я таки что-то делаю не так. Был задан вопрос в тех поддержку.
> В разделе загрузки написано:
>
> To use this software, please read the online manual before installing the driver.
>
>
>
> Где я могу найти это руководство? Структура сайта затрудняет поиск.
>
>
>
> Прошу принять во внимание, что Red Hat Enterprise Linux является одной из стандартных операционных систем в промышленной эксплуатации. CentOS является полным клоном Red Hat Enterprise Linux, отличающимся только товарным знаком.
>
> Любой уважающий себя производитель оборудования, заявля о поддержке Linux, как это сделала компания Canon указав в поддерживаемых ОС Linux, поддерживает данную ОС актуальных версий. А так же SUSE Linux Enterprise, и с недавних пор — Ubuntu LTS.
>
> Кроме того, существует единственная система печати CUPS, которая поставляется во всех дистрибутивах Linux а так же входит в Mac OS X.
>
> По сему, прошу предоставить мне документацию по настройке и отладке ccpd, которая упоминается в разделе загрузки драйверов. Найти самостоятельно мне её не удалось.
>
> Документация нужна на английском, русском или украинском языке.
Возможно, кто-то скажет «куда ты лезешь, не учи большую фирму работать», но вот как-то опыт работы с оборудованием Dell и HP вызвал желание чётко уяснить политику производителя.
Ответом был ещё более чёткий «посыл».
> Информируем Вас, что запрошенная Вами документация не может быть выслана. Просим принять во внимание, что согласно соглашению пользователя, CANON не предоставляет каких-либо гарантий в отношении программ, файлов, драйверов и прочих материалов, содержащихся на сайте программного обеспечения CANON или загружаемых с ним. Все такие программы, файлы, драйверы и прочие материалы предоставляются «как есть».
Дальше сработал принцип «это что ж, я железяку работать не заставлю?». На сайте Canon в лицензии четко указано право пользователя проводить реверс-инжиниринг и любыми путями менять драйвера в своих нуждах. Первым делом были исследованы архивы с исходными кодами драйвера. Как оказалось, интересующая меня часть имеется только в бинарном виде, а исходники — фильтры CUPS, с GPL`ным прошлым.
Знаний ассемблера у меня 0, но добиться какого-нибудь отладочного вывода я хотел любой ценой. Натравив strings на бинарный файл с демоном я обнаружил, что отладка в нём вообще не предусмотрена. Было также обнаружено графическое приложение captstatusui. Запускаться оно соглашалось только от суперпользователя и… исправно ругалось на невозможность установить соединение с принтером намекая на отключенный кабель или обесточенный принтер. Ситуация оказалась куда банальнее. ccpd упорно игнорировал путь к usb-устройству, и пытался работать с /dev/usb/lp0 — которым был старое МФУ, не знающий никакого CAPT.
Как ни странно, но оказавшись единственным принтер заработал. Т.е. демон упорно хватался за первый попавшийся USB-принтер и пытался печатать на него, но т.к. это был не тот принтер — ничего не происходило. О чём и было сообщено тех. поддержке производителя:
> Информирую вас, что мне удалось запустить принтер, причиной неисправности была программная ошибка в драйвере вызванная низкой квалификацией разработчиков. Но т.к. компания Canon не заинтересована в работоспособности своего оборудования после его продажи, я вам её не сообщаю.
>
> Прошу принять во внимание, что запрошенная мною документация упомянута в разделе загрузки драйверов как опубликованная в открытом доступе.
>
>
>
> Благодарю вас за переписку, она помогла мне убедить заказчика впредь заказывать оборудование производства Hewlett-Packard. | https://habr.com/ru/post/188212/ | null | ru | null |
# Работа с datetime_select и time_select при использовании опции: minute_step
Хелперы datetime\_select и time\_select используются для генерации блока dropdown-полей выбора даты и времени (или только времени) внутри формы. По умолчанию минуты выводятся от 00 до 59 с шагом 1.
Зачастую такая точность не нужна, а кроме того, неудобно использовать выпадающий список из 60 значений. Параметр :minute\_step позволяет указать нужный нам шаг изменения значения минут.
Как многое в Rails, эти хелперы обладают некоторым уровнем “интеллекта”—для значения “по умолчанию” они используют текущее дату и время (если вы не указали :include\_blank => true). И вот с этим есть небольшая проблема. О ней и ее решении читаем ниже.
#### В чем проблема?
Она в том, что при использовании опции :minute\_step значение минут округляется до 00, если переданное в хелпер значение времени не кратно значению :minute\_step. Таким образом, указав :minute\_step => 5 мы получим эффект невозможности отобразить 42 минуты.
Понятно, что если ваше приложение “считает” минуты с некоторым шагом, то и значения минут будут также кратны этому шагу. Но что делать при операции создания записи? Т.е. когда устанавливается текущее время, а это невсегда кратно шагу.
Допустим шаг у нас 5 минут, а текущее время 15:42, тогда в форме создания записи вы увидите время 15:00, и нужно будет кликать и выбирать ближайшее удобное значение (40 или 45 минут). Это невсегда удобно.
Вариант решения?
Один из вариантов—округлить значение текущего времени до точки кратной нашему шагу. В коде это будет выглять вот так:
`<%= datetime_select :created_at, :default => (Time.current.min % 5).minutes.ago(Time.current), :minute_step => 5 %>`
или для time\_select
`<%= time_select :created_at, :default => (Time.current.min % 5).minutes.ago(Time.current), :minute_step => 5 %>`
Таким образом мы всегда будем иметь в полях ввода минут ближайшее к удобному для нас значение.
Приятной работы!
Материал из [блога Hash Train](http://ru.hashtrain.com/blog) | https://habr.com/ru/post/36718/ | null | ru | null |
# Автоматическая блокировка экрана в MacOSX
Читая данное сообщество как простой ~~смертный~~ незарегестрированный читатель натолкнулся на данную [статью](http://habrahabr.ru/blogs/macosx/63444/), которая меня просто вынудила получить инвайт и зарегиться. В данном топике было предложено очень много вариантов блокировки экрана с минимальным участием пользователя, но все они, на мой взгляд, несколько «тяжелые». В каждом из способов нужно было что-то нажимать, куда-то кликать, а лень, как известно, побеждает мир (в хорошем смысле).
Итак, хотел бы представить Вашему взору один из способов довести все до автоматизма.
Из чего готовим:
1) Должен быть установлен пакет Xcode, для нормального пользования скриптов
2) Программа [BluePhoneElite](http://mirasoftware.com/), которая имеет кучу встроенных триггеров (Itunes, DVD, смена статусов iChat, etc.)
3) Мобильный телефон с Bluetooth (надеюсь у каждого есть? :) ) для того чтобы никуда не щелкать мышкой.
4) Keychain ;)
Как готовить:
1) Начнем с простого — с установки BluePhoneElite на компьютер. Программа платная, но стоит своих денег (ИМХО). Как поставить программу и «спарить» с телефоном думаю не у кого вопросов не возникнет.
2) Открываем Программы — Служебные — Связка ключей (Keychain) и создаем объект с именем BluePhone с Вашим именем пользователя и паролем. (понадобится для автоматического ввода пароля)
3) Открываем настройки Системы — Безопасность и ставим галку «Требовать пароль при выходе из режима сна и заставки».
4) Открываем AppleScript и вот тут-то начинается все веселье :). Копипастим туда следующий скрипт:
`using terms from application "BluePhoneElite 2"
on proximity change phone with event theEvent
if theEvent is "exited" then
set the target_app to ((path to "dlib" from system domain as string) & ¬
"Frameworks:ScreenSaver.framework:Versions:A:Resources:ScreenSaverEngine.app") as alias
set process_flag to false
tell application "System Events"
if exists process "ScreenSaverEngine" then set process_flag to true
if (application processes whose name is "SecurityAgent") is not {} then
if windows of process "SecurityAgent" is not {} then set the process_flag to true
end if
end tell
if process_flag is false then tell application (target_app as string) to launch
end if
if theEvent is "entered" then
set the process_flag to false
tell application "System Events"
if exists process "ScreenSaverEngine" then
set the process_flag to true
tell application "System Events" to keystroke return
else
if (application processes whose name is "SecurityAgent") is not {} then
if windows of process "SecurityAgent" is not {} then set the process_flag to true
end if
end if
end tell
if the process_flag is false then return
set now to current date
repeat
tell application "System Events"
if (application processes whose name is "SecurityAgent") is not {} then
if (windows of process "SecurityAgent") is not {} then
tell application "Keychain Scripting"
set MP to password of key 1 of keychain ¬
"login.keychain" whose name is "BluePhone"
end tell
tell window 1 of application process "SecurityAgent"
keystroke MP
click button "OK" of group 2
end tell
return
end if
end if
end tell
if ((current date) - now) is greater than 20 then exit repeat
delay 0.2
end repeat
end if
end proximity change
end using terms from`
Сохраняем его в своей папке пользователя (по желанию).
5) Назначаем триггер реакции «Enter/Exit Range» Applescript и указываем файлик со скриптом.
6) Идем в Настройки — Универсальный доступ и ставим галочку «Включить доступ для вспомогательных устройств».
Done!
Теперь как только мы отходим от компа вместе с телефоном — включается заставка, останавливается фильм, музыка и прочее, а как только появляемся около компа — скрипт автоматически введет за Вас пароль и пазлочит экран :)
Надеюсь что данный пост поможет решить сие неудобство при блокировке экрана.
P.S.: Сильно не пинать — моя первая запись. :) | https://habr.com/ru/post/63653/ | null | ru | null |
# Списки с разными типами элементов и разными провайдерами данных
#### Предисловие
Однажды понадобилось мне выводить в одном ListView карточки разных типов, да еще и полученные с сервера по разным API. Мол, пусть пользователь порадуется и в одной ленте новостей увидит:
* карточки видео, с тамнейлами и описаниями;
* карточки авторов или тегов, с большой кнопкой «подписаться».
Очевидно, что мастерить один большой layout, в котором учитывать все мыслимые варианты карточек — плохо, да и расширяться это будет так себе.
Второй сложностью было то, что источниками данных для карточек могли быть совершенно разные ресурсы сервера, список должен был собираться с помощью одновременных запросов к нескольким разным API, отдающим разные типы данных.
Ну и чтобы жизнь медом не казалась, серверное API менять нельзя.
#### От API к ListView
Virgil Dobjanschi на [Google I/O 2010](http://dl.google.com/googleio/2010/android-developing-RESTful-android-apps.pdf) отлично разложил по полочкам, как реализовывать взаимодействие с REST API. Самый первый паттерн гласит:
1. Activity создает Service, выполняющий запрос к REST API;
2. Service разбирает ответ и сохраняет данные в БД через ContentProvider;
3. Activity получает уведомление об изменении данных и обновляет представление.
**UPD** Тут небольшой холивар на тему использования сервиса возник, так что лучше заменить это слово на «библиотеку, реализующую HTTP запросы» — неважно, каким именно способом.
Так в итоге все и работает: делаем пачку запросов к API, вставляем данные с помощью ContentProvider в отдельные таблицы, связанные с типами REST-ресурсов, уведомляем с помощью notifyChange о доступности новых данных в ленте. Но, как водится, есть две проблемы:
* Как правильно отобразить список карточек?
* Как собрать запрос для ленты?
#### Отображаем разные типы карточек
Сначала разберемся с тем, что попроще. Решение легко находится в гугле, поэтому привожу его кратко.
В [адаптере](http://developer.android.com/reference/android/support/v4/widget/CursorAdapter.html) списка карточек переопределяем методы:
```
@Override
int getViewTypeCount() {
// тут все просто, число реализованных типов карточек заранее известно
return VIEW_TYPE_COUNT;
}
@Override
int getItemViewType(int position) {
// По порядковому номеру текущей строки курсора определяем тип элемента
Cursor c = (Cursor)getItem(position);
int columnIndex = c.getColumnIndex(VIEW_TYPE_COLUMN);
return c.getInt(columnIndex);
}
@Override
void bindView(View view, Context context, Cursor c) {
// обновляем данные в уже существующей вьюхе с учетом типа отображения
int columnIndex = c.getColumnIndex(VIEW_TYPE_COLUMN);
int viewType = c.getInt(columnIndex);
switch(viewType) {
case VIEW_TYPE_VIDEO:
bindVideoView(view);
break;
case VIEW_TYPE_SUBSCRIPTION:
// и так далее
}
}
@Override
View newView(Context context, Cursor cursor, ViewGroup parent) {
// создаем новую вьюху с учетом типа отображения
int columnIndex = c.getColumnIndex(VIEW_TYPE_COLUMN);
int viewType = c.getInt(columnIndex);
switch(viewType) {
case VIEW_TYPE_VIDEO:
return newVideoView(cursor);
case VIEW_TYPE_SUBSCRIPTION:
// и так далее
}
}
```
Дальше чудесный класс `CursorAdapter` сделает все сам: сам инициализирует отдельные кэши вьюшек для разных типов представлений, сам разберется с тем, создавать ли новые или переиспользовать старые вьюшки… в общем все здорово, вот только необходимо получить в курсоре колонку `VIEW_TYPE_COLUMN`.
#### Собираем SQL-запрос для ленты
Пусть для определенности в БД есть таблицы:
* **videos** — содержит список видео для ленты.
Колонки id, title, picture, updated.
* **authors, tags** — содержат списки сущностей, на которых можно подписаться (один к одному отображаются на API сервера).
Колонки id, name, picture, updated.
Итого, необходимо сконструировать запрос, возвращающий следующие столбцы:
| столбец | видео | автор | тег | комментарий |
| --- | --- | --- | --- | --- |
| id | video\_id | author\_id | tag\_id | первичный ключ в соответствующей таблице |
| view\_type | VIDEO | SUBSCRIPTION | SUBSCRIPTION | тип карточки для отображения |
| content\_type | videos | authors | tags | тип контента — или имя таблицы, если так удобнее |
| title | video\_title | NULL | NULL | название видео |
| name | NULL | author\_name | tag\_name | имя автора или название тега |
| picture | link | link | link | ссылка на картинку |
| updated | timestamp | timestamp | timestamp | время обновления объекта на сервере |
Поясню чуть подробнее.
* **view\_type** — отвечает за тип отображения. Обратите внимание, что для авторов и тегов тип отображения один и тот же.
* **content\_type** — отвечает за источник данных. Для автора и тега он уже отличается, что позволяет при необходимости обратиться к нужной таблице или нужному API за дополнительными данными.
* **title, name и picture** — столбцы таблицы, которые могут быть общими для всех или уникальными для каждой конкретной таблицы
* **updated** — поле, по которому строки будут упорядочиваться в результате.
В sqlite запрос получается достаточно простой:
```
SELECT
0 as view_type,
'videos' as content_type,
title,
NULL as name,
picture,
updated
FROM videos
UNION ALL
SELECT
1 as view_type,
'authors' as content_type,
NULL as title,
name,
picture,
updated
FROM authors
UNION ALL
SELECT
1 as view_type,
'tags' as content_type,
NULL as title,
name,
picture,
updated
FROM tags
ORDER BY updated
```
Конечно, можно такой запрос построить «руками», но в [SQLiteQueryBuilder](http://developer.android.com/reference/android/database/sqlite/SQLiteQueryBuilder.html) есть немножко глючные, но работающие методы построения такого запроса.
Итак, Activity запрашивает у нашего ContentProvider ленту:
```
Cursor c = getContext().getContentResolver().query(Uri.parse("content://MyProvider/feed/"));
```
При этом в методе `MyProvider.query` необходимо определить, что происходит запрос именно к Uri ленты, и переключиться в режим «интеллектуального» построения запроса.
```
Cursor query(Uri contentUri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
if (isFeedUri(contentUri))
return buildFeedUri();
// иначе строим все остальные типы запросов
// ...
}
Cursor buildFeedUri() {
// множество всех "не-вычисляемых" столбцов участвующих в запросе таблиц
HashSet unionColumnsSet = new HashSet();
// список Uri всех таблиц, участвующих в подзапросах (videos, authors и tags)
ListcontentUriList = getSubqueryContentUriList();
// для каждой таблицы необходимо вычислить значение viewType
String[] viewTypeColumns = new String[contentUriList.size()];
// для каждой таблицы вычисляем ее contentType
String[] contentTypeColumns = new String[contentUriList.size()];
for (int i=0; i projection = getProjection(contentUri);
// получаем множество всех различных колонок таблиц
unionColumnsSet.addAll(projection);
}
// Итого, на данный момент для для каждого подзапроса, мы знаем: тип карточки,
// значение content-type и список всех колонок, участвующих в основном запросе.
String[] subqueries = new String[contentUriList.size()];
for (int i=0; i projection = prependViewTypeExpr(viewTypeColumns[i], getProjection(contentUri));
// фильтруем подзапрос, по необходимости
String selection = computeWhere(contentUri);
subqueries[i] = builder.buildUnionSubQuery(
"content\_type", // typeDiscriminatorColumn - отвечает за то,
// из какой таблицы взята текущая строка данных
unionColumns,
projection,
0,
getTable(contentUri), // значение для колонки content\_type
// (в данном примере совпадает с названием таблицы)
selection,
null, // selectionArgs - ВНЕЗАПНО методом buildUnionSubQuery вообще не используется
// (бага такая с API level 1, в API level 11 - вообще параметр удален)
null, // groupBy
null // having
);
}
// все подзапросы построены, осталось собрать их вместе и добавить порядок сортировки.
SQLiteQueryBuilder builder = new SQLiteQueryBuilder()
String orderBy = "updated DESC";
String query = builder.buildUnionQuery(
subqueries,
orderBy,
null // limit - нам не нужен, вроде как.
);
return getDBHelper().getReadableDatabase().rawQuery(
query,
null // selectionArgs - нами не используется
);
}
```
В общем, если пример написан правильно, при обращении к `content://MyProvider/feed/` наш ContentProvider сгенерирует нужный нам UNION-запрос и отдаст необходимые данные адаптеру.
#### Получаем обновления данных с сервера
Но что такое? Запрашиваем вторую страницу API video, данные, судя по логам, сохраняются в БД, но ListView не обновляется…
Дело в реализации [LoaderCallbacks](http://developer.android.com/reference/android/app/LoaderManager.LoaderCallbacks.html)
```
@Override
public Loader onCreateLoader(int loaderId, Bundle params) {
return new CursorLoader(
getContext(),
Uri.parse("content://MyContentProvider/feed/"),
...
);
}
```
Когда Activity запрашивает ContentProvider, CursorLoader создает [ContentObserver](http://developer.android.com/reference/android/database/ContentObserver.html), следящий за Uri `content://MyProvider/feed/`; когда же наш сервис сохраняет результаты запроса к API сервера, ContentProvider автоматически уведомляет об изменении данных по другому Uri, `content://MyProvider/videos/`.
Как правильно и окончательно решить эту проблему, я не знаю. В моем приложении оказалось достаточно в коде, сохраняющем результаты запроса в БД, явно уведомлять об изменении данных ленты (уведомление об изменениях в конкретной таблице ложится на плечи провайдера):
```
getContext.getContentResolver().notifyChange(Uri.parse("content://MyProvider/feed/", null));
```
#### Альтернативные решения
* [MergeCursor](http://developer.android.com/reference/android/database/MergeCursor.html) — оборачивает список курсоров в интерфейс курсора, при итерации возвращая последовательно все строки из первого курсора, затем второго и т.д.
В случае, когда порядок строк в запросе не важен — позволяет очень сильно упростить код.
* [MatrixCursor](http://developer.android.com/reference/android/database/MatrixCursor.html) — позволяет не обращаясь к БД предоставить интерфейс курсора к любому двумерному массиву. MergeCursor + сортировка + MatrixCursor — дает профит в случае, когда необходимо отсортировать и показать не очень большое число строк. | https://habr.com/ru/post/221851/ | null | ru | null |
# arr[-1] или самые редкие конструкции в С
С - это неоднозначный язык. Сам по себе он небольшой, об этом писал Брайан Керниган в своей знаменитой книге "Язык программирования С". Но это не мешает комбинируя базовые возможности языка составлять более комплексные и запутанные конструкции. Иногда они встречаются в кодах реальных программ довольно редко, из-за своей узкой области применения - о них и пойдёт речь в этой статье.
Структура статьи
----------------
Сначала расскажу о базовых и часто встречаемых конструкциях, которые могут и вовсе не удивить опытных программистов на С, но вот уже ниже идут всё более редкие и интересные конструкции, которые уже далеко не часто можно где-либо встретить.
Содержание
----------
1. union
2. register
3. Статические функции
4. Константный указатель
5. Препроцессорная склейка строк
6. Конкатенация строк во время компиляции
7. #undef
8. sizeof без ()
9. Создание функции в стиле K&R
10. Указатели на функции
11. Указатели на указатели
12. Функции с переменным количеством параметров
13. Массив + индекс (два в одном)
14. Индекс с массивом, но вверх ногами
15. strtok(), tmpfile()
16. Возврат указателя на функцию из функции
17. volatile
18. Макросы с переменным количеством параметров
19. auto
20. Использование возвращаемых значений scanf() и printf()
21. Каламбур типизации
22. Отрицательные индексы
union
-----
Объединения в С встречаются в зависимости от задачи:
`union cnt {
int ival;
float fval;
};`
Это далеко не редкое явление, и эта конструкция вошла в список только по той причине, что по частоте применения она не может конкурировать с подобным ей *struct*, который использует такой же синтаксис но находит себе место даже в небольших программах гораздо чаще чем объединения.
register
--------
Это ещё одно ключевое слово в С. А вот вы можете вспомнить когда вы создавали регистровую переменную в последний раз? И я нет. Стандарт языка говорит что компилятор может и вовсе проигнорировать это ключевое слово и вместо регистра процессора поместить переменную в оперативную память. К тому же нельзя брать адрес регистровой переменной в независимости от того помещена она в регистр на самом деле, или нет. Из плюсов только то, что к ней вроде как обращение идёт быстрее, так как она находится в регистре, но что-то не особо верится. Думаю понятно, почему это ключевое слово вошло в список - минусов здесь к сожалению больше чем плюсов.
Статические функции
-------------------
Если объявить автоматическую переменную с ключевым словом `static`, то переменная в отличии от обычной сохранит своё значение при выходе из функции. Но можно и саму функцию сделать статической:
`static char* get_next_password (const password_t stack[], ssize_t *sp){
return (sp > 0) ? stack[--*sp].data : NULL;
}`
При беглом просмотре можно подумать что функция возвращает `static char*`, но на деле же она возвращает обычный указатель на строку, а вот статическое объявление говорит о том, что функция видна только в том файле исходного кода, в котором она описана. То есть если вы подключите заголовочный файл с этой функцией к другому, и попытайтесь вызвать её из другого файла, то будет ошибка о том что имя не найдено. Это некий механизм сокрытия имён, только в С. Такой приём часто используется в ядре ОС Linux. Но вот в небольших, а уж тем более одно-файловых программах вы такое вряд-ли найдёте. То же применимо и к статическим глобальным переменным - эффект такой-же как и с функциями. Применение я здесь увидел только одно - хранение 2-х функций с одинаковыми именами в 2-х разных файлах исходного кода.
Константный указатель
---------------------
Указателем на константу уже никого не удивишь - `const char*`. Совсем другое дело константный указатель: `char * const`Хоть я сам часто пишу на С, но о такой вещи не знал, и встречается она далеко не часто. Для ясности картины:
* `char* ptr;` - указатель на char
* `const char* ptr;` - указатель на const char
* `char * const ptr;` - константный указатель на char
* `const char * const ptr;` - константный указатель на const char
Конечно никто не запрещает делать так: `char const *ptr;`, то есть поменять char и const местами. Это также будет указателем на const char.
Препроцессорная склейка строк
-----------------------------
Выглядит странно, но следующий фрагмент программы прекрасно компилируется, и запускается:
`int ma\
in (void){
retu\
rn 0; }`
Оператор `\`- это специальный инструмент препроцессора, позволяющий склеить текущую и следующую строку исходного кода перед компиляцией. Зачем это нужно? Например когда слишком длинное условие:
`} while ((x >= 0) && (y >= 0) && (x <= WIN_SX-1) && (y <= WIN_SY-1) && flag && f(2));`
Можно его разделить с помощью знаков `\`:
`} while\
((x >= 0) &&\
(y >= 0) &&\
(x <= WIN_SX-1) &&\
(y <= WIN_SY-1) &&\
flag && f(2));`
Пример надуманный так как описанный выше код прекрасно работает и без этих символов. Но нельзя просто так переносить слова - они будут восприниматься как два имени, будь-то имена переменных, констант, ключевые слова и т.д. Да и вообще не пишите длинных условий, лучше пишите функции/макросы для таких длинных участков:
`} while (access()); /* мм красота */`
Также они применяются чтобы красиво оформить макросы
`#define macro\
/* code */`
Конкатенация строк во время компиляции
--------------------------------------
Продолжая тематику строк можно ещё вспомнить приём конкатенации строк во время компиляции. То есть если написать две строки рядом, то они склеятся в одну строку.
`puts( "Hello, " "world!" );` - склеится в "hello, world!"
А вот это уже будет полезно для работы с длинными строками, чтобы можно было их переносить. Так как просто перенести, не закрыв и/или не открыв двойные кавычки не получится:
`const char* ultra_string = "Lorem
ipsum..."; //ошибка`
`const char* ultra_string = "Lorem"
" ipsum..."; //склеится в "Lorem ipsum..."`
Это свойство строк хорошо сочетается с препроцессорным оператором `#`,который переводит операнд в строку. Итак можно придумать такой отладочный вывод:
`#define dprint(exp)\
printf(#exp " = %i\n", (int)(exp));`
При вызове `int n = 10; dprint(n/5);` будет следующая последовательность операций препроцессора:
1. `printf(#exp " = %i\n", (int)(exp)); //исходная строка`
2. `printf(#(n/5) " = %i\n", (int)(n/5)); //вставка аргумента`
3. `printf("n/5" " = %i\n", (int)(n/5)); //конвертирование в строку`
4. `printf("n/5 = %i\n", (int)(n/5)); //конкатенация строк`
Вот простой пример применения, который был описан в книге Брайана Кернигана.
#undef
------
На самом деле применений у этой препроцессорной директивы не так уж и много. Разве что она может ограничить действие имени определённого через `#define`. Или же ставить его перед функциями так:
`#undef to_str /* на всякий "пожарный" */
char* to_str (long val);`
Но всё же я не думаю, что это сильно полезно, особенно когда программист уверен что такого макроса не существует.
sizeof без ()
-------------
И действительно, так как `sizeof`не является функцией, то по идеи как и в случае с `return` можно писать выражение, размер которого мы вычисляем без скобок. Но не всегда - стандарт говорит что скобки необходимы в случае с вычислением размера типа. А когда вычисляется размер выражения - скобки вообще не обязательны:
`int *dyn_arr = malloc( sizeof *dyn_arr * A_SIZE);`
Создание функции в стиле K&R
----------------------------
Вообще в стандарте C2X больше не позволительно объявлять функции так:
`size_t move(a,b)
size_t a, b;
{
a = a ^ b;
b = a ^ b;
a = a ^ b;
}`
К сожалению или к счастью практически все современные программы на С которые написаны на С11 и выше уже используют привычную всем конструкцию: тип аргумент, тип аргумент...
Указатели на функции
--------------------
И всё, что вообще с ними связано. Я думаю они не сильно полезны, максимум как аргумент для другой функции, к примеру `qsort()` из заголовочного файла использует `int (*compare)(const void*, const void*)` в качестве параметра. Конечно говорить что они совсем не нужны категорически нельзя. Здесь всё зависит от задачи. Ещё они позволяют чуть лучше понять С и как он работает. Кстати в указатель на функцию можно положить как адрес функции, так и имя функции, так как
`f = &f`, напоминает ситуацию со статическими массивами: `m = &m`. Бывают полезны указатели на функции и в случае с массивом из функций, обращение к которому выглядит весьма необычно: `(void)funcs[idx](param1,param2);`
`void parse_line(const char* input, rtable_line* line){
sscanf("%zu %zu %c\n", line->adress, line->hist_cnt, line->state);
}
...
void (*parse_func)(const char*, rtable_line*) = &parse_line; // 1 способ
parse_func = parse_line; //2 способ
parse_func(_input, _line); //вызов по указателю`
В приведённом примере выше указать на функцию `parse_line` можно двумя способами: явно указав амперсанд, или не указывая его вовсе. 2 способа эквивалентны.
Указатели на указатели
----------------------
на указатели на указатели на указатели...
То есть:
`int *p; /* всё нормально - может быть переменная, а может быть массив */
int **p; /* это всё ещё переменная, а может быть двумерный массив. А может надо изменить указатель через его адрес */
int ***p; /* что-то много звёздочек. Трёх-мерный массив? Адрес адреса указателя? Переменная? */
int ****p; /* если вы пишите что-то такое не комментируя - обратитесь к врачу */`Как по мне такая конструкция может встретится на практике в таком виде:
`void free_and_setto_NULL (void** ptr){
free(*ptr);
*ptr = NULL;
}`
Но что-то я сомневаюсь что в таком случае нельзя обойтись макросом, или вовсе сделать все эти операции на месте вызова.
Функции с переменным количеством параметров
-------------------------------------------
Как часто вы видите подобное?
`#include
void print\_strings (size\_t count, ...){
va\_list cstring;
va\_start(cstring, count);
while (count > 0){
puts(va\_arg(cstring, char\*));
--count;
}
va\_end(cstring);
}`
Можно было например передать массив строк, тогда код получился бы короче:
`void print_strings (size_t count, const char* strings[]){
while (count > 0)
puts(*strings++), --count;
}`
Ну да, вызывать будет посложнее: `print_strings( 2, (const char*[]){"I love C", "What am I doing?"});`, но такой способ как минимум уменьшает объём кода в 3 раза. Но зато объявление функций с переменным количеством параметров выглядят красиво.
`void print_strings( size_t, ... ); /* красота */`
Стоит упомянуть, что в C функция, объявленная без параметров принимает произвольное число аргументов. Если вы не собирайтесь передавать в функцию никаких параметров, то при объявлении функции хорошей практикой будет написать `void` на месте параметров. В таком случае при передаче чего-либо в функцию компилятор не проигнорирует такой вызов в отличии от `()` на месте аргументов.
Массив + индекс (два в одном)
-----------------------------
Редко (очень редко) где, я встречаю подобные выражения:
`"Programming"[i++]`
В самом деле, немногие начинающие программисты знают что можно объявить массив/строку и взять элемент из неё. Наверно с первого взгляда покажется, что данная комбинация вообще не имеет смысла - зачем брать целый массив только ради получения одного элемента из него? Однако данная конструкция находит себе место под солнцем, например в рисовании символов по яркости:
`for (int i = 0; i < 10; i++){ putchar("@#c;:,. "[brightness[i]]); }`
Здесь очень удобно проиллюстрирована возможность не создавать отдельный массив для символов яркости. Или:
`printf ((char*[]){ "NO", "YES" } [state]);`
Вот так можно обойти создание массива строк, хотя в таких ситуациях более понятным и читабельным всё же будет тернарный оператор `?:`
Индекс с массивом, но вверх ногами
----------------------------------
Простой пример:
`int arr[ARR_SIZE], i = ARR_SIZE-1;
while (i>=0) {i--[arr] = i+1;}`
Здесь может показаться что будет ошибка в выражении `i--[arr]`, так как индекс и имя массива перепутаны местами. Но всё прекрасно работает - язык С, это язык возможностей. Вот незадача - оно работает, но как? При первом беглом взгляде я подумал об адресах. Быть может если arr представить как адрес, то тогда всё сходится, так как это целое число а индекс должен быть целым числом. Но меня ждал сюрприз во время разбора индекса, я не понял как из `i--`можно взять к примеру элемент под 3 индексом? 3 бит числа? Но потом прочитав объяснение всё сразу стало понятно.
Когда компилятор встречает выражение на подобие `arr[i--]`, то он представляет его как `*(arr + i--).`Иными словами он прибавляет к адресу первой (нулевой) ячейки массива индекс в квадратных скобках, а потом по полученному адресу достаёт значение. А что будет если поменять местами индекс и массив? `i--[arr]` оттранслируется как `*(i-- + arr)`. От перемены мест слагаемых сумма не меняется, следовательно и итоговый адрес тоже. Если ранее упомянутые конструкции находили себе хоть какое-то применение, то это просто забавный способ запутать программу для человека, который пока что не прочёл эту статью.
strtok(), tmpfile()
-------------------
Те самые, одни из самых редких функций библиотеки С. `char* strtok(s, d)` разбивает строку s на токены. При первом вызове надо передавать функции параметр s, а вот уже далее надо передавать `NULL`, тогда функция вернёт следующий токен из той же строки. d - это строка делителей. То есть те символы, которые разбивают строку на токены. Возвращает указатель на следующий токен.
`char str[50] = "Enjoy C programming!";
char* token = strtok(str, " .,!?"); //токены разделяются одним из символов d
do {
printf("token - \'%s\'\n", token);
token = strtok(NULL, " .,!?");
} while (token);`
Такая функция может быть полезна для различного рода парсеров. Хотя для парсинга простых шаблонных строк больше подходит `sscanf()`. + ко всему функция является небезопасной, так как редактирует исходную строку s, которую она принимает на вход.
А `tmpfile()` просто возвращает указатель на промежуточный файл (или поток). В большинстве случаев достаточно просто массива. Если посмотреть использование функции в интернете на разных обучающих сайтах, то вы не найдёте ничего кроме заголовка `FILE* tmpfile(void)`,и демонстрации открытия и закрытия этого файла.
Возврат указателя на функцию из функции
---------------------------------------
`int (*foo(void))(size_t, size_t);`
Страшное объявление, но это всего лишь функция, возвращающая указатель на функцию, которая имеет сигнатуру `int f(size_t,size_t)`. Хорошей практикой будет избегать таких объявлений, используя typedef:
`typedef int (*funcptr)(size_t, size_t);
funcptr foo(void); //и всё понятно`
Встречается такой стиль гораздо реже, но к нему надо стремиться. Ведь цель написать и быстрый и понятный код, а не только быстрый. (К программистам на Assemler не относится понятный, можете не волноваться по поводу читабельности). Да и вообще причиной ненависти к С у многих людей являются именно сложные объявления, а особенно те, в которых используются функции.
volatile
--------
Иногда компилятор может оптимизируя удалять целые куски кода. Чтобы такого не было желательно ставить ключевое слово `volatile` перед объявлением переменной, если вы хотите чтобы компилятор 100% не применил свои коварные оптимизации к этой переменной. (Хорошо что слово `volatile` не может игнорироваться, как иногда бывает с `register`, а то в этой жизни пришлось бы больше ни в чём не быть уверенным)
Макросы с переменным количеством параметров
-------------------------------------------
Вы думали всё заканчивается на функциях? К удивлению для меня в некоторых стандартах (а в частности и С11) можно делать макросы с переменным количеством аргументов, точно так же как и функции
`#define vmacro(...)`
А как к параметрам-то обратиться? Всё просто - тут вам никаких . Всего лишь в тексте для замены макросом нужно прописать `__VA_ARGS__`. Может показаться странным, но если вы подумайте как работает препроцессор - это просто обработчик текста, и он не может думать о том, как работать с этими аргументами и их типами. Точно также как и в макросы с фиксированным числом аргументов препроцессор С вставляет их на их места, так и здесь. Отличие лишь в том что в случае с переменным количеством параметров на место вставится не один, а столько сколько было указано в круглых скобках при макро-вызове аргументов.
`#define myprint(str, ...)\
printf(str, __VA_ARGS__);`
Также такой способ даёт почву для размышлений о том какие розыгрыши можно выдумать с таким инструментом:
`#define for(...) //обезвредили все циклы for`
auto
----
Не знаю зачем, может в ранних версиях языка без этого слова было никак не обойтись. В современных реалиях `int x;` объявленная внутри функции и так подразумевается автоматической, несмотря на то что здесь отсутствует явное `auto int x;`На моей теме VScode оно даже не подсвечивается как ключевое слово. Хотя в C++ оно активно используется в случае, когда программист абсолютно не переживает о том какой тип имеет переменная:
`for (auto idx = 0; idx < 10; ++idx)`
Использование возвращаемых значений scanf() и printf()
------------------------------------------------------
Что может быть абсурднее? Кто-то может первый раз слышать о том, что `printf()` из стандартной библиотеки возвращает кол-во напечатанных байтов на экран. Его братья `sprintf()`, `vprintf()`, `fprintf()` делают тоже самое. Соответственно `scanf()` возвращает кол-во считанных байт. Один раз видел даже такой код:
`assert (printf("Some str") == strlen("Some str"));`
Предохраниться лишний раз никогда не бывает лишним.
Каламбур типизации
------------------
Одно из моих любимых. Если знаешь как устроена память - то власть в твоих руках. Каламбур типизации это в большинстве случаев небезопасные / неопределённые стандартом / платформо-зависимые и опасные решения, основывающиеся на знании устройства памяти, и использующих инструменты языка. Объяснить мощь каламбура можно на следующем простом примере
**Задача**: дано шестнадцатеричное число `uint64_t x = 0x2E6D6172676F7270;`В каждом байте числа записан символ. Вывести число как строку символов.
Первое что приходит в голову - извлекать текущий байт, отображать его на экране как символ, затем сдвигать число направо на один байт пока число не станет нулём.
`uint8_t cb; while (cb = x & 0xFF){ putchar(cb); x >>= 8; }`
Такая запись вполне работает, и выводит каждый байт числа как символ. Но всегда есть альтернативные пути решения такой-же задачи, но заметно короче. "Короче" не всегда значит лучше!
`printf ("%.8s", (char*)&x);`
В один вызов printf уложилась задача, ранее решаемая с помощью цикла. Но как?
Дело в том что память в компьютере хранится в ячейках, и каждая ячейка имеет свой размер в байтах. Если представить x не как одно большое 8-байтное число как массив байтов (символов), то получим вот это:
`10111001 10110101 10000101 11001001 10011101 10111101 11001000 00000000} x`
Далее мы берём адрес первого байта этого числа:
`10111001 10110101 10000101 11001001 10011101 10111101 11001000 00000000
^
&x`
И далее мы преобразуем адрес из указателя на число в указатель на строку приведением типов:
`10111001 10110101 10000101 11001001 10011101 10111101 11001000 00000000 }
^
(char*)&x`
И вот мы и получили строку, так как знаем что `uint64_t` это просто массив из 8 байт, и с помощью изменения адреса мы изменили представление памяти этого конкретного куска для компилятора, которому принципиально не важно что именно находится по адресу - надо лишь чтобы размер соответствовал. Формат `%.8s` неспроста имеет цифру 8. В ином случае мы рискуем вывести всё что лежит в памяти, пока не встретим 0. Поэтому поставим ограничение на 8 символов.
#### Почему это плохо?
Многие люди задаются этим вопросом. Это ведь сокращает код! Может показаться что это плохо из-за того что это не предусмотрено стандартом языка или из-за такого что такой код тяжёлый для чтения. Однако проблема совсем в другом. Вот пример базовой функции, возвращающей компонент структуры:
`struct point {
int x, y;
};
int get_y(const struct point* p){ return p->y; }`
Выражение `p->y` здесь уж слишком банальное. Давайте усложним его
`int get_y(const struct point* p){ return *(int*)((char*)&(p->x)+4); }`
Здесь сначала берётся адрес переменной `p->x.` Затем зная что переменные в структуре идут в памяти по порядку мы можем сдвинутся на 4 байта вправо и получить адрес переменной `p->y`. Это производится с помощью приведения типа указателя на символ (байт), сдвижке его на 4 ячейки вправо. Теперь полученный адрес обязательно нужно привести к указателю на целую ячейку, и перейти по нему. Такой пример в отличии от предыдущего демонстрирует не сокращение объёма кода, а наоборот его увеличение, а что ещё хуже - увеличению количества операций которое нужно выполнить. Из этих примеров вывод такой - каламбур типизации в реальных программах это плохо потому, что
1. Размер ячеек на каждой платформе может отличаться
2. Разные компиляторы могут по разному хранить переменные в памяти
Оба этих фактора могут обеспечить неправильное или неопределённое поведение программы.
Отрицательные индексы
---------------------
Изюминка этого чарта. `arr[-1]` - вполне себе привычная запись для программиста на Pascal. Всё потому что в этом языке при создании массива указывается не только правая, но ещё и левая граница массива:
`var arr : array[-100..100] of integer;`
Но С - язык другой. Каждый программист наизусть знает что индексы массивов здесь начинаются с нуля как и в любых других С-подобных языках. Тем не менее не забывайте, что оператор `[]` применим не только к массивам но и у указателям.
`int real_array[100], *arr = real_array+3;
arr[-1] = 3;
arr[-2] = 65;
arr[-3] = 3278;
printf("arr[-1] = %d, arr[-2] = %d, arr[-3] = %d\n", arr[-1], arr[-2], arr[-3]);`
Если вы всё равно не поняли как это работает, то вот то как компилятор представил запись `arr[-1]`:
`*(arr + (-1)) = 3;`
Или же эквивалент ей:
`*(real_arr + 2) = 3;`
Такого вы точно скорее всего не видели в уже готовых работающих проектах на языке С.
Выводы
------
Язык С намного больше, обширнее и глубже чем кажется - необходимо как минимум несколько лет практики и опыта чтобы знать большинство возможностей этого инструмента. Хоть язык и имеет множество конструкций которые редко применяются, всё же они как никакие другие нужны в некоторых задачах. Я постарался дать примеры использования практически всех конструкций из этого списка. Надеюсь вы узнали что-то новое для себя из этой статьи, или хотя бы вспомнили хорошо забытое старое. Всем желаю чтобы ваши индексы находились в границах массивов, а `malloc()` никогда не возвращал `NULL`. | https://habr.com/ru/post/652621/ | null | ru | null |
# Widgets. Custom fonts
Столкнулся с ситуацией, когда было необходимо в виджете, на экране андофона, отобразить текст красивым нестандартным шрифтом. С того момента и начался сей пост.
Разработка виджета немного отличается от разработки *activity*, и вот это «немного» иногда ставит палки в колеса. Подробно расписывать разработку виджета я не буду, на *Хабре* уже есть несколько замечательных постов на эту тему (например, [Hello World widget для Android](http://habrahabr.ru/blogs/android_development/114515/) или вообще такая вот шпаргалка, [Создание Виджета](http://code.google.com/p/android-cbrf/wiki/Widget)), остановлюсь лишь на особенностях.
##### Суть проблемы
Проблема заключалась в том, что писать кастомным шрифтом в *activity* мы можем, установив всего лишь свойство **Typeface** необходимому нам **View**.
```
Typeface tf = Typeface.createFromAsset(getAssets(), "fonts/Aliner.ttf");
TextView tv = (TextView) findViewById(R.id.txtFont);
tv.setTypeface(tf);
```
А вот с виджетом такое уже не пройдет. Добраться до **View** мы можем только через объект **RemoteViews**, который предоставляет нам не очень то и большие возможности. До свойст «вьюшек» мы тоже так просто не доберемся, хотя значения некоторых, мы всё таки можем изменить через методы:
```
remoteView.setInt(R.id.widgetPNG, "setAlpha", 50);
remoteView.setBoolean(R.id.a_text_view, "setSelected", true);
remoteView.setCharSequence(viewId, "setText", "Hello World!");
.....
```
но вопрос со шрифтом остается открытым.
Решение было найдено с помощью **Bitmap**'ов.
##### Подключение кастомного шрифта
Первое что необходимо, это найти подходящий нам шрифт и покласть его в директорию *./assets/fonts/*:
Далее остается только подключить его в коде виджета:
```
Typeface tf = Typeface.createFromAsset(context.getAssets(),"fonts/Benegraphic.ttf");
```
##### Конверт текста в картинку
Как я уже говорил, работать мы будем с **Bitmap**'ом. Имея текст, преобразовать его в картинку нам поможет следующий метод:
```
private Bitmap convertToImg(String text, Context context)
{
Bitmap btmText = Bitmap.createBitmap(400, 100, Bitmap.Config.ARGB_4444);
Canvas cnvText = new Canvas(btmText);
Typeface tf = Typeface.createFromAsset(context.getAssets(),"fonts/Benegraphic.ttf");
Paint paint = new Paint();
paint.setAntiAlias(true);
paint.setSubpixelText(true);
paint.setTypeface(tf);
paint.setColor(Color.WHITE);
paint.setTextSize(50);
cnvText.drawText(text, 150, 50, paint);
return btmText;
}
```
Метод **convertToImg()** возвращает уже готовый «битмап» с текстом, написанный шрифтом **Benegraphic.ttf**. Нам же остается только установить его в виджете.
##### Добавление «текста» в виджет
Установить сгенерированный *bitmap* в виджет труда особого не составит, это всего-то 3 строки кода:
```
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds)
{
RemoteViews remoteViews = new RemoteViews(context.getPackageName(), R.layout.widget);
remoteViews.setImageViewBitmap(R.id.imText, convertToImg("Hello World!", context));
appWidgetManager.updateAppWidget(appWidgetIds, remoteViews);
}
```
На этом весь кодинг заканчивается. Запустив приложение и установив виджет на один из рабочих столов мы увидим подобную картину:
Вот мы и получили кастомный шрифт в виджетах **Android**.
##### Заключение
Одним из способов, мы всё таки решили проблему. Это конечно был выход, но хотелось чего-то более нативного. Очень надеюсь что есть еще способы, но увы ни придумать, ни найти больше ничего другого не получилось. Люди в интернетах также задаются этим вопросом, но ответа пока не видел. Может быть кто-то из вас уже сталкивался, интересно было бы услышать в комментариях :)
Скачать весь проект можно [здесь](http://zigles.com/files/Widget.CustomFont.zip). | https://habr.com/ru/post/117672/ | null | ru | null |
# Кроссплатформенный переключатель прокси-сервера на Python + Qt
Устав искать нормальный портативный инструмент для переключения между моим рабочим прокси-сервером и прямым подключением дома (который, к тому же, работал бы на Windows и Linux), я решил-таки запилить собственную тулзу для этих целей. Вооружившись Python и Qt, начал клепать код в VSCode... Что из этого вышло -- читаем под катом.
---
Мотивация
---------
Основной мотивацией для создания данного инструмента стало жуткое неудобство системных настроек прокси при работе из офиса и дома. Каждый раз приходилось лезть в настройки прокси, передвигать флажок... А, кроме того, еще удалять или скрывать системные переменные HTTP\_PROXY (и им подобные), чтобы консольные приложения вроде git также слушались руля... Это на Винде. А на Линуксе так вообще веселая история: не все графические системы имеют встроенные утилиты для управления настройками прокси, и моя Kali Linux как раз такая. Приходится вручную комментировать / раскомментировать экспорты переменных среды (той же HTTP\_PROXY) и перелогиниваться... Морока, одним словом.
Беглый (а затем и не очень беглый) поиск в гугле / яндексе результатов не дал: предлагаются в основном плагины для браузеров, переключающие прокси только для браузера (системные настройки не изменяются). Нормальной легковесной, портативной, бесплатной, кроссплатформенной тулзы с графическим интерфейсом мне найти так и не удалось. И тогда, кряхтя и сопя от борьбы с ленью, открыл я VSCode и создал новый проект на Python...
Требования к инструменту
------------------------
Почиркав в блокноте наброски GUI, я определился со следующими минимальными требованиями к приложению:
* включение / выключение прокси-сервера одной кнопкой (с соответствующими автоматическими изменениями переменных среды)
* настройки прокси должны быть постоянными, т.е. записываться в соответствующие системные файлы и оставаться после перезагрузки
* возможность раздельных настроек для HTTP, HTTPS, FTP и (что бывает нужно для Unix) - RSYNC
* импорт / экспорт настроек в / из файла
* возможность подробного лога для отладки
Сразу скажу, что особой эстетичнойти GUI в минимальных требованиях не числилось. Главное -- простота и интуитивность. Это так, чтобы вы меня не слишком терроризировали за дизайнерские способности :)
Где хранятся системные настройки прокси
---------------------------------------
### Windows
На машинах под Windows настройки прокси хранятся (как и большинство других системных настроек) в реестре. А именно, в ветке `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings` (таким образом, эти настройки задаются пользователем и не являются общесистемными).
Настройки прокси в реестре Windows. Зеленым выделены основные переменные.За настройки прокси отвечают две переменные в реестре:
1. `ProxyServer`: адрес и порт прокси сервера, разделенные двоеточием (у моего прокси, например, адрес = 192.168.1.10, порт = 3128)
2. `ProxyOverride`: разделенные запятыми адреса и маски адресов, которые должны работать по прямому соединению, минуя прокси (обычно сюда добавляется , что означает localhost, т.е. не использовать прокси для локальных соединений)
Кроме того, многие приложения (в основном, консольные) берут настройки прокси не из реестра, а из специальных переменных среды:
* `HTTP_PROXY` - прокси для HTTP-соединений в формате `http://[[USER]:[PASSWORD]@]HOST:PORT` (например, "http://user:pass@192.168.1.1:3000" или если без прокси-аутентификации: "http://192.168.1.1:3000")
* `HTTPS_PROXY` - то же для HTTPS-соединений
* `FTP_PROXY` - то же для FTP-соединений
* `RSYNC_PROXY` - то же для [RSYNC](https://ru.wikipedia.org/wiki/Rsync)-соединений
* `NO_PROXY` - адреса в обход прокси (аналог вышеуказанного `ProxyOverride`)
Переменные среды в Windows: определены переменные, относящиеся к настройкам прокси### Linux и MacOS
В Unix'ах, как водится, все настройки хранятся в обычных файлах: пользовательские -- в директории текущего пользователя (`~/...`), системные -- в директории `/etc`.
Настройки прокси задаются такими же переменными среды для соответствующих соединений (`HTTP_PROXY` и т.д.) + `NO_PROXY` для прямых адресов + иногда может встречаться переменная `ALL_PROXY`, задающая настройки для всех типов соединений.
Вот неполный перечень файлов, в которых обычно задаются переменные среды и иные настройки:
* Пользователь: `~/.profile, ~/.bashrc, ~/.bash_profile, ~/.zshrc, ~/.cshrc, ~/.tcshrc, ~/.login`
* Система: `/etc/environment, /etc/profile, /etc/bashrc, /etc/bash.bashrc, /etc/zsh/zshrc, /etc/csh.cshrc, /etc/csh.login`
А еще, конечно, переменные могут определяться в скриптах, расположенных в специальных директориях: `/etc/init.d`, `/etc/environment.d` и т.п. Простор фантазии, в двух словах!
Структура приложения
--------------------
➯ **Приложение размещено на** [**Github**](https://github.com/S0mbre/proxen)**.**
Структура приложения (писалось на Python 3.10) получилась такая:
* 🖿`doc/` - документация (сделана при помощи [Doxygen](https://www.doxygen.nl/))
* 🖿`resources/` - иконки и картинки
* ©`LICENSE` - лицензионный файл ([MIT License](https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D1%86%D0%B5%D0%BD%D0%B7%D0%B8%D1%8F_MIT), т.е. полностью open-source, свободно для изменений и использования в т.ч. в коммерческих целях)
* ✍`README.md` - краткое описание
* 🐍`proxen.py` - главный файл для запуска приложения (создает объект `QApplication` и запускает главный цикл с основным окном)
* 🐍`gui.py` - все GUI формы (виджеты Qt)
* 🐍`qtimports.py` - импорт пакетов Qt с поддержкой различных фреймворков: PyQt5, PyQt6, PySide2 и PySide6 (импортируется тот, который установлен)
* 🐍`sysproxy.py` - классы для работы с переменными среды и настройками прокси -- "сердце" инструмента
* 🐍`utils.py` - глобальные переменные и полезные функции
* ⚙`config.ini` - файл с настройками приложения (пока там только включение лога и вывод его в консоль)
* 🐍`config.py` - соответствующий объект настроек (используется [configparser](https://docs.python.org/3/library/configparser.html))
* 🖹`requirements.txt` - зависимости, которые можно установить [при помощи pip](https://pip.pypa.io/en/stable/cli/pip_install).
Принцип работы приложения
-------------------------
Работу приложения проще объяснить на визуальной схеме.
Схема работы proxen👓 [Просмотр с возможностью зума](https://viewer.diagrams.net/?layers=1&nav=1&title=proxen.drawio#Uhttps%3A%2F%2Fdrive.google.com%2Fuc%3Fid%3D1nUsTf7DDxSiSq4Ft0zydefh_hIvhla3P%26export%3Ddownload) ▶ [𝓭𝓻𝓪𝔀.𝓲𝓸](https://app.diagrams.net/)
Окно приложения реализовано Qt-виджетом `MainWindow`. Связь между GUI и настройками прокси осуществляется при помощи 4 уровней абстракции:
1. **Уровень** ❹. Обычный питоновский словарь (dict) `localproxy` со следующими элементами:
```
{
'enabled': b_enabled, # статус прокси (вкл/выкл)
'http_proxy': { # настройки прокси для HTTP
'host': str_host, # адрес сервера
'port': n_port, # порт сервера
'auth': b_auth, # требуется ли аутентификация
'uname': str_username, # имя пользователя на прокси-сервере
'password': str_userpass # пароль пользователя
},
'https_proxy': { # настройки прокси для HTTPS
# см. http_proxy
},
'ftp_proxy': { # настройки прокси для FTP
# см. http_proxy
},
'rsync_proxy': { # настройки прокси для RSYNC
# см. http_proxy
},
'noproxy': str_no_proxy # адреса (маски) без прокси через ","
}
```
Параметры элементов управления пользовательского интерфейса синхронизируются с этим локальным словарем. Пока пользователь не нажал кнопку `Apply` или `Restore`, никакого взаимодействия с нижними уровнями не происходит.
2. **Уровень** ❸. Объект `Proxy` (`sysproxy`), реализующий те же параметры в виде свойств (properties). Свойства прокси (`http_proxy`, `https_proxy` и т.д.) -- объекты типа `Proxyconf` (инкапсулирующие параметры хоста, порта и аутентификации); свойство noproxy -- объект типа `Noproxy`, который позволяет преобразовывать прямые адреса в список и в строку и обратно. Синхронизация со словарем `localproxy` осуществляется двумя методами: `asdict()` сериализует объект `Proxy` в словарь, `from_dict()` -- применяет данные из словаря. При изменении каждого свойства вызываются соответствующие setter-методы, которые и передают управление на нижестроящий уровень -- объект `Sysenv`.
3. **Уровень** ❷. Класс `Sysenv` определяет основные методы для работы непосредственно с переменными среды и файлами, хранящими системные настройки. Для получения значения переменной среды (например, `HTTP_PROXY`) используется метод `get_sys_env()`. Для изменения переменной и записи ее в соответствующий файл -- метод `set_sys_env()`. Для удаления переменной (из памяти и соответствующих файлов) -- `unset_sys_env()`. Каждый из этих методов уже вызывает соответствующие низкоуровневые методы.
4. **Уровень** ❶. На самом нижнем уровне используются специальные методы для работы с реестром Windows (чтение, запись, создание и удаление переменных в соответствующих ветках) и файлами Linux / Mac (чтение, изменение и удаление экспортов переменных среды). Как я уже говорил, на Винде за прокси отвечает пользовательская ветка в реестре (независимо от наличия прав администратора у текущего пользователя). На Unix'ах приложение по умолчанию работает с локальным файлом пользователя (зависящем от выбранного шелла, например, у меня это `~/.zshrc`) и дополнительно, если есть права суперпользователя, также синхронизирует все переменные с системным файлом (по умолчанию -- `/etc/environment`).
Стоит отметить еще два момента:
* приложение реализовано с использованием многопоточности: операции работы с настройками прокси выполняются в отдельных потоках, чтобы не "замораживать" GUI
* переключатель `Enable` на первой вкладке сразу применяет настройки (без нажания `Apply`) -- это было так задумано в рамках идеи "one-click switch"
Ручное управление переменными среды
-----------------------------------
Пока я отлаживал утилиту, я незаметно для себя реализовал еще один виджет для просмотра и управления всех переменных среды. При помощи этого инструмента я создавал, удалял и изменял произвольные переменные, следя, как программа работает с системными файлами. Позже я решил добавить эту возможность в само приложение и разместил кнопку `Env variables` на странице `Settings`.
Нажав на Env variables, попадаем в редактор переменных среды.Интерфейс до предела минималистичен. Я даже не буду ничего описывать, просто дам скрин :)
Эта "утилита в утилите" может применяться вместно штатных инструментов ОС.
Справочная документация
-----------------------
Она есть :) По кнопке `Help | Open docs` открывается HTML-справка в браузере.
Справочная документация: титульная страницаВесь код подробно прокомментирован, что позволяет пользоваться [Doxygen](https://www.doxygen.nl/index.html) для генерации документации для разработчиков:
На этом всё! Буду рад, если кому-то инструмент окажется полезным. Также можно направлять предложения в комментариях👇 или через [страницу репозитория](https://github.com/S0mbre/proxen/issues). | https://habr.com/ru/post/646407/ | null | ru | null |
# Расширяем класс Imagick
Приветствую всех своих первых читателей!
#### Завязка
Написать эту самую первую статью меня толкнул всего один единственный баг в библиотеки Imagick, который отнял у меня некоторое время.
Началось всё с того, что была задача написать некий класс на php для работы с изображениями. Решил прибегнуть к помощи ImageMagick и к расширению Imagick.
Сам класс Imagick имеет обширное количество методов, однако требовалось расширить его и добавить собственные методы, такие, как проверка существования кеша изображения и получения пути к нему, собственно само кеширование ну и некоторые другие вспомогательные.
Для этих целей был написан нехитрый класс:
```
php
namespace app;
class Images extends \Imagick {
private $_filePath = null;
private $_cacheFile = null;
// переопределенный метод
public function readImage($filePath) {
$this-_filePath = $filePath;
parent::readImage($this->_filePath);
}
// что-то от себя
public function myMethod() {
}
// дальше идёт продолжение кода...
?>
```
Теперь давайте разберёмся, почему этот класс работать НЕ будет.
#### Кульминация
Причиной неработоспособности данного кода состоит в том, что член этого класса "\_filePath", как и любой другой, будет иметь значение NULL. В этом и заключается баг [№59565](https://bugs.php.net/bug.php?id=59565)
Проблема оказалось решающей, ведь без использования собственных переменных мой класс терял всякий смысл.
#### Развязка
Требуется решить данную проблему таким способом, чтобы сохранить весь функционал, гибкость и, при выходе стабильного релиза Imagick можно было бы с минимальным вмешательством в коде перейти на «правильный путь»
Для этого мне пришла в голову использовать магический метод \_\_call, который вызывается тогда, когда вызываемый метод нашего класса не найден. В итоге класс получился следующим:
```
php
namespace app;
class Images {
private $_filePath = null;
private $_cacheFile = null;
private $_Imagick = null;
public function __construct() {
$this-_Imagick = new \Imagick();
}
// переопределенный метод
public function readImage($filePath) {
$this->_filePath = $filePath;
$this->_Imagick->readImage($this->_filePath);
}
// что-то от себя
public function myMethod() {
}
// то, что решит проблему
public function __call($name, $args) {
return call_user_func_array(array($this->_Imagick, $name), $args);
}
// дальше идёт продолжение кода...
?>
```
#### Выводы
Согласен с тем, что метод решения какой-то костыльный, однако в этой ситуации подходит больше всего.
После стабильного релиза, в классе будет достаточно добавть " extends \Imagick" и убрать методы "\_\_call"
и конструктор.
[PECL Imagick](http://pecl.php.net/package/imagick) — на сегодня, версия 3.0.1 является последней стабильной. В версии «3.1.0b1» баг уже пофиксен. Кроме этого, есть уже и «3.1.0RC1». Однако когда выйдет стабильная версия — пока не известно.
Буду рад услышать тех, кто уже встречался с этой проблемой и их варианты решения. | https://habr.com/ru/post/138179/ | null | ru | null |
# Kubernetes в ДомКлик: как спать спокойно, управляя кластером на 1000 микросервисов
Меня зовут Виктор Ягофаров, и я занимаюсь развитием Kubernetes-платформы в компании ДомКлик в должности технического руководителя разработки в команде Ops (эксплуатация). Я хотел бы рассказать об устройстве наших процессов Dev <-> Ops, об особенностях эксплуатации одного из самых больших k8s-кластеров в России, а также о DevOps/SRE-практиках, которые применяет наша команда.
#### Команда Ops
В команде Ops на данный момент работает 15 человек. Трое из них отвечают за офис, двое работают в другом часовом поясе и доступны, в том числе, и ночью. Таким образом, всегда кто-то из Ops находится у монитора и готов среагировать на инцидент любой сложности. Ночных дежурств у нас нет, что сохраняет нашу психику и даёт возможность всем высыпаться и проводить досуг не только за компьютером.
Компетенции у всех разные: сетевики, DBA, специалисты по стеку ELK, Kubernetes-админы/разработчики, специалисты по мониторингу, виртуализации, железу и т.д. Объединяет всех одно — каждый может заменить в какой-то степени любого из нас: например, ввести новые ноды в кластер k8s, обновить PostgreSQL, написать pipeline CI/CD + Ansible, автоматизировать что-нибудь на Python/Bash/Go, подключить железку в ЦОД. Сильные компетенции в какой-либо области не мешают сменить направление деятельности и начать прокачиваться в какой-нибудь другой области. Например, я устраивался в компанию как специалист по PostgreSQL, а сейчас моя главная зона ответственности — кластеры Kubernetes. В команде любой рост только приветствуется и очень развито чувство плеча.
Кстати, мы [хантим](https://habr.com/ru/company/domclick/vacancies/). Требования к кандидатам довольно стандартные. Лично для меня важно, чтобы человек вписывался в коллектив, был неконфликтным, но также умел отстаивать свою точку зрения, желал развиваться и не боялся делать что-то новое, предлагал свои идеи. Также, обязательны навыки программирования на скриптовых языках, знание основ Linux и английского языка. Английский нужен просто для того, чтобы человек в случае факапа мог загуглить решение проблемы за 10 секунд, а не за 10 минут. Со специалистами с глубоким знанием Linux сейчас очень сложно: смешно, но два кандидата из трех не могут ответить на вопрос «Что такое Load Average? Из чего он складывается?», а вопрос «Как собрать core dump из сишной программы» считают чем-то из мира сверхлюдей… или динозавров. С этим приходится мириться, так как обычно у людей сильно развиты другие компетенции, а «линуксу» мы научим. Ответ на вопрос «зачем это всё нужно знать DevOps-инженеру в современном мире облаков» придётся оставить за рамками статьи, но если тремя словами: всё это нужно.
#### Команда Tools
Немалую роль в автоматизации играет команда Tools. Их основная задача — создание удобных графических и CLI-инструментов для разработчиков. Например, наша внутренняя разработка Confer позволяет буквально несколькими кликами мыши выкатить приложение в Kubernetes, настроить ему ресурсы, ключи из vault и т.д. Раньше был Jenkins + Helm 2, но пришлось разработать собственный инструмент, чтобы исключить копи-пасту и привнести единообразие в жизненный цикл ПО.
Команда Ops не пишет пайплайны за разработчиков, но может проконсультировать по любым вопросам в их написании (у кое-кого еще остался Helm 3).
#### DevOps
Что касается DevOps, то мы видим его таким:
Команды Dev пишут код, выкатывают его через Confer в dev -> qa/stage -> prod. Ответственность за то, чтобы код не тормозил и не сыпал ошибками, лежит на командах Dev и Ops. В дневное время реагировать на инцидент со своим приложением должен, в первую очередь, дежурный от команды Ops, а в вечернее и ночное время дежурный админ (Ops) должен разбудить дежурного разработчика, если он точно знает, что проблема не в инфраструктуре. Все метрики и алерты в мониторинге появляются автоматически или полуавтоматически.
Зона ответственности Ops начинается с момента выкатки приложения в прод, но и ответственность Dev на этом не заканчивается — мы делаем одно дело и находимся в одной лодке.
Разработчики консультируют админов, если нужна помощь в написании админского микросервиса (например, Go backend + HTML5), а админы консультируют разработчиков по любым инфраструктурным вопросам, или вопросам, связанным с k8s.
Кстати, у нас вообще нет монолита, только микросервисы. Их количество пока что колеблется между 900 и 1000 в prod k8s-кластере, если измерять по количеству *deployments*. Количество подов колеблется между 1700 и 2000. Подов в prod-кластере сейчас около 2000.
Точные числа назвать не могу, так как мы следим за ненужными микросервисами и выпиливаем их в полуавтоматическом режиме. Следить за ненужными сущностями в k8s нам помогает [useless-operator](https://github.com/Nastradamus/useless-operator), что здорово экономит ресурсы и деньги.
Управление ресурсами
---------------------
#### Мониторинг
Краеугольным камнем в эксплуатации большого кластера становится грамотно выстроенный и информативный мониторинг. Мы пока не нашли универсального решения, которое покрыло бы 100 % всех «хотелок» по мониторингу, поэтому периодически клепаем разные кастомные решения в этой среде.
* **Zabbix**. Старый добрый мониторинг, который предназначен, в первую очередь, для отслеживания общего состояния инфраструктуры. Он говорит нам, когда нода умирает по процу, памяти, дискам, сети и так далее. Ничего сверхъестественного, но также у нас есть отдельный DaemonSet из агентов, с помощью которых, например, мы мониторим состояние DNS в кластере: ищем тупящие поды coredns, проверяем доступность внешних хостов. Казалось бы, зачем ради этого заморачиваться, но на больших объемах трафика этот компонент является серьезной точкой отказа. Ранее я уже [описывал](https://habr.com/ru/company/domclick/blog/495450/), как боролся с производительностью DNS в кластере.
* **Prometheus Operator**. Набор различных экспортеров даёт большой обзор всех компонентов кластера. Далее визуализируем всё это на больших дашбордах в Grafana, а для оповещений используем alertmanager.
Еще одним полезным инструментом для нас стал [list-ingress](https://github.com/Nastradamus/list-ingress). Мы написали его после того, как несколько раз столкнулись с ситуацией, когда одна команда перекрывает своими путями Ingress другой команды, из-за чего возникали ошибки 50x. Сейчас перед деплоем на прод разработчики проверяют, что никого не заденут, а для моей команды это хороший инструмент для первичной диагностики проблем с Ingress'ами. Забавно, что сначала его написали для админов и выглядел он довольно «топорно», но после того, как инструмент полюбился dev-командам, он сильно преобразился и стал выглядеть не как «админ сделал веб-морду для админов». Скоро мы откажемся от этого инструмента и подобные ситуации будут валидироваться еще до выкатки пайплайна.
#### Ресурсы команд в «Кубе»
Прежде чем приступить к примерам, стоит объяснить, как у нас работает выделение ресурсов для *микросервисов*.
Чтобы понимать, какие команды и в каких количествах используют свои *ресурсы* (процессор, память, локальный SSD), мы выделяем на каждую команду свой *namespace* в «Кубе» и ограничиваем его максимальные возможности по процессору, памяти и диску, предварительно обговорив нужды команд. Соответственно, одна команда, в общем случае, не заблокирует для деплоя весь кластер, выделив себе тысячи ядер и терабайты памяти. Доступы в namespace выдаются через AD (мы используем RBAC). Namespace'ы и их лимиты добавляются через пул-реквест в GIT-репозиторий, а далее через Ansible-пайплайн всё автоматически раскатывается.
Пример выделения ресурсов на команду:
```
namespaces:
chat-team:
pods: 23
limits:
cpu: 11
memory: 20Gi
requests:
cpu: 11
memory: 20Gi
```
#### Реквесты и лимиты
В «Кубе» *Request* — это количество гарантированно зарезервированных ресурсов под *pod* (один или более докер-контейнеров) в кластере. Limit — это негарантированный максимум. Часто можно увидеть на графиках, как какая-то команда выставила себе слишком много реквестов для всех своих приложений и не может задеплоить приложение в «Куб», так как под их namespace все request'ы уже «потрачены».
Правильный выход из такой ситуации: смотреть реальное потребление ресурсов и сравнивать с запрошенным количеством (Request).
На скриншотах выше видно, что «запрошенные» (Requested) CPU подбираются к реальному количеству потоков, а Limits могут превышать реальное количество потоков центральных процессоров =)
Теперь подробно разберём какой-нибудь namespace (я выбрал namespace kube-system — системный namespace для компонентов самого «Куба») и посмотрим соотношение реально использованного процессорного времени и памяти к запрошенному:
Очевидно, что памяти и ЦПУ зарезервировано под системные службы намного больше, чем используется реально. В случае с kube-system это оправдано: бывало, что nginx ingress controller или nodelocaldns в пике упирались в CPU и отъедали очень много RAM, поэтому здесь такой запас оправдан. К тому же, мы не можем полагаться на графики за последние 3 часа: желательно видеть исторические метрики за большой период времени.
Была разработана система «рекомендаций». Например, здесь можно увидеть, каким ресурсам лучше бы поднять «лимиты» (верхняя разрешенная планка), чтобы не происходило «троттлинга» (throttling): момента, когда под уже потратил CPU или память за отведенный ему квант времени и находится в ожидании, пока его «разморозят»:
А вот поды, которым следовало бы умерить аппетиты:
Про *троттлинг* + мониторинг ресурсов можно написать не одну статью, поэтому задавайте вопросы в комментариях. В нескольких словах могу сказать, что задача автоматизации подобных метрик весьма непростая и требует много времени и эквилибристики с «оконными» функциями и «CTE» Prometheus / VictoriaMetrics (эти термины взяты в кавычки, так как в PromQL почти что нет ничего подобного, и приходится городить страшные запросы на несколько экранов текста и заниматься их оптимизацией).
В итоге, у разработчиков есть инструменты для мониторинга своих namespaces в «Кубе», и они способны сами выбирать, где и в какое время у каких приложений можно «подрезать» ресурсы, а каким подам можно на всю ночь отдать весь CPU.
#### Методологии
В компании, как сейчас *модно*, мы придерживаемся DevOps- и *SRE*-практик. Когда в компании 1000 микросервисов, около 350 разработчиков и 15 админов на всю инфраструктуру, приходится «быть модным»: за всеми этими «базвордами» скрывается острая необходимость в автоматизации всего и вся, а админы не должны быть бутылочным горлышком в процессах.
Как Ops, мы предоставляем различные метрики и дашборды для разработчиков, связанные со скоростью ответа сервисов и их ошибками.
Мы используем такие методологии, как: [RED](https://thenewstack.io/monitoring-microservices-red-method/), [USE](http://www.brendangregg.com/usemethod.html) и [Golden Signals](https://medium.com/forepaas/distributed-monitoring-101-the-four-golden-signals-305bbbc33d35), комбинируя их вместе. Стараемся минимизировать количество дашбордов так, чтобы с одного взгляда было понятно, какой сервис сейчас деградирует (например, коды ответов в секунду, время ответа по 99-перцентилю), и так далее. Как только становятся нужны какие-то новые метрики для общих дашбордов, мы тут же их рисуем и добавляем.
*Я не рисовал графики уже месяц. Наверное, это хороший знак: значит большинство «хотелок» уже реализованы. Бывало, что за неделю я хотя бы раз в день рисовал какой-нибудь новый график.*
Получившийся результат ценен тем, что теперь разрабы довольно редко ходят к админам с вопросами «где посмотреть какую-то метрику».
Внедрение *Service Mesh* не за горами и должно сильно облегчить всем жизнь, коллеги из Tools уже близки к внедрению абстрактного «Istio здорового человека»: жизненный цикл каждого HTTP(s)-запроса будет виден в мониторинге, и всегда можно будет понять «на каком этапе всё сломалось» при межсервисном (и не только) взаимодействии. Подписывайтесь на новости хаба компании ДомКлик. =)
Поддержка инфраструктуры Kubernetes
-----------------------------------
Исторически сложилось так, что мы используем патченную версию *Kubespray* — Ansible-роль для разворачивания, расширения и обновления Kubernetes. В какой-то момент из основной ветки была выпилена поддержка non-kubeadm инсталляций, а процесс перехода на kubeadm предложен не был. В итоге, компания Southbridge сделала свой форк (с поддержкой kubeadm и быстрым фиксом критических проблем).
Процесс обновления всех кластеров k8s выглядит так:
* Берем *Kubespray* от Southbridge, сверяем с нашей веткой, мерджим.
* Выкатываем обновление в *Stress*-«Куб».
* Выкатываем обновление по одной ноде (в Ansible это «serial: 1») в *Dev*-«Куб».
* Обновляем *Prod* в субботу вечером по одной ноде.
В будущем есть планы заменить *Kubespray* на что-нибудь более быстрое и перейти на *kubeadm*.
Всего у нас три «Куба»: Stress, Dev и Prod. Планируем запустить еще один (*hot standby*) Prod-«Куб» во втором ЦОДе. *Stress* и *Dev* живут в «виртуалках» (oVirt для Stress и VMWare cloud для Dev). *Prod*-«Куб» живёт на «голом железе» (bare metal): это одинаковые ноды с 32 CPU threads, 64-128 Гб памяти и 300 Гб SSD RAID 10 — всего их 50 штук. Три «тонкие» ноды выделены под «мастера» *Prod*-«Куба»: 16 Гб памяти, 12 CPU threads.
Для прода предпочитаем использовать «голое железо» и избегаем лишних прослоек вроде *OpenStack*: нам не нужны «шумные соседи» и CPU *steal time*. Да и сложность администрирования возрастает примерно вдвое в случае in-house OpenStack.
Для CI/CD «Кубовых» и других инфраструктурных компонентов используем отдельный GIT-сервер, Helm 3 (перешли довольно болезненно с Helm 2, но очень рады опции *atomic*), Jenkins, Ansible и Docker. Любим feature-бранчи и деплой в разные среды из одного репозитория.
### Заключение
Вот так, в общих чертах, в компании ДомКлик выглядит процесс DevOps со стороны инженера эксплуатации. Статья получилась менее технической, чем я ожидал: поэтому, следите за новостями ДомКлик на Хабре: будут более «хардкорные» статьи о Kubernetes и не только. | https://habr.com/ru/post/501122/ | null | ru | null |
# Разрешаем доступ к веб-серверу только через CloudFlare (iptables)
Cloudflare — отличная штука для защиты сайтов от разных компьютерных жуликов — хацкеров. Однако, если они всё же узнали как-то оригинальный IP веб-сервера, на котором расположен сайт, они как минимум будут пробовать атаковать его по IP, минуя прокси. Можно городить редиректы, слать NGINX-ом ресеты кодом 444 при попытке зайти на несуществующие домены, но самый железный выход из ситуации такой: открыть http/https трафик на сервер только для IP адресов нашей защитной прокси.
Кстати, данный метод также может сделать отчасти бесполезным разного рода сайты вроде [crimeflare.org](http://crimeflare.org). Ну узнал «сыщик», что домен когда-то был доступен по такому-то IP — проверить, там ли он ещё, попытавшись зайти директом на IP:443 или IP:80 будет уже бесполезно.
А если на сервере закрыть вообще все порты, отключить ICMP и реализовать доступ только через IPMI/VNC, никто не узнает, что на нашем IP вообще что-то существует.
Сделаем это в iptables.
У CloudFlare есть огромное количество адресов, но все они ужимаются в небольшое количество подсетей. Предвидя такой запрос, ребята [опубликовали статью](https://support.cloudflare.com/hc/en-us/articles/200169166-How-do-I-whitelist-Cloudflare-s-IP-addresses-in-iptables-), рассказывающую, где можно найти их актуальные подсети и даже что писать в iptables. Одна проблема — делать это предполагается вручную, что довольно неудобно и ненадёжно: адресация в CloudFlare может меняться со временем, и когда-нибудь может получиться так, что прокся, расположенная на новых адресах, будет не разрешена у вас на сервере. Соответственно клиенты, чьи сесссии будут проходить через эти новые адреса, не смогут зайти на ваш сайт.
К счастью, проблема автоматизируема. Итак:
**1.** Запрещаем в iptables весь HTTP/HTTPS трафик:
```
iptables -I INPUT 1 -p tcp -m multiport --dports http,https -j DROP
```
**2.** Кладём куда-нибудь, например, по /root/cloudflare-update.sh скрипт cloudflare-update.sh со следующим содержимым:
```
#!/bin/bash
while read ip ; do iptables -D INPUT -p tcp -m multiport --dports http,https -s "$ip" -j ACCEPT ; done <<< "$(curl https://www.cloudflare.com/ips-v4)"
while read ip ; do iptables -I INPUT -p tcp -m multiport --dports http,https -s "$ip" -j ACCEPT ; done <<< "$(curl https://www.cloudflare.com/ips-v4)"
iptables-save > /etc/iptables/rules.v4
```
То есть мы удаляем все существующие записи, добавленные ранее, заново добавляем всё, что имеется в списке адресов CloudFlare. Таким образом избегаем дубликатов правил. К конце — сохраняемся.
**3.** Делаем скрипт исполняемым:
```
chmod +x /root/cloudflare-update.sh
```
**4.** В крон (например, в конец файла /etc/crontab) добавляем задание обновлять адреса каждые 12 часов:
```
0 */12 * * * root /root/cloudflare-update.sh &> /dev/null
```
**Всё!** Теперь попасть по 80 и 443 портам на ваш сервер можно только через прокси, т.к. в любой момент времени только адреса, принадлежащие прокси, разрешены на сервере. | https://habr.com/ru/post/414837/ | null | ru | null |
# CSS разработчики — почему они нужны миру?
*[Аудио версия на русском (яндекс.музыка)](https://music.yandex.ru/album/10034426/track/63612500?lang=en) / [iTunes](https://podcasts.apple.com/us/podcast/5-css-%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%87%D0%B8%D0%BA%D0%B8-%D0%BF%D0%BE%D1%87%D0%B5%D0%BC%D1%83-%D0%BE%D0%BD%D0%B8-%D0%BD%D1%83%D0%B6%D0%BD%D1%8B-%D0%BC%D0%B8%D1%80%D1%83/id1499128651?i=1000468116230)*
В последние десять лет CSS сильно разросся путём добавления всё большего числа возможностей, таким образом постепенно становясь довольно сложным и запутанным. CSS наших дней сильно отличается от CSS десятилетия 2001-2010 годов.
Прежде чем я начну объяснять, почему миру нужны разработчики CSS, мы должны вернуться назад и посмотреть на историю CSS.
> *Disclaimer:
>
> Это вольный перевод статьи.
Стиль повествования может не совпадать с таковым автора.
Никакие идеи, домыслы, факты или суждения не были убраны или добавлены.*
>
>
История CSS
-----------
В десятилетие 2001-2010 годов, когда интернет завоевывал мир, CSS стоял на месте. Internet Explorer версии 6-7-8 был ведущим браузером. Microsoft в то время не уделяла большого внимания спецификациям CSS, не проявляла никакого интереса к добавлению в него новых функций. CSS оставался на уровне версии 2.1 все эти годы.
С 2007 года начали появляться современные браузеры Firefox и Chrome. Даже в это время мы всё еще должны были поддерживать Internet Explorer. Это сдерживало наше развитие. Будучи главным правящим браузером в то время, IE установил практически несуществующую, близкую к нулю, скорость разработки CSS. Это был «темный век» интернета.
Основополагающие события новой эры CSS
--------------------------------------
Я был разработчиком в то время, и потому видел два важных события которые изменили мир CSS и веба в целом:
1. **Начало эры смартфонов (29 июня 2007 года)** — всё началось с выпуска первого iPhone. Этот релиз вызвал необходимость поддержки новых функций CSS, которые соответствовали бы новой категории веб-устройств.
2. **Выпуск браузера Chrome (2 сентября 2008 года)** — Chrome был новым браузером, который начинался как десктоп приложение.
До тех пор Internet Explorer был главным правителем интернета и диктовал его развитие.
Почему Frontend разработчики имеют дело и с CSS, и с JavaScript
---------------------------------------------------------------
В то время была довольно распространена идея того, что Frontend разработчики должны управлять всеми возможностями клиента. Тогда было только несколько правил CSS. В настоящее время CSS расширился, и такое видение больше не актуально.
CSS 3, HTML 5 и JavaScript: новая эра
-------------------------------------
Трудно сказать точно, когда появился CSS 3, поскольку он разрабатывался с 1999 года. Реальная поддержка в интернете началась в 2011 году. В то время Chrome & Firefox увеличивали свою долю рынка. Смартфоны становились очень популярными. Имея собственные браузеры, все они начали поддерживать первые новые функции CSS 3.
Эти изменения привели к снижению популярности Internet Explorer. В то время он все ещё был значительным браузером, однако, Microsoft понял, что должен начать уделять внимание спецификациям и разработке CSS. Они выпустили Internet Explorer 9.
Новый CSS
---------
**CSS 3 теперь 10 лет, почему нет CSS 4?** CSS 3, в отличие от CSS 2.1, является открытым стандартом. Благодаря этому он постоянно обновляется. Нет никакой необходимости называть новую версию «CSS 4», так как CSS 3 — это непрерывная разработка, версия на все времена.
С 2011 года каждое обновление браузера включает в себя новые функции CSS. В последние несколько лет большинство браузеров — Chrome, Firefox, Opera, Edge — обновляются почти каждый месяц (Safari обновляется в основном раз в год). Эта частота означает, что мы получаем новые функции CSS почти сразу же, как они появляются.
Что нового появилось в CSS за последние 10 лет
----------------------------------------------
В последние десять лет появилось много новых спецификаций для разных типов
модулей CSS, например:
1. **Layout** — адаптивный дизайн, Flexbox, CSS-гриды, многоколоночная компоновка, writing mode и [логические параметры](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Logical_Properties/Basic_concepts);
2. **Typography** — пользовательские шрифты, font-variant, line-breaking;
3. **Shapes & Graphics** — фильтры, маски, blend-mode, clip-path, shapes и т.д.
4. **Animations & Transforms** — CSS/SVG анимация, transitions, transforms, will-change.
5. **Units** — viewport величины vw/vh/vmin/vmax, rem, функция calc(), размерные метки contain, fit-content, min-content, max-content;
6. **CSS preprocessor** — sass, less, stylus, postCSS
7. **и многое другое** — работа с SVG, `@support`, CSS переменные и тому подобное.
Можно заметить, что многие новые функции попадают под ответственность frontend разработчика. Это значит, что он должен получить опыт во всех из них. А ведь это даже не полный список.
В реальной жизни веб-разработчика практически невозможно иметь даже базовый уровень понимания всех этих новых функций.
Помимо этого, параллельно развивался JavaScript. И развивался он, возможно, даже больше, чем CSS. Это делает его ещё более трудным для одного человека, чтобы идти в ногу со всеми разработками.
Большая ошибка веб-индустрии
----------------------------
Эта ситуация, в которой frontend разработчики не смогли справиться с новой сложностью в CSS, создала новое движение под названием «Как не изучать CSS».
> Новое движение под названием «Как не изучать CSS»
Первые CSS фреймворки
---------------------
Начало этой ошибки положили фреймворки, такие как Bootstrap и Foundation. Первый выпуск каждого из них состоялся в 2011 году. Эта конкретная дата не случайна — это были первые годы CSS3, адаптивного дизайна, мобильных веб-сайтов и кроссбраузерной вёрстки.
Я никогда не пытался глубоко погрузиться в Bootstrap, так как мне никогда не нравилось его несемантическое соглашение об именовании CSS. Помогая другим веб-разработчикам в [сообществе](https://www.facebook.com/groups/css.masters.israel/), я быстро понял, что Bootstrap подходит только для тех случаев, когда вы используете его как есть, не пытаясь настроить под себя.
*Bootstrap HTML — большинство классов несемантичны.*
Angular 2: первый JavaScript-согласованный фреймворк
----------------------------------------------------
Новый Angular стал первым кто ввел инкапсулированные стили. Это был способ избавить неопытного веб-разработчика от необходимости понимать каскадирование CSS. Используя этот метод, вы можете создавать глобальные стили и при этом иметь локальные стили для каждого компонента.
Из всех различных идей разработки идея инкапсулированных стилей, с моей точки зрения, является хорошей, потому что вы все еще можете создавать как глобальные стили, так и инкапсулированные стили для компонентов. Кроме того, у нас все ещё есть разделение проблем для CSS/SASS, для HTML и для JavaScript. Мы можем наслаждаться простым способом загрузки только необходимых стилей.
React — смерть семантики!
-------------------------
React развивает эту идею дальше и пишет весь HTML и CSS внутри JavaSscript. Цель создания многоразовых стилей умерла с React’ом. Он автоматически генерирует имена классов CSS; таким образом, код становится нечитаемым и невозможным для понимания, как из-за имен классов CSS, так и из-за несемантического HTML. С моей точки зрения, это похоже на то, как CSS и HTML писались в начале интернета, когда не имело значения, как выглядели CSS или HTML, пока они работали.
*React — нечитаемые имена css классов*
**Почему это так плохо?** Когда у вас есть реальная проблема с CSS, а обычный frontend разработчик не может её решить и нуждается в опытном CSS-разработчике, запутанный код React стоит на пути. Да, оба веб-разработчика могут решить её вместе, но это отнимает время у двух опытных веб-разработчиков.
Очнитесь!
---------
**Frontend разработчики не тащат в CSS!** Кто-то должен сказать это вслух! Да, я знаю, что это грубое обобщение и поэтому не на 100% правильно, но я не пытаюсь быть на 100% правильным.
**Прежде чем я продолжу, вы должны узнать обо мне немного больше.**
*Очнитесь — frontend разработчики не тащат в CSS!*
Кто я есть такой
----------------
Я начинал как frontend разработчик в начале 2007 года.
В начале 2012 года я почти полностью перестал писать JavaScript, основная причина заключалась в том, что я очень любил CSS, а JavaScript — гораздо меньше.
С 2012 года и до настоящего времени, поскольку я был сосредоточен только на CSS, я развил преимущество в этой области. За эти годы я написал много [статей о CSS](https://eladsc.com/tag/articles/), основал местное [CSS сообщество на 5,000 участников](https://www.facebook.com/groups/css.masters.israel/) и провел [бесчисленное количество бесед](https://eladsc.com/tag/talks/) на встречах, семинарах и конференциях.
*Я выступаю на конференции ConFrontJS 2019, в Варшаве, Польша*
**Зачем я тебе все это рассказываю?** Потому что я все ещё своего рода единорог в своей стране и в веб-индустрии. Да, я получаю много благодарностей, но есть большое но! Хотя это работает для меня, потому что я хорошо известен в веб-индустрии моей страны, другим трудно стать такими же, потому что веб-индустрия все еще пытается сохранить **«старое название Frontend developer»** (что означает, попробуйте написать первоклассный JavaScript и CSS).
В моей стране я знаю самых лучших Frontend разработчиков. Поскольку я заинтересован в понимании веб-индустрии, я всегда спрашиваю этих лучших Frontend талантов, считают ли они, что они хороши в CSS. Их ответ продолжает удивлять меня — большинство из них ощущают себя неуверенными в CSS, и они всегда удивляются разработчикам, таким как я, которые любят CSS.
Веб-индустрия должна измениться
-------------------------------
Несмотря на то, что это работало до 2010 года, это не может продолжаться в 2020 году. Веб-индустрия изменилась, и пришло время созреть и отказаться от ранних названий должностей в веб-индустрии и перейти к новому позиционированию.
Позиционированию, которое будет соответствовать потребностям нашего времени. Поначалу крупным компаниям. Затем всем остальным.
В чём интерес компаний?
-----------------------
В 2020 году CSS является важным навыком. В то время как компании пытаются сэкономить деньги, они могут в конечном итоге потратить больше денег. За годы работы веб-разработчиком я видел, как разработчики тратили слишком много времени на то, что специализированный CSS разработчик мог бы решить за 10 минут и с более производительным кодом.
> В 2020 году CSS — важный навык.
Какими могут быть новые названия должностей?
--------------------------------------------
За последние восемь лет я несколько раз менял должность. Я делал это, чтобы объяснить свои способности людям, которые видят [мой профиль в LinkedIn](https://www.linkedin.com/in/eladshechter/).
Сначала я называл себя CSS Master (по названию сообщества, которое я основал — [CSS Masters Israel](https://www.facebook.com/groups/css.masters.israel/)). Было забавно видеть вскоре после этого объявления о работе с таким заголовком. Я понял что есть компании которые нуждаются в CSS разработчике, но не знают как его адекватно назвать.
Позже я несколько раз менял название своей должности (UI / CSS — Developer / Interface Developer/ Engineer / Architect / Expert), пытаясь вписать свои способности в название работы.
Не будьте только CSS разработчиком
----------------------------------
В наши дни у нас есть несколько типов разработчиков, которые специализируются на визуальной части, такой как CSS и, к примеру, SVG. Я попытаюсь **определить эти типы здесь**:
**CSS Developer** — это название предназначено для специалистов среднего звена в CSS. Это разработчики, которые могут взять дизайн и легко преобразовать его в CSS.
**CSS Architect** — эта категория предназначена для разработчиков, таких как я, которые, помимо эффективного построения CSS, являются экспертами в планировании разделения CSS и его построения в сложную строительную структуру. В отличие от разработчиков CSS, архитекторы CSS более опытны и знают, как умно масштабировать большие проекты, с дополнительными CSS разработчиками, работающими в их команде. Кроме того, они общаются с другими веб-разработчиками, менеджерами проектов и веб-дизайнерами.
*Разнообразие прекрасно!*
**CSS Animations Developer** — в наши дни мы можем улучшить пользовательский опыт почти без усилий, используя CSS-анимации или SVG-анимации, тем самым превращая хороший проект в фантастический. Эта работа может подойти крупным компаниям.
Это наиболее распространенные потребности для 2020 года, но есть и другие типы специализированных разработчиков, такие как:
* [Sara Soueidan](https://www.sarasoueidan.com/), **SVG Expert**.
* [Diana Smith](https://diana-adrianne.com/purecss-pink/), её я бы назвал **CSS Artist**.
Их может быть больше — возможности безграничны!
В заключение
------------
В этой статье я стремился повысить осведомленность о предмете, который, как мне кажется, еще не был освещён. Моя цель — направить веб-индустрию в нужное русло.
Кроме моей статьи, есть еще статьи на эту тему, с других точек зрения:
* The Great Divide, статья на сайте CSS Tricks: <https://css-tricks.com/the-great-divide/>
* What CSS Developers Do and Why You Need One, статья на сайте TopTal.com: <https://www.toptal.com/css/why-you-need-a-css-developer>
Напоследок
----------
Если вам понравилась эта статья, я был бы признателен, если бы вы поделились ею с другими, чтобы эта идея могла поднять новую осведомленность в веб-индустрии.
Кто я есть такой?
-----------------
Моё имя Elad Shechter, я Web разработчик, специализирусь на архитектуре CSS и HTML. Работаю для сайта [investing.com](https://www.investing.com/).
Мой [Twitter](https://twitter.com/eladsc) и [вебсайт](https://eladsc.com/).
 | https://habr.com/ru/post/492822/ | null | ru | null |
# STM32F4: GNU AS: Мигаем светодиодом (Оживление) (Часть 2)
Это вторая публикация на тему программирования микроконтроллеров STM32 на языке ассемблера, первая часть находится [Здесь](http://habrahabr.ru/post/274541/).
Если у вас возникли вопросы или пожелания, но вы не можете здесь писать то переходите в VK: [vk.com/topic-200545792\_46641967](https://vk.com/topic-200545792_46641967)
Дополнительно, обращаю внимание что сейчас (2021 год) написан небольшой редактор для программирования на ассемблере, в котором так же был написан код аналогичной функциональности, но с использованием «плюшек и удобных подушек» редактора, посмотреть конкретно про написание мигалки в нем можно в статье [Assembler Editor Plus: Использование модулей](https://habr.com/ru/post/543200/) (возможно в процессе прочтения нужно будет пройти еще по нескольким ссылкам где будет описано про функциональность редактора в общем, и как выполняется создание проекта, компиляция, прошивка, отладка)
Итак, в прошлой статье мы создали инструмент при помощи которого, можно произвести компиляцию и компоновку (линковку) проекта на языке ассемблера. Теперь напишем программу за работой которой можно наблюдать.
Нам понадобиться знание языка ассемблера микроконтроллера STM32. Чтобы было проще начать если Вы вообще не сталкивались и не знаете что почитать «по теме» то могу предложить следующие источники:
[1] книгу **Джозеф Ю. Ядро Cortex-M3 Компании ARM. Полное руководство.**
.
Ссылку на книгу давать не буду, она легко гуглится в любом желаемом формате, или покупается на том же [озоне](http://www.ozon.ru/context/detail/id/32658813/).
Несмотря на другое ядро (у микроконтроллера STM32F4xx — Cortex-M4) инструкции ассемблера у всего семейства одинаковы, русский же язык повествования книги сможет облегчить задачу первоначального «вхождения».
Обращаю внимание, что некоторые русскоязычные ресурсы и указанная мною книга тоже (!), могут содержать небольшие неточности и ошибки, поэтому не ленитесь проверять те или положения по другим источникам и даташитам производителя
[2] Статью "**Изучение системы команд процессора ARM**" с ресурса marsohod которая размещена [Здесь](http://marsohod.org/index.php/prodmarsohod2/amber-arm-soc/226-arm-instr).
В этой статье затронуты некоторые практические, но отнюдь не всегда очевидные аспекты использования инструкций ARM. В этой статье рассмотрены вопросы каким образом кодируются инструкции, наглядно показано откуда идут ограничения, где есть преимущества.
Далее идут англоязычные руководства и документы:
[3] **Cortex-M4 Devices. Generic User Guide**. Скачать можно с сайта источника, размещено [Здесь](http://infocenter.arm.com/help/topic/com.arm.doc.dui0553a/DUI0553A_cortex_m4_dgug.pdf) Система команд рассматривается в Chapter 3 «The Cortex-M4 Instruction Set», хотя несомненно необходимо этот документ попытаться почитать, выбирая информацию перекрестно с [1] (если знания английского не позволяют читать «напрямую»)
[4] **STM32F3 and STM32F4 Series Cortex-M4 programming manual**. Искать на st.com, прямая [Ссылка](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/programming_manual/DM00046982.pdf). Фактически это англоязычная версия книги [1], но читать ее все равно стоит, там есть примеры которых нет в [1].
[5] **RM0090. Reference manual. STM32F405/415, STM32F407/417, STM32F427/437 and STM32F429/439 advanced ARM-based 32-bit MCUs**. Искать тоже на st.com, прямая [Ссылка](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/reference_manual/DM00031020.pdf). Это руководство содержит в себе описание архитектуры микроконтроллера, его периферию, регистры управления ею.
---
Со своей стороны я сделаю лишь некоторые важные, на мой взгляд, замечания:
**1) О загрузке 32-ух разрядного значения в регистр.**
Как Вы уже узнали, регистры микроконтроллера 32-ух битные, между тем команды прямой загрузки в регистр 32-ух разрядного числа в системе команд микроконтроллера нет.
Выход который применяется всеми тривиален: загрузка верхних / нижних 16-ти бит слова отдельно командами **MOVW/MOVT**, например для R0:
```
MOVW R0, lower16
MOVT R0, upper16
```
Зачастую эту конструкцию даже объединяют в макрос, обычно называемый **MOV32**
```
.macro MOV32 regnum,number
MOVW \regnum,:lower16:\number
MOVT \regnum,:upper16:\number
.endm
```
Данные команды транслируются в 8 байт (2 слова по 32 бита) кода, и исполняются 2 такта процессора.
Еще один способ загрузки 32-ух битного значения в регистр это применение инструкции LDR Rg,=val32
```
LDR R0, =0x11223344 @ 32-ух битное значение
```
Данная инструкция не является отдельной инструкцией микроконтроллера, и при компиляции она заменяется на команду загрузки 32-ух битного значения из памяти по смещению относительно **PC** и константой в FLASH памяти с загружаемым значением:
```
LDR R0, [pc, offset to_M]
...
to_M: .word 0x11223344 @ 32-ух битное значение
```
Инструкция **LDR R0, [pc, offset ]** является 16-ти битной (Thumb формат), плюс 32 бита в памяти на хранение самой константы — ИТОГО расход памяти 48 бит (6 байт), вместе 64 бит (8 байт) при использовании набора команд макроса **MOV32**
По времени исполнения — команда LDR будет выполнена за ~~1~~ 2 такта (я был не прав, меня поправили, см. комментарии), ~~а~~ набор команд макроса MOV32 за 2 такта. Ограничение у способа загрузки 32-ух битного значения при помощи команды LDR rg, [pc, offset] в ~~«длине рук»~~ величине возможного используемого смещения.
К слову команда LDR R0, =var32 очень не корректно описана в [1], стр. 69, я зачеркнул некорректные суждения:
По всей видимости это ошибка при переводе, но как показывает практика — именно такие ошибки «в простом» способны попортить больше всего нервов, так как «копаясь в коде» в самую последнюю очередь заподозришь в неверной работе инструкцию в работе которой абсолютно все понятно. К слову в [4] команда LDR Rg, =val32 вообще не выделяется как отдельная, что логично, это обычная загрузка значения регистра из ячейки памяти. Этот момент нужно обязательно, что называется, прочувствовать — обязательно проверим и будем использовать.
**2) Условное исполнение операций**
~~Еще одна «фича» микроконтроллера (и вообще «камней» с ядром ARM) возможность указания в инструкциях условия исполнения по флагам (EQ/NE, CS/CC, MI/PL и так далее).
Однако не все так просто: для возможности условного исполнения инструкций они должны быть включены в так называемый **IT** блок.~~ (условие буду проверять, подробности смотрите в комментариях к статье)
Этот блок может в себя включать от 1 до 4 инструкций, инструкция **IT** подразумевает наличие после себя одной команды с условным исполнением, еще до трех команд (всего должно быть не более 4-х команд!) расширяется указанием условий:
1. «T» — для исполнения инструкции при выполнении условия указанного в инструкции IT
2. «E» — для исполнения инструкции при невыполнении условия указанного в инструкции IT
Примеры:
```
IT EQ @ одна команда, по флагу EQ (равенства нулю)
MOVEQ R0, 0x0000
ITT NE @ две команды, по флагу NE (не равенства нулю)
MOVNE R0, 0x0001
ADDNE R1, R0, R2
ITTE CS @ две команды по флагу CS (перенос), одна команда при СС (нет переноса)
MOVCS R0, R4
ADDCS R1, R0, R2
SUBCC R1, R4
```
Использование IT блока оптимизирует работу конвейера ядра микроконтроллера.
Дополнительно необходимо помнить, что например в отличие от инструкций ассемблера восьмибитных процессоров прошлых поколений — инструкции ARM влияют на флаги только если это напрямую указано суффиксом **«S»**
После команд которые влияют на флаги можно использовать **IT** блок. Для команд перехода (**B**) с условием **IT** блок не нужен.
**3) Программы на ядре ARM являются перемещаемыми !**
Если Вы внимательно изучали форматы инструкций — то наверное заметили полное отсутствие команд с прямой адресацией! нет ни загрузок из ячеек памяти с абсолютно указанным адресом, ни переходов! Все ячейки для операций записи/чтения, все переходы осуществляются по относительным адресам по смещению от **PC**, конечно при желании можно сделать переход по абсолютному адресу, но в общем случае программа является перемещаемой. Поэтому при анализе текста скомпилированной программы будьте готовы к тому, что в программе не будет абсолютных адресов, и возможно, иногда придется пересчитывать смещения в адреса для проверки правильности компиляции (это будет не часто, но «предупрежден значит вооружен»), как это делать смотрите в прошлой статье.
---
Теперь давайте перейдем к написанию программы, работу которой мы сможем увидеть (не люблю называть такие программы «Hello Word!» просто потому что никакого «Hello» в мигании светодиодом не вижу, скорее это программы «оживляющие» микроконтроллер).
Для написания программы нам потребуется понимание работы следующих инструкций: **MOV, MOVT, LDR, STR, ORR, B, BL, BX, SUB**, в условных переходах мы будем использовать условие **NE** (дойдя до этого места вы должны себе представлять что делает та или иная инструкция)
Считаю что будет уместным сделать небольшую отсылку к [Статье](http://we.easyelectronics.ru/STM32/prakticheskiy-kurs-stm32-urok-1---gpio-porty-vvoda-vyvoda.html), описывающую аналогичную функциональность, но на языке Си для среды CooCox, там дано краткое описание регистров которые нужно установить и их возможных значений. После прочтения статьи Вам должно стать понятно что именно мы должны будем сделать, на языке ассемблера, для того чтобы получить «мигалку».
Укрупненно, для того чтобы включать выключать светодиод нам нужна программа следующего вида:
```
< блок настройки вывода на выход >
BLINK_LOOP:
< блок включения светодиода >
< блок паузы >
< блок выключения светодиода >
< блок паузы >
B BLINK_LOOP @ операция зацикливания последних 4 блоков
```
Напишем **Блок настройки периферии программы**
Вся периферия «на кристалле» STM32 тактируется. Тактирование может быть включено/выключено отдельно для каждого устройства микроконтроллера — это сделано и для экономии энергии и для устранения конфликтов различных устройств при использовании одних и тех же ресурсов.
Поскольку вся возможная периферия доступна в виде регистров адресуемых как ячейки памяти, эти регистры описаны обычно в файлах-определениях, эти файлы определения существуют для различных семейств микроконтроллеров, внутри семейства обычно не отличаются. К сожалению для GNU ассемблера мне не удалось найти готовый файл, поэтому я его сделал из файла-определения среды CooCox — фактически заменил префиксы дефиниций, знаки "=" поменял на "," символы примечания на "@" и получился вот такой файл [stm32f40x.inc](https://yadi.sk/d/9WQa4CwamgzSL). Файл определений не догма, и не что то неизменное — при написании программ я постоянно его дополняю (старые значения стараюсь не убирать, никогда не знаешь заранее какие значения могут понадобиться), чего и вам желаю. Одновременно именно этот файл нужно передавать компилятору вместе с текстом программы или, например, «товарищу» на проверку, так как «любой другой» файл определений может просто нужных определений не иметь и при компиляции будет сгенерирована ошибка.
Формат файла определений — проще некуда:
```
@ Имя константы Значение Примечание
.equ FLASH_BASE ,0x08000000 @ FLASH(up to 1 MB) base address */
.equ CCMDATARAM_BASE ,0x10000000 @ CCM(core coupled memory) data RAM(64 KB)*/
.equ SRAM1_BASE ,0x20000000 @ SRAM1(112 KB) base address */
. . .
```
Откроем этот файл в режиме редактирования (F4) в FAR, находясь в самом его начале запускаем поиск по строке «GPIOH»
> В качестве отладочной платы я использую китайскую «поделку» [Open407I-C](http://www.waveshare.com/open407i-c-standard.htm) на ее «борту» стоит микроконтроллер STM32F407IGT, светодиоды на моей плате подключены к GPIO\_H, выводам PH2 и PH3, соответственно примеры я делаю именно под свою отладочную плату, а вот под имеющуюся у вас наверняка STM32F4 Discovery Вам примеры в этой и последующих публикациях не подойдут именно по причине подключения к другим портам GPIO и другим выводам. Разница на самом деле минимальна, но текст программы нужно будет править самостоятельно.
>
> Так что, если Вас действительно тема программирования микроконтроллеров на ассемблере «задела», для Вас это будет:
>
> 1. **интересно** (вы не занимаетесь простым копированием кода который я привел — в отличие от первой статьи где достаточно было просто внимательно читать, в этой публикации Вам придется еще и самостоятельно проходить тот же путь что и я, но под свою отладочную плату),
> 2. **полезно** (сделанное один раз своими руками и головой запоминается намного лучше просто скопированного). Файл-определений для контроллеров семейства STM32F407 одинаков (вам не придется делать свой).
>
>
>
> Файл с описанием подключений на отладочной плате STM32F4 Discovery можно найти в документе [Discovery kit for STM32F407/417 lines](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/DM00039084.pdf) (про подключение светодиодов в параграфе 4.4). Вообще все что предлагает ST по данной плате находиться [здесь](http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/PF252419)
>
>
По строке поиска «GPIOH» находится строка определение
Выше найденной строки, в примечании, указано, что это оборудование находится на шине **AHB1 peripherals**.
Теперь у нас два возможных пути:
1) Найти в Reference manual какой регистр RCC отвечает за тактирование GPIO\_H. Регистр будет называться **RCC\_AHB1\_<что\_то>**. Попутно прочитаете и будете примерно представлять функциональность системы регистров RCC.
2) Не уходя с stm32f40x.inc ищем регистр RCC который разрешает тактирование для шины **AHB1**, для этого опять идем в начало файла определений (Ctrl + Home) и ищем строку «RCC\_AHB1», попутно находки проверяем в Reference manual, вы должны найти:
1. **RCC\_AHB1RSTR** (будет найдено смещение регистра и его битовые определения), взглянув в Reference manual узнаем что этот регистр отвечает за сброс устройств — не наш случай.
2. **RCC\_AHB1ENR**, с битовыми определениями совпадающими с названием устройств, из Reference manual узнаем что это действительно тот самый регистр который мы ищем
Теперь нужно вычислить адрес регистра **RCC\_AHB1ENR**.
Адрес вычисляется следующим образом:
1) берем значение **PERIPH\_BASE (0x4000 0000)**
2) К нему прибавляем значение **RCC\_BASE (AHB1PERIPH\_BASE + 0x3800)**
3) К полученному прибавляем значение **RCC\_AHB1ENR (0x30)**
Получается **RCC\_AHB1ENR = 0x4002 3830**
Теперь по битовым определениям регистра **RCC\_AHB1ENR** находим, что GPIOH включается записью значения **0x00000080**.
Как видите найти нужное значение было не так уж и сложно, и зачастую, при некотором опыте в Reference manual заглядывать и не придется по каждой мелочи.
теперь напишем запись найденного значения по найденному адресу при помощи уже известных нам инструкций.
Код программы включающий GPIOH мог бы выглядеть так:
```
@ включим тактирование GPIO_H
MOV32 R0, PERIPH_BASE + RCC_BASE + RCC_AHB1ENR @ адрес
MOV32 R1, RCC_AHB1ENR_GPIOHEN @ значение
STR R1, [R0] @ запись R1 по адресу указанному в R0
```
мы не подставляем точный адрес и значение потому, что и считать лень, да и не наглядно будет — куда записываем, что записываем… а вот с указанием имен констант — все понятно (конечно, если вы знакомы с ассемблером).
Написанное выше должно быть Вам АБСОЛЮТНО понятно! понятны инструкции (не углубляясь в написание макроса), понятны константы адреса и значения (откуда взялись, чему равны, где в Reference manual проверить)
Теперь еще одна мелочь: как видно из битового определения **RCC\_AHB1ENR** — если мы просто запишем значение **0х00000080** — то мы включив **GPIOH** — выключим всю остальную периферию, в нашей программе это допустимо, но вообще так делать не правильно, давайте перепишем таким образом чтобы отключения остальной периферии не происходило:
```
@ включим тактирование GPIO_H
MOV32 R0, PERIPH_BASE + RCC_BASE + RCC_AHB1ENR @ адрес
MOV32 R1, RCC_AHB1ENR_GPIOHEN @ значение
LDR R2, [R0] @ прочитали значение регистра
ORR R1, R1, R2 @ логическое, побитовое ИЛИ : R1= R1 ИЛИ R2
STR R1, [R0] @ запись R1 по адресу указанному в R0
```
Теперь необходимо настроить GPIOH вывод PH2 на выход.
Из примера выше мы уже знаем, что за режим работы вывода порта отвечает регистр **GPIOx\_MODER**, тут нужно будет обратиться к Reference manual, описание этого регистра находится на стр. 283, нам нужен режим «General purpose output mode», согласно Reference manual для этого в соответствующее поле регистра (биты 4 и 5) нужно записать значение «01»
Сделаем это!
Задача 1: узнать адрес регистра и сформировать значение на запись в него.
Вычислим адрес:
1) берем значение **PERIPH\_BASE (0x4000 0000)**
2) к нему прибавим значение **GPIOH\_BASE (AHB1PERIPH\_BASE + 0x1C00)**
3) и к полученному значение **GPIO\_MODER (0x00)**
Получаем адрес как сумму: **PERIPH\_BASE + GPIOH\_BASE + GPIO\_MODER**
Теперь разберемся со значением: чтобы задать режим вывода PH2 GPIOH необходимо установить bit4=1, bit5=0, то есть, в двоичном виде:
**0000 0000 0000 0000 0000 0000 0001 0000 = 0x00000010**
Такое значение есть в файле определений:
Задача 2: напишем код устанавливающий режим работы вывода PH2 GPIOH.
Задумались? код ведь от предыдущего будет отличаться только константами, и может выглядеть так:
```
@ установим режим GPIOH pin_2
MOV32 R0, PERIPH_BASE + GPIOH_BASE + GPIO_MODER @ адрес
MOV32 R1, GPIO_MODER_MODER2_0 @ значение
LDR R2, [R0] @ прочитали значение регистра
ORR R1, R1, R2 @ логическое, побитовое ИЛИ: R1= R1 ИЛИ R2
STR R1, [R0] @ запись R1 по адресу указанному в R0
```
Есть еще один способ определения значения режима работы вывода PH2 GPIOH: можно использовать прямое значение из файла определений: **GPIO\_MODER\_MODER\_GENERAL\_OUT (0x00000001)** сдвинув его на соответствующую позицию регистра.
Поскольку у нас размер настройки 2 бита, и установить нужно настройку для вывода 2 — то количество бит на которые нужно сдвинуть константу можно посчитать по формуле: <размер настройки> \* <номер вывода>, получается конструкция вида: **MOV32 R1, GPIO\_MODER\_MODER\_GENERAL\_OUT << (2\*2)**, и код настройки может выглядеть так:
```
@ установим режим GPIOH PH2
MOV32 R0, PERIPH_BASE + GPIOH_BASE + GPIO_MODER @ адрес
MOV32 R1, GPIO_MODER_MODER_GENERAL_OUT << (2*2) @ значение полученное сдвигом константы
LDR R2, [R0] @ прочитали значение регистра
ORR R1, R1, R2 @ логическое, побитовое ИЛИ: R1= R1 ИЛИ R2
STR R1, [R0] @ запись R1 по адресу указанному в R0
```
А вот дальше нас ждет приятный сюрприз, несмотря на пример приведенный где то уже в середине публикации, остальные регистры нам можно не устанавливать (!):
1. регистр GPIOx\_OTYPER (схема выхода) по умолчанию установлен в «0» (что означает режим работы выхода «push-pull» — то что нам и нужно!)
2. регистр GPIOx\_OSPEEDR (скорость выхода) для портов после GPIO\_B установлен в «0» что означает Low speed (а нам быстрее пары/тройки герц и не нужно будет)
3. регистр GPIOx\_PUPDR (подтяжка) так же для портов после GPIO\_B установлен в «0», что означает No pull-Up, pull-down
Теперь осталось научиться управлять состоянием вывода PH2 нашего GPIOH чтобы мигать светодиодом.
Сначала хотел сделать это через GPIOx\_ODR (стр. 285 Reference manual), но потом решил что проще будет сделать через регистр GPIOx\_BSRR.
Его отличие от GPIOx\_ODR в том что запись в нижние 16 бит приводит к установке логической «1» на соответствующем выводе, а запись в верхние 16 бит — приводит к сбросу в логический «о», так же на соответствующем выводе порта
Давайте сформируем конкретные значения для примера [ двоичное (шестнадцатеричное) ]:
1. 0000 0000 0000 0000 0000 0000 0000 0100 (0x00000004)- включить светодиод
2. 0000 0000 0000 0100 0000 0000 0000 0000 (0x00040000)- выключить светодиод
Думаю что код реализующий включение и выключение светодиода (без паузы между ними) вы сможете написать сами, но без этого кода статья будет не полной так что пишу сам (проверьте себя!), заодно применим новую для нас команду вызова подпрограммы **BL**:
```
BLINK_LOOP:
@ включим светодиод
MOV32 R0, PERIPH_BASE + GPIOH_BASE + GPIO_BSRR @ адрес
MOV32 R1, 0x04 @ значение
STR R1, [R0] @ запись R1 по адресу указанному в R0
BL DELAY @ пауза
@ выключим светодиод
MOV32 R0, PERIPH_BASE + GPIOH_BASE + GPIO_BSRR @ адрес
MOV32 R1, 0x04 << (1*16) @ значение 1-размер поля, 16-во второе полуслово
STR R1, [R0] @ запись R1 по адресу указанному в R0
BL DELAY @ пауза
B BLINK_LOOP @ делаем цикл
```
Про команды **BL / BX**: это команды организации вызова подпрограмм, адрес возврата при переходе с помощью **BL** сохраняется в регистре **LR**, никаких сохранений в стек не происходит (в отличие от 8ми битных процессоров, которые сохраняли на стек адрес возврата из подпрограммы). Соответственно команда **BX** просто осуществляет возврат из подпрограммы по адресу возврата в **LR**.
Ну и код реализующий паузу (задержку), в данный момент ничего умнее простого цикла со счетчиком мы не придумаем:
```
DELAY:
MOV32 R2, 0x00100000 @ повтор цикла задержки 0x0010 0000 раз.
Delay_loop: SUBS R2, R2, 1
BNE Delay_loop
BX LR
```
Новая команда BNE — это команда перехода с условием NE — «не равно».
Код паузы (задержки) работает следующим образом:
в R2 загрузили начальное значение (0x00100000),
далее из R2 вычитаем 1, причем команда вычитания у нас с суффиксом «S» — то есть после своей работы обновляет флаги,
к команде BNE подходим со сброшенным (если в R2 не ноль) флагом, и переходим на метку Delay\_loop (на вычитание из R2 единицы),
и так будет до тех пор пока R2 не станет равным нулю, в этом случае команда BNE выполнена не будет (еще раз повторю: NE-это выполнение при неравенстве нулю) и произойдет возврат из подпрограммы командой **BX LR**.
Ну вот и все. Наша программа написана, теперь осталось собрать ее кусочки в один файл и откомилировать / скомпоновать (меня тут немного пожурили за слово «линковать» в первой публикации).
полный текст моей программы выглядит следующим образом:
```
@GNU AS
@ Настройки компилятора
.syntax unified @ тип синтаксиса
.thumb @ тип используемых инструкций Thumb
.cpu cortex-m4 @ микроконтроллер
.include "stm32f40x.inc" @ файл определений микроконтроллера
@ макрос псевдокоманды MOV32, пока просто используем, не вникая как, что и почему
.macro MOV32 regnum,number
MOVW \regnum,:lower16:\number
MOVT \regnum,:upper16:\number
.endm
@ таблица векторов прерываний
.section .text
.word 0x20020000 @ Вершина стека
.word Reset+1 @ Вектор сброса
Reset:
@ включим тактирование GPIOH
MOV32 R0, PERIPH_BASE + RCC_BASE + RCC_AHB1ENR @ адрес
MOV32 R1, RCC_AHB1ENR_GPIOHEN @ значение
LDR R2, [R0] @ прочитали значение регистра
ORR R1, R1, R2 @ логическое, побитовое ИЛИ: R1= R1 ИЛИ R2
STR R1, [R0] @ запись R1 по адресу указанному в R0
@ установим режим GPIOH PH2
MOV32 R0, PERIPH_BASE + GPIOH_BASE + GPIO_MODER @ адрес
MOV32 R1, GPIO_MODER_MODER2_0 @ значение
LDR R2, [R0] @ прочитали значение регистра
ORR R1, R1, R2 @ логическое, побитовое ИЛИ: R1= R1 ИЛИ R2
STR R1, [R0] @ запись R1 по адресу указанному в R0
BLINK_LOOP:
@ включим светодиод
MOV32 R0, PERIPH_BASE + GPIOH_BASE + GPIO_BSRR @ адрес
MOV32 R1, 0x04 @ значение
STR R1, [R0] @ запись R1 по адресу указанному в R0
BL DELAY @ пауза
@ выключим светодиод
MOV32 R0, PERIPH_BASE + GPIOH_BASE + GPIO_BSRR @ адрес
MOV32 R1, 0x04 << (1*16) @ значение 1-размер поля, 16-во второе полуслово
STR R1, [R0] @ запись R1 по адресу указанному в R0
BL DELAY @ пауза
B BLINK_LOOP @ делаем цикл
DELAY:
MOV32 R2, 0x00100000 @ повтор цикла задержки 0x0010 0000 раз.
Delay_loop:
SUBS R2, R2, 1
BNE Delay_loop
BX LR
```
Обратите внимание!
После последней команды в файле программы я оставил одну пустую строку! если этого не сделать, то компилятор будет ругаться. Служебную команду **.end** можно не использовать.
Текст программы компилируется в binary файл размером 116 байт.
Залить в микроконтроллер нашу программу можно при помощи DFU, подробнее как это делается я описывал в статье [STM32F4: Программирование через интерфейс USB (DFU/DfuSe)](http://vg.ucoz.ru/publ/programmirovanie_mikrokontrollerov_stm32/stm32_programmirovanie_cherez_interfejs_usb/9-1-0-22). Только обратите внимание что для прошивки у нас «готовится» файл с расширением .bin — чтобы корректно «прошить» необходимо будет указать адрес записи его во FLASH = 0x08000000 (это вы должны помнить из прошлой публикации). Либо можно использовать любой другой имеющийся способ прошивки микроконтроллера (на плате STM32F4 встроен ST-Link у которого есть соответствующая утилита)
p.s. Записали? в STM32F4 Discovery? и не работает? ПРАВИЛЬНО не работает! у STM32F4 Discovery светодиоды подключены к другим GPIO, и чтобы программа заработала ее нужно поправить! Об успехах (и не очень) можно делиться в комментариях или на электронную почту: gorbukov<здесь что то тявкало]яндекс.ru
для тех кому некогда заниматься созданием своего проекта «с нуля» даю [ссылку](https://yadi.sk/d/bdQH8yqWmh8XM) на скачивание готового проекта и настроенной средой компиляции (с некоторыми «плюшками» в виде вывода статистики, генерации .hex файла прошивки, генерацией вспомогательных файлов для контроля компиляции и т.д.)
на этом вторая публикация закончена.
Следующая публикация [STM32F4: GNU AS: Мигаем светодиодом (Версия для STM32F4 Discovery, Оптимизация) (Часть 3)](http://habrahabr.ru/post/274901/)
p.s. что такое github пока не знаю, если найду нормальную документацию «что и как в нем делать» — то перезалью… пока же кроме регистрации и создания репозитария ничего толкового не получается (например русские комментарии в исходниках почему-то по русски не отображаются)… | https://habr.com/ru/post/274579/ | null | ru | null |
# Балльно-рейтинговая технология оценки знаний
Приветствую всех и каждого в отдельности кто читает данную статью так как речь в ней пойдет о том, что в той или иной мере касается каждого из нас — об образовании.
Немного текста для погружения в тему. И так в общем об образовании в нашей стране статистика такова:
Из занятых в экономике России (100%) имеют
ВЫСШЕЕ ПРОФЕССИОНАЛЬНОЕ ОБРАЗОВАНИЕ
всего: 27, 8%
мужчины: 25,2%
женщины 30,5%
НЕПОЛНОЕ ВЫСШЕЕ ПРОФЕССИОНАЛЬНОЕ
всего: 1,5%
мужчины: 1,4%
женщины 1,5%
по данным опубликованным на [сайте](http://www.gks.ru/bgd/regl/b08_11/IssWWW.exe/Stg/d01/06-05.htm) ведомства ФЕДЕРАЛЬНАЯ СЛУЖБА ГОСУДАРСТВЕННОЙ СТАТИСТИКИ РОССИЙСКОЙ ФЕДЕРАЦИИ.
Все мы знаем как происходит обучение в государственных ВУЗ-ах, для тех кто подзабыл напоминаю:
Есть основная образовательная программа она делиться на блоки и темы. В течении всего срока обучения студенты проходят дисциплины в соответствии с учебным планом. Не знаю что конкретно повлияло на изменения формата оценки знаний студентов, но подозреваю, что это связано с болонским процессом и переходом на уровни образования бакалавриат и магистратура.
#### И так, какие грядут изменения в правилах игры для студента, вуза и преподавателя.
и вот какие
Балльно-рейтинговые технологии оценки знаний основывающиеся на документационной и программно — аппаратной базе. И мне бы хотелось остановиться на второй составляющей и провести ее некую декомпозицию. И первым блоком в моей де композиционной модели станет модель подсчета баллов. Ко вниманию общественности хочу предложить следующий алгоритм подсчета баллов:
Оценивать будем аудиторную работу, посещаемость и вне аудиторную работу.
##### Аудиторная работа делиться на занятия практические, так называемые ответы с места и деловые игры.
За каждое занятие студент может получить оценку не выше максимального балла установленного преподавателем (условно от 1 — до бесконечности), затем мы получаем сумму всех отношений оценки к максимальному баллу и делим на кол-во занятий на которых студент получал оценки и приравниваем к ста баллам (условно, приравнять можно к любой шкале) путем умножения, получаем средневзвешенное значение — что и будет являться баллом за аудиторную работу.
##### Посещаемость — был или не был
Тут все просто — отнимаем из общего числа прошедших занятий кол-во пропущенных делим на кол-во прошедших занятий и приводим это числа к установленной шкале (условно 100 баллов)
##### Вне аудиторная работа
Подсчет ровно такой же как и в случае с аудиторной работой, за тем исключением что все занятия обязательны идут в счет.
##### Теперь осталось нам посчитать итоговый балл
Для этого раздадим веса для каждого вида занятий:
* Аудиторная работа 40 баллов
* Посещаемость 30 баллов
* Вне аудиторная работа 30 баллов
Получаем суммарный балл набранный студентом путем сложения отношений каждого промежуточного балла к сумме всех весов. Для понимающих код, а таких здесь, надо полагать большинство предлагаю строку кода в которой эта операция и реализуется:
`$STUDENT_ITOG_att[$w][2] = round((($STUDENT_ITOG[$w][1]*40)+($STUDENT_ITOG[$w][2]*30)+($STUDENT_ITOG_att[$w][1]*30)) / 100, 2);`
Подводя итог данной статьи хотелось бы услышать ваши комментарии по данному методу оценки знаний. | https://habr.com/ru/post/130572/ | null | ru | null |
# Захват видео с сетевых камер, часть 1
 Сетевые видеокамеры постепенно вытесняют аналоговые, хоть и стоят они сейчас гораздо дороже. Сетевые обладают рядом очевидных приемуществ:
* нет необходимости в отдельном регистраторе или плате захвата;
* помехоустойчивость;
* простая интеграция в существующую сеть;
* нет ограничения по расстоянию;
* наличие камер высокого разрешения;
* просмотр камеры прямо с самой камеры по http;
* наличие всевозможных настроек;
* и др.
Нас интересует способ получения изображений с таких камер, для этого надо знать а как вообще они их передают? На наше счастье камеры используют существующие стандарты, а не то, что взбредёт в голову китайскому разработчику. Подавляющее большинство камер используют один или несколько способов передачи видео, это в основном Motion JPEG по HTTP, Motion JPEG по RTSP или H264 по RTSP. Также многие камеры могут передавать звук, но он нас не интересует сейчас.
В этой статье я рассмотрю эти способы передачи изображений с сетевых камер, а также приведу пример захвата таких изображений всё на том же Python'е.
#### MJPEG over HTTP
Самый простой способ передачи картинки — это MJPEG по HTTP. В этом случае кадры отдаются готовыми JPEG файлами через специальные разделители. Для таких случаев был разработан специальный MIME тип [multipart](http://en.wikipedia.org/wiki/MIME#Multipart_messages). У него есть несколько подтипов, нас интересуют mixed и x-mixed-replace. Отличий между ними практически нет, мы их будем обрабатывать абсолютно одинаково. Отличие у них смысловое: mixed указывает просто на документ, состоящий из нескольких частей, эти части могут быть независимыми или могут объединяться; а тип x-mixed-replace прямо указывает, что каждая следующая часть должна заменять собой предыдущую и обрабатываться должны как обновление какого-то представления. Буква «x» вначале названия указывает на то, что этот тип является экспериментальным, но тем не менее он во всю используется.
В HTTP заголовке тип MIME указывается в `Content-Type` параметре:
```
Content-Type: multipart/mixed; boundary="some_boundary"
```
или
```
Content-Type: multipart/x-mixed-replace; boundary=other_boundary
```
У этих типов есть обязательный параметр `boundary`, который указывает каким текстом разделяются части документа. К разделителю также добавляются два дефиса в его начало. Важно чтобы этот разделитель не встречался в самом сообщении, если не указывается его размер в `Content-Size`.
Чтобы понять структуру передачи MJPEG по HTTP достаточно взглянуть на следующий пример:
```
HTTP/1.0 200 OK
Connection: close
Server: MJPG-Streamer/0.2
Cache-Control: no-store, no-cache, must-revalidate, pre-check=0, post-check=0, max-age=0
Pragma: no-cache
Expires: Mon, 3 Jan 2000 12:34:56 GMT
Content-Type: multipart/x-mixed-replace;boundary=boundarydonotcross
--boundarydonotcross
Content-Type: image/jpeg
Content-Length: 23950
X-Timestamp: 0.000000
%Binary JPEG%
--boundarydonotcross
Content-Type: image/jpeg
Content-Length: 24756
X-Timestamp: 0.000000
%Binary JPEG%
--boundarydonotcross
Content-Type: image/jpeg
Content-Length: 23950
X-Timestamp: 0.000000
%Binary JPEG%
```
Для анализа того, как ваша сетевая камера передаёт изображения, можно воспользоваться либо снифером (я пользуюсь [WireShark](http://www.wireshark.org/)), либо подключиться к камере через telnet, например так:
```
$ telnet 192.168.0.50 80
Trying 192.168.0.50..
Connected to 192.168.0.50.
Escape character is '^]'.
GET /jpeg HTTP/1.1
```
После строки GET нужно ещё отправить одну пустую строку для индикации того, что ваш заголовок закончился. А вместо "/jpeg" нужно написать тот запрос, по которому ваша камера отдаёт MJPEG.
В приведённом выше примере `%Binary JPEG%` соответствует интересующей нас информации — JPEG изображению. Его-то нам и нужно выделить из потока.
Как видно вначале идёт стандартный HTTP заголовок с описанием документа. `Connection` может быть как `close`, так и `keep-alive`, в нашем случае это не играет роли. Из заголовка нам всего навсего нужно две строчки: первая со статусом 200 OK, которая говорит нам, что всё хорошо, сейчас вылетит птичка; и `Content-Type` для определения параметра `boundary`.
После HTTP заголовка (после пустой строки) идёт тело передаваемого документа, состоящего из множества частей. Каждая часть начинается с разделителя, имеет свой собственный заголовок и своё тело документа после пустой строки. `Content-Type: image/jpeg` указывает нам, что мы действительно получаем JPEG изображения, `Content-Length` на размер текущего кадра в байтах (в первой части это 23950 байт), а в `X-Timestamp` может передаваться временная отметка текущего кадра, можно использовать для этих целей текущее время компьютера в момент приёма кадра, но `X-Timestamp` будет точнее, так как сеть может оказывать разное влияние на скорость передачи кадров.
#### Python MJPEG over HTTP Client
Несмотря на простой формат передачи изображений, их приём можно реализовать разными методами. Также играет роль TCP сегментация, а точнее подход к её обработке. Дело в том, что максимальный размер передаваемого сообщения ([MTU](http://ru.wikipedia.org/wiki/MTU)) по Ethernet не может превышать 1500 байт и данные мы обрабатываем каждый раз когда такой пакет к нам приходит. Если анализировать информацию сразу по её приходу, то может случится так, что данные будут не полными и парсер не сможет справится со своей задачей. А если буферизировать поток входящих данных, то это не лучшим образом сказывается на производительности и ресурсоёмкости. Надежнее было бы воспользоваться буферизацией и приступать к анализу только когда уже накоплено достаточно информации (сначала нужно прочитать до `'\r\n\r\n'`, чтобы выделить заголовок, а потом либо до тех пор пока не встретятся два раза в потоке разделители, либо также читать до пустой строки, определять размер изображения и отсчитывать количество байт). Но я воспользовался методом обработки информации сразу по её приходу.
Код клиента состоит из двух файлов: `main.py` и `http_mjpeg_client.py`. В первом производится запуск приложения, а во втором реализована работа с камерой. Сразу их и приведу здесь.
main.py
```
from twisted.internet import reactor
from http_mjpeg_client import MJPEGFactory
def processImage(img):
'This function is invoked by the MJPEG Client protocol'
# Process image
# Just save it as a file in this example
f = open('frame.jpg', 'wb')
f.write(img)
f.close()
def main():
print 'Python M-JPEG Over HTTP Client 0.1'
# Define connection parameters, login and password are optional.
config = {'request': '/mjpeg',
'login': 'admin',
'password': 'admin',
'ip': '127.0.0.1',
'port': 8080,
'callback': processImage}
# Make a connection
reactor.connectTCP(config['ip'], config['port'], MJPEGFactory(config))
reactor.run()
print 'Python M-JPEG Client stopped.'
# this only runs if the module was *not* imported
if __name__ == '__main__':
main()
```
http\_mjpeg\_client.py
```
from twisted.internet.protocol import Protocol, ClientFactory
from base64 import b64encode
import re
debug = 1
class MJPEGClient(Protocol):
def __init__(self):
# A place for configuration parameters
self.config = {}
# I we are connected to a web server
self.isConnected = False
# The boundary in multipart stream
self.boundary = ''
# Actual image data goes here
self.img = ''
# Size of the image frame being downloaded
self.next_img_size = 0
# Indicates that currently parsing a header
self.isHeader = False
def connectionMade(self):
# Implement basic authorization
if self.config['login']:
authstring = 'Authorization: Basic ' + b64encode(self.config['login']+':'+self.config['password']) + '\r\n'
else:
authstring = ''
# Form proper HTTP request with header
to_send = 'GET ' + self.config['request'] + ' HTTP/1.1\r\n' + \
authstring + \
'User-Agent: Python M-JPEG Client\r\n' + \
'Keep-Alive: 300\r\n' + \
'Connection: keep-alive\r\n\r\n'
# Send it
self.transport.write(to_send)
if debug:
print 'We say:\n', to_send
def dataReceived(self, data):
if debug:
print 'Server said:\n', len(data), 'bytes of data.'
if not self.isConnected:
# Response header goes before empty line
data_sp = data.strip().split('\r\n\r\n', 1)
header = data_sp[0].splitlines()
# Parse header
for line in header:
if line.endswith('200 OK'): # Connection went fine
self.isConnected = True
if debug: print 'Connected'
if line.startswith('Content-Type: multipart'): # Got multipart
r = re.search(r'boundary="?(.*)"?', line)
self.boundary = r.group(1) # Extract boundary
if debug: print 'Got boundary:', self.boundary
# If we got more data, find a JPEG there
if len(data_sp) == 2:
self.findJPEG(data_sp[1])
else:
# If connection is alredy made find a JPEG right away
self.findJPEG(data)
def findJPEG(self, data):
hasMoreThanHeader = False
# If we know next image size, than image header is already parsed
if not self.next_img_size:
# Otherwise it should be a header first
for line in data.splitlines():
if line == '--'+self.boundary:
self.isHeader = True
if debug: print 'Got frame header'
elif line == '':
if self.isHeader:
# If we might have more data after a header in a buffer
hasMoreThanHeader = True
self.isHeader = False
elif self.isHeader:
# Here we can parse all the header information
# But we are really interested only in one
if line.startswith('Content-Length:'):
self.next_img_size = int(line.split(' ')[1])
if debug: print 'Next frame size:', self.next_img_size
else:
# How many bytes left to read
remains = self.next_img_size - len(self.img)
self.img += data[:remains]
# We got the whole image
if len(self.img) == self.next_img_size:
if debug: print 'Got a frame!'
# Run a callback function
self.config['callback'](self.img)
# Reset variables
self.img = ''
self.next_img_size = 0
# If something left in a buffer
if data[remains:]:
self.findJPEG(data[remains:])
if hasMoreThanHeader:
data_sp = data.split('\r\n\r\n', 1)
# If there is something after a header in a buffer
if len(data_sp) == 2:
self.findJPEG(data_sp[1])
def connectionLost(self, reason):
print 'Connection lost, reconnecting'
self.isConnected = False
self.img = ''
self.next_img_size = 0
self.isHeader = 0
self.boundary = ''
class MJPEGFactory(ClientFactory):
def __init__(self, config):
self.protocol = MJPEGClient
self.config = config
def buildProtocol(self, addr):
prot = ClientFactory.buildProtocol(self, addr)
# Weird way to pass the config parameters to the protocol
prot.config = self.config
return prot
def clientConnectionLost(self, connector, reason):
# Automatic reconnection
connector.connect()
```
В главном файле мы определяем параметры подключения к камере в словаре `config`, запускаем реактор сетевого фрэймворка Twisted и обрабатываем получаемые изображения в функции `processImage()`. В этом примере каждый получаемый кадр просто записывается в текущую директорию с именем `frame.jpg`.
Работоспособность я проверял с помощью [MJPEG стримера](http://sourceforge.net/projects/mjpg-streamer/), запускал я его вот так:
`./mjpg_streamer -i "./input_testpicture.so" -o "./output_http.so -w ./www"`
При этом `request` в конфигурации клиента надо указать равным `/?action=stream`.
Передавать изображения с вебкамеры он у меня отказался.
Я старался хорошо документировать второй файл, чтобы читателю было легче понять как происходит процесс изъятия изображений из потока. На словах алгоритм можно описать следующим образом: при подсоединении к камере первым делом формируем HTTP заголовок с обращением к ней и отсылаем его, это функция `connectionMade()`. Функция `dataReceived()` вызывается всякий раз, когда к нам приходят новые данные. В ней мы проверяем установлена ли уже передача JPEG данных или нет. Если ещё нёт, то значит к нам должен прийти HTTP заголовок ответа камеры, мы его выделяем с помощью функции `split('\r\n\r\n', 1)`, затем разбираем его по полочкам, выделяя нужные параметры (статус и `boundary`). В остальных случаях мы полученные данные сразу передаём функции `findJPEG()`.
В этой функции так же происходит ветвление в зависимости от того получили ли мы внутренний заголовок JPEG документа или ещё нет. Если не получили — ожидаем его и разбираем, если получили — значит данные это непосредственно JPEG изображение и складываем их в переменную `self.img` до тех пор пока не получим все `self.next_img_size` байт изображения, а когда получим — вызываем функцию, переданную нам через параметр конфигурации `callback`, и отдаём ей только что полученное изображение.
Параметр `debug` можно выставить в ноль для отключения отображения выводимой информации.
Загрузить исходный код можно по этой ссылке: [Python MJPEG over HTTP Client](http://python-mjpeg-over-http-client.googlecode.com/files/http_mjpeg_client-0.1.zip).
Продолжение следует…
#### Полезно почитать:
[MIME](http://en.wikipedia.org/wiki/MIME)
[Motion JPEG](http://en.wikipedia.org/wiki/Motion_JPEG)
[Список заголовков HTTP](http://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B8%D1%81%D0%BE%D0%BA_%D0%B7%D0%B0%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D0%BA%D0%BE%D0%B2_HTTP)
P.S.: Я решил разбить статью на две части, так как единым целом она получается довольно объёмной, а я не хочу её перегружать для лучшего понимания и большего удобства. | https://habr.com/ru/post/115808/ | null | ru | null |
# Проброс нескольких одинаковых устройств USB в виртуальную машину libvirt+QEMU
### Конфигурация.
Сервер виртуальных машин на GNU/Linux. Виртуальные машины Windows. Гипервизор QEMU-KVM.
Виртуальные машины запускаются автоматически.
### Описание проблемы.
Для двух программ есть два электронных (лицензионных) ключа Guardant одной модели (у них одинаковые Vendor ID и Product ID). Чтобы не возникал конфликт, в libvirt в описании виртуальной машины такие ключи добавляются с указанием аппаратного адреса (bus, device). После перезагрузки может оказаться так, что номера устройств будут другие. А если переключить их в другой порт, то и номер шины может стать другим.
### Неудачное решение
Первое, что пришло в голову после изучения [документации](https://libvirt.org/formatdomain.html) — указать в конфигурации виртуальной машины все возможные bus и device для этих одинаковых USB-ключей. Но это породило неудобство при просмотре и редактировании виртуальной машины в Virt-Manager.
### Окончательное решение.
Разбираться с UDEV желания не было. (Не знаю, можно ли в нём изменить номер устройства на шине USB, а изменить номер шины наверняка невозможно.)
Поэтому было применено максимально универсальное решение: в процессе загрузки после запуска виртуальной машины выполняется скрипт, который выясняет номера шины и номер устройства для каждого из одинаковых электронных ключей, формирует файл-описание устройств для libvirt (формата XML) и добавляет проброс этих устройств в виртуальную машину. Если в скрипте возникнет ошибка, она заносится в syslog и на stderr.
Чтобы не придумывать обработку start/stop/status и проверку зависимостей, скрипт добавлен в rc.local — он заведомо выполняется последним из стартовых скриптов.
Использование этого метода исключает переключение USB-ключей во время работы виртуальной машины — если вытащить ключ и вставить его в другой порт, он не будет подключен повторно. Для сервера это ограничение приемлимо.
Вывод lsusb (для справки), нужные устройства — пятое и шестое на третьей шине:
```
Bus 003 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub
Bus 003 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 003 Device 003: ID 1a40:0101 Terminus Technology Inc. Hub
Bus 003 Device 008: ID 051d:0002 American Power Conversion Uninterruptible Power Supply
Bus 003 Device 004: ID 064f:0bd8 WIBU-Systems AG BOX/RU
Bus 003 Device 005: ID 0a89:0008
Bus 003 Device 006: ID 0a89:0008
Bus 004 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub
Bus 004 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
```
Текст скрипта:
```
#!/bin/sh
# libvirt-win-attach-guardant-keys
# attach all guardant keys into virtual machine "win"
VMachine="win"
MYDIR="/tmp/libvirt-guardant/"
SYSLOG="logger -s -p daemon.error "
if [ -d $MYDIR ]; then rm -f $MYDIR/*_*.xml ; else
mkdir $MYDIR || ( $SYSLOG "Can't create $MYDIR" ; exit 1 )
fi
cd $MYDIR
echo "Attach guardant keys into virtual machine \"$VMachine\":"
lsusb | awk '/ID 0a89:0008/{gsub(":", "", $4);print "\n \n \n \n \n" > ""$2"_"$4".xml"; }' || ( $SYSLOG "Error in lsusb|awk: $? $!" ; exit 1 )
for devxml in *_*.xml ; do echo " USB_${devxml/.xml/} ..." ; virsh attach-device $VMachine $devxml | grep -vE "^(Device attached successfully|$)" ; done
cd /tmp
rm -f $MYDIR/*.xml
rmdir $MYDIR
echo "Done."
```
Пояснение к тексту.
Для простоты программа для AWK передаётся в командной строке. При этом, чтобы избежать сложностей с экранированием кавычек и "$", внутри awk-программы переменные шела не используются. Поэтому сделан переход в созданный временный каталог, а также параметры устройств заданы константами (Vendor ID 0x0a89 и Product ID 0x0008). | https://habr.com/ru/post/259401/ | null | ru | null |
# Краткий обзор NLP библиотеки SpaСy
Обработка естественного языка(Natural Language Processing — NLP) сегодня становится очень востребованной, так как людям несомненно проще общаться с машинами также, как они общаются с людьми.
Поэтому сейчас, вместе с быстрым развитием этой области, всё больше сервисов используют NLP: чат-боты, в которых больше не нужно выбирать готовые ответы, голосовые ассистенты, электронная почта, чтобы автоматически сортировать письма и так далее. В этом посте я хочу рассказать об относительно новой Python библиотеке SpaCy, которая стала, если не индустриальным стандартом, как ~~кричат~~ заявляют сами создатели на сайте библиотеки: <https://spacy.io/>, то как минимум одним из самых популярных и удобных решений. Приятного чтения!
Сравнение с NLTK
================
NLTK(Natural Language ToolKit) — самая известная NLP библиотека, созданная исследователями в данной области. Она популярна в академических кругах и в основном используется для обучения или создания различных методов обработки и не только используя базовые инструменты, которые NLTK предоставляет в огромном количестве и не всегда самые лучшие. Так же она довольно медленная в силу того, что написана полностью на Python и работает со строками.
SpaCy — в каком-то смысле противоположность NLTK. Она значительно быстрее, так как она написана на Cython и работает с объектами, об этом дальше. SpaCy предоставляет в основном лучшие инструменты для решения конкретной задачи. Она — numpy из мира NLP.
В целом, SpaCy с её предобученными моделями, скоростью, удобным API и абстракцией гораздо лучше подходит для разработчиков, создающих готовые решения, а NLTK с огромным числом инструментов и возможностью городить любые огороды — для исследователей и студентов. В любом случае для создания собственных моделей ни та, ни другая библиотека не подходит. Для этого всего существуют Tensorflow, PyTorch и прочие.
**Тесты скорости и подробнее о различиях**
<https://spacy.io/usage/facts-figures>
<https://medium.com/activewizards-machine-learning-company/comparison-of-top-6-python-nlp-libraries-c4ce160237eb>
Если кратко, то SpaCy может примерно всё то же самое, что и NLTK и их аналоги, но быстрее и точнее.
Архитектурные особенности
=========================
Центральными структурами данных в SpaCy являются **Doc** и **Vocab**. Объект **Doc** хранит последовательности токенов и все их аннотации. Объект **Vocab** хранит набор справочных таблиц, что делает общую информацию доступной для всех документов. При централизованном хранении строк, векторов слов и лексических атрибутов отсутствует необходимость хранения нескольких копий этих данных. Это экономит память и обеспечивает единый источник правды.
Объект **Doc** владеет данными, а **Span** и **Token** являются представлениями, что позволяет Spacy работать быстро, без лишних копирований, указывающими на них. Объект **Doc** создается объектом **Tokenizer**, а затем модифицируется in-place компонентами pipeline. Объект **Language** координирует эти компоненты. Он берет необработанный текст и отправляет его по pipeline, возвращая аннотированный документ.
Курс от создателей
==================
У создателей есть хороший подробный курс по NLP с использованием SpaCy, начиная с самых основ и заканчивая дообучением встроенных моделей и адаптированию библиотеки под ваш проект: <https://course.spacy.io/en>
Установка
=========
Весь код примеров будет по ссылке на Colab ниже.
Установка под все платформы предельно проста и не отличается от других пакетов Python(установка через pip/conda), и описана на сайте библиотеки, где можете собрать свой стартовый набор. Я использую Python 3.8.2 под Pop!\_OS 20.04(короче Ubuntu):
Зависимости для Ubuntu:
```
sudo apt-get install build-essential python-dev git
```
Установка SpaCy и en\_core\_web\_sm — пакета небольшой модели английского, которая почти не уступает более крупным собратьям(<https://spacy.io/models/en>):
```
pip3 install -U spacy
pip3 install -U spacy-lookups-data
python3 -m spacy download en_core_web_sm
```
Так же вы можете поставить Spacy с поддержкой вычислений на CUDA, о которой тоже есть информация на странице с установкой. Установка на Google Colab ничем не отличается. Официальных моделей русского языка пока нет, но они в процессе разработки. Но есть очень неплохо работающий вариант, который не работает пока на последней версии Spacy и тянет дополнительные зависимости: <https://github.com/buriy/spacy-ru>
Простейшие примеры
==================
Весь код примеров будет на Colab: <https://colab.research.google.com/drive/1BmOAjjYt-t_lT9suZNnf1j5ykDX5IYT0?usp=sharing>
Для начала импортнём SpaCy и создадим объект nlp, что будет общей частью всех примеров:
```
import spacy
nlp = spacy.load("en_core_web_sm")
```
Токенизация, POS-tagging и определение начальной формы слова — лемматизация в случае SpaCy:
(текст токена, начальная форма, часть речи, является ли стоп-словом)
```
doc = nlp("While Samsung has expanded overseas, South Korea is still host to most of its factories and research engineers.")
for token in doc:
print(token.text, token.lemma_, token.pos_, token.is_stop)
```
**Результат**
While while SCONJ True
Samsung Samsung PROPN False
has have AUX True
expanded expand VERB False
overseas overseas ADV False
,, PUNCT False
South South PROPN False
Korea Korea PROPN False
is be AUX True
still still ADV True
host host NOUN False
to to ADP True
most most ADJ True
of of ADP True
its -PRON- DET True
factories factory NOUN False
and and CCONJ True
research research NOUN False
engineers engineer NOUN False
.. PUNCT False
Построение дерева зависимостей для того же примера:
(текст токена, тип зависимости(согласно Universal Dependency), корневое слово)
```
for token in doc:
print(token.text, token.dep_, token.head)
```
**Результат**
While mark expanded
Samsung nsubj expanded
has aux expanded
expanded advcl is
overseas advmod expanded
, punct is
South compound Korea
Korea nsubj is
is ROOT is
still advmod is
host attr is
to prep host
most pobj to
of prep most
its poss factories
factories pobj of
and cc factories
research compound engineers
engineers conj factories
. punct is
Несомненно, лучший способ увидеть зависимости — увидеть дерево. В Spacy есть модуль для визуализации дерева зависимостей, а также распознанных сущностей. Посмотрим как работает, сделав это для слайса от первого до 11 токенов:
```
from spacy import displacy
displacy.render(doc[:11], style='dep', jupyter=True)
```
**Результат**
Распознавание именованных сущностей:
```
doc2 = nlp("Nasa administrator Jim Bridenstine says at the moment of launch, he was praying.")
for ent in doc2.ents:
print(ent.text, ent.label_)
displacy.render(doc2, style='ent', jupyter=True)
```
**Результат**
Nasa ORG
Jim Bridenstine PERSON
Это были самые базовых возможностей данной библиотеки.
Возможности из коробки
======================
* Находить фразы по паттернам. Live-демонстрация с возможность "похимичить": <https://explosion.ai/demos/matcher>
* Гибкая кастомизация пайплайна обработки
* Fine-tuning встроенных моделей на ваших данных и создание своих
* И другие полезности
[Подробные примеры](https://spacy.io/usage/examples)
Огромное множество полезнейших наработок для и с использованием SpaCy: <https://spacy.io/universe>, в том числе решение кореферентности, обвязка для PyTorch, готовые движки для чат-ботов и так далее.
Заключение
==========
Эта библиотека хорошо подойдёт как для разработчиков, так и для исследователей. SpaCy скрывает лишние подробности, позволяя быстро решать задачи NLP state-of-the-art решениями. При этом возможность допиливать модельки и кастомизировать пайплайн развязывает руки для новых экспериментов, чем вам я и желаю заниматься! | https://habr.com/ru/post/504680/ | null | ru | null |
# Изучаем МойОфис: как использовать макросы в редакторах документов и электронных таблиц
Привет, Хабр! Недавно в нашем корпоративном блоге мы рассказали о выходе [**новой версии**](https://habr.com/ru/company/ncloudtech/news/t/564002/) МойОфис 2021.02, в которой появились удобные инструменты для работы с [**формулами**](https://habr.com/ru/company/ncloudtech/blog/563842/) и математическими выражениями, а также со [**сводными таблицами**](https://habr.com/ru/company/ncloudtech/blog/563922/).
Помимо этого, в состав релиза 2021.02 вошел программный отладчик макрокоманд. Он проверяет исполнение кода и помогает обнаружить ошибки синтаксиса. Сегодня мы продемонстрируем возможности работы с макросами в документах на примере текстового редактора «МойОфис Текст», а заодно коснемся темы создания надстроек, которые позволят расширить функциональные возможности редактора.
---
Для начала разберёмся, что такое макросы и надстройки, в каких продуктах они представлены, для чего используются и в чём их отличия.
При работе с текстом, таблицами или иными данными пользователь выполняет различные операции с помощью выбора пункта меню или нажатия на специальную кнопку. Однако по большей части при этом выполняется только одно действие и только над выбранным диапазоном значений. Но что делать, если нужно не просто выполнить некую последовательность действий, но ещё и повторить её несколько раз, используя при этом разные наборы данных? Или даже расширить функции обработки, добавить что-то своё, чего еще не было реализовано в редакторе? Для этого и существуют макросы и надстройки.
> **Макрос** — это программный алгоритм, небольшой кусок кода, который позволяет пользователю автоматизировать ту или иную последовательность действий в конкретном открытом документе — например, это может быть автоматическое редактирование документа с заменой символа минус на тире, переводом кавычек в «елочки» и расстановкой символов конца абзаца до нужного значения.
>
> **Надстройка** — программный модуль, который подключается в редактор и может работать не только с данными внутри конкретного документа, но и с другими документами, а также выполнять иные действия, включая операции с файлами.
>
>
МойОфис выпускает несколько продуктов для работы с документами и коммуникациями, — как для коммерческих, так и для частных пользователей. И тем и другим доступны макрокоманды, с которыми можно работать прямо в документах. Напомним, что продукт «МойОфис Стандартный. Домашняя версия» доступен для некоммерческого использования, бесплатен и не содержит рекламы. Его можно скачать [**с нашего сайта**](https://myoffice.ru/products/standard-home-edition/), а также в магазинах приложений [**Windows Store**](https://www.microsoft.com/store/productId/9NP3B3GJM0L7) и [**Mac App Store**](https://apps.apple.com/ru/app/id1548915000). А вот работать с надстройками смогут только коммерческие пользователи, которые приобрели «МойОфис Стандартный».
Для написания макросов и надстроек в МойОфис используется свободный скриптовый язык программирования Lua. Этот кросс-платформенный язык легок в освоении и обладает достаточно широкими возможностями. В настоящий момент в МойОфис реализована поддержка Lua версии 5.3.2.
Отметим, что во всемирно известном офисном ПО Microsoft Office для создания макрокоманд применяется другая технология — VBA (Visual Basic for Applications), специальная версия языка Visual Basic для автоматизации действий внутри документов прикладного ПО. Но мы, как производитель программных продуктов, в силу существующих лицензионных ограничений не можем использовать проприетарные технологии Microsoft. Если вы представляете организацию, которая находится в процессе миграции на российские решения, то тоже не сможете пользоваться таким инструментом.
Кроме того, конверторов из VBA в Lua не существует в принципе. Поэтому, если вам требуется работать с документами, которые содержат макросы и были ранее созданы в Microsoft Office, то вам придется переводить код макрокоманд на язык Lua. Мы понимаем, что это может быть проблемой для тех, кто переходит на отечественное ПО, и специально для наших покупателей предлагаем такие решения:
* Центр компетенций «Хаб Знаний МойОфис» разработал методологию обучения основам Lua, которая позволяет быстро научиться созданию макросов в редакторах МойОфис. Первая публичная лекция по этой методологии [**состоится 14 октября 2021 года**](https://myofficehub.ru/events/sozdanie-makrosov-v-redaktorakh-myoffice/?utm_source=habr.com&utm_medium=referral&utm_campaign=study-myoffice).
* МойОфис также предлагает полный комплекс консалтинговых услуг для покупателей наших продуктов — пользователи не останутся один на один со своими проблемами, обращайтесь в службу технической поддержки, мы поможем с решением вашей ситуации.
Для создания макросов на Lua вам точно понадобятся следующие материалы:
* [**Книга Роберта Иерузалимски**](https://dmkpress.com/catalog/computer/programming/978-5-97060-203-4/), одного из авторов языка Lua.
* [**Русскоязычное руководство по Lua версии 5.3**](https://lua.org.ru/contents_ru.html).
* «[**Руководство программиста**](https://support.myoffice.ru/products/myoffice-sdk/)» — детальное описание методов и функций, которые реализованы в библиотеке MyOffice Document API и используются для работы с макросами и надстройками в редакторах.
Как писать макросы в МойОфис
----------------------------
Сейчас мы покажем, как происходит работа с макросами и надстройками. Для начала запускаем редактор макросов, который находится в меню «Инструменты» — «Редактирование макроса».
Далее создаём новый скрипт: нажимаем на «плюс», после чего появляется название нового скрипта и возможность ввода кода. Для удобства работы можно задать произвольное название.
### Рассмотрим простой пример
Для начала сделаем скрипт, который будет выводить в документ текстовую строку с фразой «Привет, Мир!». Для этого нам потребуется совершить несколько базовых действий. Сначала с помощью метода *Document:getRange* предоставим доступ ко всему документу как области данных:
```
local range = document:getRange()
```
Далее нужно определить позицию: в какую часть документа мы будем вставлять текст. В нашем случае — это конец документа. Определим значение переменной pos, которая будет отражать позицию в документе, и сделаем это с помощью метода *Range:getEnd*. Учтите, что этот метод возвращает позицию в конце фрагмента текстового документа, не включая последний символ paragraph mark. Если требуется определить позицию в начале документа, то пользуйтесь методом *Range:getBegin*.
```
local pos = range:getEnd()
```
Теперь воспользуемся методом *Position:insertText* и вставим строку с нужным нам текстом в определенную выше позицию в документе.
```
pos:insertText("Привет, Мир!")
```
Наш первый макрос будет выглядеть следующим образом:
После нажатия кнопки «Выполнить», в отладчике вы увидите сообщение «Макрос выполнен успешно», а в самом документе появится строка «Привет, Мир!»:
### Как с помощью макросов в МойОфис посчитать число символов в документе
Попробуем сделать пример посложнее. Представим типовую задачу — нужно посчитать количество символов и слов в документе. Оставим от предыдущего примера переменные *range* и *pos*, они нам еще пригодятся.
```
local range = document:getRange()
local pos = range:getEnd()
```
Теперь с помощью метода *text = range:extractText()* преобразуем тело документа в одну текстовую строку. При работе с этим методом находящиеся внутри области изображения, таблицы и прочие подобные элементы документа игнорируются.
Перейдем к подсчету символов. Сделать это очень просто — нам нужно лишь определить длину строки, и для этого можно было бы воспользоваться простой функцией *len()*. Однако, в случае с кириллическими символами в строке, Lua будет считать длину строки неправильно, т.к. на каждый такой символ будет приходиться два бита, а не один, как в случае с латиницей или цифрами. К счастью, в Lua 5.3 появилась поддержка кодировки UTF-8, которой мы и воспользуемся. Введем переменную *Allsymbols*, которую определим с помощью функции *utf8.len()*:
```
Allsymbols = utf8.len(text)
```
Неотъемлемой частью любого документа являются символы конца абзаца. Их может быть произвольное количество, и для правильного подсчета числа символов их надо удалить из результата, который мы получили выше с помощью *utf8.len()*. Но сначала нужно посчитать, сколько символов конца абзаца попало в строку при выгрузке с помощью метода *extractText()*. Для этого нам понадобится несколько строк кода. В них мы сперва определим значение переменной *newLine* равным нулю, а затем, с помощью простого цикла подсчитаем в выгруженном объеме текста общее количество всех символов конца абзаца. Используем для этого стандартную функцию *string.gmatch*, в аргументах которой указываем где искать (*text*) и что искать (*"\n"*).
```
local newLine = 0
for text in string.gmatch(text, "\n") do
newLine = newLine + 1
end
```
Теперь осталось лишь вычесть из общего числа символов *AllSymbols* число символов конца абзаца *newLine*. Введем новую переменную *Symb*:
```
Symb = Allsymbols – newLine
```
Перейдем к подсчёту слов. С этим дело обстоит несколько сложнее — для определения числа слов нам потребуется воспользоваться функцией *gsub* (глобальная замена) и регулярным выражением.
```
_,Word = text:gsub("%S+","")
```
Механика подсчета следующая: с помощью функции *gsub* мы определяем в строке слова, которые разделены пробелами. В этом нам помогает регулярное выражение *%S+*, с помощью которого определяются все элементы строки, не являющиеся пробелами. Так мы получаем все элементы, которые в строке отделены пробелами. И от функции *gsub* нам нужен не результат преобразования строки, а лишь число найденных элементов. Для этого мы определяем переменную *Word* как второй результат функции *gsub* и указываем это с помощью символа подчеркивания.
Следующая часть кода — создание таблицы, куда поместим найденные значения.
Для этого построим такую конструкцию: простую таблицу из двух строк и двух колонок (определяется переменной t\_id), которая будет сопровождаться заголовком «Выводы»:
```
pos:insertText("Выводы")
t_id = pos:insertTable(2,2,"SomeTable")
```
Теперь осталось сформировать таблицу и вывести в нее результат.
```
local tbl= document:getBlocks():getTable(t_id)
```
Для этого определим переменную *tbl*, которая с помощью методов *document:getBlocks()* и *getTable()* формирует таблицу в документе с заданными в переменной *t\_id* значениями: 2 строки, 2 столбца, название «*Some Table*».
Далее нам остается только заполнить таблицу.
```
tbl:getCell(DocumentAPI.CellPosition(0,0)):setText("Количество символов")
tbl:getCell(DocumentAPI.CellPosition(1,0)):setText("Количество слов")
tbl:getCell(DocumentAPI.CellPosition(0,1)):setText(tostring(Symb))
tbl:getCell(DocumentAPI.CellPosition(1,1)):setText(tostring(Word))
```
Для этого используем метод *getCell* для получения доступа к конкретной ячейке таблицы. Саму ячейку выбираем с помощью функции *DocumentAPI.CellPosition*, в аргументах которой начиная с нуля указываем номер строки и столбца. Затем, с помощью метода *setText* присваиваем ячейке текстовое значение типа «Текстовый», и выводим в нее нужную нам фразу. В случае с результатом вычислений, нам потребуется еще и преобразовать число в текст с помощью функции *tostring*.
В итоге получаем такой код макроса:
```
local range = document:getRange()
local pos = range:getEnd()
text = range:extractText()
Allsymbols = utf8.len(text)
local newLine = 0
for text in string.gmatch(text, "\n") do
newLine = newLine + 1
end
Symb = Allsymbols - newLine
_,Word = text:gsub("%S+","")
pos:insertText("Выводы")
t_id = pos:insertTable(2,2,"SomeTable")
local tbl= document:getBlocks():getTable(t_id)
tbl:getCell(DocumentAPI.CellPosition(0,0)):setText("Количество символов")
tbl:getCell(DocumentAPI.CellPosition(1,0)):setText("Количество слов")
tbl:getCell(DocumentAPI.CellPosition(0,1)):setText(tostring(Symb))
tbl:getCell(DocumentAPI.CellPosition(1,1)):setText(tostring(Word))
```
Вставляем код в соответствующее поле. При этом части кода маркируются разными цветами для лучшей читаемости. Назовем наш макрос «Символы».
Можно сразу запустить программу с помощью кнопки выполнить, либо использовать режим отладки (кнопка отладить). При необходимости вы можете установить контрольные точки на важных строках кода, чтобы отладчик на них останавливался. Для этого кликните по пустому серому полю между номером строки и её представлением в поле ввода кода макроса.
Если в коде есть какие-то проблемы (в нашем случае была осознанно удалена буква m в слове document на 13 строке), то при отладке, в левом нижнем поле красным будет обозначена ошибка, а строка с ней помечена зелёной стрелкой.
Если мы устраним проблему и вернем букву m в слово docuent, а затем нажмем кнопку "Выполнить", то отладчик сообщит об успешном выполнении кода макроса:
Посмотрим, как макрос срабатывает на реальном примере. В качестве тестового материала используем пару абзацев текста-«рыбы» Lorem ipsum. Заходим в редактор макросов, выбираем скрипт и запускаем его. После запуска в поле Output появляется сообщение об успешном выполнении.
Результат работы макроса — небольшая сгенерированная табличка, расположенная ниже исходного текста.
### Как запускать макросы из боковой панели редакторов МойОфис
Ещё один способ запуска скрипта в документе — это открытие панели запуска макросов. В поле под строкой «Поиск» будут перечислены все макросы данного документа.
Если навести курсор на строчку с желаемым макросом, появляются две дополнительных кнопки-символа — запуск и редактирование кода. Также запускать макрос можно двойным щелчком по названию.
Вы можете добавлять новые скрипты и изменять их при необходимости. Разумеется, использовать макросы можно не только в текстовым редакторе, но и в табличном — благодаря широким возможностям языка Lua.
Как писать надстройки в МойОфис
-------------------------------
В отличие от макросов, надстройка представляет собой отдельный архивный Zip-файл с расширением .mox. Внутри архива могут содержаться различные файлы и каталоги, включая обязательные: файл регистрации надстройки, файл сценария надстройки и файл, содержащий текст лицензионного соглашения с конечным пользователем EULA.
Файл регистрации надстройки является тестовым документом и должен называться Package.lua. Внутри него содержатся ключи и их значения. Некоторые ключи являются обязательными, другие — нет. Подробный перечень ключей, их описания и другие полезные материалы для разработки собственных модулей вы можете найти в «[**Руководстве программиста**](https://support.myoffice.ru/products/myoffice-sdk/)» [**на сайте МойОфис**](https://support.myoffice.ru/products/myoffice-sdk/).
```
local Package = {
vendor = "МойОфис",
description = "Это пример расширения для МойОфис",
extensionID = "com.example.entryform",
extensionName = "Тестовое Расширение",
extensionVersion = {
major = 1,
minor = 1,
patch = 0,
build = "" },
applicationId = "MyOffice Text",
apiVersion = {
major = 1,
minor = 0 },
commandsProvider = "cmd/entryform.lua",
fallbackLanguage = 'en',
onLoad = "cmd/entryform-prep.lua",
onUnload = "cmd/entryform-prep.lua"
}
return Package
```
Файл сценария надстройки называется так, как указано в значении ключа commandsProvider файла регистрации, и включает в себя все команды управления надстройкой и описание функций. Команды будут отображаться в виде подпунктов в меню надстроек.
```
Actions = {}
function Actions.getCommands()
return {
{
id = "EntryForm.addLines",
menuItem = "Добавить строку",
command = Actions.addLines
}
}
end
function Actions.addLines(context)
context.doWithDocument(function(document)
local rng = document:getRange()
local begin_pos = rng:getBegin()
begin_pos:insertText("Эта строка вставлена с помощью расширения \n")
end)
end
return Actions
```
```
local Actions = {}
function Actions.onLoadExtension()
-- Подготовка ресурсов для надстройки
end
function Actions.onUnloadExtension()
-- Освобождение ресурсов для надстройки
end
return Actions
```
Осталось только создать файл лицензии LICENSE и поместить его в папку META-INF.
Теперь упаковываем всё это в Zip-архив и меняем расширение на .mox. Всё готово! Можем устанавливать.
Установка и запуск надстроек МойОфис
------------------------------------
Процесс установки прост и понятен. Выбираем в меню «Надстройки» — «Управление надстройками». В появившемся окне нажимаем на единственную кнопку «Установить» и указываем нужный файл расширения.
Читаем и принимаем лицензионное соглашение. В случае отказа установка будет прервана.
Готово! Надстройка установлена и появилась в списке.
Тут же можно посмотреть информацию о ней, отключить ее или полностью удалить из приложения.
Запускается надстройка и выбираются команды также через раздел «Надстройки». После установки в нём появится название надстройки и список команд в выпадающем меню.
Нажимаем на единственную команду и видим результат — вставленную строчку.
Итог
----
В статье мы показали разницу между макросами и надстройками и продемонстрировали на примерах лишь малую часть их возможностей. Вы легко можете разработать свою надстройку, скомпилировать внешние модули для использования в её составе и расширить функциональные возможности программ МойОфис под свои запросы.
Напомним, что на нашем сайте и в магазинах операционных систем можно [**бесплатно загрузить и опробовать редакторы МойОфис**](https://myoffice.ru/products/standard-home-edition/). Специально для наших пользователей мы также подготовили «[**Руководство программиста**](https://support.myoffice.ru/products/myoffice-sdk/)», которое содержит подробное описание функций, команд и прочую необходимую документацию для работы с макросами и надстройками.
Нам интересны ваши впечатления от реализации функциональности макрокоманд в редакторах МойОфис. Пожалуйста, расскажите в комментариях, удобно ли пользоваться таким решением, корректно ли работает отладчик макрокоманд на ваших скриптах, и каких дополнительных возможностей вам не хватает в наших редакторах. Как вы думаете, какие макросы, в том числе созданные вами, могут быть полезны для продуктов МойОфис?
Будем рады любым конструктивным откликам; возможно, именно ваши идеи окажут существенное влияние на развитие технологий автоматизации в наших продуктах. Мы внимательно изучим обратную связь и подарим памятные подарки авторам лучших на наш взгляд предложений. | https://habr.com/ru/post/575336/ | null | ru | null |
# Практическое знакомство с пакетным менеджером для Kubernetes — Helm
Статья является логическим продолжение нашей [недавней публикации](https://habr.com/company/flant/blog/417079/) об истории пакетного менеджера для Kubernetes — [**Helm**](https://helm.sh/). В этот раз мы снова затронем вопросы устройства и функционирования нынешнего Helm (**версия 2.x**), а также управляемых им чартов и репозиториев, после чего перейдём к практике: установке Helm в кластер Kubernetes и использованию чартов.
Вступление
----------
**Helm — инструмент для управления чартами.**
**Чарт** описывает необходимый набор данных для создания экземпляра приложения в кластере Kubernetes. Он может иметь вложенные чарты и использоваться как для описания полноценных сервисов, состоящих из множества зависимых ресурсов, так и для описания отдельных независимых составляющих. К примеру, чарт [stable/gitlab-ce](https://github.com/helm/charts/tree/master/stable/gitlab-ce) описывает комплексное решение с [использованием](https://github.com/helm/charts/blob/8bcad6ca54c8580e7ec79012ddca250631047b43/stable/gitlab-ce/requirements.yaml#L1-L7) независимых чартов redis и postgresql.
Чарт может быть установлен неограниченное количество раз в одном и том же кластере. Таким образом, описание логики выката приложения в разные окружения может и должно храниться в одном чарте.
Клиентская часть Helm отвечает за формирование чарта и передачу вместе с пользовательскими параметрами находящемуся в кластере Kubernetes компоненту **Tiller**. В свою очередь, Tiller отвечает за жизненный цикл экземпляра запущенного чарта, релиза. *(На всякий случай напомню, что в следующем крупном обновлении Helm — версии 3 — уже не будет Tiller.)*
А теперь — обо всём по порядку.
Установка и обновление
----------------------
Для работы с Helm требуется Kubernetes. Можно использовать локально установленный [Minikube](https://kubernetes.io/docs/setup/minikube/) *(см. также «[Начало работы в Kubernetes с помощью Minikube](https://habr.com/company/flant/blog/333470/)»)* или любой другой доступный кластер.
Начнём с установки клиента: выбираем [релиз](https://github.com/kubernetes/helm/releases), скачиваем и распаковываем архив для своей системы, переносим исполняемый файл…
```
$ curl https://storage.googleapis.com/kubernetes-helm/helm-v2.10.0-linux-amd64.tar.gz | tar -zxv
$ sudo mv linux-amd64/helm /usr/local/bin/helm
```
Далее установка Tiller в кластер. По умолчанию Tiller устанавливается в **кластер контекста `kubectl`** (`kubectl config current-context`), в **пространство имён `kube-system`**, но это можно изменить, используя соответствующие опции и переменные окружения — они описаны в справке (`helm init --help`). Выполним установку и посмотрим на созданные ресурсы в кластере:
```
$ helm init
$HELM_HOME has been configured at /home/habr/.helm.
(Use --client-only to suppress this message, or --upgrade to upgrade Tiller to the current version.)
Happy Helming!
$ kubectl get all --selector=name=tiller --namespace kube-system
NAME READY STATUS RESTARTS AGE
po/tiller-deploy-df4fdf55d-h5mvh 0/1 Running 0 5s
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE
svc/tiller-deploy 10.107.191.68 44134/TCP 5s
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
deploy/tiller-deploy 1 1 1 0 5s
NAME DESIRED CURRENT READY AGE
rs/tiller-deploy-df4fdf55d 1 1 0 5s
```
Теперь Tiller установлен в кластер и готов к управлению релизами, взаимодействию с Kubernetes API.
***Примечание**: При установке и обновлении (опция `--upgrade`) Tiller'а можно **задавать конкретный образ** вместо использования последнего стабильного релиза по умолчанию. Имя произвольного образа определяется опцией `--tiller-image`, а с опцией `--canary-image` при выкате Tiller будет использован canary-образ. Сanary-образ позволяет использовать Tiller, версия кода которого соответствует ветке master.*
Служебные данные хранятся в кластере в специальных ресурсах, `ConfigMaps`, поэтому удаление и переустановка Tiller'а не приводят к потере данных установленных ранее релизов.
Репозитории чартов
------------------
Репозиторий чартов — HTTP-сервер для хранения и распространения чартов. Информация о чартах в репозитории хранится в файле `index.yaml`. В нём же указывается, откуда каждый чарт может быть загружен. Чаще всего чарты хранятся вместе с файлом `index.yaml`, но ничего не мешает разместить их на другом сервере. Обычно файловая структура сводится к плоской форме:
```
.
├── index.yaml
├── artifactory-7.3.0.tgz
├── docker-registry-1.5.2.tgz
...
└── wordpress-2.1.10.tgz
```
По умолчанию Helm использует [официальный репозиторий чартов Kubernetes](https://github.com/helm/charts). Он содержит тщательно проработанные актуальные чарты для решения множества прикладных задач. Этот репозиторий именуется **stable**:
```
$ helm repo list
NAME URL
stable https://kubernetes-charts.storage.googleapis.com
```
При необходимости **создание** собственного репозитория не составит никаких проблем. Требования к серверу — минимальные, поэтому, как и большинство публичных репозиториев чартов, его можно разместить на GitHub Pages. Подробнее про инструменты и необходимые для этого шаги можно почитать в [документации](https://github.com/helm/helm/blob/master/docs/chart_repository.md).
При использовании репозиториев чартов они могут быть добавлены и удалены. Для того, чтобы версии чартов были актуальными, необходимо периодически обновлять индекс. Приведу пример для публичного репозитория [bitnami](https://github.com/bitnami/charts), большая часть чартов которого используется в официальном репозитории Helm:
```
$ helm repo add bitnami https://charts.bitnami.com/bitnami
"bitnami" has been added to your repositories
$ helm repo update
Hang tight while we grab the latest from your chart repositories...
...Successfully got an update from the "bitnami" chart repository
...Successfully got an update from the "stable" chart repository
Update Complete. Happy Helming!
$ helm repo remove bitnami
"bitnami" has been removed from your repositories
```
Далее — **поиск** по репозиториям. Вызов `helm search` без аргументов показывает все доступные чарты:
```
$ helm search
NAME CHART VERSION APP VERSION DESCRIPTION
stable/acs-engine-autoscaler 2.2.0 2.1.1 Scales worker nodes within agent pools
stable/aerospike 0.1.7 v3.14.1.2 A Helm chart for Aerospike in Kubernetes
stable/anchore-engine 0.2.1 0.2.4 Anchore container analysis and policy evaluation engine s...
stable/apm-server 0.1.0 6.2.4 The server receives data from the Elastic APM agents and ...
stable/ark 1.2.1 0.9.1 A Helm chart for ark
stable/artifactory 7.3.0 6.1.0 Universal Repository Manager supporting all major packagi...
...
stable/weave-cloud 0.2.2 0.2.0 Weave Cloud is a add-on to Kubernetes which provides Cont...
stable/weave-scope 0.9.3 1.6.5 A Helm chart for the Weave Scope cluster visualizer.
stable/wordpress 2.1.10 4.9.8 Web publishing platform for building blogs and websites.
stable/xray 0.4.1 2.3.0 Universal component scan for security and license invento...
stable/zeppelin 1.0.1 0.7.2 Web-based notebook that enables data-driven, interactive ...
stable/zetcd 0.1.9 0.0.3 CoreOS zetcd Helm chart for Kubernetes
```
В необязательном поле `keywords` в `Chart.yaml` разработчики указывают теги, которые используются для упрощения поиска в репозиториях чартов:
```
$ helm search web
NAME CHART VERSION APP VERSION DESCRIPTION
stable/cerebro 0.3.1 0.8.1 A Helm chart for Cerebro - a web admin tool that replaces...
stable/chronograf 0.4.5 1.3 Open-source web application written in Go and React.js th...
stable/jasperreports 2.0.4 7.1.0 The JasperReports server can be used as a stand-alone or ...
stable/joomla 2.0.9 3.8.12 PHP content management system (CMS) for publishing web co...
stable/kubernetes-dashboard 0.7.2 1.8.3 General-purpose web UI for Kubernetes clusters
stable/odoo 2.0.7 11.0.20180815 A suite of web based open source business apps.
stable/phabricator 2.1.9 2018.34.0 Collection of open source web applications that help soft...
stable/redmine 4.1.0 3.4.6 A flexible project management web application.
stable/rethinkdb 0.1.4 0.1.0 The open-source database for the realtime web
stable/schema-registry-ui 0.1.0 v0.9.4 This is a web tool for the confluentinc/schema-registry i...
stable/superset 0.1.2 0.24.0 Apache Superset (incubating) is a modern, enterprise-read...
stable/testlink 2.0.3 1.9.17 Web-based test management system that facilitates softwar...
stable/tomcat 0.1.0 7 Deploy a basic tomcat application server with sidecar as ...
stable/wordpress 2.1.10 4.9.8 Web publishing platform for building blogs and websites.
...
$ helm search cms blog
NAME CHART VERSION APP VERSION DESCRIPTION
stable/drupal 1.1.3 8.5.6 One of the most versatile open source content management ...
stable/joomla 2.0.9 3.8.12 PHP content management system (CMS) for publishing web co...
stable/wordpress 2.1.10 4.9.8 Web publishing platform for building blogs and websites
```
***Примечание:** При использовании команды `helm search` можно столкнуться с нестабильной работой нескольких фильтров: наличие результата зависит от порядка указания и количества фильтров.*
После того, как круг поисков сузился до нескольких вариантов, можно перейти к более детальному анализу чартов — с помощью команды `helm inspect`. Она выводит содержимое файлов чарта `Chart.yaml`, `values.yaml` и `README.md`. Каждый раздел по отдельности можно вывести с соответствующими аргументами: `chart`, `values` и `readme`.
В официальном репозитории чарты прекрасно документированы и содержат примеры использования, а некоторые чарты — даже готовые конфигурации для **production**. К примеру, хороший `readme` представлен у [stable/wordpress](https://github.com/helm/charts/blob/master/stable/wordpress/README.md) *(для его вывода в консоли см. `helm inspect readme stable/wordpress`)*.
Поиск — это хороший способ найти доступные пакеты. После того, как пакет найден, можно использовать его для установки приложения в кластер.
Первое приложение
-----------------
Для примера выбран уже упомянутый чарт [stable/wordpress](https://github.com/helm/charts/blob/master/stable/wordpress).
В нём используются параметры, описанные в файле `values.yaml`. Параметры можно переопределить в YAML-файле, а затем передать этот файл во время установки (опции `-f`, `--values`). Кроме того, их можно переопределить непосредственно в командной строке (опции `--set`, `--set-string` и `--set-file`). Все опции доступны для использования произвольное количество раз; при этом переопределение в командной строке имеет больший приоритет над файлами с параметрами.
При установке чарта можно задать имя релизу опцией `--name` или использовать случайное имя, сгенерированное Helm.
Установим чарт с [конфигурацией для production](https://github.com/helm/charts/blob/master/stable/wordpress/values-production.yaml), поменяем название блога, отключим сохранение данных WordPress в `PersistentVolumeClaim` *(подробнее про постоянные хранилища см. в [документации Kubernetes](https://kubernetes.io/docs/concepts/storage/persistent-volumes/))*:
```
$ curl https://raw.githubusercontent.com/helm/charts/master/stable/wordpress/values-production.yaml --output values-production.yaml
$ helm install --name habr --set "wordpressBlogName=Flant's Blog!" --set "persistence.enabled=false" -f values-production.yaml stable/wordpress
NAME: habr
LAST DEPLOYED: Fri Aug 31 15:17:57 2018
NAMESPACE: default
STATUS: DEPLOYED
RESOURCES:
==> v1/Secret
NAME TYPE DATA AGE
habr-mariadb Opaque 2 0s
habr-wordpress Opaque 2 0s
==> v1/ConfigMap
NAME DATA AGE
habr-mariadb-init-scripts 1 0s
habr-mariadb 1 0s
habr-mariadb-tests 1 0s
==> v1/Service
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
habr-mariadb ClusterIP 10.111.7.232 3306/TCP 0s
habr-wordpress ClusterIP 10.106.129.88 80/TCP,443/TCP 0s
==> v1beta1/Deployment
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
habr-wordpress 3 3 3 0 0s
==> v1beta1/StatefulSet
NAME DESIRED CURRENT AGE
habr-mariadb 1 1 0s
==> v1beta1/Ingress
NAME HOSTS ADDRESS PORTS AGE
wordpress.local-habr wordpress.local 80, 443 0s
==> v1/Pod(related)
NAME READY STATUS RESTARTS AGE
habr-wordpress-7955b95fd-hh7b9 0/1 ContainerCreating 0 0s
habr-wordpress-7955b95fd-tgsxk 0/1 ContainerCreating 0 0s
habr-wordpress-7955b95fd-xjz74 0/1 ContainerCreating 0 0s
habr-mariadb-0 0/1 ContainerCreating 0 0s
NOTES:
1. Get the WordPress URL:
You should be able to access your new WordPress installation through
https://wordpress.local/admin
2. Login with the following credentials to see your blog
echo Username: user
echo Password: $(kubectl get secret --namespace default habr-wordpress -o jsonpath="{.data.wordpress-password}" | base64 --decode)
```
В случае работы с полноценным кластером далее можно следовать рекомендациям из блока *NOTES* выше. Если же у вас Minikube — откройте сайт в браузере следующим образом:
```
$ minikube service habr-wordpress
Waiting, endpoint for service is not ready yet...
Opening kubernetes service default/habr-wordpress in default browser...
```
Поздравляю, приложение в кластере!
Развёрнутый чарт с WordPress появился в списке всех релизов Helm:
```
$ helm list
NAME REVISION UPDATED STATUS CHART APP VERSION NAMESPACE
habr 1 Fri Aug 31 15:17:57 2018 DEPLOYED wordpress-2.1.10 4.9.8 default
```
Следующим шагом обновим наш релиз и изменим образ с блогом. Для примера будет использован другой тег из того же Docker-репозитория (`4.9.8-ol-7`):
```
$ helm upgrade habr --set "image.tag=4.9.8-ol-7" --set "wordpressBlogName=Flant's Blog!" --set "persistence.enabled=false" -f values-production.yaml stable/wordpress
Release "habr" has been upgraded. Happy Helming!
LAST DEPLOYED: Fri Aug 31 15:21:08 2018
NAMESPACE: default
STATUS: DEPLOYED
RESOURCES:
==> v1/Service
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
habr-mariadb ClusterIP 10.111.7.232 3306/TCP 3m
habr-wordpress ClusterIP 10.106.129.88 80/TCP,443/TCP 3m
==> v1beta1/Deployment
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
habr-wordpress 3 4 2 0 3m
==> v1beta1/StatefulSet
NAME DESIRED CURRENT AGE
habr-mariadb 1 1 3m
==> v1beta1/Ingress
NAME HOSTS ADDRESS PORTS AGE
wordpress.local-habr wordpress.local 80, 443 3m
==> v1/Pod(related)
NAME READY STATUS RESTARTS AGE
habr-wordpress-66f4fd6b74-gqwhh 0/1 Pending 0 0s
habr-wordpress-66f4fd6b74-mf6vj 0/1 Pending 0 0s
habr-wordpress-7955b95fd-hh7b9 1/1 Running 2 3m
habr-wordpress-7955b95fd-tgsxk 1/1 Running 2 3m
habr-wordpress-7955b95fd-xjz74 0/1 Terminating 2 3m
habr-mariadb-0 1/1 Running 0 3m
==> v1/Secret
NAME TYPE DATA AGE
habr-mariadb Opaque 2 3m
habr-wordpress Opaque 2 3m
==> v1/ConfigMap
NAME DATA AGE
habr-mariadb-init-scripts 1 3m
habr-mariadb 1 3m
habr-mariadb-tests 1 3m
NOTES:
1. Get the WordPress URL:
You should be able to access your new WordPress installation through
https://wordpress.local/admin
2. Login with the following credentials to see your blog
echo Username: user
echo Password: $(kubectl get secret --namespace default habr-wordpress -o jsonpath="{.data.wordpress-password}" | base64 --decode)
```
Обратите внимание, что **при обновлении** Tiller сравнивает полученный чарт с параметрами с последним сохранённым и выполняет соответствующие запросы в Kubernetes API, а **актуальное состояние ресурсов релиза не берётся в расчёт**. Важно понимать эту особенность и не совершать ошибок:
* Обновление ничем не отличается от инсталяции: Helm-клиент отправляет Tiller чарт вместе с параметрами, поэтому надо быть внимательнее и не забыть указать параметры и файлы с параметрами, которые задавались при инсталяции (или при предыдущем обновлении) и которые не должны быть проигнорированы. В примере выше — это `--set "wordpressBlogName=Flant's Blog!" --set "persistence.enabled=false" -f values-production.yaml`.
* Приложения, которые выкатываются при помощи Helm, должны обслуживаться только с использованием Helm: изменения, сделанные вручную при помощи `kubectl`, не будут учтены Helm и могут приводить к необратимым последствиям.
Отсюда логичное заключение: **процесс должен быть автоматизирован**, а изменения должны выполняться только через коммит в Git-репозиторий, изменения файлов чарта и конфигурационного файла CI.
Состояние компонентов релиза приложения в кластере всегда можно проверить следующим образом:
```
$ helm status habr
LAST DEPLOYED: Fri Aug 31 15:21:08 2018
NAMESPACE: default
STATUS: DEPLOYED
RESOURCES:
==> v1/Secret
NAME TYPE DATA AGE
habr-mariadb Opaque 2 4m
habr-wordpress Opaque 2 4m
==> v1/ConfigMap
NAME DATA AGE
habr-mariadb-init-scripts 1 4m
habr-mariadb 1 4m
habr-mariadb-tests 1 4m
==> v1/Service
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
habr-mariadb ClusterIP 10.111.7.232 3306/TCP 4m
habr-wordpress ClusterIP 10.106.129.88 80/TCP,443/TCP 4m
==> v1beta1/Deployment
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
habr-wordpress 3 4 2 3 4m
==> v1beta1/StatefulSet
NAME DESIRED CURRENT AGE
habr-mariadb 1 1 4m
==> v1beta1/Ingress
NAME HOSTS ADDRESS PORTS AGE
wordpress.local-habr wordpress.local 80, 443 4m
==> v1/Pod(related)
NAME READY STATUS RESTARTS AGE
habr-wordpress-66f4fd6b74-gqwhh 0/1 Pending 0 1m
habr-wordpress-66f4fd6b74-mf6vj 1/1 Running 0 1m
habr-wordpress-7955b95fd-hh7b9 1/1 Running 3 4m
habr-wordpress-7955b95fd-tgsxk 1/1 Running 3 4m
habr-mariadb-0 1/1 Running 1 4m
NOTES:
1. Get the WordPress URL:
You should be able to access your new WordPress installation through
https://wordpress.local/admin
2. Login with the following credentials to see your blog
echo Username: user
echo Password: $(kubectl get secret --namespace default habr-wordpress -o jsonpath="{.data.wordpress-password}" | base64 --decode)
```
Helm позволяет **откатываться до определённой ревизии релиза**. На текущий момент ревизий две:
```
$ helm history habr
REVISION UPDATED STATUS CHART DESCRIPTION
1 Fri Aug 31 15:17:57 2018 SUPERSEDED wordpress-2.1.10 Install complete
2 Fri Aug 31 15:21:08 2018 DEPLOYED wordpress-2.1.10 Upgrade complete
```
Откатим приложения к первоначальному состоянию:
```
$ helm rollback habr 1
Rollback was a success! Happy Helming!
```
Теперь история ревизий пополнилась на одну запись:
```
$ helm history habr
REVISION UPDATED STATUS CHART DESCRIPTION
1 Fri Aug 31 15:17:57 2018 SUPERSEDED wordpress-2.1.10 Install complete
2 Fri Aug 31 15:21:08 2018 SUPERSEDED wordpress-2.1.10 Upgrade complete
3 Fri Aug 31 15:25:06 2018 DEPLOYED wordpress-2.1.10 Rollback to 1
```
Статья подходит к концу и релиз больше не требуется?
```
$ helm delete habr
release "habr" deleted
```
А удалён ли он в действительности?..
**Команда удаляет Kubernetes-ресурсы, связанные с релизом, но не сам релиз**. Вся информация о релизе остаётся доступной, в том числе и его история:
```
$ helm list --all
NAME REVISION UPDATED STATUS CHART APP VERSION NAMESPACE
habr 3 Fri Aug 31 15:25:06 2018 DELETED wordpress-2.1.10 4.9.8 default
```
```
$ helm history habr
REVISION UPDATED STATUS CHART DESCRIPTION
1 Fri Aug 31 15:17:57 2018 SUPERSEDED wordpress-2.1.10 Install complete
2 Fri Aug 31 15:21:08 2018 SUPERSEDED wordpress-2.1.10 Upgrade complete
3 Fri Aug 31 15:25:06 2018 DELETED wordpress-2.1.10 Deletion complete
```
***Примечание**: По задумке, удалённый релиз можно откатывать к предыдущим версиям, но в последних версиях эта возможность не работает — подробности см. в [issue #3722](https://github.com/helm/helm/issues/3722).*
Для полного удаления релиза используется опция `--purge`:
```
$ helm delete --purge habr
release "habr" deleted
```
Резюмируя
---------
В этой статье рассказано про базовую архитектуру Helm 2, его компоненты и их функций, а также об основных примитивах, чартах, релизах и репозиториях чартов. Мы установили Helm в кластер Kubernetes и получили понимание жизненного цикла релиза и основных команд для работы с ним.
Следующий материал из этого цикла будет посвящён теме **создания собственного чарта** — в нём я расскажу про структуру чарта, шаблонизацию и инструменты отладки. **ОБНОВЛЕНО**: Новая статья доступна по [этой ссылке](https://habr.com/ru/company/flant/blog/423239/).
P.S.
----
* «[Создание пакетов для Kubernetes с Helm: структура чарта и шаблонизация](https://habr.com/company/flant/blog/423239/)»;
* «[Пакетный менеджер для Kubernetes — Helm: прошлое, настоящее, будущее](https://habr.com/company/flant/blog/417079/)»;
* «[Практика с dapp. Часть 2. Деплой Docker-образов в Kubernetes с помощью Helm](https://habr.com/company/flant/blog/336170/)»;
* «[Сборка и дeплой приложений в Kubernetes с помощью dapp и GitLab CI](https://habr.com/company/flant/blog/345580/)»;
* «[Лучшие практики CI/CD с Kubernetes и GitLab](https://habr.com/company/flant/blog/345116/)» *(обзор и видео доклада)*. | https://habr.com/ru/post/420437/ | null | ru | null |
# Podget + rsync + BashPod + GUI = KBashPod для подкастофилов
#### Вступление
В прошлой серии мы Вам рассказали о том, как собирались [“убивать” FineReader](http://habrahabr.ru/blogs/linux/109052/#habracut). Однако это было далеко не первое начинание нашего дуэта. В этот раз центром нашего повествования станет программа KbashPod. Которая создана для пользователей Linux, постоянно прослушивающих подкасты на своем ПК и мобильных устройствах.
[](http://kde-apps.org/content/show.php?content=134656)
Каждый из авторов программы уделяет некоторое время прослушиванию подкастов. При чем в процессе прослушивания задействованы как мобильные устройства, так и стационарный ПК. А в самом процессе решаются такие задачи как:
* актуализация БД подкастов (добавление новых подкастов или удаление старых);
* загрузка новых подкастов по мере их выхода;
* удаление ранее заруженых подкастов;
* синхронизация подкастов между ПК и мобильным устройством.
Первые три пункта без проблем решаются консольной утилитой podget, последняя rsync. Ну и само собой, все эти задачи решаемые двумя программами, было логично объединить одним скриптом, автором которого является [mr-protos](http://mr-protos.ya.ru).
#### Статья Mr-Protos о создании BashPod-а
Данная статья предназначена для опытных пользователей Linux и вопросы установки пакетов, создание исполняемого файла и выбора текстового редактора для правки конфигурационных файлов опущены.
И так, начнём
В системе должны быть установлены следующие пакеты:
* libnotify-bin\*
* podget
* rsync
*Примечание:*
Пакет libnotify-bin нужен для всплывающих уведомлений, которые показывают ключевые действия скрипта или сообщают об ошибке. В различных дистрибутивах название этого пакета может отличаться, или он может входить в состав пакета libnotify.
##### Настройка podget
Запускаем в консоли podget для автоматического создания конфигурационных файлов и прерываем его работу сочетанием Ctrl + C
Редактируем файл ~/.podget/podgetrc (параметры, оставляемые по умолчанию пропущены):
Задаём место загрузки подкастов
`dir_library="место на компьютере куда будут загружаться подкасты"`
Комментируем строку, т.к. для наших целей нет необходимости в создании плей-листа
`#playlist_namebase=New-`
Включаем удаление старых подкастов
`cleanup=1`
Задаём количество дней хранения файлов до очистки
`cleanup_days=7`
Если используется файловая система FAT32, то следует раскомментировать строчку для удаления символов в названии файлов, запрещённых в данной файловой системе. Рекомендую в любом случае раскомментировать её и добавить туда символ % для более эстетичного сохранения имён файлов (даже если файловая система позволяет использовать такие символы)
`filename_badchars=!#$^&=+{}[]:;"'<>?|\`
Задаём минимально количество свободного места на диске, при котором загрузка будет остановлена. В данном примере — 600Мб
`min_space=614400`
Редактируем список адресов подкастов для загрузки (~/.podget/serverlist):
Комментируем все строки этого файла если нас не интересуют подкасты, записанные там по умолчанию.
Добавляем строчки нужных подкастов по принципу:
`<ссылка> <Категория> <Имя>`
Например:
`russianubuntupodcast.rpod.ru/rss_ynq_bbb4.xml Linux_Podcasts Russian Ubuntu Podcast`
*Примечания:*
* символы пробела в URL должны быть заменены на %20;
* название категории не должно содержать пробелов;
* сохраняться в файловой системе подкасты будут по принципу: /Папка\_с\_подкастами/Категория/Имя/выпуск\_1.mp3.
##### Создание bash-скрипта
Создаём исполняемый bash-скрипт (bashpod.sh) для синхронизации скачаных подкастов с mp3-плеером или телефоном в режиме флешки:
`#!/bin/bash
PODDIR="/место на компьютере/куда скачиваются подкасты/"
DEVICEDIR="/директория/куда монтируется устройство/проигрывающее mp3/"
notify-send 'Bashpod' 'Скачивание подкастов' ; podget -s &&
notify-send 'Bashpod' 'Синхронизация с телефоном' ; rsync -ruq --del "$PODDIR" "$DEVICEDIR" && notify-send 'Bashpod' 'Готово' || notify-send 'Bashpod' 'При работе возникли ошибки'`
Данный скрипт синхронизирует скачивает подкасты, удаляет старые и синхронизирует их с mp3-плеером. В приведённом скрипте существует возможность выведения малоинформативного сообщения об ошибках, ловить которые следует запуская скрипт из консоли.
Теперь создаём кнопку на панели и пункт меню средствами вашего DE, где прописываем название и путь к скрипту bashpod.sh.
#### KBashPod
Ну и как водится, захотелось все это вновь завернуть в красивую обвертку с красивым обличием. Так и родилась идея KbashPod для тех кому консоли оказалось мало. И теперь при монтировании носителя Вы сразу можете выбрать одним из действий синхронизацию подкастов, при помощи дружелюбного интерфейса KBashPod.
В GUI доступны основные опции настройки, такие как:
* количество скачиваемых подкастов;
* время жизни старых подкастов;
* критический размер свободного места для остановки скачивания;
* основные пути синхронизации подкастов;
* редактирование библиотеки подкастов.
Кроме того, благодаря доработке кода исходного bash-скрипта, KBashPod имеет собственные файлы конфигурации утилиты podget, размещаемые в директории /.kbashpod. Это позволяет независимо использовать саму утилиту и KBashPod. Также это избавляет от предварительного редактирования файлов ~/.podget/podgetrc и ~/.podget/serverlist, описанного в начале этой статьи.
В новой версии (1.1) программы была добавлена интеграция с KDE Solid и теперь при обнаружении нового съемного носителя информации предлагается запустить KBashPod для синхронизации подкастов. А по умолчанию в программе уже предустановленна ссылка на подкаст от одного из авторов статьи ([b0noI](http://b0noi.ya.ru)), It-sexual о котором можно более подробно узнать на [страничке подкаста](http://it-sexual.rpod.ru).
#### Ссылки
* [kde-apps.org](http://kde-apps.org/content/show.php?content=134656)
* [KBashPod x86 deb](http://kde-apps.org/content/download.php?content=134656&id=1&tan=85996148)
* [KBashPod x86 rpm](http://kde-apps.org/content/download.php?content=134656&id=2&tan=75207385)
* [KBashPod src tar.gz](http://kde-apps.org/content/download.php?content=134656&id=3&tan=68802399)
* [подкаст it-sexual, установленный в программе](http://it-sexual.rpod.ru)
##### Авторы
* [mr-protos](http://mr-protos.ya.ru)
* [b0noI](http://b0noi.ya.ru) | https://habr.com/ru/post/109296/ | null | ru | null |
# Подводные камни Terraform
[](https://habr.com/ru/company/piter/blog/496820/)
Выделим несколько подводных камней, включая те, что связаны с циклами, выражениями if и методиками развертывания, а также с более общими проблемами, которые касаются Terraform в целом:
* параметры count и for\_each имеют ограничения;
* ограничения развертываний с нулевым временем простоя;
* даже хороший план может оказаться неудачным;
* рефакторинг может иметь свои подвохи;
* отложенная согласованность согласуется… с отлагательством.
### Параметры count и for\_each имеют ограничения
В примерах этой главы параметр count и выражение for\_each активно применяются в циклах и условной логике. Они хорошо себя показывают, но у них есть два важных ограничения, о которых необходимо знать.
* В count и for\_each нельзя ссылаться ни на какие выходные переменные ресурса.
* count и for\_each нельзя использовать в конфигурации модуля.
#### В count и for\_each нельзя ссылаться ни на какие выходные переменные ресурса
Представьте, что нужно развернуть несколько серверов EC2 и по какой-то причине вы не хотите использовать ASG. Ваш код может быть таким:
```
resource "aws_instance" "example_1" {
count = 3
ami = "ami-0c55b159cbfafe1f0"
instance_type = "t2.micro"
}
```
Рассмотрим их по очереди.
Поскольку параметру count присвоено статическое значение, этот код заработает без проблем: когда вы выполните команду apply, он создаст три сервера EC2. Но если вам захотелось развернуть по одному серверу в каждой зоне доступности (Availability Zone или AZ) в рамках текущего региона AWS? Вы можете сделать так, чтобы ваш код загрузил список зон из источника данных aws\_availability\_zones и затем «циклически» прошелся по каждой из них и создал в ней сервер EC2, используя параметр count и доступ к массиву по индексу:
```
resource "aws_instance" "example_2" {
count = length(data.aws_availability_zones.all.names)
availability_zone = data.aws_availability_zones.all.names[count.index]
ami = "ami-0c55b159cbfafe1f0"
instance_type = "t2.micro"
}
data "aws_availability_zones" "all" {}
```
Этот код тоже будет прекрасно работать, поскольку параметр count может без проблем ссылаться на источники данных. Но что произойдет, если количество серверов, которые вам нужно создать, зависит от вывода какого-то ресурса? Чтобы это продемонстрировать, проще всего взять ресурс random\_integer, который, как можно догадаться по названию, возвращает случайное целое число:
```
resource "random_integer" "num_instances" {
min = 1
max = 3
}
```
Этот код генерирует случайное число от 1 до 3. Посмотрим, что случится, если мы попытаемся использовать вывод result этого ресурса в параметре count ресурса aws\_instance:
```
resource "aws_instance" "example_3" {
count = random_integer.num_instances.result
ami = "ami-0c55b159cbfafe1f0"
instance_type = "t2.micro"
}
```
Если выполнить для этого кода terraform plan, получится следующая ошибка:
```
Error: Invalid count argument
on main.tf line 30, in resource "aws_instance" "example_3":
30: count = random_integer.num_instances.result
The "count" value depends on resource attributes that cannot be determined until apply, so Terraform cannot predict how many instances will be created. To work around this, use the -target argument to first apply only the resources that the count depends on.
```
Terraform требует, чтобы count и for\_each вычислялись на этапе планирования, до создания или изменения каких-либо ресурсов. Это означает, что count и for\_each могут ссылаться на литералы, переменные, источники данных и даже списки ресурсов (при условии, что их длину можно определить во время планирования), но не на вычисляемые выходные переменные ресурса.
### count и for\_each нельзя использовать в конфигурации модуля
Когда-нибудь у вас может появиться соблазн добавить параметр count в конфигурации модуля:
```
module "count_example" {
source = "../../../../modules/services/webserver-cluster"
count = 3
cluster_name = "terraform-up-and-running-example"
server_port = 8080
instance_type = "t2.micro"
}
```
Этот код пытается использовать count внутри модуля, чтобы создать три копии ресурса webserver-cluster. Или, возможно, вам захочется сделать подключение модуля опциональным в зависимости от какого-нибудь булева условия, присвоив его параметру count значение 0. Такой код будет выглядеть вполне разумно, однако в результате выполнения terraform plan вы получите такую ошибку:
```
Error: Reserved argument name in module block
on main.tf line 13, in module "count_example":
13: count = 3
The name "count" is reserved for use in a future version of Terraform.
```
К сожалению, на момент выхода Terraform 0.12.6 использование count или for\_each в ресурсе module не поддерживается. Согласно заметкам о выпуске Terraform 0.12 (http://bit.ly/3257bv4) компания HashiCorp планирует добавить эту возможность в будущем, поэтому, в зависимости от того, когда вы читаете эту книгу, она уже может быть доступна. Чтобы узнать наверняка, [почитайте журнал изменений Terraform здесь](https://github.com/hashicorp/terraform/blob/master/CHANGELOG.md).
### Ограничения развертываний с нулевым временем простоя
Использование блока create\_before\_destroy в сочетании с ASG является отличным решением для организации развертываний с нулевым временем простоя, если не считать один нюанс: правила автомасштабирования при этом не поддерживаются. Или, если быть более точным, это сбрасывает размер ASG обратно к min\_size при каждом развертывании, что может стать проблемой, если вы использовали правила автомасштабирования для увеличения количества запущенных серверов.
Например, модуль webserver-cluster содержит пару ресурсов aws\_autoscaling\_schedule, которые в 9 утра увеличивают количество серверов в кластере с двух до десяти. Если выполнить развертывание, скажем, в 11 утра, новая группа ASG загрузится не с десятью, а всего с двумя серверами и будет оставаться в таком состоянии до 9 утра следующего дня.
Это ограничение можно обойти несколькими путями.
* Поменять параметр recurrence в aws\_autoscaling\_schedule с 0 9 \* \* \* («запускать в 9 утра») на что-то вроде 0-59 9-17 \* \* \* («запускать каждую минуту с 9 утра до 5 вечера»). Если в ASG уже есть десять серверов, повторное выполнение этого правила автомасштабирования ничего не изменит, что нам и нужно. Но если группа ASG развернута совсем недавно, это правило гарантирует, что максимум через минуту количество ее серверов достигнет десяти. Это не совсем элегантный подход, и большие скачки с десяти до двух серверов и обратно тоже могут вызвать проблемы у пользователей.
* Создать пользовательский скрипт, который применяет API AWS для определения количества активных серверов в ASG, вызвать его с помощью внешнего источника данных (см. пункт «Внешний источник данных» на с. 249) и присвоить параметру desired\_capacity группы ASG значение, возвращенное этим скриптом. Таким образом, каждый новый экземпляр ASG всегда будет запускаться с той же емкостью, что и стаашего кода Terraform и усложняет его обслуживание.
Конечно, в идеале в Terraform должна быть встроенная поддержка развертываний с нулевым временем простоя, но по состоянию на май 2019 года команда HashiCorp не планировала добавлять эту функциональность ([подробности — здесь](http://github.com/hashicorp/terraform/issues/1552)).
### Корректный план может быть неудачно реализован
Иногда при выполнении команды plan получается вполне корректный план развертывания, однако команда apply возвращает ошибку. Попробуйте, к примеру, добавить ресурс aws\_iam\_user с тем же именем, которое вы использовали для пользователя IAM, созданного вами ранее в главе 2:
```
resource "aws_iam_user" "existing_user" {
# Подставьте сюда имя уже существующего пользователя IAM,
# чтобы попрактиковаться в использовании команды terraform import
name = "yevgeniy.brikman"
}
```
Теперь, если выполнить команду plan, Terraform выведет на первый взгляд вполне разумный план развертывания:
```
Terraform will perform the following actions:
# aws_iam_user.existing_user will be created
+ resource "aws_iam_user" "existing_user" {
+ arn = (known after apply)
+ force_destroy = false
+ id = (known after apply)
+ name = "yevgeniy.brikman"
+ path = "/"
+ unique_id = (known after apply)
}
Plan: 1 to add, 0 to change, 0 to destroy.
```
Если выполнить команду apply, получится следующая ошибка:
```
Error: Error creating IAM User yevgeniy.brikman: EntityAlreadyExists:
User with name yevgeniy.brikman already exists.
on main.tf line 10, in resource "aws_iam_user" "existing_user":
10: resource "aws_iam_user" "existing_user" {
```
Проблема, конечно, в том, что пользователь IAM с таким именем уже существует. И это может случиться не только с пользователями IAM, но и почти с любым ресурсом. Возможно, кто-то создал этот ресурс вручную или с помощью командной строки, но, как бы то ни было, совпадение идентификаторов приводит к конфликтам. У этой ошибки существует множество разновидностей, которые часто застают врасплох новичков в Terraform.
Ключевым моментом является то, что команда terraform plan учитывает только те ресурсы, которые указаны в файле состояния Terraform. Если ресурсы созданы каким-то другим способом (например, вручную, щелчком кнопкой мыши на консоли AWS), они не попадут в файл состояния и, следовательно, Terraform не будет их учитывать при выполнении команды plan. В итоге корректный на первый взгляд план окажется неудачным.
Из этого можно извлечь два урока.
* Если вы уже начали работать с Terraform, не используйте ничего другого. Если часть вашей инфраструктуры управляется с помощью Terraform, больше нельзя изменять ее вручную. В противном случае вы не только рискуете получить странные ошибки Terraform, но также сводите на нет многие преимущества IaC, так как код больше не будет точным представлением вашей инфраструктуры.
* Если у вас уже есть какая-то инфраструктура, используйте команду import. Если вы начинаете использовать Terraform с уже существующей инфраструктурой, ее можно добавить в файл состояния с помощью команды terraform import. Так Terraform будет знать, какой инфраструктурой нужно управлять. Команда import принимает два аргумента. Первым служит адрес ресурса в ваших конфигурационных файлах. Здесь тот же синтаксис, что и в ссылках на ресурсы: \_. (вроде aws\_iam\_user.existing\_user). Второй аргумент — это идентификатор ресурса, который нужно импортировать. Скажем, в качестве ID ресурса aws\_iam\_user выступает имя пользователя (например, yevgeniy.brikman), а ID ресурса aws\_instance будет идентификатор сервера EC2 (вроде i-190e22e5). То, как импортировать ресурс, обычно указывается в документации внизу его страницы.
Ниже показана команда import, позволяющая синхронизировать ресурс aws\_iam\_user, который вы добавили в свою конфигурацию Terraform вместе с пользователем IAM в главе 2 (естественно, вместо yevgeniy.brikman нужно подставить ваше имя):
```
$ terraform import aws_iam_user.existing_user yevgeniy.brikman
```
Terraform обратится к API AWS, чтобы найти вашего пользователя IAM и создать в файле состояния связь между ним и ресурсом aws\_iam\_user.existing\_user в вашей конфигурации Terraform. С этого момента при выполнении команды plan Terraform будет знать, что пользователь IAM уже существует, и не станет пытаться создать его еще раз.
Следует отметить, что, если у вас уже есть много ресурсов, которые вы хотите импортировать в Terraform, ручное написание кода и импорт каждого из них по очереди может оказаться хлопотным занятием. Поэтому стоит обратить внимание на такой инструмент, как Terraforming (http://terraforming.dtan4.net/), который может автоматически импортировать из учетной записи AWS код и состояние.
### Рефакторинг может иметь свои подвохи
*Рефакторинг* — распространенная практика в программировании, когда вы меняете внутреннюю структуру кода, оставляя внешнее поведение без изменения. Это нужно, чтобы сделать код более понятным, опрятным и простым в обслуживании. Рефакторинг — это незаменимая методика, которую следует регулярно применять. Но, когда речь идет о Terraform или любом другом средстве IaC, следует крайне осторожно относиться к тому, что имеется в виду под «внешним поведением» участка кода, иначе возникнут непредвиденные проблемы.
Например, распространенный вид рефакторинга — замена названий переменных или функций более понятными. Многие IDE имеют встроенную поддержку рефакторинга и могут автоматически переименовать переменные и функции в пределах всего проекта. В языках программирования общего назначения это тривиальная процедура, о которой можно не задумываться, однако в Terraform с этим следует быть крайне осторожными, иначе можно столкнуться с перебоями в работе.
К примеру, у модуля webserver-cluster есть входная переменная cluster\_name:
```
variable "cluster_name" {
description = "The name to use for all the cluster resources"
type = string
}
```
Представьте, что вы начали использовать этот модуль для развертывания микросервиса с названием foo. Позже вам захотелось переименовать свой сервис в bar. Это изменение может показаться тривиальным, но в реальности из-за него могут возникнуть перебои в работе.
Дело в том, что модуль webserver-cluster использует переменную cluster\_name в целом ряде ресурсов, включая параметр name двух групп безопасности и ALB:
```
resource "aws_lb" "example" {
name = var.cluster_name
load_balancer_type = "application"
subnets = data.aws_subnet_ids.default.ids
security_groups = [aws_security_group.alb.id]
}
```
Если поменять параметр name в каком-то ресурсе, Terraform удалит старую версию этого ресурса и создаст вместо него новую. Но если таким ресурсом является ALB, в период между его удалением и загрузкой новой версии у вас не будет механизма для перенаправления трафика к вашему веб-серверу. Точно так же, если удаляется группа безопасности, ваши серверы начнут отклонять любой сетевой трафик, пока не будет создана новая группа.
Еще одним видом рефакторинга, который вас может заинтересовать, является изменение идентификатора Terraform. Возьмем в качестве примера ресурс aws\_security\_group в модуле webserver-cluster:
```
resource "aws_security_group" "instance" {
# (...)
}
```
Идентификатор этого ресурса называется instance. Представьте, что во время рефакторинга вы решили поменять его на более понятное (по вашему мнению) имя cluster\_instance:
```
resource "aws_security_group" "cluster_instance" {
# (...)
}
```
Что в итоге случится? Правильно: перебой в работе.
Terraform связывает ID каждого ресурса с идентификатором облачного провайдера. Например, iam\_user привязывается к идентификатору пользователя IAM в AWS, а aws\_instance — к ID сервера AWS EC2. Если изменить идентификатор ресурса (скажем, с instance на cluster\_instance, как в случае с aws\_security\_group), для Terraform это будет выглядеть так, будто вы удалили старый ресурс и добавили новый. Если применить эти изменения, Terraform удалит старую группу безопасности и создаст другую, а между тем ваши серверы начнут отклонять любой сетевой трафик.
Вот четыре основных урока, которые вы должны извлечь из этого обсуждения.
+ Всегда используйте команду plan. Ею можно выявить все эти загвоздки. Тщательно просматривайте ее вывод и обращайте внимание на ситуации, когда Terraform планирует удалить ресурсы, которые, скорее всего, удалять не стоит.
+ Создавайте, прежде чем удалять. Если вы хотите заменить ресурс, хорошенько подумайте, нужно ли создавать замену до удаления оригинала. Если ответ положительный, в этом может помочь create\_before\_destroy. Того же результата можно добиться вручную, выполнив два шага: сначала добавить в конфигурацию новый ресурс и запустить команду apply, а затем удалить из конфигурации старый ресурс и воспользоваться командой apply еще раз.
+ Изменение идентификаторов требует изменения состояния. Если вы хотите поменять идентификатор, связанный с ресурсом (например, переименовать aws\_security\_group с instance на cluster\_instance), избегая при этом удаления ресурса и создания его новой версии, необходимо соответствующим образом обновить файл состояния Terraform. Никогда не делайте этого вручную — используйте вместо этого команду terraform state. При переименовании идентификаторов следует выполнить команду terraform state mv, которая имеет следующий синтаксис:
```
terraform state mv
```
ORIGINAL\_REFERENCE — это выражение, ссылающееся на ресурс в его текущем виде, а NEW\_REFERENCE — то место, куда вы хотите его переместить. Например, при переименовании группы aws\_security\_group с instance на cluster\_instance нужно выполнить следующую команду:
```
$ terraform state mv \
aws_security_group.instance \
aws_security_group.cluster_instance
```
Так вы сообщите Terraform, что состояние, которое ранее относилось к aws\_security\_group.instance, теперь должно быть связано с aws\_security\_group.cluster\_instance. Если после переименования и запуска этой команды terraform plan не покажет никаких изменений, значит, вы все сделали правильно.
+ Некоторые параметры нельзя изменять. Параметры многих ресурсов неизменяемые. Если попытаться их изменить, Terraform удалит старый ресурс и создаст вместо него новый. На странице каждого ресурса обычно указывается, что происходит при изменении того или иного параметра, поэтому не забывайте сверяться с документацией. Всегда используйте команду plan и рассматривайте целесообразность применения стратегии create\_before\_destroy.
### Отложенная согласованность согласуется… с отлагательством
API некоторых облачных провайдеров, таких как AWS, асинхронные и имеют отложенную согласованность. Асинхронность означает, что интерфейс может сразу же вернуть ответ, не дожидаясь завершения запрошенного действия. Отложенная согласованность значит, что для распространения изменений по всей системе может понадобиться время; пока это происходит, ваши ответы могут быть несогласованными и зависеть от того, какая реплика источника данных отвечает на ваши API-вызовы.
Представьте, к примеру, что вы делаете API-вызов к AWS с просьбой создать сервер EC2. API вернет «успешный» ответ (201 Created) практически мгновенно, не дожидаясь создания самого сервера. Если вы сразу же попытаетесь к нему подключиться, почти наверняка ничего не получится, поскольку в этот момент AWS все еще инициализирует ресурсы или, как вариант, сервер еще не загрузился. Более того, если вы сделаете еще один вызов, чтобы получить информацию об этом сервере, может прийти ошибка (404 Not Found). Дело в том, что сведения об этом сервере EC2 все еще могут распространяться по AWS, чтобы они стали доступными везде, придется подождать несколько секунд.
При каждом использовании асинхронного API с отложенной согласованностью вы должны периодически повторять свой запрос, пока действие не завершится и не распространится по системе. К сожалению, AWS SDK не предоставляет для этого никаких хороших инструментов, и проект Terraform раньше страдал от множества ошибок вроде 6813 (https://github.com/hashicorp/terraform/issues/6813):
```
$ terraform apply
aws_subnet.private-persistence.2: InvalidSubnetID.NotFound:
The subnet ID 'subnet-xxxxxxx' does not exist
```
Иными словами, вы создаете ресурс (например, подсеть) и затем пытаетесь получить о нем какие-то сведения (вроде ID только что созданной подсети), а Terraform не может их найти. Большинство из таких ошибок (включая 6813) уже исправлены, но время от времени они все еще проявляются, особенно когда в Terraform добавляют поддержку нового типа ресурсов. Это раздражает, но в большинстве случаев не несет никакого вреда. При повторном выполнении terraform apply все должно заработать, поскольку к этому моменту информация уже распространится по системе.
Данный отрывок представлен из книги Евгения Брикмана [«Terraform: инфраструктура на уровне кода»](https://www.piter.com/collection/soon/product/terraform-infrastruktura-na-urovne-koda). | https://habr.com/ru/post/496820/ | null | ru | null |
# RPM-репозиторий — своими руками
Итак, начнём.
При внедрении DevOps-процесса в компании одним из возможных вариантов хранилища артефактов сборки может стать rpm-репозиторий. По существу — это просто веб-сервер, раздающий определённым образом организованное содержимое. Есть, конечно, коммерческие варианты maven-репозиториев, которые имеют плагины для поддержки rpm, но мы же не ищем лёгких путей?
### Задача
Написать сервис, который будет принимать готовые rpm-пакеты по протоколу HTTP, парсить их метаданные, раскладывать файлы пакетов по каталогам в соответствии с внутренней структурой репозитория и обновлять метаданные репозитория после обработки очередного пакета. Что из этого получилось — описано под катом.
### Анализ
В моей голове задача почти мгновенно распалась на несколько частей: первая — принимающая, которая должна принять rpm-пакет по HTTP; вторая — обрабатывающая, которая должна принятый RPM-пакет обработать. Ну и где-то ещё должен быть веб-сервер, который будет раздавать содержимое репозитория.
### Принимающая часть
Ввиду того, что с Nginx я знаком давно, выбор веб-сервера для приёма rpm-пакетов и раздачи содержимого репозитория даже не стоял — только Nginx. Приняв это как данность, я нашёл в документации нужные опции и написал
**Часть конфигурации Nginx, которая принимает файлы**
```
location /upload {
proxy_http_version 1.1;
proxy_pass http://127.0.0.1:5000;
proxy_pass_request_body off;
proxy_set_header X-Package-Name $request_body_file;
client_body_in_file_only on;
client_body_temp_path /tmp/rpms;
client_max_body_size 128m;
}
```
Результат данной конфигурации — при приёме файла Nginx сохранит его в заданный каталог и сообщит исходное имя в отдельном заголовке.
Для полноты картины — вторая крохотная
**Часть конфигурации, которая раздаёт содержимое репозитория**
```
location /repo {
alias /srv/repo/storage/;
autoindex on;
}
```
Итак, у нас есть первая часть, которая умеет принимать файлы и отдавать их.
### Обрабатывающая часть
Обрабатывающая часть напиcана на Python без особых премудростей и выглядит
**Вот так:**
```
#!/usr/bin/env python
import argparse
import collections
import pprint
import shutil
import subprocess
import threading
import os
import re
import yaml
from flask import Flask, request
from pyrpm import rpmdefs
from pyrpm.rpm import RPM
# Сервис для поддержания репозиториев (С) Sergey Pechenko, 2017
# Лицензия - GPL v2.0. Никаких дополнительных гарантий или прав не предоставляется.
# Для лицензирования использования кода в коммерческом продукте свяжитесь с автором.
class LoggingMiddleware(object):
# Вспомогательный класс для логирования запросов и отладки
def __init__(self, app):
self._app = app
def __call__(self, environ, resp):
errorlog = environ['wsgi.errors']
pprint.pprint(('REQUEST', environ), stream=errorlog)
def log_response(status, headers, *args):
pprint.pprint(('RESPONSE', status, headers), stream=errorlog)
return resp(status, headers, *args)
return self._app(environ, log_response)
def parse_package_info(rpm):
# Обработка метаданных пакета
os_name_rel = rpm[rpmdefs.RPMTAG_RELEASE]
os_data = re.search('^(\d+)\.(\w+)(\d+)$', os_name_rel)
package = {
'filename': "%s-%s-%s.%s.rpm" % (rpm[rpmdefs.RPMTAG_NAME],
rpm[rpmdefs.RPMTAG_VERSION],
rpm[rpmdefs.RPMTAG_RELEASE],
rpm[rpmdefs.RPMTAG_ARCH]),
'os_abbr': os_data.group(2),
'os_release': os_data.group(3),
'os_arch': rpm[rpmdefs.RPMTAG_ARCH]
}
return package
# Объект приложения и его настройки
app = Flask(__name__)
settings = {}
# Тестовый обработчик - пригодится в начале настройки
@app.route('/')
def hello_world():
return 'Hello from repo!'
# Обработчик конкретного маршрута в URL
@app.route('/upload', methods=['PUT'])
def upload():
# Ответ по умолчанию
status = 503
headers = []
# Этот нестандартный заголовок мы добавили в конфигурацию Nginx ранее
curr_package = request.headers.get('X-Package-Name')
rpm = RPM(file(unicode(curr_package)))
rpm_data = parse_package_info(rpm)
try:
new_req_queue_element = '%s/%s' % (rpm_data['os_release'], rpm_data['os_arch'])
dest_dirname = '%s/%s/Packages' % (
app.settings['repo']['top_dir'],
new_req_queue_element)
# Перемещаем файл в нужный каталог
shutil.move(curr_package, dest_dirname)
src_filename = '%s/%s' % (dest_dirname, os.path.basename(curr_package))
dest_filename = '%s/%s' % (dest_dirname, rpm_data['filename'])
# Переименовываем файл
shutil.move(src_filename, dest_filename)
# Готовим ответ, который получит загружавший клиент
response = 'OK - Accessible as %s' % dest_filename
status = 200
if new_req_queue_element not in req_queue:
# Кладём запрос на обработку этого пакета в очередь
req_queue.append(new_req_queue_element)
event_timeout.set()
event_request.set()
except BaseException as E:
response = E.message
return response, status, headers
def update_func(evt_upd, evt_exit):
# Ждёт события, затем запускает обновление метаданных
while not evt_exit.is_set():
if evt_upd.wait():
# Выбираем следующий доступный запрос из очереди
curr_elem = req_queue.popleft()
p = subprocess.Popen([app.settings['index_updater']['executable'],
app.settings['index_updater']['cmdline'],
'%s/%s' % (app.settings['repo']['top_dir'], curr_elem)],
shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
res_stdout, res_stderr = p.communicate(None)
pprint.pprint(res_stdout)
pprint.pprint(res_stderr)
# Сбрасываем событие обновления
evt_upd.clear()
return
def update_enable_func(evt_req, evt_tmout, evt_upd, evt_exit):
while not evt_exit.is_set():
# Ожидаем запрос
evt_req.wait()
# OK, дождались
# Теперь выдерживаем 30 секунд, а если в это время пришёл запрос....
while evt_tmout.wait(30) and (not evt_exit.is_set()):
evt_tmout.clear()
if evt_exit.is_set():
break
evt_upd.set()
evt_tmout.clear()
evt_req.clear()
return
def parse_command_line():
# Разбор агрументов командной строки
parser = argparse.ArgumentParser(description='This is a repository update helper')
parser.prog_name = 'repo_helper'
parser.add_argument('-c', '--conf', action='store', default='%.yml' % prog_name, type='file', required='false',
help='Name of the config file', dest='configfile')
parser.epilog('This is an example of Nginx configuration:\
location /repo {\
alias /srv/repo/storage/;\
autoindex on;\
}\
\
location /upload {\
client_body_in_file_only on;\
client_body_temp_path /tmp/rpms;\
client_max_body_size 128m;\
proxy_http_version 1.1;\
proxy_pass http://localhost:5000;\
proxy_pass_request_body off;\
proxy_set_header X-Package-Name $request_body_file;\
}\
')
parser.parse_args()
return parser
def load_config(fn):
with open(fn, 'r') as f:
config = yaml.safe_load(f)
return config
def load_hardcoded_defaults():
# Прибитые гвоздями настройки "по умолчанию"
config = {
'index_updater': {
'executable': '/bin/createrepo',
'cmdline': '--update'
},
'repo': {
'top_dir': '/srv/repo/storage'
},
'server': {
'address': '127.0.0.1',
'port': '5000',
'prefix_url': 'upload',
'upload_header': ''
},
'log': {
'name': 'syslog',
'level': 'INFO'
}
}
return config
if __name__ == '__main__':
try:
cli_args = parse_command_line()
settings = load_config(cli_args['configfile'])
except BaseException as E:
settings = load_hardcoded_defaults()
req_queue = collections.deque()
# Application-level specific stuff
# Exit flag
exit_flag = False
# Событие, сигналящее о пришедшем запросе
event_request = threading.Event()
# Событие, сигналящее об окончании задержки
event_timeout = threading.Event()
# Событие, сигналящее о запуске обновления метаданных
event_update = threading.Event()
# Событие, сигналящее о завершении вспомогательных потоков
event_exit = threading.Event()
# Готовим начальное состояние событий
event_request.clear()
event_timeout.clear()
event_update.clear()
# Поток, который запускает обновление метаданных репозитория
update_thread = threading.Thread(name='update_worker', target=update_func, args=(event_update, event_exit))
update_thread.start()
# Поток, отсчитывающий время задержки, и начинающий отсчёт сначала, если задержка прервана
# Если задержка прервана - начинаем отсчёт сначала
delay_thread = threading.Thread(name='delay_worker', target=update_enable_func,
args=(event_request, event_timeout, event_update, event_exit))
delay_thread.start()
# Его Величество Приложение
app.wsgi_app = LoggingMiddleware(app.wsgi_app)
app.run(host=settings['server']['address'], port=settings['server']['port'])
# Это событие заставит оба дополнительных потока завершиться
event_exit.clear()
```
Важный и, скорее всего, непонятный с первого взгляда момент — зачем же здесь нужны потоки, события и очередь.
Они нужны для передачи данных между асинхронными процессами. Вот смотрите, ведь HTTP-клиент не обязан ждать какого-то разрешения, чтобы загрузить пакет? Правильно, он может начать загрузку в любой момент. Соответственно, в основном потоке приложения мы должны сообщить клиенту об успешности/неуспешности загрузки, и, если загрузка удалась, передать данные через очередь другому потоку, который выполняет вычитывание метаданных пакета, а затем перемещение его в файловой системе. При этом отдельный поток следит, прошло ли 30 секунд с момента загрузки последнего пакета, или нет. Если прошло — метаданные репозитория будут обновлены. Если же время ещё не вышло, а уже пришёл следющий запрос — сбрасываем и перезапускаем таймер. Таким образом, всякая загрузка пакета будет отодвигать обновление метаданных на 30 секунд.
### Как пользоваться
Сначала нужно
**Установить пакеты Python по списку:**appdirs==1.4.3
click==6.7
Flask==0.12.1
itsdangerous==0.24
Jinja2==2.9.6
MarkupSafe==1.0
packaging==16.8
pyparsing==2.2.0
pyrpm==0.3
PyYAML==3.12
six==1.10.0
uWSGI==2.0.15
Werkzeug==0.12.1
К сожалению, я не могу гарантировать, что это минимально возможный список — команда pip freeze просто берёт список доступных пакетов Python и механически переносит его в файл, не рассматривая, используется ли конкретный пакет в конкретном проекте или нет.
Затем нужно установить пакеты с **nginx** и c **createrepo**:
```
yum install -y nginx createrepo
```
Запуск проекта выглядит вот так:
```
nohup python app.py
```
После того, как всё будет запущено, можно пробовать загрузить rpm-пакет в репозиторий вот такой командой:
```
curl http://hostname.example.com/upload -T
```
Я понимаю, что описанный сервис далёк от совершенства и являет собой скорее прототип, нежели полноценное приложение, но, с другой стороны, он может быть легко дополнен/расширен.
Для удобства желающих код выложен на [GitHub](https://github.com/tnt4brain/rpm-repo-manager). Предложения по дополнению сервиса, а ещё лучше — pull-request'ы горячо приветствуются!
Надеюсь, этот прототип окажется кому-то полезным. Спасибо за внимание!
**P.S.**Ну и для тех, кому очень нужно, небольшой сниппет для укрощения SELinux:
```
#!/bin/bash
semanage fcontext -a -t httpd_sys_rw_content_t "/srv/repo/storage(/.*)?"
restorecon -R -v /srv/repo/storage
setsebool -P httpd_can_network_connect 1
``` | https://habr.com/ru/post/337736/ | null | ru | null |
# DIY Электрическая система переключения скоростей для шоссейного велосипеда
При езде на шоссейном велосипеде особенно важно минимизировать изменения в необходимом усилии и скорости вращения педалей, для этого в зависимости от рельефа необходимо часто переключать скорости велосипеда. На бюджетных шоссейных велосипедах, естественно, стоит бюджетная система переключения, с ней лишний раз подумаешь, менять скорость или нет. Под катом то, как я это исправил.
Сервопривод и корпус устройства.
---
### Предыстория
Меня зовут Вячеслав. В коронокризис было скучно, поэтому я начал бегать. За 3 месяца пробежал 350 км и 02.08.2020 пробежал Московский полумарафон.
После бега решил попробовать шоссейный велосипед. Я, еще контактные педали в глаза не видевший, уже слоты на спринты к айронмэну на 2021 присматривал, такое бывает. Велосипед и оборудование выбирал самые бюджетные, поэтому простор для фантазии и доработок открыт.
### Электронное переключение скоростей
В моем шоссейном велосипеде скорости переключаются на середине руля, поэтому для постоянного переключения нужно отпускать барана, это очень неудобно. В более дорогих системах переключения на самом баране, но там одна система стоит дороже, чем весь мой велосипед.
Моей задачей было с минимальными доработками и сохранением существующего варианта переключения сделать удобное и быстрое электрическое переключение параллельно.
Для прототипа использовалось то, что было под рукой. Измерив ход движения тросика(22мм) и необходимое усилие от родной системы, выбрал сервопривод ds3115mg.
Конструкция элементарная: батарея+Arduino nano+две кнопки+серво.
Кнопки подтянул к 5V через внутренний резистор.
### Код Arduino
```
#include
Servo myservo;
int speedg = 1;
int up = 1;
int p = 0;
void setup() {
myservo.attach(9);
pinMode(8, INPUT\_PULLUP);
pinMode(7, INPUT\_PULLUP);
}
void loop() {
if (digitalRead(7) == 0) {
if (speedg > 1) {
speedg--;
up = 0;
}
p = 1;
}
if (digitalRead(8) == 0) {
if (speedg < 7) {
speedg++;
up = 1;
}
p = 1;
}
if (speedg == 1) {
myservo.write(0);
}
if (speedg == 2) {
if (up == 1) {
myservo.write(75);
} else {
myservo.write(60);
}
}
if (speedg == 3) {
if (up == 1) {
myservo.write(85);
} else {
myservo.write(80);
}
}
if (speedg == 4) {
if (up == 1) {
myservo.write(97);
} else {
myservo.write(90);
}
}
if (speedg == 5) {
if (up == 1) {
myservo.write(110);
} else {
myservo.write(103);
}
}
if (speedg == 6) {
myservo.write(120);
}
if (speedg == 7) {
myservo.write(140);
}
if ( p == 1) {
delay(300);
p = 0;
}
}
```
Параметры подбирал. причем некоторые скорости для переключения вверх и вниз требовали разного угла поворота сервопривода.
Распечатал на 3D-принтере корпус для Arduino, серво и батареи. Прикрепил корпус к раме, тросик от серво соединил с тросом штатной системы(фото КДПВ, смотри выше).
Первые испытания показали живучесть системы, поэтому решил добавить фичи.
Добавив датчик Холла и магнит на ведущей звезде, получил датчик каденса, теперь могу менять передачи автоматически в зависимости от падения каденса.
Добавив 3-осевой гироскоп и акселерометр MPU6050, пришлось повозиться с калибровкой. Зная угол велосипеда, можем переключать передачи автоматически в горку и с горки.
В целом, автоматизация скорее отвлекает, имея две кнопки с моментальным переключением всегда удобнее самому менять скорость.
### В планах
* Поменять микроконтроллер.
* Добавить датчик скорости вращения колеса.
* Добавить BTLE для синхронизации и передачи данных в STRAVA.
* Сделать корпус устройства в виде фонаря с дисплеем отображения текущей скорости и серво-приводом внутри.
* Заменить сервопривод на актуатор с обратной связью.
Внимание, вопрос
----------------
Как Вы считаете стоит ли попробовать это решение для выхода на краудфандинг?
Велокомпьютер с подключением к Strava+электронное переключение скоростей и все в корпусе фонаря с функцией фонаря+ автоматическое переключение от каденса или уклона. И все это за сумму менее $100 | https://habr.com/ru/post/517236/ | null | ru | null |
# Мониторинг приложений с помощью Pinba
 Привет, Хабр! Мы в Badoo стараемся активно участвовать в жизни IT-сообщества: используем многие open-source-технологии и инструменты, а также делимся своими разработками.
Один из таких инструментов – [Pinba](http://pinba.org/) – сервис для получения realtime-статистики от работающих приложений без накладных расходов на её сбор. Узнать побольше вы можете [в этой статье](https://habrahabr.ru/company/badoo/blog/149695/).
Мы стараемся помочь всем, кто использует Pinba в своих проектах и всегда рады слышать success stories, связанные с Pinba. Этот перевод – одна из подобных историй от разработчиков Dailymotion.
### Введение
Для мониторинга, анализа и оптимизации своих приложений компания Dailymotion использует множество инструментов, таких как StatsD, Graphite, collectd и Datadog. Но есть среди них и менее известный — Pinba (расшифровывается как PHP Is Not a Bottleneck Anymore).
В настоящее время мы работаем над миграцией устаревшего монолитного PHP-приложения с большим количеством legacy-кода. Вместо него планируется развернуть несколько современных микросервисов. С помощью Pinba мы собираем:
* данные о текущем PHP-приложении. Это позволяет эффективнее выполнять обслуживание и развертывание (выявлять релизы, отрицательно влияющие на производительность), а также находить и анализировать возможные проблемы. К тому же полученные данные помогают определить, какие компоненты платформы стоит улучшать в первую очередь, чтобы получить наибольший прирост производительности;
* данные о новых микросервисах. Причем, в зависимости от языка разработки (в настоящее время это Python или Go), мы используем различных клиентов (хотя для них есть клиенты «из коробки» — прим. пер.).
### Что такое Pinba?
Создатель Pinba, [tony2001](https://habrahabr.ru/users/tony2001/), описывает его так:
> «Это сервер статистики, использующий MySQL в качестве интерфейса. Pinba собирает и обрабатывает данные, передаваемые множеством процессов PHP по протоколу UDP, а затем отображает статистику в виде простых и понятных отчетов. Кроме того, с помощью специального интерфейса можно получить доступ к необработанным данным в режиме «только для чтения», чтобы сформировать более подробные отчеты».
Как это работает?
Расширение Pinba для PHP установлено на всех серверах нашей веб-фермы. Оно собирает технические данные для каждого потока PHP и, после того как ответ отправлен клиенту, отправляет полученные метрики на центральный сервер Pinba через UDP (используется формат обмена данными Google Protobuf). На центральном сервере движок Pinba агрегирует содержимое этих сообщений и, прикидываясь read-only движком MySQL, предоставляет данные в виде таблиц, которые можно просматривать и делать по ним любые выборки с помощью любого знакомого вам клиента MySQL. Удобно и эффективно.
Несмотря на расхожие заблуждения, Pinba — это не отладчик и не графический инструмент. Это просто средство для просмотра данных, которое формирует картину происходящего в вашем приложении на продакшене (в режиме реального времени создается срез за последнюю минуту или две). Оно позволяет использовать динамические метрики для построения графиков временных рядов без ущерба для производительности и, соответственно, вовремя выявлять возможные проблемы.
Конечно, Pinba не панацея и не решит всех проблем. Одна из распространенных ошибок связана с использованием этого сервиса для сбора точных данных (например, в качестве счетчика событий, имевших место за последнюю минуту). Сервис Pinba не предназначен для такого рода задач (как вы уже знаете, в целях повышения производительности сообщения protobuf отправляются через UDP, поэтому некоторые пакеты могут теряться по пути). Используйте этот инструмент для отслеживания тенденций, он не подходит для точной количественной оценки действий.
### Наша архитектура
Какие метрики можно отслеживать с помощью сервиса?
Спектр технических метрик, отслеживаемых по умолчанию во всех процессах PHP, очень широк:
* doc\_size — размер ответа;
* mem\_peak\_usage — выделенная память (максимальный объем);
* request\_time — время, затраченное на создание процесса (обработку microsend);
* ru\_utime/ru\_stime — статистические данные об использовании ресурсов сервера (пользователем и системой);
* status — код ответа HTTP;
* memory\_footprint — объем памяти, занимаемой процессом.
Движок хранит метрики для каждого процесса в таблице request, выделяя по одной строке для каждого ответа PHP за последние pinba\_stats\_history секунды (в нашем случае — 60 секунд).
```
mysql> SELECT script_name, doc_size, mem_peak_usage, status, memory_footprint, hostname
FROM request
LIMIT 10;
```
| **script\_name** | **doc\_size** | **mem\_peak\_usage** | **status** | **memory\_footprint** | **hostname** |
| --- | --- | --- | --- | --- | --- |
| [PROD]video\_item | 5.422 | 10240 | 200 | 54728 | web-065 |
| [PROD]widget\_dispatch\_v3 | 38.056 | 14848 | 200 | 31624 | web-031 |
| [PROD]video\_list | 154.369 | 20736 | 200 | 87176 | web-004 |
| [PROD]rest\_api | 0.235 | 22784 | 200 | 51568 | web-128 |
| [PROD]rest\_api | 9.306 | 34048 | 200 | 55624 | web-024 |
| [PROD]rest\_api | 5.448 | 35072 | 200 | 54676 | web-041 |
| [PROD]controller\_dispatch | 2.003 | 11776 | 200 | 36388 | web-033 |
| [PROD]widget\_v3\_chunks | 22.525 | 12544 | 200 | 33544 | web-165 |
| [PROD]cdn\_director | 0 | 9984 | 302 | 42892 | web-034 |
| [PROD]rest\_api | 0.019 | 20736 | 200 | 32500 | web-085 |
Таблица request содержит метрики для каждого процесса PHP, и получить доступ к необработанным данным может быть довольно сложно в случае интенсивного трафика:
```
mysql> SELECT COUNT(1) from request;
```
| COUNT(1) |
| --- |
| 1197502 |
То есть в рамках всей нашей веб-фермы за 60 секунд было сгенерировано 1 197 502 ответа PHP.
К счастью, движок параллельно выполняет моментальную агрегацию, помещая сводные метрики в таблицу report\_ \*. Метрики, сгруппированные по значению в поле script\_name, находятся в таблице report\_by\_script\_name, поэтому мы можем анализировать метрики для конкретных значений script\_name. Например, мы можем получить статистические данные о десяти наиболее часто вызываемых маршрутах:
```
mysql> SELECT script_name, req_count, req_per_sec, memory_footprint_total, req_time_median
FROM report_by_script_name
ORDER BY req_count DESC
LIMIT 10;
```
| **script\_name** | **req\_count** | **req\_per\_sec** | **memory\_footprint\_total** | **req\_time\_median** |
| --- | --- | --- | --- | --- |
| [PROD]rest\_api | 276508 | 4608.47 | 12916600000 | 0.0514983 |
| [PROD]embed\_player | 162808 | 2713.47 | 8074990000 | 0.109837 |
| [PROD]cdn\_director | 122526 | 2042.1 | 5103160000 | 0.0280768 |
| [PROD]widget\_dispatch\_v3 | 105822 | 1763.7 | 4349350000 | 0.049904 |
| [PROD]history\_logger | 98481 | 1641.35 | 4060860000 | 0.0127946 |
| [PROD]video\_item | 66250 | 1104.17 | 3563420000 | 0.254091 |
| [PROD]autocomplete\_list | 56313 | 938.55 | 2322790000 | 0.0104993 |
| [PROD]webapp\_ads\_mopub | 52187 | 869.783 | 2183980000 | 0.0326299 |
| [PROD]gravity\_report | 45992 | 766.533 | 1895290000 | 0.0167253 |
| [PROD]player\_data | 33584 | 559.733 | 1724540000 | 0.113651 |
Мы также можем вычислить средний объем выделенной памяти, просто выполнив запрос
```
memory_footprint_total/req_count AS avg_mem_footprint
```
По умолчанию движок еще и консолидирует метрики в нескольких других удобных таблицах:
* report\_by\_server\_name;
* report\_by\_hostname;
* report\_by\_server\_and\_script;
* report\_by\_hostname\_and\_server;
* report\_by\_hostname\_server\_and\_script.
Чтобы получить подробную информацию, используйте таблицу, объединяющую данные по нескольким измерениям. Это могут быть, например, наиболее часто используемые скрипты на хосте и сервере:
```
mysql> SELECT hostname, server_name, script_name, req_count, req_per_sec, req_time_median
FROM report_by_hostname_server_and_script
ORDER BY req_count DESC
LIMIT 2;
```
| **hostname** | **server\_name** | **script\_name** | **req\_count** | **req\_per\_sec** | **req\_time\_median** |
| --- | --- | --- | --- | --- | --- |
| web-121 | api.dailymotion.com | [PROD]api\_oauth\_token | 4144 | 69.0667 | 0.0104435 |
| web-038 | api.dailymotion.com | [PROD]rest\_api | 3455 | 57.5833 | 0.0441618 |
### Сбор собственных метрик
Как вы видите, Pinba предоставляет много полезной информации без дополнительных настроек, но это далеко не всё! Помимо таблиц отчетов вы можете использовать таблицы tag*report*\*. Метрики консолидируются в этих таблицах в соответствии со значениями тегов, которые вы определяете в своем коде.
Например, в старой базе кода Dailymotion у нас два вида тегов:
* I/O: любой доступ извне, блокировка выполнения процесса (доступ к
серверам типа MySQL, Elastic, Redis, memcached или внешним API,
например, Facebook или Twitter);
* algo: алгоритмы, за которыми мы хотим наблюдать.
Например, для memcache мы используем теги следующим образом:
*код клиента*
```
$pinbaTimer = $this->pinbaService->startTimer([
'group' => 'memcached',
'memcached' => $this->pinba_pool,
'method' => 'get',
'namespace' => 'dm_cache'
]);
$value = $this->memcache->get($this->prefix . $key);
$this->pinbaService->stopTimer($pinbaTimer);
```
*сервис Pinba*
```
public function startTimer(array $tags) {
if (!$this->isPinbaInstalled) {
return null;
}
$timerId = 't' . ++$this->incr;
$this->timers[$timerId] = pinba_timer_start($tags);
return $timerId;
}
public function stopTimer($timerId) {
if ($this->isPinbaInstalled && isset($this->timers[$timerId])) {
pinba_timer_stop($this->timers[$timerId]);
unset($this->timers[$timerId]);
}
}
```
Затем мы создаем пользовательские таблицы в базе данных Pinba, с помощью комментариев объясняя движку, что в них хранить.
Например, так выглядит таблица для хранения метрик, характеризующих использование memcached:
```
CREATE TABLE `tag_report_memcached_method_namespace` (
`script_name` varchar(128) DEFAULT NULL,
`memcached` varchar(64) DEFAULT NULL,
`method` varchar(64) DEFAULT NULL,
`namespace` varchar(64) DEFAULT NULL,
`req_count` int(11) DEFAULT NULL,
`req_per_sec` float DEFAULT NULL,
`hit_count` int(11) DEFAULT NULL,
`hit_per_sec` float DEFAULT NULL,
`timer_value` float DEFAULT NULL,
`timer_median` float DEFAULT NULL,
`index_value` varchar(256) DEFAULT NULL
) ENGINE=PINBA DEFAULT CHARSET=latin1 COMMENT='tagN_report:memcached,method,namespace';
```
А так — таблица для хранения метрик о параметрах ввода-вывода приложения:
```
CREATE TABLE `tag_report_group_method` (
`script_name` varchar(128) DEFAULT NULL,
`group` varchar(64) DEFAULT NULL,
`method` varchar(64) DEFAULT NULL,
`req_count` int(11) DEFAULT NULL,
`req_per_sec` float DEFAULT NULL,
`hit_count` int(11) DEFAULT NULL,
`hit_per_sec` float DEFAULT NULL,
`timer_value` float DEFAULT NULL,
`timer_median` float DEFAULT NULL,
`index_value` varchar(256) DEFAULT NULL
) ENGINE=PINBA DEFAULT CHARSET=latin1 COMMENT='tag2_report:group,method';
```
Примечание для себя: в следующий раз не использовать зарезервированные слова SQL (group, ...) в качестве имен столбцов.
Эти таблицы позволяют нам получить подробные статистические данные, например, обо всех операциях ввода-вывода для конкретного маршрута:
```
mysql> SELECT `group`,
SUM(req_count) AS req,
AVG(timer_median) AS timer_median,
SUM(timer_value)/SUM(hit_count) AS tph,
SUM(timer_value)/SUM(req_count) AS tpr,
SUM(timer_value) AS timer_total
FROM tag_report_group_method
WHERE script_name='[PROD]video_item'
AND `group` != "int_api"
GROUP BY `group`
ORDER BY timer_total DESC;
```
| **group** | **req** | **timer\_median** | **tph** | **tpr** | **timer\_total** |
| --- | --- | --- | --- | --- | --- |
| mysql | 118124 | 0.009819403290748596 | 0.003329653064723691 | 0.05909533790217434 | 6980.5776943564415 |
| memcached | 188049 | 0.00976656749844551 | 0.0003179184672595343 | 0.01067464985796328 | 2007.3572311401367 |
| Elastic | 32049 | 0.011334048118442297 | 0.016838098360988627 | 0.026841974640797184 | 860.2584452629089 |
| Redis | 48999 | 0.009611431136727333 | 0.011986066101148827 | 0.012204265879965226 | 597.9968238524161 |
| DMX | 61436 | 0.009767306968569756 | 0.0016191925102048436 | 0.0073448760845254615 | 451.23980712890625 |
| Curl | 24882 | 0.06987743234882753 | 0.008533559191620778 | 0.008533559191620778 | 212.3320198059082 |
| cleeng | 50 | 0.12915635108947754 | 0.1352721940790749 | 1.0902938842773438 | 54.51469421386719 |
| Facebook API | 22 | 0.5436198115348816 | 0.5515929568897594 | 0.5515929568897594 | 12.135045051574707 |
| Live API | 1 | 0.01953125 | 0.0049230000004172325 | 0.0049230000004172325 | 0.0049230000004172325 |
Подробные сведения о MySQL SELECT:
```
mysql> SELECT mysql, method, timer_value,
timer_value/req_count AS avg_timer_value,
hit_count/req_count AS avg_op_count,
timer_value/hit_count AS avg_op_value,
hit_count,
req_count
FROM tag_report_mysql_method
WHERE method='select'
AND script_name='[PROD]video_item'
AND req_count > 200
ORDER BY avg_op_count DESC
LIMIT 4;
```
| **mysql** | **method** | **timer\_value** | **avg\_timer\_value** | **avg\_op\_count** | **avg\_op\_value** | **hit\_count** | **req\_count** |
| --- | --- | --- | --- | --- | --- | --- | --- |
| video | select | 3971.99 | 0.10144789052722653 | 16.6880 | 0.006079103953896177 | 653384 | 39153 |
| video\_view\_summary | select | 264.027 | 0.007824405328308366 | 12.6024 | 0.000620868312581275 | 425254 | 33744 |
| static\_asset\_video\_sprite | select | 15.4905 | 0.022613802443455604 | 7.6496 | 0.0029561936400318875 | 5240 | 685 |
| video\_has\_repost | select | 1468.93 | 0.027541118671605483 | 6.7955 | 0.0040528553527407 | 362444 | 53336 |
Мы отслеживаем использование запросов select. Если их количество становится очень большим, возможно, кеширование выполняется неэффективно.
### Дополнительные возможности
Мы также используем еще одну интересную возможность Pinba — теги, позволяющие различать запросы разных типов. Запросы помечаются тегами, которые вы определили. Например, мы используем теги для следующих запросов:
* format: формат ответа (html, rss, atom, ...);
* site\_content: языки контента сайта (en, de, fr, jp, ru, ...);
* bot: реальный клиент или бот? (yes/no);
* auth: пользователь прошел проверку подлинности (выполнил вход)? (yes/no);
* provider: определяем различия между версиями PHP: стандартный PHP или HHVM и т.д.
Затем мы создаем таблицы и в комментариях для движка указываем что и где нужно хранить. Например, мы можем сформировать таблицу на основе report\_by\_script\_name, в которой движок сохраняет данные только для процессов PHP со значением no для тега запроса bot и значением no для тега запроса auth. Другими словами, это реальные пользователи, не выполнившие вход в систему — обычная ситуация.
```
CREATE TABLE `auth_no_bot_no_report_by_script_name` (
`req_count` int(11) DEFAULT NULL,
`req_per_sec` float DEFAULT NULL,
...
`req_time_median` float DEFAULT NULL,
`index_value` varchar(256) DEFAULT NULL
) ENGINE=PINBA DEFAULT CHARSET=latin1 COMMENT='report1::tag.auth=no,tag.bot=no';
```
### Построение графиков
Pinba хранит полученные метрики всего одну-две минуты. Поэтому для построения графиков данные требуется консолидировать на внешних ресурсах. Здесь мы используем collectd в паре с плагином MySQL. При этом выполняются запросы к базе данных Pinba, а результаты сохраняются в Whisper. Затем мы запрашиваем Whisper с помощью Graphite и Tessera или Grafana.
### Заключение
Использование Pinba с нашим устаревшим PHP-приложением позволило нам:
* обнаружить возможные источники проблем в приложении;
* выявить ошибки (необоснованно большое число запросов к серверам на некоторых маршрутах);
* построить графики и настроить оповещения, чтобы выявлять случаи снижения производительности после релиза.
Мы также используем Pinba в своих проектах на Python. Специализированную версию Pynba создал наш старый друг (а теперь и коллега) johnnoone.
Единственное, что мы заметили во время использования Pinba: расширение не всегда верно «забывает» информацию о старых запросах. Иногда таблицы отчета содержат фантомные результаты — данные об активности, имевшей место более минуты назад. Это может стать проблемой, если с помощью Pinba нужно убедиться, что что-то не происходит (обычно после развертывания нового кода на продакшене). Это один из немногих случаев, когда причина ошибки не в вашем коде.
Самый простой способ устранить ее — перезапустить движок Pinba. В результате появятся небольшие пробелы на графиках, но фантомные данные точно исчезнут. (Примечание: TRUNCATE TABLE вам не подходит, поскольку это не движок MySQL.)
### Полезные ресурсы для пользователей Pinba
1. GitHub: <https://github.com/tony2001/pinba_engine>
2. Документация: <https://github.com/tony2001/pinba_engine/wiki>
3. Мониторинг производительности PHP-кода с помощью Pinba:
<https://habrahabr.ru/company/badoo/blog/149695/> | https://habr.com/ru/post/319934/ | null | ru | null |
# Нулевой год в БД Oracle
На третьем курсе в СПБПУ Петра Великого у меня был экзамен по SQL в БД Oracle. Экзамен состоял из трех задач. Этот экзамен был одним из самых сложных за все четыре года обучения в университете. Дается три задачи на несколько часов. Если решил все три задачи, то получаешь оценку 5, один недочет (например, лишний пробел) - 4, одна задача решена неверна - 3, два недочета - 3.
Сегодня я хочу рассказать об одной из задач, которая была в этом экзамене.
Что-то пошло не так...Экзамен этот я завалил. Смог я его сдать только со второй попытки. Это было очень неожиданно для меня, а для моих родителей чем-то за гранью, ведь я учился на 4 и 5, и раньше такого не было.
Используя обращение только к таблице DUAL, построить SQL-запрос, возвращающий один столбец, содержащий календарь на заданный месяц заданного года:
* номер дня в месяце (цифрами),
* полное название месяца по-английски заглавными буквами (в верхнем регистре),
* год (четыре цифры),
* полное название дня недели по-английски строчными буквами (в нижнем регистре).
Каждое "подполе" должно быть отделено от следующего одним пробелом. В результате не должно быть начальных и хвостовых пробелов. Количество возвращаемых строк должно точно соответствовать количеству дней в текущем месяце. Строки должны быть упорядочены по номерам дней в месяце по возрастанию.
**Календарь должен создаваться для любых допустимых значений дат Oracle.** Задачу решить без использования разделов Model и рекурсивного With.
Пример вывода результата:
1 MAY 2020 friday
2 MAY 2020 saturday
Задача показалась мне самой простой. Приведу запрос, с помощью которого я решил данную задачу.
```
with input as (
select to_date(:dt, 'mm.syyyy') dt
from dual
)
select to_number(to_char(level + dt - 1, 'dd'),'99') ||
to_char(level + dt - 1, ' MONTH ', 'nls_date_language=american') ||
to_char(level + dt - 1, 'syyyy ' , 'nls_date_language=american') ||
to_char(level + dt - 1, 'day', 'nls_date_language=american') calendar
from dual
join input on 1 = 1
connect by level + dt - 1 <= last_day(dt);
```
На первый взгляд все выглядит хорошо, но рассмотрим один интересный момент. Допустимый диапазон для года - это целое число от -4172 до 9999, кроме 0. Возьмем декабрь 1 года до н.э. и январь 1 года н.э. В результате мы увидим, что после среды идет суббота, а значит задача решена неверно.
Пример работы запроса с -0001 и 0001 годамиВ григорианском и юлианском календарях [отсутствует нулевой год](https://ru.wikipedia.org/wiki/0_%D0%B3%D0%BE%D0%B4). Также и в Oracle нет нулевого года, а -0001 год Oracle соответствует 2 году до н.э. по традиционной хронологии.
```
--Результат 01/01/0001
select to_date('31.12.-0001', 'dd.mm.syyyy') + 1
from dual;
```
Сопоставление стандарта ISO 8601 и традиционной хронологииТогда даты, которые относятся к нашей эре продолжаем создавать, как это делалось в первом запросе. -0002 год Oracle "сдвинем" вправо, то есть он станет 2 годом до н.э. по традиционной хронологии, -0003 Oracle, станет 3 до н.э. и т.д. **Но мы не можем также сдвинуть -0001 год Oracle, добавляя дни/месяцы и др. Однако можно найти год, который будет похож на нулевой год. Например, это 420 год н.э. Тогда будем использовать этот год для вывода месяца нулевого года, а при выводе указывать, что это -0001.** И тогда можно отойти от понятия нулевого года, ведь остались  года.
```
with input as (
select to_date(:dt, 'mm.syyyy') dt
from dual
)
select case
when extract (year from dt) > 0 then
to_char(level + dt - 1, 'fm dd ') ||
to_char(level + dt - 1, 'MONTH ', 'nls_date_language=american') ||
to_char(level + dt - 1, 'syyyy ', 'nls_date_language=american') ||
to_char(level + dt - 1, 'day', 'nls_date_language=american')
when extract (year from dt) = -1 then
to_char(level + to_date(regexp_replace(to_char(dt, 'mm.syyyy'), '-0001', '0420'), 'mm.syyyy') - 1, 'fm dd ') ||
to_char(level + to_date(regexp_replace(to_char(dt, 'mm.syyyy'), '-0001', '0420'), 'mm.syyyy') - 1, 'MONTH ', 'nls_date_language=american') ||
to_char(level + dt - 1, 'syyyy ', 'nls_date_language=american') ||
to_char(level + to_date(regexp_replace(to_char(dt,'mm.syyyy'), '-0001', '0420'),'mm.syyyy') - 1, 'day', 'nls_date_language=american')
else
to_char(level + add_months(dt, 12) - 1, 'fm dd ') ||
to_char(level + add_months(dt, 12) - 1, 'MONTH ', 'nls_date_language=american') ||
to_char(level + dt - 1, 'syyyy ', 'nls_date_language=american') ||
to_char(level + add_months(dt, 12) - 1, 'day', 'nls_date_language=american')
end calendar
from dual
join input on 1 = 1
connect by level + dt - 1 <= last_day(dt);
```
Полученный запрос помогает добиться необходимого результата. Вот так задача, в которой я был абсолютно уверен, была решена неверно мной на экзамене.
 | https://habr.com/ru/post/589733/ | null | ru | null |
# C#. Создаем приложение, требующие повышения прав выполнения через UAC
Недавно столкнулся с необходимостью создания приложения, требующего повышения привилегий для запуска в Windows 7. Оказалось, создать такое приложение совсем несложно. Сейчас на практическом примере мы рассмотрим, как это можно сделать.
**Настройка среды**
Поставленную задачу мы будем решать при помощи Microsoft Visual Sutdio 2008. В моем распоряжении в этот самый момент находится редакция Team Edition. Для реализации задуманного потребуется наличие некоторых компонентов от Visual C++. Если вы пишете, например, только на C#, или вы начинающий разработчик, вы могли пропустить установку этих компонентов:
[](http://radikal.ru/F/s005.radikal.ru/i210/1001/8c/fba51a1cabe7.jpg.html)
**Реализация задачи**
После того, как компоненты доставлены, создаем новый проект. Для ясности задачи в нашем случае это будет обычный проект Windows Forms:
[](http://radikal.ru/F/s005.radikal.ru/i211/1001/2f/eb30bd1f3d0b.jpg.html)
Ничего писать мы в нем не будет, а перейдем прямо в свойства проекта и исключим из него манифест:
[](http://radikal.ru/F/s001.radikal.ru/i194/1001/3f/c850e9052291.jpg.html)
Компилим проект, и создаем командный файл (\*.bat или \*.cmd) вот такого содержания:
`@echo off
SetLocal EnableExtensions DisableDelayedExpansion
cd /d %~dp0
"%programfiles%\Microsoft SDKs\Windows\v6.0A\bin\mt.exe" -manifest "%~dp0uactest.exe.manifest" -outputresource:"%~dp0uactest.exe";#1
pause`
Положите его рядом со скомпилированным бинарником **uactest.exe.**
Теперь запустите блокнот, и вставьте туда следующий текст:
```
xml version="1.0" encoding="UTF-8" standalone="yes"?
```
Сохраните файл c параметрами, указанными на рисунке, в ту же папку, куда вы сохранили командный файл.
[](http://radikal.ru/F/s55.radikal.ru/i148/1001/36/e9ec61d337fc.jpg.html)
Запустите командный файл. У вас должно получиться что-то вроде этого:
[](http://radikal.ru/F/s42.radikal.ru/i096/1001/8d/a229fdf527fb.jpg.html)
**Выводы**
В данной статье был рассмотрен общий поход по созданию приложений, требующих повышенных привилегий администратора для своего запуска. Методика основывается на на внедрении в ресурсы специально подготовленного манифеста и не претендует на уникальность или на прямое руководство к действию. | https://habr.com/ru/post/82609/ | null | ru | null |
# Мошенничество в системах Телебанк и Альфа-Клик
Уже порядка 2 месяца клиенты онлайн-систем Телебанк (банк ВТБ24) и Альфа-Клик (Альфа-банк) рискуют стать (и становятся) жертвами мошенничества. Мы, к сожалению, таковыми стали.
Если кратко, то вирус (или троян, не знаю) изменяет файл hosts, добавляя в него такие строки:
`77.78.239.138 www.telebank.ru
77.78.239.138 telebank.ru
77.78.239.138 www.alfabank.ru
77.78.239.138 alfabank.ru
77.78.239.138 click.alfabank.ru
77.78.239.138 www.click.alfabank.ru`
Пользователь, пытаясь зайти в систему Телебанк, попадает на сайт злоумышленников. Там ему показывается страничка с входом на сайт, очень похожая на основную (почти идентичная). Пользователь вводит логин и пароль, а так же переменный код с карточки. Ему показывается сообщение об ошибке на сервере, и просьба попробовать через несколько минут снова. Таким образом мошенники узнают логин и пароль, а так же несколько переменных кодов, с их помощью они заходят в систему, переводят деньги на другой аккаунт и потом на пластиковую карту, затем быстро обналичивают в банкомате. Если человек сомневается, вводить ли повторно пароль, то через некоторое время ему звонит «сотрудник банка», и говорит что проблема с системой решена и можно попробовать зайти снова. Так же приходят смски, что работа системы восстановлена, пробуйте снова. В итоге мошенники получили 5 переменных кодов, и украли 150 тыс рублей.
На компьютере, с которого пытались зайти, стоял лицензионный антивирус DrWeb, автоматически обновлялся всегда когда надо.
История эта в конце концов со счастливым концом — деньги банк вернул.
Хотя странно, уже множество случаев подобного рода мошенничества, а банк в системе безопасности так ничего не предпринял.
### Мораль
1. Будьте внимательны, лучше сами проверяйте hosts, если увидите подобные симптомы — «сбой в системе, повторите снова». Не делайте так, даже если «саппорт» говорит что можно попробовать снова.
2. Заходите только с проверенных компьютеров и по протоколу https.
3. Закройте на карточке овердрафт. А то если всё таки каким-то образом у вас украдут деньги и банк всё таки решит их не возвращать, то можно залезть в такие минуса, что после кражи ещё будет должны вернуть банку овердрафт, причём в ограниченные сроки.
Вот и всё. Предупреждён, значит вооружён. Кто хочет прочитать историю мошенничества подробнее: [www.banki.ru/services/responses/bank/?responseID=2410229](http://www.banki.ru/services/responses/bank/?responseID=2410229) | https://habr.com/ru/post/108720/ | null | ru | null |
# Брокер сообщений NATS: как мы решали проблему скоростной и стабильной доставки сообщений
Всем привет. Меня зовут Женя, я работаю, как это сейчас модно говорить, DevOps-инженером в компании Garage Eight.
В этой статье я бы хотел поделится опытом внедрения и эксплуатации брокера сообщений NATS в нашей инфраструктуре — настолько понравилась эта технология.
Давным-давно, когда вышел последний сезон сериала «Игра престолов», перед нами в компании Garage Eight встала задача максимально быстрой доставки сообщений из пункта A в пункт B. Условия были таковы:
* перед тем как сообщение достигнет пункта назначения, оно проходит ряд сервисов;
* каждый сервис выполняет определенный набор действий над этим сообщением;
* время прохождения сообщений через весь путь должно быть минимальным;
* брокер сообщений должен работать стабильно 24\7.
Также желательными требованиями были простота написания кода для работы с брокером сообщений и простота обслуживания брокера.
Поиски решения
--------------
Изначально в качестве шины данных хотели взять RabbitMQ, поскольку мы уже с ним работаем. Однако не раз и не два случалось так, что RabbitMQ по своим внутренним причинам (в частности, из-за переполнения очередей) переставал работать. Это сильно влияло как на сервисы, которые с ним работают, так и на людей, которые работают с этими сервисами (думаю, что все, кто работает с RabbitMQ в проде, сталкивались с подобным). Это одна из основных причин, почему мы отказались от использования «кролика». Также были сомнения относительно скорости доставки, что стало еще одним аргументом в пользу поиска другого брокера сообщений (тут должна быть статья про бенчмарки различных брокеров сообщений).
Мы смотрели в сторону брокера Kafka, и это вроде как хорошая штука, но по итогу мы отказались тащить решение, написанное на Java.
Походив по интернету, наткнулись на брокер сообщений NATS. В нем нас подкупил написанный на Go бинарный файл, который можно достаточно легко развернуть в инфраструктуре и писать сервисы для него на [очень большом количестве языков](https://nats.io/download/) (есть даже реализация для Arduino :) ). Но поскольку нашим основным ЯП является Go, а NATS написан на Go, это тоже вошло в копилку аргументов за то, чтобы попробовать NATS. Более того, NATS позиционировался как [высокопроизводительный брокер сообщений](https://nats.io/), и все эти факторы привели к тому, что мы решили его попробовать.
Немного про NATS
----------------
NATS — это высокопроизводительный брокер сообщений, написанный на Go. Он создан Дереком Коллисоном, за плечами которого более 20 лет работы над распределенными очередями сообщений. NATS используется [широким списком крупных компаний](https://nats.io/) в своей инфраструктуре.
Для работы с сообщениями в NATS используется простой текстовый протокол в стиле публикации/подписки. Клиенты подключаются и взаимодействуют с сервером через обычный сокет TCP/IP, используя небольшой набор протокольных операций, которые заканчиваются новой строкой.
Для роутинга сообщений используются [Subject-ы](https://docs.nats.io/nats-concepts/subjects) (мы называем их «топики»). Это что-то вроде связки exchange-queue в RabbitMQ. По сути сабжект — это просто строка, которую используют и тот, кто пишет сообщения с одной стороны, и тот, кто читает сообщения с другой стороны. Сабжекты могут иметь иерархическую структуру, которая разделяется символом “.”. Читатели при этом могут читать из многих сабжектов, используя символы “*” или “>”.*
*“*” означает читать из всех текущих сабжектов в иерархии, а “>” — из текущего и всех последующих.
Все это отлично описано в [документации](https://docs.nats.io/nats-concepts/subjects).
Как мы приготовили Nats
-----------------------
Поскольку в то время, когда мы внедряли NATS, кластерная версия была немного сыровата, мы решили готовить standalone вариант без подтверждения доставки (в целом допускалась потеря 1-3 % сообщений).
Чтобы внедрить NATS, была написана простейшая роль, которая наливает Docker-контейнер с брокером и монтирует туда конфиг.
Для написания сервисов мы пользовались примерами, [которые описаны в официальной документации](https://github.com/nats-io/nats.go), и вот что у нас получилось:
Пример кода для чтения сообщений:
```
`func StartReader(ctx context.Context) error {
var err error
bufferSize := 64
//вычитываем в нескольких горутинах
concurrentExecution := 5
//Nats name будет потом отображаться в json на страничке мониторинге
nc, err := nats.Connect("natsURI", nats.Name("natReaderConnectName"))
if err != nil {
return fmt.Errorf("could not connect to nats: %v", err)
}
natsChan := make(chan *nats.Msg, bufferSize)
defer nc.Close()
sub, err := nc.ChanSubscribe("natsReaderSubject", natsChan)
if err != nil {
return fmt.Errorf("could not subscribe to nats: %v", err)
}
defer func() {
_ = sub.Unsubscribe()
close(natsChan)
}()
errorChan := make(chan error, 1)
//Добавляем хэндлеры, которые будут отрабатывать в случае ошибки вычитки, дисконнектов, или закрытого коннекта
nc.SetErrorHandler(func(_ *nats.Conn, _ *nats.Subscription, err error) {
fmt.Printf("reader error handler %s\n", err.Error())
errorChan <- err
})
nc.SetDisconnectErrHandler(func(_ *nats.Conn, err error) {
fmt.Printf("reader disconnect error handler: %v", zap.Error(err))
})
nc.SetClosedHandler(func(_ *nats.Conn) {
fmt.Printf("reader close handler")
})
//вычитываем из созданного канала и делаем там свою логику (в этом примере просто выводим на экран)
for i := 0; i < concurrentExecution; i++ {
go func() {
for msg := range natsChan {
var data interface{}
err := json.Unmarshal(msg.Data, &data)
fmt.Println(data)
}
if err != nil {
errorChan <- err
}
}()
}
}`
```
Пример кода, который пишет, и того проще:
```
`func NatsWriter() error{
nc, err := nats.Connect("natsURI", nats.Name("NatsConnectName"))
var someMsg struct{
msg string
}
//топик, в который будем писать
subject := "nats_subject"
b, err := json.Marshal(someMsg)
if err != nil {
return err
}
err = nc.Publish(subject, b)
return err
}`
```
Реализовав логику, попробовали запуститься, и у нас получилась следующая схема.
Есть сервис, который пишет в NATS, в топик awesomeService. Есть второй сервис, который читает из этого топика и делает над сообщением свою магию, затем пишет обратно в NATS, но уже в топик serviceA. Из этого топика уже вычитывают сообщения конечные потребители.
Для обеспечения отказоустойчивости мы просто запустили второй NATS и начали писать в него те же сообщения. Сейчас кластерная версия и NATS JetStream уже нормально работают, и их можно использовать в продакшене.
Запутистились, стартанули, заработало.
Постепенно схема разрасталась, сервисов, которые пишут и обрабатывают сообщения становилось больше, читалей, которые считывают сообщения, тоже становилось больше. При этом, помимо Go, используются C++ и иногда Python сервисы.
Сегодня схема выглядит следующим образом (фактически в нашей схеме намного больше сервисов, через которые проходят сообщения, но смысл сохраняется).
Разумеется, количество сообщений, передаваемых через NATS, тоже увеличилось
Стоит отметить, что достаточно большое количество сервисов, которые занимаются обработкой сообщений, находятся на том же сервере, где запущен сам NATS.
Время прохождения сообщений, один из наиболее критичных для нас факторов, составляет, в 99 перцентилей от 500 микросекунд до 2 миллисекунд. Весьма хороший показатель при наших потребностях.
В плане стабильности NATS тоже показал себя с хорошей стороны, но с одной, довольно болезненной проблемой, нам все-таки пришлось столкнуться. В том числе именно из-за этой проблемы у нас стала теряться некоторая часть сообщений, но об этом ниже.
Относительно потребляемых ресурсов за все время эксплуатации не было каких-то неожиданных факапов, из-за которых пришлось бы срочно что-то тюнить. Все в рамках прогнозируемых изменений.
При необходимости в NATS [можно добавить авторизацию](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/auth_intro), как на уровне всего сервиса, так и на уровне отдельных топиков\пользователей. Мы в свое время это сделали, чтобы ограничить работу с топиками
Отдельным пунктом хотелось бы отметить мониторинг. По дефолту он доступен по HTTP в NATS на порту 8222.
В каждой из вкладок — статистика по выбранному пункту.
В standalone-версии, которую мы используем, чаще всего заходим во вкладку Сonnections, где показаны основные текущие коннекты, количество сообщений\байт, когда запущен и так далее.
```
{
"num_connections": 1,
"total": 1,
"offset": 0,
"limit": 1024,
"connections": [
{
"cid": 4,
"kind": "Client",
"type": "nats",
"ip": "192.168.1.1",
"port": 8085,
"start": "1970-01-01T06:32:17.920532298Z",
"last_activity": "1970-01-01T15:52:17.218785543Z",
"rtt": "78µs",
"uptime": "0d0h1m59s",
"idle": "0s",
"pending_bytes": 0,
"in_msgs": 146288056,
"out_msgs": 0,
"in_bytes": 14592708062,
"out_bytes": 0,
"subscriptions": 0,
"name": "some-awesome-client",
"lang": "go",
}
```
Но все же хочется мониторинг смотреть не в отдельном веб-интерфейсе, а в системе, с плюшками в виде алертов и графиков. Поскольку для наших сервисов мы используем прометей, [нашелся telegraf exporter](https://github.com/influxdata/telegraf/blob/master/plugins/inputs/nats/README.md), с помощью которого снимаем метрики. Правда, этот экспортер снимает только общую информацию касательно количества текущих коннектов, slow\_consumers(об этом немного ниже) и количества входящих\исходящих сообщений\байт (основные показатели, которые доступны на вкладке general).
Ложка дегтя
-----------
Это, наверное, не столько ложка дегтя, сколько архитектурная особенность NATS, но в свое время мы с ней немного потрепались. В чем суть.
Архитектура NATS направлена, в первую очередь, на стабильность работы самого сервера, а не отдельных его клиентов. Соответственно, если кто-то из читателей по каким-то причинам начинает читать медленнее, чем в сабжект пишутся данные, то такой клиент помечается как Slow consumer, а коннект дропается. Чтобы определять, через какой период определять клиент как slow consumer, в NATS используется параметр **write\_deadline** ([подробнее в документации](https://docs.nats.io/running-a-nats-service/nats_admin/slow_consumers)). Я, кстати, так и нашел возможность конфигурирования этого параметра через размер буфера, а не через время «протухания» сообщения.
Нам такая реализация и была нужна в брокере, поскольку, конечно, не очень хорошо бы было, если какой-то из читателей отвалится, но куда критичнее было бы падение всего сервера NATS.
Неприятной же особенностью при такой архитектуре стало то, что если из очереди читают несколько клиентов и один из них начинает тормозить в вычитке (из-за сети, по причине «внутренних противоречий» или из-за чего-нибудь еще), то остальные клиенты, которые читают из этого сабжекта, тоже начинают тормозить при вычитке.
Почему это происходит? Для читателей в NATS реализован цикл, по которому он последовательно проходит и пушит сообщения вместо обработки каждого читателя в отдельной горутине. Подробности [этого кода можно посмотреть в исходниках](https://github.com/nats-io/nats-server/blob/0c2727eef2e2ce461c9eab4e9f587ea907e07925/server/client.go#L4177).
В результате мы просто разнесли по разным Subjects стабильных и нестабильных клиентов, чтобы они не аффектили друг друга. Пока что полет нормальный :)
Выводы
------
Как оказалось, иметь дело с NATS достаточно приятно. Неприхотливый, быстрый, удобный, весьма стабильный, этот брокер оказался хорошим решением для нашей задачи. За все время эксплуатации NATS (+- 3 года) он работает очень стабильно и предсказуемо (за исключением той ложки дегтя, которая была описана выше).
Мы, к сожалению, еще не пробовали работать с кластерной версией или с JetStream, который позволяет сохранять данные на диск. Возможно, там могут выстрелить свои баги\фичи, но это, наверное, будет уже совсем другая история. | https://habr.com/ru/post/708250/ | null | ru | null |
# Скроллер для видео и понимание представления времени в Objective-C
Здраствуй, Хабражитель!
В этой статье я хочу поделиться своим опытом работы с видео в одном из своих последних проектов для iOS. Не буду углубляться в подробности, лишь опишу одну из задач, которую не удалось решить с помощью поиска по хабру, гитхабу и остальному интернету. Задача состояла в следующем: сделать скроллер для видео, да не простой, а чтобы был как в стандартной галерее iOS 7.
Т.к. для воспроизведения видео использовался стандартный компонент *MPMoviePlayerViewController*, а он поддерживает перемотку видео в любую позицию, то основная задача состояла в том, чтобы получить из видео картинки через равные промежутки времени и положить их на *UIView*, таким образом, чтобы они оказывались примерно под текущей позицией в видео. Забегая немного вперед хочу сказать, что по ходу дела пришлось решить еще пару проблем: тормоза при генерации картинок из видео на iPad, и разная длина слайдера в вертикальной и горизонтальной ориентации устройства.
Итак, для начала нам нужно понять, каким образом можно получить картинки из видео. И в этом нам поможет *AVAssetImageGenerator*. Этот класс специально создан для того, чтобы получать картинки с произвольного места видео. Будем считать, что наш тестовый файл располагается в домашней папке и называется **test.mov**:
```
NSString *filepath = [NSString stringWithFormat:@"%@/Documents/test.mov", NSHomeDirectory()];
NSURL *fileURL = [NSURL fileURLWithPath:filepath];
```
Пример использования *AVAssetImageGenerator*:
```
// create asset
AVURLAsset *asset = [[AVURLAsset alloc] initWithURL:fileURL options:nil];
// create generator
AVAssetImageGenerator *generator = [[AVAssetImageGenerator alloc] initWithAsset:asset];
// time for preview
CMTime time = CMTimeMake(1, 2);
// get image ref
CGImageRef imageRef = [generator copyCGImageAtTime:time actualTime:nil error:nil];
// create image
UIImage *image = [UIImage imageWithCGImage:oneRef];
```
Раньше я не сталкивался с *CMTime*, и для того, чтобы разделить время на равные промежутки, не плохо было бы понять, что представляет из себя эта структура данных.
*CMTimeMake* принимает на вход два аргумента: **value** и **timescale**. Я ознакомился с официальной документацией и хочу объяснить простыми словами тем, кто не в курсе, что это за аргументы.
Во-первых, **timescale**, это число, на которое будет разделена каждая секунда. С помощью этого аргумента задается точность, с которой мы можем указать нужный момент времени. Например, если **timescale** указать равным 10, то можно получить 1/10 часть секунды.
В свою очередь **value** указывает на нужную часть времени, с учетом **timescale**. Например, мы имеем видео длиной 60 секунд, **timescale** равен 10, чтобы получить 30 секунду, **value** должно быть равно 300.
Чтобы еще лучше понять представление времени с помощью *CMTime*, скажу что количество секунд в текущий момент видео равняется **value/timescale**. Из предыдущего примера 30 секунда равна 300/10. Если понимать перевод времени из секунд в *CMTime* и обратно, то дальше ни каких проблем с этой структурой не должно возникнуть.
Идем дальше, теперь нам нужно узнать длину видео. Это довольно просто, созданный ранее объект *asset* уже имеет нужное нам свойство.
```
CMTime duration = asset.duration;
```
Хорошо, у нас есть все для того, чтобы нарезать видео на кучу картинок. Теперь встает вопрос, сколько их нужно для портретной и альбомной ориентации устройств. Первое на что нужно обратить внимание, это высота скроллера в стандартной галерее iPhone и iPad. Да, она почти одинаковая, различается только ширина. Не трудно догадаться, что количество картинок равно ширине слайдера поделенной на ширину одной картинки. Я решил, что сделаю квадратные картинки 29х29 точек. Тут есть один тонкий момент, в генераторе размер картинок нужно указывать в пикселях, поэтому там будет значение 58х58.
```
generator.maximumSize = CGSizeMake(58.0, 58.0);
```
Для простоты и удобства, число картинок я указал в дефайнах
```
#define iPad (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad)
#define ThumbnailsCountInPortrait (iPad ? 25 : 10)
#define ThumbnailsCountInLandscape (iPad ? 38 : 15)
```
Теперь все готово для генерации картинок. Я сделал два разных массива, т.к. в портретной и альбомной ориентации картинки из видео будут разные.
```
NSMutableArray *portraitThumbnails = [NSMutableArray array];
NSMutableArray *landscapeThumbnails = [NSMutableArray array];
// generate portrait thumbnails
for (NSInteger i=0; i < ThumbnailsCountInPortrait; i++) {
CMTime time = CMTimeMake(duration.value/ThumbnailsCountInPortrait*i, duration.timescale);
CGImageRef oneRef = [generator copyCGImageAtTime:time actualTime:nil error:nil];
[portraitThumbnails addObject:[UIImage imageWithCGImage:oneRef]];
}
// generate landscape thumbnails
for (NSInteger i=0; i < ThumbnailsCountInLandscape; i++) {
CMTime time = CMTimeMake(duration.value/ThumbnailsCountInLandscape*i, duration.timescale);
CGImageRef oneRef = [generator copyCGImageAtTime:time actualTime:nil error:nil];
[landscapeThumbnails addObject:[UIImage imageWithCGImage:oneRef]];
}
```
Не думаю, что тут будет уместно рассказывать как размещать полученные картинки в ряд на *UIView*, и тем более как их брать из разных массивов при разной ориентации устройства. В этом на самом деле нет ничего сложного и все это можно увидеть в готовом примере.
На последок я хотел бы рассказать про метод решения проблемы с тормозами. Т.к. слайдер инициализируется при загрузке контроллера, то имеет место быть задержка анимации перехода к текущему контроллеру. Самое простое решение — **dispatch\_async**. Эта крайне полезная штука позволяет выполнить содержимое блока асинхронно в фоне, не притормаживая приложение.
Пример использования:
```
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
[videoScroller initializeThumbnails];
dispatch_async(dispatch_get_main_queue(), ^{
[videoScroller loadThumbnails];
});
});
```
Думаю понятно, что **videoScroller** это наш объект, который инициализирует в фоне свои данные, а потом загружает их.
Рабочий пример можно взять тут: <https://github.com/iBlacksus/BLVideoScroller>
**P.S.**
Это моя первая статья, если она окажется интересной для хабражителей, то я готов и дальше делиться своим опытом, в частности планирую написание статьи о создании слайдера, позволяющего выбрать цвет текста с произвольной палитры, которая представляет из себя просто картинку. | https://habr.com/ru/post/204440/ | null | ru | null |
# Как рассуждать, чтобы проходить Capture The Flag игры
Capture The Flag - название ряда соревнований в информатике, чаще всего - в информационной безопасности. Как веб-разработчик, я интересуюсь только CTF в области web'а - поиск уязвимостей, атаки, сетевое взаимодействие. На старте решения первого CTF было трудно понять, как же именно рассуждают проф. игроки, участвующие в турнирах, и я решил написать несколько статей о том, как можно искать зацепки в исходных данных и как раскручивать их до победы.
Картинка для красоты. Источник: https://habr.com/ru/post/535140/ Рассказывать это я буду на живых примерах от простого к сложному. В качестве первой игры рекомендую пройти CuriositY - "любопытство", как достаточно простой, приятный и не требующий глубоких/широких познаний в Computer Science квест. Если вы хотите попробовать себя до прочтения статьи, то [вот ссылка на игру](https://shark.fish/curiosity/level001/index.html).
Источник: https://shark.fish/curiosity/level001/index.html ### Начальная настройка:
Во-первых, необходимо открыть браузер без расширений, т.к. некоторые из них добавляют ненужные фреймы, скрывают блоки и прочее. Нам нужно видеть документ в нормальном состоянии (утверждение не всегда верно). Во-вторых, открыть девтулз и выставить Desktop режим, чтобы видеть, когда и как меняется курсор. Это пригодится в первой же задаче.
Далее текст скрыт под спойлеры для удобства) Вышло достаточно многословно. Первые 10 задач достаточно простые, поэтому снова рекомендую попробовать сначала самостоятельное решение.
### Задача 1.
Превью, рассуждения и решениеЗадача 1.Здесь всё достаточно просто. До того, как открыть код страницы, можно нажать на каждый видимый блок, вернуться в исходное состояние, и провести мышкой между блоками. Так, по изменившемуся на указатель курсору, заметим, что в центре есть ссылка без бекграунда, ведущая нас на второй этап.
### Задача 2.
Превью, рассуждения и решениеЗадача 2.В качестве подсказки мы получаем переменную lvl и инкремент) В данном случае легко заметить, что в адресной строке у нас есть level и номер, пробуем увеличить на один и переходим на следующий этап. Пока всё просто, но это начало))
Кстати, если вы продолжите увеличивать номер, то увидите маленькую пасхалочку от автора.
### Задача 3.
Превью, рассуждения и решениеЗадача 3.Здесь мы не можем ничего прожать, нет никаких видимых элементов, кликабельных ссылок. Значит, открываем код страницы и смотрим HTML, т.к. в подсказке как раз скобки, характерные в т.ч. для языков разметки.
Страничка простая, поэтому сразу находим в комментарии `applause.html` и вставляем в адресную строку для перехода на следующий этап.
### Задача 4.
Превью, рассуждения и решениеЗадача 4. Подсказка тоже достаточно простая, сразу видно обычную консоль, поэтому до того, как начнём думать "а вдруг что-то сложнее", пробуем проверить вывод консоли на странице - и, бинго! Находим `iso.html`. Вставляем в адресную строку, идём дальше.
### Задача 5.
Превью, рассуждения и решениеЗадача 5. Пробуем консольные команды, уже становится интересно)Задачи усложняются. Мы видим терминал, можем вводить туда команды, базовое в таком случае - посмотреть, что есть ( ls ), посмотреть, есть ли скрытые файлы ( ls -a ), сменить директорию ( cd ) и прочие. Чем сложнее CTF, тем лучше нужно ориентироваться в консольных командах и понимать, какие параметры можно передать команде.
Итак, сначала посмотрим, что у нас в папке. Вводим `ls -a` и видим, что есть субдиректория curiosity. Переходим в неё с помощью команды cd и снова смотрим, что у нас есть.
В текущей директории есть ряд файлов и субдиректорий. Мы сейчас находимся на пятом уровне, поэтому попробуем перейти в 005 и посмотреть, что там:
А вот и ответТак как все предыдущие ответы сводились к поиску html файла, то и тут не будет исключений. Вводим в адресную строку `quiff.html` и переходим на шестой уровень
### Задача 6.
Превью, рассуждения и решениеЗадача 6. Нередко подсказки зашиты в urlЧто ж, раз на странице ничего не кликается, а подсказка в урле означает "слой", то сразу идём в девтулз. Ожидать можно многого: div с pointer-events:none, z-index и position: absolute, нужно внимательно смотреть возможные варианты. Однако, в данном случае, всё проще: изображение - svg, значит, нужно открыть его в новой вкладке и так же посмотреть в девтулз.
У свг могут быть атрибуты или метаинформация, которые в других задачах могут содержать подсказки, но у нас всё ещё проще: достаточно удалить , чтобы увидеть ответ на задачу.
Решение: https://shark.fish/curiosity/level006/behind.html ### Задача 7.
Превью, рассуждения и решениеЗадача 7. Перевод с латыниЭто задание примечательно тем, что представляет собой целый класс подсказок: отсылки на цитаты, личности, события. Для решения подобных вопросов необходимо развивать кругозор не только в технических рамках, но и читать о развитии науки в целом, узнавать людей, их высказывания и прочее. Я предпочитаю всё же более hard skills задачи, а не эрудицию, но всё же.
Школьных познаний латыни достаточно, чтобы сопоставить: vita = жизнь, universum = вселенная, omnia (больше от Gitlab Omnibus триггернуло) - что-то типа "всё вместе". Похоже, что тут "Главный вопрос жизни, вселенной и всего такого" с ответом "42" - и 42.html действительно является ответом.
### Задача 8.
Превью, рассуждения и решениеЗадача 8. Явно преобразование числа из десятичной системы в двоичнуюЗдесь тоже всё достаточно просто:
- имеем число
- необходимо конвертировать его в двоичное
- после попробуем вставить число + '.html' в адресную строку
Чтобы быстро сконвертировать число из десятичной в двоичную систему нам нужно открыть консоль браузера и ввести `Number(42).toString(2)`, что вернёт нам `'101010'.`
### Задача 9.
Превью, рассуждения и решениеЗадача 9. Название файла наводит на мысльПодсказка явно требует подстановки пути до файла в урл. Вставив эту строку вместо csv.html, мы получаем файл, похожий на координаты в трёхмерном пространстве: 3 столбца и множество строк, во всех ячейках - цифры.
После достаточно долгих поисков сумел отыскать сервис, позволяющий залить csv и сгенерировать модель: <http://bl.ocks.org/phil-pedruco/9913243>
Модель можно вращать, осматривать с разных сторонПохоже на полый цилиндр. Попробуем подставить названия в адресную строку
https://shark.fish/curiosity/level009/cylinder.htmlЧто ж, придётся угадывать. Пробовал переводить трубу, бочку, кольцо - безрезультатно. Признаюсь, залез на гитхаб проекта, чтобы увидеть ответ. Оказалось, что это `donut.html` - то есть пончик. Не согласен с автором, но, возможно, нужно было использовать не онлайн генерацию, а какое-то более известное средство, возможно, MatLab.
### Задача 10.
Превью, рассуждения и решениеЗадача 10. Упоминание в соцсетяхИзначально по подсказке я подумал, что это упоминание на гитхабе, и нужно найти такой профиль. Сразу скопировал всю строку и отправил в гугл, оказалось, что это профиль в твиттере с единственным постом: `fever.html`
### Задача 11.
Превью, рассуждения и решениеЗадача 11. РепозиторийНеобязательно сразу клонировать проект, мы можем перейти по ссылке и посмотреть, что находится в репозитории. Видим, что там один .md файл, но есть один нюанс: почти 900 коммитов!
Без поллитры, наверное, не разобраться.Что ж, клонируем, будем изучать историю изменений файла. Задание так же типовое, и для решения задач данного класса нужно понимать, как работает git, и уметь пользоваться либо консолью, либо графическим представлением. По командам чаще всего нужны:
- log
- log -S
- diff
- show
Также попробуем открыть первый коммит, 11й коммит (номер задачи). Итоговый алгоритм решения задачи оказался достаточно простым: я решил, что нужно искать по строке из `.md` файла, и выполнил команду git log -S 'There is nothing here'
Поиск дал 3 коммита, у одного commit message - 'jneq', у второго - 'uokp', у третьего - 'Initial commit'. Чтобы посмотреть изменения, выведем для каждого коммита git show, и увидим простые диффы, у одного из который будет нужный файл - cactus.html
### Задача 12.
Превью, рассуждения и решениеЗадача 12. Буквы или символы?Странное задание. Изначально искал подвох, но глаза зацепились за res, our, попробовал ввести resource и прокатило. Иногда задачи проще, чем кажутся.
### Задача 13.
Превью, рассуждения и решениеЗадача 13. Подсказка в адресной строкеCразу гуглим ISO 10646, вспоминаем, что это стандарт символов Unicode, и теперь у нас два варианта:
- посчитать сумму и найти символ в таблице юникода
- найти символы в таблице юникода и посчитать сумму
Как оказалось, под 2609 в таблице символов юникода находится солнце, а 26С6 - дождь. Сложив дождь и солнце, мы получаем радугу, и, введя в адресную строку rainbow, получим ошибку:
Значит, нужен юникодСимвол радуги в юникоде - 1f308. Вбиваем его в урл и переходим на следующий уровень.
### Задача 14
Превью, рассуждения и решениеЗадача 14. Выглядит простоСудя по урлу и ошибки в консоли, нам нужно смотреть JS-код на странице. Для удобства приведу его здесь:
`[ -1, -3, 14, 16, 1, 8, -54, 4, 16, 9, 8 ].map(function() { return String.fromCharCode(x) + ONE_HUNDRED; }).join("");`
Для тех, кто знаком с JS, очевидно, что в коллбэк для map не передаём переменную, плюс у нас не определена и переменная ONE\_HUNDRED. Передаём икс, ONE\_HUNDRED меняем на число, копируем и вставляем в консоль, смотрим ответ:
https://shark.fish/curiosity/level014/cartel.html### Задача 15
Превью, рассуждения и решениеЗадача 15. КоординатыЧто ж, очень сильно похоже на координаты для GPS. Открываем Google Maps, вбиваем строку as is - не удаётся найти. Пробуем сменить местами аргументы - видим фотографию Hollywood, вводим в адресную строку и финишируем!
Спасибо за внимание! Надеюсь, у меня удалось заинтересовать подобными контестами пару-тройку новых людей :) | https://habr.com/ru/post/682986/ | null | ru | null |
# Flutter. Keys! Для чего они?
Параметр `key` можно найти практически в каждом конструкторе виджета, но используют этот параметр при разработке достаточно редко. `Keys` сохраняют состояние при перемещении виджетов в дереве виджетов. На практике это означает, что они могут быть полезны для сохранения местоположения прокрутки пользователя или сохранения состояния при изменении коллекции.
Данная статья адаптирована из следующего [видео](https://youtu.be/kn0EOS-ZiIc). Если вы предпочитаете слушать / смотреть, а не читать, то видео предоставит вам тот же материал.
Секретная информация о `keys`
-----------------------------
Большую часть времени… `keys` вам не нужны. В общем, нет никакого вреда в их добавлении, но в этом также нет необходимости, так как они просто занимают место, как новое ключевое слово или объявление типов с обеих сторон новой переменной (я о тебе, `Map aMap = Map()`).
> Но если вы обнаружите, что добавляете, удаляете или переставляете в коллекции виджеты, которые содержат некоторое состояние и имеют один тип, то стоит обратить внимание на `keys`!
Чтобы продемонстрировать, почему вам нужны `keys` при изменении коллекции виджетов, я написала чрезвычайно простое приложение с двумя разноцветными виджетами, которые меняются местами при нажатии на кнопку:
В данной версии приложения у меня два виджета случайного цвета без состояния (`StatelessWidget`) в `Row` и виджете PositionedTiles с состоянием (`StatefulWidget`), чтобы хранить в нем порядок цветных виджетов. Когда я нажимаю кнопку `FloatingActionButton` внизу, цветные виджеты правильно меняют своё место в списке:
```
void main() => runApp(new MaterialApp(home: PositionedTiles()));
class PositionedTiles extends StatefulWidget {
@override
State createState() => PositionedTilesState();
}
class PositionedTilesState extends State {
List tiles = [
StatelessColorfulTile(),
StatelessColorfulTile(),
];
@override
Widget build(BuildContext context) {
return Scaffold(
body: Row(children: tiles),
floatingActionButton: FloatingActionButton(
child: Icon(Icons.sentiment\_very\_satisfied), onPressed: swapTiles),
);
}
swapTiles() {
setState(() {
tiles.insert(1, tiles.removeAt(0));
});
}
}
class StatelessColorfulTile extends StatelessWidget {
Color myColor = UniqueColorGenerator.getColor();
@override
Widget build(BuildContext context) {
return Container(
color: myColor, child: Padding(padding: EdgeInsets.all(70.0)));
}
}
```
Но если мы добавим в наши цветные виджеты состояние (сделаем их `StatefulWidget`) и будем в них хранить цвет, то при клике по кнопке выглядит так, как будто ничего не происходит:
```
List tiles = [
StatefulColorfulTile(),
StatefulColorfulTile(),
];
...
class StatefulColorfulTile extends StatefulWidget {
@override
ColorfulTileState createState() => ColorfulTileState();
}
class ColorfulTileState extends State {
Color myColor;
@override
void initState() {
super.initState();
myColor = UniqueColorGenerator.getColor();
}
@override
Widget build(BuildContext context) {
return Container(
color: myColor,
child: Padding(
padding: EdgeInsets.all(70.0),
));
}
}
```
В качестве разъяснения: код, указанный выше, глючит в том, что он не показывает обмен цветами, когда пользователь нажимает кнопку. Чтобы исправить эту ошибку, надо добавить `key` параметр в цветные `StatefulWidget` виджеты, а затем виджеты поменяются местами, как мы хотим:
```
List tiles = [
StatefulColorfulTile(key: UniqueKey()), // Keys added here
StatefulColorfulTile(key: UniqueKey()),
];
...
class StatefulColorfulTile extends StatefulWidget {
StatefulColorfulTile({Key key}) : super(key: key); // NEW CONSTRUCTOR
@override
ColorfulTileState createState() => ColorfulTileState();
}
class ColorfulTileState extends State {
Color myColor;
@override
void initState() {
super.initState();
myColor = UniqueColorGenerator.getColor();
}
@override
Widget build(BuildContext context) {
return Container(
color: myColor,
child: Padding(
padding: EdgeInsets.all(70.0),
));
}
}
```
Но это необходимо, только если у вас есть виджеты с состоянием в поддереве, которое вы меняете. Если все поддерево виджета в вашей коллекции не имеет состояния, ключи не нужны.
Вот так! В общем-то все, что вам нужно знать, чтобы использовать `keys` во `Flutter`. Но если вы хотите несколько углубиться в происходящее…
---
Разбираемся, почему `keys` иногда необходимы
--------------------------------------------
Вы все еще здесь, да? Ну, тогда подходите ближе, чтобы узнать истинную природу деревьев элементов и виджетов, чтобы стать Flutter Магом! Ухахаха! Ха-ха! Ха-ха! ГМ, извините.
Как вы знаете, внутри для каждого виджета Flutter строит соответствующий элемент. Так же, как Flutter строит дерево виджетов, он также создает дерево элементов (ElementTree). ElementTree чрезвычайно просто, содержит только информацию о типе каждого виджета и ссылку на дочерние элементы. Вы можете думать о ElementTree как о скелете вашего Flutter приложения. Он показывает структуру вашего приложения, но всю дополнительную информацию можно посмотреть по ссылке на исходный виджет.
Row виджет в приведенном выше примере содержит набор упорядоченных слотов для каждого из его дочерних элементов. Когда мы меняем порядок цветных виджетов в Row, Flutter ходит по ElementTree, чтобы проверить, является ли структура скелета приложения такой же.
Проверка начинается с RowElement, а затем переходит к дочерним элементам. ElementTree проверяет, что у нового виджета те же тип и `key`, что и у старого, и если это так, то элемент обновляет свою ссылку на новый виджет. В версии кода без состояния у виджетов нет `key`, поэтому Flutter просто проверяет только тип. (Если слишком много информации за раз, то посмотрите анимированную диаграмму выше.)
Ниже ElementTree для виджетов с состоянием выглядит немного иначе. Есть виджеты и элементы, как и раньше, но также есть пара объектов состояния для виджетов, и информация о цвете хранится в них, а не в самих виджетах.
В случае цветных `StatefulWidget` виджетов без `key`, когда я меняю порядок двух виджетов, Flutter ходит по ElementTree, проверяет тип RowWidget и обновляет ссылку. Затем элемент цветного виджета проверяет, что соответствующий виджет имеет тот же тип, и обновляет ссылку. То же самое происходит со вторым виджетом. Поскольку Flutter использует ElementTree и соответствующее ему состояние, чтобы определить, что на самом деле отображать на вашем устройстве, с нашей точки зрения, похоже, что виджеты не поменялись местами!
В исправленной версии кода в цветных виджетах с состоянием в конструкторе я определила свойство `key`. Теперь, если мы поменяем виджеты в `Row`, то по типу они совпадут как и раньше, но значения `key` у цветного виджета и у соответствующего элемента в ElementTree будут разными. Это заставляет Flutter деактивировать эти элементы цветных виджетов и удалить ссылки на них в ElementTree, начиная с первого, у которого не совпадает `key`.
Затем Flutter ищет для дочерних виджетов в `Row` элемент в ElementTree с соответствующим `key`. При совпадении добавляет ссылку в элемент на виджет. Flutter делает для каждого дочернего элемента без ссылки. Теперь Flutter отобразит то, что мы ожидаем, цветные виджеты меняются местами, когда я нажимаю кнопку.
Таким образом, `keys` полезны, если вы изменяете порядок или количество виджетов с состоянием в коллекции. В данном я примере я сохранила цвет. Однако, часто состояние бывает не таким явным. Воспроизведение анимации, отображение введенных пользователем данных и прокрутка местоположения, – всё имеет состояние.
---
Когда мне использовать `keys`?
------------------------------
Короткий ответ: если вам нужно добавить `keys` в приложение, то следует добавить их в верхней части поддерева виджетов с состоянием, которое необходимо сохранить.
Распространенная ошибка, которую я видела, — люди думают, что им нужно определить `key` только для первого виджета с состоянием, но есть нюансы. Не верите мне? Чтобы показать, в какие неприятности мы можем попасть, я обернула мои цветные виджеты в `Padding` виджеты, при этом оставив ключи для цветных виджетов.
```
void main() => runApp(new MaterialApp(home: PositionedTiles()));
class PositionedTiles extends StatefulWidget {
@override
State createState() => PositionedTilesState();
}
class PositionedTilesState extends State {
// Stateful tiles now wrapped in padding (a stateless widget) to increase height
// of widget tree and show why keys are needed at the Padding level.
List tiles = [
Padding(
padding: const EdgeInsets.all(8.0),
child: StatefulColorfulTile(key: UniqueKey()),
),
Padding(
padding: const EdgeInsets.all(8.0),
child: StatefulColorfulTile(key: UniqueKey()),
),
];
@override
Widget build(BuildContext context) {
return Scaffold(
body: Row(children: tiles),
floatingActionButton: FloatingActionButton(
child: Icon(Icons.sentiment\_very\_satisfied), onPressed: swapTiles),
);
}
swapTiles() {
setState(() {
tiles.insert(1, tiles.removeAt(0));
});
}
}
class StatefulColorfulTile extends StatefulWidget {
StatefulColorfulTile({Key key}) : super(key: key);
@override
ColorfulTileState createState() => ColorfulTileState();
}
class ColorfulTileState extends State {
Color myColor;
@override
void initState() {
super.initState();
myColor = UniqueColorGenerator.getColor();
}
@override
Widget build(BuildContext context) {
return Container(
color: myColor,
child: Padding(
padding: EdgeInsets.all(70.0),
));
}
}
```
Теперь по нажатию на кнопку виджеты получают совершенно случайные цвета!
Так выглядит дерево виджетов и ElementTree с добавленными `Padding` виджетами:
Когда мы меняем позиции дочерних виджетов, алгоритм поиска соответствия между элементами и виджетами смотрит на один уровень в дереве элементов. На диаграмме дочерние элементы дочерних элементы затемнены, чтобы ничто не отвлекало от первого уровня. На этом этом уровне все совпадает правильно.
На втором уровне Flutter замечает, что `key` цветного элемента не соответствует `key` виджета, поэтому он деактивирует этот элемент, отбрасывая удаляя все ссылки на него. `keys`, которые мы используем в этом примере, – `LocalKeys`. Это означает, что при сопоставлении виджета с элементами Flutter ищет совпадения `keys` только на определенном уровне дерева.
Поскольку он не может найти элемент цветного виджета на этом уровне с соответствующим `key`, он создает новый и инициализирует новое состояние, делая в данном случае виджет оранжевым!
Если мы определим `keys` для `Padding` виджетов:
```
void main() => runApp(new MaterialApp(home: PositionedTiles()));
class PositionedTiles extends StatefulWidget {
@override
State createState() => PositionedTilesState();
}
class PositionedTilesState extends State {
List tiles = [
Padding(
// Place the keys at the \*top\* of the tree of the items in the collection.
key: UniqueKey(),
padding: const EdgeInsets.all(8.0),
child: StatefulColorfulTile(),
),
Padding(
key: UniqueKey(),
padding: const EdgeInsets.all(8.0),
child: StatefulColorfulTile(),
),
];
@override
Widget build(BuildContext context) {
return Scaffold(
body: Row(children: tiles),
floatingActionButton: FloatingActionButton(
child: Icon(Icons.sentiment\_very\_satisfied), onPressed: swapTiles),
);
}
swapTiles() {
setState(() {
tiles.insert(1, tiles.removeAt(0));
});
}
}
class StatefulColorfulTile extends StatefulWidget {
StatefulColorfulTile({Key key}) : super(key: key);
@override
ColorfulTileState createState() => ColorfulTileState();
}
class ColorfulTileState extends State {
Color myColor;
@override
void initState() {
super.initState();
myColor = UniqueColorGenerator.getColor();
}
@override
Widget build(BuildContext context) {
return Container(
color: myColor,
child: Padding(
padding: EdgeInsets.all(70.0),
));
}
}
```
Flutter замечает проблему и обновляет ссылки правильно, как это было в нашем предыдущем примере. Порядок во Вселенной восстановлен.
---
Какой тип `Key` мне следует использовать?
-----------------------------------------
Flutter APIs дали нам на выбор несколько `Key` классов. Тип `key`, который вы должны использовать, зависит от того, какая отличительная характеристика у элементов, нуждающихся в `keys`. Посмотрите на информацию, которую вы храните в соответствующих виджетов.
Рассмотрим следующее To-do приложение[1], где вы можете изменить порядок элементов в списке задач на основе приоритета, а когда закончите, вы можете их удалить.
**ValueKey**
В данном случае можно ожидать, что текст пункта на выполнение будет постоянным и уникальным. Если это так, то, вероятно, это хороший кандидат для `ValueKey`, где текст является "значением".
```
return TodoItem(
key: ValueKey(todo.task),
todo: todo,
onDismissed: (direction) => _removeTodo(context, todo),
);
```
**ObjectKey**
В другом случае, у вас может быть приложение "Адресная книга", в котором перечислены сведения о каждом пользователе. В этом случае каждый дочерний виджет хранит более сложную комбинацию данных. Любое из отдельных полей, например имя или день рождения, может совпадать с другой записью, но комбинация уникальна. В этом случае скорее всего лучше всего подходит `ObjectKey`.
**UniqueKey**
Если у вас есть несколько виджетов в коллекции с одинаковым значением или если вы хотите действительно убедиться, что каждый виджет отличается от всех других, то можно использовать `UniqueKey`. Я использовала `UniqueKey` в примере приложения для переключения цветов, потому что у нас не было других постоянных данных, которые хранились бы в наших виджетах, и мы не знали, какой цвет будет у виджета при создании.
Важно отметить, что **не надо** использовать случайное число в качестве вашего `key`. Каждый раз, когда виджет будет создан, будет генерироваться новое случайное число, и вы потеряете согласованность между фреймами. При таком сценарии вы можете вообще не использовать `keys`!
**PageStorageKeys**
`PageStorageKeys` – это специализированные `keys`, которые содержит текущее состояние скролла, чтобы приложение могло сохранить его для последующего использования.
**GlobalKeys**
Есть два варианта использования `GlobalKeys`: они позволяют виджетам менять родителей в любом месте приложения без потери состояния и могут использоваться для доступа к информации о другом виджете в совершенно другой части дерева виджетов. В качестве примера первого сценария можно представить, что вы хотите показать один и тот же виджет на двух разных экранах, но с одинаковым состоянием, для того, чтобы данные виджета сохранились, вы будете использовать `GlobalKey`. Во втором случае может возникнуть ситуация, когда вам надо проверить пароль, но при этом вы не хотите делиться информацией о состоянии с другими виджетами в дереве. `GlobalKeys` также могут быть полезны для тестирования, используя `key` для доступа к конкретному виджету и запроса информации о его состоянии.
Часто (но не всегда!) `GlobalKeys` немного похожи на глобальные переменные. Зачастую их можно заменить на использование `InheritedWidgets` или что-то вроде Redux, или шаблона BLoC.
---
Краткое заключение
------------------
В общем используйте `Keys`, если вы хотите сохранить состояние между поддеревьями виджетов. Это чаще всего происходит при изменении коллекции виджетов одного типа. Поместите `key` в верхней части поддерева виджетов, которое необходимо сохранить, и выберите тип `key` на основе данных, хранящихся в виджете.
Поздравляю, теперь вы на пути к тому, чтобы стать Flutter Магом! О, я сказала маг? Я имела в виду мага[2], как тот, кто пишет исходный код приложения… что почти так же хорошо. …Почти.
[1] Вдохновление для написания кода To-do приложения получено здесь
<https://github.com/brianegan/flutter_architecture_samples/tree/master/vanilla>
[2] Автор использует слово `sorcerer` и позже добавляет в него лишнюю букву до `sourcerer` | https://habr.com/ru/post/446050/ | null | ru | null |
# MongoDB и MySQL в Ruby и PHP
Некоторое время назад довольно заинтересовался разработкой для [MongoDB](http://www.mongodb.org) и провел некоторые бенчмарки в сравнении с MySQL.
Изначально только в Ruby, но, когда результаты изумили (в худшую сторону), то и в PHP, для сравнения.
Может быть, это кому-то сэкономит некоторое время.
**Исходные данные:*** Система:`$ uname -a
Linux pavlin.ik 2.6.31-gentoo-r4 #1 SMP Sun Nov 1 18:21:31 MSK 2009 i686 Intel(R) Core(TM)2 Duo CPU T5450 @ 1.66GHz GenuineIntel GNU/Linux`
* MongoDB v. 1.0.1
* Gems:
+ gem mongo (0.16)
+ gem mongo\_ext (0.16)
+ gem mysql (2.8.1)Ruby:
+ ruby 1.8.7 (2009-06-12 patchlevel 174) [i686-linux]
+ ruby 1.9.1p243 (2009-07-16 revision 24175) [i686-linux]
+ [ruby-enterprise-1.8.7-2009.10](http://www.rubyenterpriseedition.com/)PHP 5.2.11-pl0-gentoo with Suhosin-Patch 0.9.7 (cli)
Исходный код тестов есть тут: <http://github.com/latrommi/benchmarking>
Собственно, результаты:
Вывод один: это *не значит*, что MongoDB хуже MySQL, это значит, что для нее ещё не написано *нормального, быстрого* драйвера для Ruby :)
P.S. будет круто, если кто-то проведет аналогичные тесты для Python.
P.P.S. пользуясь случаем, передаю привет [TravisBickle](https://habrahabr.ru/users/travisbickle/) ;) | https://habr.com/ru/post/74683/ | null | ru | null |
# Разработка телеграм-бота на Kotlin + Spring Boot
Привет, читателям Хабра!
В этой статье я расскажу о том, как быстро и легко разработать свой собственный телеграм-бот на языке Kotlin с использованием Spring Boot.
Основная задумка заключается в том, чтобы архитектура Бота была абстрагирована от бизнес процессов. То есть акцент должен быть задействован именно на написании кода, который нужен только бизнесу.
### Технологии
Мой выбор пал на следующий стек технологий:
* Kotlin
* Spring Boot 2.5+
* JOOQ
* Freemarker
* PostgreSQL
* org.telegram.telegrambots
### Обоснования выбора технологий
**Spring Boot** и весь Spring Framework в JVM мире стал неотъемлемой частью создания больших и сложных энтерпрайз систем. Пал выбор именно на него, так как порой хочется сделать не просто бота, а полноценное приложение, которым будет удобно пользоваться и удобно масштабировать.
**Kotlin** считается неким витком развития в мире JVM, он проще JAVA и очень хорошо интегрирован в Spring Framework
**JOOQ** — механизм, который помогает на DSL подобном языке формировать sql запросы.
**Freemarker** — шаблонизатор, необходим для формирования динамичных текстовок
**PostgreSQL** — СУБД. Тут субъективный выбор. Считаю его лучшим из бесплатных инструментов.
**org.telegram.telegrambots** — набор библиотек для Telegram Api
### Источники
Сам код лежит в [гитхабе](https://github.com/minpor/telegram-bot-kotlin-template).
Как создать нового бота и описание api можно найти [тут](https://tlgrm.ru/docs/bots)
### Руководство
Как и в любое приложении в JVM мире, начнем работу с описании зависимостей.
**build.gradle.kts**
```
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
import nu.studer.gradle.jooq.JooqEdition
import nu.studer.gradle.jooq.JooqGenerate
val postgresVersion = "42.3.1"
val telegramBotVersion = "5.3.0"
// Список необходимых плагинов
plugins {
id("nu.studer.jooq") version("6.0.1")
id("org.flywaydb.flyway") version("7.7.0")
id("org.springframework.boot") version "2.5.6"
id("io.spring.dependency-management") version "1.0.11.RELEASE"
kotlin("jvm") version "1.5.31"
kotlin("plugin.spring") version "1.5.31"
}
group = "ru.template.telegram.bot.kotlin"
version = "0.0.1-SNAPSHOT"
java.sourceCompatibility = JavaVersion.VERSION_11
repositories {
mavenCentral()
}
// механизм, который поможет сгенерить метаданные
configurations {
compileOnly {
extendsFrom(configurations.annotationProcessor.get())
}
}
tasks.clean {
delete("src/main/java")
}
extra["springCloudVersion"] = "2020.0.4"
val flywayMigration = configurations.create("flywayMigration")
// Надстройка для миграции данных в СУБД
flyway {
validateOnMigrate = false
configurations = arrayOf("flywayMigration")
url = "jdbc:postgresql://localhost:5432/kotlin_template"
user = "postgres"
password = "postgres"
}
// список зависимстей
dependencies {
flywayMigration("org.postgresql:postgresql:$postgresVersion")
jooqGenerator("org.postgresql:postgresql:$postgresVersion")
runtimeOnly("org.postgresql:postgresql")
//Классические стартеры spring boot
implementation("org.springframework.boot:spring-boot-starter")
implementation("org.springframework.boot:spring-boot-starter-jooq")
implementation("org.springframework.boot:spring-boot-starter-freemarker")
implementation("org.springframework.boot:spring-boot-starter-web")
implementation("org.telegram:telegrambots:$telegramBotVersion")
implementation("org.telegram:telegrambotsextensions:$telegramBotVersion")
implementation("org.telegram:telegrambots-spring-boot-starter:$telegramBotVersion")
// зависимости, которые помогут сгенерить метаданные
compileOnly("org.springframework.boot:spring-boot-configuration-processor")
annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
implementation("org.jetbrains.kotlin:kotlin-reflect")
implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
testImplementation("org.springframework.boot:spring-boot-starter-test")
}
dependencyManagement {
imports {
mavenBom("org.springframework.cloud:spring-cloud-dependencies:${property("springCloudVersion")}")
}
}
tasks.withType {
kotlinOptions {
freeCompilerArgs = listOf("-Xjsr305=strict")
jvmTarget = "11"
}
}
tasks.withType {
useJUnitPlatform()
}
// Настройка для JOOQ, в которой описано правило формирования POJO классов для формирования запросов при помощи DSL кода
jooq {
edition.set(JooqEdition.OSS)
configurations {
create("main") {
jooqConfiguration.apply {
jdbc.apply {
driver = "org.postgresql.Driver"
url = flyway.url
user = flyway.user
password = flyway.password
}
generator.apply {
name = "org.jooq.codegen.DefaultGenerator"
generate.apply {
isDeprecated = false
isRecords = true
isImmutablePojos = false
isFluentSetters = false
isJavaBeansGettersAndSetters = false
isSerializablePojos = true
isVarargSetters = false
isPojos = true
isNonnullAnnotation = true
isUdts = false
isRoutines = false
isIndexes = false
isRelations = true
isPojosEqualsAndHashCode = true
}
database.apply {
name = "org.jooq.meta.postgres.PostgresDatabase"
inputSchema = "public"
excludes = "flyway\_schema\_history"
}
target.apply {
// Пакет куда отрпавляются сгенерированные классы
packageName = "ru.template.telegram.bot.kotlin.template.domain"
directory = "src/main/java"
}
strategy.name = "org.jooq.codegen.DefaultGeneratorStrategy"
}
}
}
}
// таска для генерации JOOQ классов
tasks.named("generateJooq").configure {
inputs.files(fileTree("src/main/resources/db/migration"))
.withPropertyName("migrations")
.withPathSensitivity(PathSensitivity.RELATIVE)
allInputsDeclared.set(true)
outputs.upToDateWhen { false }
}
}
```
Как мы видим из описания кода выше, мы собираем зависимости при помощи Gradle. Не будем подробно останавливаться на теме: как правильно написать gradle-файл. В интернете много примеров. Сейчас нам не так это важно.
Следующим этапом — создание главного класса, который будет запускать нашего бота.
**Application.kt**
```
package ru.template.telegram.bot.kotlin.template
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
// Все Spring Boot приложения начинаются с аннотации @SpringBootApplication
@SpringBootApplication
class Application
fun main(args: Array) {
runApplication(\*args)
}
```
Для примера, весь наш код описан в пакете ru.template.telegram.bot.kotlin.template. Там будут лежать и прочие компоненты нашей архитектуры.
Создадим пакеты:
* api — Классы, которые относятся к непосредственному взаимодействию с Телеграм API (отправка и получение данных)
* command — Список команд телеграм бота
* component — Прочие бины.
* config — Конфигурация приложения
* dto — DTO классы
* enums — Енумы
* event — Список классов для формирования ивентов [Application Publisher](https://www.baeldung.com/spring-events)
* listener — Приём событий Application Publisher
* properties — Классы настроек приложения. Сами настройки лежат в ресурсах приложения (appication.yml)
* repository — Слой взаимодействия с СУБД
* service — Сервисы приложения
* strategy — Стратегии. Это те компоненты, которые нужно менять, добавлять и удалять по ходу изменения бизнес процессов
#### Начало формирование архитектуры с небольшим примером
Нам необходимо создать такой компонент, который бы принимал наши сообщения от Бота и начинал их обрабатывать.
Создадим файл application.yml
```
# Настройка для телеграм апи
bot:
username: kotlin_template_bot
token: [your bot token here]
# Настройка для СУБД
spring:
datasource:
url: jdbc:postgresql://localhost:5432/kotlin_template
username: postgres
password: postgres
```
После чего опишем нашего бота в виде класса
**BotProperty.kt**
```
package ru.template.telegram.bot.kotlin.template.properties
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.stereotype.Component
@Component
@ConfigurationProperties(prefix = "bot")
// Всё, что есть в application.yml можно описать в виде класса. Делается в первую очередь для удобства
data class BotProperty(
var username: String = "",
var token: String = ""
)
```
В примере представлены несколько команд бота. Они описаны в виде енумов
**CommandCode.kt**
```
package ru.template.telegram.bot.kotlin.template.enums
// Енум состоит из самой команды, команды бота в телеграме и ее словесное описание
enum class CommandCode(val command: String, val desc: String) {
START("start", "Start work"),
USER_INFO("user_info", "user info"),
BUTTON("button", "button yes no")
}
```
Для примера реализуем несколько команд: Начало работы (приветствие), информация о пользователе ( на этом этапе просто обновим данные в базе случайным текстом) и сообщение с кнопками (здесь нажмём на кнопку из предложенных)
Для простоты у нас будет 1 таблица **users**
Создадим миграцию в resources/db/migration
**V1\_\_init.sql**
```
create table users
(
id int8 primary key not null,
step_code varchar(100), -- код этапа
text varchar(100), -- произвольный текст
accept varchar(3) -- данные из кнопок
);
```
Теперь необходимо подготовить **UsersRepository** в котором будут реализованы все методы, которые понадобятся нам в работе.
**UsersRepository.kt**
```
package ru.template.telegram.bot.kotlin.template.repository
import org.jooq.DSLContext
import org.springframework.stereotype.Repository
import ru.template.telegram.bot.kotlin.template.domain.Tables
import ru.template.telegram.bot.kotlin.template.domain.tables.pojos.Users
import ru.template.telegram.bot.kotlin.template.enums.StepCode
@Repository
class UsersRepository(private val dslContext: DSLContext) {
private val users = Tables.USERS
// Проверка на существование пользователя в базе. Нужно 1 раз для команды /start
fun isUserExist(chatId: Long): Boolean {
return dslContext.selectCount().from(users).where(users.ID.eq(chatId)).fetchOneInto(Int::class.java) == 1
}
// Созадние пользователя для команды /start
fun createUser(chatId: Long): Users {
val record = dslContext.newRecord(users, Users().apply {
id = chatId
stepCode = StepCode.START.toString()
})
record.store()
return record.into(Users::class.java)
}
// получить информацию о пользователе
fun getUser(chatId: Long) =
dslContext.selectFrom(users).where(users.ID.eq(chatId)).fetchOneInto(Users::class.java)
// Обновление этапа в боте
fun updateUserStep(chatId: Long, stepCode: StepCode): Users =
dslContext.update(users)
.set(users.STEP_CODE, stepCode.toString())
.where(users.ID.eq(chatId)).returning().fetchOne()!!.into(Users::class.java)
// Обновление текста. Этот метод срабатывает у команды /user_info
fun updateText(chatId: Long, text: String) {
dslContext.update(users)
.set(users.TEXT, text)
.where(users.ID.eq(chatId)).execute()
}
// Обновление данных пришедшие от кнопок в команде /button
fun updateAccept(chatId: Long, accept: String) {
dslContext.update(users)
.set(users.ACCEPT, accept)
.where(users.ID.eq(chatId)).execute()
}
}
```
Здесь уже можно и нужно сформировать POJO объекты при помощи таски gradle *flywayMigrate* *generateJooq*
Создать новую команду тоже для нас не проблема. В данной статье опишем только одну команду, всё остальное есть в исходниках. Делается по аналогии
**StartCommand.kt**
```
package ru.template.telegram.bot.kotlin.template.command
import org.springframework.context.ApplicationEventPublisher
import org.springframework.stereotype.Component
import org.telegram.telegrambots.extensions.bots.commandbot.commands.BotCommand
import org.telegram.telegrambots.meta.api.objects.Chat
import org.telegram.telegrambots.meta.api.objects.User
import org.telegram.telegrambots.meta.bots.AbsSender
import ru.template.telegram.bot.kotlin.template.enums.CommandCode
import ru.template.telegram.bot.kotlin.template.enums.StepCode
import ru.template.telegram.bot.kotlin.template.event.TelegramStepMessageEvent
import ru.template.telegram.bot.kotlin.template.repository.UsersRepository
@Component
class StartCommand(
private val usersRepository: UsersRepository,
private val applicationEventPublisher: ApplicationEventPublisher // Интерфейс который отправляет событие
) : BotCommand(CommandCode.START.command, CommandCode.START.desc) {
companion object {
private val START_CODE = StepCode.START
}
override fun execute(absSender: AbsSender, user: User, chat: Chat, arguments: Array) {
val chatId = chat.id // chatId передает телеграм
// если пользователя в базе не существует, то создаём его, иначе обновляешь этап
if (usersRepository.isUserExist(chatId)) {
usersRepository.updateUserStep(chatId, START\_CODE)
} else usersRepository.createUser(chatId)
applicationEventPublisher.publishEvent(
TelegramStepMessageEvent(chatId = chatId, stepCode = START\_CODE)
)
}
}
```
Как мы видим из кода, начинаем формировать событие *TelegramStepMessageEvent*.
**BotCommand** — это интерфейс описания команд телеграм АПИ
Класс TelegramStepMessageEvent лежит в пакете event
**TelegramStepMessageEvent.kt**
```
package ru.template.telegram.bot.kotlin.template.event
import ru.template.telegram.bot.kotlin.template.enums.StepCode
class TelegramStepMessageEvent(
// chatId из бота
val chatId: Long,
// Этап или шаг в боте (стартовый, выбор кнопки, сообщение пришедшее после кнопки и тд и тп). Не путать с командами, так как в команде может быть несколько этапов
val stepCode: StepCode
)
```
StepCode — enum, который носит информацию о типе сообщения, о шаге и прочую системную информацию
**StepCode.kt**
```
package ru.template.telegram.bot.kotlin.template.enums
// Тип (Простой текст или текст с кнопками) и botPause - остановить переход на новый этап для принятия решения пользователем
enum class StepCode(val type: StepType, val botPause: Boolean) {
START(StepType.SIMPLE_TEXT, false),
USER_INFO(StepType.SIMPLE_TEXT, true),
BUTTON_REQUEST(StepType.INLINE_KEYBOARD_MARKUP, true),
BUTTON_RESPONSE(StepType.SIMPLE_TEXT, true)
}
enum class StepType {
// Простое сообщение
SIMPLE_TEXT,
// Сообщение с кнопкой
INLINE_KEYBOARD_MARKUP
}
```
Остановимся немного на енуме **StepCode** и **StepType**. Когда мы выбираем ту или иную команду формируется сообщение, которое отправляется пользователю. Иногда нужно отправить несколько сообщений подряд. Например *START* и затем *USER\_INFO*. botPause нужен в первую очередь, чтобы проинформировать пользователя о необходимости принятия решений. Некоторые сообщения приходят с кнопками. Для этого и нужен енум **StepType**
Непосредственная реализация приёма сообщений будет представлена в компоненте **ApplicationListener**
**ApplicationListener.kt**
```
package ru.template.telegram.bot.kotlin.template.listener
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Lazy
import org.springframework.context.event.EventListener
import org.springframework.stereotype.Component
import ru.template.telegram.bot.kotlin.template.enums.ExecuteStatus
import ru.template.telegram.bot.kotlin.template.event.TelegramReceivedCallbackEvent
import ru.template.telegram.bot.kotlin.template.event.TelegramReceivedMessageEvent
import ru.template.telegram.bot.kotlin.template.event.TelegramStepMessageEvent
import ru.template.telegram.bot.kotlin.template.repository.UsersRepository
import ru.template.telegram.bot.kotlin.template.service.MessageService
import ru.template.telegram.bot.kotlin.template.strategy.LogicContext
import ru.template.telegram.bot.kotlin.template.strategy.NextStepContext
@Component
class ApplicationListener(
private val logicContext: LogicContext, // Основная бизнес логика
private val nextStepContext: NextStepContext, // Выбор следующего этапа
private val usersRepository: UsersRepository, // Слой СУБД
private val messageService: MessageService // Сервис, который формирует объект для отрпавки сообщения в бота
) {
// Слушаем событие TelegramReceivedMessageEvent
inner class Message {
@EventListener
fun onApplicationEvent(event: TelegramReceivedMessageEvent) {
logicContext.execute(chatId = event.chatId, message = event.message)
val nextStepCode = nextStepContext.next(event.chatId, event.stepCode)
if (nextStepCode != null) {
stepMessageBean().onApplicationEvent(
TelegramStepMessageEvent(
chatId = event.chatId,
stepCode = nextStepCode
)
)
}
}
}
// Слушаем событие TelegramStepMessageEvent
inner class StepMessage {
@EventListener
fun onApplicationEvent(event: TelegramStepMessageEvent) {
// Обновляем шаг
usersRepository.updateUserStep(event.chatId, event.stepCode)
// Отправляем сообщение в бота (и формируем)
messageService.sendMessageToBot(event.chatId, event.stepCode)
}
}
// Слшуаем событие TelegramReceivedCallbackEvent
inner class CallbackMessage {
@EventListener
fun onApplicationEvent(event: TelegramReceivedCallbackEvent) {
val nextStepCode = when (logicContext.execute(event.chatId, event.callback)) {
ExecuteStatus.FINAL -> { // Если бизнес процесс одобрил переход на новый этап
nextStepContext.next(event.chatId, event.stepCode)
}
ExecuteStatus.NOTHING -> throw IllegalStateException("Не поддерживается")
}
if (nextStepCode != null) {
// редирект на событие TelegramStepMessageEvent
stepMessageBean().onApplicationEvent(
TelegramStepMessageEvent(
chatId = event.chatId,
stepCode = nextStepCode
)
)
}
}
}
@Bean
@Lazy
// Бин поступления сообщения от пользователя
fun messageBean(): Message = Message()
@Bean
@Lazy
// Бин отправки сообщения ботом
fun stepMessageBean(): StepMessage = StepMessage()
@Bean
@Lazy
// Бин, который срабатывает в момент клика по кнопке
fun callbackMessageBean(): CallbackMessage = CallbackMessage()
}
```
MessageService — сервис, который формирует объект Телеграм АПИ сообщения и делает запрос на отправку в бота
**MessageService.kt**
```
package ru.template.telegram.bot.kotlin.template.service
import org.springframework.context.ApplicationEventPublisher
import org.springframework.stereotype.Service
import org.telegram.telegrambots.meta.api.methods.BotApiMethod
import org.telegram.telegrambots.meta.api.methods.ParseMode
import org.telegram.telegrambots.meta.api.methods.send.SendMessage
import org.telegram.telegrambots.meta.api.objects.Message
import org.telegram.telegrambots.meta.api.objects.replykeyboard.InlineKeyboardMarkup
import org.telegram.telegrambots.meta.api.objects.replykeyboard.ReplyKeyboardRemove
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton
import ru.template.telegram.bot.kotlin.template.api.TelegramSender
import ru.template.telegram.bot.kotlin.template.dto.MarkupDataDto
import ru.template.telegram.bot.kotlin.template.dto.markup.DataModel
import ru.template.telegram.bot.kotlin.template.enums.StepCode
import ru.template.telegram.bot.kotlin.template.enums.StepType.*
import ru.template.telegram.bot.kotlin.template.event.TelegramStepMessageEvent
import ru.template.telegram.bot.kotlin.template.strategy.MarkupContext
import ru.template.telegram.bot.kotlin.template.strategy.MessageContext
import ru.template.telegram.bot.kotlin.template.strategy.NextStepContext
@Service
class MessageService(
private val telegramSender: TelegramSender, // отправщик сообщения
private val messageContext: MessageContext, // Формирование текстовок сообщения
private val applicationEventPublisher: ApplicationEventPublisher,
private val markupContext: MarkupContext, // Формирование текстовок с кнопками
private val nextStepContext: NextStepContext // Выбор следующего этапа
) {
fun sendMessageToBot(
chatId: Long,
stepCode: StepCode
) {
when (stepCode.type) {
// Простое сообщение
SIMPLE\_TEXT -> telegramSender.execute(simpleTextMessage(chatId))
// Сообщение с кнопками
INLINE\_KEYBOARD\_MARKUP -> telegramSender.sendInlineKeyboardMarkup(chatId)
}
if (!stepCode.botPause) { // если нет паузы, то формируем следующее сообщение
applicationEventPublisher.publishEvent(
TelegramStepMessageEvent(
chatId = chatId,
stepCode = nextStepContext.next(chatId, stepCode)!!
)
)
}
}
// SendMessage - объект телеграм АПИ для отправки сообщения
private fun simpleTextMessage(chatId: Long): SendMessage {
val sendMessage = SendMessage()
sendMessage.chatId = chatId.toString()
sendMessage.text = messageContext.getMessage(chatId)
sendMessage.enableHtml(true)
return sendMessage
}
// Отправляем в бота сообщение с кнопками
private fun TelegramSender.sendInlineKeyboardMarkup(chatId: Long) {
val inlineKeyboardMarkup: InlineKeyboardMarkup
val messageText: String
val inlineKeyboardMarkupDto = markupContext.getInlineKeyboardMarkupDto(chatId)!!
messageText = inlineKeyboardMarkupDto.message
inlineKeyboardMarkup = inlineKeyboardMarkupDto.inlineButtons.getInlineKeyboardMarkup()
this.execute(sendMessageWithMarkup(chatId, messageText, inlineKeyboardMarkup))
}
private fun sendMessageWithMarkup(
chatId: Long, messageText: String, inlineKeyboardMarkup: InlineKeyboardMarkup
): BotApiMethod {
val sendMessage = SendMessage()
sendMessage.chatId = chatId.toString()
sendMessage.text = messageText
sendMessage.replyMarkup = inlineKeyboardMarkup
sendMessage.parseMode = ParseMode.HTML
return sendMessage
}
// Формируем модель кнопок
private fun List.getInlineKeyboardMarkup(): InlineKeyboardMarkup {
val inlineKeyboardMarkup = InlineKeyboardMarkup()
val inlineKeyboardButtonsInner: MutableList = mutableListOf()
val inlineKeyboardButtons: MutableList> = mutableListOf()
this.sortedBy { it.rowPos }.forEach { markupDataDto ->
val button = InlineKeyboardButton()
.also { it.text = markupDataDto.text }
.also { it.callbackData = markupDataDto.text }
inlineKeyboardButtonsInner.add(button)
}
inlineKeyboardButtons.add(inlineKeyboardButtonsInner)
inlineKeyboardMarkup.keyboard = inlineKeyboardButtons
return inlineKeyboardMarkup
}
}
```
Сам отправщик сообщений выглядит проще. Все механизмы в библиотеке, но для ее реализации нужно создать класс
**TelegramSender.kt**
```
package ru.template.telegram.bot.kotlin.template.api
import javax.annotation.PostConstruct
import org.springframework.stereotype.Component
import org.telegram.telegrambots.extensions.bots.commandbot.TelegramLongPollingCommandBot
import org.telegram.telegrambots.extensions.bots.commandbot.commands.IBotCommand
import org.telegram.telegrambots.meta.api.methods.commands.SetMyCommands
import org.telegram.telegrambots.meta.api.methods.send.SendMessage
import org.telegram.telegrambots.meta.api.objects.Update
import org.telegram.telegrambots.meta.api.objects.commands.BotCommand
import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScopeChat
import ru.template.telegram.bot.kotlin.template.properties.BotProperty
import ru.template.telegram.bot.kotlin.template.service.ReceiverService
@Component
class TelegramSender(
private val botProperty: BotProperty,
private val botCommands: List,
private val receiverService: ReceiverService
) : TelegramLongPollingCommandBot() {
@PostConstruct
// Регистрация команд в системе
fun initCommands() {
botCommands.forEach {
register(it)
}
registerDefaultAction { absSender, message ->
val commandUnknownMessage = SendMessage()
commandUnknownMessage.chatId = message.chatId.toString()
commandUnknownMessage.text = "Command '" + message.text.toString() + "' unknown"
absSender.execute(commandUnknownMessage)
}
}
// токен. Формируем в @BotFather
override fun getBotToken() = botProperty.token
// username. Формируем в @BotFather
override fun getBotUsername() = botProperty.username
// событие, которое пришли от пользователя (кромер команд)
override fun processNonCommandUpdate(update: Update) {
receiverService.execute(update)
}
}
```
**TelegramLongPollingCommandBot** — это базовый класс Телеграм АПИ, который отправляет и принимает сообщения. Хочу отметить, что в примере есть проперти, который нужно задать через [BotFather](https://habr.com/ru/users/botfather/)
Осталось дело за малым. Сервис приёма сообщений **ReceiverService** непосредственно принимает текст, введенный пользователем или мета информацию по кнопке.
**ReceiverService.kt**
```
package ru.template.telegram.bot.kotlin.template.service
import org.springframework.context.ApplicationEventPublisher
import org.springframework.stereotype.Service
import org.telegram.telegrambots.meta.api.objects.CallbackQuery
import org.telegram.telegrambots.meta.api.objects.Message
import org.telegram.telegrambots.meta.api.objects.Update
import ru.template.telegram.bot.kotlin.template.enums.StepCode
import ru.template.telegram.bot.kotlin.template.event.TelegramReceivedCallbackEvent
import ru.template.telegram.bot.kotlin.template.event.TelegramReceivedMessageEvent
import ru.template.telegram.bot.kotlin.template.repository.UsersRepository
@Service
class ReceiverService(
private val applicationEventPublisher: ApplicationEventPublisher,
private val usersRepository: UsersRepository
) {
// выходной метод сервиса
fun execute(update: Update) {
if (update.hasCallbackQuery()) { // Выполнить, если это действие по кнопке
callbackExecute(update.callbackQuery)
} else if (update.hasMessage()) { // Выполнить, если это сообщение пользователя
messageExecute(update.message)
} else {
throw IllegalStateException("Not yet supported")
}
}
private fun messageExecute(message: Message) {
val chatId = message.chatId
val stepCode = usersRepository.getUser(chatId)!!.stepCode // Выбор текущего шага
applicationEventPublisher.publishEvent( // Формируем событие TelegramReceivedMessageEvent
TelegramReceivedMessageEvent(
chatId = chatId,
stepCode = StepCode.valueOf(stepCode),
message = message
)
)
}
private fun callbackExecute(callback: CallbackQuery) {
val chatId = callback.from.id
val stepCode = usersRepository.getUser(chatId)!!.stepCode // Выбор текущего шага
applicationEventPublisher.publishEvent( // Формируем событие TelegramReceivedCallbackEvent
TelegramReceivedCallbackEvent(chatId = chatId, stepCode = StepCode.valueOf(stepCode), callback = callback)
)
}
}
```
Здесь всё просто, если Кнопка, то событие для кнопки, если текст, то событие для обработки текста.
#### Бизнес процессы
Так как эта статья отражает лишь архитектуру бота, то описывать реализацию бизнес процессов нет смысла. Код с примером можно найти в гитхабе по ссылке выше.
Отмечу только тот факт, что для описания самих бизнес процессов необходимо для каждого этапа реализовать имплементацию интерфейсов
### Заключение
Итого, что мы имеем? Описанный код продемонстрировал "поляну" для того, чтобы разработчики накидали классы, в которых будет реализована основная бизнес логика (добавление данных в базу, действие по кнопке). Также можно реализовать бизнес логику на роутинг следующего шага. Конечно, данная статья не поможет реализовать достаточно сложного бота. Однако, поработав с аналитиком и архитектором, можно с лёгкостью реализовать новые слои в пакете **strategy**. | https://habr.com/ru/post/588474/ | null | ru | null |
# How to push parameters into methods without parameters in safe code
Hello. This time we continue to laugh at the normal method call. I propose to get acquainted with the method call with parameters without passing parameters. We will also try to convert the reference type to a number — its address, without using pointers and *unsafe code*.
### Disclaimer
Before proceeding with the story, I strongly recommend that you read the previous [post about StructLayout](https://habr.com/en/post/446478/). Here I will use some features, that were described there.
Also I would like to warn that this article does not contain material that should be used in real projects.
### Some initial information
Before we start practicing, let's remember how the C# code is converted into assembler code.
Let us examine a simple example.
```
public class Helper
{
public virtual void Foo(int param)
{
}
}
public class Program
{
public void Main()
{
Helper helper = new Helper();
var param = 5;
helper.Foo(param);
}
}
```
This code does not contain anything difficult, but the instructions generated by JiT contain several key points. I propose to look only on a small fragment of the generated code. in my examples I will use assembler code for 32 bit machines.
```
1: mov dword [ebp-0x8], 0x5
2: mov ecx, [ebp-0xc]
3: mov edx, [ebp-0x8]
4: mov eax, [ecx]
5: mov eax, [eax+0x28]
6: call dword [eax+0x10]
```
In this small example, you can observe fastcall — calling convention that uses registers to pass parameters (the first two parameters from left to right in the ecx and edx registers), and the remaining parameters are passed through the stack from right to left. The first (implicit) parameter is the address of the instance of the class on which the method is called (for non-static methods).
In our case first parameter is the address of the instance, second one is our **int** value.
So int the **first** line we see the local variable 5, there is nothing interesting here.
In the **second** line, we copy the address of the Helper instance into the ecx register. This is the address of the pointer to method table.
In the **third** line there is copying of local variable 5 into the edx register
In the **fourth** line we can see copying of the method table address into the eax register
**Fifth** line contains loading of the value from memory at the address 40 bytes larger than the address of the method table: the start of the methods addresses in the method table. (The method table contains various information that is stored before. For example address of the base class method table, the EEClass address, various flags, including the garbage collector flag, and so on). Thus, the address of the first method from the method table is now stored in the eax register.
*Note: In .NET Core the layout of the method table was changed. Now there is field (at 32/64 bit offset for 32 and 64 bit systems respectively) that contains the address of the start of method list.*
In the **sixth** line, the method is called at offset 16 from the beginning, that is, the fifth one in the method table. Why is our only method is fifth? I remind you that **object** has 4 virtual methods (*ToString(), Equals(), GetHashCode() and Finalize()*), which all classes will have, respectively.
### Goto Practice;
Practive:
It's time to start a small demonstration. I suggest such small blank (very similar to the blank from the previous article).
```
[StructLayout(LayoutKind.Explicit)]
public class CustomStructWithLayout
{
[FieldOffset(0)]
public Test1 Test1;
[FieldOffset(0)]
public Test2 Test2;
}
public class Test1
{
public virtual int Useless(int param)
{
Console.WriteLine(param);
return param;
}
}
public class Test2
{
public virtual int Useless()
{
return 888;
}
}
public class Stub
{
public void Foo(int stub) { }
}
```
And let's use that stuff in such way:
```
class Program
{
static void Main(string[] args)
{
Test2 fake = new CustomStructWithLayout
{
Test2 = new Test2(),
Test1 = new Test1()
}.Test2;
Stub bar = new Stub();
int param = 55555;
bar.Foo(param);
fake.Useless();
Console.Read();
}
}
```
As you might guess, from the experience of the previous article, the *Useless(int j)* method of type **Test1** will be called.
But what will be displayed? The attentive reader, I believe, has already answered this question. «55555» is displayed on the console.
But let's still look at the generated code fragments.
```
mov ecx, [ebp-0x20]
mov edx, [ebp-0x10]
cmp [ecx], ecx
call Stub.Foo(Int32)
mov ecx, [ebp-0x1c]
mov eax, [ecx]
mov eax, [eax+0x28]
call dword [eax+0x10]
```
I think you recognize the virtual method call pattern, it starts after *Stub.Foo(Int32) call*. As we can see, as expected ecx is filled with the address of the instance on which the method is called. But since the compiler think that we call a method of type Test2, which has no parameters, nothing is written to edx. However, we have another method call before. And there we have used edx to pass parameter. And of course we don't have instructions, that clear edx. So, as you can see in console output, previous edx value was used.
There is another interesting nuance. I specifically used the meaningful type. I suggest trying to replace the parameter type of the Foo method of the Stub type with any reference type, for example, a string. But the parameter type of the method *Useless()* does not change. Below you can see the result on my machine with some clarifying information: WinDBG and Calculator :)
[](https://habrastorage.org/webt/lj/pt/5i/ljpt5isxjzejz0_kxhu0yyovyhw.jpeg)
*Clickable image*
The output window displays the address of the reference type in decimal notation.
### Total
We refreshed the knowledge of calling methods using the fastcall convention and immediately used the wonderful edx register to pass a parameter in 2 methods at a time. We also spat on all types and with the knowledge that everything is only bytes easily obtained the address of the object without using pointers and unsafe code. Further I plan to use the received address for even more inapplicable purposes!
Thanks for attention!
P.S. C# code can be found [here](https://gist.github.com/ZloyChert/c1b013b35cc3c76c45f2b8b6f39f9196) | https://habr.com/ru/post/447254/ | null | en | null |
# Информационные сообщения в 1С. Как это можно сделать
Здравствуйте.
Сегодня речь пойдет о реализации подсистемы выдачи информационных сообщений пользователю. Стандартный способ проинформировать о чем-либо пользователя – это использование процедуры «**Сообщить**». Однако в некоторых случаях, хочется создать отдельный список, который не будет замусоривать своим выводом основной список сообщений платформы. Также желательно иметь возможность выделять цветом различные сообщения (в зависимости от их типа, например). В общем, расскажу, как это получилось сделать у меня. Приведенное в статье решение можно встроить в свою программу без какой-либо адаптации.
Предыстория.
============
В свое время, работая с системой контроля версий [Perforce](https://ru.wikipedia.org/wiki/Perforce), а именно с ее графическими клиентами, я обратил внимание на удобный элемент интерфейса – многострочное поле вывода сообщений внизу главного окна программы. После того, как пользователь выполнял какие-то обращения к серверу системы, в это поле добавлялись текстовые сообщения, описывающие процесс взаимодействия клиента с сервером (какие конкретно действия выполнялись, и результат их выполнения). Не знаю, почему именно Perforce произвел на меня такое впечатление, хотя абсолютно ту же систему я наблюдал до и после в различных графических IDE (Delphi, C++ и т.д.) – окно вывода сообщений той консольной программы (компилятор или клиент системы контроля версий), в качестве оболочки которой выступает графическая программа. Но впрочем, статья вовсе не про Perforce, просто я считаю удобным способ многострочного вывода сообщений в процессе выполнения какой-то длительной работы. Получить большой список сообщений гораздо лучше (информативнее), чем одиночный MessageBox в самом конце этой работы. Подобный подход мы, кстати, видим и в антивирусных программах.
На создание собственной подсистемы сообщений меня натолкнула необходимость реализации программы, которая выполняет относительно длительный процесс обработки данных (т.е. пользователь нажал кнопку «*Выполнить*», а потом может, условно говоря, несколько минут ждать, пока процесс выполняется). Подобные программы (обработки) есть и в типовых конфигурациях 1С (в основном это различные выгрузки-загрузки). Стандартное окно сообщений платформы (то, куда выводится информация процедурой «**Сообщить**») меня не устраивало. Я хотел, чтобы сообщения, связанные с моей обработкой были сгруппированы, и не смешивались ни с какими другими сообщениями. Также я хотел, чтобы список сообщений можно было как-то сохранять на всякий случай (в текстовый файл, как это сделано в антивирусах). Ну и главное, я планировал сделать сообщения разного типа (информационные, предупреждения, сообщения об ошибках). Ну и соответственно раскрашивать их в различные цвета.
В рассматриваемом примере таблица вывода сообщения (элемент интерфейса **ТабличноеПоле**) выглядит примерно так:
Описание реализации.
====================
В общем, опишу здесь то, что получилось. Для реализации буду опять использовать свою технологию «ООП в 1С» (метод подробно описан [здесь](https://habrahabr.ru/post/271731/)). Соответственно будет создан «класс»: «*СообщенияПрограммы*».
В дальнейшем при объяснениях будем считать, что делаем внешнюю обработку.
Нам понадобятся иконки для отображения статусов сообщений. Загрузим из соответствующих BMP-файлов (прилагаются к данной статье) в ресурсы (макеты типа «Двоичные данные»)
| Изображение | Название исходного файла | Название макета |
| --- | --- | --- |
| | statok.bmp | КартинкаСообщениеСтатусОК |
| | statwarning.bmp | КартинкаСообщениеСтатусПредупреждение |
| | staterror.bmp | КартинкаСообщениеСтатусОшибка |
Затем нужно будет как-то эти картинки загрузить для использования – превратим их в ресурсы.
Определим в главном модуле глобальную переменную «КоллекцияКартинок» в виде структуры из объектов стандартного класса «Картинка». Напишем подпрограмму «СформироватьКоллекциюКартинок», которая будет инициализировать коллецию. Будем вызывать эту подпрограмму в инициализирующей секции модуля.
Также наши сообщения будут иметь некоторые числовые типы – уровни. Номер уровня будет влиять на количество отступов из пробельных символов слева при выводе сообщения в интерфейс или файл (как бы наглядно показываем уровень вложенности сообщений друг в друга).
| Название | Описание | Числовое значение |
| --- | --- | --- |
| ТИПСООБЩ\_НЕОПРЕД | Неопределенное значение | 0 |
| ТИПСООБЩ\_УРОВЕНЬ1 | Уровень вложенности 1 | 1 |
| ТИПСООБЩ\_УРОВЕНЬ2 | Уровень вложенности 2 | 2 |
| ТИПСООБЩ\_УРОВЕНЬ3 | Уровень вложенности 3 | 3 |
У каждого сообщения есть определенный статус, показывающий, чем именно является сообщение.
| Название | Описание | Числовое значение |
| --- | --- | --- |
| СТАТСООБЩ\_НЕОПРЕД | Неопределенное значение | 0 |
| СТАТСООБЩ\_ОК | Уровень вложенности 1 | 1 |
| СТАТСООБЩ\_ПРЕДУПР | Уровень вложенности 2 | 2 |
| СТАТСООБЩ\_ОШИБКА | Уровень вложенности 3 | 3 |
Представим типы и статусы в виде числовых констант, как это делается в С/С++ (**#define**) или Pascal (**const**). В 1С будем имитировать константы вставкой их в глобальную переменную-структуру (ключ элемента структуры – это символьное имя константы, а значение элемента структуры – это численное значение константы).
```
Функция ИнициализацияПрочихКонстант()
Проч = Новый Структура;
// Типы сообщений
Проч.Вставить("ТИПСООБЩ_НЕОПРЕД", 0); // Тип неопределен
Проч.Вставить("ТИПСООБЩ_УРОВЕНЬ1", 1); // Сообщение уровня 1
Проч.Вставить("ТИПСООБЩ_УРОВЕНЬ2", 2); // Сообщение уровня 2
Проч.Вставить("ТИПСООБЩ_УРОВЕНЬ3", 3); // Сообщение уровня 3
// Статусы сообщений
Проч.Вставить("СТАТСООБЩ_НЕОПРЕД", 0); // Статус неопределен
Проч.Вставить("СТАТСООБЩ_ОК", 1); // Статус "ОК"
Проч.Вставить("СТАТСООБЩ_ПРЕДУПР", 2); // Статус "Предупреждение"
Проч.Вставить("СТАТСООБЩ_ОШИБКА", 3); // Статус "Ошибка"
Возврат Проч
КонецФункции
```
Еще нам нужно будет получать текущее значение времени в миллисекундах. Используем для этого машину JavaScript в виде глобальной переменной COM-объекта.
Вот что получилось в главном модуле:
**Исходный текст**
```
////////////////////////////////////////////////////////////////////////////////
// ПРОЧИЕ КОНСТАНТЫ
Перем Проч Экспорт; // Структура с константами
Перем КоллекцияКартинок Экспорт; // Набор иконок интерфейса
////////////////////////////////////////////////////////////////////////////////
// ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
Перем JavaScript; // Машина для работы с JavaScript
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// П О Д П Р О Г Р А М М Ы И Н И Ц И А Л И З А Ц И И К О Н С Т А Н Т
//
///////////////////////////////////////////////////////////////////////////////////////////////////
// Инициализирует набор констант общего назначения
//
// Параметры:
// НЕТ.
//
// Возврат:
// Структура с полями - константами общего назначения
//
Функция ИнициализацияПрочихКонстант()
Проч = Новый Структура;
// Типы сообщений
Проч.Вставить("ТИПСООБЩ_НЕОПРЕД", 0); // Тип неопределен
Проч.Вставить("ТИПСООБЩ_УРОВЕНЬ1", 1); // Сообщение уровня 1
Проч.Вставить("ТИПСООБЩ_УРОВЕНЬ2", 2); // Сообщение уровня 2
Проч.Вставить("ТИПСООБЩ_УРОВЕНЬ3", 3); // Сообщение уровня 3
// Статусы сообщений
Проч.Вставить("СТАТСООБЩ_НЕОПРЕД", 0); // Статус неопределен
Проч.Вставить("СТАТСООБЩ_ОК", 1); // Статус "ОК"
Проч.Вставить("СТАТСООБЩ_ПРЕДУПР", 2); // Статус "Предупреждение"
Проч.Вставить("СТАТСООБЩ_ОШИБКА", 3); // Статус "Ошибка"
Возврат Проч
КонецФункции
// Формирует набор картинок, на основании изображений, сохраненных в двоичных
// макетах обработки.
//
// Параметры:
// НЕТ.
//
// Возврат:
// Структура с полями - объектами типа Картинка с загруженными картинками
//
Функция СформироватьКоллекциюКартинок()
КоллекцияКартинок = Новый Структура;
КоллекцияКартинок.Вставить("СообщениеСтатусОК", Новый Картинка(ПолучитьМакет("КартинкаСообщениеСтатусОК")));
КоллекцияКартинок.Вставить("СообщениеСтатусПредупреждение", Новый Картинка(ПолучитьМакет("КартинкаСообщениеСтатусПредупреждение")));
КоллекцияКартинок.Вставить("СообщениеСтатусОшибка", Новый Картинка(ПолучитьМакет("КартинкаСообщениеСтатусОшибка")));
Возврат КоллекцияКартинок
КонецФункции
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// П О Д П Р О Г Р А М М Ы И Н И Ц И А Л И З А Ц И И Г Л О Б А Л Ь Н Ы Х П Е Р Е М Е Н Н Ы Х
//
///////////////////////////////////////////////////////////////////////////////////////////////////
// Создает объект JavaScript и возвращает его в качестве значения
// Формирует набор картинок, на основании изображений, сохраненных в двоичных
// макетах обработки.
//
// Параметры:
// НЕТ.
//
// Возврат:
// Ссылка на машину JavaScript или Неопределено, если машина не создана
//
Функция СоздатьОбъектJavaScript()
Рез = Неопределено;
Попытка
Рез = Новый COMОбъект("MSScriptControl.ScriptControl");
Рез.Language = "javascript";
Исключение
КонецПопытки;
Возврат Рез
КонецФункции
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// П О Д П Р О Г Р А М М Ы О Б Щ Е Г О Н А З Н А Ч Е Н И Я
//
///////////////////////////////////////////////////////////////////////////////////////////////////
// Расширяет строку до заданной ширины пробелами, добавляя их слева
//
// Параметры:
// Стр - исходная строка
// Ширина - кол-во символов до которого нужно расширить строку
// Возврат:
// Полученная строка
//
Функция РасширСтрЛев(Стр, Ширина)
Рез = Стр;
Инд = Ширина - СтрДлина(Рез);
Пока Инд > 0 Цикл
Рез = " " + Рез;
Инд = Инд - 1
КонецЦикла;
Возврат Рез
КонецФункции
// Расширяет строку до заданной ширины пробелами, добавляя их справа
//
// Параметры:
// Стр - исходная строка
// Ширина - кол-во символов до которого нужно расширить строку
// Возврат:
// Полученная строка
//
Функция РасширСтрПрав(Стр, Ширина)
Рез = Стр;
Инд = Ширина - СтрДлина(Рез);
Пока Инд > 0 Цикл
Рез = Рез + " ";
Инд = Инд - 1
КонецЦикла;
Возврат Рез
КонецФункции
// Возвращает текущую дату и время в миллисекундах
//
// Параметры:
// НЕТ
// Возврат:
// Числовое значение или 0, если значение определить не удалось
//
Функция ПолучитьТекущееВремяВМиллисекундах() Экспорт
Время = 0;
Если JavaScript <> Неопределено Тогда
Время = JavaScript.Eval("new Date().getTime()");
КонецЕсли;
Возврат Время;
КонецФункции
////////////////////////////////////////////////////////////////////////////////
// ОПЕРАТОРЫ ОСНОВНОЙ ПРОГРАММЫ - НАЧАЛЬНАЯ ИНИЦИАЛИЗАЦИЯ
// ИНИЦИАЛИЗАЦИЯ КОНСТАНТ
// Константы общего назначения
Проч = ИнициализацияПрочихКонстант();
// Коллекция картинок
КоллекцияКартинок = СформироватьКоллекциюКартинок();
// ИНИЦИАЛИЗАЦИЯ ГЛОБАЛЬНЫХ ПЕРЕМЕННЫХ
// Создать машину JavaScript
JavaScript = СоздатьОбъектJavaScript();
```
Набор сообщений существует в виде таблицы значений (стандартный класс **ТаблицаЗначений**) со следующими колонками:
| Название колонки | Тип данных | Назначение |
| --- | --- | --- |
| ТипСообщ | Число | Тип сообщения (уровень) – одна из констант ТИПСООБЩ\_ |
| СтатусСообщ | Число | Статус сообщения – одна из констант СТАТСООБЩ\_ |
| ТекстСообщ | Строка | Основной текст сообщения. Здесь обычно указываем, какое действие выполняется длительным процессом в данный момент. |
| КомментарийСообщ | Строка | Дополнительный текст сообщения. Здесь обычно указываем результат выполнения действия, описанного в колонке ТекстСообщ. Если действие завершилось ошибкой, то сообщение об ошибке приводим в этой же колонке |
Эта таблица значений уже может отображаться в каких-то элементах интерфейса пользователя (например в объекте класса **TaбличноеПоле**).
Набор сообщений будет реализован в виде класса, имеющего следующие методы:
| Заголовок метода | Описание |
| --- | --- |
| Функция Сообщения\_Конструктор() | Начальное создание объекта. Возвращает объект класса «Сообщения». |
| Процедура Сообщения\_УстАтриб(Сообщ, Форма, ТабПоле, ТабЗнач) | Установка атрибутов объекта. Нужно передать:
— ссылку на форму (Форма), на которой будет отображаться список сообщений;
— элемент формы типа ТабличноеПоле (ТабПоле), в который будут выводится сообщения;
— ТаблицаЗначений (ТабЗнач), в которой будет храниться собственно список сообщений. |
| Процедура Сообщения\_Инициализация(Сообщ) | Будет проинициализирована ТаблицаЗначений (ранее установленная процедурой Сообщения\_УстАтриб) |
| Процедура Сообщения\_Обновить(Сообщ) | Выполняет принудительную отрисовку списка сообщений на форме (ранее установленная процедурой Сообщения\_УстАтриб) |
| Функция Сообщения\_Добавить(Сообщ, ТипСообщ, ТекстСообщ, СтатусСообщ=Неопределено, КомментСообщ=Неопределено) | Добавляет в набор новое сообщение с соответствующими атрибутами. Возвращает идентификатор сообщения с помощью которого, к данному сообщению можно будет обращаться в дальнейшем. |
| Процедура Сообщения\_Изменить(Сообщ, ИдСообщ, ТипСообщ=Неопределено, ТекстСообщ=Неопределено, СтатусСообщ=Неопределено, КомментСообщ=Неопределено) | Изменяет атрибуты уже существующего сообщения с указанным идентификатором. |
| Процедура Сообщения\_Удалить(Сообщ, ИдСообщ) | Удалить ранее добавленное сообщение с соответствующим идентификатором. |
| Процедура Сообщения\_Очистить(Сообщ) | Удалить все сообщения набора. |
| Функция Сообщения\_ПолучитьТип(Сообщ, ИдСообщ) | Получить атрибут «Тип» для существующего сообщения с указанным идентификатором. |
| Процедура Сообщения\_УстановитьТип(Сообщ, ИдСообщ, ТипСообщ) | Установить атрибут «Тип» для существующего сообщения с указанным идентификатором. |
| Функция Сообщения\_ПолучитьСтатус(Сообщ, ИдСообщ) | Получить атрибут «Статус» для существующего сообщения с указанным идентификатором. |
| Процедура Сообщения\_УстановитьСтатус(Сообщ, ИдСообщ, СтатусСообщ) | Установить атрибут «Статус» для существующего сообщения с указанным идентификатором. |
| Функция Сообщения\_ПолучитьТекст(Сообщ, ИдСообщ) | Получить атрибут «Текст сообщения» для существующего сообщения с указанным идентификатором. |
| Процедура Сообщения\_УстановитьТекст(Сообщ, ИдСообщ, ТекстСообщ) | Установить атрибут «Текст сообщения» для существующего сообщения с указанным идентификатором. |
| Функция Сообщения\_ПолучитьКоммент(Сообщ, ИдСообщ) | Получить атрибут «Комментарий» для существующего сообщения с указанным идентификатором. |
| Процедура Сообщения\_УстановитьКоммент(Сообщ, ИдСообщ, КомментСообщ) | Установить атрибут «Комментарий» для существующего сообщения с указанным идентификатором. |
| Функция Сообщения\_ЦветТекста(ТипСообщ, СтатусСообщ) | Определить цвет текста сообщения для указанного статуса. Используется при раскраске сообщений в интерфейсе. |
| Функция Сообщения\_ЦветКомментария(ТипСообщ, СтатусСообщ) | Определить цвет дополнительного текста (комментария) сообщения для указанного статуса. Используется при раскраске сообщений в интерфейсе. |
| Функция Сообщения\_Картинка(ТипСообщ, СтатусСообщ) | Определить иконку для сообщения с указанным статусом. Используется при выводе сообщений в интерфейсе. |
| Функция Сообщения\_СохранитьВФайл(Сообщ) | Сохранить набор сообщений в текстовый файл (имя файла запрашивает у пользователя). |
Итак, полный текст главного модуля обработки:
**Текст модуля**
```
////////////////////////////////////////////////////////////////////////////////
// ПРОЧИЕ КОНСТАНТЫ
Перем Проч Экспорт; // Структура с константами
Перем КоллекцияКартинок Экспорт; // Набор иконок интерфейса
////////////////////////////////////////////////////////////////////////////////
// ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
Перем JavaScript; // Машина для работы с JavaScript
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// П О Д П Р О Г Р А М М Ы И Н И Ц И А Л И З А Ц И И К О Н С Т А Н Т
//
///////////////////////////////////////////////////////////////////////////////////////////////////
// Инициализирует набор констант общего назначения
//
// Параметры:
// НЕТ.
//
// Возврат:
// Структура с полями - константами общего назначения
//
Функция ИнициализацияПрочихКонстант()
Проч = Новый Структура;
// Типы сообщений
Проч.Вставить("ТИПСООБЩ_НЕОПРЕД", 0); // Тип неопределен
Проч.Вставить("ТИПСООБЩ_УРОВЕНЬ1", 1); // Сообщение уровня 1
Проч.Вставить("ТИПСООБЩ_УРОВЕНЬ2", 2); // Сообщение уровня 2
Проч.Вставить("ТИПСООБЩ_УРОВЕНЬ3", 3); // Сообщение уровня 3
// Статусы сообщений
Проч.Вставить("СТАТСООБЩ_НЕОПРЕД", 0); // Статус неопределен
Проч.Вставить("СТАТСООБЩ_ОК", 1); // Статус "ОК"
Проч.Вставить("СТАТСООБЩ_ПРЕДУПР", 2); // Статус "Предупреждение"
Проч.Вставить("СТАТСООБЩ_ОШИБКА", 3); // Статус "Ошибка"
Возврат Проч
КонецФункции
// Формирует набор картинок, на основании изображений, сохраненных в двоичных
// макетах обработки.
//
// Параметры:
// НЕТ.
//
// Возврат:
// Структура с полями - объектами типа Картинка с загруженными картинками
//
Функция СформироватьКоллекциюКартинок()
КоллекцияКартинок = Новый Структура;
КоллекцияКартинок.Вставить("СообщениеСтатусОК", Новый Картинка(ПолучитьМакет("КартинкаСообщениеСтатусОК")));
КоллекцияКартинок.Вставить("СообщениеСтатусПредупреждение", Новый Картинка(ПолучитьМакет("КартинкаСообщениеСтатусПредупреждение")));
КоллекцияКартинок.Вставить("СообщениеСтатусОшибка", Новый Картинка(ПолучитьМакет("КартинкаСообщениеСтатусОшибка")));
Возврат КоллекцияКартинок
КонецФункции
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// П О Д П Р О Г Р А М М Ы И Н И Ц И А Л И З А Ц И И Г Л О Б А Л Ь Н Ы Х П Е Р Е М Е Н Н Ы Х
//
///////////////////////////////////////////////////////////////////////////////////////////////////
// Создает объект JavaScript и возвращает его в качестве значения
// Формирует набор картинок, на основании изображений, сохраненных в двоичных
// макетах обработки.
//
// Параметры:
// НЕТ.
//
// Возврат:
// Ссылка на машину JavaScript или Неопределено, если машина не создана
//
Функция СоздатьОбъектJavaScript()
Рез = Неопределено;
Попытка
Рез = Новый COMОбъект("MSScriptControl.ScriptControl");
Рез.Language = "javascript";
Исключение
КонецПопытки;
Возврат Рез
КонецФункции
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// П О Д П Р О Г Р А М М Ы О Б Щ Е Г О Н А З Н А Ч Е Н И Я
//
///////////////////////////////////////////////////////////////////////////////////////////////////
// Расширяет строку до заданной ширины пробелами, добавляя их слева
//
// Параметры:
// Стр - исходная строка
// Ширина - кол-во символов до которого нужно расширить строку
// Возврат:
// Полученная строка
//
Функция РасширСтрЛев(Стр, Ширина)
Рез = Стр;
Инд = Ширина - СтрДлина(Рез);
Пока Инд > 0 Цикл
Рез = " " + Рез;
Инд = Инд - 1
КонецЦикла;
Возврат Рез
КонецФункции
// Расширяет строку до заданной ширины пробелами, добавляя их справа
//
// Параметры:
// Стр - исходная строка
// Ширина - кол-во символов до которого нужно расширить строку
// Возврат:
// Полученная строка
//
Функция РасширСтрПрав(Стр, Ширина)
Рез = Стр;
Инд = Ширина - СтрДлина(Рез);
Пока Инд > 0 Цикл
Рез = Рез + " ";
Инд = Инд - 1
КонецЦикла;
Возврат Рез
КонецФункции
// Возвращает текущую дату и время в миллисекундах
//
// Параметры:
// НЕТ
// Возврат:
// Числовое значение или 0, если значение определить не удалось
//
Функция ПолучитьТекущееВремяВМиллисекундах() Экспорт
Время = 0;
Если JavaScript <> Неопределено Тогда
Время = JavaScript.Eval("new Date().getTime()");
КонецЕсли;
Возврат Время;
КонецФункции
// Преобразует массив чисел из объекта COMSafeArray в строку символов
//
// Параметры:
// ОбъектCOMSafeArray - ссылка на массив чисел типа COMSafeArray
// (размерность массива должна быть 1)
// Возврат:
// Полученная строка или "", если операцию выполнить не удалось
//
Функция COMSafeArrayВСтроку(ОбъектCOMSafeArray) Экспорт
Рез = "";
Если ТипЗнч(ОбъектCOMSafeArray) = Тип("COMSafeArray") И
(ОбъектCOMSafeArray.GetDimensions() = 1) И
(ОбъектCOMSafeArray.GetLength(0) > 0) Тогда
Массив = ОбъектCOMSafeArray.Выгрузить();
Для Каждого КодСимв Из Массив Цикл
Если ТипЗнч(КодСимв) = Тип("Число") Тогда
// Перекодировка символа из Windows-1251 в UTF-8
Если (КодСимв >= 192) И (КодСимв <= 223) Тогда
// А - Я
КодСимв = КодСимв + 848
ИначеЕсли (КодСимв >= 224) И (КодСимв <= 239) Тогда
// а - п
КодСимв = КодСимв + 848
ИначеЕсли (КодСимв >= 240) И (КодСимв <= 255) Тогда
// р - я
КодСимв = КодСимв + 848
ИначеЕсли (КодСимв = 184) Тогда
// ё
КодСимв = 1105
ИначеЕсли (КодСимв = 168) Тогда
// Ё
КодСимв = 1025
ИначеЕсли (КодСимв = 185) Тогда
// №
КодСимв = 8470
КонецЕсли;
// Добавить символ к строке
Рез = Рез + Символ(КодСимв)
КонецЕсли
КонецЦикла
КонецЕсли;
Возврат Рез
КонецФункции
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// К Л А С С Ы О Б Щ Е Г О Н А З Н А Ч Е Н И Я
//
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Реализация класса СообщенияПрограммы (Сообщения)
// Создание полей объекта в виде структуры.
//
// Параметры:
// Нет.
// Возврат:
// Возвращает созданную структуру
//
Функция Сообщения_СоздатьОбъект() Экспорт
Сообщ = Новый Структура;
// Общие параметры сущности
Сообщ.Вставить("Форма", Неопределено); // Форма с табличным полем
Сообщ.Вставить("ТабПоле", Неопределено); // Табличное поле на форме
Сообщ.Вставить("ТабЗнач", Неопределено); // Таблица значений с сообщениями
Сообщ.Вставить("ВремяПредОбновл", Неопределено); // Время последн. обновл. формы, мс (INT)
Возврат Сообщ;
КонецФункции
// Имитирует конструктор объекта.
//
// Параметры:
// НЕТ
// Возврат:
// (Структура) - Структура с полями объекта
//
Функция Сообщения_Конструктор() Экспорт
Сообщ = Сообщения_СоздатьОбъект();
Возврат Сообщ;
КонецФункции
// Имитирует деструктор объекта - освобождает память.
//
// Параметры:
// Сообщ - ссылка на объект
//
Процедура Сообщения_Деструктор(Сообщ) Экспорт
КонецПроцедуры
// Устанавливает основные атрибуты для вывода сообщений.
//
// Параметры:
// Сообщ - ссылка на объект
// Форма - ссылка на форму, на которой расположено табличное поле списка
// ТабПоле - ссылка табличное поле списка для вывода сообщений
// ТабЗнач - таблица значений с сообщениями
//
Процедура Сообщения_УстАтриб(Сообщ, Форма, ТабПоле, ТабЗнач) Экспорт
Сообщ.Форма = Форма;
Сообщ.ТабПоле = ТабПоле;
Сообщ.ТабЗнач = ТабЗнач
КонецПроцедуры
// Инициализирует таблицу сообщений. Добавляет недостающие колонки
//
// Параметры:
// Сообщ - ссылка на объект
//
Процедура Сообщения_Инициализация(Сообщ) Экспорт
Если Сообщ.ТабЗнач <> Неопределено Тогда
КЧ = Новый КвалификаторыЧисла(10, 0);
КС = Новый КвалификаторыСтроки();
МассивТипов = Новый Массив;
МассивТипов.Добавить(Тип("Число"));
ОписаниеТиповЧисла = Новый ОписаниеТипов(МассивТипов, , ,КЧ);
МассивТипов.Очистить();
МассивТипов.Добавить(Тип("Строка"));
ОписаниеТиповСтроки = Новый ОписаниеТипов(МассивТипов, , КС);
// Колонка "ТипСообщ"
Если Сообщ.ТабЗнач.Колонки.Найти("ТипСообщ") = Неопределено Тогда
Сообщ.ТабЗнач.Колонки.Добавить("ТипСообщ", ОписаниеТиповЧисла, "Тип", 30)
КонецЕсли;
// Колонка "СтатусСообщ"
Если Сообщ.ТабЗнач.Колонки.Найти("СтатусСообщ") = Неопределено Тогда
Сообщ.ТабЗнач.Колонки.Добавить("СтатусСообщ", ОписаниеТиповЧисла, "Статус", 30)
КонецЕсли;
// Колонка "ТекстСообщ"
Если Сообщ.ТабЗнач.Колонки.Найти("ТекстСообщ") = Неопределено Тогда
Сообщ.ТабЗнач.Колонки.Добавить("ТекстСообщ", ОписаниеТиповСтроки, "Текст", 200)
КонецЕсли;
// Колонка "КомментарийСообщ"
Если Сообщ.ТабЗнач.Колонки.Найти("КомментарийСообщ") = Неопределено Тогда
Сообщ.ТабЗнач.Колонки.Добавить("КомментарийСообщ", ОписаниеТиповСтроки, "Комментарий", 200)
КонецЕсли
КонецЕсли
КонецПроцедуры
// Выполняет овновление формы, на которой размещено табличное поле
// Тем самым вызывает прорисовку сообщений.
// Выполняет это не чаще заданного интервала, мс
//
// Параметры:
// Сообщ - ссылка на объект
//
Процедура Сообщения_Обновить(Сообщ) Экспорт
Если Сообщ.Форма <> Неопределено Тогда
Интервал = 500; // Интервал обновлений (не чаще), мс
ВремяТекущОбновл = ПолучитьТекущееВремяВМиллисекундах();
Если (Сообщ.ВремяПредОбновл = Неопределено) ИЛИ
(Сообщ.ВремяПредОбновл = 0) ИЛИ
(ВремяТекущОбновл - Сообщ.ВремяПредОбновл >= Интервал) Тогда
// Выполняем обновление
Сообщ.ВремяПредОбновл = ВремяТекущОбновл;
Сообщ.Форма.Обновить()
КонецЕсли
КонецЕсли
КонецПроцедуры
// Добавляет новое сообщение в таблицу значений
//
// Параметры:
// Сообщ - ссылка на объект;
// ТипСообщ - тип добавляемого сообщения;
// ТекстСообщ - текст добавляемого сообщения;
// СтатусСообщ - статус добавляемого сообщения;
// КомментСообщ - комментарий к добавляемому сообщению
// Возврат:
// Уникальный идентификатор добавленного сообщения. Используется для дальнейшего обращения к сообщению с целью
// его редактирования. По сути представляет собой порядковый номер строки в таблице Сообщ.ТабЗнач
//
Функция Сообщения_Добавить(Сообщ, ТипСообщ, ТекстСообщ, СтатусСообщ=Неопределено, КомментСообщ=Неопределено) Экспорт
ИдСообщ = Неопределено;
Если (Сообщ.ТабЗнач <> Неопределено) И
(ТипСообщ <> Неопределено) И
(ТипСообщ >= Проч.ТИПСООБЩ_УРОВЕНЬ1) И (ТипСообщ <= Проч.ТИПСООБЩ_УРОВЕНЬ3) И
(ТекстСообщ <> Неопределено) Тогда
НоваяСтрока = Сообщ.ТабЗнач.Добавить();
НоваяСтрока.ТипСообщ = ТипСообщ;
// Преобразовать текст
Если ТипСообщ = Проч.ТИПСООБЩ_УРОВЕНЬ1 Тогда
ИначеЕсли ТипСообщ = Проч.ТИПСООБЩ_УРОВЕНЬ2 Тогда
ТекстСообщ = " " + ТекстСообщ
ИначеЕсли ТипСообщ = Проч.ТИПСООБЩ_УРОВЕНЬ3 Тогда
ТекстСообщ = " " + ТекстСообщ
КонецЕсли;
// Установить текст
НоваяСтрока.ТекстСообщ = ТекстСообщ;
Если (СтатусСообщ <> Неопределено) И
(СтатусСообщ >= Проч.СТАТСООБЩ_ОК) И (СтатусСообщ <= Проч.СТАТСООБЩ_ОШИБКА) Тогда
НоваяСтрока.СтатусСообщ = СтатусСообщ;
Иначе
НоваяСтрока.СтатусСообщ = Проч.СТАТСООБЩ_НЕОПРЕД;
КонецЕсли;
НоваяСтрока.КомментарийСообщ = КомментСообщ;
Если Сообщ.ТабПоле <> Неопределено Тогда
// Изменение текущей строки табличного поля на добавляемую,
// чтобы пользователь видел, что добавляется в список в данный момент
Сообщ.ТабПоле.ТекущаяСтрока = НоваяСтрока;
КонецЕсли;
Сообщения_Обновить(Сообщ);
ИдСообщ = Сообщ.ТабЗнач.Индекс(НоваяСтрока);
КонецЕсли;
Возврат ИдСообщ
КонецФункции
// Изменяет атрибуты сообщения с идентификатором ИдСообщ. Те, значение которых не "Неопределено"
//
// Параметры:
// Сообщ - ссылка на объект;
// ИдСообщ - идентификатор сообщения (порядковый номер строки);
// ТипСообщ - тип добавляемого сообщения;
// ТекстСообщ - текст добавляемого сообщения;
// СтатусСообщ - статус добавляемого сообщения;
// КомментСообщ - комментарий к добавляемому сообщению
//
Процедура Сообщения_Изменить(Сообщ, ИдСообщ, ТипСообщ=Неопределено, ТекстСообщ=Неопределено,
СтатусСообщ=Неопределено, КомментСообщ=Неопределено) Экспорт
Если (Сообщ.ТабЗнач <> Неопределено) И
(ИдСообщ <> Неопределено) И
(ИдСообщ >= 0) И (ИдСообщ < Сообщ.ТабЗнач.Количество()) Тогда
ФлагИзменения = Ложь; // Признак того, что что-то изменили (хоть один атрибут)
Если ТипСообщ <> Неопределено Тогда
Если (ТипСообщ <> Сообщ.ТабЗнач[ИдСообщ].ТипСообщ) И
(ТипСообщ >= Проч.ТИПСООБЩ_УРОВЕНЬ1) И (ТипСообщ <= Проч.ТИПСООБЩ_УРОВЕНЬ3) Тогда
Сообщ.ТабЗнач[ИдСообщ].ТипСообщ = ТипСообщ;
ФлагИзменения = Истина
КонецЕсли
КонецЕсли;
Если ТекстСообщ <> Неопределено Тогда
Если ТекстСообщ <> Сообщ.ТабЗнач[ИдСообщ].ТекстСообщ Тогда
// Преобразовать текст
Если Сообщ.ТабЗнач[ИдСообщ].ТипСообщ = Проч.ТИПСООБЩ_УРОВЕНЬ1 Тогда
ИначеЕсли Сообщ.ТабЗнач[ИдСообщ].ТипСообщ = Проч.ТИПСООБЩ_УРОВЕНЬ2 Тогда
ТекстСообщ = " " + ТекстСообщ
ИначеЕсли Сообщ.ТабЗнач[ИдСообщ].ТипСообщ = Проч.ТИПСООБЩ_УРОВЕНЬ3 Тогда
ТекстСообщ = " " + ТекстСообщ
КонецЕсли;
// Установить текст
Сообщ.ТабЗнач[ИдСообщ].ТекстСообщ = ТекстСообщ;
ФлагИзменения = Истина
КонецЕсли
КонецЕсли;
Если СтатусСообщ <> Неопределено Тогда
Если СтатусСообщ <> Сообщ.ТабЗнач[ИдСообщ].СтатусСообщ Тогда
Если (СтатусСообщ <> Неопределено) И
(СтатусСообщ >= Проч.СТАТСООБЩ_ОК) И (СтатусСообщ <= Проч.СТАТСООБЩ_ОШИБКА) Тогда
Сообщ.ТабЗнач[ИдСообщ].СтатусСообщ = СтатусСообщ;
Иначе
Сообщ.ТабЗнач[ИдСообщ].СтатусСообщ = Проч.СТАТСООБЩ_НЕОПРЕД;
КонецЕсли;
ФлагИзменения = Истина
КонецЕсли
КонецЕсли;
Если КомментСообщ <> Неопределено Тогда
Если КомментСообщ <> Сообщ.ТабЗнач[ИдСообщ].КомментарийСообщ Тогда
Сообщ.ТабЗнач[ИдСообщ].КомментарийСообщ = КомментСообщ;
ФлагИзменения = Истина
КонецЕсли
КонецЕсли;
Если ФлагИзменения = Истина Тогда
// Прорисовка, если реально було обновление
Сообщения_Обновить(Сообщ)
КонецЕсли
КонецЕсли
КонецПроцедуры
// Удаляет сообщение с идентификатором ИдСообщ
//
// Параметры:
// Сообщ - ссылка на объект
// ИдСообщ - идентификатор сообщения (порядковый номер строки)
//
Процедура Сообщения_Удалить(Сообщ, ИдСообщ) Экспорт
Если (Сообщ.ТабЗнач <> Неопределено) И
(ИдСообщ <> Неопределено) И
(ИдСообщ >= 0) И (ИдСообщ < Сообщ.ТабЗнач.Количество()) Тогда
Сообщ.ТабЗнач.Удалить(ИдСообщ);
Сообщения_Обновить(Сообщ)
КонецЕсли
КонецПроцедуры
// Удаляет все сообщения из таблицы
//
// Параметры:
// Сообщ - ссылка на объект
//
Процедура Сообщения_Очистить(Сообщ) Экспорт
Если (Сообщ.ТабЗнач <> Неопределено) И
(Сообщ.ТабЗнач.Количество() > 0) Тогда
Сообщ.ТабЗнач.Очистить();
Сообщения_Обновить(Сообщ)
КонецЕсли
КонецПроцедуры
// Возвращает тип сообщения с идентификатором ИдСообщ
//
// Параметры:
// Сообщ - ссылка на объект
// ИдСообщ - идентификатор сообщения (порядковый номер строки)
// Возврат:
// Тип сообщения или Неопределено, если сообщение не найдено
//
Функция Сообщения_ПолучитьТип(Сообщ, ИдСообщ) Экспорт
Рез = Неопределено;
Если (Сообщ.ТабЗнач <> Неопределено) И
(ИдСообщ <> Неопределено) И
(ИдСообщ >= 0) И (ИдСообщ < Сообщ.ТабЗнач.Количество()) Тогда
Рез = Сообщ.ТабЗнач[ИдСообщ].ТипСообщ
КонецЕсли;
Возврат Рез
КонецФункции
// Устанавливает тип сообщения с идентификатором ИдСообщ
//
// Параметры:
// Сообщ - ссылка на объект
// ИдСообщ - идентификатор сообщения (порядковый номер строки)
// ТипСообщ - тип сообщения
//
Процедура Сообщения_УстановитьТип(Сообщ, ИдСообщ, ТипСообщ) Экспорт
Если (Сообщ.ТабЗнач <> Неопределено) И
(ИдСообщ <> Неопределено) И
(ИдСообщ >= 0) И (ИдСообщ < Сообщ.ТабЗнач.Количество()) И
(ТипСообщ <> Сообщ.ТабЗнач[ИдСообщ].ТекстСообщ) И
(ТипСообщ >= Проч.ТИПСООБЩ_УРОВЕНЬ1) И (ТипСообщ <= Проч.ТИПСООБЩ_УРОВЕНЬ3) Тогда
Сообщ.ТабЗнач[ИдСообщ].ТипСообщ = ТипСообщ;
Сообщения_Обновить(Сообщ)
КонецЕсли;
КонецПроцедуры
// Возвращает статус сообщения с идентификатором ИдСообщ
//
// Параметры:
// Сообщ - ссылка на объект
// ИдСообщ - идентификатор сообщения (порядковый номер строки)
// Возврат:
// Статус сообщения или Неопределено, если сообщение не найдено
//
Функция Сообщения_ПолучитьСтатус(Сообщ, ИдСообщ) Экспорт
Рез = Неопределено;
Если (Сообщ.ТабЗнач <> Неопределено) И
(ИдСообщ <> Неопределено) И
(ИдСообщ >= 0) И (ИдСообщ < Сообщ.ТабЗнач.Количество()) Тогда
Рез = Сообщ.ТабЗнач[ИдСообщ].СтатусСообщ
КонецЕсли;
Возврат Рез
КонецФункции
// Устанавливает статус сообщения с идентификатором ИдСообщ
//
// Параметры:
// Сообщ - ссылка на объект
// ИдСообщ - идентификатор сообщения (порядковый номер строки)
// СтатусСообщ - статус сообщения
//
Процедура Сообщения_УстановитьСтатус(Сообщ, ИдСообщ, СтатусСообщ) Экспорт
Если (Сообщ.ТабЗнач <> Неопределено) И
(ИдСообщ <> Неопределено) И
(ИдСообщ >= 0) И (ИдСообщ < Сообщ.ТабЗнач.Количество()) И
(СтатусСообщ <> Сообщ.ТабЗнач[ИдСообщ].СтатусСообщ) Тогда
Если (СтатусСообщ <> Неопределено) И
(СтатусСообщ >= Проч.СТАТСООБЩ_ОК) И (СтатусСообщ <= Проч.СТАТСООБЩ_ОШИБКА) Тогда
Сообщ.ТабЗнач[ИдСообщ].СтатусСообщ = СтатусСообщ;
Иначе
Сообщ.ТабЗнач[ИдСообщ].СтатусСообщ = Проч.СТАТСООБЩ_НЕОПРЕД;
КонецЕсли;
Сообщения_Обновить(Сообщ)
КонецЕсли
КонецПроцедуры
// Возвращает текст сообщения с идентификатором ИдСообщ
//
// Параметры:
// Сообщ - ссылка на объект
// ИдСообщ - идентификатор сообщения (порядковый номер строки)
// Возврат:
// Текст сообщения или Неопределено, если сообщение не найдено
//
Функция Сообщения_ПолучитьТекст(Сообщ, ИдСообщ) Экспорт
Рез = Неопределено;
Если (Сообщ.ТабЗнач <> Неопределено) И
(ИдСообщ <> Неопределено) И
(ИдСообщ >= 0) И (ИдСообщ < Сообщ.ТабЗнач.Количество()) Тогда
Рез = Сообщ.ТабЗнач[ИдСообщ].ТекстСообщ
КонецЕсли;
Возврат Рез
КонецФункции
// Устанавливает текст сообщения с идентификатором ИдСообщ
//
// Параметры:
// Сообщ - ссылка на объект
// ИдСообщ - идентификатор сообщения (порядковый номер строки)
// ТекстСообщ - текст добавляемого сообщения;
//
Процедура Сообщения_УстановитьТекст(Сообщ, ИдСообщ, ТекстСообщ) Экспорт
Если (Сообщ.ТабЗнач <> Неопределено) И
(ИдСообщ <> Неопределено) И
(ИдСообщ >= 0) И (ИдСообщ < Сообщ.ТабЗнач.Количество()) И
(ТекстСообщ <> Неопределено) И
(ТекстСообщ <> Сообщ.ТабЗнач[ИдСообщ].ТипСообщ) Тогда
// Преобразовать текст
Если Сообщ.ТабЗнач[ИдСообщ].ТипСообщ = Проч.ТИПСООБЩ_УРОВЕНЬ1 Тогда
ИначеЕсли Сообщ.ТабЗнач[ИдСообщ].ТипСообщ = Проч.ТИПСООБЩ_УРОВЕНЬ2 Тогда
ТекстСообщ = " " + ТекстСообщ
ИначеЕсли Сообщ.ТабЗнач[ИдСообщ].ТипСообщ = Проч.ТИПСООБЩ_УРОВЕНЬ3 Тогда
ТекстСообщ = " " + ТекстСообщ
КонецЕсли;
// Установить текст
Сообщ.ТабЗнач[ИдСообщ].ТекстСообщ = ТекстСообщ;
Сообщения_Обновить(Сообщ)
КонецЕсли
КонецПроцедуры
// Возвращает комментарий к сообщению с идентификатором ИдСообщ
//
// Параметры:
// Сообщ - ссылка на объект
// ИдСообщ - идентификатор сообщения (порядковый номер строки)
// Возврат:
// Комментарий сообщения или Неопределено, если сообщение не найдено
//
Функция Сообщения_ПолучитьКоммент(Сообщ, ИдСообщ) Экспорт
Рез = Неопределено;
Если (Сообщ.ТабЗнач <> Неопределено) И
(ИдСообщ <> Неопределено) И
(ИдСообщ >= 0) И (ИдСообщ < Сообщ.ТабЗнач.Количество()) Тогда
Рез = Сообщ.ТабЗнач[ИдСообщ].КомментарийСообщ
КонецЕсли;
Возврат Рез
КонецФункции
// Устанавливает комментарий к сообщению с идентификатором ИдСообщ
//
// Параметры:
// Сообщ - ссылка на объект
// ИдСообщ - идентификатор сообщения (порядковый номер строки)
// КомментСообщ - комментарий к сообщению
//
Процедура Сообщения_УстановитьКоммент(Сообщ, ИдСообщ, КомментСообщ) Экспорт
Если (Сообщ.ТабЗнач <> Неопределено) И
(ИдСообщ <> Неопределено) И
(ИдСообщ >= 0) И (ИдСообщ < Сообщ.ТабЗнач.Количество()) И
(КомментСообщ <> Сообщ.ТабЗнач[ИдСообщ].КомментарийСообщ) Тогда
Сообщ.ТабЗнач[ИдСообщ].КомментарийСообщ = КомментСообщ;
Сообщения_Обновить(Сообщ)
КонецЕсли
КонецПроцедуры
// В зависимости от типа сообщения и статуса определяет цвет текста сообщения
//
// Параметры:
// ТипСообщ - тип сообщения
// СтатусСообщ - статус сообщения
// Возврат:
// Цвет текста сообщения
//
Функция Сообщения_ЦветТекста(ТипСообщ, СтатусСообщ) Экспорт
Рез = Неопределено;
Если ТипСообщ = Проч.ТИПСООБЩ_УРОВЕНЬ1 Тогда
Рез = WebЦвета.Черный
ИначеЕсли ТипСообщ = Проч.ТИПСООБЩ_УРОВЕНЬ2 Тогда
Рез = WebЦвета.Черный
ИначеЕсли ТипСообщ = Проч.ТИПСООБЩ_УРОВЕНЬ3 Тогда
Рез = WebЦвета.Черный
КонецЕсли;
Возврат Рез
КонецФункции
// В зависимости от типа сообщения и статуса определяет цвет текста комментария
//
// Параметры:
// ТипСообщ - тип сообщения
// СтатусСообщ - статус сообщения
// Возврат:
// Цвет текста комментария
//
Функция Сообщения_ЦветКомментария(ТипСообщ, СтатусСообщ) Экспорт
Рез = Неопределено;
Если СтатусСообщ = Проч.СТАТСООБЩ_ОК Тогда
Рез = WebЦвета.Зеленый
ИначеЕсли СтатусСообщ = Проч.СТАТСООБЩ_ПРЕДУПР Тогда
Рез = WebЦвета.Оранжевый
ИначеЕсли СтатусСообщ = Проч.СТАТСООБЩ_ОШИБКА Тогда
Рез = WebЦвета.Красный
КонецЕсли;
Возврат Рез
КонецФункции
// В зависимости от типа сообщения и статуса определяет картинку статуса сообщения
//
// Параметры:
// ТипСообщ - тип сообщения
// СтатусСообщ - статус сообщения
// Возврат:
// Картинка статуса сообщения
//
Функция Сообщения_Картинка(ТипСообщ, СтатусСообщ) Экспорт
Рез = Неопределено;
Если СтатусСообщ = Проч.СТАТСООБЩ_ОК Тогда
Рез = КоллекцияКартинок.СообщениеСтатусОК
ИначеЕсли СтатусСообщ = Проч.СТАТСООБЩ_ПРЕДУПР Тогда
Рез = КоллекцияКартинок.СообщениеСтатусПредупреждение
ИначеЕсли СтатусСообщ = Проч.СТАТСООБЩ_ОШИБКА Тогда
Рез = КоллекцияКартинок.СообщениеСтатусОшибка
КонецЕсли;
Возврат Рез
КонецФункции
// Запрашивает имя файла и сохраняет набор сообщений в текстовый файл
//
// Параметры:
// Сообщ - ссылка на объект
// Возврат:
// Истина, если сохранение выполнено и Ложь - в противном случае
//
Функция Сообщения_СохранитьВФайл(Сообщ) Экспорт
Рез = Ложь; // Еще ничего не сохранили
Если Сообщ.ТабЗнач = Неопределено Тогда
// Неверные параметры
Возврат Рез
КонецЕсли;
// Создать диалог и выбрать файл для сохранения
ДиалогВыбораФайла = Новый ДиалогВыбораФайла(РежимДиалогаВыбораФайла.Сохранение);
ДиалогВыбораФайла.Фильтр = "Текстовые файлы (*.txt)|*.txt" +
"|Все файлы (*.*)|*.*";
ДиалогВыбораФайла.Заголовок = "Сохранение сообщений";
ДиалогВыбораФайла.МножественныйВыбор = Ложь;
ДиалогВыбораФайла.ПредварительныйПросмотр = Ложь;
ДиалогВыбораФайла.Расширение = "txt";
ДиалогВыбораФайла.ИндексФильтра = 0;
ДиалогВыбораФайла.ПроверятьСуществованиеФайла = Истина;
Если ДиалогВыбораФайла.Выбрать() Тогда
// Выполнить сохранение
Попытка
// Открыть файл
ЗаписьТекста = Новый ЗаписьТекста(ДиалогВыбораФайла.ПолноеИмяФайла, КодировкаТекста.ANSI);
// Сформировать и записать в файл строки сообщений
// Выяснить максимальные длины строк в сообщениях
ДлинаТекстаМакс = 0;
ДлинаКомментМакс = 0;
Для Каждого СтрокаТЗ Из Сообщ.ТабЗнач Цикл
ДлинаТекстаТек = СтрДлина(СтрокаТЗ.ТекстСообщ);
Если ДлинаТекстаТек > ДлинаТекстаМакс Тогда
ДлинаТекстаМакс = ДлинаТекстаТек;
КонецЕсли;
ДлинаКомментТек = СтрДлина(СтрокаТЗ.КомментарийСообщ);
Если ДлинаКомментТек > ДлинаКомментМакс Тогда
ДлинаКомментМакс = ДлинаКомментТек;
КонецЕсли;
КонецЦикла;
// Выполнить запись строк
Для Каждого СтрокаТЗ Из Сообщ.ТабЗнач Цикл
Дист = " "; // Разделитель элементов строки
Стр = "";
// Записать в строку статус сообщения
Если (СтрокаТЗ.СтатусСообщ <> Неопределено) И
(СтрокаТЗ.СтатусСообщ <> Проч.СТАТСООБЩ_НЕОПРЕД) Тогда
СтатусСтр = "";
Если СтрокаТЗ.СтатусСообщ = Проч.СТАТСООБЩ_ОК Тогда
СтатусСтр = "ОК";
ИначеЕсли СтрокаТЗ.СтатусСообщ = Проч.СТАТСООБЩ_ПРЕДУПР Тогда
СтатусСтр = "ПРЕДУПРЕЖДЕНИЕ";
ИначеЕсли СтрокаТЗ.СтатусСообщ = Проч.СТАТСООБЩ_ОШИБКА Тогда
СтатусСтр = "ОШИБКА";
КонецЕсли;
Если Стр <> "" Тогда
Стр = Стр + Дист
КонецЕсли;
Стр = Стр + РасширСтрПрав(СтатусСтр, 14);
КонецЕсли;
// Записать в строку текст сообщения
Если (СтрокаТЗ.ТекстСообщ <> Неопределено) И
(СтрокаТЗ.ТекстСообщ <> "") Тогда
Если Стр <> "" Тогда
Стр = Стр + Дист
КонецЕсли;
Стр = Стр + РасширСтрПрав(СтрокаТЗ.ТекстСообщ, ДлинаТекстаМакс);
КонецЕсли;
// Записать в строку текст комментария
Если (СтрокаТЗ.КомментарийСообщ <> Неопределено) И
(СтрокаТЗ.КомментарийСообщ <> "") Тогда
Если Стр <> "" Тогда
Стр = Стр + Дист
КонецЕсли;
Стр = Стр + РасширСтрПрав(СтрокаТЗ.КомментарийСообщ, ДлинаКомментМакс);
КонецЕсли;
// Записать строку в файл
Если Стр <> "" Тогда
ЗаписьТекста.ЗаписатьСтроку(Стр)
КонецЕсли
КонецЦикла;
// Закрыть файл
ЗаписьТекста.Закрыть();
Рез = Истина // Операция выполнена успешно
Исключение
// Сообщение об ошибке
Предупреждение("Ошибка сохранения сообщений:" + Символы.ПС +
ИнформацияОбОшибке().Описание);
КонецПопытки
КонецЕсли;
Возврат Рез
КонецФункции
////////////////////////////////////////////////////////////////////////////////
// ОПЕРАТОРЫ ОСНОВНОЙ ПРОГРАММЫ - НАЧАЛЬНАЯ ИНИЦИАЛИЗАЦИЯ
// ИНИЦИАЛИЗАЦИЯ КОНСТАНТ
// Константы общего назначения
Проч = ИнициализацияПрочихКонстант();
// Коллекция картинок
КоллекцияКартинок = СформироватьКоллекциюКартинок();
// ИНИЦИАЛИЗАЦИЯ ГЛОБАЛЬНЫХ ПЕРЕМЕННЫХ
// Создать машину JavaScript
JavaScript = СоздатьОбъектJavaScript();
```
Обратите внимание на то, что при выполнении длительного процесса в цикле, интерфейс пользователя блокируется, и поэтому факт добавления или изменения сообщений не будет виден пользователю – прорисовки не будет. Для принудительного выполнения прорисовки, нужно вызвать метод **Обновить()** формы, отображающей сообщения. Но частый вызов этого метода затормозит работу, поэтому вызывать его нужно лишь иногда (хоть и с небольшим интервалом, чтобы пользователь не заметил лагов – в данной реализации интервал обновления не чаще чем 1 раз в 0,5сек). Для реализации обновления служит метод класса **Сообщения\_Обновить**.
Пример использования.
=====================
В данном примере форма, отображающая набор сообщений выглядит вот так:
Вместо кнопки «*Запустить процесс*», в реальности должно быть что-то более полезное – какой-то пользовательский интерфейс. Кнопка «*Запустить процесс*» имитирует заполнение списка сообщений, демонстрируя то, как могли бы выводиться сообщения в процессе реального выполнения какого-либо длительного действия.
В качестве реквизитов формы создана **ТаблицаЗначений** — «Сообщения». Мы ее никак не инициализируем, а просто передаем в качестве параметров соответствующим методам класса «Сообщения\_», а они уже создают нужные колонки:
```
ОбъектСообщ = Сообщения_Конструктор();
Сообщения_УстАтриб(ОбъектСообщ, ЭтаФорма, ЭлементыФормы.ТабличноеПолеСообщения, Сообщения);
Сообщения_Инициализация(ОбъектСообщ);
```
Для отображения **ТаблицыЗначений** «Сообщения», на форме размещен визуальный компонент типа «**ТабличноеПоле**» — «ТабличноеПолеСообщения». При создании колонок в ТабличномПоле, учитываем следующие колонки ТаблицыЗначений (описывались ранее):
— *ТипСообщ*;
— *СтатусСообщ*;
— *ТекстСообщ*;
— *КомментарийСообщ*.
Текст модуля главной формы обработки (отображающей сообщения):
**Текст модуля формы**
```
////////////////////////////////////////////////////////////////////////////////
// ОСНОВНОЕ ОКНО ПРОГРАММЫ
Перем ОбъектСообщ; // Объект для вывода сообщений в таблицу знач. и отобр. в табл. поле
////////////////////////////////////////////////////////////////////////////////
// ОБРАБОТЧИКИ СОБЫТИЙ ФОРМЫ
// Процедура - обработчик события "При открытии" формы. Данное событие
// возникает при открытии формы, до показа окна пользователю.
//
// Параметры:
// Нет.
//
Процедура ПриОткрытии()
// Создание объекта сообщений и инициализация таблицы сообщений
ОбъектСообщ = Сообщения_Конструктор();
Сообщения_УстАтриб(ОбъектСообщ, ЭтаФорма, ЭлементыФормы.ТабличноеПолеСообщения, Сообщения);
Сообщения_Инициализация(ОбъектСообщ);
КонецПроцедуры
// Процедура - обработчик события "При закрытии" формы. Данное событие
// возникает после закрытия формы.
// Освобождение занятых ресурсов.
//
// Параметры:
// Нет.
//
Процедура ПриЗакрытии()
// Завершить работу с объектом вывода сообщений
Сообщения_Деструктор(ОбъектСообщ)
КонецПроцедуры
// Процедура - обработчик события "Нажатие" кнопки КнопкаЗапуститьПроцесс.
// Имитирует операцию, в процессе выполнения которой выводятся сообщения.
//
// Параметры:
// Элемент - кнопка.
//
Процедура КнопкаЗапуститьПроцессНажатие(Элемент)
// Подготовка данных к началу операции
ГСЧ = Новый ГенераторСлучайныхЧисел();
ВсегоОбъектов = ГСЧ.СлучайноеЧисло(1, 100);
// Запросить согласие пользователя на выполнение операции
РезВопр = Вопрос("Выполнить обработку данных?",
РежимДиалогаВопрос.ДаНет,
,
,
"Обработка данных");
Если РезВопр = КодВозвратаДиалога.Да Тогда
// Подготовка интерфейса к запуску процесса
ErrMsg = "";
Сообщения_Очистить(ОбъектСообщ);
// Сообщение о начале операции
Сообщения_Добавить(ОбъектСообщ, Проч.ТИПСООБЩ_УРОВЕНЬ1, "*** НАЧАЛО ОБРАБОТКИ ДАННЫХ ***");
Рез = Ложь;
КолОбрОб = 0;
Попытка
// Выполнять обработку объектов
Для Инд=1 По ВсегоОбъектов Цикл
// Вывести сообщение о том, что началась обработка очередного объекта
ИдСообщУр2 = Сообщения_Добавить(ОбъектСообщ, Проч.ТИПСООБЩ_УРОВЕНЬ2, "Обработка объекта " + Формат(Инд, "ЧГ=0; ЧН=''"));
// ******************************
// Здесь собственно выполняется сама операция над текущим объектом
Если ГСЧ.СлучайноеЧисло(0, ВсегоОбъектов) > 0 Тогда
// Считаем, что операция над текущим объектом выполнена успешно
Рез = Истина
Иначе
// Считаем, что операция над текущим объектом выполнена с ошибкой
Рез = Ложь
КонецЕсли;
// ******************************
// Установить результат операции над текущим объектом в окне сообщений
СтатСообщ = Проч.СТАТСООБЩ_НЕОПРЕД;
КоммСообщ = "";
Если Рез Тогда
// Операция завершена удачно
СтатСообщ = Проч.СТАТСООБЩ_ОК;
КоммСообщ = "ОК"
Иначе
// Ошибки при выполнении операции
СтатСообщ = Проч.СТАТСООБЩ_ОШИБКА;
КоммСообщ = "ОШИБКА"
КонецЕсли;
Сообщения_Изменить(ОбъектСообщ, ИдСообщУр2, , , СтатСообщ, КоммСообщ);
// Анализируем результат текущей итерации
Если НЕ Рез Тогда
// Ошибка - прервать работу
Прервать
КонецЕсли;
КолОбрОб = КолОбрОб + 1
КонецЦикла
Исключение
// Возникло исключение - ошибка
ErrMsg = ИнформацияОбОшибке().Описание;
Рез = Ложь
КонецПопытки;
// Сообщение об окончании операции
Если Рез Тогда
// Операция завершена успешно
Сообщения_Добавить(ОбъектСообщ, Проч.ТИПСООБЩ_УРОВЕНЬ1, "*** ОБРАБОТКА ДАННЫХ ЗАВЕРШЕНА ***");
Иначе
// Операция прервана
Сообщения_Добавить(ОбъектСообщ, Проч.ТИПСООБЩ_УРОВЕНЬ1, "*** ОБРАБОТКА ДАННЫХ ПРЕРВАНА ***", Проч.СТАТСООБЩ_ОШИБКА, ErrMsg)
КонецЕсли;
// Установка интерфейса по окончанию загрузки
ТекстСообщ = "";
Если Рез Тогда
ТекстСообщ = "Обработка выполнена успешно"
Иначе
ТекстСообщ = "Обработка выполнена с ошибками"
КонецЕсли;
ТекстСообщ = ТекстСообщ + Символы.ПС;
ТекстСообщ = ТекстСообщ + "Обработано " + Формат(КолОбрОб, "ЧГ=0; ЧН=''") + " объектов.";
Предупреждение(ТекстСообщ, , "Обработка данных")
КонецЕсли
КонецПроцедуры
// Процедура - обработчик события "ПриВыводеСтроки" табличного поля
// ТабличноеПолеСообщения. Данное событие происходит при выводе каждой строки.
//
// Параметры:
// Элемент - табличное поле;
// ОформлениеСтроки - объект настройки визуального оформления строки
// ДанныеСтроки - набор данных строки табличного поля.
//
Процедура ТабличноеПолеСообщенияПриВыводеСтроки(Элемент, ОформлениеСтроки, ДанныеСтроки)
// Оформление ячейки "Статус"
ОформлениеСтроки.Ячейки.КолонкаСтатусСообщения.ОтображатьТекст = Ложь;
КартинкаСтатуса = Сообщения_Картинка(ДанныеСтроки.ТипСообщ, ДанныеСтроки.СтатусСообщ);
Если КартинкаСтатуса <> Неопределено Тогда
ОформлениеСтроки.Ячейки.КолонкаСтатусСообщения.ОтображатьКартинку = Истина;
ОформлениеСтроки.Ячейки.КолонкаСтатусСообщения.Картинка = КартинкаСтатуса;
КонецЕсли;
// Оформление ячейки "Текст"
Если (ДанныеСтроки.ТекстСообщ <> Неопределено) И
(ДанныеСтроки.ТекстСообщ <> "") Тогда
ЦветТекста = Сообщения_ЦветТекста(ДанныеСтроки.ТипСообщ, ДанныеСтроки.СтатусСообщ);
Если ЦветТекста <> Неопределено Тогда
ОформлениеСтроки.Ячейки.КолонкаТекстСообщения.ЦветТекста = ЦветТекста
КонецЕсли
КонецЕсли;
// Оформление ячейки "Комментарий"
Если (ДанныеСтроки.КомментарийСообщ <> Неопределено) И
(ДанныеСтроки.КомментарийСообщ <> "") Тогда
ЦветКомментария = Сообщения_ЦветКомментария(ДанныеСтроки.ТипСообщ, ДанныеСтроки.СтатусСообщ);
Если ЦветКомментария <> Неопределено Тогда
ОформлениеСтроки.Ячейки.КолонкаКомментарийСообщения.ЦветТекста = ЦветКомментария
КонецЕсли
КонецЕсли
КонецПроцедуры
// Процедура - обработчик события "Нажатие" кнопки КнопкаСообщенияОткрытьВНовомОкне.
// Открывает текущий список сообщений в новом окне.
//
// Параметры:
// Элемент - кнопка.
//
Процедура КнопкаСообщенияОткрытьВНовомОкнеНажатие(Элемент)
ФормаПросмотраСообщений = ЭтотОбъект.ПолучитьФорму("ФормаПросмотраСообщений", ЭтаФорма);
ФормаПросмотраСообщений.ShowMessagesDlg(ОбъектСообщ)
КонецПроцедуры
// Процедура - обработчик события "Нажатие" кнопки КнопкаСообщенияСохранить.
// Сохранить текущий набор сообщений в файл.
//
// Параметры:
// Элемент - кнопка.
//
Процедура КнопкаСообщенияСохранитьНажатие(Элемент)
Сообщения_СохранитьВФайл(ОбъектСообщ);
КонецПроцедуры
```
Форма просмотра сообщений.
==========================
Также имеется отдельное окно просмотра списка сообщений (соответствующей ТаблицыЗначений). Оно предназначено для того, чтобы можно было более удобно проанализировать большой список (так как в основном диалоговом окне ТабличноеПоле сообщений сильно растянуть по высоте не удастся – будет мешать другие элементы интерфейса).
Выглядит форма примерно следующим образом:
Код модуля формы совсем несложный. Вот такой:
**Текст модуля формы**
```
////////////////////////////////////////////////////////////////////////////////
// ДИАЛОГ ДЛЯ ОТОБРАЖЕНИЯ СПИСКА СООБЩЕНИЙ В ОТДЕЛЬНОМ ОКНЕ
Перем ОбъектСообщ; // Объект для работы с сообщениями
////////////////////////////////////////////////////////////////////////////////
// ОБРАБОТЧИКИ СОБЫТИЙ ФОРМЫ
// Процедура - обработчик события "Действие" элемента меню КоманднаяПанельМенюСохранитьВФайл.
// Сохранить текущий набор сообщений в файл.
//
// Параметры:
// Кнопка - элемент меню.
//
Процедура КоманднаяПанельМенюСохранитьВФайл(Кнопка)
Сообщения_СохранитьВФайл(ОбъектСообщ);
КонецПроцедуры
// Процедура - обработчик события "ПриВыводеСтроки" табличного поля
// ТабличноеПолеСообщения. Данное событие происходит при выводе каждой строки.
//
// Параметры:
// Элемент - табличное поле;
// ОформлениеСтроки - объект настройки визуального оформления строки
// ДанныеСтроки - набор данных строки табличного поля.
//
Процедура ТабличноеПолеСообщенияПриВыводеСтроки(Элемент, ОформлениеСтроки, ДанныеСтроки)
// Оформление ячейки "Статус"
ОформлениеСтроки.Ячейки.КолонкаСтатусСообщения.ОтображатьТекст = Ложь;
КартинкаСтатуса = Сообщения_Картинка(ДанныеСтроки.ТипСообщ, ДанныеСтроки.СтатусСообщ);
Если КартинкаСтатуса <> Неопределено Тогда
ОформлениеСтроки.Ячейки.КолонкаСтатусСообщения.ОтображатьКартинку = Истина;
ОформлениеСтроки.Ячейки.КолонкаСтатусСообщения.Картинка = КартинкаСтатуса;
КонецЕсли;
// Оформление ячейки "Текст"
Если (ДанныеСтроки.ТекстСообщ <> Неопределено) И
(ДанныеСтроки.ТекстСообщ <> "") Тогда
ЦветТекста = Сообщения_ЦветТекста(ДанныеСтроки.ТипСообщ, ДанныеСтроки.СтатусСообщ);
Если ЦветТекста <> Неопределено Тогда
ОформлениеСтроки.Ячейки.КолонкаТекстСообщения.ЦветТекста = ЦветТекста
КонецЕсли
КонецЕсли;
// Оформление ячейки "Комментарий"
Если (ДанныеСтроки.КомментарийСообщ <> Неопределено) И
(ДанныеСтроки.КомментарийСообщ <> "") Тогда
ЦветКомментария = Сообщения_ЦветКомментария(ДанныеСтроки.ТипСообщ, ДанныеСтроки.СтатусСообщ);
Если ЦветКомментария <> Неопределено Тогда
ОформлениеСтроки.Ячейки.КолонкаКомментарийСообщения.ЦветТекста = ЦветКомментария
КонецЕсли
КонецЕсли
КонецПроцедуры
////////////////////////////////////////////////////////////////////////////////
// ПОДПРОГРАММЫ ВНЕШНЕГО ИНТЕРФЕЙСА
// Вызов диалога просмотра списка сообщений
//
// Параметры:
// ОбъектСообщения - объект для работы с сообщениями.
//
Процедура ShowMessagesDlg(ОбъектСообщений) Экспорт;
Если ОбъектСообщений <> Неопределено Тогда
// Выполнить начальную установку параметров
ОбъектСообщ = ОбъектСообщений;
ЭлементыФормы.ТабличноеПолеСообщения.Значение = ОбъектСообщ.ТабЗнач;
// Вызвать диалог
ЭтаФорма.ОткрытьМодально()
КонецЕсли
КонецПроцедуры
```
Скачать исходные тексты подсистемы сообщений и рассмотренный пример (обработка для 1С 8.2) можно [здесь](https://yadi.sk/d/YOsuUaCSps7VF).
На этом все. Всем удачи. До встречи.
P.S.
====
В следующей статье я планирую рассказать о работе с сервером (базами) FireBird из 1С.
Мы выясним:
— как корректно подключаться к серверу (базе) и отключаться;
— как выполнять запросы: передавать и получать данные;
— как работать с бинарными полями и строками в различной кодировке;
— как вызывать хранимые процедуры и получать результаты их работы;
— как обойти такую неприятность, как автоматический разрыв клиентского соединения со стороны сервера FireBird (простой и понятный способ, который почему-то нигде не описан в Интернете).
Мы создадим обособленные и переносимые наборы подпрограмм («классов»):
— для подключения к базе (сможем подключаться к серверу, базе и выполнять запросы);
— для работы с параметрами запроса (можно будет задавать и устанавливать параметры почти как в Delphi);
А также:
— для работы с множествами целых чисел и строк (удобно задавать множественные параметры для запросов);
— удобное хранилище профилей подключений к различным базам FireBird, а также интерфейс пользователя (форма для редактирования набора профилей подключений)
В общем, думаю, что будет интересно. Еще раз, удачи… | https://habr.com/ru/post/278521/ | null | ru | null |
# Тюнинг производительности для ASP.NET. Часть 1
[](http://www.gotdotnet.ru/upload/blog/jeje/ef7/Untitled-1_2.png)В первой части уловок с производительностью для ASP.NET и IIS7 мы рассмотрим некоторые простые, но тем не менее мощные возможности web.config файла. Используя некоторые трюки мы увеличим производительность любого нового или существующего веб-сайта, не изменяя ничего, кроме web.config файла.
Следующие XML-сниппеты **должны** быть помещены в секцию в web.config.
### HTTP-сжатие
На практике, вы обычно можете настроить сжатие по HTTP в ASP.NET, используя [сторонние](http://blowery.org/httpcompress/) или собственные библиотеки. С IIS7 вы можете отбросит все это и использовать встроенный компрессор, доступный с web.config. Добавьте следующую строчку кода для включения HTTP-компрессии:
> `<urlCompression doDynamicCompression="true" doStaticCompression="true" dynamicCompressionBeforeCache="true"/>`
По умолчанию, сжиматься могут только текстовые типы данных.
#### doDynamicCompression
Установите данный атрибут в true и вы получите сжатие для таких динамически созданных данных, как страницы, представления, обработчики. Ничто не мешает это сделать.
#### doStaticCompression
Данный атрибут позволяет выбирать, хотите ли вы или нет сжимать статические файлы: стили и скрипты. Изображения и другие не текстовые данные по умолчанию не сжимаются. Советую включить данную опцию.
#### dynamicCompressionBeforeCache
Если вы делаете кэширование вывода страниц в ASP.NET сайтах, то вы можете попросить IIS7 сжимать результат перед тем, как поместить в кэш. Проблемы могут возникнуть только если у вас собственный механизм кэширования вывода. Попробуйте активировать данную возможность и протестировать приложение. Если все отлично работает, то почему бы не оставить его включенным?
#### Заметка
По умолчанию, только текстовые типы содержимого подлежат сжатию. Это означает, что если вы посылаете application/x-javascript, как тип содержимого, то вам следует изменить его на text/javascript. Если вы используете собственные модули на сайтах, тогда возможно у вас будут конфликты с IIS7 компрессией.
#### Ресурсы
* [Add new mime-types for compression](http://www.west-wind.com/weblog/posts/98538.aspx)
* [Configure HTTP compression in IIS 7 (Technet)](http://technet.microsoft.com/en-us/library/cc771003%28WS.10%29.aspx)
### Кеширование статических файлов
Для увеличения скорости загрузки важно, чтобы все, что могло кэшироваться браузером, кэшировалось браузером. Сюда входят такие статические файлы, как изображения, стили, скрипты. Позволив браузеру кэшировать все эти файлы, ему не придется запрашивать их заново на протяжении периода кэша. Это сохраняет много трафика вам и вашим посетителям, делая загрузку страниц быстрее. Правильно настроенный первичный кэш браузера гораздо быстрее вызовет события *load* и *DOMContentLoaded*.
Добавив данный сниппет в ваш web.config, все статические файлы будут кэшированы браузером на год:
> `<staticContent>
>
> <clientCache cacheControlMode="UseMaxAge" cacheControlMaxAge="365.00:00:00"/>
>
> staticContent>`
Данные настройки устанавливают срок годности файлов на один год вперед. Происходит это, когда IIS указывает в HTTP-заголовке иструкции для браузера, в данном случае он просит о добавлении файла в кэш. Если же вы нажмете F5 или Ctrl+F5, браузер запросит файлы вне зависимости от их даты истечения.
Главной проблемой кэширования на клиентской стороне – это изменение статических файлов до истечения срока годности. Посетитель со старой версией в кэше не увидит новых файлов, пока не очистит кэш браузера, нажав F5. Поэтому данные настройки нужно использовать с осторожностью и, думаю, следует сократить срок годности. Во второй части я рассмотрю данную проблему и предложу простой способ для её решения.
#### Заметка
Убедитесь, что важные пользовательские данные не кэшируются браузером. Иначе они будут доступны другим пользователям, использующие данный браузер.
#### Ресурсы
* [Client Cache (iis.net)](http://www.iis.net/ConfigReference/system.webServer/staticContent/clientCache) | https://habr.com/ru/post/99296/ | null | ru | null |
# Разбор настройки ELK 7.5 для анализа логов Mikrotik
Давно была мысль посмотреть, что можно делать с ELK и подручными источниками логов и статистики. На страницах хабра планирую показать практический пример, как с помощью домашнего мини-сервера можно сделать, например, honeypot с системой анализа логов на основе ELK стека. В этой статье расскажу про простейший пример анализа логов firewall с помощью стека ELK. В дальнейшем хотелось бы описать настройку окружения для анализа Netflow трафика и pcap дампов инструментом Zeek.
Если у вас есть публичный IP-адрес и более-менее умное устройство в качестве шлюза/файрволла, вы можете организовать пассивный honeypot, настроив логирование входящих запросов на «вкусные» TCP и UDP порты. Под катом пример настройки маршрутизатора Mikrotik, но если у вас под рукой маршрутизатор другого вендора (или какая-то ещё security система), нужно просто немного разобраться с форматами данных и вендоро-специфичными настройками, и получится тот же результат.
### Disclaimer
Статья не претендует на оригинальность, здесь не рассматриваются вопросы отказоустойчивости сервисов, безопасности, лучших практик и т.д. Нужно рассматривать этот материал как академический, он подходит для ознакомления с базовым функционалом стека ELK и механизмом анализа логов сетевого устройства. Однако и не новичку может быть что-то интересно.
Проект запускается из docker-compose файла, соответственно развернуть своё подобное окружение очень просто, даже если у вас под рукой маршрутизатор другого вендора, нужно просто немного разобраться с форматами данных и вендоро-специфичными настройками. В остальном я постарался максимально подробно описать все нюансы, связанные с конфигурированием Logstash pipelines и Elasticsearch mappings в актуальной версии ELK. Все компоненты этой системы хостятся на [github](https://github.com/mekhanme/elk-mikrot), в том числе конфиги сервисов. В конце статьи я сделаю раздел Troubleshooting, в котором будут описаны шаги по диагностике популярных проблем новичков в этом деле.
### Введение
На самом сервере у меня установлена система виртуализации Proxmox, на ней в KVM машине запускаются Docker контейнеры. Предполагается, что вы знаете, как работает docker и docker-compose, благо примеров настройки о использования в интернете достаточно. Я не буду касаться вопросов установки Docker, про docker-compose немного напишу.
Идея запустить honeypot возникла в процессе изучения Elasticsearch, Logstash и Kibana. В профессиональной деятельности я никогда не занимался администрированием и вообще использованием этого стека, но у меня есть хобби проекты, благодаря которым сложился большой интерес изучить возможности, которые даёт поисковый движок Elasticsearch и Kibana, с помощью которых можно анализировать и визуализировать данные.
Моего не самого нового мини сервера NUC с 8GB RAM как раз хватает для запуска ELK стека с одной нодой Elastic. В продакшн окружениях так делать, конечно, не рекомендуется, но для обучения в самый раз. По поводу вопроса безопасности в конце статьи есть ремарка.
В интернете полно инструкций по установке и конфигурированию ELK стека для схожих задач (например, [анализ brute force атак на ssh с помощью Logstash версии 2](https://habr.com/ru/post/324760/), [анализ логов Suricata с помощью Filebeat версии 6](https://habr.com/ru/post/431600/)), однако в большинстве случаев не уделяется должного внимания деталям, к тому же 90 процентов материала будет для версий от 1 до 6 (на момент написания статьи актуальная версия ELK 7.5.0). Это важно, потому что с 6 версии Elasticsearch [решили убрать](https://www.elastic.co/guide/en/elasticsearch/reference/6.7/removal-of-types.html) сущность mapping type, тем самым синтаксис запросов и структура мапингов изменились. Mapping template в Elastic вообще очень важный объект, и чтобы потом не было проблем с выборкой и визуализацией данных, советую не увлекаться копипастой и стараться понимать, что делаете. Дальше я постараюсь понятно объяснять, что значат описываемые операции и конфиги.
Настройка роутера
-----------------
Для домашней сети в качестве маршрутизатора я использую Mikrotik, так что пример будет для него. Но на отправку syslog на удалённый сервер можно настроить почти любую систему, будь то маршрутизатор, сервер или ещё какая-то security система, которая умеет логировать.
### Отправка syslog сообщений на удалённый сервер
В Mikrotik для настройки логирования на удалённый сервер через CLI достаточно ввести пару команд:
```
/system logging action add remote=192.168.88.130 remote-port=5145 src-address=192.168.88.1 name=logstash target=remote
/system logging add action=logstash topics=info
```
### Настройка правил firewall с логированием
Нас интересуют только определённые данные (hostname, ip-adress, username, url etc.), из которых можно получить красивую визуализацию или выборку. В самом простом случае, чтобы получить информацию о сканировании портов и попытке доступа, нужно настроить компонент firewall на логирование срабатываний правила. Я на Mikrotik настроил правила в таблице NAT, а не Filter, так как в дальнейшем собираюсь поставить ханипоты, которые будут эмулировать работу сервисов, это позволит исследовать больше информации о поведении ботнетов, но это уже более продвинутый сценарий и о нём не в этот раз.
Внимание! В конфигурации ниже стандартный TCP порт сервиса SSH (22) натится в локальную сеть. Если вы используете SSH для доступа к роутеру извне и в настройках стоит порт 22 (*ip service print* в CLI и *ip > services* в Winbox), стоит переназначить порт для management SSH, либо не вводить последнее правило в таблице.
Так же, в зависимости от названия WAN-интерфейса (если не используется WAN bridge), нужно поменять параметр *in-interface* на соответствующий.
```
/ip firewall nat
add action=netmap chain=dstnat comment="HONEYPOT RDP" dst-port=3389 in-interface=bridge-wan log=yes log-prefix=honeypot_rdp protocol=tcp to-addresses=192.168.88.201 to-ports=3389
add action=netmap chain=dstnat comment="HONEYPOT ELASTIC" dst-port=9200 in-interface=bridge-wan log=yes log-prefix=honeypot_elastic protocol=tcp to-addresses=192.168.88.201 to-ports=9211
add action=netmap chain=dstnat comment=" HONEYPOT TELNET" dst-port=23 in-interface=bridge-wan log=yes log-prefix=honeypot_telnet protocol=tcp to-addresses=192.168.88.201 to-ports=2325
add action=netmap chain=dstnat comment="HONEYPOT DNS" dst-port=53 in-interface=bridge-wan log=yes log-prefix=honeypot_dns protocol=udp to-addresses=192.168.88.201 to-ports=9953
add action=netmap chain=dstnat comment="HONEYPOT FTP" dst-port=21 in-interface=bridge-wan log=yes log-prefix=honeypot_ftp protocol=tcp to-addresses=192.168.88.201 to-ports=9921
add action=netmap chain=dstnat comment="HONEYPOT SMTP" dst-port=25 in-interface=bridge-wan log=yes log-prefix=honeypot_smtp protocol=tcp to-addresses=192.168.88.201 to-ports=9925
add action=netmap chain=dstnat comment="HONEYPOT SMB" dst-port=445 in-interface=bridge-wan log=yes log-prefix=honeypot_smb protocol=tcp to-addresses=192.168.88.201 to-ports=9445
add action=netmap chain=dstnat comment="HONEYPOT MQTT" dst-port=1883 in-interface=bridge-wan log=yes log-prefix=honeypot_mqtt protocol=tcp to-addresses=192.168.88.201 to-ports=9883
add action=netmap chain=dstnat comment="HONEYPOT SIP" dst-port=5060 in-interface=bridge-wan log=yes log-prefix=honeypot_sip protocol=tcp to-addresses=192.168.88.201 to-ports=9060
add action=dst-nat chain=dstnat comment="HONEYPOT SSH" dst-port=22 in-interface=bridge-wan log=yes log-prefix=honeypot_ssh protocol=tcp to-addresses=192.168.88.201 to-ports=9922
```
В Winbox то же самое настраивается в разделе *IP > Firewall > вкладка NAT*.
Теперь роутер будет перенаправлять полученные пакеты на локальный адрес 192.168.88.201 и кастомный порт. Сейчас пока что никто не слушает на этих портах, так что коннекты будут обрываться. В дальнейшем в докере можно запустит honeypot, коих множество под каждый сервис. Если этого делать не планируется, то вместо правил NAT следует прописать правило с действием drop в цепочке Filter.
### Запуск ELK с помощью docker-compose
Дальше можно приступать к настройке компонента, который будет заниматься процессингом логов. Cоветую сразу заняться практикой и склонировать репозиторий, чтобы видеть конфигурационные файлы полностью. Все описываемые конфиги можно увидеть там, в тексте статьи я буду копировать только часть конфигов.
```
❯❯ git clone https://github.com/mekhanme/elk-mikrot.git
```
В тестовом или dev окружении удобнее всего запускать docker контейнеры c помощью docker-compose. В этом проекте я использую docker-compose файл последней на данный момент [версии 3.7](https://docs.docker.com/compose/compose-file/), он требует docker engine версии 18.06.0+, так что не лишним обновить [docker](https://docs.docker.com/install/linux/docker-ce/centos/), а так же [docker-compose](https://docs.docker.com/compose/install/).
```
❯❯ curl -L "https://github.com/docker/compose/releases/download/1.25.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
❯❯ chmod +x /usr/local/bin/docker-compose
```
Так как в последних версиях docker-compose выпилили параметр *mem\_limit* и добавили *deploy*, запускающийся только в swarm mode (*docker stack deploy*), то запуск *docker-compose up* конфигурации с лимитами приводит к ошибке. Так как я не использую swarm, а лимиты ресурсов иметь хочется, запускать приходится с опцией *--compatibility*, которая конвертирует лимиты из docker-compose новых версий в нон-сварм эквивалент.
Пробный запуск всех контейнеров (в фоновом режиме -d):
```
❯❯ docker-compose --compatibility up -d
```
Придётся подождать, пока скачаются все образы, и после того как запуск завершится, проверить статус контейнеров можно командой:
```
❯❯ docker-compose --compatibility ps
```
Благодаря тому, что все контейнеры будут в одной сети (если явно не указывать сеть, то создаётся новый бридж, что подходит в этом сценарии) и в docker-compose.yml у всех контейнеров прописан параметр *container\_name*, между контейнерами уже будет связность через встроенный DNS докера. Вследствие чего не требуется прописывать IP-адреса в конфигах контейнеров. В конфиге Logstash прописана подсеть 192.168.88.0/24 как локальная, дальше по конфигурации будут более подробные пояснения, по которым можно оттюнить пример конфига перед запуском.
Настройка сервисов ELK
----------------------
Дальше будут пояснения по настройке функционала компонентов ELK, а также ещё некоторые действия, которые нужно будет произвести над Elasticsearch.
Для определения географических координат по IP-адресу потребуется скачать free базу [GeoLite2](https://dev.maxmind.com/geoip/geoip2/geolite2/) от MaxMind:
```
❯❯ cd elk-mikrot && mkdir logstash/geoip_db
❯❯ curl -O https://geolite.maxmind.com/download/geoip/database/GeoLite2-City-CSV.zip && unzip GeoLite2-City-CSV.zip -d logstash/geoip_db && rm -f GeoLite2-City-CSV.zip
❯❯ curl -O https://geolite.maxmind.com/download/geoip/database/GeoLite2-ASN-CSV.zip && unzip GeoLite2-ASN-CSV.zip -d logstash/geoip_db && rm -f GeoLite2-ASN-CSV.zip
```
### Настройка Logstash
Основным файлом конфигурации является *logstash.yml*, там я прописал опцию автоматического релоада конфигурации, остальные настройки для тестового окружения не значительные. Конфигурация самой обработки данных (логов) в Logstash описывается в отдельных *conf* файлах, обычно хранящихся в директории *pipeline*. При схеме, когда используются [multiple pipelines](https://www.elastic.co/guide/en/logstash/current/multiple-pipelines.html), файл *pipelines.yml* описывает активированные пайплайны. Пайплайн — это цепочка действий над неструктурированными данными, чтобы на выходе получить данные с определённой структурой. Схема с отдельно настроенным *pipelines.yml* не обязательная, можно обойтись и без него, загружая все конфиги из примонтированной директории *pipeline*, однако с определённым файлом *pipelines.yml* настройка получается более гибкая, так как можно не удаляя *conf* файлы из директории *pipeline*, включать и выключать необходимые конфиги. К тому же перезагрузка конфигов работает только в схеме multiple pipelines.
```
❯❯ cat logstash/config/pipelines.yml
- pipeline.id: logstash-mikrot
path.config: "pipeline/logstash-mikrot.conf"
```
Дальше идёт самая важная часть конфига Logstash. Описание pipeline состоит из нескольких секций — в начале в секции *Input* указываются плагины, с помощью которых Logstash получает данные. Наиболее простой способ собирать syslog с сетевого устройства — использовать input плагины [tcp](https://www.elastic.co/guide/en/logstash/current/plugins-inputs-tcp.html)/[udp](https://www.elastic.co/guide/en/logstash/current/plugins-inputs-udp.html). Единственный обязательный параметр этих плагинов — это *port*, его нужно указать таким же, как и в настройках роутера.
Второй секцией идёт *Filter*, в которой прописываются дальнейшие действия с пока ещё не структурированными данными. В моём примере удаляются лишние syslog сообщения от роутера с определённым текстом. Делается это с помощью условия и стандартного действия [*drop*](https://www.elastic.co/guide/en/logstash/7.5/plugins-filters-drop.html), которое отбрасывает всё сообщение, если условие удовлетворяется. В [условии](https://www.elastic.co/guide/en/logstash/7.5/event-dependent-configuration.html) проверяется поле *message* на наличие определённого текста.
Если сообщение не дропнулось, оно идёт дальше по цепочке и попадает в фильтр [*grok*](https://www.elastic.co/guide/en/logstash/7.5/plugins-filters-grok.html). Как написано в документации, *grok is a great way to parse unstructured log data into something structured and queryable*. Этот фильтр применяют для обработки логов различных систем (linux syslog, веб-сервера, БД, сетевые устройства и т.д.). На основе [готовых паттернов](https://github.com/logstash-plugins/logstash-patterns-core/tree/master/patterns) можно, не тратя много времени, составить парсер для любой более-менее повторяющейся последовательности. Для валидации удобно использовать [онлайн парсер](http://grokdebug.herokuapp.com/) (в последней версии Kibana аналогичный функционал есть в разделе *Dev Tools*).
В *docker-compose.yml* прописан volume *"./logstash/patterns:/usr/share/logstash/patterns",* в директории *patterns* лежит файл со стандартными community-паттернами (просто для удобства, посмотреть если забыл), а так же файл с паттернами нескольких типов сообщений Mikrotik (модули *Firewall* и *Auth)*, по аналогии можно дополнить своими шаблонами для сообщений другой структуры.
Стандартные опции *add\_field* и *remove\_field* позволяют внутри любого фильтра добавить или удалить поля из обрабатываемого сообщения. В данном случае удаляется поле *host*, которое содержит имя хоста, с которого было получено сообщение. В моём примере хост всего один, так что смысла в этом поле нет.
Дальше всё в той же секции *Filter* я прописал фильтр [*cidr*](https://www.elastic.co/guide/en/logstash/7.5/plugins-filters-cidr.html), который проверяет поле с IP-адресом на соответствие условию вхождения в заданную подсеть и ставит тег. На основе тега в дальнейшей цепочке будут производиться или не производиться действия (если конкретно, то это для того, чтобы в дальнейшем не делать geoip lookup для локальных адресов).
Секций *Filter* может быть сколько угодно, и, чтобы было меньше условий внутри одной секции, в новой секции я определил действия для сообщений без тега *src\_local*, то есть тут обрабатываются события файрволла, в которых нам интересен именно адрес источника.
Теперь надо немного подробнее рассказать про то, откуда Logstash берёт GeoIP информацию. Logstash поддерживает базы [GeoLite2](https://dev.maxmind.com/geoip/geoip2/geolite2/). Есть несколько вариантов баз, я использую две базы: GeoLite2 City (в которой есть информация о стране, городе, часовом поясе) и GeoLite2 ASN (информация об автономной системе, к которой принадлежит IP-адрес).
Плагин [*geoip*](https://www.elastic.co/guide/en/logstash/7.3/plugins-filters-geoip.html) и занимается добавлением GeoIP информации в сообщение. Из параметров надо указать поле, в котором содержится IP-адрес, используемую базу, и название нового поля, в которое будет прописана информация. У меня в примере тоже самое делается и для destination IP-адреса, но пока что в этом простом сценарии эта информация будет неинтересна, так как адрес назначения всегда будет являться адресом роутера. Однако в дальнейшем в этот пайплайн можно будет добавить логи не только с файрволла, но и с других систем, где актуально будет смотреть на оба адреса.
Фильтр [*mutate*](https://www.elastic.co/guide/en/logstash/7.3/plugins-filters-mutate.html) позволяет изменять поля сообщения и модифицировать сам текст в полях, в документации подробно написано много примеров того, что можно делать. В данном случае используется для добавления тега, переименования полей (для дальнейшей визуализации логов в Kibana требуется определённый формат объекта [*geo-point*](https://www.elastic.co/guide/en/elasticsearch/reference/7.3/geo-point.html), дальше я ещё коснусь этой темы) и удаления ненужных полей.
На этом секция обработки данных заканчивается и остаётся только обозначить, куда слать структурированное сообщение. В данном случае сбором данных будет заниматься Elasticsearch, нужно только ввести IP-адрес, порт и название индекса. Индекс рекомендуется вводить с variable полем даты, чтобы каждый день создавался новый индекс.
### Настройка Elasticsearch
Возвращаемся к Elasticsearch. Для начала надо удостовериться, что сервер запущен и функционирует. С Elastic эффективнее всего взаимодействовать через Rest API в CLI. С помощью curl можно посмотреть состояние ноды (localhost заменить на ip-адрес докер хоста):
```
❯❯ curl localhost:9200
```
Дальше можно пробовать открыть Kibana по адресу [*localhost*](http://localhost):5601. В веб-интерфейсе Kibana настраивать ничего нет необходимости (разве что поменять тему на тёмную). Нам интересно посмотреть, создался ли индекс, для этого нужно открыть раздел *Management* и слева вверху выбрать *Elasticsearch Index Management*. Здесь можно посмотреть, сколько документов заиндексировано, сколько это занимает места на диске, так же из полезного можно посмотреть информацию по мапингу индекса.
Как раз дальше нужно прописать правильный mapping template. Эта информация Elastic нужна для того, чтобы он понимал, к каким типам данных какие поля относить. Например, чтобы делать специальные выборки на основе IP-адресов, для поля *src\_ip* нужно явно указать тип данных *ip*, а для определения географического положения нужно определить поле *geoip.location* в определённом формате и прописать тип *geo\_point*. Все возможные поля описывать не надо, так как для новых полей тип данных определяется автоматически на основе динамических шаблонов (*long* для чисел и *keyword* для строк).
Записать новый template можно или с помощью curl, или прямо из консоли Kibana (раздел *Dev Tools*).
```
❯❯ curl -X POST -H "Content-Type: application/json" -d @elasticsearch/logstash_mikrot-template.json http://192.168.88.130:9200/_template/logstash-mikrot
```
После изменения мапинга нужно удалить индекс:
```
❯❯ curl -X DELETE http://192.168.88.130:9200/logstash-mikrot-2019.12.16
```
Когда прилетит хотя бы одно сообщение в индекс, проверить мапинг:
```
❯❯ curl http://192.168.88.130:9200/logstash-mikrot-2019.12.16/_mapping
```
Для дальнейшего использования данных в Kibana, нужно в разделе *Management > Kibana Index Pattern*создать *pattern* . *Index name* ввести с символом \* (*logstash-mikrot\*)*, чтобы матчились все индексы, выбрать поле *timestamp* в качестве поля с датой и временем. В поле *Custom index pattern ID* можно ввести ID паттерна (например, *logstash-mikrot*), в дальнейшем это может упростить обращения к объекту.
Анализ и визуализация данных в Kibana
-------------------------------------
После того, как создали *index pattern*, можно приступать к самому интересному — анализу и визуализации данных. В Kibana есть множество функционала и разделов, но нам пока что будут интересны только два.
### Discover
Здесь можно просматривать документы в индексах, фильтровать, искать и смотреть полученную информацию. Важно не забывать про шкалу времени, которая задаёт временные рамки в условиях поиска.
### Visualize
В этом разделе можно строить визуализацию на основе собранных данных. Самое простое — это отобразить источники сканирующих ботнетов на географической карте, точечно или в виде heatmap. Так же доступно множество способов построить графики, сделать выборки и т.д.
В дальнейшем я планирую рассказать подробнее про обработку данных, возможно визуализацию, может что-то ещё интересное. В процессе изучения буду стараться дополнять туториал.
Troubleshooting
---------------
В случае, если в Elasticsearch индекс не появляется, нужно в первую очередь смотреть логи Logstash:
```
❯❯ docker logs logstash --tail 100 -f
```
Logstash не будет работать, если нет связности с Elasticsearch, или ошибка в конфигурации пайплайна — это основные причины и о них становится ясно после внимательного изучения логов, которые по умолчанию пишутся в json докером.
Если ошибок в логе нет, нужно убедиться, что Logstash ловит сообщения на своём настроенном сокете. Для целей дебага можно использовать *stdout* в качестве *output*:
```
stdout { codec => rubydebug }
```
После этого Logstash будет писать дебаг информацию при полученном сообщении прямо в лог.
Проверить Elasticsearch очень просто — достаточно сделать GET запрос curl`ом на IP-адрес и порт сервера, либо на определённый API endpoint. Например посмотреть состояние индексов в человекочитаемой таблице:
```
❯❯ curl -s 'http://192.168.88.130:9200/_cat/indices?v'
```
Kibana тоже не запустится, если не будет коннекта до Elasticsearch, увидеть это легко по логам.
Если веб-интерфейс не открывается, то стоит убедиться, что в Linux правильно настроен или отключён firewall (в Centos были проблемы с *iptables* и*docker*, решились по советам из [топика](https://stackoverflow.com/questions/31667160/running-docker-container-iptables-no-chain-target-match-by-that-name)). Также стоит учитывать, что на не очень производительном оборудовании все компоненты могут загружаться несколько минут. При нехватке помяти сервисы вообще могут не загрузиться. Посмотреть использование ресурсов контейнерами:
```
❯❯ docker stats
```
Если вдруг кто-то не знает, как корректно изменить конфигурацию контейнеров в файле *docker-compose.yml* и перезапустить контейнеры, это делается редактированием *docker-compose.yml* и с помощью той же команды с тем же параметрами перезапускается:
```
❯❯ docker-compose --compatibility up -d
```
При этом в изменённых секциях старые объекты (контейнеры, сети, волюмы) стираются и пересоздаются новые согласно конфигу. Данные сервисов при этом не теряются, так как используется *named volumes*, которые не удаляются с контейнером, а конфиги монтируются с хостовой системы, Logstash так умеет даже мониторить файлы конфигов и перезапускать пайплайн конфигурацию при изменении в файле.
Перезапустить сервис отдельно можно командой *docker restart* (при этом не обязательно находиться в директории с *docker-compose.yml)*:
```
❯❯ docker restart logstash
```
Посмотреть конфигурацию объекта докер можно командой *docker inspect*, совместно с*[jq](https://stedolan.github.io/jq/tutorial/)* использовать удобнее.
Заключение
----------
Хочу отметить, что security в этом проекте не доложено потому, что это тестовое (dev) окружение и не планируется выпуск наружу за пределы роутера. Если разворачивать для более серьёзного использования, то нужно следовать best practice, устанавливать сертификаты для HTTPS, делать резервирование, нормальный мониторинг (который запускается не рядом с основной системой). К слову, на моём сервере работает Traefik в докере, который является обратным прокси для некоторых сервисов, а так же терминирует TLS на себя и делает аутентификацию. То есть, благодаря настроенному DNS и reverse proxy, появляется возможность из интернета зайти в веб-интерфейс Kibana с ненастроенным HTTPS и паролем (насколько я понял, в комьюнити версии Kibana не поддерживает парольную защиту веб-интерфейса). Планирую в дальнейшем описать свой опыт настройки Traefik для использования в домашней сети с Docker. | https://habr.com/ru/post/481596/ | null | ru | null |
# Selenium: работаем с элементами страницы, используя @FindBy и PageFactory
В этой статье будет рассмотрена возможность использования аннотации @FindBy для поиска элементов на странице, а так же создание своих классов для работы с элементами и контейнерами вроде форм, таблиц и т.д.
#### Введение в @FindBy
Для начала посмотрим на тест, который просто ищет какую-то фразу на ya.ru
```
public class SearchTest {
@Test(dataProvider = "pageObjects")
public void testSearch(final SearchPage searchPage) {
searchPage.init(driver);
driver.get("http://ya.ru");
searchPage.search("Bolek i Lolek");
}
@DataProvider
private Object[][] pageObjects() {
return new Object[][]{
{new SimpleSearchPage()},
{new AnnotatedSearchPage()},
{new ExtendedSearchPage()},
{new SearchPageWithSearchForm()}
};
}
private WebDriver driver;
@BeforeClass
public void beforeClass() {
driver = new FirefoxDriver();
}
@AfterClass
public void afterClass() {
driver.quit();
}
}
```
Как видите, тест очень простой и ничего собственно не тестирует, а просто запускается 4 раза с разными page-объектами, рассматривая эволюцию которых, мы и будем изучать @FindBy.
Изначально page-класс для страницы поиска выглядел так:
```
public class SimpleSearchPage implements SearchPage {
private WebDriver driver;
@Override
public void search(final String query) {
driver.findElement(By.id("text")).sendKeys(query);
driver.findElement(By.cssSelector("input[type=\"submit\"]")).click();
}
@Override
public void init(final WebDriver driver) {
this.driver = driver;
}
}
```
Здесь мы видим довольно-таки стандартный подход к использованию веб-драйвера для поиска элементов, т.е. driver.findElement(By.something()).
Лёгким движением рук можно преобразовать этот класс, используя аннотации
```
public class AnnotatedSearchPage implements SearchPage {
@FindBy(id = "text")
private WebElement searchField;
@FindBy(css = "input[type=\"submit\"]")
@CacheLookup
private WebElement searchButton;
@Override
public void search(final String query) {
searchField.sendKeys(query);
searchButton.click();
}
@Override
public void init(final WebDriver driver) {
PageFactory.initElements(driver, this);
}
}
```
Как это работает?! В методе init() мы вызываем `PageFactory.initElements(driver, this);`. Драйвер не начинает искать элементы на странице сразу же, а ищет их как только мы обращаемся к полю класса. Например строка `searchButton.click();` «превращается» в `driver.findElement(By.cssSelector("input[type=\"submit\"]")).click();`
Плюсов от такого подхода вроде бы пока маловато, но они есть:
1. не нужно писать driver.findElements(...) и копипастить этот поиск по всему классу;
2. можно использовать аннотацию @CacheLookup: найдя элемент в первый раз, driver кэширует его и в будущем уже использует кэшированный объект, что даёт небольшой прирост в скорости тестов;
3. можно уйти от использования интерфейса WebElement и создать свои классы для элементов страницы типа Button, TextField и т.д.
#### Создание своих классов для элементов страницы
Я уже многократно напарывался на тот факт, что интерфейс WebElement не очень-то удобен:
1. он предоставляет излишний функционал, например, .getCssValue(), который абсолютно ненужен в selenium тестах;
2. его невозможно расширить, т.е. нельзя добавить пару своих ну очень удобных методов на каждый день, ну и, соответственно, из него нельзя удалить ненужные методы (например, для любой ссылки метод .isEnabled() просто не имеет смысла);
3. для того, чтобы работать с более сложными элементами (например, с выпадающими списками) приходится явно вызывать конструктор класса Select, что больше похоже на какой-то хак.
Давайте посмотрим, как можно модифицировать page-класс, используя свои интерфейсы для элементов на странице.
```
public class ExtendedSearchPage implements SearchPage {
@FindBy(id = "text")
private TextField searchField;
@FindBy(css = "input[type=\"submit\"]")
private Button searchButton;
@Override
public void search(final String query) {
searchField.clearAndType(query);
searchButton.click();
}
@Override
public void init(final WebDriver driver) {
PageFactory.initElements(new ExtendedFieldDecorator(driver), this);
}
}
```
Итак, здесь мы уже используем TextField и Button вместо WebElement. Ключевым моментом здесь является использование самописного FieldDecorator в методе init(). Теперь именно он инициализирует поля класса ExtendedSearchPage. Плюсы от использования такого подхода:
1. повышается читаемость тестов: глядя на тип поля, сразу же становится понятно, что это кнопка, а не просто какой-то абстрактный элемент на странице, хотя на самом деле это может быть и не кнопка, но это уже зависит от реализации класса Button;
2. возможность добавлять свои методы, например, clearAndType() для полей ввода;
3. более изящный способ создания классов-контейнеров (таблиц, форм и т.д.);
Есть конечно же и минус: для каждого найденного элемента создаётся ещё один объект в памяти, который просто делегирует все вызовы объекту WebElement.
#### Создание классов-контейнеров
Как обычно, для начала немного кода
```
public class SearchPageWithSearchForm implements SearchPage {
@FindBy(tagName = "form")
private SearchForm searchForm;
@Override
public void search(final String query) {
searchForm.search(query);
}
@Override
public void init(final WebDriver driver) {
PageFactory.initElements(new ExtendedFieldDecorator(driver), this);
}
}
public class SearchForm extends AbstractContainer {
@FindBy(id = "text")
private TextField searchField;
@FindBy(css = "input[type=\"submit\"]")
private Button searchButton;
public void search(final String query) {
searchField.clearAndType(query);
searchButton.click();
}
}
```
Здесь мы уже видим полноценный класс для формы поиска, который можно спокойно переиспользовать на разных страницах (конечно, если на всех страницах сайта форма поиска реализована одинаково). Дополнительно, можно реализовать процесс иницализации объектов-контейнеров таким образом, что поиск элементов будет происходить только внутри контейнера, а не по всей странице, таким образом, получается, что контейнер ничего не знает об окружающем мире, что в конечном итоге и даёт нам возможность использовать его для тестирования других страниц.
##### Исходники
Исходники примеров можно скачать [отсюда](https://github.com/oraz/selenium). | https://habr.com/ru/post/134462/ | null | ru | null |
# demiurGo.cms Вступление
История создания.
=================
*«Делайте сегодня то, о чем другие завтра только подумают…»
Сократ.*
В 2005 году работая верстальщиком в одной web студии я впервые столкнулся с понятием CMS, первой же системой с которой я познакомился, была NetCat, а точнее все что от нее осталось после жесткого издевательства и переработок местными программистами.
Меня поразила легкость управления данным продуктом, но были конечно и недостатки от которых бросало в дрожь.
Тогда у меня и возникла идея создания своей собственной системы, с которой я буду дружить.
Перечитав тонны литературы и взяв в багаж немало терпения и килограммы кофе, я приступил к разработкам.
*«Первый блин — комом, но добавить икорки и получится даже очень ничего»*
Первой моей CMS была система под названием HCMS (кстати, заметил тенденцию — называть свои продукты с префиксом своего ника у большинства разработчиков). На нее ушло порядком 3-х месяцев, но результат меня конечно не устраивал – слишком много бесполезного кода для очень ущербного функционала. И как настоящий «поэт» — я сжег рукопись в надежде на просветление моделей в моей голове.
Приобретая немало опыта с каждой новой версией у меня стало получаться все лучше и лучше. К концу 2007 года получился слегка сыроватый и подгорелый продукт HCMS pro v6. Да! – 5 раз я удалял с винта тонны кода, но через несколько месяцев теста новой системы — мне пришлось удалить ее и в 6-й раз.
*«Отчаянье – привилегия слабых духом»*
После небольшого перерыва в пол года я опять открыл «блокнот» и изучив несколько популярных CMS — опять взялся за старое.
Подведу черту под лирическим отступлением: не пейте много кофе – он(-о) вас погубит!
Принцип работы
==============
Анализируя структуру web сайтов — систему можно разложить на несколько составляющих:
— Оформление
— Структура
— Контент
Все эти составляющие должны зависеть друг от друга следующим образом:
Система определяет текущий раздел, подключает привязанный шаблон оформления и внедряет там, где нужно контент предназначенный данному разделу.
Все очень просто с первого взгляда, но возникает вопрос — каким образом?
Часть 1. Оформление.
--------------------
Я не стал прибегать к готовым «темплированным» решениям и сильно заморачиваться в этой области. Поставил задачу: есть сверстанный дизайн и его необходимо натянуть на систему без особых усилий и чтобы на это уходило от пяти до десяти минут.
> `"Content-Type" content="text/html; charset=utf-8">
>
> =$<font color="#0000ff"this -> \_pageINFO["name"] ?>
>
>
>
> =$<font color="#0000ff"this->head()?>
>
>
>
>
>
>
>
>
>
> =$<font color="#0000ff"this -> adminpanel() ?>
>
> =$<font color="#0000ff"this -> content() ?>
>
>
>
>
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вот и все, это самый простой пример который я могу привести. А теперь по порядку:
**$this->\_pageINFO** — массив содержащий в себе информацию о текущем разделе
**$this->head()** – функция подключения всего самого необходимого CSS, JS и.т.д.
**$this->adminpanel()** – функция вывода админ – панельки
**$this ->content()** — функция вывода контента
Это самые необходимые внедрения в шаблон, без них, конечно, жить тоже можно, но тогда нет смылся использовать CMS.
К каждому шаблону привязывается CSS и JS файл – так чтобы удобно было)
Часть 2. Структура.
-------------------
В каждом сайте есть структура. Набор разделов и подразделов мы создаем вручную указывая привязку к оформлению и функционалу.
В основном классе контента данные о текущем разделе храниться в массиве **$this->\_pageINFO**, адрес (url) текущего раздела можно определить через **$this->FullUrl()**, а url другого раздела можно определить через его **id** **$this->FullUrl(‘id — раздела’)**.
Часть 3. Контент.
-----------------
Как вы уже поняли контент, каким бы он не был, вызывается внутри шаблона — оформления через функцию **$this->content()** и определяется указанным при создании раздела функционалом.
Функционал разделен на две вариации:
— Системный компонент
— Компонент (конфигуратор)
Более подробно о компонентах в следующих сериях…
Внимание! Система проходит beta – тестирование.
Для тех что хочет ее «погонять» вот [ссылка](http://www.demiur-go.com/download/). | https://habr.com/ru/post/56271/ | null | ru | null |
# Все начинается с анонса на Хабре
Привет Хабр! Путь многих стартапов от идеи до коммерчески успешных проектов начинается с анонса на Хабре. Для кого-то анонс является [хорошим подспорьем](http://habrahabr.ru/company/lingualeo/blog/89288/) для быстрого роста, [для других](http://habrahabr.ru/company/lpcloud/blog/235309/) – поводом еще раз углубиться в разработку и улучшить свой продукт.
В нашем случае – это второй вариант. Ваши замечания, советы и рекомендации определили дальнейшее развитие проекта. О том каким он стал и чего добился за 2 месяца работы, мы хотим рассказать в этом посте.
#### Коротко о проекте
Основная [идея LPCloud](http://lpcloudapp.com/) — **облегчить разработчикам** поддержку созданных Landing Page и дать возможность клиентам самостоятельно **вносить мелкие правки** в проект. На данный момент в сервисе создано более 500 лэндингов, а доход от платящих клиентов уже позволяет оплачивать сервера.
#### Нововведения
Теперь вы прямо на этапе создания Landing Page сможете загрузить свою верстку или выбрать бесплатный шаблон из нашей галерии. Загружать свою верстку можно drag'n'drop-ом. Формы в LPCloud настраиваются автоматически, поэтому никаких дополнительных скриптов писать не нужно.
#### Подключение Яндекс.Метрики и Google.Analytics
Клиенты могут самостоятельно подключить сервисы аналитики — достаточно просто авторизоваться в своем аккаунте или вписать идентификатор счетчика.
#### Улучшения в редакторе
Чтобы было больше места для редактирования, вынесли редактор в отдельное окно и объединили его с функционалом для проведения A/B-тестирования.
#### Документация
Для реализации всяких крутых штук, типа редиректа пользователей, зашедших с iPhone, в AppStore, составили [подробную документацию](http://lpcloudapp.com/docs). LPCloud использует open source шаблонизатор liquid, написанный для одной из лучших e-commenrce платформ Shopify. Вот таким вот образом образом можно выполнить редирект в зависимости от ОС.
```
{if current_host.os == 'android'}
window.location.href="//google.com"
{elsif current_host.os == 'ios'}
window.location.href="//apple.com"
{elsif current_host.os == 'osx'}
alert('Зашли с мака!')
{endif}
```
#### Что дальше?
В ближайших планах две больших задачи: существенно улучшить визуальный редактор и **расширить функционал для разработчиков**. Будем рады услышать ваши пожелания и идеи по этому поводу. | https://habr.com/ru/post/243127/ | null | ru | null |
# Сервис уведомлений в NextJS или ReactJS-приложении с помощью RxJS
В данной заметке я бы хотел поделиться опытом реализации простого, но достаточно функционального сервиса уведомлений, который можно легко реализовать в своем React (или NextJS, как в моем случае) приложении. Приложение будет написано на TypeScript, базисом для него послужит фреймворк NextJS 11-й версии (версию 12, каюсь, пока не изучал и в бою не испытывал). Для связи между страницей и алертами будет использоваться библиотека RxJS.
Вдохновением для написания данной статьи послужила, во-первых, производственная необходимость (а все мы знаем, как данный зверь умеет придать вдохновения), а во-вторых - прошлогодняя статья [Jason Watmore](https://jasonwatmore.com/post/2020/02/17/react-alert-toaster-notifications). Однако переводом данная заметка не является, поскольку итоговый результат сильно отличается от результата Джейсона. Кроме того, наш инструмент будет написан на TypeScript.
#### Почему RxJS?
Да, все знают, что одна лишняя зависимость проекта - минус 10 очков кармы для его архитектора. Но, с моей точки зрения, использование RxJS для данной задачи весьма оправдано, ибо позволяет написать решение простое, читабельное, масштабируемое и приятное глазу. А если RxJS потом заиспользовать еще для чего-нибудь - хотя бы для того же фетчинга API, то будет двойной профит. Поэтому...
#### Постановка задачи
Необходимо реализовать инструмент, с помощью которого можно отображать на странице всплывающие уведомления нескольких разных типов (ошибка, успех, предупреждение, нейтральная информация), при этом:
* Уведомления не должны занимать на странице место, портя верстку;
* Уведомления должны уметь автоматически закрываться через определенный интервал времени;
Самое важное: сервисом должно быть удобно пользоваться! Никакого копипаста, никакого бойлерплейт-кода. Так, чтобы даже стажер, вчера пришедший в компанию, умел выводить уведомления на странице.
Начнем с создания базовой структуры проекта (структура проекта - шаблонная, реализованная примерно по шагам, описанным в [моей прошлой статье](https://habr.com/ru/post/572230/))
Итоговый результат можно взять в [репозитории](https://gitlab.com/agratoth/nextjs-rxjs-alerting-service). Ветки соответствуют подразделам статьи.
Поиграться с демо можно [тут](https://nextjs-rxjs-demo.herokuapp.com/) (если хабраэффект не убьет)
### Базовая структура проекта
Стартовую структуру проекта можно подглядеть в [ветке](https://gitlab.com/agratoth/nextjs-rxjs-alerting-service/-/tree/base_project)
Несколько моментов:
* Проект настроен на достаточно высокий уровень строгости. Люблю, когда линтер не дает мне спуску в вопросах вроде забытых точек с запятой, неодинаковых кавычек и обязательных экспортов. Если такое поведение линтера и компилятора для вас слишком жестокое - подкрутить их можно в файлах `.eslintrc` и `tsconfig.json`
* В проекте настроена работа с SVG, хотя самих SVG в проекте не используется. Это просто привычка - настроить определенный скоуп шаблонных нюансов "на вырост"
* Я не являюсь специалистом в чистой верстке, и знанию различных фич верстки я предпочитаю использование флекс-боксов. Или гридов. Или еще чего-то такого же, простого и рабочего. Для того же выравнивания блока по центру экрана, к примеру. Прошу понять и простить.
### Подготовка страницы
Итоговое состояние проекта после данного шага - в [ветке](https://gitlab.com/agratoth/nextjs-rxjs-alerting-service/-/tree/preparation_completed)
Первым делом нам необходимо создать экспортируемые типы и интерфейсы, которые будут повсеместно использоваться далее в коде. Первый - тип `TColors`, который будет у нас одновременно указывать на цвет кнопки и на тип алерта. Всего цветов-типов четыре - `success`, `error`, `warning` и `info`.
Создадим файл `src/types/colors.ts`
```
export type TColors = 'success'|'error'|'warning'|'info';
```
Вторым библиотечным объектом будет интерфейс алерта.
Создадим файл `src/types/alert.ts`
```
import { TColors } from './colors';
export interface IAlert {
id: number,
status: TColors,
message: string,
timeout: number,
}
```
Данный интерфейс содержит всю информацию, необходимую для отображения алерта:
* `id`: уникальный идентификатор алерта. Его необходимость будет проиллюстрирована далее
* `status`: тип алерта. Фактически - его цвет, поскольку никаких иных функциональных различий между алертами разных типов нет
* `message`: текст уведомления
* `timeout`: таймаут закрытия алерта. Если передано значение `0`, алерт самостоятельно закрываться не будет. В ином случае число в данном поле указывает на количество секунд до автозакрытия
Далее нам необходимо указать все SCSS-переменные с цветами, которые мы будем использовать в дальнейшем.
Изменим файл `src/styles/variables.scss`, приведя его к следующему состоянию:
```
$danger: #FD726A;
$danger-light: #FFDEDD;
$success: #44CB7F;
$success-light: #D4FFE7;
$warning: #F39C12;
$warning-light: #FDEBD0;
$info: #3498DB;
$info-light: #D6EAF8;
$white: #FFF;
```
Для того, чтобы в дальнейшем было удобно импортировать в коде различные объекты, немного изменим секцию `compilerOptions/paths` в файле конфигурации компилятора TypeScript - `tsconfig.json`:
```
...
"paths": {
"pages/*": ["./src/pages/*"],
"components/*": ["./src/components/*"],
"layout": ["./src/layout/index.tsx"],
"types/*": ["./src/types/*"],
"services/*": ["./src/services/*"],
}
...
```
Директории layout и services мы будем использовать чуть дальше.
Теперь нам необходимо создать большую часть компонентов, которые будут у нас использоваться в приложении. В частности, это кнопки (`Button`), алерт (`Alert`), контейнер для отображения алертов (`AlertingService`), контейнер для отображения содержимого страницы по центру самой страницы (`CenteredVerticalForm`). Последний компонент необязателен, какой-либо функциональной нагрузки не несет, и служит чисто декоративным элементом
#### Button
Начнем с Button. Начнем создавать в `src/components/Button` файлы компонента:
`button.props.ts` - интерфейс пропсов (свойств компонента). Нам необходимо использовать некоторые пропсы базового , поэтому унаследуем пропсы нашего компонента от `DetailedHTMLProps`
```
import { ButtonHTMLAttributes, DetailedHTMLProps, ReactNode } from 'react';
import { TColors } from 'types/colors';
export interface ButtonProps extends
DetailedHTMLProps, HTMLButtonElement> {
children: ReactNode;
color: TColors;
}
```
`button.module.scss` - SCSS-модуль компонента. Все стили, которые будут использовать кнопки:
```
@import '../../styles/variables.scss';
.default {
width: 250px;
height: 40px;
letter-spacing: 1px;
font-size: 16px;
font-weight: 500;
&.success {
color: $success-light;
background-color: $success;
&:active {
color: $success;
background-color: $success-light;
}
}
&.error {
color: $danger-light;
background-color: $danger;
&:active {
color: $danger;
background-color: $danger-light;
}
}
&.warning {
color: $warning-light;
background-color: $warning;
&:active {
color: $warning;
background-color: $warning-light;
}
}
&.info {
color: $info-light;
background-color: $info;
&:active {
color: $info;
background-color: $info-light;
}
}
}
```
`button.tsx` - собственно, сам компонент. Мы собираем имена классов с помощью `classnames`, и пробрасываем в базовый событие `onClick`:
```
import cl from 'classnames';
import { ButtonProps } from './button.props';
import styles from './button.module.scss';
export const Button = (props: ButtonProps): JSX.Element => {
return (
{props.children}
);
};
```
`index.ts`:
```
export * from './button';
```
#### CenteredVerticalForm
Далее создадим компонент `CenteredVerticalForm`, единственной задачей которого будет "сделать красиво". Создадим в `src/components/CenteredVerticalForm` необходимые файлы.
`centered_vertical_form.props.ts` - пропсы. Заметьте, в отличие от Button мы самостоятельно создаем `children`, поскольку данные пропсы мы ни от чего не наследуем. Можно унаследовать от базовых интерфейсов React, но объем кода не изменится, так что смысла особого в этом нет, потому как ничего кроме `children` мы все равно использовать не будем:
```
import { ReactNode } from 'react';
export interface CenteredVerticalFormProps {
children: ReactNode,
}
```
`centered_vertical_form.module.scss` - SCSS-модуль
```
@import '../../styles/variables.scss';
.container {
display: flex;
align-items: center;
justify-content: center;
width: 100%;
height: 100vh;
}
.form {
display: grid;
width: 350px;
grid-template-rows: 1fr;
gap: 20px;
justify-items: center;
}
```
`centered_vertical_form.tsx` - сам компонент
```
import { CenteredVerticalFormProps } from './centered_vertical_form.props';
import styles from './centered_vertical_form.module.scss';
export const CenteredVerticalForm = (props: CenteredVerticalFormProps): JSX.Element => {
return (
{props.children}
);
};
```
`index.ts` - экспорт во внешний мир
```
export * from './centered_vertical_form';
```
#### Alert
`Alert` - самый главный компонент текущей системы. Виновник торжества, так сказать. Создадим файлы компонента в директории `src/components/Alert`.
`alert.props.ts` - пропсы компонента. Здесь нам необходимо пронаследовать интерфейс пропсов от интерфейса `IAlert`, потому что все поля `IAlert` должны стать пропсами компонента `Alert`. Почему в качестве пропсов сразу не использовать `IAlert`? Ну а вдруг нам в будущем понадобится передавать в объект `Alert` еще что-то? Колбэк для `onClick`, например, или внешний `className`
```
import { IAlert } from 'types/alert';
export interface AlertProps extends IAlert {}
```
`alert.module.scss` - SCSS-модуль. Здесь у нас так же созданы все классы, необходимые для раскрашивания алертов в цвета, соответствующие типам:
```
@import '../../styles/variables.scss';
.default {
display: flex;
align-items: center;
justify-content: space-between;
width: 100%;
min-height: 40px;
padding: 8px;
button {
background-color: transparent;
font-size: 12px;
font-weight: 700;
}
&.success {
color: $success-light;
background-color: $success;
button {
color: $success-light;
}
}
&.error {
color: $danger-light;
background-color: $danger;
button {
color: $danger-light;
}
}
&.warning {
color: $warning-light;
background-color: $warning;
button {
color: $warning-light;
}
}
&.info {
color: $info-light;
background-color: $info;
button {
color: $info-light;
}
}
}
```
`alert.tsx` - файл компонента. В нем мы, также как и в `Button`, конструируем с помощью `classnames` классы компонента из базового и класса цвета. Кроме того, мы создаем отдельную кнопку для закрытия алерта, оживлять которую будем чуть позже:
```
import cl from 'classnames';
import { AlertProps } from './alert.props';
import styles from './alert.module.scss';
export const Alert = (props: AlertProps): JSX.Element => {
return (
{props.message}
X
);
};
```
В `index.ts` добавляем экспорт компонента наружу:
```
export * from './alert';
```
#### AlertingService
Ну и, собственно, компонент сервиса алертинга. Технически он представляет собой контейнер, размещаемый где-то на странице, в который помещаются все активные в данный момент алерты. Дополнительной фичей можно сделать пропсы, которые позволят менять местоположение контейнера:
`alerting_service.props.ts` - пропсы компонента
```
export interface AlertingServiceProps {
vertical: 'top'|'bottom';
horizontal: 'left'|'right';
}
```
`alerting_service.module.scss` - SCSS-модуль:
```
@import '../../styles/variables.scss';
.default {
position: absolute;
display: flex;
align-items: flex-start;
flex-direction: column;
justify-content: flex-start;
width: 350px;
&.left {
left: 16px;
}
&.right {
right: 16px;
}
&.top {
top: 16px;
}
&.bottom {
bottom: 16px;
}
div {
margin-bottom: 8px;
}
}
```
`alerting_service.tsx` - сам компонент. Здесь уже происходит несколько интересных вещей. В частности, мы создаем массив алертов `alerts` (который чуть позже заменим на стейт), и добавляем в него один тестовый элемент, чтобы протестировать верстку и расположение компонента. Кроме того, с помощью метода `map` мы рендерим компоненты `Alert`, чтобы отобразить их на странице. В качестве пропса `key` пока воспользуемся индексом элемента в `map`, чуть позже поменяем на id алерта.
```
import cl from 'classnames';
import { IAlert } from 'types/alert';
import { Alert } from 'components/Alert';
import { AlertingServiceProps } from './alerting_service.props';
import styles from './alerting_service.module.scss';
export const AlertingService = (props: AlertingServiceProps): JSX.Element => {
const alerts: IAlert[] = [
{
id: 0,
message: 'Success message',
status: 'success',
timeout: 5,
},
];
const alertsContent = alerts.map((alert, idx) => {
return ;
});
return (
{alertsContent}
);
};
```
Ну и, как всегда, экспортируем компонент во внешний мир в `index.ts`.
#### Сборка
Соберем итоговую страницу. В файл `src/pages/index.tsx` добавим все созданные выше компоненты:
```
import { AlertingService } from 'components/AlertingService';
import { Button } from 'components/Button';
import { CenteredVerticalForm } from 'components/CenteredVerticalForm';
const Home = (): JSX.Element => {
return (
NextJS+RxJS Alerting service
Success
Error
Warning
Info
);
};
export default Home;
```
Мы должны увидеть центрированный вертикальный блок разноцветных кнопок и один зеленый алерт в правом верхнем углу страницы. Алерт пока закрыть нельзя, на нажатие кнопок приложение пока тоже не реагирует. Пришло время для RxJS.
### Пишем уведомления в console.log
Итоговое состояние проекта после данного шага - в [ветке](https://gitlab.com/agratoth/nextjs-rxjs-alerting-service/-/tree/alerts_to_log)
Первое, что мы попытаемся сделать - это просто поймать события вызова алертов и вывести в лог. Время для настоящих уведомлений придет в следующем разделе.
Но для начала надо установить в проект библиотеку RxJS и реализовать всю логику взаимодействия компонентов с сабджектами RxJS. То есть - написать ту часть alerting\_service, которая работает поверх RxJS.
Установим библиотеку:
```
npm i rxjs
```
Создадим файл `src/services/alerting_service.ts`. Далее нам необходимо импортировать все требуемые типы и создать объект `Subject`:
```
import { Observable, Subject } from 'rxjs';
import { IAlert } from 'types/alert';
import { TColors } from 'types/colors';
const alertsSubject = new Subject();
```
Дальше мы будем использовать `alertsSubject` в качестве стрима для пересылки алертов между компонентами.
Теперь создадим в этом же файле первый хелпер, который позволит генерировать событие отправки алерта:
```
...
const alert = (status: TColors, message: string, timeout: number): void => {
alertsSubject.next({
id: Math.round(window.performance.now()*10),
status, message, timeout
});
};
...
```
Вызвав в любом месте кода хелпер с необходимыми аргументами (цвет, сообщение, таймаут закрытия), мы отправляем в стрим `alertsSubject` объект, имеющий, кроме всего прочего, еще и `id` (соответствующий округленной отметке времени жизни страницы). Благодаря этому мы получаем алерты с гарантировано уникальными `id`, которые нам, к тому же, нигде не надо хранить.
Однако, выбирать явно цвет алерта каждый раз неудобно. Напишем пачку из четырех хелперов, позволяющих создавать каждый вид алертов:
```
...
const success = (message: string, timeout = 0): void => {
alert('success', message, timeout);
};
const error = (message: string, timeout = 0): void => {
alert('error', message, timeout);
};
const warning = (message: string, timeout = 0): void => {
alert('warning', message, timeout);
};
const info = (message: string, timeout = 0): void => {
alert('info', message, timeout);
};
...
```
Почти готово. Осталось реализовать функцию, возвращающую `Observable`- объект, чтобы получатели алертов могли на него подписаться:
```
...
const onAlert = (): Observable => {
return alertsSubject
.asObservable();
};
...
```
Итоговый вид файла
```
import { Observable, Subject } from 'rxjs';
import { IAlert } from 'types/alert';
import { TColors } from 'types/colors';
const alertsSubject = new Subject();
const success = (message: string, timeout = 0): void => {
alert('success', message, timeout);
};
const error = (message: string, timeout = 0): void => {
alert('error', message, timeout);
};
const warning = (message: string, timeout = 0): void => {
alert('warning', message, timeout);
};
const info = (message: string, timeout = 0): void => {
alert('info', message, timeout);
};
const alert = (status: TColors, message: string, timeout: number): void => {
alertsSubject.next({
id: Math.round(window.performance.now()\*10),
status, message, timeout
});
};
const onAlert = (): Observable => {
return alertsSubject
.asObservable();
};
export {
success,
warning,
error,
info,
onAlert,
};
```
Отлично. Самое время допилить получателя сообщений - компонент `AlertingService`.
В файл компонента добавляем необходимый код:
```
import { useEffect } from 'react';
...
import { onAlert } from 'services/alerting_service';
...
useEffect(() => {
onAlert().subscribe(v => {
console.log(v);
});
}, []);
...
```
Итоговый вид файла
```
import cl from 'classnames';
import { useEffect } from 'react';
import { IAlert } from 'types/alert';
import { Alert } from 'components/Alert';
import { onAlert } from 'services/alerting_service';
import { AlertingServiceProps } from './alerting_service.props';
import styles from './alerting_service.module.scss';
export const AlertingService = (props: AlertingServiceProps): JSX.Element => {
const alerts: IAlert[] = [
{
id: 0,
message: 'Success message',
status: 'success',
timeout: 5,
},
];
const alertsContent = alerts.map((alert, idx) => {
return ;
});
useEffect(() => {
onAlert().subscribe(v => {
console.log(v);
});
}, []);
return (
{alertsContent}
);
};
```
Осталось подцепить к `onClick` кнопок на странице вызов rxjs-хелпера, приведя `src/pages/index.ts` к следующему виду:
```
import { success, error, warning, info } from 'services/alerting_service';
import { AlertingService } from 'components/AlertingService';
import { Button } from 'components/Button';
import { CenteredVerticalForm } from 'components/CenteredVerticalForm';
const Home = (): JSX.Element => {
return (
NextJS+RxJS Alerting service
success('Success message', 3)}>Success
error('Error message', 10)}>Error
warning('Warning message', 5)}>Warning
info('Info message')}>Info
);
};
export default Home;
```
Можно запустить проект и попробовать понажимать на кнопки. Внешне ничего не изменилось, но в консоль страницы должны начать падать объекты `IAlert`.
### Настоящие уведомления
Итоговое состояние проекта после данного шага - в [ветке](https://gitlab.com/agratoth/nextjs-rxjs-alerting-service/-/tree/alerting_without_closing)
Итак, теперь у нас уже точно все готово для того, чтобы отображать настоящие алерты.
Для начала нам необходимо убрать в компоненте `AlertingService` фиктивный массив алертов и создать полноценный стейт:
```
...
export const AlertingService = (props: AlertingServiceProps): JSX.Element => {
const [alerts, setAlerts] = useState([]);
...
```
Теперь необходимо изменить эффект, в котором мы подписываемся на `onAlert`:
```
...
useEffect(() => {
onAlert().subscribe(v => {
setAlerts([
...alerts,
v,
]);
});
}, [alerts]);
...
```
Что мы здесь делаем: мы получаем из стрима объект IAlert, и кладем его в конец стейта. Всё, остальное доделает уже написанный ранее код.
Итоговый вид файла
```
import cl from 'classnames';
import { useEffect, useState } from 'react';
import { IAlert } from 'types/alert';
import { Alert } from 'components/Alert';
import { onAlert } from 'services/alerting_service';
import { AlertingServiceProps } from './alerting_service.props';
import styles from './alerting_service.module.scss';
export const AlertingService = (props: AlertingServiceProps): JSX.Element => {
const [alerts, setAlerts] = useState([]);
const alertsContent = alerts.map((alert, idx) => {
return ;
});
useEffect(() => {
onAlert().subscribe(v => {
setAlerts([
...alerts,
v,
]);
});
}, [alerts]);
return (
{alertsContent}
);
};
```
Теперь нажатие на любую из кнопок на странице приведет к появлению соответствующего алерта. Они полностью функциональны, за исключением одной мелочи - они не закрываются. Пришло время их этому научить.
### Создаем дополнительный стрим, учим уведомления закрываться
Итоговое состояние проекта после данного шага - в [ветке](https://gitlab.com/agratoth/nextjs-rxjs-alerting-service/-/tree/closing)
Для того, чтобы уведомления у нас закрывались по нажатию на кнопку с крестиком, нам необходимо реализовать в файле `src/services/alerting_service.ts` еще один стрим, хелпер и возврат `Observable`:
```
...
const closedAlertsSubject = new Subject();
...
const close = (id: number): void => {
closedAlertsSubject.next(id);
};
...
const onClosed = (): Observable => {
return closedAlertsSubject
.asObservable();
};
...
```
При этом по этому новому стриму нам нет необходимости отправлять весь объект IAlert. Достаточно сообщить `id` алерта, который необходимо закрыть.
Итоговый вид файла
```
import { Observable, Subject } from 'rxjs';
import { IAlert } from 'types/alert';
import { TColors } from 'types/colors';
const alertsSubject = new Subject();
const closedAlertsSubject = new Subject();
const success = (message: string, timeout = 0): void => {
alert('success', message, timeout);
};
const error = (message: string, timeout = 0): void => {
alert('error', message, timeout);
};
const warning = (message: string, timeout = 0): void => {
alert('warning', message, timeout);
};
const info = (message: string, timeout = 0): void => {
alert('info', message, timeout);
};
const close = (id: number): void => {
closedAlertsSubject.next(id);
};
const alert = (status: TColors, message: string, timeout: number): void => {
alertsSubject.next({
id: Math.round(window.performance.now()\*10),
status, message, timeout
});
};
const onAlert = (): Observable => {
return alertsSubject
.asObservable();
};
const onClosed = (): Observable => {
return closedAlertsSubject
.asObservable();
};
export {
success,
warning,
error,
info,
close,
onClosed,
onAlert,
};
```
Теперь добавляем обработчик `onClick` для кнопки с крестиком в компоненте `Alert`:
```
import cl from 'classnames';
import { close } from 'services/alerting_service';
import { AlertProps } from './alert.props';
import styles from './alert.module.scss';
export const Alert = (props: AlertProps): JSX.Element => {
return (
{props.message}
close(props.id)}>X
);
};
```
Осталось только научить компонент `AlertingService` удалять алерты, `id` которых он получил по новому стриму. Создадим подписку и код удаления алерта из стейта компонента:
Итоговый вид файла
```
import cl from 'classnames';
import { useEffect, useState } from 'react';
import { IAlert } from 'types/alert';
import { Alert } from 'components/Alert';
import { onAlert, onClosed } from 'services/alerting_service';
import { AlertingServiceProps } from './alerting_service.props';
import styles from './alerting_service.module.scss';
export const AlertingService = (props: AlertingServiceProps): JSX.Element => {
const [alerts, setAlerts] = useState([]);
const alertsContent = alerts.map((alert, idx) => {
return ;
});
useEffect(() => {
onAlert().subscribe(v => {
setAlerts([
...alerts,
v,
]);
});
onClosed().subscribe(id => {
setAlerts(
alerts.filter(alert => alert.id !== id),
);
});
}, [alerts]);
return (
{alertsContent}
);
};
```
Теперь нажатие на кнопку закрытия алерта должно его закрывать. Осталось немного - научить алерты закрываться по таймауту, исправить несколько ошибок и навести общего лоску.
### Создаем обработку автоматического закрывания уведомления, устраняем ошибки
Итоговое состояние проекта после данного шага - в [ветке](https://gitlab.com/agratoth/nextjs-rxjs-alerting-service/-/tree/autoclosing)
Первое, что надо сделать на этом этапе - это решить, кто будет закрывать алерты по таймауту. В оригинальной статье (указанной в начале данной заметки) алерты закрываются со стороны компонента-контейнера. Мне эта логика показалась не вполне обоснованной. Например, если мы хотим реализовать такую логику, как "таймаут приостанавливается, пока на алерт наведен курсор мыши" достаточно сложно было бы реализовать со стороны контейнера. Посему закрытие по таймауту я унес в компонент `Alert` (в конце концов, компонент алерта знает, с каким таймаутом он запущен. Почему бы ему самому не рулить этим процессом?)
Добавим в компонент `Alert` код, вызывающий таймаут, если значение `timeout` его пропсов больше нуля (в обратном случае алерт считается перманентным, и закрывается только кнопкой):
```
import cl from 'classnames';
import { useEffect } from 'react';
import { close } from 'services/alerting_service';
import { AlertProps } from './alert.props';
import styles from './alert.module.scss';
export const Alert = (props: AlertProps): JSX.Element => {
useEffect(() => {
if (props.timeout > 0){
const timer = setTimeout(() => {
close(props.id);
}, props.timeout * 1_000);
return () => {
clearTimeout(timer);
};
}
}, [props.id, props.timeout]);
return (
{props.message}
close(props.id)}>X
);
};
```
Обратите внимание на строку:
```
return () => {
clearTimeout(timer);
};
```
Это очистка таймаута, вызываемая при размонтировании компонента. Про нее забывать нельзя.
Все, теперь компонент сам при создании запускает таймер, и отправляет в стрим закрытия сигнал со своим `id`, совершая `роскомнадзор`.
Осталось исправить пару неочевидных ошибок в компоненте `AlertingService`.
Во-первых, необходимо поменять ключ, устанавливаемый на алерты в методе `map`. При текущем значении, с учетом того, что алерты приходят снизу, а уходят сверху, каждый перерендер списка алертов вызывает сброс таймеров в компонентах (что логично, ибо компоненты перегружаются). Необходимо поменять `key` с `idx` на `alert.id`:
```
...
const alertsContent = alerts.map((alert) => {
return ;
});
...
```
Во-вторых, необходимо отписываться от стримов при перерендере компонента `AlertingService` (который происходит каждый раз, когда меняется стейт `alerts`):
```
...
useEffect(() => {
const onAlertSubscription$ = onAlert().subscribe(v => {
setAlerts([
...alerts,
v,
]);
});
const onClosedSubscription$ = onClosed().subscribe(id => {
setAlerts(
alerts.filter(alert => alert.id !== id),
);
});
return () => {
onAlertSubscription$.unsubscribe();
onClosedSubscription$.unsubscribe();
};
}, [alerts]);
...
```
В противном случае это будет создавать неприятные фантомные сайд-эффекты (на поиск которых я потратил некоторое количество бесценного времени).
Всё. Теперь сервис алертинга полностью функционален. Он в использовании не требует практически никаких телодвижений (взгляните на код страницы `index.tsx`), никаких дополнительных стейтов и коллбеков для него создавать не нужно. Управление через несколько хелперов, и один компонент, который нужно обязательно разместить где-то на странице. Последнее мы как раз можем легко исправить, сделав компонент еще более удобным.
### Прячем AlertingService в общий layout
Итоговое состояние проекта после данного шага - в [ветке](https://gitlab.com/agratoth/nextjs-rxjs-alerting-service/-/tree/layout)
Создадим HOC, в который мы будем оборачивать компоненты страниц (в него потом можно будет добавить и такие нужные повторяющиеся штуки, как навигацию с хедерами и футерами).
В первую очередь необходимо создать файлы компонента layout. Создадим директорию `src/layout/BaseLayout` с файлами:
`base_layout.props.ts` - пропсы компонента. В них ничего особенного, просто стандартные `children`
```
import { ReactNode } from 'react';
export interface BaseLayoutProps {
children: ReactNode
}
```
`base_layout.module.scss` - SCSS-модуль
```
@import '../../styles/variables.scss';
.default {
background-color: $white;
}
```
`base_layout.tsx` - сам компонент
```
import { BaseLayoutProps } from './base_layout.props';
import styles from './base_layout.module.scss';
export const BaseLayout = ({ children }: BaseLayoutProps): JSX.Element => {
return (
{children}
);
};
```
Теперь в `src/layout/index.tsx` создадим HOC (High Order Component), в который добавим и наш компонент `AlertingService`:
```
import { FunctionComponent } from 'react';
import { AlertingService } from 'components/AlertingService';
import { BaseLayout } from './BaseLayout';
export const withLayout = >(Component: FunctionComponent) => {
return function withLayoutComponent(props: T): JSX.Element {
return (
);
};
};
```
HOC готов. Фактически - это функция, которая принимает в себя компонент страницы (или любой другой компонент) и возвращает его обернутую версию. Обогащенную (в нашем случае) еще и дополнительным компонентом.
Теперь пришла пора изменить код компонента страницы, убрав из него `AlertingService` и добавив использование HOC:
```
import { success, error, warning, info } from 'services/alerting_service';
import { withLayout } from 'layout';
import { Button } from 'components/Button';
import { CenteredVerticalForm } from 'components/CenteredVerticalForm';
const Home = (): JSX.Element => {
return (
NextJS+RxJS Alerting service
success('Success message', 3)}>Success
error('Error message', 10)}>Error
warning('Warning message', 5)}>Warning
info('Info message')}>Info
);
};
export default withLayout(Home);
```
Теперь уже - совсем всё. Теперь каждая страница, обернутая в HOC (а в хотя бы относительно большом приложении это - вообще каждая страница), в неявном виде теперь содержит `AlertingService`, отправлять алерты в который можно простым вызовом из любого обработчика события или эффекта хелперы `success`, `error`, `warning` и `info`, устанавливая для каждого отдельного кейса необходимое сообщение и таймаут. А сервис алертингов позаботится обо всем остальном.
### Заключение
Сегодня мы реализовали достаточно полезную штуку, и даже выполнили все Acceptance Criteria, что очень даже неплохо. Данный подход можно использовать в любых ситуациях, когда необходимо создать канал связи между компонентами, без необходимости проброса пропсов и событий. Способ не претендует на silver bullet, лишь является одним из возможных вариантов решения определенной задачи.
Спасибо за внимание! | https://habr.com/ru/post/590377/ | null | ru | null |
# Linux: Приучаем Time Machine к домашнему серверу
Поставил себе задачу — бэкапить свой iMac при помощи Time Machine на домашний сервак под Gentoo
emerge net-fs/netatalk
nano /etc/netatalk/netatalk.conf
`Оставляем только нужное
ATALKD_RUN=no
PAPD_RUN=no
CNID_METAD_RUN=yes
AFPD_RUN=yes
TIMELORD_RUN=no
A2BOOT_RUN=no`
nano /etc/netatalk/afpd.conf
`в конце файла дописываем
- -noddp -advertise_ssh`
nano /etc/netatalk/AppleVolumes.default
`в конце файла дописываем шары
/mnt/sdb/TimeMachine TimeMachine allow:@users
(точка монтирования - имя - пользователи)`
/etc/init.d/atalk start
tail /var/log/messages (смотрим, нет ли ошибок)
rc-update add atalk default (добавляем в автозагрузку)
я не стал морочится с настройкой Avahi что бы поднять Bonjour (эта зараза слишком много хочет вместе с собой), по этому переходим к настройке MacOS
Проверяем всё ли работает
Finder — Go — afp://сервер/TimeMachine
после ввода имени/пароля всё должно нормально подмонтироваться
далее, капсула сама не хочет нормально работать, по этому заставляем её ручками, открываем консоль и пишем:
hdiutil create -size 160g -fs HFS+J -volname “TimeMachine” имя\_мак\_компа\_мак\_адрес\_мак\_компа.sparsebundle
в ответ получаем:
created: /Users/имя\_пользователя/имя\_машины\_001ec20a3330.sparsebundle
далее:
cp -r /Users/имя\_пользователя/имя\_машины\_001ec20a3330.sparsebundle /Volumes/TimeMachine/имя\_машины\_001ec20a3330.sparsebundle
и закрываем терминал
теперь всё должно прекрасно работать, сам сижу заливаю 106Гб :) | https://habr.com/ru/post/59605/ | null | ru | null |
# BI с Redshift от ETL до бордов
Привет, Хабр, я Node.js разработчик, и я хочу поделиться с вами опытом по реализации business intelligence (BI) процесса.
В какой-то момент бизнес вырос до размера, пусть и небольшого, когда считать различные цифры и проводить аналитику в excel таблицах уже сложно и медленно, да и количество людей работающих с данными значительно выросло. Тогда зашла речь об автоматизации этого процесса и визуализации различного рода аналитики. Так мы подошли к мысли, что пора реализовывать BI внутри компании.
BI - это просто набор механизмов, технологий для сбора, анализа и визуализации данных.
### Немного о бизнесе
У нас есть заказы (orders), которые создаются в лабораториях. У этих заказов есть различные этапы (statuses) их обработки, бизнесу интересно понимать скорость обработки этих заказов, т.е. время перехода из одного статуса в другой, соотношение количества результатов заказов к общему количеству.
### Выбор хранилища
В качестве главного хранилища мы используем не реляционную базу данных Cassandra. Для нашего BI она нам не подходит, т.к. она не предназначена для аналитики данных. У нее есть свой язык CQL (Cassandra Query Language), но он сильно урезан относительно SQL. к тому же мы используем такую схему данных, когда у нас в одной колонки хранится ID объекта, а в другой хранится JSON объекта. С такой схемой далеко в аналитику не уедешь.
Т.к. у нас вся архитектура лежит в AWS, наш взор сразу пал на Redshift. Изучив ее особенности мы решили, что для наших задач ее функционала хватит более чем. Мы не занимались здесь глубокой аналитикой и сравнением Redshift с другими решениями, такими как ClickHouse, BigQuery, Azure.
### ETL для Redshift
Разработчики заранее [дают](https://docs.aws.amazon.com/redshift/latest/dg/r_INSERT_30.html) нам понять, что подход, когда мы в режиме реального времени пишем данные в БД с Redshift не прокатит. Лучший [способ](https://docs.aws.amazon.com/redshift/latest/dg/c_best-practices-use-copy.html) доставки данных в хранилище это копирование из S3 файлов в формате csv.
Этот способ невероятно быстрый за счет того, что позволяет обрабатывать файлы [параллельно](https://docs.aws.amazon.com/redshift/latest/dg/c_best-practices-use-multiple-files.html), но есть и некоторые ограничения. Файлов должно быть немного, желательно столько сколько у вас развернуто node Redshift, чтобы файлы обрабатывались параллельно и размер файлов должен быть от 1 - 125 МБ.
Подумав над всеми этими рекомендациями, мы поняли, что нам нужна реализация, которая будет писать данные в файлы, а затем заливать их в файловое хранилище AWS S3 и дальше перемещать уже в хранилище Redshift.
Первая серьезная проблема с которой мы столкнулись это то, что обновлять данные будет очень сложно и дорого как по времени, так и по ресурсам. Исходя из этого, мы поняли, что нам нужно записывать данные в разных состояниях, опираясь на какие-то события в системе, а уже по дате создания записи фильтровать их. Важно, что дата создания (timestamp) !== дате добавления строки в БД, т.к. мы пишем данные пачками.
Таким образом, каждая таблица у нас содержит данные об объекте в разный промежуток времени и выглядят они примерно так:
### Сервис для подготовки данных (service-redshift)
Давайте реализуем сервис таким образом, чтобы он прослушивал все события, которые прилетают в брокер и решал, надо ли ему записать объект из события, взяв определенные поля, или на его основе сделать какую-то запись.
В наш брокер прилетают сообщения (events) в формате:
```
some_event: {
method: POST,
current_state: { object_type: order_status, … },
previous_state: { - }
},
another_some_event: {
method: PATCH,
current_state: { object_type: order, status: received, … },
previous_state: { object_type: order, status: created, … }
},
```
Мы можем подключить наш сервис к брокеру и реагировать на события. Давайте напишем функцию, которая будет реагировать на метод PATCH у event на конкретный тип объекта requisition.
```
// index.js
const handlers = {
"PATCH order": require("./order").onPatch,
}
const onHandleEvent = async (event) => {
await handlers[`${event.method} ${event.object_type}`]();
}
```
Теперь опишем обработчик для объекта requisition
```
// order.js
const onPatch = async event => {
...
}
```
В эту функцию у нас прилетает event с типом объекта requisition и его предыдущим и текущим состоянием. Теперь мы можем сформировать какой-нибудь объект из полученных данных и отправить его в **промежуточное** хранилище. У нас могут быть разные события на один и тот же объект, поэтому давайте реализуем функцию, которая будет формировать объект независимо от того какой метод отработал.
```
// collector_order.js
const onHandleOrder = event => {
//здесь могут быть какие-то расчеты полей, но у этого объекта
//все будет просто
return {
id: event.id,
status: event.status,
created_at: event.created_at,
};
};
// order.js
const onPatch = async event => {
const order = onHandleOrder(event);
await sendToTempStore(order);
};
```
### Промежуточное хранилище
Определимся теперь, где нам промежуточно хранить данные перед их отправкой в S3. Можно было бы писать прямо в S3 файлы, но:
1. В файлы нельзя проводить дописывание
2. Если бы мы загружали туда по одному файлу, а потом собирали их и где-то агрегировали, тогда наш алгоритм работал бы медленно
Т.к. мысль с файлами нас еще не покинула, наш взор пал на технологию AWS EFS. Но прошерстив документацию, стало понятно, что возникнет проблема с чтением маленьких файлов, а записывать все в один будет не так быстро, как хотелось бы.
И тут мы наконец-то добрались до самого быстрого хранилища - оперативная память, а именно: Redis.
Соберем брокер, service\_redshift, Redis и сам Redshift в одну единую схему:
Было решено, что данные будут ходить в Redshift раз в какой-то промежуток времени (Migration шаг в схеме). Значит, что за это время данные должны полежать в Redis, а во время боя курантов перебраться в файлы и отправиться в S3.
В Redis нужно каким-то образом искать данные для отправки, не зная их ID. Лучший вариант был - это сложить все данные в Set, а затем найти нужный Set и перебрать его значения. Сами данные будут представлять из себя строчки, связанные запятой, так сказать, подготовились к формату csv.
Чтобы легче всего было найти нужные данные в Redis мы воспользовались маской для ключа вот такого вида: table\_name-YYYY-MM-DD-HH. Таким образом, мы можем в назначенное время, зная имена конечных таблиц, найти все необходимые нам данные.
Адаптируем функцию обработки объекта по методу, добавив запись в Redis
```
// temp_store.js
const moment = require("moment");
const redis = require("./connected_redis");
const generateKeyName = (data, tableName) => {
const date = moment().format('YYYY-MM-DD-HH');
return `${tableName}-${date}`;
}
const sendToTempStore = async (order, tableName) => {
const row = Object.values(order)
.push(new Date().toISOString()) // Это наша колонка timestamp, она всегда идет в конце
.join(",");
const key = generateKeyName(row, tableName);
// В случае отсутсвия Set, редис сам создаст его
// Поэтому никаких дополнительных проверок тут не надо
await redis.rPush(key, row);
}
// order.js
const onPatch = async event => {
const order = onHandleOrder(event);
await sendToTempStore(order, "orders");
};
```
В конечно итоге мы получаем Set с нашими объектами для определенной таблицы
### Миграция в Redshift
Собрав данные в Redis, мы раз в период начинаем их оттуда извлекать и записывать в файлы, причем, не забывая о рекомендациях документации о размере и количестве файлов.
Алгоритм действия будет у нас выглядеть таким образом:
Берем все сеты, которые есть в Redis (мы выделили отдельный Redis под эти манипуляции, а значит лишнего не захватим). Перебираем все таблицы, создаем папку под каждую таблицу, туда мы будем складывать файлы для последующей миграции. Отбираем набор сетов для таблицы, убираем тот, который не равен текущему часу (почему так чуть подробнее ниже), остальные складываем в структуру данных Map.
Теперь берем каждую таблицу и все ее сеты. Так как в сете у нас может быть много записей, ограничим обработку до 100к, т.к. одна запись примерно 102 bytes, значит 100к ~ 10 MB. Таким образом контролируем память. Если записей больше, чем 100к, разбиваем на чанки, записывая пограничные индексы. В конечном счете записываем данные в файлы по сетам.
После того, как мы собрали файлы из сетов, можем переносить это все в S3, а затем переносим это в Redshift, используя команду COPY.
Стоит отметить, что сервис не работает постоянно, он представляет из себя контейнер ECS, который запускается по расписанию, что как раз в 2-ом пункте позволяет нам не писать никуда никакие интервалы. Интервал контролируется временем запуска.
### Визуализация данных
К визуализации данных мы уже подошли, сравнивая различные решения. Выбор стоял между двумя - Redash, Metabase.
Tableau отпало, т.к. инструмент слишком мощный и у нас просто нет необходимости в большой части его функционала.
Grafana рассматривалась, но вскоре мы решили, что для рядовых пользователей этот инструмент будет слишком тяжелым.
Есть две ключевые особенности, которые были главными аргументами в пользу одного из решений (Redash vs Metabase).
Redash имеет такую архитектуру, что при выполнение какого либо запроса, он не ждет ответа в браузере от своего сервера, который в свою очередь ждет ответа от базы данных. Вместо этого он создает Job, которая ждет выполнения запроса и с браузера клиента он проверяет ее статус. Когда Job завершилась, он берет результат и показывает в дашборде.
Metabase посылает запрос к своему сервису и ждет результата до последнего, если у вас стоит какой-то балансировщик или прокси сервер, который отбрасывает запросы, если они идут дольше 60 секунд, вы испытаете вот [такую](https://github.com/metabase/metabase/issues/12423) проблему.
Redash обладает еще одной особенностью, он позволяет выстраивать графики опираясь на один запрос, в то время как Metabase нужно иметь отдельный запрос на каждый график.
В ходе долгой дискуссии мы все же решили, что с точки зрения пользователя, гораздо удобнее будет использовать Metabase, не смотря на, с нашей точки зрения, техническое превосходство Redash.
С инструментом определились, осталось сформировать запросы, учитывая, что мы храним данные в разных состояниях.
Мы используем [materialized view](https://docs.aws.amazon.com/redshift/latest/dg/materialized-view-overview.html), чтобы не собирать постоянно данные с разных таблиц при помощи join, т.к. этот процесс на большом количестве данных и связей достаточно медленный. Оно представляет из себя таблицу, собранную из разных таблиц воедино. Эта таблица имеет возможность обновляться автоматически по мере обновления данных в таблицах, из которых она соткана. Если таблицы начинают обновляться друг за другом, materialized view обновиться лишь один раз, когда закончатся обновления всех таблиц. Сам запрос выглядит примерно так:
```
create view orders_mv
(order_id, status, created_at)
as
CREATE MATERIALIZED VIEW orders_mv AUTO REFRESH YES
AS
(
with order_v as (
SELECT o.order_id,
o.status,
o.created_at,
FROM (SELECT o.order_id,
o.status,
o.created_at,
// Здесь мы как раз проводим фильтрацию, отбирая только последнее состояние заказа в БД
pg_catalog.row_number() OVER (PARTITION BY o.order_id ORDER BY o."timestamp" DESC) AS row_num
FROM orders o
) o
WHERE o.row_num = 1
```
### Подытожим
У нас получилось собрать конструкцию из сервиса и скрипта, который запускается по расписанию, воссоздав таким образом свой процесс ETL.
У него есть один минус, который мы видим сразу же - чем больше данных (колонок) мы хотим видеть в момент их выставления у объектов, тем больше записей мы получим на выходе в Redshift. Например, у ордера мы хотим видеть 2 промежуточных состояния, когда выставится some\_column\_one и some\_column\_two, таким образом, мы получим две записи:
Но при текущем количестве данных (<10кк в час) нас вполне устраивает это решение, а когда мы доберемся до больших цифр, мы начнем свой переезд в AWS Kenesis. Думаю мы еще обязательно поделимся этим опытом с вами. | https://habr.com/ru/post/669240/ | null | ru | null |
# Сделайте свое приложение масштабируемым, оптимизировав производительность ORM
***Перевод статьи подготовлен в преддверии старта курса [«Backend-разработчик на PHP»](https://otus.pw/8haY/).***
---
Привет! Я Валерио, разработчик из Италии и технический директор платформы `Inspector.dev`.
В этой статье я поделюсь набором стратегий оптимизации ORM, которые я использую, разрабатывая сервисы для бэкенда.
Уверен, каждому из нас приходилось жаловаться, что сервер или приложение работает медленно (а то и вовсе не работает), и коротать время у кофемашины в ожидании результатов длительного запроса.
Как это исправить?
Давайте узнаем!
### База данных — это общий ресурс
Почему база данных вызывает столько проблем с производительностью?
Мы часто забываем, что ни один запрос не является независимым от других.
Мы думаем, что даже если какой-то запрос выполняется медленно, он едва ли влияет на другие… Но так ли это на самом деле?
База данных — это общий ресурс, используемый всеми процессами, которые выполняются в вашем приложении. Даже один плохо спроектированный метод обращения к базе данных может нарушить производительность всей системы.
Поэтому не забывайте о возможных последствиях, думая: «Ничего страшного, что этот фрагмент кода не оптимизирован!» Одно медленное обращение к базе данных может привести к ее перегрузке, а это, в свою очередь, может негативно сказаться на работе пользователей.
### Проблема N+1 запроса к базе данных
В чем состоит проблема N+1?
Это типичная проблема, возникающая при использовании ORM для взаимодействия с базой данных. Она не связана с написанием кода на SQL.
При использовании системы ORM, такой как Eloquent, не всегда очевидно, какие запросы будут выполняться и когда. В контексте этой конкретной проблемы давайте поговорим об отношениях и безотложной загрузке (eager loading).
Любая система ORM позволяет объявлять отношения между сущностями и предоставляет отличный API для навигации по структуре базы данных.
Ниже приведен хороший пример для сущностей «Статья» (Article) и «Автор» (Author).
```
/*
* Each Article belongs to an Author
*/
$article = Article::find("1");
echo $article->author->name;
/*
* Each Author has many Articles
*/
foreach (Article::all() as $article)
{
echo $article->title;
}
```
Однако при использовании отношений внутри цикла нужно писать код осторожно.
Взгляните на приведенный ниже пример.
Мы хотим добавить имя автора рядом с названием статьи. Благодаря ORM можно получить имя автора, используя отношение типа «один-к-одному» между статьей и автором.
Кажется, все просто:
```
// Initial query to grab all articles
$articles = Article::all();
foreach ($articles as $article)
{
// Get the author to print the name.
echo $article->title . ' by ' . $article->author->name;
}
```
Но тут-то мы и попали в ловушку!
**Этот цикл генерирует один начальный запрос для получения всех статей:**
```
SELECT * FROM articles;
```
**и еще N запросов, чтобы получить автора каждой статьи и вывести значение поля «имя» (name), даже если автор всегда один и тот же.**
```
SELECT * FROM author WHERE id = [articles.author_id]
```
**Получаем ровно N+1 запрос.**
Это может показаться не такой уж важной проблемой. Ну, сделаем пятнадцать-двадцать лишних запросов — не страшно. Однако давайте вернемся к первой части этой статьи:
* База данных — это ресурс, совместно используемый всеми процессами.
* Сервер базы данных имеет ограниченные ресурсы, а если используется управляемый сервис, то более высокая нагрузка на базу данных может привести к более высоким денежным расходам.
* Если база данных размещена на отдельном физическом сервере, все данные будут передаваться с дополнительной сетевой задержкой.
### Решение: использовать безотложную загрузку
Согласно документации Laravel существует немалая вероятность столкнуться с проблемой N+1 запроса, потому что при обращении к отношениям Eloquent как к свойствам (`$article->author`) происходит «ленивая загрузка» (lazy loading) данных отношений.
**Это означает, что данные отношений не загружаются, пока вы впервые не обратитесь к свойству.**
Однако, воспользовавшись простым методом, мы можем загрузить все данные отношений сразу. Тогда при обращении к отношению Eloquent как к свойству ORM-система не будет выполнять новый запрос, потому что данные уже были загружены.
Такая тактика называется «безотложной загрузкой» и поддерживается всеми ORM.
```
// Eager load authors using "with".
$articles = Article::with('author')->get();
foreach ($articles as $article)
{
// Author will not run a query on each iteration.
echo $article->author->name;
}
```
Eloquent предлагает метод `with()` для безотложной загрузки отношений.
В этом случае будут выполнены только два запроса.
Первый нужен для загрузки всех статей:
```
SELECT * FROM articles;
```
Второй будет выполнен методом `with()` и извлечет всех авторов:
```
SELECT * FROM authors WHERE id IN (1, 2, 3, 4, ...);
```
Внутренний механизм Eloquent сопоставит данные, и к ним можно будет обращаться обычным способом:
```
$article->author->name;
```
### Оптимизируйте операторы `select`
Долгое время я думал, что явное объявление количества полей в запросе на выборку не приводит к значительному повышению производительности, поэтому для простоты я получал в своих запросах все поля.
Кроме того, жесткое задание списка полей в конкретном операторе select усложняет дальнейшую поддержку такого фрагмента кода.
Самая большая ловушка, которую таит в себе этот аргумент, заключается в том, что с точки зрения базы данных это действительно может быть правдой.
Однако мы работаем с ORM, поэтому данные, выбранные из базы, будут загружены в память на стороне PHP, чтобы далее ими управляла система ORM. Чем больше полей мы захватим, тем больше памяти займет процесс.
Laravel Eloquent предоставляет метод select, позволяющий ограничить запрос только теми столбцами, которые нам нужны:
```
$articles = Article::query()
->select('id', 'title', 'content') // The fields you need
->latest()
->get();
```
После исключения полей интерпретатору PHP не придется обрабатывать лишние данные, поэтому вы сможете значительно снизить потребление памяти.
Отказ от полной выборки может также повысить производительность при сортировке, группировке и объединении, так как и сама база данных может за счет этого экономить память.
### Используйте представления в MySQL
Представления (view) — это SELECT-запросы, построенные на основе других таблиц и хранящиеся в базе данных.
Когда мы выполняем запрос SELECT к одной или нескольким таблицам, база данных вначале компилирует наш SQL-оператор, убеждается, что он не содержит ошибок, а затем выполняет выборку данных.
Представление — это предварительно скомпилированный оператор SELECT, при обработке которого MySQL немедленно выполняет лежащий в основе представления внутренний запрос.
Кроме того, MySQL обычно ведет себя умнее PHP, когда дело касается фильтрации данных. При использовании представлений достигается значительный прирост в производительности по сравнению с использованием функций PHP для обработки коллекций или массивов.
Если вы хотите подробнее изучить возможности MySQL для разработки приложений, интенсивно использующих базу данных, ознакомьтесь вот с этим замечательным сайтом: [www.mysqltutorial.org](https://www.mysqltutorial.org)
### Свяжите модель Eloquent с представлением
Представления также называют «виртуальными таблицами». С точки зрения ORM они выглядят как обычные таблицы.
Поэтому можно создать модель Eloquent для запроса данных, находящихся в представлении.
```
class ArticleStats extends Model
{
/**
* The name of the view is the table name.
*/
protected $table = "article_stats_view";
/**
* If the resultset of the View include the "author_id"
* we can use it to retrieve the author as normal relation.
*/
public function author()
{
return $this->belongsTo(Author::class);
}
}
```
**Отношения работают как обычно, равно как и приведение типов, разбиение на страницы и т. д. И при этом не страдает производительность.**
### Заключение
Надеюсь, что эти советы помогут вам в разработке более надежного и масштабируемого ПО.
Все примеры кода написаны с использованием Eloquent в качестве ORM, но следует иметь в виду, что эти стратегии одинаково работают для всех основных ORM.
Как я часто говорю, инструменты нужны нам для того, чтобы воплощать в жизнь эффективные стратегии. А если нет стратегии, то не о чем и рассуждать.
Большое спасибо, что прочитали статью до конца. Если хотите узнать больше про Inspector, приглашаю на наш сайт [www.inspector.dev](https://www.inspector.dev). Не стесняйтесь писать в чат, если будут вопросы!
*Ранее опубликовано здесь: [www.inspector.dev/make-your-application-scalable-optimizing-the-orm-performance](https://www.inspector.dev/make-your-application-scalable-optimizing-the-orm-performance/)*
[](https://otus.pw/8haY/)
> #### Читать ещё:
>
>
>
> * [Понимаем JIT в PHP 8](https://habr.com/ru/company/otus/blog/509598/)
> | https://habr.com/ru/post/521488/ | null | ru | null |
# STM32 и FreeRTOS. 4. Шаг в сторону HAL
> HAL 9000: I'm completely operational, and all my circuits are functioning perfectly.
*или это должно быть первой статьей, но я почему-то всегда пишу подобное ближе к концу*
Раньше было [про потоки](http://habrahabr.ru/post/249273/), [про семафоры](http://habrahabr.ru/post/249283/) и [очереди](http://habrahabr.ru/post/249381/)
 Одним из основных *препятствий* для перехода на STM32 является обилие текстов, инструкций и мануалов, описывающих работу с контроллером. Виновником этого обилия стала сама STMicroelectronics, которая поначалу планомерно запутывала своих пользователей, а затем предлагала неверные варианты выхода.
Проблема заключается в многообразии выпускаемых контроллеров, которые почему-то требовали разных процедур инициализации даже для одной и той же периферии. И код, работающий на одном контроллере, отказывался работать на другом. В результате по сети гуляют сборники шаманских рецептов, для понимания которых требуется куча времени и воскуривание даташитов.
Но не так давно ST поняла, в какую яму она угодила и начала усиленно из нее выбираться, привлекая новые силы. И именно благодаря этому сейчас время старта сократилось до несуразно маленьких величин. Как это выглядит на практике? Добро пожаловать под кат.
Для начала дам совет, как быстро определить то, что не стоит читать про STM32.
Во-первых, год публикации раньше 2011-2012. Просто поверьте, что «то, что тогда» и «то, что сейчас» — две большие разницы. SPL и HAL в мире STM не просто очередные аббревиатуры.
Во-вторых, если встретится подобный код (это всего лишь кусочек инициализации ADC, если это кому-либо интересно).
```
RCC->APB2ENR |= RCC_APB2ENR_ADC1EN;
ADC1->SMPR2 |= ADC_SMPR2_SMP0 | ADC_SMPR2_SMP1
| ADC_SMPR2_SMP2 | ADC_SMPR2_SMP3 | ADC_SMPR2_SMP4
| ADC_SMPR2_SMP5 | ADC_SMPR2_SMP6 | ADC_SMPR2_SMP7;
ADC1->SQR1 |= ADC_SQR1_L_2 | ADC_SQR1_L_1 | ADC_SQR1_L_0;
ADC1->SQR2 |= ADC_SQR2_SQ8_2 | ADC_SQR2_SQ8_1 | ADC_SQR2_SQ8_0
| ADC_SQR2_SQ7_2 | ADC_SQR2_SQ7_1;
```
В итоге после просмотра такого… великолепия большинство со словами «да ну его нафиг, я уж как-нибудь с pinMode проживу, чем такое городить» закидывало купленную на всякий случай плату в дальний угол ящика стола. Не скрою, я сам таким же был и только большая нужда заставила меня изучать что же скрыто за аббревиатурами CMSIS и SPL. Повторять мой путь сейчас нет совершенно никакого смысла (да и я постарался забыть большую часть того, чего прочитал), ну разве что если у вас очень большое желание добраться до потрохов. Поэтому здесь я рассказываю для тех, кому надо ехать.
Итак, в чем проблема? Главная и единственная проблема — это инициализация периферии. Вон те шаманские пляски с битами возникли не на пустом месте. И 99% проблем «у меня не работает» заключаются именно в неправильной инициализации. Не те частоты, попытка использовать выделенное под другое ресурсы и так далее и тому подобное. Что особо обостряет проблему, так это то, что никаких кодов ошибок или там эксепшенов нет. Все как у сапера: что-то сделал не так — все мертвое.
**Вам кажется, что это сказки? Вот вам рисуночек схемы тактирования STMF3**
Подсчетом мест, где можно ошибиться, предлагаю заняться самостоятельно
В итоге ST выкатила сначала SPL (Standard Peripheral Library), которая хоть улучшила ситуацию, но не сильно. А затем появилась следующая версия, которую обозвали HAL. А что бы еще больше облегчить разработчикам жизнь, была обновлена утилита STM32CubeMX, которая позволила буквально парой кликов мышки сгенерировать код инициализации для всего многообразия плат, процессоров и периферии. А рядышком положила так называемые firmware, в которые запихнула кучу примеров работы именно для данного процессора.
И то, что нажатием двух кнопок можно получить 100% (я ни разу пока не встретился с обратным) рабочий код абсолютно давит мысли «там оптимизировать и оптимизировать»…
 Сама программа построена по привычному всем принципу «выбери мышкой что надо и нажми кнопку». Выбрал одну схему тактирования — программа сразу показала частоты и выделила красным те места, которые с такими частотами работать не могут. Попробовали использовать тот функционал, который в данных условиях невозможен (например, ножка уже занята чем-то другим) — опять подсветит ошибку.
Вот на рисунке слева я показал список функций, которые можно повесить на одну-единственную ножку. После подсчета обычно AVRщики (где 4 функции на ножку — максимум) долго хмыкают и что-то подсчитывают в уме. А когда я им говорю, что таких ножек может быть больше 160 штук, то вообще выпадают в осадок.
Но больше всего меня радует тот факт, что теперь благодаря HAL не надо переписывать код работы с периферией. Если где-то написано
```
НAL_GPIO_WritePin(GPIOA,GPIO_PIN_2,GPIO_PIN_RESET);
```
То я знаю, что на всех доступных на данный момент мне процессорах этот код переведет ножку PA2 в «ноль». И даже написанная функция взятия среднего значения нужного канала АЦП тоже не будет сопротивляться при переходе с L1 на F4
```
int GetADCValue(uint32_t Channel,uint32_t Count)
{
int val = 0;
ADC_ChannelConfTypeDef sConfig;
sConfig.Channel=Channel;
sConfig.Rank=1;
sConfig.SamplingTime=10;
HAL_ADC_ConfigChannel(&hadc,&sConfig);
for(int i = 0; i < Count; i++)
{
HAL_ADC_Start(&hadc);
HAL_ADC_PollForConversion(&hadc,1);
val += HAL_ADC_GetValue(&hadc);
}
return val / Count;
}
```
А теперь немного положенной по канонам магии STM32
Как вы думаете, сколько мне придется приложить усилий, что бы получить из STM32F3 ком-порт в usb, который просто будет возвращать то, что в него послали? Я тут подсчитал — 12 нажатий мышкой (включить USB, выбрать CDC, сгенерировать) и 6 строчек кода в функции CDC\_Receive\_FS (файл usbd\_cdc\_if.с)
```
for (int i = 0; i < *Len; i++)
UserTxBufferFS[i] = UserRxBufferFS[i];
USBD_CDC_SetTxBuffer(&hUsbDeviceFS, &UserTxBufferFS[0], *Len);
USBD_CDC_TransmitPacket(&hUsbDeviceFS);
USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &UserRxBufferFS[0]);
USBD_CDC_ReceivePacket(&hUsbDeviceFS);
```
И примерно так же и с той же сложностью реализуется «звуковая карта», «флешка» или HID. Да, дадут только код инициализации, логику самому писать надо будет, но и это — офигенное подспорье.
Я даже выкладывать проект не буду, ибо толку тащить то, что надеюсь и так уже есть у Вас на компе, но результат покажу.
На вопрос «где бы примерчик взять?» ответ простой — в скачиваемой при генерации «фирмвари» лежит куча примеров. И рекомендую накачать (в менюшке найдете) «фирмварь» для других моделей процессоров — очень часто примеры не пересекаются и тот же «АЦП через DMA» есть только в одном месте, хотя прекрасно работает и там и там.
Отдельным абзацем замечу, что STM32Cube хоть и помогает программисту в быстром старте, она по прежнему требует понимания, что же настраивается и почему именно так настраивается. К примеру, по умолчанию прерывания и DMA для USART выключены, поэтому некоторые функции просто не будут работать. В общем, тщательно смотрите за вкладочками, благо программа позволяет перегенерировать проект, сохранив уже написанное.
*Где-то здесь программисты обычно уже уходят «поуши» в генерацию «чего-то этакого», смену дескрипторов, размеров буферов и смены отображаемого названия в диспетчере задач на «Super Cool Device». Ну и я оставлю Вас с этим*
[Завершаем и приносим пользу](http://habrahabr.ru/post/249975/) | https://habr.com/ru/post/249395/ | null | ru | null |
# Почему для нового проекта я взял Robot Framework
Недавно я сменил проект — пришел в новую разработку, где до меня не было никакого тестирования, ни ручного, ни автоматического. Условий на инструментарий (за исключением того, что это Python) заказчик не накладывал, так что я сделал собственный выбор. В этой статье я расскажу, почему в таких условиях предпочел Robot Framework. А в конце будет немного специально написанных под статью примеров, иллюстрирующих, о чем речь.
Автоматизацией тестирования я занимаюсь уже более 10 лет, а с Robot Framework взаимодействовал порядка трех из них.
Как я отметил выше, не так давно я пришел на новый проект, где начал автоматизацию тестирования с нуля. Подробностей о проекте рассказать не могу — NDA. Отмечу лишь, что это крутой инструмент автоматизации, который в перспективе должен сэкономить массу человеческих ресурсов. Построен он из микросервисов. Пока что моя работа касается четырех из них, но в будущем я расширю свою деятельность и на другие — все упирается в то, что у меня лишь 8 рабочих часов в сутки. На все нужно время.
Отсутствие тестирования в случае этого проекта было тождественно отсутствию рекомендуемого инструментария. В рамках стека Python у меня была свобода выбора. И я ей воспользовался.
Почему Robot Framework?
-----------------------
Думаю, меня можно отнести к поклонникам Robot Framework. Как мне кажется, на нем можно сделать практически все.
На других проектах в компании используется pytest. Однако, на мой взгляд, он не имеет таких возможностей, поскольку ограничен возможностями Python. Ты просто пишешь код на Python и отмечаешь, что в такой-то переменной ожидаешь определенное значение. На мой вкус, это просто, но слишком абстрактно. Очень многое передано на откуп разработчику, которому все полезные фишки придется добавлять руками. Robot Framework делает это сам. Вот четыре момента, которые стоят того, чтобы взять его к себе на проект.
### Гибкость
Robot Framework сам написан на Python (т.е. может все, что может Python), и для него есть множество библиотек, созданных сообществом, что многократно расширяет спектр решаемых проблем.
Под Robot Framework можно легко писать свои библиотеки, интегрировав его практически с чем угодно, и все будет сразу работать. Не потребуется никаких костылей и велосипедов.
А кроме того, Robot Framework позволяет писать параметрические тесты (шаблоны), что сильно ускоряет работу автоматизатора.
### Русский язык в тестах
Один из принципиальных моментов — то, что keyword (аналоги обычных методов в Robot Framework, которые исторически почему-то называют именно так) можно писать по-русски. В результате тексты тестов, конечно, далеки от литературного языка, но с первого взгляда становится понятно, что там происходит. Нужно это в первую очередь не конечным разработчикам, а, например, стейкхолдерам. Они могут самостоятельно открывать тесты и видеть, что именно там происходит: “Выбрать случайный элемент из…” и т.п.
### Тегирование
Robot Framework хорошо работает с тегами. Можно не только запускать тесты с определенным тегом, но и анализировать с их помощью отчеты. Лог-файл содержит статистику по тегам, на основе которой можно предпринимать какие-то действия, если продумать расстановку тегов заранее.
Удобно, что не нужно в каждом тесте писать все теги в длинную портянку, а можно вложить тесты в древовидную структуру. В моем случае это выглядит так: первый уровень — микросервис, второй — вид теста, третий — сами тесты (удобно положить init-файл, содержащий теги для того, что вложено внутрь).
У себя я создал тег для каждого микросервиса, каждого тестового подхода (smoke-тесты, CRUD-тесты, интеграция и т.п.). Могу запустить тесты конкретного вида или только для конкретного сервиса. Также я тегирую вид функции — списковые или детализированные. И если в продукте “ломается” функционал, отвечающий за списковые функции, все тесты с этим тегом станут красными, несмотря на то, где они расположены и к чему относятся.
Тегами я осуществляю привязку автотестов к Jira. Когда баг из трекера закрывается, а тест из красного становится зеленым, у нас остается история, что именно изменилось. Спустя много месяцев, если тест снова станет красным, мы сможем увидеть, какие действия были предприняты для исправления проблемы в прошлый раз, и даже предположить, что привело к повторному воспроизведению бага.
Еще один специальный тег у меня добавлен для некритичных багов. GitLab не дает нам ничего делать со сборкой, если падает хотя бы один тест. Это логично — пока все баги не исправятся, мы не можем выпустить продукт или даже недельный спринт. Но низкоприоритетные и незначимые баги есть и у нас. Для них-то я и выделил тег, позволяющий Robot Framework не ронять всю сборку, если конкретно эти тесты (тесты с этим тегом) не проходят.
### Отличный лог
Анализ логов — неотъемлемая часть тестирования. Что бы ни происходило в момент выполнения тестов, Robot Framework пишет абсолютно все. Вплоть до того, что мне пришлось писать специальную обертку, которая скрывает из лога логин и пароль для подключения к базе.
Такая детализация помогает намного быстрее понять, в чем причина падения теста — тестируемая система неправильно работает или в тесте что-то не учтено и его нужно исправить? Ответ на этот вопрос не всегда очевиден. Ошибки разработчиков и тестировщиков распределяются 50/50.
В других инструментах — в том же pytest — можно формировать такой же подробный лог. Но там задача его генерации ложится на плечи разработчика, который пишет тесты. Ему нужно продумать, какие записи в логе действительно нужны.
Что есть на проекте уже сейчас
------------------------------
С того момента, как я начал использовать Robot Framework, прошло уже несколько месяцев. На данный момент на Robot Framework реализовано более 200 тестов и, как было упомянуто выше, есть интеграция с GitLab, которая помогает проверять вносимые в разрабатываемый продукт изменения (тест-кейсы с идентификаторами, позволяющими привязать к ним автотесты, хранятся в testrail).
Для расчета покрытия я написал утилиту, которая берет из Swagger список API бэкенда и сопоставляет его с тем, что было протестировано. Таким образом, у нас есть четкое понимание покрытия в текущий момент времени. К примеру, мы знаем, что сегодня этот микросервис покрыт целиком, а другой — на 98%. А после добавления новой функциональности, которая еще не отражена в тестировании, покрытие падает. Соответственно, можно спланировать, чтобы на следующий спринт я реализовал автотесты.
Естественно, проект развивается дальше. Например, сейчас мы разворачиваем мок-сервер (о том, что это такое и зачем нужно, [мой коллега уже писал на Хабре](https://habr.com/ru/company/maxilect/blog/430530/)).
А теперь к практике
-------------------
Приведенные примеры созданы специально для статьи, чтобы проиллюстрировать изложенные выше идеи. Если вы захотите поэкспериментировать с этими примерами собственноручно, все они выложены [в нашем репозитории](https://github.com/maxilect/robot-framework-examples).
### Пример самого простого теста
Начнем с самого простого теста на Robot Framework.
В примере ниже сначала создается сессия до некого заведомо доступного ресурса (в нашем случае — [en.wikipedia.org/wiki](https://en.wikipedia.org/wiki)). Вызывая Get корня (/), мы проверяем код состояния 200.
```
*** Settings ***
Documentation Пример smoke-автотеста.
Library RequestsLibrary
*** Variables ***
${base_url} https://en.wikipedia.org/wiki
${url} /
*** Test Cases ***
Проверить доступность Wiki
Create session conn ${base_url} disable_warnings=1
${response} Get request conn ${url}
Delete all sessions
Should be equal ${response.status_code} ${200}
```
### Шаблонные (параметрические) тесты
Robot Framework позволяет создавать шаблоны тестов. Если мы переведем тест из предыдущего примера в шаблонный вид, то сможем его легко масштабировать, добавляя вызовы с нужными аргументами. Для примера проверим ответ 200 для страниц с биографиями ученых.
```
*** Settings ***
Documentation Пример smoke-автотеста. С использованием шаблона теста.
... Шаблонные тесты легко масштабируются.
Library RequestsLibrary
Test Setup Создать соединение
Test Teardown Закрыть все соединения
Test Template Smoke-тест
*** Variables ***
${base_url} https://en.wikipedia.org/wiki
*** Test Cases ***
Проверить доступность страницы о Ньютоне
/Isaac_Newton
Проверить доступность страницы об Эйнштейне
/Albert_Einstein
Проверить доступность страницы о Хокинге
/Stephen_Hawking
*** Keywords ***
Создать соединение
Create session conn ${base_url} disable_warnings=1
Закрыть все соединения
Delete all sessions
Smoke-тест
[Arguments] ${url}
${response} Get request conn ${url}
Should be equal ${response.status_code} ${200}
```
### Тегирование и чтение логов
Продолжаем совершенствовать простейший тест.
Имея шаблон как единую точку входа, мы можем легко добавить проверку года рождения ученого. Так мы подтверждаем, что загруженная страница отображает правильные данные.
Кроме того, в примере ниже я обернул существующие keyword в русские названия – на мой вкус, так тест читается органичнее. Меня как тестировщика всегда раздражали методы, названные «как бы по-английски», но совершенно безграмотно. Всегда лучше писать на том языке, который знаешь.
```
*** Settings ***
Documentation Пример smoke-автотеста. С использованием шаблона теста.
... Шаблонные тесты легко масштабируются.
... Шаблонные тесты так же легко расширяются.
... Добавлено тэгирование.
Library RequestsLibrary
Test Setup Создать соединение
Test Teardown Закрыть все соединения
Test Template Smoke-тест
*** Variables ***
${base_url} https://en.wikipedia.org/wiki
*** Test Cases ***
Проверить доступность страницы о Ньютоне
[Tags] Newton
/Isaac_Newton 1642
Проверить доступность страницы об Эйнштейне
[Tags] Einstein
/Albert_Einstein 1879
Проверить доступность страницы о Хокинге
[Tags] Hawking
/Stephen_Hawking 1942
Проверить доступность несуществующей страницы (для отображения ошибки)
[Tags] Numbers
/123456789 1899
*** Keywords ***
Создать соединение
Create session conn ${base_url} disable_warnings=1
Закрыть все соединения
Delete all sessions
Smoke-тест
[Arguments] ${url} ${expected_word}
${response} Get request conn ${url}
Should be equal ${response.status_code} ${200}
... msg=При выполнении GET ${url} был получен код состояния, отличный от 200 ОК.
Проверить наличие слова на странице ${response.text} ${expected_word}
Проверить наличие слова на странице
[Arguments] ${text} ${expected_word}
Should contain ${text} ${expected_word} msg=Не найдено искомое слово ${expected_word}!
```
Обратите внимание на `[Tags]`. Сюда можно внести теги, которые, как я писал выше, помогут оценить проблемы на уровне отчета. Аналогично `Force Tags` в файле \_\_init\_\_.robot (см. пример [в нашем репозитории](https://github.com/maxilect/robot-framework-examples)) позволяет задать теги для всех тестов в директории, включая вложенные. Если тегирование выполнено правильно, даже не читая названий самих тестов и не залезая в их логику, можно довольно точно предположить, что именно не работает в тестируемом проекте.
Посмотрите на отчет о запуске этих тестов. Для наглядности я добавил тест, который будет находить ошибку.
Статистика отчета — его самая важная часть.
В нашем примере полностью не прошли тесты с тегом `numbers` (1 из 1 у нас, а в реальной жизни будет, например 17 из 20). Можно предположить, что проблема именно в этой странице.
Теги помогают запускать тесты выборочно. Для запуска всех тестов с конкретным тегом в строке запуска необходимо указать:
```
--include
```
Поддерживаются даже логические операции с тегами:
```
-- include AND
```
Например, если нужно запустить только Smoke тест для тестов с тегом numbers, следует добавить:
```
--include smokeANDnumbers
```
### Некритические тесты
Перейдем к хитростям, которые здорово упрощают работу.
Разметив тест тегами, можно определить один или несколько из них как “некритичные”. Тест с таким тегом всё равно будет показывать наличие ошибок (если они есть), но в итоге эти ошибки не будут трактоваться как «недопустимые». Я пользуюсь этой опцией, когда некие минорные баги учли, занесли в баг-трекер, но пока не исправили. Без нее автотесты, включенные в CI, при обнаружении подобных известных проблем не дадут собрать проект, а это не всегда удобно.
Добавим новый тест:
```
Проверить доступность несуществующей страницы (для демонстрации некритичных ошибок)
[Tags] Letters Known
/abcdefghi 1799
```
При запуске добавленный тег определим как «некритичный», используя ключ:
```
--noncritical Known
```
### Keyword на python
Следующим примером я проиллюстрирую, как добавить свою библиотеку.
Создадим новый keyword “Генерировать массив чисел”. Его назначение очевидно (за это я и люблю русские названия).
```
from random import randint
from typing import List
from robot.api.deco import keyword
class ArrayGeneratorLibrary:
ROBOT_LIBRARY_SCOPE = 'GLOBAL'
@keyword("Генерировать массив чисел")
def generate_array(self, length: int, minimal: int, maximal: int) -> List[int]:
result = []
for i in range(int(length)):
result.append(randint(int(minimal), int(maximal)))
return result
```
Подключаем библиотеку в тесте:
```
Library libraries.ArrayGeneratorLibrary
```
и используем ее:
```
Работа с библиотекой, написанной на python.
${array} Генерировать массив чисел ${5} ${2} ${8}
Log to console ${array}
```
Не забудьте, что если у вас вложенная структура, разделять ее следует точками, как в примере.
Еще небольшая хитрость: цифры, переданные в `${}`, трактуются как int, а не как строки!
#### Встроенные аргументы
Еще одна приятная вещь — встроенные аргументы, которые передаются не в конце вызова, как обычно, а прямо в его теле.
Для иллюстрации напишем обертку для созданного выше генератора массивов, позволяющую использовать встроенные аргументы:
```
Сгенерировать ${n} чисел, от ${from} до ${to}
${result} Генерировать массив чисел ${n} ${from} ${to}
[Return] ${result}
```
Теперь можно писать так:
```
Пример обёртки и метода со встроенными аргументами.
${array} Сгенерировать 5 чисел, от 2 до 8
Log to console ${array}
```
### Подмена части имени метода, вставка python и циклы
Следующая хитрость, которая мне очень нравится в Robot Framework, – подмена части имени. Допустим, у нас есть два метода: один выбирает четные числа, другой – нечетные.
```
Найти чётные числа в списке
[Arguments] ${list}
${evens} Evaluate [i for i in $list if i % 2 == 0]
[Return] ${evens}
Найти нечётные числа в списке
[Arguments] ${list}
${odds} Evaluate [i for i in $list if i % 2 != 0]
[Return] ${odds}
```
Использованный выше keyword `Evaluate` позволяет выполнить строчку кода python «прямо здесь». Обратите внимание, если вы не хотите заменить кусок строки содержимым переменной, а именно передать ссылку на нее, то следует указывать имя переменной сразу за знаком `$` без фигурных скобок!
А вот так можно вызвать оба метода, подменив различающуюся часть их названия:
```
Пример передачи части названия метода, в виде параметра. Цикл.
${types} Create list чётные нечётные
${array} Сгенерировать 5 чисел, от 12 до 28
FOR ${type} IN @{types}
${numbers} Run keyword Найти ${type} числа в списке ${array}
log to console ${numbers}
END
```
### Декораторы методов
Да, Robot Framework позволяет написать декоратор для других keyword!
В качестве иллюстрации этой возможности напишем декоратор, который выбирает отрицательные числа в ответе любого метода, возвращающего список.
```
Найти отрицательные числа в ответе, вызвав
[Arguments] ${keyword} @{args} &{kwargs}
${list} Run keyword ${keyword} @{args} &{kwargs}
${negs} Evaluate [i for i in $list if i < 0]
[Return] ${negs}
```
Обратите внимание:
`@{args}` – это все неименованные аргументы;
`&{kwargs}` – это все именованные аргументы.
Имея эту связку, можно перенаправить их, фактически создав декоратор.
Работа с декоратором будет выглядеть так:
```
Пример декоратора метода
${negs} Найти отрицательные числа в ответе, вызвав Генерировать массив чисел 10 -5 5
log to console ${negs}
```
Вместо заключения
-----------------
В примерах выше я показал основные возможности Robot Framework, которые существенно облегчают жизнь. Но этим списком его фишки не ограничиваются.
Если у вас будут какие-то вопросы, пишите в комментариях. Мы выделим основное направление читательского интереса и ответим на вопросы продолжением текста.
Автор статьи: Владимир Васяев.
P.S. Мы публикуем наши статьи на нескольких площадках Рунета. Подписывайтесь на наши страницы в [VK](https://vk.com/maxilect), [FB](https://www.facebook.com/maxilectru/) или [Telegram-канал](https://t.me/maxilect), чтобы узнавать обо всех наших публикациях и других новостях компании Maxilect. | https://habr.com/ru/post/470924/ | null | ru | null |
# Честный MVC на React + Redux
[](https://habrahabr.ru/company/devexpress/blog/305812/)
Эта статья о том, как построить архитектуру web-приложения в соответствии с принципами MVC на основе [React](https://github.com/facebook/react) и [Redux](https://github.com/reactjs/redux). Прежде всего, она будет интересна тем разработчикам, кто уже знаком с этими технологиями, или тем, кому предстоит использовать их в новом проекте.
Model-View-Controller
=====================
Концепция MVC позволяет разделить данные (модель), представление и обработку действий (производимую контроллером) пользователя на три отдельных компонента:
1. Модель (англ. Model):
* Предоставляет знания: данные и методы работы с этими данными;
* Реагирует на запросы, изменяя своё состояние;
* Не содержит информации, как эти знания можно визуализировать;
2. Представление (англ. View) — отвечает за отображение информации (визуализацию).
3. Контроллер (англ. Controller) — обеспечивает связь между пользователем и системой: контролирует ввод данных пользователем и использует модель и представление для реализации необходимой реакции.
React в роли View
=================
[React.js](https://facebook.github.io/react/) это фреймворк для создания интерфейсов от Facebook. Все аспекты его использования мы рассматривать не будем, речь пойдет про Stateless-компоненты и React исключительно в роли View.
Рассмотрим следующий пример:
```
class FormAuthView extends React.Component {
componentWillMount() {
this.props.tryAutoFill();
}
render() {
return (
Submit
);
}
}
```
Здесь мы видим объявление компонента FormAuthView. Он отображает форму с двумя Input-ами для логина и пароля, а также кнопку Submit.
FormAuthView это Stateless-компонент, т.е. он не имеет внутреннего состояния и все данные для отображения получает исключительно через Props. Также через Props этот компонент получает и Callback-и, которые эти данные меняют. Сам по себе этот компонент ничего не умеет, можно назвать его "Глупым", так как никакой логики обработки данных в нем нет, и сам он не знает, что за функции он использует для обработки пользовательских действий. При создании компонента он пытается использовать Callback из Props для автозаполнения формы. Про реализацию функции автозаполнения формы этому компоненту тоже ничего неизвестно.
Это пример реализации слоя View на React.
Redux в роли Model
==================
Redux является предсказуемым контейнером состояния для JavaScript-приложений. Он позволяет создавать приложения, которые ведут себя одинаково в различных окружениях (клиент, сервер и нативные приложения), а также просто тестируются.
Использование Redux подразумевает существование одного единственного объекта Store, в State которого будет хранится состояние всего вашего приложения, каждого его компонента.
Чтобы создать Store, в Redux есть функция createStore.
```
createStore(reducer, [preloadedState], [enhancer])
```
Её единственный обязательный параметр это Reducer. Reducer это такая функция, которая принимает State и Action, и в соответствии с типом Action определенным образом модифицирует иммутабельный State, возвращая его измененную копию. Это единственное место в нашем приложении, где может меняться State.
Определимся какие Action-ы нужны, для работы нашего примера:
```
const EAction = {
FORM_AUTH_LOGIN_UPDATE : "FORM_AUTH_LOGIN_UPDATE",
FORM_AUTH_PASSWORD_UPDATE : "FORM_AUTH_PASSWORD_UPDATE",
FORM_AUTH_RESET : "FORM_AUTH_RESET",
FORM_AUTH_AUTOFILL : "FORM_AUTH_AUTOFILL"
};
```
Напишем соответствующий Reducer:
```
function reducer(state = {
login : "",
password : ""
}, action) {
switch(action.type) {
case EAction.FORM_AUTH_LOGIN_UPDATE:
return {
...state,
login : action.login
};
case EAction.FORM_AUTH_PASSWORD_UPDATE:
return {
...state,
password : action.password
};
case EAction.FORM_AUTH_RESET:
return {
...state,
login : "",
password : ""
};
case EAction.FORM_AUTH_AUTOFILL:
return {
...state,
login : action.login,
password : action.password
};
default:
return state;
}
}
```
И ActionCreator-ы:
```
function loginUpdate(event) {
return {
type : EAction.FORM_AUTH_LOGIN_UPDATE,
login : event.target.value
};
}
function passwordUpdate(event) {
return {
type : EAction.FORM_AUTH_PASSWORD_UPDATE,
password : event.target.value
};
}
function reset() {
return {
type : EAction.FORM_AUTH_RESET
};
}
function tryAutoFill() {
if(cookies && (cookies.login !== undefined) && (cookies.password !== undefined)) {
return {
type : EAction.FORM_AUTH_AUTOFILL,
login : cookies.login,
password : cookies.password
};
} else {
return {};
}
}
function submit() {
return function(dispatch, getState) {
const state = getState();
dispatch(reset());
request('/auth/', {send: {
login : state.login,
password : state.password
}}).then(function() {
router.push('/');
}).catch(function() {
window.alert("Auth failed")
});
}
}
```
Таким образом, данные приложения и методы работы с ними описаны с помощью Reducer и ActionCreators. Это пример реализации слоя Model с помощью Redux.
React-redux в роли Controller
=============================
Все React-компоненты так или иначе будут получать свой State и Callback-и для его изменения только через Props. При этом ни один React-компонент не будет знать о существовании Redux и Actions вообще, и ни один Reducer или ActionCreator не будет знать о React-компонентах. **Данные и логика их обработки полностью отделены от их представления**. Я хочу особенно обратить на это внимание. Никаких "Умных" компонентов не будет.
Напишем Controller для нашего приложения:
```
const FormAuthController = connect(
state => ({
login : state.login,
password : state.password
}),
dispatch => bindActionCreators({
loginUpdate,
passwordUpdate,
reset,
tryAutoFill,
submit
}, dispatch)
)(FormAuthView)
```
На этом всё: React-компонент FormAuthView получит login, password и Callback-и для их изменения через Props.
[Результат работы этого демо-приложения можно посмотреть на Codepen](http://codepen.io/MrCheater/pen/GqQpYY).
Что нам дает такой подход
=========================
* Использование только Stateless-компонентов. Большую часть которых можно написать в виде Functional-component, что является [рекомендованным подходом](https://facebook.github.io/react/docs/reusable-components.html#stateless-functions), т.к. они быстрее всего работают и потребляют меньше всего памяти
* React-компоненты можно переиспользовать с разными контроллерами или без них
* Легко писать тесты, ведь логика и отображение не связаны между собой
* Можно реализовать Undo/Redo и использовать Time Travel из Redux-DevTools
* Не нужно использовать Refs
* Жесткие правила при разработке делают код React-компонентов однообразным
* Отсутствуют проблемы с серверным рендерингом
Что будет, если отступить от MVC
================================
Велик соблазн сделать какие-то компоненты поудобнее и написать их код побыстрее, завести внутри компонента State. Мол какие-то его данные временные, и хранить их не нужно. И всё это будет работать до поры до времени, пока, например, вам не придется реализовать логику с переходом на другой URL и возвращением обратно — тут всё сломается, временные данные окажутся не временными, и придется всё переписывать.
При использовании Stateful-компонентов, чтобы достать их State, придется использовать Refs. Такой подход нарушает однонаправленность потока данных в приложении и повышает связность компонентов между собой. И то и другое — плохо.
Также некоторые Stateful-компоненты могут иметь проблемы с серверным рендеренгом, ведь их отображение определяется не только с помощью Props.
А еще следует помнить, что в Redux Action-ы обратимы, но изменения State внутри компонентов — нет, и если смешать такое поведение — ничего хорошего не получится.
Заключение
==========
Надеюсь, описание честного MVC подхода при разработке с использованием React и Redux будет полезно разработчикам для создания правильной архитектуры своего web-приложения.
Если есть возможность в полной мере использовать концепцию MVC, то давайте её использовать, и не нужно изобретать что-то другое. Это подход проверенный на прочность десятилетиями, и все его плюсы, минусы и подводные камни давно известны. Придумать что-то лучше навряд ли получиться.
 | https://habr.com/ru/post/305812/ | null | ru | null |
# Чини свою Теслу сам, тыжпрограммист
Тыжпрограммист, честь тебе и хвала. Возможно, твоя юность прошла в растянутом шерстяном свитере, но сейчас ты гордо смеешься в лицо любому приколу об айтишниках. Возможно, прошло время ремонта автомобилей с ДВС с мужиками в гаражах, но....Валера, настало твое время.
Ты айтишник, на тебя с обожанием смотрят женщины и с завистью мужчины. Хорошо, что ты уже за компьютером, будем в две клавиатуры хакать Теслу.
---
Для начала следует разобраться с hardware в Вашей Tesla. Нас интересует MCU (Media Control Unit), Бывает MCU1(Tegra) и MCU2(Intel).
В Тесла есть специальный диагностический режим, в котором видны все текущие ошибки, 100 последних ошибок. Есть возможность открытия сервисного меню для калибровки отдельных узлов.
Если у Вас Tesla model S дорестайлинговая на MCU1. Подключаемся вместо приборной панели в Fakro-Lan и запускаем скрипт перевода в factory. Factory mode отличается от Developer mode тем, что после перезагрузки не слетает.
```
#!/bin/bash
#
# Put Tesla MCU1 in factory mode
#
# Call over diagnostics port with seceth enabled
#
# Reboot MCU afterwards
#
VALUE=true
if [ ! -z "$1" ]; then
VALUE=$1
fi
CID="192.168.90.100"
curl "http://${CID}:4070/_data_set_value_request_?name=GUI_factoryMode&value=${VALUE}"
```
Для получения обновлений и управления автомобилем через приложение нужно, чтобы на машине были живые сертификаты. Сертификаты можно утерять, если автомобиль в период их смены долгое время будет без интернета или в случае рутования машины.
Сертификаты живут здесь `/var/lib/car_creds/car.{crt,key}`.
Каждому автомобилю выдаются уникальные клиентские сертификаты для Hermes/OpenVPN, и они периодически меняются. Это усложняет захват образов прошивки или проверку бэкенда Tesla, так как сначала вам нужно получить root-доступ к автомобилю.
Получение root-прав позволяет Вам загружать любую модифицированную прошивку. Например, превратить Ваш авто в бэтмобиль.
Иногда это вынужденная мера, так как eMMC от Hynix на Тегре не очень хорошего качества и живет около 5 лет, потому что запись в /var очень активная. Для замены чипа памяти на Swissbit eMMC Вам потребуются root-права.
Я уже писал как [снять дамп с NAND](https://habr.com/ru/post/524054/), здесь процесс абсолютно идентичный. Если память не поменять заблаговременно, то eMMC будет изнашиваться, процессор Tegra не сможет загрузиться, а ваш экран MCU не будет включаться или MCU будет перезагружаться и перезагружаться.
Конечно удалять и заменять этот чип, рискованно. Но как только MCU мертв, маловероятно, что вы сможете восстановить раздел /var, который является разделом 3 на чипе.
MMC/SD на самом деле является стандартом интерфейса, который позволяет различным производителям создавать чипы. Если вы не хотите сейчас заменять чип и просто хотите получить дамп, вы можете припаяться к колодкам на задней панели CID, подключить их к выводам ридера и прочитать eMMC таким образом.
Если Вы будете использовать такой способ - смотрите инструкцию к Вашему ридеру.
Получение root-доступа
----------------------
Есть возможность получения root доступа через уязвимости софта, но они легко закрываются. Есть железный вариант и он надежнее. Это работает на Теграх без автопилота и с автопилотом 1 поколения. CID - центральный дисплей это дочерняя плата к MCU.
CID сделан Nvidia, процессор на MCU так же Nvidia. Поскольку это сделано nVidia, они использовали типичную систему на своих высококлассных видеокартах, то есть обновление прошивки идет попеременно в раздел 1 или 2, в зависимости от того, что в данный момент не активно, новая прошивка проверяется, затем автомобиль перезагружается на новую прошивку и развертывает поэтапные компоненты в остальной части автомобиля.
Загрузочный сопроцессор живет в чипе Tegra 3, отличном от реального процессора T3, и при сбросе этот сопроцессор инициализируется. Это довольно большой чип для встроенного устройства (512 МБ), и причина в том, что он отслеживает, какой раздел в eMMC является активным, а затем грузит ОС из него в оперативной памяти при каждой загрузке. После завершения работы сопроцессор цепочкой загружается в процессор T3, который загружается в файловую систему в оперативной памяти, и монтирует раздел eMMC 3 как /var и 4 как /home.
Более подробно на английском <https://unofficial-tesla-tech.com/index.php?title=Rooting_MCU1>
Если у тебя model3, значит ты умеешь отделять зерна от плевел, тебе маркетинговый шит что слону дробина, не бьет прямиком в мозг, то ты понимаешь, что Tesla model 3 это лучший электромобиль на текущий момент. Это многократно подтверждается владельцами с опытом эксплуатации разных моделей.
Возможно, Вам как и мне, с первого взгляда на интерьер model3 захотелось эту видеодвойку на шифонэре прикрыть салфеточкой.
Но, это только на первый взгляд. Чем дольше ты будешь пользоваться этим авто - тем более ты проникнешься гениальностью исполнения.
Недавно я получил Tesla Model 3, и так как я обожаю ковыряться в системах и пытаясь выяснить, как устроен ~~мой компьютер~~ (моя машина).
Я работаю над инфраструктурой машинного обучения ( <https://golf-robotics.com/>, сами понимаете, будущее за роботами), поэтому мне хотелось бы иметь возможность взглянуть на то, как автопилот FSD работает под капотом и что он на самом деле может делать за пределами той ограниченной информации, которую показывает пользовательский интерфейс.
Если Вы хотите повторить мои действия или испытывать что-то новое стоит зарегистрироваться в Tesla bug bounty <https://bugcrowd.com/tesla>
Одобренные участники программы могут взламывать автомобили Tesla без боязни юридических последствий или отзыва гарантии. Тесла поможет Вам оживить кирпич, но это не точно!
```
cid/ice - это компьютер, который управляет дисплеем и всеми медиа-системами, такими как звук.
192.168.90.100
первичный и вторичный компьютеры автопилота.
192.168.90.103 - ap/ape
192.168.90.105 - ap-b/ape-b
Шлюз - это в первую очередь UDP-сервер, который управляет коммутатором, конфигурацией автомобиля и прокси-запросами между стороной ethernet (cid/автопилот) и
192.168.90.102 CAN-ШИНА к контроллерам и датчикам двигателя.
Модем - это LTE-модем
192.168.90.60
Тюнер - это для AM/FM-радио. Не присутствует на более новых автомобилях модели 3, включая мои. Отсутствие AM/FM-радио действительно кажется проблемой безопасности, поэтому я был удивлен, увидев, что оно было удалено.
192.168.90.60
```
Внутренняя автомобильная сеть использует Marvel 88EA6321 в качестве коммутатора. Это автомобильный гигабитный коммутатор.
Большинство соединений используют 100BASE-T1, который является 2-проводным PHY для Ethernet. Компьютеры автопилота, модем, тюнер, шлюз, CID-все используют 100Base-T1. Есть два стандартных порта Ethernet. Один из них расположен на материнской плате CID и имеет стандартный разъем Ethernet. Другой расположен в пространстве для ног со стороны водителя и имеет специальный разъем.
Tcam
----
TCAM-это особый тип памяти, который может выполнять очень быстрые поиски/фильтры за один цикл. Это позволяет Шлюзу задавать пакетные фильтры для применения коммутатором. По умолчанию порт ethernet в пространстве для ног со стороны водителя отключен этими правилами. Диагностический разъем на материнской плате CID может получить доступ только к портам 8080 (Odin) и 22 (SSH) на CID.
Дорестовые Model S используют постоянное соединение OpenVPN для связи с “материнским кораблем”, как называет его Тесла. Все коммуникации с Tesla проходят через это VPN-соединение, так что нет никакой возможности получить файл обновлений.
Вместо использования OpenVPN M3 запускает прокси-сервис под названием Hermes. Hermes-это относительно простая служба, которая может передавать неаутентифицированные запросы по CID на материнский корабль. Предположительно, поддержание постоянных соединений OpenVPN на 500 000+ автомобилях не было масштабируемым, поэтому они переключились на более простое решение.
Бинарники
---------
Есть куча разных двоичных файлов hermes. Все они, кажется, написаны на Go :). Приятно видеть, как мой любимый язык программирования работает в моей машине.
```
$ ls opt/hermes/
hermes_client* hermes_fileupload* hermes_historylogs* hermes_teleforce*
hermes_eventlogs* hermes_grablogs* hermes_proxy*
$ file /opt/hermes/hermes_client
opt/hermes/hermes_client: sticky ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, Go BuildID=JRZRLflVY89A6p67rwkt/nb9KmeWMLadrBGvRVujH/aJPtciQz8Xldpa7VcVy_/XzIY9KY7sZI0KdwLYOK5, stripped
```
### Odin
Odin-это сервис python 3, работающий на каждом автомобиле. Он используется для различных действий по техническому обслуживанию автомобиля, таких как калибровка радара и камер. Если вы подключитесь к внутренней карточной сети, то сможете получить к ней доступ по адресу 192.168.90.100:8080.
Если вы попытаетесь выполнить какое-либо из действий на Odin, он просто выдаст ошибку.
Odin реализован довольно интересным способом. Есть список задач и сетей. Задачи-это действия высокого уровня, которые могут быть выполнены кем-то с определенными разрешениями.
LIB-файлы-это “сети”, которые, по-видимому, являются специфичной для домена программой языка/пользовательского интерфейса только для создания служебных задач.
Сети очень близки к JSON, но хранятся в файлах .py.
Вот отрывок из одного:
```
network = {
...
"get_success": {
"default": {"datatype": "Bool", "value": False},
"position": {"y": 265.22259521484375, "x": 108.96072387695312},
"variable": {"value": "success"},
"value": {"datatype": "Bool"},
"type": "networks.Get",
},
"IfThen": {
"position": {"y": 340.1793670654297, "x": 297.02069091796875},
"expr": {"datatype": "Bool", "connection": "get_success.value"},
"if_true": {"connection": "exit.exit"},
"type": "control.IfThen",
"if_false": {"connection": "capturemetric.capture"},
},
...
}
```
#### Kernel / Secure Boot
Я не очень много знаю об используемом Intel SOC, но он поддерживает некоторую безопасную загрузку. У меня нет возможности проверить, включен ли он, но я не удивлюсь, если это так. Если он не включен, то должна быть возможность изменить kernel, чтобы отключить dm-verity и загрузить неподписанный образ.
Updater
-------
Все прошивки блоков подписаны Tesla. Программа обновления проверяет подпись перед обновлением, чтобы убедиться, что ничего странного не происходит. Это означает, что мы не можем использовать программу обновления для установки модифицированной прошивки.
CAN Bus
-------
В автомобиле есть несколько шин CAN, до которых можно добраться. CAN-шина не зашифрована, поэтому мы можем извлечь из них изрядное количество внутренних данных. Было несколько проектов по реинжинирингу значений CAN.
Есть пара готовых диагностических инструментов, которые вы можете использовать для их чтения.
Сервисы и приложения
--------------------
Spotify работает под управлением пользователя spotify как сервис. Похоже, нет никакого способа развернуть новые изолированные приложения в системе. Я думал, что будет что-то похожее на Android APKs для чего-то вроде Spotify, но это просто приложение Qt.
Я продолжаю разбираться, если Вы считаете пост интересным - дайте знать и я напишу продолжение.
Большое спасибо ребятам из сервиса Tesla в Москве <https://teesla.ru/> за оказанную помощь в попытках собрать воедино возможные варианты самостоятельного обслуживания своего автомобиля.
Просто для справки, перевод в factory в СНГ оценивается где-то в $200, теперь Вы можете это делать бесплатно! За смену памяти на Тегре в сервисах могут попросить до $1000, но Вы во всеоружии! | https://habr.com/ru/post/551534/ | null | ru | null |
# Амнезия FreeBSD
Я никогда не понимал как работает распределение памяти во FreeBSD. Из всего многообразия документации полезное помнилось, лишь
> An urban myth has circulated for years that Linux did a better job avoiding swapouts than FreeBSD, but this in fact is not true. What was actually occurring was that FreeBSD was proactively paging out unused pages in order to make room for more disk cache while Linux was keeping unused pages in core and leaving less memory available for cache and process pages.
Ну лучше чем Linux, да и пусть. Я не против. Но хуже самого непонимая процесса выделения памяти меня убивала *Inactive* память. Что это такое и можно ли «это» безболезненно использовать? Считать ли эту память доступной для использования приложением?
Под cut'ом больше вопросов чем ответов.
FAQ FreeBSD сообщает, что
> 16.2.
>
>
>
> Why does top show very little free memory even when I have very few programs running?
>
>
>
> The simple answer is that free memory is wasted memory. Any memory that programs do not actively allocate is used within the FreeBSD kernel as disk cache. The values shown by top(1) labeled as Inact, Cache, and Buf are all cached data at different aging levels. This cached data means the system does not have to access a slow disk again for data it has accessed recently, thus increasing overall performance. In general, a low value shown for Free memory in top(1) is good, provided it is not very low.
Хорошо, пусть это кеш какого-то уровня, но почему не поместить эту *Inact* память в *Cache*? Может быть потому, что она доступна для использования (как утверждают многочисленные форумчане) и пусть не моментально, но может быть выделена по запросу?
Попытаемся выяснить это практическим путём. Имеем:
```
# top -b 0
last pid: 1019; load averages: 0.21, 0.45, 0.24 up 0+00:03:33 14:26:30
28 processes: 1 running, 27 sleeping
Mem: 18M Active, 17M Inact, 130M Wired, 24M Buf, 3756M Free
Swap: 3852M Total, 3852M Free
```
То есть почти вся память Free и своп полностью свободен.
Теперь, чтобы задействовать доступную память, создадим tmpfs раздел.
```
# mkdir /tmp/gb
# mount -t tmpfs -o mode=01777,size=3221225472 tmpfs /tmp/gb
# df -h | egrep "(Filesystem|tmpfs)"
Filesystem Size Used Avail Capacity Mounted on
tmpfs 3.0G 4.0K 3.0G 0% /tmp/gb
```
При этом
```
# top -b 0
last pid: 1028; load averages: 0.09, 0.19, 0.17 up 0+00:09:30 14:32:27
28 processes: 1 running, 27 sleeping
Mem: 18M Active, 17M Inact, 130M Wired, 24M Buf, 3756M Free
Swap: 3852M Total, 3852M Free
```
Согласен, раз раздел просто создан/примонтирован, но свободен, то незачем выделять ему память.
Поместим в него файл.
```
# dd if=/dev/urandom of=/tmp/gb/file.txt bs=1M count=3k
3072+0 records in
3071+0 records out
3220176896 bytes transferred in 53.334672 secs (60376801 bytes/sec)
# df -h | egrep "(Filesystem|tmpfs)"
Filesystem Size Used Avail Capacity Mounted on
tmpfs 3.0G 3.0G 1.0M 100% /tmp/gb
```
3 гигабайта памяти занято, но при этом
```
# top -b 0
last pid: 1040; load averages: 0.19, 0.26, 0.20 up 0+00:16:40 14:39:37
28 processes: 1 running, 27 sleeping
Mem: 18M Active, 3088M Inact, 137M Wired, 24M Buf, 677M Free
Swap: 3852M Total, 3852M Free
```
они почему-то считаются *Inact*. Но раз она не Active, то попытаемся её задествовать. Набросаем небольшой «Hello, world!» для выделения памяти и её последующего освобождения:
```
#include
#include
#include
#include
int main (int argc, char \*argv[])
{
int i;
char \*buffer[64];
long lSize = 1024\*1024\*1024;
int iMB = argc < 2 ? 1 : atoi(argv[1]);
printf("iMB:\t%d\n", iMB);
for(i=0; i < iMB; i++)
{
buffer[i] = (char\*) malloc (lSize);
if(buffer[i] != NULL)
{
printf("Alloc: %d\n", i);
memset(buffer[i], 127, lSize);
} else printf("Error!\n");
sleep(1);
}
sleep(10);
for(i=0; i < iMB; i++)
{
printf("Free: %d\n", i);
free (buffer[i]);
}
return 0;
}
```
```
# time ./a.out 3
iMB: 3
Alloc: 0
Alloc: 1
Alloc: 2
Free: 0
Free: 1
Free: 2
0.915u 1.475s 1:00.16 3.9% 5+168k 0+0io 0pf+0w
```
Почему так долго? Вероятно наш tmpfs, якобы находящийся в Inactive, выдавливался в своп.
Дествительно, при выделении памяти (момент *«sleep(10);»* в коде) видим:
```
# top -b 0
last pid: 1128; load averages: 0.02, 0.11, 0.14 up 0+00:28:34 14:51:31
37 processes: 1 running, 36 sleeping
Mem: 3106M Active, 621M Inact, 155M Wired, 26M Cache, 27M Buf, 14M Free
Swap: 3852M Total, 2502M Used, 1350M Free, 64% Inuse
```
Но хуже другое. После освобождения памяти приложением:
```
# top -b 0
last pid: 1129; load averages: 0.09, 0.12, 0.15 up 0+00:28:48 14:51:45
36 processes: 1 running, 35 sleeping
Mem: 33M Active, 621M Inact, 145M Wired, 26M Cache, 27M Buf, 3095M Free
Swap: 3852M Total, 2502M Used, 1350M Free, 64% Inuse
```
своп остался задействован.
Обращения к файлу вновь вернули память в *Inact*
```
# time dd of=/dev/zero if=/tmp/gb/file.txt bs=1M count=3k
3071+0 records in
3071+0 records out
3220176896 bytes transferred in 40.265654 secs (79973292 bytes/sec)
0.008u 3.796s 0:40.26 9.4% 22+154k 0+0io 0pf+0w
# time dd of=/dev/zero if=/tmp/gb/file.txt bs=1M count=3k
3071+0 records in
3071+0 records out
3220176896 bytes transferred in 1.242623 secs (2591434941 bytes/sec)
0.000u 1.241s 0:01.24 100.0% 25+173k 0+0io 0pf+0w
# top -b 0
last pid: 1144; load averages: 0.09, 0.12, 0.14 up 0+00:36:22 14:59:19
36 processes: 1 running, 35 sleeping
Mem: 29M Active, 3077M Inact, 146M Wired, 4K Cache, 27M Buf, 669M Free
Swap: 3852M Total, 2502M Used, 1350M Free, 64% Inuse
```
При этом непонятно почему остался *Swap: 2502M Used*
Но, допустим, это нормально и при наличии свободного свопа можно считать эту задействанную память неактивной и помечать её как *Inact*. Что же будет, если у нас нет свопа? Надеюсь, теперь задействованная память теперь будет *Active*.
Убираем своп, аналогично монтируем 3Gb раздел tmpfs и заполняем его.
```
# top -b 0
last pid: 1013; load averages: 0.58, 0.53, 0.29 up 0+00:05:03 15:11:46
34 processes: 1 running, 33 sleeping
Mem: 21M Active, 3089M Inact, 138M Wired, 24M Buf, 673M Free
Swap:
```
Для очистки совести убедимся что top не врёт:
```
# expr `sysctl -n vm.stats.vm.v_inactive_count` \* `sysctl -n vm.stats.vm.v_page_size`
3239620608
```
И, несмотря на отсутствие свопа, наша занятая память по прежнему не совсем активна… Раз она не активна попробуем её вновь занять нашим приложением.
```
# ./a.out 3
iMB: 3
Alloc: 0
Killed
```
Ч.т.д. и, наконец:
```
# top -b 0
last pid: 1026; load averages: 0.15, 0.22, 0.21 up 0+00:11:37 15:18:20
34 processes: 1 running, 33 sleeping
Mem: 3102M Active, 1524K Inact, 138M Wired, 200K Cache, 24M Buf, 679M Free
Swap:
# expr `sysctl -n vm.stats.vm.v_inactive_count` \* `sysctl -n vm.stats.vm.v_page_size`
1720320
```
Здесь, наверное, должен быть какой-то вывод, но его нет… | https://habr.com/ru/post/275917/ | null | ru | null |
# Petya и другие. ESET раскрывает детали кибератак на корпоративные сети
Эпидемия шифратора Petya в центре внимания. Проблема в том, что это лишь последний инцидент в серии атак на украинские компании. Отчет ESET раскрывает некоторые возможности Diskcoder.C (он же ExPetr, PetrWrap, Petya или NotPetya) и включает информацию о ранее неосвещенных атаках.
### TeleBots
В декабре 2016 года мы опубликовали исследование деструктивных атак, выполненных кибергруппой, которую мы называем TeleBots. Группировка атаковала [финансовые учреждения](https://www.welivesecurity.com/2016/12/13/rise-telebots-analyzing-disruptive-killdisk-attacks/) и использовала версию деструктивного компонента [KillDisk для Linux](https://www.welivesecurity.com/2017/01/05/killdisk-now-targeting-linux-demands-250k-ransom-cant-decrypt/). Кроме того, TeleBots могут иметь отношение к группе BlackEnergy, связанной с [кибератаками](https://habrahabr.ru/company/eset/blog/274503/) на энергетические компании.
Вредоносная программа KillDisk использовалась группой TeleBots на заключительном этапе атак, чтобы перезаписать файлы с определенными расширениями на диске жертвы. Забегая вперед, выкуп никогда не был приоритетом для этой группы.
В первой волне атак в декабре 2016 года KillDisk переписывал целевые файлы, вместо шифрования данных. Жертва не получала контакты для связи с атакующими, вредоносная программа просто выводила на экран изображение, отсылающее к сериалу «Мистер Робот».
*Рисунок 1. Изображение, которое выводил на экран KillDisk в ходе первой волны атак в декабре 2016 года.*
Во второй волне атак злоумышленники доработали KillDisk, добавив шифрование и контактную информацию в сообщение о выкупе, что придавало сходство с типичной программой-вымогателем. При этом авторы запросили за восстановление данных рекордную сумму – 222 биткоина (около 250 тысяч долларов по нынешнему курсу). Это может указывать на то, что хакеры не были заинтересованы в получении выкупа, а стремились нанести ущерб атакуемым компаниям.
*Рисунок 2. Требование выкупа KillDisk, версия второй волны атак в декабре 2016 года.*
В 2017 году группа TeleBots продолжила атаки, которые стали более изощренными. С января по март 2017 года группа скомпрометировала украинскую компанию, разрабатывающую программное обеспечение (не M.E.Doc) и, используя VPN-туннели, получила доступ к внутренним сетям нескольких финансовых учреждений.
*Рисунок 3. Атаки на цепи поставок (supply-chain attacks) в 2017 году*
В ходе этой атаки TeleBots пополнили арсенал двумя образцами шифраторов и обновленными версиями инструментов, упомянутых в наших предыдущих отчетах.
Первый бэкдор, на который в значительной степени полагалась группа, – Python/TeleBot.A, который был переписан с языка программирования Python на Rust. Функции не изменились – это стандартный бэкдор, который использует Telegram Bot API, чтобы получать команды от операторов и отправлять ответы.
*Рисунок 4. Дизассемблированный код Win32/TeleBot.AB trojan.*
Второй бэкдор, написанный на VBS и упакованный с помощью программы `script2exe`, был сильно обфусцирован, но его функциональность осталась такой же, как в прежних атаках.
*Рисунок 5. Обфусцированная версия VBS-бэкдора.*
На этот раз VBS-бэкдор использует командный C&C-сервер 130.185.250[.]171. Чтобы сделать соединения менее подозрительными для тех, кто проверяет журналы фаервола, атакующие зарегистрировали домен **transfinance.com[.]ua** и разместили его на этом IP-адресе. Как видно на рисунке 6, также был запущен почтовый сервер с именем `severalwdadwajunior`, который работал в сети Tor.
*Рисунок 6. Информация о сервере группы TeleBots.*
Кроме того, атакующие использовали следующие инструменты:
* CredRaptor (кража паролей)
* Plainpwd (модифицированный Mimikatz используется для восстановления учетных данных Windows из памяти)
* SysInternals’ PsExec (используется для распространения угрозы внутри сети)
Как сказано ранее, на завершающей стадии атаки TeleBots распространяют шифратор, используя PsExec и украденные учетные данные Windows. Антивирусные продукты ESET детектируют его как Win32/Filecoder.NKH. После выполнения малварь шифрует все файлы (за исключением расположенных в C:\Windows) с применением алгоритмов AES-128 и RSA-1024. Вредоносная программа добавляет к зашифрованным файлам расширение `.xcrypted`
Когда шифрование завершено, программа создает текстовый файл readme.txt со следующим содержанием:
*Please contact us: openy0urm1nd@protonmail.ch*
Помимо вредоносного ПО для Windows, группа TeleBots использовала Linux-шифратор для других ОС. ESET детектирует угрозу как Python/Filecoder.R, она написана на Python. На этот раз атакующие используют для шифрования файлов сторонние утилиты, такие как `openssl`. Шифрование осуществляется с помощью алгоритмов RSA-2048 и AES-256.
*Рисунок 7. Код на Python Linux-шифратора Python/Filecoder.R, используемого группой TeleBots.*
В коде скрипта на Python атакующие оставляют свой комментарий, включающий следующий текст:
*feedback: openy0urm1nd[@]protonmail.ch*
### Win32/Filecoder.AESNI.C
18 мая мы [зафиксировали](https://www.esetnod32.ru/company/press/center/shifrator-xdata-atakoval-ukrainskie-kompanii/) активность шифратора другого семейства – Win32/Filecoder.AESNI.C, также известного как XData.
Программа-вымогатель распространялась преимущественно на Украине, что связано с интересным начальным вектором заражения. По данным телеметрии ESET, шифратор появлялся на компьютере сразу после запуска программного обеспечения для отчетности и документооборота M.E.Doc, широко распространенного в украинских компаниях.
Функционал Win32/Filecoder.AESNI.C позволял шифратору автоматически распространяться в локальной сети компании. В частности, встроенная DLL Mimikatz использовалась для извлечения учетных записей Windows из памяти скомпрометированного компьютера. С помощью учетных данных малварь распространялась внутри сети, используя утилиту PsExec.
Похоже на то, что атакующие не достигли своей цели в ходе этой атаки, либо провели тестирование перед более эффективным ударом. В любом случае, мастер-ключи были опубликованы на форуме [BleepingComputer](https://www.bleepingcomputer.com/news/security/aes-ni-ransomware-dev-releases-decryption-keys-amid-fears-of-being-framed-for-xdata-outbreak/), там же появилось заявление о том, что исходный код AESNI был украден у настоящего автора и использовался в украинском инциденте.
ESET выпустила [дешифратор](https://www.esetnod32.ru/company/press/center/eset-vosstanovit-fayly-zashifrovannye-aes-ni-i-xdata/) для жертв Win32/Filecoder.AESNI.
### Эпидемия Diskcoder.C (более известного как Petya)
Что действительно получило широкое освещение в СМИ, так это эпидемия Petya, начавшаяся 27 июня. Вредоносная программа скомпрометировала множество систем в критических инфраструктурах и корпоративных сетях на Украине и за ее пределами.
Шифратор, который используется в этой атаке, может подменять главную загрузочную запись (MBR) собственным вредоносным кодом. Код позаимствован у программы-вымогателя [Win32/Diskcoder.Petya](http://virusradar.com/en/Win32_Diskcoder.Petya.B/description), поэтому некоторые исследователи называют угрозу ExPetr, PetrWrap, Petya или NotPetya. В отличие от оригинального Petya, авторы Diskcoder.C изменили код MBR таким образом, что восстановить данные стало невозможно. Точнее, атакующие не могут отправить жертве ключ расшифровки, и его невозможно ввести в соответствующее поле, поскольку он содержит недопустимые символы.
Визуально MBR часть Diskcoder.C выглядит как слегка модифицированная версия Petya: сначала она показывает сообщение, в котором выдает себя за CHKDSK – утилиту проверки диска от Microsoft. В процессе фейкового сканирования Diskcoder.C на самом деле шифрует данные.
*Рисунок 8. Фейковое сообщение CHKDSK, отображаемое Diskcoder.C.*
Когда шифрование завершено, код MBR отображает следующее сообщение с инструкциями для оплаты, но, как уже было доказано, эта информация бесполезна.
*Рисунок 9. Сообщение Diskcoder.C с инструкциями для оплаты выкупа.*
Остальной код, помимо заимствованного MBR, написан авторами вредоносной программы. Он включает шифратор файлов, который может использоваться в дополнение к шифрующей диск MBR. Вредоносная программа использует алгоритмы AES-128 и RSA-2048.
Стоит отметить, что авторы допустили ошибки, что сократило возможности дешифровки файлов. Например, Diskcoder.C шифрует только первый 1 Мб данных и не записывает header и footer, только исходные зашифрованные данные. Малварь не переименовывает файлы, поэтому сложно сказать, какие файлы зашифрованы, а какие нет.
Интересно, что список целевых расширений хотя и не полностью идентичен, но очень похож на используемый в атаках KillDisk [в декабре 2016 года](https://www.welivesecurity.com/2016/12/13/rise-telebots-analyzing-disruptive-killdisk-attacks/).
*Рисунок 10. Список целевых расширений Diskcoder.C.*
После выполнения Diskcoder.C пытается увеличить охват при помощи эксплойта EternalBlue, который использует бэкдор DoublePulsar, работающий в режиме ядра. Точно такой же метод использовался в вымогателе WannaCryptor.D.
Diskcoder.C также использовал метод, позаимствованный у Win32/Filecoder.AESNI.C (XData) – он использует упрощенную версию Mimikatz, чтобы получить учетные данные, а затем исполняет вредоносное ПО на других машинах локальной сети с помощью SysInternals PsExec.
Наконец, авторы Diskcoder.C использовали третий метод распространения – механизм WMI.
Все три метода применялись для распространения Diskcoder.C внутри сетей. В отличие от WannaCryptor, новый шифратор использовал эксплойт EternalBlue только на компьютерах в диапазоне адресов локальной сети.
Почему эпидемия вышла за пределы Украины? Наше исследование показало, что зараженные компании в других странах подключались через VPN к своим украинским филиалам или бизнес-партнерам.
### Начальный вектор заражения
И Diskcoder.C, и Win32/Filecoder.AESNI.C использовали атаки на цепь поставок (supply-chain attack) в качестве начального вектора заражения. Эти семейства вредоносного ПО передавались при помощи программного обеспечения для отчетности и документооборота M.E.Doc, которое широко используется в бухгалтерском учете.
Существует несколько вариантов проведения этих атак. У M.E.Doc есть внутренняя система обмена документами и сообщениями, так что хакеры могли использовать фишинг. В этом случае необходимо взаимодействие с пользователем, возможно, не обошлось без социальной инженерии. Поскольку Win32/Filecoder.AESNI.C не распространился слишком широко, мы сначала решили, что были задействованы именно эти методы.
Но последующая эпидемия Diskcoder.C дает основания предполагать, что у хакеров был доступ к серверу обновлений легитимного ПО M.E.Doc. С его помощью атакующие могли направлять вредоносные обновления с их установкой автоматически без участия пользователя. Поэтому так много систем на Украине пострадало от этой атаки. Кажется, что создатели малвари недооценили способности Diskcoder.C к экспансии.
Исследователи ESET нашли подтверждение этой теории. Мы обнаружили PHP-бэкдор в файле `medoc_online.php` в одной из директорий на сервере FTP M.E.Doc. Доступ к бэкдору можно было получить через HTTP, хотя он был зашифрован, и атакующему нужен был пароль для его использования.
*Рисунок 11. Директория с РНР-бэкдором на FTP.*
Надо сказать, что есть признаки, указывающие на то, что Diskcoder.C и Win32/Filecoder.AESNI.C – не единственные семейства вредоносных программ, которые использовали этот вектор. Можем предположить, что вредоносные обновления были применены для скрытого проникновения в компьютерные сети, принадлежащие приоритетным объектам.
Одной из вредоносных программ, распространявшихся с помощью скомпрометированного механизма обновлений M.E.Doc, был VBS-бэкдор, который использует группа TeleBots. На этот раз атакующие снова использовали доменные имена, связанные с финансовой темой: **bankstat.kiev[.]ua**.
В день начала эпидемии Diskcoder.C А-запись этого домена была изменена на 10.0.0.1.
### Выводы
Группа TeleBots совершенствует инструменты деструктивных атак. Вместо направленных фишинговых писем с документами, содержащими вредоносные макросы, они использовали более сложную схему, известную как кибератаки на цепи поставок (supply-chain attack). До начала эпидемии группа атаковала преимущественно финансовый сектор. Вероятно, что последняя кампания была нацелена на украинский бизнес, но атакующие недооценили возможности вредоносной программы – малварь вышла из-под контроля.
### Индикаторы заражения (IoC)
**Детектирование продуктами ESET:**
`Win32/TeleBot trojan
VBS/Agent.BB trojan
VBS/Agent.BD trojan
VBS/Agent.BE trojan
Win32/PSW.Agent.ODE trojan
Win64/PSW.Agent.K trojan
Python/Filecoder.R trojan
Win32/Filecoder.AESNI.C trojan
Win32/Filecoder.NKH trojan
Win32/Diskcoder.C trojan
Win64/Riskware.Mimikatz application
Win32/RiskWare.Mimikatz application`
**C&C:**
`transfinance.com[.]ua (IP: 130.185.250.171)
bankstat.kiev[.]ua (IP: 82.221.128.27)
www.capital-investing.com[.]ua (IP: 82.221.131.52)`
**Легитимные серверы, используемые авторами вредоносной программы:**
`api.telegram.org (IP: 149.154.167.200, 149.154.167.197, 149.154.167.198, 149.154.167.199)`
**VBS-бэкдор:**
`1557E59985FAAB8EE3630641378D232541A8F6F9
31098779CE95235FED873FF32BB547FFF02AC2F5
CF7B558726527551CDD94D71F7F21E2757ECD109`
**Mimikatz:**
`91D955D6AC6264FBD4324DB2202F68D097DEB241
DCF47141069AECF6291746D4CDF10A6482F2EE2B
4CEA7E552C82FA986A8D99F9DF0EA04802C5AB5D
4134AE8F447659B465B294C131842009173A786B
698474A332580464D04162E6A75B89DE030AA768
00141A5F0B269CE182B7C4AC06C10DEA93C91664
271023936A084F52FEC50130755A41CD17D6B3B1
D7FB7927E19E483CD0F58A8AD4277686B2669831
56C03D8E43F50568741704AEE482704A4F5005AD
38E2855E11E353CEDF9A8A4F2F2747F1C5C07FCF
4EAAC7CFBAADE00BB526E6B52C43A45AA13FD82B
F4068E3528D7232CCC016975C89937B3C54AD0D1`
**Win32/TeleBot:**
`A4F2FF043693828A46321CCB11C5513F73444E34
5251EDD77D46511100FEF7EBAE10F633C1C5FC53`
**Win32/PSW.Agent.ODE (CredRaptor):**
`759DCDDDA26CF2CC61628611CF14CFABE4C27423
77C1C31AD4B9EBF5DB77CC8B9FE9782350294D70
EAEDC201D83328AF6A77AF3B1E7C4CAC65C05A88
EE275908790F63AFCD58E6963DC255A54FD7512A
EE9DC32621F52EDC857394E4F509C7D2559DA26B
FC68089D1A7DFB2EB4644576810068F7F451D5AA`
**Win32/Filecoder.NKH:**
`1C69F2F7DEE471B1369BF2036B94FDC8E4EDA03E`
**Python/Filecoder.R:**
`AF07AB5950D35424B1ECCC3DD0EEBC05AE7DDB5E`
**Win32/Filecoder.AESNI.C:**
`BDD2ECF290406B8A09EB01016C7658A283C407C3
9C694094BCBEB6E87CD8DD03B80B48AC1041ADC9
D2C8D76B1B97AE4CB57D0D8BE739586F82043DBD`
**Win32/Diskcoder.C:**
`34F917AABA5684FBE56D3C57D48EF2A1AA7CF06D`
**PHP shell:**
`D297281C2BF03CE2DE2359F0CE68F16317BF0A86` | https://habr.com/ru/post/332058/ | null | ru | null |
# The Best Golang framework: no framework?
Best Framework?Вольный перевод статьи на ресурсе [threedots.tech](https://threedots.tech/post/best-go-framework/) от Robert Laszczak - главного инженера в [SlashID](http://slashid.dev/), сооснователя [Three Dots Labs](https://threedotslabs.com/) и создателя популярной Golang-библиотеки [Watermill](https://github.com/ThreeDotsLabs/watermill).
На протяжении некоторого времени я занимался руководством группы Go-разработчиков и одним из самых распространенных вопросов от начинающих специалистов был - **"Какой фреймворк мне следует использовать?".** Одним из самых худших советов, которые вы можете услышать в Golang - это следовать подходу и принципам других языков программирования.
В других языках программирования имеются популярный фреймворки, которые стали неким стандартном и используются **“по умолчанию”.** В Java есть [Spring](https://spring.io/), в Python есть [Django](https://www.djangoproject.com/) и [Flask](https://flask.palletsprojects.com/en/2.2.x/) (+ различные расширения), в Ruby есть [Rails](https://rubyonrails.org/), у Node есть [Express](https://expressjs.com/ru/), а у PHP есть [Symfony](https://symfony.com/) и [Laravel](https://laravel.com/). В Golang на данный момент времени есть отличие - здесь нет фреймворка по умолчанию.
Что еще более интересно, многие опытные Go-разработчики предполагают, что Вам вообще не следует использовать фреймворк. Вы можете про себя сказать - **они что, сумасшедшие?** 😁
Создание сервиса на Go из библиотек может создать ощущение создания монстра ФранкенштейнаФилософия Golang
----------------
Фреймворки в Go существуют, но ни один из них не предоставляет такого набора функций - как фреймворки в других популярных языках. **Это не скоро изменится.**
Вы можете подумать, что это потому - экосистема Go крайне молодая и еще не сформирована полностью. Но есть более важный фактор. Go построен на философии Unix, которая гласит:
> 1. Write programs that do one thing and do it well.
>
> 2. Write programs to work together.
>
> 3. Write programs to handle text streams because that is a universal interface
>
>
Эта философия возникла у [Ken Thompson](https://ru.wikipedia.org/wiki/%D0%A2%D0%BE%D0%BC%D0%BF%D1%81%D0%BE%D0%BD,_%D0%9A%D0%B5%D0%BD) - разработчика языка программирования B (предшественника C).
На практике **философия Unix** отдает предпочтение созданию небольших независимых частей программного обеспечения, которые хорошо выполняют что-то одно. Возможно, вы видели это в своем терминале (пример):
```
cat example.txt | sort | uniq
```
Разберем подробнее пример выше: утилита **cat** считывает файл *example.txt, далее* утилита**sort** сортирует данные и после утилита **uniq** оставляет только уникальные значения.
Все команды независимы и выполняют одну задачу. Это происходит непосредственно из **философии Unix**. Благодаря такому дизайну вы можете самостоятельно разрабатывать гораздо меньшие по размеру независимые команды.
В Golang философия Unix видна в стандартной библиотеке. Лучшими примерами являются наиболее распространенные интерфейсы ввода-вывода: `io.Reader` и `io.Writer`. Многие популярные библиотеки также придерживаются такой философии.
Фреймворки разработаны в соответствии с этой философией часто пытаются охватить все возможные варианты использования (use cases), что в конченом итоге может привести к невозможности его переиспользования. Через какое-то время такой фреймворк просто умрет.
Что важно понимать!
-------------------
У каждого технического решения есть свои **компромиссы**. Вам нужно осознать эти ограничения, которые имеют большую важность для Вас и Вашего проекта .
Некоторые решения имеют смысл, когда Вы например работаете над доказательством некой концепции/подхода и после просто проект выбрасываете. В этом случае наиболее важным фактором является то, как быстро Вы сможете все развернуть/установить и проверить Вашу гипотезу (качество соответственно вторично тут). Но если Вы работаете над проектом в долгую и создаете его с участием нескольких человек - такой подход может оказаться провальным.
Для большинства проектов наиболее важными параметрами являются:
* как быстро вы можете начать проект;
* как быстро вы сможете развивать этот проект в долгосрочной перспективе;
* насколько гибким для будущих изменений будет проект (это тесно связано с предыдущим пунктом).
Предлагаю начать оценивать наши выбранные решения именно с этих позиций.
Экономия времени
----------------
Одно из самых больших обещаний любого фреймворка - это **экономия времени**. Вы запускаете одну команду и получаете полностью функциональный проект готовый ко всему. Фреймворки обычно обеспечивают четкую структуру проекта и это действительно помогает при отсутствии необходимых знаний. Но, как и в случае с любыми техническими решениями - это **не бесплатно**.
Со временем, когда проект будет развиваться и код будет стремительно становиться все больше - вы быстро наткнетесь на стену условностей и ограничения конкретного фреймворка. Идеи и требования к фреймворку автора, может легко отличаться от Ваших взглядов и подходов. Решение принятое создателем фреймворка, может хорошо работать для простых CRUD-приложений, но может не подходить для более сложных сценариев использования. Таким образом легко потерять все свое сэкономленное время на начальном этапе проекта и в скором времени Ваша работа перерастет в борьбу с ограничениями фреймворка.
Пару лет назад я работал в компании, которая изначально начинала с фреймворка на Go (я пропущу название фреймворка). Компания росла и создавала новые сервисы. Со временем мы начали испытывать больше боли, когда хотели реализовать более сложные варианты использования. Это стало для нас серьезной проблемой. К сожалению, избавиться от фреймворка было уже непросто.
В какой-то момент некоторые компоненты/модули фреймворка могут перестать поддерживаться/развиваться и будут несовместимыми с остальной экосистемой Вашего проекта. Мы были вынуждены избавиться от такого решения. Замена фреймворка в десятках сервисов была нетривиальной и трудоемкой задачей. Это потребовало межкомандных взаимодействий, на устранение данной проблемы ушло несколько человеко-месяцев и было несколько инцидентов на ПРОМе. Даже если в конце концов проект был признан успешным, я не рассматривал его таковым с технической точки. Все потраченное время можно было бы использовать гораздо эффективнее, если бы кто-то принял другое решение на самом старте. Неудивительно, что многие компании страдают от недостатка доверия к команде разработки.
Это отличный пример того, как такое незначительное решение может через пару лет превратиться в проблему - на устранение которой потребуется много усилий и денег.
Сложность поддержки проекта
---------------------------
Измерение сложности поддержки проектов спорная тема. Трудно сравнивать два проекта. Некоторые люди говорят, что фреймворки великолепны и они не испытывают боли от их использования. Для других фреймворки могут стать самым большим кошмаром в долгосрочной перспективе. Некоторые проекты гораздо более сложные, чем другие. Многие люди думают, что борьба с фреймворком - это всего лишь часть работы. Вот почему трудно объективно измерить влияние фреймворков на сложность поддержки.
К счастью, мы можем помочь себе понять это с помощью небольшой науки. Точнее, с отличной книгой [Accelerate: The Science of Lean Software and DevOps](https://www.amazon.com/Accelerate-Software-Performing-Technology-Organizations/dp/1942788339), основанной на научных исследованиях. Книга сосредоточена на поиске параметров лучших и наихудших команд. Что важно для нас - одним из наиболее значимых факторов хорошей производительности является слабосвязанная архитектура.
Команды, которыми я руководил, часто спрашивали меня - **как узнать, слабо ли связана наша архитектура**. Один из самых простых способов - обеспечить легкость замены или удаления частей вашего приложения. Если трудно удалить части вашего приложения -значит Ваше приложение тесно связано. Прикосновение к одной части - вызывает эффект домино изменений в разных местах.
Почему слабосвязанная архитектура так важна? Давайте просто это признаем - это так. Мы все люди и даже после самых тщательных исследований мы совершаем ошибки. Когда вы выбираете неправильный фреймворк или библиотеку - их должно быть легко заменить, не переписывая весь проект. Если мы хотим сэкономить время, мы должны подумать о том, что помогает в долгосрочной перспективе, а не только в начале проекта.
Рассмотрим сценарий, когда вы хотите полностью **удалить** фреймворк. Потребуется ли для этого много переписывания кода? Можно ли это сделать на нескольких сервисах независимо? Если **нет**, то Вы могли бы приложить некоторые усилия, чтобы отделить фреймворк от Вашей основной логики. Но это же потребует пожертвовать “экономией времени”, ради чего и используют фреймворки в первую очередь!
Есть ли альтернатива? Создаем сервисы без фреймворков
-----------------------------------------------------
Вам может показаться, что создание Ваших сервисов без фреймворка займет целую **вечность**. Особенно, если вы переходите с других языков программирования. Я это прекрасно понимаю. У меня было такое же чувство пару лет назад, когда я начал писать на Go. Сейчас могу сказать уже с уверенностью - это был неоправданный страх. Отсутствие фреймворка не означает, что Вам нужно будет создавать все самостоятельно. Существует множество проверенных библиотек, которые обеспечивают необходимую Вам функциональность.
Вам нужно приложить немного больше усилий к исследованиям. Даже пара часов исследований - ничто по сравнению с продолжительностью всего проекта. Вы также очень скоро вернете это время назад благодаря гибкости, которую это Вам даст данный подход.
Что Вам следует делать, если Вы решите не использовать фреймворки? Самым большим препятствием в начале может быть то, как надо создавать сервис. Самый простой способ - начать с того, что поместить все в один файл. Вы можете начать с простого и постепенно усложнять с развитием проекта.
Полезно иметь примеры проектов, которые вы можете использовать в качестве основы. Вы можете взглянуть на проект, который я использовал для своего приложения*Let’s build event-driven application in 15 minutes with Watermill* presentation at [GoRemoteFest](https://www.youtube.com/watch?v=6Zgi5nUPf70) –[github.com/roblaszczak/goremotefest-livecoding](https://github.com/roblaszczak/goremotefest-livecoding). Для этого примера потребовались всего две внешние библиотеки.
Не стесняйтесь клонировать этот репозиторий и адаптировать его под Ваши потребности. Я уверен, что в этом примере нет всех библиотек, необходимых для Вашего проекта. Чтобы помочь вам с более конкретными вариантами использования, на следующей неделе мы опубликуем статью со списком библиотек Go, которые Вы можете использовать для создания своих сервисов на Go. Мы пользуемся ими уже пару лет. Мы также объясним, почему мы используем эти библиотеки и как узнать, хороша ли подобная библиотека или плоха для Вас.
Изменяем части Вашего проекта, не убивая егоКогда Ваш проект станет более сложным и Вы уже знаете - как Ваши библиотеки работают вместе, Вы легко можете начать его рефакторинг. В конце концов, Вам может не понадобиться большинство функций фреймворка, которые казались критически важными на самом старте. Благодаря этому Вы можете в конечном итоге получить более простой проект.
Если Вы ищете информацию о том, как могут выглядеть более продвинутые проекты, Вам следует ознакомиться с [Wild Workouts](https://github.com/ThreeDotsLabs/wild-workouts-go-ddd-example) – нашим полнофункциональным примером проекта на Go. Мы выпустили бесплатную электронную книгу объемом более 200 страниц, описывающую - как мы создали это приложение.
Итого
-----
Решение о том, как Вы будете создавать свои сервисы - это не тот вопрос, где Вам следует не думать и сразу выбирать популярный фреймворк на все случаи жизни. Принятие неправильного решения может очень негативно сказаться на Вашем времени в долгосрочной перспективе. Это негативно влияет и на скорость Вашей команды и что более важно - на моральный дух.
Приняв неправильное решение, Вы можете быстро попасть в ловушку заблуждения о заниженных трудозатратах на разработку. Вместо того чтобы становиться героями, которые решают проблемы (борясь с фреймворком), мы должны по максимум избегать возможность их появления.
---
ИМХО
----
Статья и мнение Robert Laszczak имеет конечно право на жизнь - это его опыт и виденье. Вставлю и свои 5 копеек. Каждый проект проходит стандартные станции жизни и от идеи до текущего момент могут меняться и технологии реализации и непосредственно команды (люди), которые отвечали за разработку/поддержку.
В самом начале большинству проектов нужна именно скорость разработки для подтверждения гипотез и для быстрого выхода на рынок - как итог привлечение конечных потребителей и завоевание хоть какой-то доли рынка. Когда появляются реальные потребители (aka клиенты) - растет нагрузка на сервисы и тут уже все зависит от прямых рук разработчика/архитектора. Когда уже начинаешь упираться в фреймворк - необходимо задать себе вопрос, а все ли я правильно делаю вообще, возможно надо сделать rtfm? Думаю в 99% случаев должна помочь тонкая настройка или точечная оптимизация кода.
Кроме проблем с ограничениями фреймворков, есть же и нюансы с самими языками программирования. Например если у Вас действительно высоконагруженные сервис, где Вам вплотную приходится профилировать CPU/RAM и использовать грязные хаки в Go для оптимальной работы GC. Тут мы уже возможно начинаем бороться с самим языком и может надо смотреть уже в сторону **Rust**?
В комментариях под постом Robert Laszczak нашлись люди, которые явно согласились с автором:
> В моей компании мы использовали сервисы Go без какого-либо фреймворка. Это был приятный опыт работы после связки Java + Spring. ... через пару месяцев цикл разработки стал гладким.
>
>
Кончено были и те, которые в корне не согласны с ним:
> Категорически не согласен с тем, что долгосрочные проекты страдают от использования фреймворков. Вы либо используете неправильную структуру, либо MVC не соответствует Вашим потребностям. Ограничения зрелых фреймворков и их обходные пути - как правило, хорошо известны. Я подозреваю, что Go медленно внедряет свои собственные Rails или Django из-за ограничений системы типов. К такому выводу я пришел после экспериментов с созданием достойной оболочки базы данных задолго до появления дженериков, что в первую очередь сводит на нет преимущества использования Go в производительности.
>
>
Из своего опыта скажу так, обычно всегда для своих задач использую стандартный HTTP-сервер + удобный кастомные роутинг в Go. Если проблемы с производительностью - вперед в pprof. Для проектов с маленькой нагрузкой хватает с головой и Flask + Gunicorn.
Для менеджеров проектов тут тоже все неоднозначно и сразу бросаться в полный кастом без фреймворков опасно - ведь при таком подходе на рынке не будет "готовых" специалистов, которые сразу смогут условно помочь проекту на 2ой день работы.
Необходимо так же помнить и о DevOps и о финансовом обосновании реализации того или иного сервиса. Увы, "серебрянной пули" как обычно нету и надо все взвешивать опираясь на многочисленные факторы... И легко может получиться так, что **вчера** было выгодно делать все на фреймворка,а **сегодня** уже нет и **наоборот**. | https://habr.com/ru/post/705078/ | null | ru | null |
# Язык Bosque — новый язык программирования от Microsoft
Буквально несколько дней назад компания Microsoft представила публике новый язык программирования. Языку дали название Bosque. Главная миссия дизайна языка — ~~лучше быть богатым и здоровым, чем бедным и больным~~ чтобы он был прост и понятен как для человека, так и для компьютера.
Информации пока что очень мало, язык еще очень свежий и нестабильный. Есть лишь [paper](https://www.microsoft.com/en-us/research/uploads/prod/2019/04/beyond_structured_report_v2.pdf) от Марка Марона и [дока в начальной стадии написания](https://github.com/Microsoft/BosqueLanguage/blob/master/docs/language/overview.md#0-Highlight-Features).
Давайте попробуем рассмотреть некоторые особенности языка.
1) Все значения в Bosque являются неизменяемыми (immutable), чтобы каждый блок кода не содержал никаких сайд-эффектов. По мнению авторов языка это полезно как для человека, так и для компьютера.
При этом, как ни странно, чуть далее по тексту рассказывается, что можно объявить изменяемую переменную ключевым словом `var!`. И это не просто сахар для более удобной инициализации иммутабельной переменной, это действительно настоящая переменная.
Ладно, допустим, это некий компромисс, и в локальном скоупе так сделали. Но дальше идет упоминание о еще не реализованной фиче языка — передаче аргументов функции по ссылке
```
function internString(ref env: Map, str: String): Int {
if(env.has(str)) { //use the ref parameter
return env.get(str);
}
env = env.add(str, env.size()); //update the ref parameter
return env.size();
}
```
Может я чего-то не понимаю, но странная какая-то иммутабельность в языке, если мы можем передать Map по ссылке, и фунция ее намутирует.
2) В языке нет циклов for, while и т.д. Вообще никаких нет. Вместо этого есть коллекции и пайплайны. Другими словами, вместо циклов нужно использовать более высокоуровневые штуки типа map, filter и т.д.
3) Строки можно делать разных типов. Т.е., например, можно сделать строку-имя или строку-zipcode, и для type-чекера это будут две разные строки. Если вы в аргументе функции ожидаете zipcode, а вам по ошибке туда пихают имя, то компилятор это не проглотит. Синтаксис такой: String[Zipcode].
Тоже сомнительная штука, почему не просто ZipCode. Один раз объявить, что ZipCode — это строка и везде в сигнатурах это писать. И почему именно для строк эта типизация сделана, а не для интов, например.
4) Вызов функций можно делать с указанием названия аргументов из сигнатуры функции, например: `myfunc(x=1, y=2)`
5) В стандартной библиотеке есть различные коллекции, и с коллекциями можно работать по разному. Можно просто по цепочке вызывать map, потом filter и т.д., а можно работать через пайплайны.
```
var v: List[Int?] = List@{1, 2, none, 4};
//Chained - List@{1, 4, 16}
v->filter(fn(x) => x != none)->map[Int](fn(x) => x*x)
//Piped none filter - List@{1, 4, 16}
v |> filter(fn(x) => x != none) |> map[Int](fn(x) => x*x)
//Piped with noneable filter - List@{1, 4, 16}
v |??> map[Int](fn(x) => x*x)
//Piped with none to result - List@{1, 4, none, 16}
v |?> map[Int](fn(x) => x*x)
```
6) рекурсия считается злом, которое может усложнить программу, поэтому рекурсивные фунции надо помечать словом `rec`
7) программы на Bosque являются детерминированными. Другими словами в языке нет неопределенного поведения. Например, нельзя использовать переменные, пока они не были определены; алгоритмы сортировки только стабильные и т.д. Если программа выдала какой-то результат, то такой же результат будет и потом, никаких сюрпризов
8) Вместо классов и интерфейсов в языке есть понятия entity и concept.
```
concept Bar {
field f: Int;
}
entity Baz provides Bar {
field g: Int;
field h: Bool = true;
}
var y = Baz@{f=1, g=2, h=false}; //Create a Baz entity with the given field values
var x = Baz@{f=1, g=2}; //Create a Baz entity with default value for h
```
Пример кода
===========
**Вот крестики-нолики на Boscque**
```
//-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------
//
//This is a bosque test/benchmark for a tic-tac-toe program.
//
namespace NSMain;
entity Board {
const playerX: String[PlayerMark] = 'x'#PlayerMark;
const playerO: String[PlayerMark] = 'o'#PlayerMark;
const allCellPositions: List[[Int, Int]] = List[[Int, Int]]@{
@[ 0, 0 ], @[ 1, 0 ], @[ 2, 0 ],
@[ 0, 1 ], @[ 1, 1 ], @[ 2, 1 ],
@[ 0, 2 ], @[ 1, 2 ], @[ 2, 2 ]
};
const winPositionOptions: List[List[[Int, Int]]] = List[List[[Int, Int]]]@{
List[[Int, Int]]@{ @[ 0, 0 ], @[ 0, 1 ], @[ 0, 2 ] },
List[[Int, Int]]@{ @[ 0, 1 ], @[ 1, 1 ], @[ 2, 1 ] },
List[[Int, Int]]@{ @[ 0, 2 ], @[ 1, 2 ], @[ 2, 2 ] },
List[[Int, Int]]@{ @[ 0, 0 ], @[ 1, 0 ], @[ 2, 0 ] },
List[[Int, Int]]@{ @[ 1, 0 ], @[ 1, 1 ], @[ 1, 2 ] },
List[[Int, Int]]@{ @[ 2, 0 ], @[ 2, 1 ], @[ 2, 2 ] },
List[[Int, Int]]@{ @[ 0, 0 ], @[ 1, 1 ], @[ 2, 2 ] },
List[[Int, Int]]@{ @[ 0, 2 ], @[ 1, 1 ], @[ 2, 0 ] }
};
//Board is a list of marks, indexed by x,y coords from upper left 0 based
field cells: List[String[PlayerMark]?];
factory static createInitialBoard(): { cells: List[String[PlayerMark]?] } {
return @{ cells=List[String[PlayerMark]?]::createOfSize(9, none) };
}
method getOpenCells(): List[[Int, Int]] {
return Board::allCellPositions->filter(fn(pos: [Int, Int]): Bool => {
return !this->isCellOccupied(pos[0], pos[1]);
});
}
method getCellContents(x: Int, y: Int): String[PlayerMark]?
requires 0 <= x && x < 3 && 0 <= y && y < 3;
{
return this.cells->at(x + y * 3);
}
method isCellOccupied(x: Int, y: Int): Bool {
return this->getCellContents(x, y) != none;
}
method isCellOccupiedWith(x: Int, y: Int, mark: String[PlayerMark]): Bool
requires mark == Board::playerX || mark == Board::playerO;
{
return this->getCellContents(x, y) == mark;
}
method markCellWith(x: Int, y: Int, mark: String[PlayerMark]): Board
requires mark == Board::playerX || mark == Board::playerO;
requires 0 <= x && x < 3 && 0 <= y && y < 3;
requires !this->isCellOccupied(x, y);
{
return this<~(cells=this.cells->set(x + y * 3, mark));
}
hidden method checkSingleWinOption(opt: List[[Int, Int]], mark: String[PlayerMark]): Bool {
return opt->all(fn(entry: [Int, Int]): Bool => this->isCellOccupiedWith(entry[0], entry[1], mark));
}
hidden method checkSingleWinner(mark: String[PlayerMark]): Bool {
return Board::winPositionOptions->any(fn(opt: List[[Int, Int]]): Bool => this->checkSingleWinOption(opt, mark));
}
method checkForWinner(): String[PlayerMark]? {
if(this->checkSingleWinner(Board::playerX)) {
return Board::playerX;
}
elif(this->checkSingleWinner(Board::playerO)) {
return Board::playerO;
}
else {
return none;
}
}
}
entity Game {
field winner: String[PlayerMark]? = none;
field board: Board = Board@createInitialBoard();
method hasWinner(): Bool {
return this.winner != none;
}
method getWinner(): String[PlayerMark]
requires this->hasWinner();
{
return this.winner->as[String[PlayerMark]]();
}
method makeAutoMove(mark: String[PlayerMark], rnd: Int): Game
requires !this->hasWinner();
{
var! nboard: Board;
if(!this.board->isCellOccupied(1, 1)) {
nboard = this.board->markCellWith(1, 1, mark);
}
else {
var opts = this.board->getOpenCells();
var tup = opts->uniform(rnd);
nboard = this.board->markCellWith(...tup, mark);
}
return this<~( board=nboard, winner=nboard->checkForWinner() );
}
method makeExplicitMove(x: Int, y: Int, mark: String[PlayerMark]): Game
requires !this.board->isCellOccupied(x, y);
{
var nboard = this.board->markCellWith(x, y, mark);
return this<~( board=nboard, winner=nboard->checkForWinner() );
}
}
entity PlayerMark provides Parsable {
field mark: String;
override static tryParse(str: String): PlayerMark | None {
return (str == "x" || str == "o") ? PlayerMark@{ mark=str } : none;
}
}
entrypoint function main(): Game {
var! game = Game@{};
game = game->makeAutoMove(Board::playerX, 0);
game = game->makeAutoMove(Board::playerO, 1);
game = game->makeAutoMove(Board::playerX, 2);
game = game->makeExplicitMove(2, 0, Board::playerO);
game = game->makeExplicitMove(2, 1, Board::playerX);
return game;
}
```
Итого
=====
В общем, желаю языку удачи, конечно, но пока что Bosque выглядит странновато и сыровато. Скорее proof of concept. Причем, не совсем ясно, что именно является киллер-фичей. Документация порождает больше вопросов, чем ответов.
Компилятор для Bosque написан на Typescript, а не на самом языке, как это принято (например, компилятор Typescript написан на Typescript). Т.е. язык, скорее всего, еще недостаточно развит для написания более менее сложных программ.
В ближайшем выпуске подкаста "[Цинковый прод](https://znprod.io/?utm_source=habrahabr&utm_campaign=448814)" мы обязательно обсудим новый язык Bosque, возможно удастся собрать побольше информации. Так что не забудьте подписаться. | https://habr.com/ru/post/448814/ | null | ru | null |
# Собираем XGBoost под OS X
[XGBoost](https://github.com/dmlc/xgboost) — С++ библиотека, реализующая методы градиентного бустинга, которую все чаще можно встретить в описаниях алгоритмов-победителей на Kaggle. Для использования из R или Python есть соответствующие обвязки, но саму библиотеку необходимо собрать из исходников. Запустив make, я увидел массу ошибок, сообщающих о ненайденных хидерах и неподдерживаемом OpenMP. Ну, не впервой.
Прогресс не стоит на месте, и алгоритм несколько упростился:
1. /usr/bin/ruby -e "$(curl -fsSL raw.githubusercontent.com/Homebrew/install/master/install)"
2. brew install gcc --without-multilib
3. pip install xgboost
4. Покорять топы лидербордов на Kaggle
С полей сообщают, что при запуске XGBoost может ругаться на ненайденную библиотеку /usr/local/lib/gcc/5/libgomp.1.dylib. В этом случае следует найти ее и положить по указанному пути.
Раньше нужно было проделать следующее:
1. Скачать XCode
2. Установить command line tools
3. Собрать Clang c поддержкой OpenMP
4. Собрать Intel OpenMP библиотеку
5. Прописать путь к OpenMP библиотеке и соответствующим хидерам
6. Собрать XGBoost
7. Установить обвязку для Python
8. Покорять топы лидербордов на Kaggle
1. **Скачать XCode**
XCode можно совершенно бесплатно скачать из App Store. После установки, набрав в командной строке терминала gcc -v, мы должны увидеть на экране примерно следующее:
```
Configured with: --prefix=/Applications/Xcode.app/Contents/Developer//usr --with-gxx-include-dir=/usr/include/c++/4.2.1
Apple LLVM version 6.1.0 (clang-602.0.53) (based on LLVM 3.6.0svn)
Target: x86_64-apple-darwin14.3.0
Thread model: posix
```
2. **Установить command line tools**
Если пропустить этот шаг, компилятор не сможет найти стандартные библиотеки C и C++. В терминале необходимо запустить
```
xcode-select --install
```
и следовать инструкциям.
3. **Собрать Clang c поддержкой OpenMP**
Эта версия компилятора поддерживает OpenMP-инструкции для распараллеливания и разрабатывается сотрудниками Intel. Можно надеяться, что в один прекрасный день эта ветка вольется обратно в транк, и OpenMP будет доступно в оригинальном Clang из коробки. Судя по всему, некоторое время назад можно было установить clang-omp с помощью brew, но это счастливое время прошло. Итак, собираем компилятор:
```
mkdir clang-omp && cd clang-omp
git clone https://github.com/clang-omp/llvm
git clone https://github.com/clang-omp/compiler-rt llvm/projects/compiler-rt
git clone -b clang-omp https://github.com/clang-omp/clang llvm/tools/clang
mkdir build && cd build
cmake ../llvm -DCMAKE_BUILD_TYPE=Release
make -j 4
```
Если ядер на машине больше 4, имеет смысл поправить цифру в последней команде.
4. **Собрать Intel OpenMP библиотеку**
Библиотека для поддержки OpenMP так же собирается из исходников. [Скачиваем](https://www.openmprtl.org/download#stable-releases), распаковываем, собираем:
```
mkdir build && cd build
cmake ..
make -j 4
```
5. **Прописать путь к OpenMP библиотеке и соответствующим хидерам**
Чтобы компилятор и линкер при сборке XGBoost смогли найти необходимые им компоненты, нужно прописать к ним пути. Для этого необходимо добавить в ~/.bash\_profile следующие строки:
```
export C_INCLUDE_PATH=PATH_TO_LIBOMP/libomp/exports/common/include/:$C_INCLUDE_PATH
export CPLUS_INCLUDE_PATH=PATH_TO_LIBOMP/libomp/exports/common/include/:$CPLUS_INCLUDE_PATH
export LIBRARY_PATH=PATH_TO_LIBOMP/libomp/exports/mac_32e/lib/:$LIBRARY_PATH
export DYLD_LIBRARY_PATH=PATH_TO_LIBOMP/libomp/exports/mac_32e/lib/:$DYLD_LIBRARY_PATH
```
Как можно догадаться, PATH\_TO\_LIBOMP — путь к папке, где лежит библиотека. Чтобы изменения вступили в силу, необходимо выполнить команду
```
source ~/.bash_profile
```
Необходимо убедиться, что все работает корректно. Для этого создадим программу-сэмпл
```
#include
#include
#include
int main(int argc, char\*\* argv) {
std::cout << "Hello!" << std::endl;
#pragma omp parallel
printf("Hello from thread %d, nthreads %d\n", omp\_get\_thread\_num(), omp\_get\_num\_threads());
return 0;
}
```
и попытаемся ее скомпилировать:
```
PATH_TO_CLANGOMP/clang-omp/build/bin/clang++ sample.cpp -o sample -fopenmp
```
Если все хорошо, запустив программу, мы увидим на экране сообщения из нескольких тредов.
6. **Собрать XGBoost**
Мы почти у цели. В папке xgboost лежит Makefile, первые строчки которого необходимо отредактировать следующим образом:
```
export CC = PATH_TO_CLANGOMP/clang-omp/build/bin/clang
export CXX = PATH_TO_CLANGOMP/clang-omp/build/bin/clang++
export MPICXX = mpicxx
export LDFLAGS= -pthread -lm
export CFLAGS = -Wall -O3 -msse2 -Wno-unknown-pragmas -funroll-loops -fopenmp
```
Собираем:
```
make -j 4
```
Победа.
7. **Установить обвязку для Python**
```
cd wrapper
python setup.py install
```
Убедиться, что обвязка XGBoost работает должным образом, можно с помощью демо-скриптов, лежащих в xgboost/demo.
8. **Покорять топы лидербордов на Kaggle**
Внезапно отключилось электричество, и эта самая важная часть, к сожалению, была утрачена и будет освещена в дальнейшем. | https://habr.com/ru/post/277189/ | null | ru | null |
# Приложение в честь Дня святого Валентина на libgdx
Периодически появляются топики, посвященные дню Валентина. В этом году я тоже решился включиться в эту тему и сделать что-нибудь оригинальное и необычное. Было решено создать простенькое приложение под Android с сердечками, которые бы имели свои физические модели и взаимодействовали друг с другом. Позже я добавил текст, звуки, частицы и некоторые другие красивости. В результате получилось даже что-то вменяемое и оригинальное! В данной статье описывается процесс создания вместе описанием возможностей и подводных камней библиотеки **libgdx**.
[](https://habr.com/ru/post/137861/).
Содержание
----------
* [Программы и инструменты](#programmy-i-instrumenty)
* [Hello World](#hello-world)
* [Общее](#obschee)
* [Текстуры](#tekstury)
* [Шрифты](#shrifty)
* [Физика](#fizika)
* [Система частиц](#sistema-chastic)
* [Звуки](#zvuki)
* [Заключение](#zaklyuchenie)
* [Исходники и исполняемые файлы](#ishodniki-i-ispolnyaemye-fayly)
Программы и инструменты
-----------------------
Для реализации задумки использовались следующие программы и библиотеки:
1. [**IntelliJ IDEA**](http://ru.wikipedia.org/wiki/IntelliJ_IDEA) — свободная среда разработки модульных и кроссплатформенных приложений. В качестве альтернативы подходит [Android Studio](https://developer.android.com/studio/), [Eclipse](https://www.eclipse.org/).
2. [**libgdx**](https://libgdx.badlogicgames.com/) — кроссплатформенная (PC, Mac, Linux, Android) Java-библиотека для разработки игр и не других графических приложений. Эта библиотека распространяется под лицензией Apache License 2.0. Некоторые участки кода оптимизированы с помощью JNI (например Box2d).
3. [**box2d-editor**](https://github.com/MovingBlocks/box2d-editor) — Редактор для создания физических моделей, используемых в физическом движке box2d, который встроен в libgdx. Здесь он будет использоваться для сопоставления рисунка сердечка и его физической модели.
4. [**Hiero bitmap font generator**](https://github.com/libgdx/libgdx/wiki/Hiero) — Программа для конвертации векторных шрифтов в растровые (поскольку в libgdx поддерживаются только растровые).
5. [**Particle Editor**](https://github.com/libgdx/libgdx/wiki/2D-Particle-Editor) — редактор для создания систем частиц от автора libgdx. Используется для частиц в эффекте "взрыва" при уничтожении сердечка.
6. [**Paint.NET**](http://www.getpaint.net/index.html) — использовался для редактирования изображения сердечка и создания фона.
Все программы и компоненты свободно распространяются, а это большой плюс. Мой выбор пал на библиотеку libgdx, потому что, во-первых, я уже имею некоторый опыт работы с ней, а, во-вторых, при ее использовании отпадает необходимость в медленном Android эмуляторе, поскольку она является кроссплатформенной и позволяет тестировать приложения в нативном java окружением с последующей компиляцией под "зелененького".
Hello World
-----------
Сначала я в двух словах расскажу как создавать проекты libgdx. С помощью `gdx-setup.jar` генерируется шаблон проекта (на основе Grandle), в котором указываются нужные целевые платформы. В настоящий момент поддерживаются `Desktop`, `Android`, `Ios`, `Html`. Правда последние два попробовать не удалось, т.к. не обладаю Ios операционной системой, а с Html возникли сложности, решить которые пока что не удалось.
Также сразу же можно выбрать используемые расширения. В нашем случае — это библиотека физики Box2d.
Впрочем, все это подробно расписано в вики: [Creating a libgdx project](https://github.com/libgdx/libgdx/wiki/Project-Setup-Gradle).
После генерации создается три папки:
* core
* desktop
* android
В двух последних помещаются лаунчеры под соответствующие платформы `DesktopLauncher` и `AndroidLauncher`, которые выглядят так:
```
public class DesktopLauncher {
public static void main (String[] arg) {
LwjglApplicationConfiguration config = new LwjglApplicationConfiguration();
config.width = 800;
config.height = 480;
new LwjglApplication(new ValentinesDayHeartsApp(), config);
}
}
```
```
public class AndroidLauncher extends AndroidApplication {
@Override
protected void onCreate (Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
AndroidApplicationConfiguration config = new AndroidApplicationConfiguration();
initialize(new ValentinesDayHeartsApp(), config);
}
}
```
Специфичного под Android кода больше не будет, что является большим достоинством выбранной библиотеки. Единственно, нужно разрешить вибрацию и запрет спящего режима (чтобы мир не сбрасывался ) в конфигурации `AndroidManifest.xml`. А также установить альбомную ориентацию, чтобы мир не переворачивался:
```
```
и
```
android:screenOrientation="landscape"
```
В core хранится общий код. Главным классом является `ValentinesDayHeartsApp`, который реализует интерфейсы `ApplicationListener` для обработки событий инициализации, рендера, финализации и других состояний и `InputProcessor` для того чтобы можно было обрабатывать пользовательский ввод.
Все, каркас готов! Теперь данное приложение будет работать и под PC и под Android.
Общее
-----
Проект имеет простую структуру: в классе `ValentinesDayHeatsApp` перегружаются методы `create`, `render`, `dispose`, `touchDown`. В методе `create` происходит инициализация всех ресурсов (текстуры, шрифты, частицы, звуки), создание физического мира. В методе `render` происходит просчет и отрисовка всех объектов мира:
```
@Override
public void render() {
updatePhysics();
updateBackground();
updateSprites();
updateParticles();
refresh();
renderBackground();
renderHearts();
renderFonts();
renderParticles();
}
```
В методе `dispose` — освобождение всех ресурсов. Да, да, несмотря на то, что в Java есть автоматическая сборка мусора, неуправляемые ресурсы (объекты Box2d и некоторые другие) все равно необходимо освобождать вручную. Метод `touchDown` срабатывает на клик мышкой или прикосновение к тачскрину. Работает так: если точка соприкосновения пересекается с некоторым сердечком, то оно удаляется. В противном случае, новое сердечко создается в месте клика. Объект \"сердце\" `Heart` имеет следующие свойства:
* `Body` — физическая модель.
* `Sprite` — графическая модель (спрайт).
* `String` — отображаемый на сердце текст.
* `Font` — шрифт, которым рисуется текст.
* `ParticleEffect` — создающиеся при уничтожении частицы.
* `BreakSound` — звук при уничтожении.
Далее я опишу компоненты приложения подробней.
Текстуры
--------
Сперва надо было найти или создать непосредственно само сердечко. К счастью, я его легко нагуглил, а затем немного отредактировал: добавил свечение и прозрачный фон. Для загрузки текстур в libgdx использовал класс `Texture`. Так как одна и та же текстура может быть задействована несколько раз, использовались дополнительные объекты `Sprite`. Они отрисовываются в методе `render`. Позиция спрайта и угол являются параметрами отрисовки и физической модели сердечка. Для разнообразия я решил сделать так, чтобы сердца имели цвета с различными оттенками. Для этого использовалась палитра HSL, которая позволяет манипулировать оттенком, насыщенностью и осветленностью, а не непосредственно компонентами цвета как RGB. Формулу преобразования RGB -> HSL и HSL -> RGB можно легко найти, а я портировал методы из статьи [Manipulating colors in .NET](http://www.codeproject.com/Articles/19045/Manipulating-colors-in-NET-Part-1) на Java. Все преобразования находятся в методах `prepareHeartsTextures`, `prepareHslData` и `generateHeartTexture`. Вот пример одного:
```
Pixmap pixmap = new Pixmap(fileHandle);
float[][][] result = new float[pixmap.getWidth()][pixmap.getHeight()][4];
for (int i = 0; i < pixmap.getWidth(); i++)
for (int j = 0; j < pixmap.getHeight(); j++) {
int color = pixmap.getPixel(i, j);
float r = (float)((color >> 24) & 0xFF) / 255.0f;
float g = (float)((color >> 16) & 0xFF) / 255.0f;
float b = (float)((color >> 8) & 0xFF) / 255.0f;
float a = (float)(color & 0xFF) / 255.0f;
result[i][j] = ColorUtils.RgbToHsl(r, g, b, a);
}
return result;
```
К сожалению, Android приложение загружается с некоторой задержкой из-за генерации текстур с разными оттенками.
Шрифты
------
Так как libgdx умеет работать только с растровыми шрифтами, я использовал программу **Hiero Bitmap Font Generator** (версия 5), которая создает изображения всех символов в формате *png* и файл *fnt*, который содержит информацию о координатах каждого символа на изображении. Вот скрин этой программы:
После того как необходимые файлы сгенерированы, шрифт можно использовать в libgdx приложении следующим образом:
```
font = new BitmapFont(
Gdx.files.internal("data/Jura-Medium.fnt"),
Gdx.files.internal("data/Jura-Medium.png"), false);
font.setColor(Color.WHITE);
```
и потом рендерить так:
```
font.draw(spriteBatch, heart.String, screenPosition.x, screenPosition.y);
```
При рендере я столкнулся с некоторыми нюансами: например, шрифт нельзя рендерить под углом, как это можно делать со спрайтом. Для решения этой проблемы нужно изменять проективную матрицу у `SpriteBatch`, а затем рендерить шрифт следующим образом:
```
Matrix4 projection = spriteBatch.getProjectionMatrix();
projection.setToOrtho2D(0, 0, WorldWidth, WorldHeight);
projection.translate(tmpVector1.x, tmpVector1.y, 0);
projection.rotate(0, 0, 1, body.getAngle() / (float)Math.PI * 180);
projection.translate(-tmpVector1.x, -tmpVector1.y, 0);
Vector2 stringSize = heart.getStringSize();
tmpVector1.add(heart.Size.x / PhysWorldWidth * WorldWidth * CenterDisplacement.x
- stringSize.x * 0.5f,
heart.Size.y / PhysWorldHeight * WorldHeight * CenterDisplacement.y
+ stringSize.y);
spriteBatch.begin();
BitmapFont.BitmapFontData fontData = font.getData();
fontData.setScale(heart.Size.x * FontSizeHeartSizeCoef.x, heart.Size.y * FontSizeHeartSizeCoef.y);
font.draw(spriteBatch, heart.String, tmpVector1.x, tmpVector1.y);
fontData.setScale(1, 1);
spriteBatch.end();
```
Физика
------
В качестве физического движка использовался **box2d**.
Для сопоставления графической и физической моделей сердца я использовал **box2d-editor**:
С помощью данной программы я создал полигон сердечка, который автоматически разбился на выпуклые многоугольники. Физическая модель по сути представляет собой набор координат этих многоугольников в формате json.
Далее этот файл используются в приложении (загрузка происходит в методе `addHeart`). libgdx умеет загружать файлы только в бинарном формате. К счастью, был найден класс [BodyEditorLoader.java](https://gist.github.com/zudov/5566204), с помощью которого можно загрузить модель и из JSON, т.е. текстового представления.
Не забываем задать плотность, трение и упругость телу:
```
FixtureDef fdef = new FixtureDef();
fdef.density = 0.75f;
fdef.friction = 1.0f;
fdef.restitution = 0.4f;
bodyLoader.attachFixture(body, "Heart", fdef, newWidth);
body.resetMassData();
```
Все, теперь сердца обладают еще и физической оболочкой!
Для того, чтобы сердца не улетали за экран, по бокам в нашем мирке просто создаются четыре статичных прямоугольника. На мобильных устройствах целесообразно менять гравитацию в зависимости от ориентации:
```
if (Gdx.app.getType() == ApplicationType.Android) {
gravity.x = -Gdx.input.getPitch() / 90.0f;
gravity.y = Gdx.input.getRoll() / 90.0f;
gravity.mul(gravityCoef);
world.setGravity(gravity);
}
```
Система частиц
--------------
В libgdx система частиц задается с помощью специальных файлов, которые могут быть сгенерированы в редакторе:
.
Как видно, этот редактор имеет достаточно много настроек: можно загружать различные текстуры, менять время жизни, форму распространения, прозрачность и другие параметры. Я же сделал частицы в виде сердечек, которые будут появляться при нажатии и уничтожении одного большого физического сердечка. В приложении работа с частицами происходит следующим образом:
### Инициализация
```
ParticleEffect effect = new ParticleEffect();
effect.load(Gdx.files.internal("data/destroy.p"), Gdx.files.internal("data"));
```
### Начало жизненного цикла
Важно не забыть про `start` без которого частицы не будут отображаться:
```
effect.setPosition(.., ..);
effect.start();
```
Звуки
-----
Звуки загружаются следующим образом:
```
sound = Gdx.audio.newSound(Gdx.files.internal("path/to/file"));
```
и затем проигрываются так:
```
sound.play(1);
```
Казалось бы, что может быть проще? Однако здесь также есть свои подводные камни. Дело в том, что почему-то загружались файлы только в формате **.ogg** и битрейте **96 кБит/сек**.
Заключение
----------
Надеюсь описанные в статье знания будут полезны многим, и они пригодятся в для разработки игр с использованием libgdx. Исходники и ресурсы разрешается использовать всем. Дарите приложения на День святого Валентина своим половинкам :)
Стоит отметить, что все слова, отображаемые на сердечках, можно менять в файле `data/words.txt`. Это работает даже без перекомпиляции.
Исходники и исполняемые файлы
-----------------------------
* Исходники: <https://github.com/KvanTTT/ValentinesDayHearts>
* Кроссплатформенный jar исполняемый файл: [ValentinesDayHearts-1.1.jar](https://github.com/KvanTTT/ValentinesDayHearts/releases/download/1.1/ValentinesDayHearts-1.1.jar)
* Apk файл для Android: [ValentinesDayHearts-1.1.apk](https://github.com/KvanTTT/ValentinesDayHearts/releases/download/1.1/ValentinesDayHearts-1.1.apk) | https://habr.com/ru/post/137861/ | null | ru | null |
# Книга «C# 9 и .NET 5. Разработка и оптимизация»
[](https://habr.com/ru/company/piter/blog/585370/) Привет, Хаброжители! В этой книге опытный преподаватель Марк Прайс дает все необходимое для разработки приложений на C#. В пятом издании для работы со всеми основными операционными системами используется популярный редактор кода Visual Studio Code. Издание полностью обновлено и дополнено новой главой, касающейся Microsoft Blazor.
В первой части книги рассмотрены основы C#, включая объектно-ориентированное программирование и новые возможности C# 9, такие как создание экземпляров новых объектов с целевым типом и работа с неизменяемыми типами с использованием ключевого слова record. Во второй части рассматриваются API .NET для выполнения таких задач, как управление данными и запросы к ним, мониторинг и повышение производительности, а также работа с файловой системой, асинхронными потоками, сериализацией и шифрованием. В третьей части на примерах кросс-платформенных приложений вы сможете собрать и развернуть собственные: например, веб-приложения с использованием ASP.NET Core или мобильные приложения на Xamarin Forms.
К концу книги вы приобретете знания и навыки, необходимые для использования C# 9 и .NET 5 для разработки сервисов, веб- и мобильных приложений.
Реализация интерфейсов и наследование классов
---------------------------------------------
Данная глава посвящена созданию новых типов на основе существующих с использованием *объектно-ориентированного программирования (ООП)*. Вы узнаете о том, как определять операции и локальные функции для выполнения простых действий, как определять делегаты и события для обмена сообщениями между типами, как реализовывать интерфейсы для разработки общей функциональности, и о дженериках. Кроме того, узнаете о разнице между ссылочными типами и типами значений, о том, как создавать новые классы, наследуя их от базовых для многократного применения функциональности, как переопределять член типа, использовать полиморфизм, создавать методы расширения и выполнять приведение классов в иерархии наследования.
**В этой главе:**
* настройка библиотеки классов и консольного приложения;
* упрощение методов;
* вызов и обработка событий;
* реализация интерфейсов;
* оптимизация типов под многократное использование с помощью дженериков;
* управление памятью с помощью ссылочных типов и типов значений;
* наследование классов;
* приведение в иерархиях наследования;
* наследование и расширение типов .NET.
### Настройка библиотеки классов и консольного приложения
Мы начнем с определения рабочей области с двумя проектами, подобного созданному в главе 5. Если вы выполнили все упражнения в той главе, то можете открыть созданную тогда рабочую область и продолжить работу.
В противном случае следуйте приведенным ниже инструкциям.
1. В существующей папке Code создайте папку Chapter06 с двумя подпапками, PacktLibrary и PeopleApp, как показано в следующей иерархии:
* Chapter06
— PacktLibrary
— PeopleApp
2. Запустите программу Visual Studio Code.
3. Выберите команду меню File ->Save Workspace As (Файл -> Сохранить рабочую область как), введите имя Chapter06 и нажмите кнопку Save (Сохранить).
4. Выберите команду меню File->Add Folder to Workspace (Файл->Добавить папку в рабочую область), выберите папку PacktLibrary и нажмите кнопку Add (Добавить).
5. Выберите команду меню File->Add Folder to Workspace (Файл->Добавить папку в рабочую область), выберите папку PeopleApp и нажмите кнопку Add (Добавить).
6. Выберите команду меню Terminal->New Terminal (Терминал->Новый терминал) и выберите PacktLibrary.
7. На панели TERMINAL (Терминал) введите следующую команду:
```
dotnet new classlib
```
8. Выберите команду меню Terminal->New Terminal (Терминал->Новый терминал) и выберите PeopleApp.
9. На панели TERMINAL (Терминал) введите следующую команду:
```
dotnet new console
```
10. На панели EXPLORER (Проводник) в проекте PacktLibrary переименуйте файл Class1.cs в Person.cs.
11. Измените содержимое файла:
```
using System;
namespace Packt.Shared
{
public class Person
{
}
}
```
12. На панели EXPLORER (Проводник) разверните папку PeopleApp и щелкните кнопкой мыши на файле PeopleApp.csproj.
13. Добавьте ссылку на проект в PacktLibrary:
```
Exe
netcoreapp3.0
```
14. На панели TERMINAL (Терминал) для папки PeopleApp введите команду dotnet build и обратите внимание на выведенную информацию, указывающую, что оба проекта были успешно созданы.
15. Добавьте операторы в класс Person для определения трех полей и метода, как показано ниже:
```
using System;
using System.Collections.Generic;
using static System.Console;
namespace Packt.Shared
{
public class Person
{
// поля
public string Name;
public DateTime DateOfBirth;
public List Children = new List();
// методы
public void WriteToConsole()
{
WriteLine($"{Name} was born on a {DateOfBirth:dddd}.");
}
}
}
```
### Упрощение методов
Сделаем так, чтобы два экземпляра человека произвели потомство. Мы можем реализовать это, написав методы. Методы экземпляра — действия, которые объект выполняет для себя; статические методы — действия, которые выполняет сам тип. Ваш выбор зависит от того, что больше всего подходит для действия.
> Имеет смысл использовать статические методы и методы экземпляров для выполнения аналогичных действий. Например, тип string имеет как статический метод Compare, так и метод экземпляра CompareTo. Это позволяет программистам, применяющим ваш тип, выбрать, как задействовать функциональность, тем самым увеличивая гибкость.
#### Реализация функционала с помощью методов
Начнем с реализации некоторых функций, используя методы.
1. Добавьте один метод экземпляра и один статический метод в класс Person, который позволит двум объектам Person производить потомство:
```
// статический метод «размножения»
public static Person Procreate(Person p1, Person p2)
{
var baby = new Person
{
Name = $"Baby of {p1.Name} and {p2.Name}"
};
p1.Children.Add(baby);
p2.Children.Add(baby);
return baby;
}
// метод «размножения» экземпляра класса
public Person ProcreateWith(Person partner)
{
return Procreate(this, partner);
}
```
Обратите внимание на следующие моменты:
* в статическом методе static с именем Procreate объекты Person для создания передаются как параметры с именами p1 и p2;
* новый класс Person с именем baby создается с именем, составленным из комбинации двух человек, которые произвели потомство;
* объект baby добавляется в коллекцию Children обоих родителей, а затем возвращается. Классы — это ссылочные типы, то есть добавляется ссылка на объект baby, сохраненный в памяти, но не копия объекта;
* в методе экземпляра ProcreateWith объект Person, для которого производится потомство, передается в качестве параметра partner, и он вместе с this передается статическому методу Procreate для повторного использования реализации метода. Ключевое слово this ссылается на текущий экземпляр класса.
> Метод, который создает новый объект или модифицирует существующий объект, должен возвращать ссылку на этот объект, чтобы вызывающая сторона могла видеть результаты.
2. В проекте PeopleApp в начале файла Program.cs импортируйте пространство имен для нашего класса и статически импортируйте тип Console, как показано ниже:
```
using System;
using Packt.Shared;
using static System.Console;
```
3. В методе Main создайте трех человек, у которых появятся дети, отметив, что для добавления символа двойной кавычки в строку необходимо поставить перед ним символ обратной косой черты с кавычкой, \":
```
var harry = new Person { Name = "Harry" };
var mary = new Person { Name = "Mary" };
var jill = new Person { Name = "Jill" };
// вызов метода экземпляра
var baby1 = mary.ProcreateWith(harry);
// вызов статического метода
var baby2 = Person.Procreate(harry, jill);
WriteLine($"{harry.Name} has {harry.Children.Count} children.");
WriteLine($"{mary.Name} has {mary.Children.Count} children.");
WriteLine($"{jill.Name} has {jill.Children.Count} children.");
WriteLine(
format: "{0}'s first child is named \"{1}\".",
arg0: harry.Name,
arg1: harry.Children[0].Name);
```
4. Запустите приложение и проанализируйте результат:
```
Harry has 2 children.
Mary has 1 children.
Jill has 1 children.
Harry's first child is named "Gary".
```
#### Реализация функционала с помощью операций
Класс System.String имеет статический метод Concat, который объединяет два строковых значения и возвращает результат:
```
string s1 = "Hello ";
string s2 = "World!";
string s3 = string.Concat(s1, s2);
WriteLine(s3); // => Hello World!
```
Вызов метода, подобного Concat, работает, но программисту может быть привычнее использовать символ + для сложения двух строковых значений:
```
string s1 = "Hello ";
string s2 = "World!";
string s3 = s1 + s2;
WriteLine(s3); // => Hello World!
```
Хорошо известная библейская фраза «Плодитесь и размножайтесь», то есть «производите потомство». Напишем код так, чтобы символ \* (умножение) позволял создавать два объекта Person.
Мы делаем это путем определения статической операции для символа \*. Синтаксис скорее похож на метод, поскольку, по сути, операция — это метод, но вместо имени метода используется символ, что сокращает синтаксис.
> Символ \* — лишь один из многих символов, которые можно использовать в качестве операции. Полный список символов приведен на сайте [docs.microsoft.com/ru-ru/dotnet/csharp/programming-guide/statements-expressions-operators/overloadable-operators](https://docs.microsoft.com/ru-ru/dotnet/csharp/programming-guide/statements-expressions-operators/overloadable-operators).
1. В проекте PacktLibrary в классе Person создайте статическую операцию для символа \*:
```
// операция "размножения"
public static Person operator *(Person p1, Person p2)
{
return Person.Procreate(p1, p2);
}
```
> В отличие от методов, операции не отображаются в списках IntelliSense для типа. Для каждой операции, которую вы определяете, также создайте метод, поскольку программисту может быть неочевидно, что операция доступна. Реализация операции может затем вызвать метод, повторно используя написанный вами код. Вторая причина предоставления метода заключается в том, что операции поддерживаются не каждым языковым компилятором.
2. В методе Main после вызова статического метода Procreate создайте еще один объект baby с помощью операции \*:
> // вызов статического метода
>
> var baby2 = Person.Procreate(harry, jill);
>
>
>
> // вызов операции
>
> var baby3 = harry \* mary;
3. Запустите приложение и проанализируйте результат:
```
Harry has 3 children.
Mary has 2 children.
Jill has 1 children.
Harry's first child is named "Gary".
```
#### Реализация функционала с помощью локальных функций
К новым возможностям языка C# 7.0 относятся *локальные функции*.
Это, по сути, перенос идеи локальных переменных на методы. Другими словами, локальными функциями являются методы, которые видимы и могут быть вызваны только в пределах метода, в котором были определены. В других языках программирования такие функции иногда называются *вложенными* или *внутренними*.
Локальные функции могут быть определены где угодно внутри метода: в начале, в конце или даже где-то посередине!
Мы воспользуемся локальной функцией для вычисления факториала.
1. В классе Person добавьте операторы, чтобы определить функцию Factorial, которая использует локальную функцию внутри себя для вычисления результата, как показано ниже:
```
// метод с локальной функцией
public int Factorial(int number)
{
if (number < 0)
{
throw new ArgumentException(
$"{nameof(number)} cannot be less than zero.");
}
return localFactorial(number);
int localFactorial(int localNumber) // локальная функция
{
if (localNumber < 1) return 1;
return localNumber * localFactorial(localNumber - 1);
}
}
```
2. В проекте Program.cs в методе Main добавьте оператор для вызова функции Factorial и запишите возвращаемое значение в консоль:
```
WriteLine($"5! is {harry.Factorial(5)}");
```
3. Запустите консольное приложение и проанализируйте результат:
```
5! is 120
```
### Вызов и обработка событий
*Методы* часто описываются как *действия, которые может выполнять объект*. К примеру, класс List может добавить в себя элемент или очистить сам себя, а File может создавать или удалять файл в файловой системе.
*События* часто описываются как *действия, которые происходят с объектом*. Например, в пользовательском интерфейсе Button есть событие Click, определяющее, что происходит с кнопкой при щелчке на ней. События можно охарактеризовать еще и как способ обмена сообщениями между двумя объектами.
События построены на делегатах, поэтому начнем с рассмотрения того, как работают делегаты.
#### Вызов методов с помощью делегатов
Вы уже знакомы с наиболее распространенным способом вызова или выполнения метода, который заключается в синтаксисе с точкой для доступа к методу по его имени. Например, метод Console.WriteLine дает типу Console задание выводить сообщения с помощью метода WriteLine.
Другой способ вызова или выполнения метода заключается в использовании *делегата*. Если вы использовали языки, поддерживающие *указатели на функции*, то делегат можно представить, как *типобезопасный указатель на метод*.
Другими словами, делегат — это адрес метода в памяти, имеющего ту же сигнатуру, что и делегат, чтобы его можно было безопасно вызвать.
Для примера представьте, что в классе Person существует метод, который должен иметь тип string, передаваемый как единственный параметр, и возвращать int:
```
public int MethodIWantToCall(string input)
{
return input.Length; // неважно, что здесь выполняется
}
```
Я мог бы вызвать этот метод на экземпляре Person с именем p1 следующим образом:
```
int answer = p1.MethodIWantToCall("Frog");
```
Как вариант, я мог бы определить делегат с совпадающей сигнатурой для косвенного вызова метода. Обратите внимание: имена параметров могут не совпадать. Должны совпадать только типы параметров и возвращаемые значения, как показано в коде ниже:
```
delegate int DelegateWithMatchingSignature(string s);
```
Теперь я могу создать экземпляр делегата, указать его на метод и, наконец, вызвать делегат (который вызывает метод!):
```
// создание экземпляра делегата, который указывает на метод
var d = new DelegateWithMatchingSignature(p1.MethodIWantToCall);
// вызов делегата, который вызывает метод
int answer2 = d("Frog");
```
Вероятно, вы задались вопросом: «А в чем смысл?» Отвечу лаконично — в гибкости.
Например, мы могли бы использовать делегаты для создания очереди методов, которые нужно вызвать по порядку. Действия в очереди, которые необходимо выполнить, распространены в сервисах для обеспечения улучшенной масштабируемости.
Другой пример — разрешить параллельное выполнение нескольких действий. Делегаты имеют встроенную поддержку асинхронных операций, которые выполняются в другом потоке, что может обеспечить улучшенную скорость отклика. Вы узнаете, как это сделать, в главе 13.
Делегаты позволяют реализовывать события для отправки сообщений между различными объектами, которые не должны знать друг о друге.
Делегаты и события — одни из самых продвинутых функций языка C#, и обучение им может занять некоторое время, поэтому не беспокойтесь, если сразу не поняли принцип их работы!
#### Определение и обработка делегатов
Microsoft предоставляет два предопределенных делегата для использования в качестве событий. Они выглядят следующим образом:
```
public delegate void EventHandler(
object sender, EventArgs e);
public delegate void EventHandler(
object sender, TEventArgs e);
```
> Если хотите определить событие в собственном типе, то вам следует использовать один из этих двух предопределенных делегатов.
1. Добавьте код, показанный ниже, в класс Person и обратите внимание на следующие моменты:
* код определяет поле делегата EventHandler с именем Shout;
* код определяет поле int для хранения AngerLevel;
* код определяет метод Poke;
* каждый раз, когда человека толкают (Poke), уровень его раздражения (AngerLevel) растет. Когда уровень раздражения достигает 3, поднимается событие Shout (возмущенный возглас), но только если делегат события указывает на метод, определенный где-либо еще в коде, то есть не null.
```
// событие
public event EventHandler Shout;
// поле
public int AngerLevel;
// метод
public void Poke()
{
AngerLevel++;
if (AngerLevel >= 3)
{
// если что-то слушает...
if (Shout != null)
{
// ...то вызывается делегат
Shout(this, EventArgs.Empty);
}
}
}
```
Проверка, является ли объект null до вызова одного из его методов, выполняется очень часто. Версия C# 6.0 и более поздние версии позволяют упростить проверки на null, вместив их в одну строку:
```
Shout?.Invoke(this, EventArgs.Empty);
```
2. В Program добавьте метод с соответствующей сигнатурой, который получает ссылку на объект Person из параметра sender и выводит некоторую информацию о них:
```
private static void Harry_Shout(object sender, EventArgs e)
{
Person p = (Person)sender;
WriteLine($"{p.Name} is this angry: {p.AngerLevel}.");
}
```
ObjectName\_EventName — соглашение Microsoft для имен методов, которые обрабатывают события.
3. В методе Main добавьте оператор для назначения метода полю делегата, как показано ниже:
```
harry.Shout = Harry_Shout;
```
4. Добавьте операторы для вызова метода Poke четыре раза после назначения метода для события Shout:
```
harry.Shout = Harry_Shout;
harry.Poke();
harry.Poke();
harry.Poke();
harry.Poke();
```
Делегаты — многоадресные; это значит, вы можете назначить несколько делегатов одному полю делегата. Вместо оператора присваивания = мы могли бы использовать оператор +=, чтобы добавить больше методов к тому же полю делегата. При вызове делегата вызываются все назначенные методы, хотя вы не можете контролировать порядок их вызова.
5. Запустите приложение и проанализируйте результат, как показано в следующем выводе, и обратите внимание, что Гарри первое время только злится и начинает кричать после того, как его толкнут не менее трех раз:
```
Harry is this angry: 3.
Harry is this angry: 4.
```
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/c-9-i-net-5-razrabotka-i-optimizatsiya)
» [Оглавление](https://www.piter.com/collection/new/product/c-9-i-net-5-razrabotka-i-optimizatsiya#Oglavlenie-1)
» [Отрывок](https://www.piter.com/collection/new/product/c-9-i-net-5-razrabotka-i-optimizatsiya#Otryvok-1)
Для Хаброжителей скидка 25% по купону — **C#**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/585370/ | null | ru | null |
# Методика формирования измерения с атрибутами типа 1 и 2
Мы работаем над DWH в телекоммуникациях, поэтому пример, который я рассматриваю, называется «Абонент». Принцип универсален и это мог быть «Клиент» или «Пациент» — в зависимости от отрасли. Я надеюсь методику найдут полезной разработчики DWH из разных отраслей.
Если Вы не понимаете, что такое DWH, измерения и факты, я рекомендую прочитать книгу Ральфа Кимбалла «Dimensional Modeling». Речь идёт о базе данных для аналитики и консолидированной отчетности предприятия, конкретно о формировании и актуализации измерений — таблиц, которые хранят атрибуты (поля) для отбора (WHERE) в будущих запросах.
Наша методика предназначена для Microsoft SQL Server.
#### Принцип определения изменений
Определение изменения атрибутов типа 1 (перезаписываемый) и 2 (с хранением истории в записях измерения) выполняется на основе сравнения контрольных сумм полей.
Для вычисления контрольных сумм используется функция T-SQL CHECKSUM, не поддерживающая типы text, ntext, image, которые и не должны помещаться в измерения. Использование BINARY\_CHECKSUM на практике показало, что возможно ложное детектирование изменений в полях, содержащих NULL. С данной методикой возможно использование кастомных функций контрольной суммы, разработанных на .NET.
#### Объявление измерения
Измерение должно быть объявлено с первичным ключом, содержащим кластерный индекс.
Пример SQL скрипта объявления измерения “Абонент”:
```
USE [DWH]
GO
/* Убедиться в существовании схемы Dim */
IF SCHEMA_ID('Dim') IS NULL
EXECUTE('CREATE SCHEMA [Dim] AUTHORIZATION [dbo]')
GO
/* Удалить Абонент */
IF EXISTS ( SELECT *
FROM dbo.sysobjects
WHERE id = OBJECT_ID(N'[Dim].[Абонент]')
AND OBJECTPROPERTY(id, N'IsUserTable') = 1 )
DROP TABLE [Dim].[Абонент]
GO
/* Создать Абонент */
CREATE TABLE [Dim].[Абонент] (
[AccountKey] INT NOT NULL IDENTITY(1,1) PRIMARY KEY CLUSTERED,
[Лицевой счёт] INT NULL,
[Тип абонента] NVARCHAR(13) NOT NULL
CHECK ([Тип абонента] IN (N'Физ.лицо', N'Юр.лицо', N'Не определено')) DEFAULT N'Не определено',
[Провайдер] NVARCHAR(16) NOT NULL DEFAULT N'Не определено',
[Номер договора] NVARCHAR(50) NOT NULL DEFAULT 'Нет в базе данных',
[Дата заключения договора] DATE,
[Дата расторжения договора] DATE,
[Имя] NVARCHAR(100) NOT NULL DEFAULT 'Нет в базе данных',
[Фамилия] NVARCHAR(100) NOT NULL DEFAULT 'Нет в базе данных',
[Отчество] NVARCHAR(100) NOT NULL DEFAULT 'Нет в базе данных',
[Дата рождения] DATE,
[ФИО] AS
[Фамилия] +
CASE WHEN [Имя] != N'Нет в базе данных' THEN N' ' + [Имя] ELSE N'' END +
CASE WHEN [Отчество] != N'Нет в базе данных' THEN N' ' + [Отчество] ELSE N'' END,
[Наименование организации] NVARCHAR(100) NOT NULL DEFAULT N'Нет в базе данных',
...
[Телефоны] NVARCHAR(200) NOT NULL DEFAULT N'Нет в базе данных',
[Телефон для SMS] NVARCHAR(20) NOT NULL DEFAULT N'Нет в базе данных',
[Факс] NVARCHAR(200) NOT NULL DEFAULT N'Нет в базе данных',
[E-mail] NVARCHAR(50) NOT NULL DEFAULT N'Нет в базе данных',
[Средства связи] AS
N'Телефоны: ' + [Телефоны] + N', ' +
N'Телефон для SMS: ' + [Телефон для SMS] + N', ' +
N'Факс: ' + [Факс] + N', ' +
N'E-mail: ' + [E-mail],
[StartTime] DATETIME2 NOT NULL,
[EndTime] DATETIME2 NULL,
[Checksum1] INT NULL,
[Checksum2] INT NULL
)
/* Запись неопределенного Абонента */
SET IDENTITY_INSERT [Dim].[Абонент] ON
INSERT INTO [Dim].[Абонент] ([AccountKey],[Лицевой счёт],[StartTime])
VALUES (-1, NULL, GETDATE())
SET IDENTITY_INSERT [Dim].[Абонент] OFF
GO
```
Нужно наложить на измерение условный индекс по бизнес-ключу с условием [EndTime] IS NULL, содержащий поля контрольных сумм. Включение в индекс контрольных сумм, при условии кластерного индекса первичного ключа таблицы измерения ([AccountKey]), позволяет не считывать саму таблицу измерения при выполнении начального запроса. При этом, индекс выполняет функцию контроля уникальности — одна действующая запись для одного бизнес-ключа.
Пример индекса для измерения “Абонент”:
```
CREATE UNIQUE INDEX IX_Абонент_Уникальность ON [Dim].[Абонент]
([Лицевой счёт], [EndTime])
INCLUDE ([Checksum1], [Checksum2])
WHERE [EndTime] IS NULL
```
##### Типовой начальный SQL запрос
Начальный SQL запрос содержит внутренний подзапрос [i], который получает поля из исходных таблиц-копий и внешний запрос [o], который формирует контрольные суммы, и присоединение актуальной строки измерения по бизнес-ключу.
Пример начального запроса для измерения “Абонент”:
```
SELECT
[o].*,
[Абонент].[Checksum2] AS [OLD_CHECKSUM2],
[Абонент].[Checksum1] AS [OLD_CHECKSUM1],
[Абонент].[AccountKey] AS [OLD_AccountKey]
FROM (
SELECT
i.*,
CHECKSUM(
[Тип абонента],
[Провайдер],
[Номер договора],
[Дата заключения договора],
[Имя],
[Фамилия],
[Отчество],
[Название организации],
[Город],
[Улица],
[Дом],
[Квартира],
[Адрес прописки],
[Паспортные данные]
) AS [CHECKSUM2],
CHECKSUM(
[Телефоны],
[Телефон для SMS],
[E-mail],
[Дата рождения]
) AS [CHECKSUM1]
FROM (
SELECT
FROM [Raw]....
LEFT JOIN [Raw]....
) AS [i] -- внутренний запрос собирает строку
) AS [o] -- внешний запрос считает контрольные суммы
LEFT JOIN [Dim].[Абонент]
ON [o].[Лицевой счёт] = [Абонент].[Лицевой счёт]
AND [Абонент].[EndTime] IS NULL
-- присоединяем последнюю действующую запись измерения
```
Приведение типов (это как правило CAST(… AS NVARCHAR(..)) или IIF(ISDATE([...]) = 1, CAST([...] AS DATE), NULL)), а так же всё связывание исходных таблиц (LEFT JOIN) и условное формирование полей (CASE, IIF) нужно делать во внутреннем запросе — внутри FROM (...) AS [i].
Если логика связывания исходных таблиц слишком сложная (например, нужно вытащить какие-то данные из иерархии) и её невозможно выполнить внутри FROM, тогда перед потоком данных в SSIS, Вам придется вставить SQL Task, формирующий промежуточные данные в отдельных таблицах (соблюдая вашу схему именования объектов). Временные таблицы не подойдут, поскольку по ним SSIS не сможет определить метаданные выходного потока.
Убедиться в корректности взаимодействия индекса и начального запроса можно, посмотрев его план выполнения. В конце плана выполнения не должно быть обращения к таблице:
#### Типовой поток данных
Поток данных формирования измерения выходит из начального SQL запроса, описанного выше, и реализует дальнейшую логику изменения.
В операции “Добавление StartTime” добавляем в поток StartTime, используя время запуска пакета SSIS (берем переменную @[System::StartTime])
В операции “Выявить обновление типа 1” выделяем один поток — “Обновлены поля Type1” на основе выражения !ISNULL(OLD\_CHECKSUM1) && CHECKSUM1 != OLD\_CHECKSUM1.
В операции “Обновить поля типа 1 по бизнес-ключу” обновляем все записи измерения (в том числе уже закрытые записи, содержащие исторические значения полей типа 2), в которых изменились атрибуты первого типа — для этого используем бизнес-ключ без условия отсечения неактуальных записей (без условия по [EndTime]). Пример для “Абонент”:
```
UPDATE [Dim].[Абонент] SET
[Телефоны] = ?,
[Телефон для SMS] = ?,
[E-mail] = ?,
[Дата рождения] = ?
[Checksum1] = ?
WHERE [Лицевой счёт] = ?
```
В операции “Выявить обновление типа 2 и новые записи” выделяем два потока:
1. “Новое” на основе выражения ISNULL(OLD\_AccountKey)
2. “Обновлены поля Type2” на основе выражения CHECKSUM2 != OLD\_CHECKSUM2
В операции “Закрыть изменившиеся строки измерения” обновляем [EndTime] для записей измерения значением StartTime из потока. Пример для “Абонент”:
```
UPDATE [Dim].[Абонент] SET [EndTime] = ? WHERE [AccountKey] = ?
```
В операции “Вставить строки в измерение” вставляем новые строки, при этом, в поле [StartTime] вставляем StartTime из потока, ключ измерения и [EndTime] игнорируем (NULL образующийся в поле [EndTime] будет признаком актуальной записи).
При вставке на последней операции не получится использовать режим Fast Load потому, что вставка, выполняемая в одном потоке с обновлениями, должна оперировать строкой, не расширяя блокировку до уровня таблицы, иначе будут конфликты между одновременно выполняемыми операциями. Альтернативно, Вы можете разнести операции по разным шагам управляющего потока, сохраняя промежуточные результаты в Raw или Cache и соблюдая порядок операций.
#### Использование транзакции
На уровне контейнера потока данных (или общего контейнера, если Вы разнесли операции по шагам управляющего потока) желательно включить транзакцию. Для этого установите TransactionOption = Required (требует DTC) и IsolationLevel не ниже ReadCommitted.
Если транзакции не будет, при прерывании потока данных часть записей измерения может остаться закрытой без вставки соответствующих актуальных записей. При следующем запуске, отсутствующие записи будут вставлены как новые, но со стартовым временем, отличающимся от времени закрытия предыдущей строки. Это следует учитывать, если факты привязываются к измерению способом присоединения записи актуальной на момент возникновения факта — оперировать при привязке измерений только временем закрытия.
#### Сравнение с другими методами
По сравнению с использованием стандартного компонента SQL Server Integration Services, под названием Slowly Changing Dimension, данный метод не использует сравнение каждого поля с каждым полем в строке измерения — он даже не обращается к таблице для выполнения такого сравнения. Это дает основное преимущество — скорость. Кроме того, стандартный Slowly Changing Dimension управляет сразу целой цепочкой элементов и это создает сложность с их кастомизацией. По неизвестным мне причинам, стандартный компонент SSIS может ложно определять изменения (возможно, это так же связано с полями NULL).
Перед коммерческими компонентами сторонних поставщиков есть принципиальное преимущество метода в том, что он базируется на стандартных компонентах и функциях поставляемых с выпуском SQL Server. Таким образом, не требуется ожидать обновленных компонентов для перехода на следующую версию SQL Server.
#### Модификации метода
Возможен модифицированный метод, при котором присоединение выполняется не в SQL запросе, а в потоке данных SSIS через в операцию Lookup. Это приводит к большему количеству обращений к базе и замене эффективного Hash Match на менее эффективные одиночные запросы. С другой стороны, это позволяет разделить исходные таблицы (таблицы-копии, формируемые на стадии загрузки из исходных систем) и таблицы измерений на разные сервера. Но польза от такой возможности у меня вызывает сомнения.
Возможно присоединение в потоке SSIS через операцию Merge Join, но она потребует извлечения таблицы и её сортировки, что сведет на нет преимущества индекса.
Расчёт контрольной суммы так же возможен в потоке данных, например отдельным компонентом, но в этом случае исчезает преимущество отсутствия необходимости в отдельных компонентах.
Расчёт контрольной суммы в потоке данных с помощью Script Transformation на C# — возможный вариант модификации, если в этом усложнении есть смысл.
Обзор реализации (со скриншотами) модифицированного метода (на самом деле предыдущей его версии) с использованием бесплатного стороннего компонента для расчёта контрольных сумм от Konesans и использованием кастомного Lookup (что бы задействовать индекс) можно [увидеть здесь](http://www.larionov.pro/2013/01/slowly-changing-dimensions-ssis.html). | https://habr.com/ru/post/195838/ | null | ru | null |
# Использование V8, часть 3
Использование V8, часть 3
Часть 3. Многопоточность, расширения и оформление кода
Часть 2 находится здесь: [habrahabr.ru/blogs/development/72592](http://habrahabr.ru/blogs/development/72592/)
Часть 1 находится здесь: [habrahabr.ru/blogs/development/72474](http://habrahabr.ru/blogs/development/72474/)
— **Многопоточность**
Многопоточность реализована в V8 просто: ее нет. Вообще. Только один тред может использовать V8 в какой-то момент времени, причем «использовать» означает не обязательно компиляцию или выполнение javascript, но и все остальное — создание темплейтов, размещение объектов на стеке V8 и т.д.
Попробуем подсластить эту бочку дегтя парой ложек меда.
Данное архитектурное решение не является, разумеется, следствием недоразвитости программистов из Гугл. Основное предназначение V8 — это клиентское приложение — браузер Chrome, который на каждую отдельную вкладку запускает отдельный процесс. Этой же схемы следует придерживаться и серверному приложению. В нашем серверном продукте используются т.н. «рабочие» процессы, которые по named pipe присоединяются к основному процессу и получают сообщения на обработку. Это позволяет полностью загружать многоядерные системы и использовать для переключения задач фактически диспетчер процессов самой ОС Windows.
Время от времени в группах обсуждения V8 появляются люди, которые хотят «настоящую» многотредовость. Причем они готовы долго и упорно править исходный код Гугл. Обычно результатом этих дискуссий является следующий вывод: превратить текущий код V8 в многотредовый очень трудно и под силу только самим разработчикам Гугл. Подробнее можно узнать, например, здесь (англ. и необходимо быть участником группы Гугл v8-users): [groups.google.ru/group/v8-users/browse\_thread/thread/44621a6efef0104f](http://groups.google.ru/group/v8-users/browse_thread/thread/44621a6efef0104f)
Однако и одним тредом V8 может распорядиться умнее. Для единоличного «захвата» V8 можно использовать обычную критическую секцию Windows, но лучше воспользоваться средством самого V8: классом Locker. Конструктор этого класса пытается «захватить» V8 (ожидая его освобождения), а деструктор «отпускает» V8. Таким образом, код использующий V8 и безопасно работающий в многотредовом приложении будет выглядеть примерно так:
> `{
>
> v8::Locker locker;
>
> // используем V8
>
> // ...
>
> }
>
> // V8 нами "отпущен"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Проблема в том, что очень часто из javascript кода мы будет вызывать наш С++ код. Например, наш dblite класс из части 2 этой статьи работает с базой данных. Очевидно, что во время его работы V8 простаивает вообщем-то зря — ведь наш C++ код большую часть времени не взаимодействует с V8, а занимается вводом/выводом.
Так вот, хорошая новость в том, что V8 предоставляет класс Unlocker, который позволяет «отпустить» V8 на время. Класс Unlocker в конструкторе «отпускает» V8, а в деструкторе опять «захватывает» (в противоположность классу Locker). Прелесть в том, что Locker-ы можно вкладывать друг в друга и Unlocker это знает и правильно отработает, то есть освободит V8 независимо от глубины вложенности Locker-ов.
Сказанное можно проиллюстрировать исправлением нашего примера из части 2 статьи с классом dblite. Перепишем функцию Open с учетом новых знаний:
> `Handle Open(const Arguments& args)
>
> {
>
> if (args.Length() < 1) return Undefined(); // нету параметров? отбой!
>
> dblite\* db = unwrap\_dblite(args.This()); // забираем указатель на dblite
>
> string sql = to\_string(args[0]); // получаем строку в C++, описание to\_string находится в первой части этой статьи
>
> bool r;
>
> {
>
> Unlocker unlocker; // освобождаем V8 для других тредов на время работы операций БД
>
> r = db->open(sql.data()); // выполняем C++ код работы с БД
>
> } // деструктор unlocker "вернет нам" V8
>
> return Boolean::New(r);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь Open() «занимает» V8 только на время взаимодействия с V8, а весь ввод-вывод может быть проделан в другом треде.
Небольшое лирическое отступление. Во время исследования возможностей Unlocker я наткнулся на баг, в результате которого простая программа, использующая V8, теряла по 100 Мб в секунду. К чести Гугловцев надо сказать, что проблема была решена очень быстро. В настоящее время в ветке trunk эта ошибка уже исправлена и issue закрыт. Подробности здесь (англ.): [code.google.com/p/v8/issues/detail?id=444](http://code.google.com/p/v8/issues/detail?id=444)
V8 умеет примитивным образом сам переключаться между тредами, которые пытаются захватить единоличный доступ к V8 через Locker. Существует вызов Locker::StartPreemption(). Возможно это решение в какой-то момент окажется удобнее прочих.
— **Расширения и оформление кода**
Критики V8 упрекают его (помимо однотредовости) и в слишком «развесистом» коде обвязки. Действительно, конструкции немного громоздкие, а Гугл предоставил это дело на откуп самим программистам. Еще более ухудшает ситуацию необходимость объявлять большое число однотипных функций обратного вызова, если делать их обычными функциями в global scope, то мешанина также обеспечена.
Простейшее решение касательно классов V8, обертывающих классы C++, может выглядеть так: объявляем специальный класс C++ — обертку. Функции обратного вызова делаем его статическими методами. Темплейт объекта нужно хранить в единственном экземпляре, так что тоже делаем его статическим. По аналогии с V8 заводим функцию New. Выглядеть это может как-то так:
> `class ScriptDatabase
>
> {
>
>
>
> // перенаправление вызовов из JavaScript в dblite
>
>
>
> // функции
>
> static Handle Open(const Arguments& args);
>
> static Handle Execute(const Arguments& args);
>
> static Handle Select(const Arguments& args);
>
> ...
>
>
>
> // свойства
>
> static Handle ErrorCode(Local<String> name,const AccessorInfo& info);
>
> ...
>
>
>
> // извлечь из js-объекта obj указатель на соответствующий ему объект C++ ScriptDatabase
>
> static dblite\* Unwrap(Handle obj);
>
>
>
> // создать новый объект на базе темплейта
>
> static Persistent New(const char\* db\_name = 0);
>
>
>
> // функция обратного вызова, создающая объект
>
> static Handle Create(const Arguments& args);
>
>
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Что касается шаблонов, то здесь, разумеется, большой простор для творчества. И конечно уже есть некоторые решения. Можно посмотреть, например, проект cproxyv8: [code.google.com/p/cproxyv8](http://code.google.com/p/cproxyv8/)
Вот таким может получиться код, используя cproxyv8: [code.google.com/p/cproxyv8/wiki/Usage](http://code.google.com/p/cproxyv8/wiki/Usage)
Существуют и другие проекты, упрощающие использование V8. Например, v8-juice: [code.google.com/p/v8-juice](http://code.google.com/p/v8-juice/)
v8-juice предлагает API для загрузки функциональности произвольной DLL в javascript (http://code.google.com/p/v8-juice/wiki/Plugins), а также удобный способ преобразования типа V8 в C++ тип (http://code.google.com/p/v8-juice/wiki/ConvertingTypes). И кое-что еще.
Должен предупредить, что это проекты сторонних разработчиков и вы будете использовать их на свой страх и риск. Я обошелся в своем решении только кодом от Гугл, поскольку еще не наткнулся на эти расширения, когда начинал. Возможно, сейчас я бы что-то и использовал… | https://habr.com/ru/post/72765/ | null | ru | null |
# Реализация списка использованных библиотек в Android приложении. Попытка №2
Совсем недавно наткнулся на [статью](http://habrahabr.ru/post/274859/) на Хабре о том, как реализовать диалоговое окно со списком использованных библиотек. Мне предложенный вариант показался слишком сложным, да и сам список смотрелся криво. В связи с этим я решил поделиться более простым и элегантным способом реализации данного функционала.
Прописываем зависимость в **build.gradle** нашего модуля:
```
compile('de.psdev.licensesdialog:licensesdialog:1.8.0')
```
Теперь нам нужно создать список с использованными библиотеками. Для этого в папке **res/raw** создаем файл **license.xml** (можно использовать и другие названия).
Пример:
```
xml version="1.0" encoding="utf-8"?
Application Crash Reporting for Android (ACRA)
http://acra.ch/
Copyright 2010 Emmanuel Astier & Kevin Gaudin
Apache Software License 2.0
Android ViewPagerIndicator
http://viewpagerindicator.com/
Copyright (C) 2011 The Android Open Source Project
Copyright (C) 2012 Jake Wharton
Apache Software License 2.0
OrmLite
http://ormlite.com/
Copyright Gray Watson
ISC License
PhotoView
https://github.com/chrisbanes/PhotoView
Copyright 2011, 2012 Chris Banes.
Apache Software License 2.0
```
Как видите нам не нужно писать огромный текст лицензии, а можно лишь указать ее имя. Библиотека на основании этого файла сгенерирует HTML-код, который потом будет отображаться в диалоговом окне. На момент написания стать поддерживаются следующие лицензии:
* Apache Software License 2.0
* BSD 2/3 Clause License
* Gnu General Public License 2.0/3.0
* GNU Lesser General Public License 2.1/3
* MIT
* Mozilla Public License 1.1
Также можно создать свою лицензию, унаследовавшись от класса **License** и реализовав абстрактные методы.
Если у библиотеки нет копирайта, то просто пишем:
```
```
Осталось написать код в нашей Activity:
```
new LicensesDialog.Builder(this)
.setNotices(R.raw.license)
.build()
.showAppCompat();
```
Вот что получается на выходе:
Также можно создать лицензию прямо в Java:
```
final String name = "LicensesDialog";
final String url = "http://psdev.de";
final String copyright = "Copyright 2013 Philip Schiffer ";
final License license = new ApacheSoftwareLicense20();
final Notice notice = new Notice(name, url, copyright, license);
new LicensesDialog.Builder(this)
.setNotices(notice)
.build()
.showAppCompat();
```
Исходный код примера можно посмотреть [здесь](https://github.com/ImangazalievM/LicenseDialogExample). Спасибо за внимание. | https://habr.com/ru/post/275097/ | null | ru | null |
# Корректный ASP.NET Core
[](https://habr.com/ru/post/437002/)
Специально для любителей книг из серии "С++ за 24 часа" решил написать статью про ASP.NET Core.
Если вы раньше не разрабатывали под .NET или под какую-то аналогичную платформу, то смысла заходить под кат для вас нет. А вот если вам интересно узнать что такое IoC, DI, DIP, Interseptors, Middleware, Filters (то есть все то, чем отличается Core от классического .NET), то вам определенно есть смысл нажать на "Читать дальше", так как заниматься разработкой без понимания всего этого явно не корректно.
IoC, DI, DIP
------------
Если театр начинается с вешалки, то ASP.NET Core начинается с Dependency Injection. Для того, чтобы разобраться с DI нужно понять, что такое IoC.
Говоря о IoC очень часто вспоминают голливудский принцип "Don't call us, we'll call you". Что означает "Не нужно звонить нам мы позвоним вам сами".
Различные источники приводят различные паттерны, к которым может быть применен IoC. И скорее всего они все правы и просто дополняют друг друга. Вот некоторые их этих паттернов: factory, service locator, template method, observer, strategy.
Давайте разберем IoC на примере простого консольного приложения.
Допустим у нас есть два простых класса, реализующих интерфейс с одним методом:
```
class ConsoleLayer : ILayer
{
public void Write(string text)
{
Console.WriteLine(text);
}
}
class DebugLayer : ILayer
{
public void Write(string text)
{
Debug.WriteLine(text);
}
}
interface ILayer
{
void Write(string text);
}
```
Они оба зависят от абстракции (в данном случае в виде абстракции выступает интерфейс).
И, допустим, у нас есть объект более высокого уровня, использующий эти классы:
```
class Logging : ILayer
{
private ILayer _instance;
public Logging(int i)
{
if (i == 1)
{
_instance = new ConsoleLayer();
}
else
{
_instance = new DebugLayer();
}
}
public void Write(string text)
{
_instance.Write(text);
}
}
```
В зависимости от параметра конструктора переменная \_instance инициализируется определенным классом. Ну и далее при вызове Write будет совершен вывод на консоль или в Debug. Все вроде бы неплохо и даже, казалось бы, соответствует первой части принципа Dependency Inversion
> Объекты более высокого уровня не зависят от объектов более низкого уровня. И те, и те зависят от абстракций.
В качестве абстракции в нашем случае выступает ILayer.
Но у нас должен быть еще и объект еще более высокого уровня. Тот, который использует класс Logging
```
static void Main(string[] args)
{
var log = new Logging(1);
log.Write("Hello!");
Console.Read();
}
```
Инициализируя Logging с помощью 1 мы получаем в классе Logging экземпляр класса, выводящего данные на консоль. Если мы инициализируем Logging любым другим числом, то log.Write будет выводить данные в Debug. Все, казалось бы, работает, но работает плохо. Наш объект более высокого уровня Main зависит от деталей кода объекта более низкого уровня – класса Logging. Если мы в этом классе что-то изменим, то нам необходимо будет изменять и код класса Main. Чтобы это не происходило мы сделаем инверсию контроля – Inversion of Control. Сделаем так чтобы класс Main контролировал то, что происходит в классе Logging. Класс Logging будет получать в виде параметра конструктора экземпляр класса, реализующего интерфейс интерфейс ILayer
```
class Logging
{
private ILayer _instance;
public Logging(ILayer instance)
{
_instance = instance;
}
public void Write(string text)
{
_instance.Write(text);
}
}
```
И теперь нас класс Main будет выглядеть таким образом:
```
static void Main(string[] args)
{
var log = new Logging(new DebugLayer());
log.Write("Hello!");
Console.Read();
}
```
Фактически мы декорируем наш объект Logging с помощью необходимого для нас объекта.
Теперь наше приложение соответствует и второй части принципа Dependency Inversion:
> Абстракции не зависят от деталей. Детали зависят от абстракций. Т.е. мы не знаем деталей того, что происходит в классе Logging, мы просто передаем туда класс, реализующий необходимую абстракцию.
Есть такой термин tight coupling – тесная связь. Чем слабее связи между компонентами в приложении, тем лучше. Хотелось бы заметить, что данный пример простого приложения немного не дотягивает до идеала. Почему? Да потому что в классе самого высокого уровня в Main у нас дважды используется создание экземпляров класса с помощью new. А есть такая мнемоническая фраза «New is a clue» — что означает чем меньше вы используется new, тем меньше тесных связей компонентов в приложении и тем лучше. В идеале мы не должны были использовать new DebugLayer, а должны были получить DebugLayer каким-нибудь другим способом. Каким? Например, из IoC контейнера или с помощью рефлексии из параметра передаваемого Main.
Теперь мы разобрались с тем, что такое Inversion of Control (IoC) и что такое принцип Dependency Inversion (DIP). Осталось разобраться с тем, что такое Dependency Injection (DI). IoC представляет собой парадигму дизайна. Dependency Injection это паттерн. Это то, что у нас теперь происходит в конструкторе класса Logging. Мы получаем экземпляр определенной зависимости (dependency). Класс Logging зависит от экземпляра класса, реализующего ILayer. И это экземпляр внедряется (injected) через конструктор.
IoC container
-------------
IoC контейнер это такой объект, который содержит в себе множество каких-то определенных зависимостей (dependency). Зависимость можно иначе назвать сервисом – как правило это класс с определенным функционалом. При необходимости из контейнера можно получить зависимость необходимого типа. Внедрение dependency в контейнер — это Inject. Извлечение – Resolve. Приведу пример самого простого самостоятельно написанного IoC контейнера:
```
public static class IoCContainer
{
private static readonly Dictionary \_registeredObjects = new Dictionary();
public static dynamic Resolve()
{
return Activator.CreateInstance(\_registeredObjects[typeof(TKey)]);
}
public static void Register() where TConcrete : TKey
{
\_registeredObjects[typeof(TKey)] = typeof(TConcrete);
}
}
```
Всего дюжина строчек кода, а уже можно использовать (не в продакшн, разумеется, а в учебных целях).
Зарегистрировать зависимость (допустим, ConsoleLayer или DebugLayer которые мы использовали в прошлом примере) можно так:
```
IoCContainer.Register();
```
А извлечь из контейнера в необходимом месте программы так:
```
ILayer layer = IoCContainer.Resolve();
layer.Write("Hello from IoC!");
```
В реальных контейнерах еще реализуется и Dispose(), позволяющий уничтожать ставшие ненужными ресурсы.
Кстати, имя IoC контейнер не совсем точно передает смысл, так как термин IoC гораздо шире по применению. Поэтому в последнее время все чаще применяется термин DI контейнер (так как все-таки применяется dependency injection).
Service lifetimes + various extension methods in Composition Root
-----------------------------------------------------------------
Приложения ASP.NET Core содержат файл Startup.cs который является отправной точкой приложения, позволяющей настроить DI. Настраивается DI в методе ConfigureServices.
```
public void ConfigureServices(IServiceCollection services) {
services.AddScoped();
}
```
Этот код добавит в DI контейнер класс SomeRepository, реализующий интерфейс ISomeRepository. То, что сервис добавлен в контейнер с помощью AddScoped означает, что экземпляр класса будет создаваться при каждом запросе страницы.
Добавить сервис в контейнер можно и без указания интерфейса.
```
services.AddScoped();
```
Но такой способ не рекомендуется, так как у вашего приложения теряется гибкость и появляются тесные связи. Рекомендуется всегда указывать интерфейс, так как в таком случае в любой момент времени можно заменить одну реализацию интерфейса другой. И если реализации поддерживают принцип Liskov substitution, то «легким движением руки» сменив название класса реализации вы измените и функционал всего приложения.
Есть еще 2 варианта добавить сервис – AddSingleton и AddTransient.
При использовании AddSingleton сервис создается один раз и при использовании приложения обращение идет к одному и тому же экземпляру. Использовать этот способ нужно особенно осторожно, так как возможны утечки памяти и проблемы с многопоточностью.
У AddSingleton есть небольшая особенность. Он может быть инициализирован либо при первом обращении к нему
```
services.AddSingleton();
```
либо сразу же при добавлении в конструктор
```
services.AddSingleton(new YourService(param));
```
Вторым способом можно даже добавить параметр в конструктор.
Если хочется добавить параметр в конструктор сервиса, добавленного не только с помощью AddSingleton, но и с помощью AddTransient/AddScoped, то можно использовать лямбда выражение:
```
services.AddTransient(o => new YourService(param));
```
Ну и наконец, при использовании AddTransient сервис создается каждый раз при обращении к нему. Отлично подходит для легких сервисов, не потребляющих память и ресурсы.
Если с AddSingleton и AddScoped все должно быть более-менее понятно, то AddTransient требует разъяснений. Официальная документация приводит пример, в котором определенный сервис добавлен в DI контейнер и в качестве параметра конструктора другого сервиса и отдельно самостоятельно. И вот в случае, если он добавлен отдельно с помощью AddTransient, он создает свой экземпляр 2 раза. Приведу очень-очень упрощенный пример. В реальной жизни к применению не рекомендуется, т.к. классы для упрощения не наследуют интерфейсы. Допустим у нас есть простой класс:
```
public class Operation
{
public Guid OperationId { get; private set; }
public Operation()
{
OperationId = Guid.NewGuid();
}
}
```
И есть второй класс, который содержит первый как зависимый сервис и получает эту зависимость в качестве параметра конструктора:
```
public class OperationService
{
public Operation Operation { get; }
public OperationService (Operation operation)
{
Operation = operation;
}
}
```
Теперь совершаем inject двух сервисов:
```
services.AddTransient();
services.AddScoped();
```
И в каком-нибудь контроллере в Action добавим получение наших зависимостей и вывод значений в окно Debug.
```
public IActionResult Index([FromServices] Operation operation,
[FromServices] OperationService operationService)
{
Debug.WriteLine(operation.OperationId);
Debug.WriteLine(operationService.Operation.OperationId);
return View();
}
```
Так вот в результате мы получим 2 разных значения Guid. А вот если мы заменим AddTransient на AddScoped, то в результате мы получим 2 одинаковых значения.
В IoC контейнере приложений ASP.NET Core по умолчанию содержатся уже некоторые сервисы. Например, IConfiguration – сервис с помощью которого можно получить настройки приложения из файлов appsettings.json и appsettings.Development.json. IHostingEnvironment и ILoggerFactory с помощью которых можно получить текущую конфигурацию и вспомогательный класс, позволяющий проводить логирование.
Извлекают классы из контейнера с помощью следующей типичной конструкции (самый банальный пример):
```
private readonly IConfiguration _configuration;
public SomePageController(IConfiguration configuration)
{
_configuration = configuration;
}
public async Task Index()
{
string connectionString = \_configuration["connectionString"];
}
```
В области видимости контроллера создается переменная с модификаторами доступа private readonly. Зависимость получается из контейнера в конструкторе класса и присваивается приватной переменной. Далее эту переменную можно использовать в любых методах или Action контроллера.
Иногда не хочется создавать переменную для того, чтобы использовать ее только в одном Action. Тогда можно использовать атрибут [FromServices]. Пример:
```
public IActionResult About([FromServices] IDateTime dateTime)
{
ViewData["Message"] = «Московское время " + dateTime.Now;
return View();
}
```
Выглядит странно, но для того, чтобы в коде не вызывать метод статического класса DateTime.Now() иногда делают так, что значение времени получается из сервиса в качестве параметра. Таким образом появляется возможность передать любое время в качестве параметра, а значит становится легче писать тесты и, как правило, становится проще вносить изменения в приложение.
Нельзя сказать, что static – это зло. Статические методы выполняются быстрее. И скорее всего static может использоваться где-то в самом IoC контейнере. Но если мы избавим наше приложение от всего статического и new, то получим большую гибкость.
Сторонние DI контейнеры
-----------------------
То, что мы рассматривали, и то, что фактически реализует ASP.NET Core DI контейнер по умолчанию, — constructor injection. Имеется еще возможность внедрить зависимость в property с помощью так называемого property injection, но эта возможность отсутствует у встроенного в ASP.NET Core контейнера. Например, у нас может быть какой-то класс, который мы внедряем как зависимость, и у этого класса есть какое-то public property. Теперь представьте себе, что во время или после того как мы внедряем зависимость, нам нужно задать значение property. Вернемся к примеру похожему на пример, который мы недавно рассматривали.
Если у нас есть такой вот класс:
```
public class Operation
{
public Guid OperationId { get; set; }
public Operation() {}
}
```
который мы можем внедрить как зависимость,
```
services.AddTransient();
```
то используя стандартный контейнер задать значение для свойства мы не можем.
Если вы захотите использовать такую возможность задать значение для свойства OperationId, то вы можете использовать какой-то сторонний DI контейнер, поддерживающий property injection. К слову сказать property injection не особо рекомендуется использовать. Однако, существуют еще Method Injection и Setter Method Injection, которые вполне могут вам пригодится и которые также не поддерживаются стандартным контейнером.
У сторонних контейнеров могут быть и другие очень полезные возможности. Например, с помощью стороннего контейнера можно внедрять зависимость только в контролеры, у которых в названии присутствует определенное слово. И довольно часто используемый кейс – DI контейнеры, оптимизированные на быстродействие.
Вот список некоторых сторонних DI контейнеров, поддерживаемых ASP.NET Core: Autofac, Castle Windsor, LightInject, DryIoC, StructureMap, Unity
Хоть при использовании стандартного DI контейнера и нельзя использовать property/method injection, но зато можно внедрить зависимый сервис в качестве параметра конструктора реализовав паттерн «Фабрика» следующим образом:
```
services.AddTransient((dsvc) =>
{
IOtherService svc = dsvc.GetService();
return new DataService(svc);
});
```
В данном случае GetService вернет null если зависимый сервис не найден. Есть вариация GetRequiredService, которая выбросит исключение в случае, если зависимый сервис не найден.
Процесс получения зависимого сервиса с помощью GetService фактически применяет паттерн Service locator.
Autofac
-------
Разберем Autofac на практическом примере. Удобно то, что сервисы из контейнера можно будет регистрировать и получать, как и дефолтным способом, так и с помощью Autofac.
Установим NuGet пакет Autofac.Extensions.DependencyInjection.
Изменим возвращаемое методом ConfigureServices значение с void на IServiceProvider. И добавим property
```
public IContainer ApplicationContainer { get; private set; }
```
После этого станет возможным добавить в конец метода ConfigureServices класса Startup код вроде следующего (это лишь один из вариантов регистрации сервисов):
```
services.AddTransient();
var builder = new ContainerBuilder();
builder.Populate(services);
builder.RegisterType().As();
this.ApplicationContainer = builder.Build();
return new AutofacServiceProvider(this.ApplicationContainer);
```
Здесь builder.Populate(services); добавляет в контейнер сервисы из IServiceCollection. Ну и далее уже можно регистрировать сервисы с помощью builder.RegisterType. Ах, да. Чуть не забыл. Необходимо изменить с void на IServiceProvider возвращаемое значение метода ConfigureServices.
AOP с помощью ASP.NET Core — Autofac Interseptors
-------------------------------------------------
Говоря про аспектно-ориентированное программирование, упоминают другой термин – cross-cutting concerns. Concern – это какая-то часть информации, которая влияет на код. В русском варианте употребляют слово ответственность. Ну а cross-cutting concerns это ответственности, которые влияют на другие ответственности. А в идеале ведь они не должны влиять друг на друга, так ведь? Когда они влияют на друг друга, то становится сложнее изменять программу. Удобнее, когда у нас все операции происходят по отдельности. Логирование, транзакции, кеширование и многое другое можно совершать с помощью AOP не изменяя код самих классов и методов.
В мире .NET часто применяется способ, когда AOP код внедряется с помощью пост-процессора в уже откомпилированный код приложения ([PostSharp](https://www.postsharp.net/)) Или же альтернативно можно применять интерцепторы – это такие перехватчики событий, которые можно добавлять в код приложения. Эти перехватчики, как правило, используют для своей работы уже рассмотренный нами паттерн декоратор.
Давайте создадим свой интерцептор. Самый простой и типичный пример, который проще всего воспроизвести — это логирование.
Установим дополнительно к пакету Autofac.Extensions.DependencyInjection еще и пакет Autofac.Extras.DynamicProxy
Установили? Добавим простенький класс лога, который будет вызываться при обращении к определенным сервисам.
```
public class Logger : IInterceptor
{
public void Intercept(IInvocation invocation)
{
Debug.WriteLine($"Calling {invocation.Method.Name} from Proxy");
invocation.Proceed();
}
}
```
Добавляем в нашу регистрацию Autofac регистрацию интерцептора:
```
builder.Register(i => new Logger());
builder.RegisterType()
.As()
.EnableInterfaceInterceptors()
.InterceptedBy(typeof(Logger));
```
И теперь при каждом обращении к классу будет вызван метод Intercept класса Logger.
Таким образом мы можем упростить себе жизнь и не писать в начале каждого метода запись в лог. Она у нас будет вестись автоматически. И при желании нам будет несложно ее изменить или отключить для всего приложения.
Также мы можем убрать .InterceptedBy(typeof(Logger)); и добавить перехват вызовов только для конкретных сервисов приложения с помощью атрибута [Intercept(typeof(Logger))] – необходимо указать его перед заголовком класса.
Middleware
----------
В ASP.NET существует определенная цепочка вызовов кода, которая происходит при каждом request. Еще до того, как загрузился UI/MVC выполняются определенные действия.
То есть, например, если мы добавим в начало метода Configure класса Startup.cs код
```
app.Use(async (context, next) =>
{
Debug.WriteLine(context.Request.Path);
await next.Invoke();
});
```
то мы сможем посмотреть в консоли дебага какие файлы запрашивает наше приложение. Фактически мы получаем возможности AOP “out of box”
Немного useless, но понятный и познавательный пример использования middleware я вам сейчас покажу:
```
public void Configure(IApplicationBuilder app)
{
app.Use(async (context, next) =>
{
await context.Response.WriteAsync("Hello!" + Environment.NewLine);
await next.Invoke();
});
app.Run(async context =>
{
await context.Response.WriteAsync("Hello again.");
});
}
```
При каждом запросе начинает выполнятся цепочка вызовов. Из каждого app.Use после вызова next.invoke() совершается переход ко следующему вызову. И все завершается после того как отработает app.Run.
Можно выполнять какой-то код только при обращении к определенному route.
Сделать это можно с помощью app.Map:
```
private static void Goodbye(IApplicationBuilder app)
{
app.Run(async context =>
{
await context.Response.WriteAsync("Goodbye!");
});
}
public void Configure(IApplicationBuilder app)
{
app.Map("/goodbye", Goodbye);
app.Run(async context =>
{
await context.Response.WriteAsync("Hello!");
});
}
```
Теперь если просто перейти на страницу сайта, то можно будет увидеть текст “Hello!”, а если добавить к строке адреса /Goodbye, то вам будет отображено Goodbye.
Кроме Use и Map можно использовать UseWhen или MapWhen для того, чтобы добавлять код в цепочку middleware только при каких-то определенных условиях.
До сих пор были все еще useless примеры, правда? Вот вам нормальный пример:
```
app.Use(async (context, next) =>
{
context.Response.Headers.Add("X-Frame-Options", "DENY");
context.Response.Headers.Add("X-Content-Type-Options", "nosniff");
context.Response.Headers.Add("X-Xss-Protection", "1");
await next();
});
```
Здесь мы добавляем к каждому запросу заголовки, помогающие обезопасить страницу от хакерских атак.
Или же вот пример локализации:
```
var supportedCultures = new[]
{
new CultureInfo("ru"),
new CultureInfo("fr")
};
app.UseRequestLocalization(new RequestLocalizationOptions
{
DefaultRequestCulture = new RequestCulture("ru"),
SupportedCultures = supportedCultures,
SupportedUICultures = supportedCultures
});
```
Теперь если вы к адресу страницы добавите параметр ?culture=fr то вы сможете переключить язык приложения на французский (если в ваше приложение добавлена локализация, то все сработает)
Filters
-------
Если цепочка middleware относятся к процессам до MVC, то фильтры работают вместе с MVC.
Следующее схематическое изображение показывает, как отрабатывают фильтры
Сначала отрабатывают фильтры авторизации. Т.е. можно создать какой-то фильтр или несколько фильтров и вписать в них какой-то свой код авторизации, который будет отрабатывать при запросах.
Затем отрабатывают фильтры ресурсов. С помощью этих фильтров можно, например, вернуть какую-то информацию из кеша.
Затем происходит привязка данных и выполняются Action фильтры. С их помощью можно манипулировать параметрами передаваемыми Action и возвращаемым результатом.
Exception фильтры как намекает название позволяют добавить какую-то общую обработку ошибок для приложения. Должно быть довольно удобно обрабатывать ошибки везде одинаково. Эдакий AOP-шный плюс.
Result фильтры позволяют совершить какие-то действия до выполнения Action контроллера или после. Они довольно похожи на Action фильтры, но выполняются только в случае отсутствия ошибок. Подходят для логики завязанной на View.
Все должно быть более понятно на примере. А у меня под рукой как раз есть пример упрощенного авторизационного фильтра:
```
public class YourCustomFilter : Attribute, IAuthorizationFilter
{
public async void OnAuthorization(AuthorizationFilterContext context)
{
// какая-то логика и в случае, если у пользователе нет прав, можно сделать следующее
context.Result = new ContentResult()
{
Content = "У вас нет прав для доступа к этому ресурсу"
};
}
}
```
Добавляете этот класс в DI контейнер (как обычно в Startup.cs)
```
services.AddScoped();
```
И теперь становится возможным добавить какую-то свою авторизацию любому Action добавив следующий атрибут
```
[ServiceFilter(typeof(YourCustomFilter))]
```
Забавная штука – можно создать свое middleware и добавлять его каким-то action в качестве фильтра. Для того, чтобы сделать так, нужно создать класс с произвольным названием и методом Configure
```
public class MyMiddlewareFilter
{
public void Configure(IApplicationBuilder applicationBuilder)
{
applicationBuilder.Use(async (context, next) =>
{
Debug.WriteLine("Привет от middleware!");
await next.Invoke();
});
}
}
```
Теперь этот класс можно добавлять Action-ам с помощью следующего атрибута
```
[MiddlewareFilter(typeof(MyMiddlewareFilter))]
``` | https://habr.com/ru/post/437002/ | null | ru | null |
# Решаем Project Euler на F#: Задача 1
Прочитав первые несколько статей из цикла [Влюбляемся в F#](http://habrahabr.ru/blogs/starting_programming/51607/), я и в самом деле, если не влюбился в него, то по меньшей мере заинтересовался. Настолько, что не вытерпел ожидания следующей дозы и решил продолжить изучение самостоятельно.
В процессе луркинга я наткнулся на чрезвычайно увлекательный сайт [Project Euler](http://projecteuler.net/), который на мой взгляд, как нельзя лучше подходит, чтобы постепенно изучить все, или по крайней мере большинство тонкостей F#. Сейчас я предлагаю для начала рассмотреть решение самой первой задачи с этого сайта. Она очень простая, и ее решение думаю не вызовет сложностей даже у тех, кто знаком с F# только по вышеприведенной статье. Итак…
Условие звучит следующим образом:
*If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
Find the sum of all the multiples of 3 or 5 below 1000.*
Решение этой задачи выглядит крайне лаконично:
> `#light
>
> let \_ =
>
> [1..999]
>
> |> List.filter (fun x -> x%3=0 or x%5=0)
>
> |> List.fold\_left (+) 0
>
> |> printfn("The answer is %d")`
Думаю, что в целом здесь нет ничего сложного, однако следует обратить внимание на несколько вещей, которые еще не упоминались в цикле статей о F#.
Во-первых, это оператор "|>", который формально определяется следующим образом:
> `let (|>) a f = f a`
а говоря попросту, передает посчитанное перед ним значение в качестве аргумента следующей функции. Этот простой оператор позволяет в многих случаях существенно сократить код.
Во-вторых, здесь применяется лямбда-функция для определения чисел, делящихся на 3 или на 5, уже знакомая даже большинству программистов-императивщиков благодаря LINQ. Синтаксис ее отличается от LINQ разве что наличием fun перед определением функции, и использованием -> вместо =>.
В-третьих, здесь используются две встроенные функции для работы со списками: List.filter и List.fold\_left. Первая из них фильтрует список в соответствии с заданной булевой функцией, в качестве которой мы и используем нашу лямбду. Вторая в нашем случае суммирует все элементы списка. Ноль, стоящий вторым аргументом в списке, задает начальное значение аккумулятора. Таким образом, для перемножения всех элементов списка код будет выглядеть так: List.fold\_left (\*) 1.
Естественно, обе эти функции можно написать и самому, например для фильтрации она может выглядеть как-то так:
> `let rec filter filter\_fun lst =
>
> match lst with
>
> |[] -> []
>
> |head::tail -> if filter\_fun head then head::(filter filter\_fun tail)
>
> else filter filter\_fun tail`
но думаю, уже все давно пришли к убеждению, что изобретать велосипед стоит далеко не всегда.
Таким образом, вся программа состоит по сути из двух последовательных шагов, которые незамедлительно приносят искомый результат. Довольно красиво, не правда ли?
UPD: Друзья, если вы минусуете топик или карму, прошу, напишите парус строчек, за что. К критике отношусь спокойно, а в следующий раз постараюсь сделать лучше. Спасибо. | https://habr.com/ru/post/52150/ | null | ru | null |
# Нативный segue слева направо в iOS
Предупреждаю сразу, это трюк. Он подойдёт далеко не всем и не всегда, но если вам нужно вывести окно с какой-то информацией слева от основного — то мой способ будет в самый раз.
Вполне возможно, что он всем уже известен, и я изобрёл велосипед, но я изобрёл его самостоятельно, после пары дней бесплодных попыток сделать **нативный** segue слева направо, так что рад поделиться.
Для начала, немного вводных данных. Segue — это способ смены экранов в iOS. Одна из самых популярных разновидностей, это push (с версии iOS 8 — show). Push segue всегда замещает текущий вид справа налево. То есть, у вас как-бы справа есть второе окно, и при нажатии кнопки оно переезжает налево, замещая первое.
Такое поведение вы видите в телефонной книге при выборе абонента. При этом, вверху появляется кнопка возврата на предыдущее окно, и, при нажатии на него, происходит искомая анимация слева направо.
Проблема в том, что мне нужно было сделать всё тоже самое, но в зеркальном отражении и стандартных способов для этого не существует (если верить Google). Есть масса инструкций, как сделать custom segue с похожей анимацией, но все они режут глаз своей неестественностью по сравнению с родным push.
Вот, что у меня получилось в итоге:
Используются исключительно стандартные методы и 0% кастомной анимации. [Готовый пример на GitHub](https://github.com/bezumkin/LeftToRightSegue).
#### Идея
Основной трюк заключается в том, что мы не делаем никакого нового segue, мы используем родной push, по назначению.
[](https://file.modx.pro/files/0/e/8/0e8a137c5230539745cf7437a8c5dd91.png)
Думаю, уже по этому скриншоту понятен смысл. Стартовое окно — Info, которое нам нужно выводить слева. При его активации мы быстро и незаметно, без анимации, выводим окно Main при помощи push segue. А после этого уже можно вернуться обратно, используя unwindFromViewController. Только пользователь об этом не знает и видит плавный и красивый left to right segue.
#### Реализация
Не буду расписывать как соединять друг с другом элементы и назначать кастомные классы, уверен — вы все и так это знаете. В любом случае, можно скачать исходники с GitHub и посмотреть.
Нам понадобятся 2 иконки, один custom segue и один InfoViewController.
На окошко Info мы добавляем одну кнопку с иконкой домика, справа. Затем соединяем её с окном Main обычным push (show) segue.
Создаём кастомный класс InfoViewController, наследник UIViewController и назначаем его окошку Info:
```
#import "InfoViewController.h"
@interface InfoViewController ()
@end
@implementation InfoViewController
// Быстрая перемотка на окно Main при первом запуске
// Запускаем custom segue с идентификатором FastSegue
- (void) viewDidLoad {
[self performSegueWithIdentifier:@"FastSegue" sender:nil];
}
// Указание метода для возврата на окно Info
- (IBAction)unwindFromViewController:(UIStoryboardSegue *)sender {
}
@end
```
Теперь нужно создать custom segue, который будет незаметно выводить окно Main при старте приложения:
```
#import "FastSegue.h"
@implementation FastSegue
// Обычный push segue, только без анимации
- (void) perform {
[[[self sourceViewController] navigationController] pushViewController:[self destinationViewController] animated:NO];
}
@end
```
А теперь нужно создать связать этим custom segue контроллер Info с Main. Этой связи обязательно присваиваем идентификатор FastSegue.
| | |
| --- | --- |
| | |
Дело за малым — сделать возврат на окно Info при нажатии на кнопку окошка Main. Это необязательная часть, потому что, по умолчанию, там и так будет сгенерирована кнопка возврата со стрелкой и названием предыдущего окна, но мне нужна именно иконка.
Кроме того, как оказалось, если заменить backBarButtonItem своим элементом, то нельзя открыть окно Info жестом слева направо, как при обычном segue.
Итак, добавляем на окно Main элемент UINavigationItem и leftBarButtonItem, чтобы заменить автоматически генерирующийся родной backBarButtonItem. Картинкой выбираем иконку «i» и наша кнопка успешно показывается при старте приложения. Только ничего не делает.
Для того, чтобы она заменила собой функционал backBarButtonItem, нужно назначить ей action unwindFromViewController — именно для этого мы и обозначили его в контроллере окна Info.
Так что связываем кнопку с точкой выхода и выбираем unwindFromViewController:
| | |
| --- | --- |
| | |
Вот и всё!
Добавлю еще, что для незаметного стартового переключения нужна LaunchImage, или LaunchScreen, но приложений без них и так не бывает.
Если вам кажется, что я здесь написал полный бред и костыль — буду рад увидеть ваше решение и применить его на практике. ~~Мне тоже данный способ кажется не совсем верным, и, тем более, совсем не универсальным~~, но он работает как мне нужно и отлично выглядит!
Спасибо за внимание.
##### Updated
Заменил [старое видео](http://youtu.be/Hs_CDUJGWcM) на чуть более наглядное, с таблицами.
##### Updated 2
Как оказалось, никакой это не костыль, никакое это не «необычное поведение». **Точно так же** работает родное приложение **Mail**.
Открываем Mail — видим сразу письма и вверху кнопку на открытие всех ящиков. При нажатии на неё происходит left to right segue, скорее всего, точно так же сделанный. То есть, предварительной незаметной отмоткой на второе окно.
Выходит, я переизобрёл то, что сама Apple уже давно использует. Привет всем [несогласным](http://habrahabr.ru/post/239093/#comment_8032621). | https://habr.com/ru/post/239093/ | null | ru | null |
# Иерархические (рекурсивные) запросы
Чтобы понять рекурсию, сначала надо понять рекурсию. Возможно, поэтому рекурсивные запросы применяют так редко. Наверняка вы представляете что такое SQL-запрос, я расскажу, чем рекурсивные запросы отличаются от обычных. Тема получилась объемная, приготовьтесь к долгому чтению. В основном речь пойдет об Oracle, но упоминаются и другие СУБД.
#### Суть проблемы
Большинство современных СУБД (Система Управления Базами Данных) — реляционные, т.е. представляют данные в виде двумерной таблицы, в которой есть строки (записи) и столбцы (поля записей). Но на практике мы часто сталкиваемся с иной организацией данных, а именно иерархической.
Взгляните на список файлов на вашем компьютере: все они организованы в виде дерева. Аналогично можно представить книги в библиотеке: Библиотека->Зал->Шкаф->Полка->Книга. То же самое и статьи на сайте: Сайт->Раздел->Подраздел->Статья. Примеры можно приводить долго. Впрочем, тут еще можно разделить все на отдельные таблицы: таблица для хранения списка библиотек, другая таблица для списка залов, третья для шкафов и т.д. Но если заранее не известна глубина вложенности или эта вложенность может меняться, тут уж от иерархии никак не отмашешься.
Проблема в том, что данные, имеющие иерархическую структуру, очень плохо представляются в реляционной модели. В стандарте SQL-92 нет средств для их обработки.
Зато такие средства появились в стандарте SQL-1999. Правда к тому времени в Oracle уже был собственный оператор CONNECT BY. Несмотря на это, в SQL-1999 синтаксис рекурсивных запросов совершенно не похож на синтаксис CONNECT BY в Oracle и использует ключевое слово WITH. Реализация же рекурсивных запросов в других СУБД несколько запоздала, так в MS SQL Server она появилась лишь в версии 2005.
Так же как и в синтаксисе, есть отличия и в терминологии. В Oracle обычно обсуждаемые запросы называются “иерархические”, у всех остальных “рекурсивные”. Суть от этого не меняется, я буду использовать и то и другое.
#### От слов к делу!
Для демонстрации будем использовать структуру каталогов, нам потребуется тестовая таблица, состоящая из 3-х полей:
**id** – идентификатор,
**pid** – идентификатор родителя (ссылается на id другой записи в той же таблице),
**title** – название каталога (вместо него может быть что угодно, даже несколько полей или ссылок к другим таблицам).
> `create table test\_table (
>
> id int,
>
> pid int,
>
> title varchar(256)
>
> );`
Здесь я использовал синтаксис mySQL, в других СУБД он несколько отличается. Так, в Oracle используются другие типы данных: вместо int — number, а вместо varchar — varchar2.
Заполнить табличку тестовыми данными не составит труда. Предлагаю записать список серверов, расположенных на территории различных предприятий в разных городах. Таким образом, в единой таблице оказываются и страны, и города, и фирмы, и сервера.
> `insert into test\_table values (1, null, 'Россия');`
Думаю, остальные строки заполнить не составит сложностей. Получается почти как на картинке, только не в том порядке. Я специально заполнял не по-порядку, чтобы простым SELECT \* FROM test\_table получалось не иерархическая структура:
```
ID PID TITLE
---- ---------- --------------------
1 Россия
2 1 Воронеж
3 2 ООО "Рога и копыта"
4 1 Москва
5 1 Лиски
6 3 Главный офис
7 3 Офис 1
8 3 Офис 2
9 8 Сервер 1
10 5 ЛискиПресс
```
Тестовые данные готовы. Приступим к выборкам.
#### mySQL
Вынужден огорчить пользователей mySQL – в этой СУБД придется рекурсию организовывать внешними по отношению к СУБД средствами, например на php (код приводить не буду, его публиковали не раз, например [здесь](http://www.codenet.ru/webmast/php/tree.php), достаточно поискать по запросу “mySQL tree” и т.п.).
Впрочем, есть [иной подход](http://dev.e-taller.net/dbtree/), заключающийся в создании левой и правой границы для каждого узла, предложенный Джо Селко. Тогда можно будет обойтись обычными, не рекурсивными запросами.
Как-то я выводил дерево объектов в действующем проекте на php. База данных была на mySQL. Поплевавшись на отсутствие удобных операторов, я решил тогда не отображать все дерево целиком, а показать пользователю только первый уровень (схлопнутое дерево). При клике по плюсику в узле дерева отображались дочерние узлы для выбранного объекта, при этом они подгружались через AJAX. Выборка дочерних узлов по известному pid происходит быстро, поэтому интерфейс получился вполне шустрым. Возможно, это не лучшее решение, но оно имеет право на жизнь.
#### SQL-1999
В отличие от предыдущего стандарта SQL-92, в названии следующего решили отобразить номер тысячелетия, чтобы он не страдал от проблемы двухтысячного года. Помимо этого :-), появились новые типы данных (LOB), новые предикаты SIMILAR и DISTINCT, точки сохранения транзакций, объекты и их методы, и многое другое. Среди нововведений появились также рекурсивные запросы, о которых мы сейчас и поговорим.
Для получения иерархических данных используется временное представление, которое описывается оператором **WITH**. После этого из нее выбираются данные простым селектом. В общем виде синтаксис примерно такой:
```
WITH [recursive] имя_алиаса_запроса [ (список столбцов) ]
AS (запрос)
основной запрос
```
В MS SQL нет ключевого слова **RECURSIVE**, его следует опустить. Но в остальном все то же самое. Такой синтаксис поддерживается в DB2, Sybase iAnywhere, MS SQL, начиная с версии 2005, и во всех базах данных, которые поддерживают стандарт SQL 1999.
Тогда для получения нашего дерева запрос получится такой:
> `WITH RECURSIVE
>
> Rec (id, pid, title)
>
> AS (
>
> SELECT id, pid, title FROM test\_table
>
> UNION ALL
>
> SELECT Rec.id, Rec.pid, Rec.title
>
> FROM Rec, test\_table
>
> WHERE Rec.id = test\_table.pid
>
> )
>
> SELECT \* FROM Rec
>
> WHERE pid is null;`
Здесь используется рекурсивная таблица Rec, которую мы сами придумали, построив ее по исходной таблице test\_table. В описании Rec указано правило, каким образом соединять: WHERE Rec.id = test\_table.pid. А в главном запросе отметили, что начинать надо с записи, у которой pid является пустым, т.е. с корневой записи.
Честно говоря, я никогда не работал в MS SQL Server 2005 или другой СУБД, использующей такой синтаксис. Поэтому написал этот запрос чисто из теоретических соображений. Для общности картины, чтобы было с чем сравнить.
В MS SQL 2008 можно применить более новое средство [hierarchyid](http://habrahabr.ru/blogs/sql/27774/). Спасибо [XaocCPS](https://habrahabr.ru/users/xaoccps/) за его описание.
#### Oracle
Наконец-то мы добрались до Oracle! Об этой СУБД я хотел бы рассказать поподробнее. В Oracle иерархические запросы появились в 8-ой версии, задолго до появления стандарта. Поэтому до сих пор используется совсем другой синтаксис. Лично мне он кажется более понятным и напоминающим обычные функциональные языки. Хотя, скорее всего, это дело привычки.
Описание синтаксиса в документации напоминает бусы: на единую нить запроса нанизываются нужные операторы. Никому не приходило в голову сделать украшение для гички?
Тут видно, что единственно важное условие для построения иерархического запроса – это оператор **CONNECT BY**, остальное “нанизывается” по мере надобности.
Необязательный оператор **START WITH** говорит Ораклу с чего начинать цикл, т.е. какая строка (или строки) будет корневой. Условие может быть практически любым, можно даже использовать функции или внутренние запросы: pid is null, или id = 1, или даже substr(title, 1, 1) = ‘Р’.
Условие после CONNECT BY нужно указать обязательно. Тут надо сказать Ораклу, как долго продолжать цикл. Что-то в духе while в обычных языках программирования. Например, мы можем попросить достать нам 10 строк: rownum<=10 – он и нафигачит нам в цикле ровно 10 одинаковых строк. Почему одинаковых? Да потому что мы указали какую строку выбрать первой, а как найти следующую нет – вот он и выдает 1-ую строку нужное количество раз. Кстати сказать, **rownum** это псевдостолбец, в котором нумеруются строки, начиная от 1 в порядке их выдачи. Его можно использовать не только в иерархических запросах. Но это уже другая история.
Как же получить нормальную иерархию? Нужно использовать специальный оператор, который называется **PRIOR**. Это обычный унарный оператор, точно такой же как + или -. “Позвоните родителям” – говорит он, заставляя Оракл обратиться к предыдущей записи. С его помощью можно написать правило pid = PRIOR id (или PRIOR id = pid, как говорится, от перестановки мест…).
Что получается? Оракл находит первую запись, удовлетворяющую условию в START WITH, и принимается искать следующую. При этом к той первой записи можно обратиться через PRIOR. Если мы все сделали правильно, то Оракл будет искать записи, в которых в поле для хранения информации о родителе (pid) будет содержаться значение, равное идентификатору id нашей первой записи. Таким образом будут найдены все потомки корневой записи. А так как процесс рекурсивный, аналогичный поиск будет продолжаться с каждой найденной строкой, пока не отыщутся все потомки.
Теперь у нас есть все необходимое, чтобы написать иерархический запрос в Oracle. Но прежде чем мы его напишем, расскажу еще об одной штуке. Порядок строк это хорошо, но нам было бы трудно понять, две строки рядом это родитель и его потомок или два брата-потомка одного родителя. Пришлось бы сверять id и pid. К счастью, Oracle предлагает в помощь дополнительный псевдостолбец **LEVEL**. Как легко догадаться, в нем записывается уровень записи по отношению к корневой. Так, 1-ая запись будет иметь уровень 1, ее потомки уровень 2, потомки потомков — 3 и т.д.
> `SELECT level, id, pid, title
>
> FROM test\_table
>
> START WITH pid is null
>
> CONNECT BY PRIOR id = pid;`
```
LEVEL ID PID TITLE
------ ---------- ---------- -------------------
1 1 Россия
2 2 1 Воронеж
3 3 2 ООО "Рога и копыта"
4 6 3 Главный офис
4 7 3 Офис 1
4 8 3 Офис 2
5 9 8 Сервер 1
2 4 1 Москва
2 5 1 Лиски
3 10 5 ЛискиПресс
```
Неплохо. Все дочерние строки оказываются под своими родителями. Сортировку бы еще добавить, чтобы записи одного уровня выводились не абы-как, а по алфавиту. Ну чтож, сортировка это просто: добавим в конец запроса конструкцию ORDER BY title.
> `SELECT level, id, pid, title
>
> FROM test\_table
>
> START WITH pid is null
>
> CONNECT BY PRIOR id = pid
>
> ORDER BY title;`
```
LEVEL ID PID TITLE
------ ---------- ---------- -------------------
2 2 1 Воронеж
4 6 3 Главный офис
2 5 1 Лиски
3 10 5 ЛискиПресс
2 4 1 Москва
3 3 2 ООО "Рога и копыта"
4 7 3 Офис 1
4 8 3 Офис 2
1 1 Россия
5 9 8 Сервер 1
```
О, нет! Вся иерархия поломалась. Что же получилось? Оракл честно выбрал нужные строки в порядке иерархии (об этом говорит правильная расстановка level), а затем пересортировал их согласно правилу ORDER BY. Чтобы указать Ораклу, что сортировать надо только в пределах одного уровня иерархии, нам поможет маленькая добавка в виде оператора **SIBLINGS**. Достаточно изменить условие сортировки на ORDER SIBLINGS BY title – и все встанет на свои места.
Кстати, возможно все еще не понятно, почему этот порядок строк является деревом. Можно убрать все “лишние” поля и добавить отступы, станет более наглядно:
> `SELECT lpad(' ', 3\*level)||title as Tree
>
> FROM test\_table
>
> START WITH pid is null
>
> CONNECT BY PRIOR id = pid
>
> ORDER SIBLINGS BY title;`
```
TREE
-----------------------------
Россия
Воронеж
ООО "Рога и копыта"
Главный офис
Офис 1
Офис 2
Сервер 1
Лиски
ЛискиПресс
Москва
```
Ну вот, теперь все в точности, как на картинке в самом начале статьи.
Помните, файловые менеджеры обычно пишут путь к каталогу, в котором вы находитесь: /home/maovrn/documents/ и т.п.? Неплохо было бы и нам сделать так же. А сделать это можно абсолютно не напрягаясь: специалисты из Oracle все уже сделали за нас. Просто берем и используем функцию **SYS\_CONNECT\_BY\_PATH()**. Она принимает два параметра через запятую: название колонки и строку с символом-разделителем. Будем не оригинальны, напишем так: SYS\_CONNECT\_BY\_PATH(title, ‘/’).
Заодно ограничим вывод, выбрав только одну строку. Для этого, как всегда, нужно добавить условие WHERE. Даже в иерархическом запросе ограничивающее условие применяется ко всем строкам. Вставить его надо до иерархической конструкции, сразу после FROM. Для примера определим путь до “Сервер 1”, который у нас записан с id=9:
> `SELECT SYS\_CONNECT\_BY\_PATH(title, '/') as Path
>
> FROM test\_table
>
> WHERE id=9
>
> START WITH pid is null
>
> CONNECT BY PRIOR id = pid;`
```
PATH
----------------------------------------------------
/Россия/Воронеж/ООО "Рога и копыта"/Офис 2/Сервер 1
```
Еще может быть полезен псевдостолбец **CONNECT\_BY\_ISLEAF**. Его можно использовать так же, как LEVEL. В этом псевдостолбце напротив каждой строки проставляется 0 или 1. Если есть потомки – проставится 0. Если потомков нет, такой узел в дереве называется “листом”, тогда и значение в поле CONNECT\_BY\_ISLEAF будет равно 1.
Устали? Осталось немного, самое страшное уже позади. Раньше мы использовали оператор PRIOR, который ссылался к родительской записи. Помимо него есть другой унарный оператор **CONNECT\_BY\_ROOT**, который ссылается (ни за что не догадаетесь!) на корневую запись, т.е. на самую первую в выборке.
> `SELECT id, pid, title, level,
>
> CONNECT\_BY\_ISLEAF as IsLeaf,
>
> PRIOR title as Parent,
>
> CONNECT\_BY\_ROOT title as Root
>
> FROM test\_table
>
> START WITH pid is null
>
> CONNECT BY PRIOR id = pid
>
> ORDER SIBLINGS BY title;`
```
ID PID TITLE LEVEL LEAF PARENT ROOT
-- --- -------------------- ----- ---- -------------------- ------
1 Россия 1 0 Россия
2 1 Воронеж 2 0 Россия Россия
3 2 ООО "Рога и копыта" 3 0 Воронеж Россия
6 3 Главный офис 4 1 ООО "Рога и копыта" Россия
7 3 Офис 1 4 1 ООО "Рога и копыта" Россия
8 3 Офис 2 4 0 ООО "Рога и копыта" Россия
9 8 Сервер 1 5 1 Офис 2 Россия
5 1 Лиски 2 0 Россия Россия
10 5 ЛискиПресс 3 1 Лиски Россия
4 1 Москва 2 1 Россия Россия
```
Стоит отметить, что если в результате выполнения запроса обнаружится петля, Oracle выдаст ошибку. К счастью, ее можно обойти, хотя если в данных содержатся петли – это явно ошибка, в деревьях не бывает петель. На картинке с “бусами” запроса был нарисован оператор **NOCYCLE** после CONNECT BY – его мы и будем применять. Теперь запрос не будет вылетать. А чтобы определить “больной” участок, воспользуемся псевдостолбцом **CONNECT\_BY\_ISCYCLE** – в нем во всех хороших строках будет записано 0, а в тех, которые приводят к петлям, волшебным образом окажется 1.
Чтобы проиллюстрировать это, придется немного подпортить данные. ЛискиПресс ссылается у нас на город Лиски; изменим запись Лиски, чтобы она ссылалась на ЛискиПресс (не забудьте про commit – я вечно забываю):
> `update test\_table set pid=10 where id=5;`
Если мы запустим какой-нибудь из предыдущих запросов, увидим, что и Лиски, и ЛискиПресс выпали из выборки, будто их нет совсем. Бегая в цикле, Оракл просто перестал на них натыкаться, т.к. нет пути от записи Россия к городу Лиски. Изменим условия START WITH, чтобы начинать с города Лиски – появится ошибка. Умный Оракл видит что запись уже выбиралась ранее и отказывается бегать в бесконечном цикле. Исправляем ошибку:
> `SELECT CONNECT\_BY\_ISCYCLE as cycl, id, pid, title
>
> FROM test\_table
>
> START WITH id=5
>
> CONNECT BY NOCYCLE PRIOR id = pid;`
```
CYCL ID PID TITLE
---- ---------- ---------- ----------
0 5 10 Лиски
1 10 5 ЛискиПресс
```
#### Практические примеры
Иерархические запросы можно применять не только там, где есть явная иерархия.
Например, рассмотрим задачу *получения списка пропущенных номеров из последовательности*. Это бывает нужно, когда в некоей таблице id генерируется автоматически путем увеличения на 1, но часть записей были удалены. Нужно получить список удаленных номеров. По хорошей традиции, это следует сделать одним селектом.
Подготовим тестовые данные. Удалим из нашей таблицы пару записей:
> `DELETE FROM test\_table WHERE id IN (3, 5);`
С чего начнем? Во-первых, неплохо было бы получить список номеров подряд от 1 до максимального значения в нашей таблице, чтобы было с чем сравнивать. Выяснить максимальное значение id из таблицы, думаю, не составит никаких трудностей:
> `SELECT max(id) FROM test\_table`
А вот чтобы сгенерировать последовательность от 1 до max как раз и понадобится рекурсивный запрос. Ведь как здорово просто взять и получить нужное количество строк! Достаточно будет их пронумеровать – и вот список готов.
> `SELECT rownum as rn FROM dual
>
> CONNECT BY level <= (SELECT max(id) FROM test\_table);`
Конструкция “SELECT … FROM dual” используется, когда надо вычислить значение функции, не производя при этом выборки данных. **Dual** – это системная таблица, состоящая из одного столбца и одной строки. Запрос из нее всегда возвращает одну строку со значением ‘X’. Благодаря такой умопомрачительной стабильности, эту таблицу удобно использовать в качестве источника строк.
Обычно таблицу, которую нагло используют для получения нужного количества строк, не выбирая сами данные, называют **pivot**. В качестве такой таблицы может выступать любая большая таблица, в том числе системная. Но использование dual в Oracle является более разумным решением.
Теперь, когда список номеров подряд уже есть, достаточно пройтись по нему и сравнить, есть ли такой номер в проверяемой таблице:
> `SELECT sq.rn
>
> FROM (SELECT rownum as rn FROM dual
>
> CONNECT BY level <= (SELECT max(id) FROM test\_table)) sq
>
> WHERE sq.rn not in (SELECT id FROM test\_table)
>
> ORDER BY rn;`
```
RN
----
3
5
```
Всё. Ведро начищено до блеска, лошадь вооружена биноклем для остроты зрения. Да не коснется вас ROLLBACK. COMMIT! | https://habr.com/ru/post/43955/ | null | ru | null |
# CsConsoleFormat: форматирование в консоли по-новому (.NET)
 Всем хорошо известны богатые средства форматирования в консоли: выравнивание пробелами, изменение текущего цвета текста и фона. Если вы хотите вывести пару строчек, то этого полностью хватает, хотя отсутствие переносов по пробелам временами раздражает. Если нужно вывести таблицу, приходится вручную рассчитывать ширину колонок, а часто просто хардкодить ширину. Если нужно раскрасить вывод, приходится испещрять вывод текста бесконечными переключениями и восстановлениями цвета. Если нужно вывести текст с переносами по словам или совместить всё перечисленное выше...
Код быстро превращается в нечитаемое месиво, в котором не разобрать, где логика, где текст, где форматирование. Это ужасно! Когда мы пишем GUI, у нас в распоряжении все прелести современной разработки: паттерны MV\*, байндинги и прочие крутые штуки. После работы с GUI написание консольных приложений сродни возвращению в каменный век.
**CsConsoleFormat** спешит на помощь!
Возможности
===========
* **Элементы как в HTML**: абзацы, спаны, таблицы, списки, границы, разделители.
* **Лейауты**: таблицы (grid), стопки (stack), липучки (dock), переносы (wrap), абсолютные (canvas).
* **Форматирование текста**: цвет текст и фона, переносы по буквам и словам.
* **Форматирование символов Unicode**: дефисы, мягкие дефисы, неразрывные дефисы, пробелы, неразрывные пробелы, пробелы с нулевой шириной.
* **Несколько синтаксисов** (см. ниже):
+ **Как WPF**: XAML с получением значений цепочек свойств (one-time binding), ресурсами, конвертерами, прикреплёнными свойствами, загрузкой документов из ресурсов.
+ **Как LINQ to XML**: C# с инициализаторами объектов, заданием прикреплённых свойств через методы расширения или индексаторы, добавление подэлементов через схлопывание списков элементов и конвертацию объектов к строкам.
* **Рисование**: геометрические примитивы (линии, прямоугольники) на основе символов псевдо-графики, цветовые преобразования (светлее, темнее), вывод текста.
* **Интернационализация**: культуры могут быть переопределены на уровне любого элемента.
* **Экспорт** во множество форматов: текст с escape-последовательностями, неформатированный текст, HTML; RTF, XPF, WPF FixedDocument, WPF FlowDocument (требуется WPF).
* **Аннотации JetBrains R#**: CanBeNull, NotNull, ValueProvider и др.
* **WPF**: контрол для отображения документа, конвертер документа, импорт изображений.
Положим, у нас есть привычные и знакомые классы Order, OrderItem, Customer. Давайте создадим документ, который выведет заказ во всех подробностях. Доступных синтаксиса два, мы можете пользоваться любым и даже совмещать их.
**XAML** (а-ля WPF):
```
Id
Name
Count
```
**C#** (а-ля LINQ to XML):
```
using static System.ConsoleColor;
var headerThickness = new LineThickness(LineWidth.Single, LineWidth.Wide);
var doc = new Document()
.AddChildren(
new Span("Order #") { Color = Yellow },
Order.Id,
"\n",
new Span("Customer: ") { Color = Yellow },
Order.Customer.Name,
new Grid { Color = Gray }
.AddColumns(
new Column { Width = GridLength.Auto },
new Column { Width = GridLength.Star(1) },
new Column { Width = GridLength.Auto }
)
.AddChildren(
new Cell { Stroke = headerThickness }
.AddChildren("Id"),
new Cell { Stroke = headerThickness }
.AddChildren("Name"),
new Cell { Stroke = headerThickness }
.AddChildren("Count"),
Order.OrderItems.Select(item => new[] {
new Cell()
.AddChildren(item.Id),
new Cell()
.AddChildren(item.Name),
new Cell { Align = HorizontalAlignment.Right }
.AddChildren(item.Count),
})
)
);
```
Выбор синтаксиса
================
**XAML** (а-ля WPF) заставляет чётко разделять модели и представления, что можно считать достоинством. Однако XAML не слишком строго типизирован и не компилируется, поэтому возможны ошибки времени выполнения. Синтаксис неоднозначный: с одной стороны, XML отличается многословностью (), с другой — позволяет экономить на записи перечислений (`Color="White"`) и пользоваться конвертерами (`Stroke="Single Wide"`).
Библиотека XAML в Mono бажная и ограниченная. Если вам нужно кросс-платформенное приложение, то использование XAML может вызвать проблемы. Однако если вы хорошо знакомы с WPF, и вам необходима поддержка только Windows, то XAML должен быть естественным. В версии для .NET Standard используется библиотека Portable.Xaml, которая должна быть чуть лучше, но пока оно недостаточно протестировано в боевых условиях.
XAML в общем виде лишь ограниченно поддерживается Visual Studio и ReSharper: хотя подсветка синтаксиса и автодополнение кода обычно работают, на автодополнение путей байндингов не рассчитывайте, да и ошибки иногда подсвечиваются там, где их нет. Впрочем, для знакомых с XAML в этом ничего нового.
**C#** (а-ля LINQ to XML) позволяет выполнять самые разнообразные преобразования прямо в коде за счёт LINQ и схлопывания списков при добавлении подэлементов. Если вы используете C# 6, в котором поддерживается `using static`, то запись некоторых перечислений можно сократить. Единственное место с нестрогой типизацией — это метод расширения `AddChildren(params object[])` (его использование опционально).
Построение документов в коде полностью поддерживается в любой среде разработки, однако попытки соорудить огромные документы одним выражением на много страниц могут привести к тормозам при использовании ReSharper (9-ая версия временами чуть не подвешивала студию; вероятно, сейчас уже неактуально).
Реальный пример
===============
В репозитрии на ГитХабе есть пример консольного приложения для отображения текущих процессов в системе и запуска новых процесов. Выглядит это примерно так:
Всё форматирование укладывается в одной небольшой и наглядный файлик. Здесь и вывод сообщений, и вывод ошибок, и форматирование таблицы процессов, и вывод справки всеми возможными способами.
Для обработки командной строки используется популярная библиотека CommandLineParser, класс `BaseOptionAttribute` оттуда и содержит информацию об одной команде или параметре. Здесь используются некоторые возможности C# 6. Остальной код, думаю, в особых объяснениях не нуждается.
```
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using CommandLine;
using static System.ConsoleColor;
internal class View
{
private static readonly LineThickness StrokeHeader = new LineThickness(LineWidth.None, LineWidth.Wide);
private static readonly LineThickness StrokeRight = new LineThickness(LineWidth.None, LineWidth.None, LineWidth.Single, LineWidth.None);
public Document Error (string message, string extra = null) =>
new Document { Background = Black, Color = Gray }
.AddChildren(
new Span("Error\n") { Color = Red },
new Span(message) { Color = White },
extra != null ? $"\n\n{extra}" : null
);
public Document Info (string message) =>
new Document { Background = Black, Color = Gray }
.AddChildren(message);
public Document ProcessList (IEnumerable processes) =>
new Document { Background = Black, Color = Gray }
.AddChildren(
new Grid { Stroke = StrokeHeader, StrokeColor = DarkGray }
.AddColumns(
new Column { Width = GridLength.Auto },
new Column { Width = GridLength.Auto, MaxWidth = 20 },
new Column { Width = GridLength.Star(1) },
new Column { Width = GridLength.Auto }
)
.AddChildren(
new Cell { Stroke = StrokeHeader, Color = White }
.AddChildren("Id"),
new Cell { Stroke = StrokeHeader, Color = White }
.AddChildren("Name"),
new Cell { Stroke = StrokeHeader, Color = White }
.AddChildren("Main Window Title"),
new Cell { Stroke = StrokeHeader, Color = White }
.AddChildren("Private Memory"),
processes.Select(process => new[] {
new Cell { Stroke = StrokeRight }
.AddChildren(process.Id),
new Cell { Stroke = StrokeRight, Color = Yellow, TextWrap = TextWrapping.NoWrap }
.AddChildren(process.ProcessName),
new Cell { Stroke = StrokeRight, Color = White, TextWrap = TextWrapping.NoWrap }
.AddChildren(process.MainWindowTitle),
new Cell { Stroke = LineThickness.None, Align = HorizontalAlignment.Right }
.AddChildren(process.PrivateMemorySize64.ToString("n0")),
})
)
);
public Document HelpOptionsList (IEnumerable options, string instruction) =>
new Document { Background = Black, Color = Gray }
.AddChildren(
new Div { Color = White }
.AddChildren(instruction),
"",
new Grid { Stroke = LineThickness.None }
.AddColumns(GridLength.Auto, GridLength.Star(1))
.AddChildren(options.Select(OptionNameAndHelp))
);
public Document HelpAllOptionsList (ILookup verbsWithOptions, string instruction) =>
new Document { Background = Black, Color = Gray }
.AddChildren(
new Span($"{instruction}\n") { Color = White },
new Grid { Stroke = LineThickness.None }
.AddColumns(GridLength.Auto, GridLength.Star(1))
.AddChildren(
verbsWithOptions.Select(verbWithOptions => new object[] {
OptionNameAndHelp(verbWithOptions.Key),
new Grid { Stroke = LineThickness.None, Margin = new Thickness(4, 0, 0, 0) }
.Set(Grid.ColumnSpanProperty, 2)
.AddColumns(GridLength.Auto, GridLength.Star(1))
.AddChildren(verbWithOptions.Select(OptionNameAndHelp)),
})
)
);
private static object[] OptionNameAndHelp (BaseOptionAttribute option) => new[] {
new Div { Margin = new Thickness(1, 0, 1, 1), Color = Yellow, MinWidth = 14 }
.AddChildren(GetOptionSyntax(option)),
new Div { Margin = new Thickness(1, 0, 1, 1) }
.AddChildren(option.HelpText),
};
private static object GetOptionSyntax (BaseOptionAttribute option)
{
if (option is VerbOptionAttribute)
return option.LongName;
else if (option.ShortName != null) {
if (option.LongName != null)
return $"--{option.LongName}, -{option.ShortName}";
else
return $"-{option.ShortName}";
}
else if (option.LongName != null)
return $"--{option.LongName}";
else
return "";
}
}
```
Магия
=====
Как всё это нагромождение элементов строится и превращается в документ? Взгляд с высоты птичьего полёта:
* Построение логического дерева: с помощью преобразований а-ля LINQ to XML схлопываются `IEnumerable` в параметрах `AddChidlren` и др.
* Построение визуального дерева: каждый элемент преобразуется к виду, удобному для движка.
* Расчёт размеров элементов: каждый элемент решает, сколько места ему надо и сколько места дать своим детям.
* Расчёт положения элементов: элементы решают, по каким координатам внутри себя разместить детей.
* Рендеринг элементов в виртуальный буфер, имитирующий консоль.
* Рендеринг буфера в реальную консоль или в любой другой формат.
А теперь подробнее про каждый пункт.
Логическое дерево
-----------------
Построение документа в XAML напоминает WPF, только с `{Get Foo}` вместо `{Binding Foo, Mode=OneTime}` и с `{Res Bar}` вместо `{StaticResource Bar}`. Конвертеры здесь — не классы, а одиночные методы, к которым можно можно обратиться через `{Call Baz}`. Margin и Padding задаются, как и в WPF, с помощью строк c 1, 2 или 4 числами. Прикреплённые свойства задаются через имя класса и свойства через точку. Короче, для знакомых с WPF всё должно быть привычно и понятно.
Построение документа в C# сделано в духе LINQ to XML (System.Xml.Linq), только вместо конструкторов с аргументом `params object[]` используется метод `AddChildren` (а также `AddColumns`). Вот доступные преобразования:
* Элементы `null` полностью игнорируются. Кроме прочего, это позволяет условно включать некоторые элементы с помощью тернарного оператора.
* Последовательности `IEnumerable` разворачиваются, вместо них добавляются их элементы. Последовательности могут быть вложенными. Например, это позволяет в одном вызове `AddChildren` создать и шапку таблицы, и её содержимое с помощью `Select`.
* Объекты, которые не являются элементами, преобразуются к строкам. Если есть возможность (поддержка `IFormattable`), то с учётом локали элемента.
Для незнакомых с WPF концепция *прикреплённых свойств* может быть непривычной. Суть в том, что иногда требуется дополнять уже имеющиеся свойства элементов, например, Canvas имеет как свои свойства, так и свойства координат для своих элементов. Такие удобно задаются с помощью метода-расширения Set: `new Div(...).Set(Canvas.LeftProperty, 10)`.
Визуальное дерево
-----------------
Элементы делятся на две большие группы: блочные и строчные — прямо как в раннем HTML. Также есть элементы-генераторы (ну то есть один элемент), которые могут служить и теми, и другими в зависимости от шаблонов.
Исходное дерево элементов — *логическое* в терминах WPF, то есть содержит элементы в том виде, в котором их создал программист. Потом оно же безвозвратно превращается в *визуальное*, то есть содержит элементы в том виде, который удобен для движка (грубо говоря, высокоуровневые абстракции преобразуются к элементам, которые реально могут себя отобразить). Это преобразование включает:
* Любой элемент может полностью заменить своё содержимое. Например, генератор Repeater клонирует свой шаблон и повторяет несколько раз, при этом исключая самого себя, а блок List расфасовывает свои подэлементы в Grid.
* Если несколько строчных элементов идут друг за другом, то они объединяются в один блок (InlineContainer).
* Если несколько блочных элементов идут друг за другом, то они объединяются в одну стопку (Stack).
Также надо отметить, что некоторые элементы умеют делать больше неявных преобразований, чем в WPF, например, Grid по умолчанию использует автоматическое последовательное размещение ячеек, что делает создание строк таблицы и указание координат каждой ячейки ненужным.
Расчёт размера элементов
------------------------
У всех элементов рекурсивно вызывается метод Measure, в котором родитель сообщает ребёнку, сколько ему положено свободного места, а ребёнок отвечает, сколько ему самому хочется. Ребёнок может попросить и больше, чем предложено, и меньше, но если попросить больше, то родитель покажет фигу. На бесконечность родитель тоже покажет фигу, даже если её предложил.
Элементы со сложной логикой размещения детей используют эту стадию, чтобы выполнить большую часть своей работы (например, контейнер строчных элементов форматирует текст, учитывая переносы и цвета).
Расчёт положения элментов
-------------------------
У всех элементов рекурсивно вызывается Arrange, в котором каждый родитель занимается размещением своих детей.
Рендеринг элементов
-------------------
У всех элементов рекурсивно вызывается Render, в котором каждый элемент отображает себя в виртуальном консольном буфере ConsoleBuffer. Класс ConsoleBuffer — это что-то сродни HDC, System.Windows.Forms.Graphics, Graphics.TCanvas и прочего такого. Он содержит методы для отображения текста, рисования и прочего.
Подаётся буфер каждому элементу в удобном виде с ограниченной доступной областью, чтобы можно было рисовать себя по координатам (0; 0)–(Width; Height), не заморачиваясь.
Рендеринг буфера
----------------
На данной стадии с буфере находится прямоугольная область с текстом и цветом. Её можно или отобразить в консоль, как и было задумано, или сотворить с ним что-то другое, например, конвертировать в HTML или отобразить в окошке WPF. За это отвечают классы, реализующие IRenderTarget.
А что как сложно-то?
--------------------
Это просто. Сложно — это ConsoleFramework и уж тем более Avalonia. Тут ни инвалидаций, ни интерактива. Всё сделано ради простоты: и просто писать документы, и просто писать элементы. Все деревья одноразовые.
Реально нужно знать только то, как использовать `AddChildren` (и то по вкусу), а также паттерны использования базовых элементов, в частности `Grid`. Всё остальное понадобится, только если захотите создавать свои элементы.
И даже если вы захотите создавать свои элементы, то можно ограничиться простым преобразованием в уже умеющие себя отображать элементы, например, List реализован через Grid, вся логика умещается в один тривиальный метод на 16 строк.
А также
=======
Всё это работает в .NET 4.0+, .NET Standard 1.3+. Для пуристов есть версия без поддержки XAML. Она же для консерваторов, потому что включает поддержку .NET 3.5.
Есть пакетик для поддержки шрифтов FIGlet из Colorful.Console, но эта зависимость была ошибкой, потому что, как выяснилось, Colorful.Console не умеет FIGlet по-нормальному. Позднее будет или поддержка на базе пакета Figgle, или своя реализация.
В репозитории также находятся два проекта-примера и тесты с покрытием средней паршивости.
Лицензия
========
Apache 2.0. Часть кода позаимствована из библиотеки ConsoleFramework, написанной Игорем Костоминым под лицензией MIT.
Ссылки
======
* **[CsConsoleFormat на GutHub](https://github.com/Athari/CsConsoleFormat)** — сорцы
* **[CsConsoleFormat на NuGet](https://www.nuget.org/packages/Alba.CsConsoleFormat)** — бинарники | https://habr.com/ru/post/271299/ | null | ru | null |
# Детекторы и дескрипторы особых точек FAST, BRIEF, ORB
В этой статье речь пойдёт о некоторых алгоритмах поиска и описания особых точек изображений. Здесь эта тема уже [поднималась](https://habr.com/post/244541/), и [не раз](https://habr.com/post/106302/). Буду считать, что основные определения читателю уже знакомы, рассмотрим детально эвристические алгоритмы FAST, FAST-9, FAST-ER, BRIEF, rBRIEF, ORB, обсудим искромётные идеи, лежащие в их основе. Частично это будет вольный перевод сути нескольких статей [1,2,3,4,5], будет немного кода для «попробовать».
Алгоритм FAST
=============
FAST, впервые предложенный в 2005 году в работе [1], был одним из первых эвристических методов поиска особых точек, который завоевал большую популярность из-за своей вычислительной эффективности. Для принятия решения о том, считать заданную точку С особой или нет, в этом методе рассматривается яркость пикселов на окружности с центром в точке С и радиусом 3:
Сравнивая яркости пикселов окружности с яркостью центра C, получаем для каждого три возможных исхода (светлее, темнее, похоже):
Здесь I – яркость пикселов, t – некоторый заранее фиксированный порог по яркости.
Точка помечается как особая, если на круге существует подряд n=12 пикселов, которые темнее, или 12 пикселов, которые светлее, чем центр.
Как показала практика, в среднем для принятия решения нужно было проверить около 9 точек. Для того, чтобы ускорить процесс, авторы предложили сначала проверить только четыре пиксела под номерами: 1, 5, 9, 13. Если среди них есть 3 пиксела светлее или темнее, то выполняется полная проверка по 16 точкам, иначе – точка сразу помечается как «не особая». Это сильно сокращает время работы, для принятия решения в среднем достаточно опросить всего лишь около 4 точек окружности.
Немного наивного кода лежит [тут](https://github.com/Unlingius/fast11)
Изменяемые параметры (описаны в коде): радиус окружности (приимает значения 1,2,3), параметр n (в оригинале n=12), параметр t. Код открывает файл in.bmp, обрабатывает картинку, сохраняет в out.bmp. Картинки обычные 24-битные.
Строим дерево решений, Tree FAST, FAST-9
========================================
В 2006 году в работе [2] удалось развить оригинальную идею с использованием машинного обучения и деревьев решений.
У оригинального FAST есть следующие недостатки:
* Несколько рядом расположенных пикселов могут быть помечены как особые точки. Нужна какая-то мера «силы» особенности. Одна из первых предложенных мер — максимальное значение t, при котором точка всё ещё принимается как особая.
* Быстрый 4-точечный тест не обобщается для n меньше 12. Так, например, визуально наилучшие результаты метода достигаются при n=9, а не 12.
* Хотелось бы ещё ускорить алгоритм!
Вместо использования каскада из двух тестов из 4 и 16 точек предлагается всё делать за один проход по дереву решений. Аналогично оригинальному методу будем сравнивать яркость центральной точки с точками на окружности, но в таком порядке, чтобы принять решение как можно быстрее. И оказывается, что можно принимать решение всего лишь за ~2 (!!!) сравнения в среднем.
Самая соль в том, как найти нужный порядок для сравнения точек. Найти при помощи машинного обучения. Предположим, кто-то отметил для нас на картинке множество особых точек. Будем использовать их как набор обучающих примеров и идея состоит в том, чтобы в качестве следующей точки жадно выбирать такую, которая даст наибольшее число информации на данном шаге. Например, пусть изначально в нашей выборке было 5 особых точек и 5 НЕособых точек. В виде таблички вот так:
Выберем теперь один из пикселов р окружности и для всех особых точек проведём сравнение центрального пиксела с выбранным. В зависимости от яркости выбранного пиксела около каждой особой точки, в таблице может быть такой результат:
Идея в том, чтобы выбрать такую точку p, чтобы цифры в столбцах таблицы максимально отличались. И если теперь для новой неизвестной точки мы получим результат сравнения «Светлее», то уже можем сразу сказать, что точка «не особая» (см. таблицу). Процесс продолжается рекурсивно до тех пор, пока в каждую группу после разделения на «темнее-похожий-светлее» не будут попадать точки только одного из классов. Получается дерево следующего вида:
В листьях дерева находится бинарное значение (красный – особая, зелёный – не особая), а в остальных вершинах дерева находится номер точки, которую нужно анализировать. Более конкретно, в оригинальной статье предлагают делать выбор номера точки по изменению энтропии. Энтропия множества точек вычисляется:
с – число особых точек,  – число не особых точек множества
Изменение энтропии после обработки точки p:
Соответственно, выбирается точка, для которой изменение энтропии будет максимально. Процесс разбиения прекращается, когда энтропия равна нулю, это означает, что все точки либо особые, либо наоборот – все не особые. При программной реализации после всего этого найденное дерево решений преобразуется в набор конструкций типа «if-else».
Последним этапом алгоритма является операция подавления немаксимумов, чтобы получить из нескольких рядом расположенных точек одну. Разработчики предлагают использовать оригинальную меру на основе суммы абсолютных разностей между центральной точкой и точками окружности в таком виде:
Здесь  и  соответственно группы пикселов светлее и темнее, t – пороговое значение яркости,  – яркость центрального пиксела,  – яркость пиксела на круге. Попробовать алгоритм можно [следующим кодом](https://github.com/Unlingius/fast22). Код взят из OpenCV и освобождён от всех зависимостей, просто запускайте.
Оптимизируем дерево решений — FAST-ER
=====================================
FAST-ER [3] – алгоритм тех же авторов, что и предыдущий, аналогично строится быстрый детектор, тоже ищется оптимальная последовательность точек для сравнения, тоже строится дерево решений, но другим методом – методом оптимизации.
Мы уже понимаем, что детектор можно представить в виде дерева решений. Если бы у нас был какой-нибудь критерий для сравнения производительности разных деревьев, то можно максимизировать этот критерий, перебирая разные варианты деревьев. И вот в качестве такого критерия предложено использовать «Повторяемость».
Повторяемость показывает, насколько хорошо особые точки сцены детектируются с разных ракурсов. Для пары картинок точка называется «полезной» (useful), если найдена на одном кадре и теоретически может быть найдена на другом, т.е. не загораживается элементами сцены. И точка называется «повторяемой» (repeated), если она найдена на втором кадре тоже. Поскольку оптика камеры неидеальна, то точка на втором кадре может находиться не в расчётном пикселе, а где-то рядом в его окрестности. Разработчики взяли окрестность в 5 пикселов. Определим повторяемость как отношение числа повторяемых точек к числу полезных:
Для поиска наилучшего детектора используется метод имитации отжига. На Хабре уже есть [прекрасная статья](https://habr.com/post/209610/) про него. Кратко, суть метода в следующем:
* Выбирается какое-то начальное решение задачи (в нашем случае это какое-то дерево детектора).
* Считается повторяемость.
* Дерево случайным образом модифицируется.
* Если модифицированный вариант лучше по критерию повторяемости, то модификация принимается, а если хуже, то может либо приняться, либо нет, с некоторой вероятностью, которая зависит от вещественного числа, называемого «температура». С увеличением числа итераций температура падает до нуля.
Кроме этого, в построении детектора теперь участвуют не 16 точек окружности, как раньше, а 47, но смысл от этого совершенно не меняется:
Согласно методу имитации отжига, определим три функции:
• Функцию стоимости k. В нашем случае в качестве стоимости мы используем повторяемость. Но тут есть одна проблема. Представим, что все точки на каждом из двух изображений детектированы как особые. Тогда получается, что повторяемость равна 100 % – абсурд. С другой стороны, пусть у нас на двух картинках найдено по одной особой точке, и эти точки совпали – повторяемость также 100 %, но это тоже нас не интересует. И поэтому авторы предложили в качестве критерия качества использовать такой:
r – повторяемость,  – число детектированных углов на кадре i, N – число кадров и s – размер дерева (число вершин). W – настраиваемые параметры метода.]
• Функцию изменения температуры со временем:
где  – коэффициенты, Imax – число итераций.
• Функцию, порождающую новое решение. Алгоритм делает случайные модификации дерева. Сначала выбирается некоторая вершина. Если выбранная вершина это лист дерева, то с равной вероятностью делаем следующее:
1. Заменим вершину случайным поддеревом с глубиной 1
2. Изменить класс этого листа (особая-неособая точки)
Если это НЕ лист:
1. Заменить номер тестируемой точки случайным числом от 0 до 47
2. Заменить вершину листом со случайным классом
3. Поменять местами два поддерева из этой вершины
Вероятность P принятия изменения на итерации I это:
k – функция стоимости, T – температура, i – номер итерации.
Эти модификации к дереву позволяют как рост дерева, так и его сокращение. Метод случайный, он не гарантирует, что получится наилучшее дерево. Запускают метод много раз, выбирая наилучшее решение. В оригинальной статье, например, запускают 100 раз на 100000 итераций каждый, что занимает 200 часов времени процессора. Как показывают результаты, получается в итоге лучше, чем Tree FAST, особенно на зашумлённых картинках.
Дескриптор BRIEF
================
После того, как особые точки найдены, вычисляют их дескрипторы, т.е. наборы признаков, характеризующие окрестность каждой особой точки. BRIEF [4] – быстрый эвристический дескриптор, строится из 256 бинарных сравнений между яркостями пикселов на размытом изображении. Бинарный тест между точками х и у определяется так:
В оригинальной статье было рассмотрено несколько способов выбора точек для бинарных сравнений. Как оказалось, один из лучших способов – выбирать точки случайным образом Гауссовским распределением вокруг центрального пиксела. Эта случайная последовательность точек выбирается один раз и в дальнейшем не меняется. Размер рассматриваемой окрестности точки равен 31х31 пиксел, а апертура размытия равна 5.
Полученный бинарный дескриптор оказывается устойчив к сменам освещения, перспективному искажению, быстро вычисляется и сравнивается, но очень неустойчив к вращению в плоскости изображения.
ORB — быстрый и эффективный
===========================
Развитием всех этих идей стал алгоритм ORB (Oriented FAST and Rotated BRIEF) [5], в котором сделана попытка улучшить производительноть BRIEF при повороте изображения. Предложено сначала вычислять ориентацию особой точки и затем проводить бинарные сравнения уже в соответствие с этой ориентацией. Работает алгоритм так:
1) Особые точки обнаруживаются при помощи быстрого древовидного FAST на исходном изображении и на нескольких изображениях из пирамиды уменьшенных изображений.
2) Для обнаруженных точек вычисляется мера Харриса, кандидаты с низким значением меры Харриса отбрасываются.
3) Вычисляется угол ориентации особой точки. Для этого, сначала вычисляются моменты яркости для окрестности особой точки:
x,y – пиксельные координаты, I – яркость. И затем угол ориентации особой точки:
Всё это авторы назвали «центроид ориентации». В итоге получаем некоторое направление для окрестности особой точки.
4) Имея угол ориентации особой точки, последовательность точек для бинарных сравнений в дескрипторе BRIEF поворачивается в соответствие с этим углом, например:
Если более формально, новые положения для точек бинарных тестов вычисляются так:
5) По полученным точкам вычисляется бинарный дескриптор BRIEF
И на этом… не всё! Есть в ORB ещё одна интересная деталь, которая требует отдельных пояснений. Дело в том, что в тот момент, когда мы «доворачиваем» все особые точки до нулевого угла, случайный выбор бинарных сравнений в дескрипторе перестаёт быть случайным. Это приводит к тому, что, во-первых, некоторые бинарные сравнения оказываются зависимыми между собой, во-вторых, их среднее уже не равно 0.5 (1 – светлее, 0 – темнее, когда выбор был случайным, то в среднем было 0.5) и всё это существенно уменьшает способность дескриптора различать особые точки между собой.
Решение — нужно выбрать «правильные» бинарные тесты в процессе обучения, эта идея веет тем же ароматом, что и обучение дерева для алгоритма FAST-9. Предположим, у нас есть куча уже найденных особых точек. Рассмотрим все возможные варианты бинарных тестов. Если окрестность 31 х 31, а бинарный тест представляет собой пару подмножеств 5 х 5 (из-за размытия), то всего вариантов выбора N=(31-5)^2 – очень много. Алгоритм поиска «хороших» тестов такой:
1. Вычисляем результат всех тестов для всех особых точек
2. Упорядочим всё множество тестов по их дистанции от среднего 0.5
3. Создадим список, который будет содержать отобранные «хорошие» тесты, назовём список R.
4. Добавим в R первый тест из отсортированного множества
5. Берём следующий тест и сравниваем его со всеми тестами в R. Если корреляция больше пороговой, то отбрасываем новый тест, иначе – добавляем.
6. Повторяем п. 5 пока не наберём нужное число тестов.
Получается, что тесты отбираются так, чтобы, с одной стороны, среднее значение этих тестов было как можно ближе к 0.5, с другой стороны, чтобы корреляция между разными тестами была минимальна. А это нам и нужно. Сравните, как было и как стало:
К счастью, алгоритм ORB реализован в библиотеке OpenCV в классе cv::ORB. Я использую версию 2.4.13. Конструктор класса принимает следующие параметры:
nfeatures – максимальное число особых точек
scaleFactor – множитель для пирамиды изображений, больше единицы. Значение 2 реализует классическую пирамиду.
nlevels – число уровней в пирамиде изображений.
edgeThreshold – число пикселов у границы изображения, где особые точки не детектируются.
firstLevel – оставить нулём.
WTA\_K – число точек, которое требуется для одного элемента дескриптора. Если равно 2, то сравнивается яркость двух случайно выбранных пикселов. Это и нужно.
scoreType – если 0, то в качестве меры особенности используется харрис, иначе – мера FAST (на основе суммы модулей разностей яркостей в точках окружности). Мера FAST чуть менее стабильная, но быстрее работает.
patchSize – размер окрестности, из которой выбираются случайные пикселы для сравнения. Код производит поиск и сравнение особых точек на двух картинках, «templ.bmp» и «img.bmp»
**Код**
```
cv::Mat img_object=cv::imread("templ.bmp", 0);
std::vector keypoints\_object, keypoints\_scene;
cv::Mat descriptors\_object, descriptors\_scene;
cv::ORB orb(500, 1.2, 4, 31, 0, 2, 0, 31);
// особые точки объекта
orb.detect(img\_object, keypoints\_object);
orb.compute(img\_object, keypoints\_object, descriptors\_object);
// особые точки картинки
cv::Mat img = cv::imread("img.bmp", 1);
cv::Mat img\_scene = cv::Mat(img.size(), CV\_8UC1);
orb.detect(img, keypoints\_scene);
orb.compute(img, keypoints\_scene, descriptors\_scene);
cv::imshow("desrs", descriptors\_scene);
cvWaitKey();
int test[10];
for (int q = 0; q<10 ; q++) test[q]=descriptors\_scene.data[q];
//-- matching descriptor vectors using FLANN matcher
cv::BFMatcher matcher;
std::vector matches;
cv::Mat img\_matches;
if(!descriptors\_object.empty() && !descriptors\_scene.empty()) {
matcher.match (descriptors\_object, descriptors\_scene, matches);
double max\_dist = 0; double min\_dist = 100;
// calculation of max and min idstance between keypoints
for( int i = 0; i < descriptors\_object.rows; i++)
{ double dist = matches[i].distance;
if( dist < min\_dist ) min\_dist = dist;
if( dist > max\_dist ) max\_dist = dist;
}
//-- Draw only good matches (i.e. whose distance is less than 3\*min\_dist)
std::vector< cv::DMatch >good\_matches;
for( int i = 0; i < descriptors\_object.rows; i++ ) if( matches[i].distance < (max\_dist/1.6) ) good\_matches.push\_back(matches[i]);
cv::drawMatches(img\_object, keypoints\_object, img\_scene, keypoints\_scene, good\_matches, img\_matches, cv::Scalar::all(-1), cv::Scalar::all(-1),
std::vector(), cv::DrawMatchesFlags::NOT\_DRAW\_SINGLE\_POINTS);
}
cv::imshow("match result", img\_matches );
cv::waitKey();
return 0;
```
Если кому-то помогло разобраться в сути алгоритмов, то всё не зря. Всем Хабра.
Литература:
1. [Fusing Points and Lines for High Performance Tracking](http://www.edwardrosten.com/work/rosten_2005_tracking.pdf)
2. [Machine learning for high-speed corner detection](http://www.edwardrosten.com/work/rosten_2006_machine.pdf)
3. [Faster and better: a machine learning approach to corner detection](https://arxiv.org/pdf/0810.2434.pdf)
4. [BRIEF: Binary Robust Independent Elementary Features](https://www.cs.ubc.ca/~lowe/525/papers/calonder_eccv10.pdf)
5. [ORB: an efficient alternative to SIFT or SURF](http://www.willowgarage.com/sites/default/files/orb_final.pdf) | https://habr.com/ru/post/414459/ | null | ru | null |
# Вычислительная геология и визуализация: пример Python 3 Jupyter Notebook
Сегодня вместо обсуждения геологических моделей мы посмотрим пример их программирования в среде Jupyter Notebook на языке Python 3 и с библиотеками Pandas, NumPy, SciPy, XArray, Dask Distributed, Numba, VTK, PyVista, Matplotlib. Это довольно простой ноутбук с поддержкой многопоточной работы и возможностью запуска локально и в кластере для обработки больших данных, отложенными вычислениями (ленивыми) и наглядной трехмерной визуализацией результатов. В самом деле, я постарался собрать разом целый набор сложных технических концепций и сделать их простыми. Для создания кластера на Amazon AWS смотрите скрипт [AWS Init script for Jupyter Python GIS processing](https://github.com/mobigroup/gis-snippets/tree/master/aws), предназначенный для единовременного создания набора инстансов и запуска планировщика ресурсов на главном инстансе.
Визуализация с помощью Visualization Toolkit(VTK) и PyVista это уже далеко не Matplotlib
Идея сделать такой пример возникла у меня давно, поскольку я регулярно занимаюсь разнообразными вычислительными задачами, в том числе для различных университетов и для геологоразведочной индустрии, и знаком очень близко с проблемами переносимости и поддерживаемости программ, а также проблемами работы с так называемыми большими данными (сотни гигабайт и терабайты) и визуализацией результатов. Так что само собой появилось желание сделать ноутбук-пример, в котором коротко и просто показать и красивую визуализацию и распараллеливание и ускорение кода Python и чтобы этот ноутбук можно было без изменений запустить как локально, так и на кластере. Все использованные библиотеки доступны уже много лет, но мало известны, или, как говорится, они остаются широко известными в узких кругах. Оставалось лишь найти подходящую задачку, на которой все это можно показать и это было, пожалуй, самым сложным — ведь мне хотелось, чтобы пример получился достаточно осмысленным и полезным. И вот такая задача нашлась — рассмотреть моделирование гравитационного поля на поверхности для заданной (синтетической в данном случае) модели плотности недр и некоторые последующие преобразования с вычислением фрактального индекса по компонентам пространственного спектра и кольцевого преобразования Радона, как его называют математики, или Хафа, согласно компьютерным наукам. Замечательно то, что с популярными библиотеками Python эти преобразования делаются буквально в несколько строчек кода, что особенно ценно для примера. Поскольку моделирование поля в каждой точке поверхности требует вычисления для всего трехмерного объема, мы будем обрабатывать гигантский объем данных. Для визуализации используем человеколюбивую обертку [PyVista](https://www.pyvista.org) для библиотеки [VTK — Visualization Toolkit](https://vtk.org), потому что писать код для последней это путь истинных джедаев… кто хочет лично в том убедиться, смотрите мой модуль к ParaView [N-Cube ParaView plugin for 3D/4D GIS Data Visualization](https://github.com/mobigroup/ParaView-plugins), написанный как раз на Python + VTK.
Теперь предлагаю проследовать [по ссылке на страницу GitHub репозитория](https://github.com/mobigroup/gis-snippets/tree/master/Synthetic%20Model%20Inversion) или сразу открыть ноутбук [basic.ipynb](https://github.com/mobigroup/gis-snippets/blob/master/Synthetic%20Model%20Inversion/basic.ipynb) Надеюсь, код достаточно просто читается, остановлюсь лишь на нескольких особенностях. Запускаемый в ноутбуке локальный кластер dask предназначен для работы на многоядерных компьютерах, а вот для работы в кластере потребуется настроить подключение к его планировщику. В упомянутом выше скрипте [AWS Init script for Jupyter Python GIS processing](https://github.com/mobigroup/gis-snippets/tree/master/aws) есть соответствующие комментарии и ссылки. В коде мы используем векторизацию NumPy, то есть передаем сразу массивы, а не скаляры, при этом пользуемся тем, что XArray объекты предоставляют доступ к внутренним NumPy объектам (object.values). Код NumPy ускорить непросто, но с помощью Numba и для такого кода можно получить некоторый выигрыш в скорости исполнения (возможно, даже около 15%):
```
from numba import jit
@jit(nopython=True, parallel=True)
def delta_grav_vertical(delta_mass, x, y, z):
G=6.67408*1e-11
return -np.sum((100.*1000)*G*delta_mass*z/np.power(x**2 + y**2 + z**2, 1.5))
```
Для перебора всех точек на поверхности куба и вычисления для каждой такой точки гравитационного воздействия от каждой точки куба (это, кстати, получается пятикратный интеграл) мы пишем:
```
def forward_gravity(da):
(da_y, da_x, da_z) = xr.broadcast(da.y, da.x, da.z)
deltagrav = lambda x0, y0: delta_grav_vertical(da.values.ravel(), (da_x.values.ravel()-x0), (da_y.values.ravel()-y0), (da_z.values.ravel()-0))
gravity = xr.apply_ufunc(deltagrav, da_x.isel(z=0).chunk(50), da_y.isel(z=0).chunk(50), vectorize=True, dask='parallelized')
...
```
Здесь xarray.broadcast с линеаризацией массивов функцией ravel() позволяют из трех одномерных координат x, y, z получить триплеты координат для каждой точки куба. Выражения da\_x.isel(z=0) и da\_y.isel(z=0) извлекают x, y координаты верхней поверхности куба, на которой и вычисляется гравитационное поле (точнее, его вертикальную компоненту, т.к. именно она измеряется при практических исследованиях и такие данные доступны для анализа). Функция xarray.apply\_ufunc() весьма универсальная и одновременно обеспечивает векторизацию и поддержку параллельных ленивых вычислений dask для указанной коллбэк функции deltagrav. Хитрость заключается в том, что для выполнения вычислений на кубе для каждой точки поверхности нужно координаты поверхности передать в виде XArray массивов, а для использования dask они также должны быть dask массивами, что мы и обеспечиваем конструкциями da\_x.isel(z=0).chunk(50) и da\_y.isel(z=0).chunk(50), где 50 это размер блока по координатам x, y (подбирается в зависимости от размера массивов и количества доступных вычислительных потоков). Да, такая вот магия — достаточно лишь использовать вызов chunk() для XArray массива, чтобы автоматически превратить его в dask массив.
Обратим внимание, что dask-вычисления по умолчанию являются ленивыми (отложенными), то есть вызов функции forward\_gravity() завершается почти мгновенно, но возвращаемый результат является лишь оберткой, которая инициирует вычисления только при непосредственном обращении к данным или вызовом load(). При интерактивной работе это очень удобно, так как мы можем написать сложный пайплайн с большими наборами данных и для проверки и визуализации выбрать лишь маленький его кусочек, а при необходимости и запустить вычисления на полном наборе данных. К примеру, мне часто приходится работать с NetCDF датасетами глобального рельефа планеты и прочими в сотни гигабайт на своем ноутбуке — визуализируя малую часть данных, а потом запускать уже готовый ноутбук в облаке для обработки всех данных. Таким образом, код для локальной работы и его продакшен версия ничем не отличаются. Главное, правильно настроить размеры dask блоков, иначе вся магия "сломается".
Код кольцевого преобразования простой и полностью основан на стандартной двумерной свертке с кольцевой маской. Вот с вычислением фрактального индекса есть небольшой нюанс. А именно, здесь используется гауссова полосовая фильтрация исходного растра для выделения спектральных компонентов (диапазонов пространственных частот), мощность которых вычисляется как стандартное отклонение значений полученных матриц. Для нашей синтетической модели можно бы и попроще, а вот для реальных данных этот метод оказывается оптимальным в силу своей устойчивости к очень зашумленным данным и отсутствия проблем с границами. Далее стандартным способом вычисляется наклон кривой на двойном логарифмическом графике (логарифм длины волны и логарифм мощности компоненты).
В заключение, приглашаю всех посетить [GitHub репозитории](https://github.com/mobigroup) с множеством геологических моделей и их визуализацией в Blender и ParaView, а также примерами различного анализа. Также смотрите готовые визуализации на [YouTube канале](https://www.youtube.com/channel/UCSEeXKAn9f_bDiTjT6l87Lg). | https://habr.com/ru/post/546800/ | null | ru | null |
# Запуск двух и более инстансов MySQL на одном Linux-сервере
Хочу поделиться еще одним способом решения такой проблемы, как запуск более одного mysql-server на одном linux-сервере. Я думаю, что некоторые из вас уже пробовали это делать, запуская руками, например, вот так:
```
mysqld_safe --defaults-file=...my2.cnf... &
```
Я считаю этот подход не совсем правильным хотя бы потому, что корректно завершить такой запущенный mysql-сервер получится не всегда. Можно ещё, конечно, использовать **mysqld\_multi**, но лично я предпочитаю полностью «изолировать» друг от друга инстансы. Именно поэтому я и предлагаю вам в своей публикации использовать в помощь систему инициализации.
Дано: OS Linux CentOS 6.5. Как ставить MySQL-сервер или его производные (например, Percona), я рассказывать не стану, перейду сразу к делу. Поставили, запустили.
```
[root@localhost /]# ps aux | grep sql
```
```
root 8455 0.0 0.2 5064 1344 pts/0 S 01:36 0:00 /bin/sh /usr/bin/mysqld_safe --datadir=/var/lib/mysql --socket=/var/lib/mysql/mysql.sock --pid-file=/var/run/mysqld/mysqld.pid --basedir=/usr --user=mysql
mysql 8566 0.0 3.0 135476 15328 pts/0 Sl 01:36 0:00 /usr/libexec/mysqld --basedir=/usr --datadir=/var/lib/mysql --user=mysql --log-error=/var/log/mysqld.log --pid-file=/var/run/mysqld/mysqld.pid --socket=/var/lib/mysql/mysql.sock --port=3306
```
Сервер запустился, всё работает. Все параметры по-умолчанию, если не указано обратное в **my.cnf**.
Теперь займёмся запуском второго инстанса. Создаем место для второй базы:
```
mkdir /var/lib/mysql2 && chown -R mysql:mysql /var/lib/mysql2
```
Для хранения логов:
```
mkdir /var/log/mysql2 && chown -R mysql:mysql /var/log/mysql2
```
Копируем дефолтный конфигурационный файл для второго инстанса:
```
cp /etc/my.cnf /etc/my2.cnf
```
Займёмся отдельной директорией в /var/run:
```
mkdir /var/run/mysqld2 && chown -R mysql:mysql /var/run/mysqld2
```
**Осталось поправить my2.cnf и добавить init-скрипт в /etc/init.d/ для корректного управления новым инстансом**.
Правим /etc/my2.cnf:
```
[mysqld]
bind-address=127.0.0.1
port=3307
datadir=/var/lib/mysql2
socket=/var/lib/mysql2/mysql2.sock
user=mysql
# Disabling symbolic-links is recommended to prevent assorted security risks
symbolic-links=0
[mysqld_safe]
log-error=/var/log/mysql2/mysqld.log
pid-file=/var/run/mysqld2/mysqld.pid
```
Чем различаются конфигурационные файлы:
```
[root@localhost mysqld2]# diff /etc/my.cnf /etc/my2.cnf
3,5c3,5
< port=3306
< datadir=/var/lib/mysql
< socket=/var/lib/mysql/mysql.sock
---
> port=3307
> datadir=/var/lib/mysql2
> socket=/var/lib/mysql2/mysql2.sock
11,12c11,12
< log-error=/var/log/mysqld.log
< pid-file=/var/run/mysqld/mysqld.pid
---
> log-error=/var/log/mysql2/mysqld.log
> pid-file=/var/run/mysqld2/mysqld.pid
```
Ну и, наконец, подготовим init-скрипт для запуска второго сервера. Здесь начинается самое интересное:
```
cp /etc/init.d/mysqld /etc/init.d/mysqld2
```
Открываем и правим отдельные строчки в файле /etc/init.d/mysqld2:
1) Во-первых, нам нужно закомментировать (или удалить) функцию **get\_mysql\_option()**, дабы она не подсовывала mysqld\_safe значения по-умолчанию:
```
#get_mysql_option(){
# result=`/usr/bin/my_print_defaults "$1" | sed -n "s/^--$2=//p" | tail -n 1`
# if [ -z "$result" ]; then
# # not found, use default
# result="$3"
# fi
#}
```
2) Также комментируем её использование в дальнейшем и записываем в нужные переменные уникальные пути и директории для нового инстанса:
```
#get_mysql_option mysqld datadir "/var/lib/mysql2"
datadir="/var/lib/mysql2"
#get_mysql_option mysqld socket "$datadir/mysql2.sock"
socketfile="$datadir/mysql2.sock"
#get_mysql_option mysqld_safe log-error "/var/log/mysql2/mysqld.log"
errlogfile="/var/log/mysql2/mysqld.log"
#get_mysql_option mysqld_safe pid-file "/var/run/mysqld2/mysqld.pid"
mypidfile="/var/run/mysqld2/mysqld.pid"
```
3) Последний штрих: в функции start() явно указываем mysqld\_safe использовать наш **отдельный** конфигурационный файл и писать в отдельную папку логи. Для этого приводим следующую строку к приблизительно такому виду:
```
$exec --defaults-file=/etc/my2.cnf --datadir="$datadir" --socket="$socketfile" \
--pid-file="$mypidfile" --log-error=/var/log/mysql2/mysqld.log \
--basedir=/usr --user=mysql >/dev/null 2>&1 &
```
Сохраняем. Запускаем, выполняя /etc/init.d/mysql2 start. Остановка: /etc/init.d/mysql2 stop. Проверка:
```
[root@localhost run]# ps aux | grep sql2
root 9375 0.0 0.2 5064 1348 pts/1 S 02:44 0:00 /bin/sh /usr/bin/mysqld_safe --defaults-file=/etc/my2.cnf --datadir=/var/lib/mysql2 --socket=/var/lib/mysql2/mysql2.sock --pid-file=/var/run/mysqld2/mysqld.pid --log-error=/var/log/mysql2/mysqld.log --basedir=/usr --user=mysql
mysql 9489 0.1 3.0 135476 15328 pts/1 Sl 02:44 0:00 /usr/libexec/mysqld --defaults-file=/etc/my2.cnf --basedir=/usr --datadir=/var/lib/mysql2 --user=mysql --log-error=/var/log/mysql2/mysqld.log --pid-file=/var/run/mysqld2/mysqld.pid --socket=/var/lib/mysql2/mysql2.sock --port=3307
root 9510 0.0 0.1 4356 732 pts/1 S+ 02:44 0:00 grep sql2
```
Ну и, наконец-то, подключаемся с помощью клиента к нашему второму MySQL-серверу путем явного указывания сокет-файла:
```
mysql -S /var/lib/mysql2/mysql2.sock
```
… и видим, что у нас всё получилось.
Спасибо за внимание.
P.S. В директории второй базы можно сначала использовать либо дефолтную, скопировав её из */var/lib/mysql*, либо заново созданную — с помощью **mysql\_install\_db**, либо уже имеющуюся (например, бэкап, созданный **Percona XtraBackup**). Самое главное — корректный пользователь-владелец (**mysql**) на файлы базы. | https://habr.com/ru/post/250929/ | null | ru | null |
# Планирование потоков в Windows. Часть 1 из 4
Ниже представлена не простая расшифровка доклада с [семинара CLRium](https://clrium.ru/), а переработанная версия для книги [.NET Platform Architecture](https://github.com/sidristij/dotnetbook). Той её части, что относится к потокам.
Потоки и планирование потоков
-----------------------------
Что такое поток? Давайте дадим краткое определение. По своей сути поток это:
* Средство параллельного относительно других потоков исполнения кода;
* Имеющего общий доступ ко всем ресурсам процесса.
Очень часто часто слышишь такое мнение, что потоки в .NET — они какие-то абсолютно свои. И наши .NET потоки являются чем-то более облегчённым чем есть в Windows. Но на самом деле потоки в .NET являются самыми обычными потоками Windows (хоть Windows thread id и скрыто так, что сложно достать). И если Вас удивляет, почему я буду рассказывать не-.NET вещи в хабе .NET, скажу вам так: если нет понимания этого уровня, можно забыть о хорошем понимании того, как и почему именно так работает код. Почему мы должны ставить volatile, использовать Interlocked и SpinWait. Дальше обычного `lock` дело не уйдёт. И очень даже зря.
Давайте посмотрим из чего они состоят и как они рождаются. По сути поток — это средство эмуляции параллельного исполнения относительно других потоков. Почему эмуляция? Потому, что поток как бы странно и смело это ни звучало — это чисто программная вещь, которая идёт из операционной системы. А операционная система создаёт этот слой эмуляции для нас. Процессор при этом о потоках ничего не знает вообще.
Задача процессора — просто исполнять код. Поэтому с точки зрения процессора есть только один поток: последовательное исполнение команд. А задача операционной системы каким-либо образом менять поток т.о. чтобы эмулировать несколько потоков.
Поток в физическом понимании
============================
"Но как же так?", — скажите вы, — "во многих магазинах и на различных сайтах я вижу запись "Intel Xeon 8 ядер 16 потоков". Говоря по-правде это — либо скудность в терминологии либо — чисто маркетинговый ход. На самом деле внутри одного большого процессора есть в данном случае 8 ядер и каждое ядро состоит из двух логических процессоров. Такое доступно при наличии в процессоре технологии Hyper-Threading, когда каждое ядро эмулирует поведение двух процессоров (но не потоков). Делается это для повышения производительности, да. Но по большому счёту если нет понимания, на каких потоках идут расчёты, можно получить очень не приятный сценарий, когда код выполняется со скоростью, ниже чем если бы расчёты шли на одном ядре. Именно поэтому раздача ядер идёт +=2 в случае Hyper-Threading. Т.е. пропуская парные ядра.
Технология эта — достаточно спорная: если вы работаете на двух таких псевдо-ядрах (**логических процессорах**, которые эмулируются технологией Hyper-Threading), которые при этом находятся на одном *физическом* ядре и работают с одной и той-же памятью, то вы будете постоянно попадать в ситуацию, когда второй логический процессор так же пытается обратиться к данной памяти, создавая блокировку либо попадая в блокировку, т.к. поток, находящийся на первом ядре работает с той же памятью.
Возникает блокировка совместного доступа: хоть и идёт эмуляция двух ядер, на самом-то деле оно одно. Поэтому в наихудшем сценарии эти потоки исполняются по очереди, а не параллельно.
Так если процессор ничего не знает о потоках, как же достигается параллельное исполнение потоков на каждом из его ядер? Как было сказано, поток — средство операционной системы выполнять на одном процессоре несколько задач одновременно. Достигается параллелизм очень быстрым переключением между потоками в течение очень короткого промежутка времени. Последовательно запуская на выполнение код каждого из потоков и делая это достаточно часто, операционная система достигает цели: делает их исполнение псевдопараллельным, но параллельным с точки зрения восприятия человека. Второе обоснование существования потоков — это утверждение, что программа не так часто срывается в математические расчёты. Чаще всего она взаимодействует с окружающим её миром: различным оборудованием. Это и работа с жёстким диском и вывод на экран и работа с клавиатурой и мышью. Поэтому чтобы процессор не простаивал, пока оборудование сделает то, чего хочет от него программа, поток можно на это время установить в состояние блокировки: ожидания сигнала от операционной системы, что оборудование сделало то, что от него просили. Простейший пример этого — вызов метода `Console.ReadKey()`.
Если заглянуть в диспетчер задач Windows 10, то можно заметить, что в данный момент в вашей системе существует около 1,5 тысячи потоков. И если учесть, что квант на десктопе равен 20 мс, а ядер, например, 4, то можно сделать вывод, что каждый поток получает 20 мс работы 1 раз в 7,5 сек… Ну конечно же, нет. Просто почти все потоки чего-то ждут. То ввода пользователя, то изменения ключей реестра… В операционной системе существует очень много причин, чтобы что-либо ждать.
Так что пока одни потоки в блокировке, другие — что-то делают.
Создание потоков
================
Простейшая функция создания потоков в пользовательском режиме операционной системы — `CreateThread`. Эта функция создаёт поток в текущем процессе. Вариантов параметризации `CreateThread` очень много и когда мы вызываем `new Thread()`, то из нашего .NET кода вызывается данная функция операционной системы.
В эту функцию передаются следующие атрибуты:
1) **Необязательная структура с атрибутами безопасности**:
* Дескриптор безопасности (SECURITY\_ATTRIBUTES) + признак наследуемости дескриптора.
> В .NET его нет, но можно создать поток через вызов функции операционной системы;
>
>
2) **Необязательный размер стека**:
* Начальный размер стека, в байтах (система округляет это значение до размера страницы памяти)
> Т.к. за нас размер стека передаёт .NET, нам это делать не нужно. Это необходимо для вызовов методов и поддержки памяти.
>
>
3) Указатель на функцию — точка входа нового потоками
4) Необязательный аргумент для передачи данных функции потока.
Из того, что мы **не** имеем в .NET явно — это структура безопасности с атрибутами безопасности и размер стэка. Размер стэка нас мало интересует, но атрибуты безопасности нас могут заинтересовать, т.к. сталкиваемся мы с ними впервые. Сейчас мы рассмотривать их не будем. Скажу только, что они влияют на возможность изменения информации о потоке средствами операционной системы.
Если мы создаём любым способом: из .NET или же вручную, средствами ОС, мы как итог имеем и ManageThreadId и экземпляр класса Thread.
Также у этой функции есть необязательный флаг: `CREATE_SUSPENDED` — поток после создания не стартует. Для .NET это поведение по умолчанию.
Помимо всего прочего существует дополнительный метод `CreateRemoteThread`, который создаёт поток в чужом процессе. Он часто используется для мониторинга состояния чужого процесса (например программа Snoop). Этот метод создаёт в другом процессе поток и там наш поток начинает исполнение. Приложения .NET так же могут заливать свои потоки в чужие процессы, однако тут могут возникнуть проблемы. Первая и самая главная — это отсутствие в целевом потоке .NET runtime. Это значит, что ни одного метод фреймворка там не будет: только WinAPI и то, что вы написали сами. Однако, если там .NET есть, то возникает вторая проблема (которой не было раньше). Это — версия runtime. Необходимо: понять, что там запущено (для этого необходимо импортировать не-.NET методы runtime, которые написаны на C/C++ и разобраться, с чем мы имеем дело). На основании полученной информации подгрузить необходимые версии наших .NET библиотек и каким-то образом передать им управление.
Я бы рекомендовал вам поиграться с задачкой такого рода: вжиться в код любого .NET процесса и вывести куда-либо сообщение об удаче внедрения (например, в файл лога)
Планирование потоков
--------------------
Для того чтобы понимать, в каком порядке исполнять код различных потоков, необходима организация планирования тих потоков. Ведь система может иметь как одно ядро, так и несколько. Как иметь эмуляцию двух ядер на одном так и не иметь такой эмуляции. На каждом из ядер: железных или же эмулированных необходимо исполнять как один поток, так и несколько. В конце концов система может работать в режиме виртуализации: в облаке, в виртуальной машине, песочнице в рамках другой операционной системы. Поэтому мы в обязательном порядке рассмотрим планирование потоков Windows. Это — настолько важная часть материала по многопоточке, что без его понимания многопоточка не встанет на своё место в нашей голове никоим образом.
Итак, начнём. Организация планирования в операционной системе Windows является: гибридной. С одной стороны моделируются условия вытесняющей многозадачности, когда операционная система сама решает, когда и на основе каких условия вытеснить потоки. С другой стороны — кооперативной многозадачности, когда потоки сами решают, когда они всё сделали и можно переключаться на следующий (UMS планировщик). Режим вытесняющей многозадачности является приоритетным, т.к. решает, что будет исполняться на основе приоритетов. Почему так? Потому что у каждого потока есть свой приоритет и операционная система планирует к исполнению более приоритетные потоки. А вытесняющей потому, что если возникает более приоритетный поток, он вытесняет тот, который сейчас исполнялся. Однако во многих случаях это бы означало, что часть потоков никогда не доберется до исполнения. Поэтому в операционной системе есть много механик, позволяющих потокам, которым необходимо время на исполнение его получить несмотря на свой более низкий по сравнению с остальными, приоритет.
### Уровни приоритета
Windows имеет 32 уровня приоритета (0-31)
* 1 уровень (00 — 00) — это Zero Page Thread;
* 15 уровней (01 — 15) — обычные динамические приоритеты;
* 16 уровней (16 — 31) — реального времени.
Самый низкий приоритет имеет Zero Page Thread. Это — специальный поток операционной системы, который обнуляет страницы оперативной памяти, вычищая тем самым данные, которые там находились, но более не нужны, т.к. страница была освобождена. Необходимо это по одной простой причине: когда приложение освобождает память, оно может ненароком отдать кому-то чувствительные данные. Личные данные, пароли, что-то ещё. Поэтому как операционная система так и runtime языков программирования (а у нас — .NET CLR) обнуляют получаемые участки памяти. Если операционная система понимает, что заняться особо нечем: потоки либо стоят в блокировке в ожидании чего-либо либо нет потоков, которые исполняются, то она запускает самый низко приоритетный поток: поток обнуления памяти. Если она не доберется этим потоком до каких-либо участков, не страшно: их обнулят по требованию. Когда их запросят. Но если есть время, почему бы это не сделать заранее?
Продолжая говорить о том, что к нам не относится, стоит отметить приоритеты реального времени, которые когда-то давным-давно таковыми являлись, но быстро потеряли свой статус приоритетов реального времени и от этого статуса осталось лишь название. Другими словами, Real Time приоритеты на самом деле не являются таковыми. Они являются приоритетами с исключительно высоким значением приоритета. Т.е. если операционная система будет по какой-то причине повышать приоритет потока с приоритетом из динамической группы (об этом — позже, но, например, потому, что потоку освободили блокировку) и при этом значение до повышения было равно `15`, то повысить приоритет операционная система не сможет: следующее значение равно `16`, а оно — из диапазона реального времени. Туда повышать такими вот "твиками" нельзя.
Уровень приоритетов **процессов** с позиции Windows API.
--------------------------------------------------------
Приоритеты — штука относительная. И чтобы нам всем было проще в них ориентироваться, были введены некие правила относительности расчетов: во-первых все потоки вообще (от всех приложений) равны для планировщика: планировщик не различает потоки это различных приложений или же одного и того же приложения. Далее, когда программист пишет свою программу, он задаёт приоритет для различных потоков, создавая тем самым модель многопоточности внутри своего приложения. Он прекрасно знает, почему там был выбран пониженный приоритет, а тут — обычный. Внутри приложения всё настроено. Далее, поскольку есть пользователь системы, он также может выстраивать приоритеты для приложений, которые запускаются на этой системе. Например, он может выбрать повышенный приоритет для какого-то расчетного сервиса, отдавая ему тем самым максимум ресурсов. Т.е. уровень приоритета можно задать и у процесса.
Однако, изменение уровня приоритета процесса не меняет *относительных приоритетов* внутри приложения: их значения сдвигаются, но не меняется внутренняя модель приоритетов: внутри по-прежнему будет поток с пониженным приоритетом и поток — с обычным. Так, как этого хотел разработчик приложения. Как же это работает?
Существует 6 *классов приоритетов* процессов. Класс приоритетов процессов — это то, относительно чего будут создаваться приоритеты потоков. Все эти классы приоритетов можно увидеть в "Диспетчере задач", при изменении приоритета какого-либо процесса.
| Название | Класс | Базовый приоритет |
| --- | --- | --- |
| 1. Real Time | 4 | 24 |
| 2. High | 3 | 13 |
| 3. Above Normal | 6 | 10 |
| 4. Normal | 2 | 8 |
| 5. Below Normal | 5 | 6 |
| 6. Idle | 1 | 4 |
Другими словами класс приоритета — это то, относительно чего будут задаваться приоритеты потоков внутри приложения. Чтобы задать точку отсчёта, было введено понятие *базового приоритета*. Базовый приоритет — это то **значение**, чем будет являться приоритет потока с типом приоритета **Normal**:
* Если процесс создаётся с *классом Normal* и внутри этого процесса создаётся поток с *приоритетом Normal*, то его **реальный приоритет Normal будет равен 8** (строка №4 в таблице);
* Если Вы создаёте процесс и у него *класс приоритета Above Normal*, то *базовый приоритет* будет равен 10. Это значит, что потоки внутри этого процесса будут создаваться с более повышенным приоритетом: **Normal будет равен 10**.
Для чего это необходимо? Вы как программисты знаете модель многопоточности, которая у вас присутствует.
Потоков может быть много и вы решаете, что один поток должен быть фоновым, так как он производит вычисления и вам
не столь важно, когда данные станут доступны: важно чтобы поток завершил вычисления (например поток обхода и анализа дерева). Поэтому, вы устанавливаете пониженный приоритет данного потока. Аналогично может сложится ситуация когда необходимо запустить поток с повышенным приоритетом.
Представим, что ваше приложение запускает пользователь и он решает, что ваше приложение потребляет слишком много процессорных ресурсов. Пользователь считает, что ваше приложение не столь важное в системе, как какие-нибудь другие приложения и понижает приоритет вашего приложения до Below Normal. Это означает, что он задаёт базовый приоритет 6 относительно которого будут рассчитываться приоритеты потоков внутри вашего приложения. Но в системе общий приоритет упадёт. Как при этом меняются приоритеты потоков внутри приложения?
| | Уровни насыщения |
| --- | --- |
| 1. Time Critical | (+15) |
| 2. Higest | (+2) |
| 3. Above normal | (+1) |
| 4. Normal | (+0) |
| 5. Below normal | (-1) |
| 6. Lowest | (-2) |
| 7. Idle | (-15) |
*Таблица 3*
Normal остаётся на уровне +0 относительно уровня базового приоритета процесса. Below normal — это (-1) относительно уровня базового. Т.е. в нашем примере с понижением уровня приоритета процесса до класса `Below Normal` приоритет потока 'Below Normal' пересчитается и будет не `8 - 1 = 7` (каким он был при классе `Normal`), а `6 - 1 = 5`. Lowest (-2) станет равным `4`.
`Idle` и `Time Critical` — это уровни насыщения (-15 и +15). Почему Normal — это `0` и относительно него всего два шага: -2, -1, +1 и +2? Легко провести параллель с обучением. Мы ходим в школу, получаем оценки наших знаний (5,4,3,2,1) и нам понятно, что это за оценки: 5 — молодец, 4 — хорошо, 3 — вообще не постарался, 2 — это не делал ни чего, а 1 — это то, что можно исправить потом на 4. Но если у нас вводится 10-ти бальная система оценок (или что вообще ужас — 100-бальная), то возникает неясность: что такое 9 баллов или 7? Как понять, что вам поставили 3 или 4?
Тоже самое и с приоритетами. У нас есть Normal. Дальше, относительно Normal у нас есть чуть повыше
Normal (Normal above), чуть пониже Normal (Normal below). Также есть шаг на два вверх
или на два вниз (Higest и Lowest). Нам, поверьте, нет никакой необходимости в более подробной градации. Единственное, очень редко, может раз в жизни, нам понадобится сказать: выше чем любой приоритет в системе. Тогда мы выставляем уровень `Time Critical`. Либо наоборот: это надо делать, когда во всей системе делать нечего. Тогда мы выставляем уровень `Idle`. Это значения — так называемые уровни насыщения.
Как рассчитываются уровни приоритета?
-------------------------------------
У нас бал класс приоритета процесса Normal (Таблица 3) и приоритет потоков Normal — это 8. Если процесс Above Normal то поток Normal получается равен 9. Если же процесс выставлен в Higest, то поток Normal получается равен 10.
Поскольку для планировщика потоков Windows все потоки процессов равнозначны, то:
* Для процесса класса Normal и потока Above-Normal
* Для процесса класса Higest и потока Normal
конечные приоритеты будут одинаковыми и равны 10.
Если мы имеем два процесса: один с приоритетом Normal, а второй — с приоритетом Higest, но при этом
первый имел поток Higest а второй Normal, то система их приоритеты будет рассматривать как одинаковые.
Как уже обсуждалось, группа приоритетов Real-Time на самом деле не является таковой, поскольку настоящий Real-Time — это гарантированная доставка сообщения за определённое время либо обработка его получения. Т.е., другими словами, если на конкретном ядре есть такой поток, других там быть не должно. Однако это ведь не так: система может решить, что низко приоритетный поток давно не работал и дать ему время, отключив real-time. Вернее его назвать классом приоритетов который работает над обычными приоритетами и куда обычные приоритеты не могут уйти, попав под ситуации, когда Windows временно повышает им приоритет.
Но так как поток повышенным приоритетом исполняется только один на группе ядер, то получается,
что если у вас даже Real-Time потоки, не факт, что им будет выделено время.
| Класс приоритета / относительный приоритет | Real-Time | High | Above-Normal | Normal | Below-Normal | Idle |
| --- | --- | --- | --- | --- | --- | --- |
| Time Critical (+насыщение) | 31 | 15 | 15 | 15 | 15 | 15 |
| Highest (+2) | 26 | 15 | 12 | 10 | 8 | 6 |
| Above Normal (+1) | 25 | 14 | 11 | 9 | 7 | 5 |
| Normal (0) | 24 | 13 | 10 | 8 | 6 | 4 |
| Below Normal (-1) | 23 | 12 | 9 | 7 | 5 | 3 |
| Lowest (-2) | 22 | 11 | 8 | 6 | 4 | 2 |
| Idle (-насыщение) | 16 | 1 | 1 | 1 | 1 | 1 |
Если перевести в графический вид, то можно заметить, что классы приоритетов пересекаются. Например, существует пересечение Above-Normal Normal Below-Normal (столбик с квадратиками):
Это значит, что для этих трех классов приоритетов процессов существуют такие приоритеты потоков внутри этих классов, что реальный приоритет будет равен. При этом, когда вы задаёте приоритет процессу вы просто повышаете или понижаете все его внутренние приоритеты потоков на определённое значение (см. Таблица 3).
Поэтому, когда процессу выдаётся более высокий класс приоритета, это повышает приоритет потоков процесса относительно обычных – с классом Normal.
| Класс приоритета / относительный приоритет | Real-Time | High | Above-Normal | Normal | Below-Normal | Idle |
| --- | --- | --- | --- | --- | --- | --- |
| Time Critical (+насыщение) | 31 | 15 | 15 | 15 | 15 | 15 |
| Highest (+2) | 26 | 15 | 12 | 10 | 8 | 6 |
| Above Normal (+1) | 25 | 14 | 11 | 9 | 7 | 5 |
| Normal (0) | 24 | 13 | 10 | 8 | 6 | 4 |
| Below Normal (-1) | 23 | 12 | 9 | 7 | 5 | 3 |
| Lowest (-2) | 22 | 11 | 8 | 6 | 4 | 2 |
| Idle (-насыщение) | 16 | 1 | 1 | 1 | 1 | 1 |
> Кстати говоря, мы стартовали продажи на CLRium #7, в котором мы с огромным удовольствием будем говорить про практику работы с многопоточным кодом. Будут и домашние задания и даже возможность работы с личным ментором.
>
>
>
> Загляните [к нам на сайт](https://clrium.ru/): мы сильно постарались, чтобы его было интересно изучить. | https://habr.com/ru/post/488260/ | null | ru | null |
# 20 ноября — запуск первой стратегической MMO-игры для… программистов
В следующий четверг состоится запуск проекта, над которым мы работали последние несколько месяцев. [Screeps](http://www.screeps.com) — первая известная мне стратегическая игра в MMO-песочнице, созданная **для программистов**. Вместо традиционного Point'n'click, геймплей заключается в написании и постоянном улучшении программы для AI ваших юнитов на JavaScript, которая управляет ими непрерывно и автономно — **даже когда вы не онлайн**. Это радикально новая идея, и если вы программист, вам определенно стоит на это взглянуть.
Если вы программист, то не думали ли вы в предыдущий раз, когда играли в свою любимую онлайн-игру, чтобы было бы здорово как-нибудь ее автоматизировать? Зачем тратить время своей жизни на выполнение действий, которые легко выполняются ботом? Почему вы должны каждый день заходить в игру, чтобы получить награду, если с этим легко справился бы скрипт? Больше никакой бессмысленной траты времени на действия, которые под силу и ребенку, мы же способны на большее. В Screeps скрипты не просто разрешены, Screeps это игра о скриптах!
Под катом технические и игровые подробности.
#### Как это выглядит
В Screeps каждый игрок с помощью специального внутриигрового редактора пишет программу на полноценном JavaScript, которая управляет его игрой. У вас есть ресурсы, база, юниты, вы боретесь за контроль над игровым пространством в едином большом мире-песочнице, работающем в реальном времени, и чтобы всем этим управлять, вы пишете что-то вроде этого:
```
var scout = require('scout');
// Производство нового юнита
var name = Game.spawns.Spawn1.createCreep(['attack','move']);
Memory.creeps[name] = { role: 'scout' };
// Раздача команд каждому юниту
for(var i in Game.creeps) {
var creep = Game.creeps[i];
if(creep.memory.role == 'scout') {
// AI разведчика вынесен в отдельный модуль
scout(creep);
}
else {
// Добыча и транспортировка ресурса
if(creep.energy < creep.energyCapacity) {
var target = creep.pos.findNearest(Game.SOURCES_ACTIVE);
creep.moveTo(target);
creep.harvest(target);
}
else {
creep.moveTo(Game.spawns.Spawn1);
creep.transferEnergy(Game.spawns.Spawn1);
}
}
}
```
При этом ваши юниты живут своей жизнью, даже когда вы не находитесь онлайн! Они будут добывать и строить, захватывать и защищаться в то время, как вы на работе, спите или гуляете со своей собакой. Можно построить целую империю с развитой системой дорог, снабжения, добычи, производства и охраной границ, лишь изредка заходя в игру, чтобы проанализировать ситуацию и отточить свои скрипты.
Screeps можно назвать игрой-платформой. Это как писать приложения на базе какого-то фреймворка, только в качестве фреймворка — игровой мир, а в качестве приложения — ваш геймплей.
#### Игровая концепция
В Screeps много программирования и мало игровых механик, которые вам надо понять, поэтому я перечислю их все ниже.
Игровой мир состоит из связанных между собой комнат. Комната — это замкнутое пространство 50 на 50 клеток, в котором может быть от 1 до 4 выходов в другие комнаты. Количество комнат в мире ограничено, но увеличивается по мере того, как приходят новые игроки. Поэтому единый игровой мир огромен и постоянно расширяется, как Вселенная.
Что есть в комнатах? Пять видов поверхности (земля, дороги, болота, укрепления и стены), источники энергии (игровой ресурс) и, конечно же, ваши юниты и строения.
*Spawns* — это центры ваших колоний. Они способны аккумулировать добытую *энергию* и тратить ее на создание ваших юнитов. В одной комнате может быть не более трех спавнов, поэтому построив три своих спавна в комнате, вы, можно сказать, захватываете ее.
Строительство юнитов, называемых *creeps*, происходит так же, как и в других стратегических играх, за одним исключением — вы сами конструируете «тело» нового крипа, выбирая из 7 доступных вариантов частей тела, и составляя из них последовательность длиной до 30 элементов. Это даёт тысячи возможных видов крипов и их ролей: простые работяги и огромные строительные машины, выкапывающие источник целиком за считанные циклы; маленькие курьеры и вместительные тяжёлые грузовики; быстрые дешёвые разведчики и хорошо оснащенные бойцы с возможностью регенерации. Или даже крипы, более похожие на добывающие, охранные или осадные башни, ведь они способны перемещаться только на пару клеток в минуту, при этом обладая невероятными характеристиками. Все ограничено лишь вашей фантазией и тактикой.
Однако, срок жизни любого крипа — 30 минут, через которые он умрет “от старости”. Поэтому вам понадобится не просто управлять существующими крипами, но наладить производство и автоматическое управление сменяющимися поколениями крипов.
Кроме создания крипов, вам также придется заботиться об инфраструктуре ваших комнат. Построенные дороги позволят быстрее перемещаться медленным крипам и настроить эффективную логистику, ramparts заблокируют перемещения противника и дадут дополнительную защиту, а spawn extensions позволят строить более мощных крипов.
#### Как это работает
Технологически игровой движок исполнен в двух различных (но работающих одинаково) вариантах — в клиентском и серверном. Клиентский вариант выполняет игровую симуляцию в вашем браузере. В этом режиме будет работать Simulation Room, в котором можно тестировать свои игровые скрипты без каких-либо ограничений, также там будет туториал и режим Survival Mode, где можно потренироваться на реальной задаче выживания под наплывом волн вражеских крипов.
В реальном онлайновом режиме игровые скрипты всех игроков выполняются уже непосредственно на сервере. Движок написан на Node.js, и скрипт игрока выполняется в нем же, то есть доступны все языковые возможности реального JS. Однако программа игрока запускается в изолированном процессе и окружении с отключенным стандартным require (точнее, замененным на игровой вариант), поэтому вмешаться в работу сервера не получится. Кроме того, выполнение процесса ограничено по времени и потреблению памяти, если оно превышает заданный лимит, то скрипт игрока просто не закончит выполнение, предупредив его об этом.
Весь этот процесс зациклен и происходит постоянно и непрерывно. Каждый игровой такт отрабатываются скрипты всех игроков, которые раздают команды юнитам. Команды выполняются, после чего запускается следующий такт. Неважно, онлайн вы или нет, игра работает в режиме реального времени всегда, поэтому основная игровая задача — написать все так, чтобы развитие (или хотя бы защита уже завоеванного) происходило автономно и ваши юниты могли сами, без вас, адекватно реагировать на различные ситуации, которые вам будут устраивать скрипты других игроков.
Фронтэнд работает на AngularJS, а вся графика — это простые анимированные SVG-формы.
Кстати, после успешного запуска игровой движок планируется выпустить в open-source, чтобы игроки могли лучше понимать механику игры, занимаясь написанием своих скриптов. Игровую симуляцию на этом движке можно будет запустить в консольном standalone-режиме на локальной машине.
**Сайт проекта: [www.screeps.com](http://www.screeps.com)**
Запуск назначен на 20 ноября. Не пропустите, для первых участников предусмотрен бонус :) | https://habr.com/ru/post/242963/ | null | ru | null |
# Как мы доработали чат-бота «Дану» и сделали её проницательнее и сообразительнее
Привет! Меня зовут Даир, я Data Scientist. Эту статью мы писали вместе с Санжаром, моим коллегой, который тоже занимался проектом. Мы расскажем, как научили понимать любые клиентские запросы уже разработанным ранее в Beeline чат-бота.
Фраза «понимание клиента» для нас значит следующее: клиент пишет текстовый запрос с описанием своей проблемы, если чат-бот может уловить суть проблемы, ее тематику и намерение, мы считаем, что мы справились со своей задачей. Намерение клиента в текстовом запросе мы называем «интент» (intent).
На конференции [BeeTech Conf 2022](https://habr.com/ru/company/beelinekz/blog/665896/) мы [рассказывали](https://youtu.be/-1Elq5bMR3M) про первую версию «ванильного» чат-бота, а в статье представляем описание его новой версии 2.0 с дополненными инсайтами и лайфхаками.
Первоначальный чат-бот: вводные данные
--------------------------------------
На схеме ниже можно увидеть весь наш путь: от постановки задачи до итоговой модели. Работа состояла их четырех условных итераций, после которых мы смогли выкатить в продуктив полноценную модель. Если вы захотите повторить наш путь и обучить своего бота, эта схема может быть полезной.
Так выглядел наш RoadmapПеред тем как приступить к постановке задачи, было необходимо осознать, что из себя представляет текущий чат-бот и что мы можем в нем улучшить.
После изучения мы поняли, что Дана (так мы называем нашего чат-бота) — это кнопочный и сценарный чат-бот. Она содержада статичные сценарии и историю обращений клиента к боту, умела распознавать тематику текстового запроса с помощью ключевых слов и отвечала клиенту. Иногда это приводило к тому, что клиенту, уже описавшему свою проблему в тексте, приходилось блуждать по сценариям чат-бота и пытаться помочь себе самому.
Мы решили начать улучшение чат-бот с компоненты распознавания тематики обращения или интент-запроса (намерения). Поэтому нашей задачей стало обучить модель классификации. Для этого нужно определить список интентов и собрать текстовые запросы клиентов с разметкой на интенты.
Чтобы максимизировать эффект от модели, мы решили брать только 15 тематик, по которым чаще всего обращаются клиенты. Для этого собрали статистику по встречаемости сценариев в диалогах чат-бота, представили имеющиеся текстовые запросы в векторном виде и кластеризовали. После анализа сформировали доменно-интентную схему
 Так выглядела схема, которую мы сформировалиПостановка и идея с кластеризацией
----------------------------------
Конечно, для постороения бейзлайна нам никто не разметил данные, поэтому мы попробовали сделать это самостоятельно. Это стало нашей основной целью на первом этапе.
Источником данных послужили запросы клиентов на русском языке. Среднее количество слов в запросе — четыре, поэтому мы собрали n-grams (словосочетания из 3-5 слов) и решили кластеризовать их разными методами типа тематического моделирования – agglomerative clustering поверх sentence embedding. Агломеративная кластеризация оказалась удобнее, так как с ее помощью получилось задать необходимый трешхолд для расстояния между кластерами и выбрать меру расстояния.
В итоге мы использовали кластеризацию с такими переменными:
```
AgglomerativeClustering(affinity="cosine",
distance_threshold=distance_threshold,
n_clusters=None,
linkage="complete")
```
Также в выставлении трешхолда расстояния нам помогла дендрограмма. На графике видно примерное расстояние между кластерами:
Смотрите на вертикальную осьИнсайты по кластеризации, география кластеров
---------------------------------------------
После того как мы завершили кластеризацию, решили посмотреть, как получившиеся кластеры расположены относительно друг друга. Возможно, группы кластеров можно объединить в интенты или домены. Для этого мы уменьшили размерность векторов до двух, агрегировали каждый получившейся кластер и отобразили это на карте кластеров.
Получились такие инсайты
На графике видно, что мы получили довольно заметное разделение: скучковались запросы по личному кабинету, интернету дома, смене тарифа и т.д. Так, мы получили авторазметку по определенным интентам с малым усилием. Плюс появились области точек (например, «интернет»), где «не пыльно» можно было разметить доменные интенты.
Метрики классификатора и чат-бота
---------------------------------
Чтобы обучить модель классификации, нужно понять, как мы будем замерять качество модели. Решили использовать стандартные метрики: precision, recall, f1 score, accuracy.
На примерах покажем, как мы их использовали и какие из них были более показательны
На первом примере модель отработала хорошо. На всех классах accuracy = 0.65. Рассчитаем macro f1 score (0.72 + 0.28 + 0.66 + 0.66)/4 ~ 0.6, weighted f1 score (0.72*0.85+0.28*0.05+0.66*0.05+0.66*0.05) ~ 0.69.
На втором модель отработала отлично. Только на одном классе accuracy = 0.85. Рассчитаем macro f1 score (0.92 + 0 + 0 + 0)/4 ~ 0.23, weighted f1 score (0.92*0.85+0*0.05+0*0.05+0*0.05) ~ 0.78.
Для нас важен каждый класс независимо от количества наблюдений у него в выборке, поэтому мы использовали именно macro f1 score.
Конечно, одними метриками классификатора нельзя оценить эффективность работы чат-бота, поэтому мы ориентируемся на его основные метрики.
**TCR (Task completed rate)** — процент диалогов, в которых частично или полностью решили проблему абонента. Это ручная разметка выборки диалогов асессорами.
Мы делили диалоги на три типа:
зеленый цвет — бот правильно распознал запрос и дал правильный ответ;
желтый цвет — бот правильно распознал запрос и дал некорректный или неполный ответ;
красный цвет — бот неправильно распознал запрос.
Это информативная метрика, но важно правильно организовать процесс разметки.
**CSI (Customer Satisfaction Index)** — средняя оценка, которую поставили клиенты боту.
Основные моменты:
— онлайн-метрика – можно замерять уровень удовлетворенности клиента в реальном времени;
— нужно следить за репрезентативностью выборки респондентов. Для этого нужно по-максимуму облегчить доступ клиентов к анкете.
**AR (Automation rate)** — процент диалогов, в которых клиент не перешел на оператора.
Метрика показывает, насколько эффективно чат-бот удерживает клиента от перехода на оператора. Но некорректно использовать только ее, так как можно попасть в ловушку «хороших» показателей. У нас этот показатель учитывается, но не имеет большого веса в принятии решения.
### Бейзлайн на саморазмеченных ngram-мах
После того, как мы определили метрики, возвращаемся к датасету с ngram-ми. Мы уже получили черновую бесплатную разметку путем кластеризации ngram. Для каждого интента собрали примерно по 60 примеров.Теперь, когда у нас есть данные, можно заняться обучением модели.
Начали с простых частотных методов векторизации текста tf-idf. Затем попробовали fast-text. Результат получился значительно хуже. Мы предположили, что это особенность нашего корпуса, состоящего из коротких запросов. После этого попробовали стандартно дообучить Bert model для русского языка.
Мы попробовали разные предобученные модели с ресурса [Hugging Face](https://huggingface.co/models). Лучший результат показала модель DeepPavlov/rubert-base-cased.
Так выглядел результат модели DeepPavlov/rubert-base-casedВторая итерация по классификатору: пайплайн, аугментации, инструмент визуализации аттеншн-карт
----------------------------------------------------------------------------------------------
После экспериментов с обучением модели у нас появился пайплайн, на котором можно достаточно быстро можно обучить любой текстовый классификатор.
Так выглядит схема пайплайнаМы использовали в паплайне [dvc](https://dvc.org/), чтобы версионировать модели, пайплайны и данные. К тому же с его помощью можно легко воспроизвести любой эксперимент и получить модель ожидаемого качества. Нужно обязательно логировать все эксперименты в mlflow, чтобы было наглядно, какие данные и параметры влияют на качество.
Нами была проделана интересная работа по аугментациям. Более того, мы сделали много (очень много) экспериментов, и решили поделиться основными методами. Не могу сказать, что методы какие-то особенные, но именно они помогли нам решить задачу, поэтому мы рекомендуем начинать с них.
**Методы, реализованные с помощью библиотеки nlpaug**
Mask insert. Контекстная вставка слова в символ.
**Random injection.** Достаточно консервативный, но результативный способ. Позволяет эмулировать опечатки и прочий шум.
```
def mask_word(text):
aug = naw.ContextualWordEmbsAug(
model_path="blinoff/roberta-base-russian-v0", aug_p=0.1
)
return re.sub("", " ", aug.augment(text))
```
**Synonymizing.** Строится синтаксическое дерево, потом оно усекается и, в зависимости от частей речи, идет синонимизация, например, через most\_similar-метод моделей дистрибутивной семантики. Один из минусов — порой теряется связность текста.
```
def ft_synonimze_word(word):
threshold = 0.6
results = np.array(ft.get_nearest_neighbors(word))
if not len(results):
return word
scores, words = results[:, 0], results[:, 1]
floated_scores = list(map(lambda row: float(row), scores))
indices = np.array(floated_scores) > threshold
if any(indices):
word = random.choice(words[indices])
return word
def ft_synonimze_text(text):
processed_text = []
for tok in text.split():
pos = morph.parse(tok)[0].tag.POS
# NOUN имя существительное хомяк
# ADJF имя прилагательное (полное) хороший
# ADJS имя прилагательное (краткое) хорош
# COMP компаратив лучше, получше, выше
# VERB глагол (личная форма) говорю, говорит, говорил
# INFN глагол (инфинитив) говорить, сказать
# PRTF причастие (полное) прочитавший, прочитанная
# PRTS причастие (краткое) прочитана
# GRND деепричастие прочитав, рассказывая
# NUMR числительное три, пятьдесят
# ADVB наречие круто
# NPRO местоимение-существительное он
# PRED предикатив некогда
if pos in (
"VERB",
"INFN",
"PRTF",
"PRTS",
"GRND",
"ADVB"
# 'NOUN', 'ADJF', 'ADJS', 'COMP',
# 'INFN', 'PRTF', 'PRTS', 'GRND', 'ADVB', 'NPRO'
):
processed_text.append(ft_synonimze_word(tok))
else:
processed_text.append(tok)
return " ".join(processed_text)
```
**Paraphrase.** Можно попробовать с инференсом paraphrase-моделей, типа T5(cointegrated/rut5-base-paraphraser). Есть одно но: требуется мониторинг, как с обратным переводом, потому что нельзя терять важные бизнес-токены.
«Хочу подключить тариф Яркий» -> «Нужно включить расценку Светлый»
```
def paraphraser(text, beams=5, grams=4, do_sample=False):
model = T5ForConditionalGeneration.from_pretrained(MODEL_NAME)
tokenizer = T5Tokenizer.from_pretrained(MODEL_NAME)
x = tokenizer(text, return_tensors="pt", padding=True).to(model.device)
max_size = int(x.input_ids.shape[1] * 1.5 + 10)
out = model.generate(
**x,
encoder_no_repeat_ngram_size=grams,
num_beams=beams,
max_length=max_size,
do_sample=do_sample
)
return tokenizer.decode(out[0], skip_special_tokens=True)
```
**Back translation.** Популярный способ аугментации через NMT-модели. Текст переводится на иностранный язык и в обратную сторону. Не самый лучший способ аугментации, если вы боитесь за какие-то ключевые слова. Как пример можно использовать эту функцию:
```
aug_trans = naw.back_translation.BackTranslationAug(
from_model_name="Helsinki-NLP/opus-mt-ru-en",
to_model_name='Helsinki-NLP/opus-mt-en-ru',
device="cuda")
```
К моменту, когда мы обработали данные и перепробовали аугментации, у нас появилась первая платная разметка. Мы подключили к процессу аннотаторов, то есть, размечали запросы вручную. Также мы смогли обучить модель на «живых» текстах с качественной разметкой: отошли от подхода с n-gram и размечали всё вручную. Результат, конечно, был лучше, чем в первой итерации:
Плюс мы впервые задались вопросом, как интерпретировать предсказания модели. Нам хотелось понять, в какую сторону «копать» дальше, чтобы найти узкие места. Мы решили изучить, как работает механизм внимания модели, какие слова для нее важны и какие слова ее триггерят, поэтому мы написали функцию по визуализации аттеншн карт с конкретных слоев и голов bert.
Эта визуализация оказалась очень полезной. Например, из нее мы можем понять, на какие ключевые слова смотрит модель, когда она явно ошибается. Благодаря этому можно точечно очистить обучающий датасет.
Третья итерация: анализ разметки, переразметка, инсайт по полноценным текстам, новые метрики
--------------------------------------------------------------------------------------------
Модель, обученная на полноценных текстах на естественном языке, оказалась намного умнее, чем модель, обученная на n-gram. То есть, мы увидели проблему: оказалось, что модель, обученная на конкретных интентах, сильно ошибалась, и мы погрузились в анализ имеющийся разметок.
Оказалась, в разметках было много ошибок, которые тянуться еще с первой итерации и со времен разметки от аннотаторов. Поэтому мы решили опять переразметить датасет, с новыми знаниями и определившись с логикой самих интентов.
В дополнение к переразметке мы решили разделить модели: две модели определяют домен и интент запроса, третья модель – определяет наличие какого-либо интента в запросе (обычная бинарная классификация).
В результате переразметки и разделение моделей качество получилось следующее:
Chain-model, sentiment, spam
----------------------------
Так как в нашей задаче пространство всех интетов неопределенное (мы не знаем, сколько их), нужно было отделять имеющийся список интентов в чат-боте и остальную лексику, в которой могут содержаться и остальные интенты. Поэтому мы провели ряд экспериментов, в результате которых оказалось, что модель, обученная на определение наличия какого-либо интента, показывает хорошие метрики и разделяет общую лексику от запросов с интентами. Мы ее включили в общий пайплайн предсказания.
«Спам»-модель была встроена в наш движок для того, чтобы фильтровать неосмысленный текст. Мы даем клиенту попытку ответить на запрос бота, как бы вынуждая его писать запросы, которые наш чат-бот способен обработать.
Финальный пайплайн На финальном пайплайне видно, что за определение интента отвечает бинарная модель. Она говорит, есть ли хоть какой-либо интент, и если он есть, запускается голосование доменной и интеной модели и финальный предикт. Если интента нет — проверяем запрос на спам и решаем, каким должен быть ответ бота.
### Что в итоге
Сейчас мы отслеживаем наше влияние на чат-бот косвенными метриками:
— доля в распознавании пула запросов моделью увеличилась до 23 % в последнем месяце («синонимы» — это тоже инструмент распознавания тематики запроса, но на основе ключевых слов)
— процент перевода на оператора уменьшился с 7 % до 5 %;
— определяем в среднем 11 % спама, чем снижаем нагрузку на операторов путем фрода.
У нас есть планы на дальнейшее улучшение чат-бота:
— увеличение количества интетов в модели, что должно в теории увеличить охват запросов;
— увеличение порога распознавания «Синонима» для повышения точности, так как больше запросов будет обрабатываться моделью распознавания интента;
— внедрение классификатора на казахском языке для дальнейшего увеличения общего охвата запросов;
— улучшение качества распознавания путем налаживания процесса разметки запросов и построение автоматического процесса разметки данных с участием аннотаторов и валидаторов;
— упрощение chain model: есть гипотеза, что можно отказаться от бинарной классификации и оставить только две модели без потери качества. Это нам даст ускорение работы сервиса.
Дополнительно хотим провести пилот с внедрением инструментов распознавания и синтеза речи, чтобы позднее строить на базе нашего чат-бота платформу для управления голосовыми и текстовыми диалогами (Conversational platform). | https://habr.com/ru/post/691996/ | null | ru | null |
# Программирование диммера на радиомодуле nrf24le1 от COOLRF
Продолжаем тему программирования радиомодулей nrf24le1 — на этот раз мы научим диммер от [COOLRF](http://habrahabr.ru/company/coolrf/) работать. После публикации мною [статьи](http://habrahabr.ru/post/210974/) про программирование радиомодулей мне предложили поучаствовать в разработке прошивки и предоставили данный диммер для экспериментов.
В итоге получился вариант управления диммером через центральный модуль [Arduino+Ethernet-nRF24L01 (W5100)](http://homes-smart.ru/index.php/oborudovanie/bez-provodov-2-4-ggts/shlyuz-ethernet-nrf24l01-w5100-na-baze-arduino-dlya-obmena-dannymi-s-nrf24l01-i-nrf24le1) или [nRF24L01+USB из USBasp](http://homes-smart.ru/index.php/oborudovanie/bez-provodov-2-4-ggts/nrf24l01-usb-iz-usbasp) а так же с помощью локальной кнопки.
#### Алгоритм диммирования
Сигнал перехода через ноль активизирует таймер, время которого зависит от установленного уровня мощности 0..100% что соответствует 0.01....0 секунды. Таймер включает симистор.
Далее, после примерно 10 миллисекунд (если я правильно прикинул) сигнал включения симистора снимается, НО симистор остается открытым пока не было перехода через ноль. Далее цикл повторяется.
Возможно читатели хабра предложат и более правильный вариант управления симистором…
#### Код прошивки
В данный момент прошивка умеет:
* Управление включением/выключением кнопкой на выключателе.
* Управление яркостью при длительном (более 1.5с) нажатии кнопки.
* Удаленный контроль состояния и уровня установленной яркости.
* Удаленное управление включением/выключением и яркостью.
Для отчета интервалов управления мощности используется таймер № 1.
Для установки интервалов для подавления дребезга и других пауз используется таймер RTC на внутреннем генераторе 32768 Гц.
Для компиляции прошивки необходим [SDK](https://github.com/maksms/NRF24LE1_client).
**Основной код диммера находится тут**
```
// модификация 23.07.14
#define chclient 1 // номер клиента 1...
#define nofloat 0 // без float , данные передаются умноженные на 10.Очень экономит место.
#define RTCDEC 8191 //65535=2 сек, 32767=1 сек,16383 = 0.250 сек ,8191 = 0.125 сек. Константы ниже используют это значение за такт:
#define TIMESEND 2 // интервал приема/отправки данных по радио.
#define TIMEKEY 4 // пауза кнопки для защиты от дребезга. (0.125*4=0.5с)
#define TIMELONGKEY 3 // долгое нажатие кнопки,вычисляется как TIMEKEY*TIMELONGKEY*0.125=время. 3*4*0.125=1.5с
#define BUTTONPIN 4 // пин, к которому подключена кнопка.
#define DIMMPIN GPIO_PIN_ID_P0_2 // пин, к которому подключен симистор.
#define stepdimm 10 // шаг управления яркостью используя кнопку
#define MAXSTEP 100 // количество шагов диммирования
#include "../libs.h"
#include "../nRFLE.c"
typedef struct{
unsigned char identifier;// номер передатчика.МЕНЯТЬ НЕЛЬЗЯ
int countPWM;
unsigned char keymode;
int Error_Message; // счетчик ошибок
long count;// счетчик передач для контроля качества канала
#if nofloat
int temperature_Sensor;
int Humidity_Sensor;
#else
float temperature_Sensor;
float Humidity_Sensor;
#endif
}
nf1;
nf1 clientnf;
#define DIMSTART 16000000/12/100/MAXSTEP
uint16_t valuepwm=0; // хранит значение мощности в тиках таймера
void setdimmer(uint8_t value){ // функция управления диммирования
valuepwm=65535-DIMSTART*(MAXSTEP-value);
if(value ==0 | clientnf.keymode==0) {
interrupt_control_ifp_disable();
gpio_pin_val_clear(DIMMPIN);
} else interrupt_control_ifp_enable();
}
uint8_t stdimm;
interrupt_isr_ifp() // прерывание при переходе через ноль
{
timer1_stop();
if(clientnf.countPWM !=0) {
timer1_set_t1_val(valuepwm);
timer1_run();
}
else gpio_pin_val_clear(DIMMPIN);
stdimm=1;
}
interrupt_isr_t1() { // прерывание на таймере
if (stdimm) {
gpio_pin_val_set(DIMMPIN);
timer1_set_t1_val(65535-100);
stdimm=0;
} else
gpio_pin_val_clear(DIMMPIN);
}
void dimmon(uint8_t mode) // функция управлением вкл/выкл
{
if (mode) interrupt_control_ifp_enable();
else {
interrupt_control_ifp_disable();
timer1_stop();
gpio_pin_val_clear(DIMMPIN);
}
clientnf.keymode=mode;
}
unsigned long countrtc=0; // переменная счетчика времени используя rtc
unsigned char servernf[32];
interrupt_isr_rtc2() // счетчик ртс импульсов используя прерывание.
{
countrtc++;
}
//====================main========================
void main()
{
int state=0;
unsigned int count=0; //counter for loop
uint8_t st=0,countpause=0,rewers=0; // for key
unsigned long statesend=0,radiosend=0;
// конфигурация RTC-->
CLKLFCTRL=1; // 0 -внешний кварц на P0.1 и P0.0. 1 - внутренний генератор.
rtc2_configure(RTC2_CONFIG_OPTION_COMPARE_MODE_0_RESET_AT_IRQ ,RTCDEC);
rtc2_run();
pwr_clk_mgmt_wakeup_configure(PWR_CLK_MGMT_WAKEUP_CONFIG_OPTION_WAKEUP_ON_RTC2_TICK_IF_INT_ENABLED,0);
interrupt_control_rtc2_enable();
// <--конфигурация RTC
interrupt_configure_ifp(INTERRUPT_IFP_INPUT_GPINT0,INTERRUPT_IFP_CONFIG_OPTION_ENABLE | INTERRUPT_IFP_CONFIG_OPTION_TYPE_FALLING_EDGE);
interrupt_control_ifp_enable();
interrupt_control_t1_enable() ;
timer1_configure(TIMER1_CONFIG_OPTION_MODE_1_16_BIT_CTR_TMR,0);
timer1_run();
sti();
gpio_pin_configure(BUTTONPIN,GPIO_PIN_CONFIG_OPTION_DIR_INPUT|GPIO_PIN_CONFIG_OPTION_PIN_MODE_INPUT_BUFFER_ON_PULL_UP_RESISTOR); // для кнопки на вход и подтянуть резистором.
gpio_pin_configure(DIMMPIN,GPIO_PIN_CONFIG_OPTION_DIR_OUTPUT);
// Тестовое мигание при запуске -->
#if 1
gpio_pin_val_set(DIMMPIN);
delay_ms(500);
gpio_pin_val_clear(DIMMPIN);
delay_ms(500);
#endif
//<-- Тестовое мигание при запуске
radiobegin(); //
openAllPipe(); // открываем прием/передачу, назначаем адреса.
setChannel(100);
setDataRate(2); // 1 - 250кб , 2 - 1 мб , 3 -2 мб.
setAutoAck(false);
setCRCLength(2); // 0 - crc off ,1 - 8bit ,2 - 16bit
setPALevel(3) ; // мощность 0..3
clientnf.identifier=chclient;
clientnf.countPWM=30;
//main program loop
while(1)
{
// ---
if (countrtc-radiosend >=TIMESEND) {
//rf_power_up(1);
rf_write_tx_payload((const uint8_t*)&clientnf, 32, true); //transmit received char over RF
//wait until the packet has been sent or the maximum number of retries has been reached
while(!(rf_irq_pin_active() && rf_irq_tx_ds_active()));
rf_irq_clear_all(); //clear all interrupts in the 24L01
rf_set_as_rx(true); //change the device to an RX to get the character back from the other 24L01
//wait a while to see if we get the data back (change the loop maximum and the lower if
// argument (should be loop maximum - 1) to lengthen or shorten this time frame
for(count = 0; count < 25000; count++)
{
if((rf_irq_pin_active() && rf_irq_rx_dr_active()))
{
state=1;
if (clientnf.count <= 2147483646) clientnf.count++; /// счетчик передач для контроля качества канала
else clientnf.count = 0;
rf_read_rx_payload((const uint8_t*)&servernf, 32); //get the payload into data
break;
}
//if loop is on its last iteration, assume packet has been lost.
if(count == 24999) clientnf.Error_Message++;
}
rf_irq_clear_all(); //clear interrupts again
rf_set_as_tx(); //resume normal operation as a TX
if (servernf[0]==chclient){
if (servernf[1]==10) { // включение/выключение по радио
dimmon(servernf[3]);
} else
if (servernf[1]==11) { // управление яркостью по радио
clientnf.countPWM=servernf[3];
setdimmer(clientnf.countPWM);
}
}
radiosend=countrtc;
}
#if 1
#define dimm clientnf.countPWM
#define keymode clientnf.keymode
if (digitalRead(BUTTONPIN)==0){ // кнопка нажата
if (countrtc-statesend>=TIMEKEY) {
if (st){
st=0;
keymode=!keymode;
dimmon (keymode);
} else
if (countpause>=TIMELONGKEY){
if (!keymode) dimmon(1); // если было выключено,то включим
else {
if(rewers) {
if(dimm-stepdimm>=0) dimm=dimm-stepdimm;
else rewers=0;
}else{
if(dimm+stepdimm<=MAXSTEP) dimm=dimm+stepdimm;
else rewers=1;
}
setdimmer(dimm);
}
} else countpause++;
statesend=countrtc;
}
} else {// кнопка отжата
if (!st){
st=1;
countpause=0;
rewers=!rewers; // менять направление изменения яркости при каждом отжатии кнопки
}
}
#endif
// end loop
}
}
```
#### Видеодемонстрация работы диммера
Что мы имеем: * диммер COOLRF.
* nrf24le1 радиомодуль не того формата, и, соответственно он не подходит на родное место установки — по этому он выведен на проводках.
* Монтажная панелька, на которой подключена кнопка с подтягивающим резистором.
* лампочка на 60вт.
Попробую расписать все по-порядку:
Сначала на видео демонстрируется управление лампочкой через кнопку:
Короткое нажатие выключает или включает лампочку, длинное нажатие изменяет яркость, если лампочка была выключена, то она включается и начинается изменение яркости. При каждом отпускании кнопки меняется направление изменения яркости.
Далее видим как лампочкой можно управлять с компьютера (точнее ноута). В тесте используется Arduino+Ethernet-nRF24L01 для удаленного управления диммером.
На 26 секунде можно заметить WEB страничку ардуинки, на которой показывает состояние беспроводных устройств:
1 строчка — это как раз наш диммер, где переменная Analog показывает текущую установленную мощность, а переменная test\_data показывает состояние включена или выключена лампочка.
2 строчка — это беспроводной датчик, который тут добавлен просто для теста.
Управление диммером показано на самодельной веб страничке( веб сервер на ноуте), на которой присутствуют кнопки заданной яркости 10,20,50 и 100%, кнопки включения/выключения, а так же поля ручной отправки данных на беспроводные устройства.
Данная тестовая страничка написана на PHP и она отправляет GET запросы на веб сервер ардуинки. Аналогично можно управлять и через nRF24L01+USB.
Как я понял COOLRF планируют спроектировать другой вариант диммера в заводском корпусе и изменив схему устройства, но данный пример прошивки, возможно с небольшими изменениями, так же будет работать на нем.
Принимаю критику и предложения в комментариях. Спасибо.
Предыдущие статьи на тему nrf24le1:
[Программируем радиомодуль NRF24LE1. Готовый беспроводной клиент](http://habrahabr.ru/post/215187/)
[Программируем nRF24LE1 через Raspberry PI и USBasp](http://habrahabr.ru/post/210974/) | https://habr.com/ru/post/230785/ | null | ru | null |
# Минимальное окружение для JS-разработки: ava, standard, chokidar-cli и precommit-hook
Вокруг полно JavaScript-фреймворков, библиотек и разнообразных инструментов. Что выбрать? Глядя на такое разнообразие, разработчику непросто ответить на этот вопрос.
[](https://habrahabr.ru/company/ruvds/blog/317238/)
По опыту знаю: первый шаг нового проекта, например, создания модуля или средства командной строки, заключается в настройке рабочего окружения. Некоторым этот шаг нравится, некоторые его терпеть не могут, но и у тех и у других предварительная подготовка часто занимает непозволительно много времени. Особенно, когда надо всё тщательно проверить и заставить все механизмы слаженно и стабильно работать вместе.
Конечно, можно включить в арсенал JS-разработчика webpack, eslint, jasmine, или даже TypeScript. При таком подходе с нахождением и устранением ошибок проблем не будет. Но всё дело в том, что для решения большинства вспомогательных задач прекрасно подойдут простые инструменты, которые практически не нуждаются в настройке. Окружение, собранное из них, позволит максимально быстро начать работу, обеспечит контроль правильности кода и своевременное оповещение об ошибках.
Когда я задумываюсь о минимальном JS-окружении, на ум сразу приходят четыре вещи: тестирование программы и анализ кода, отслеживание изменений файлов в процессе работы и проверка проекта перед фиксацией транзакций в системе контроля версий.
Сейчас я подробно расскажу о том, как, буквально на пустом месте, создать среду разработки, которая позволит в считанные минуты приступить к продуктивному труду.
Инициализация проекта Node.js и Git-репозитория
-----------------------------------------------
Сначала создадим директорию и перейдём в неё. Здесь конструкция `$_` хранит аргумент последней команды.
```
$ mkdir awesome-module && cd $_
```
Теперь инициализируем проект Node.js с настройками по умолчанию.
```
npm init --yes
```
Создадим папки и файлы
```
$ mkdir lib test
$ touch index.js lib/meaningOfLife.js test/index.test.js test/meaningOfLife.test.js
```
Теперь инициализируем Git-репозиторий и зафиксируем первую транзакцию.
```
$ git init
$ git add -A; git commit -am "Awesome Module, day one"
```
Структуру проекта мы подготовили, займёмся инструментами.
Установка инструментов
----------------------
Мы будем использовать четыре простых модуля, каждый из которых предназначен для решения одной задачи:
* [Ava](https://github.com/avajs/ava) – тестирование.
* [Standard](https://github.com/feross/standard) – статический анализ кода.
* [Chokidar-cli](https://github.com/kimmobrunfeldt/chokidar-cli) – наблюдение за изменениями в файлах.
* [Precommit-hook](https://github.com/nlf/precommit-hook) – автоматический запуск npm-скриптов.
Почему я выбрал именно их? Просто потому, что они не требуют вообще никакой настройки. Такой подход отлично разгружает голову, открывая дорогу полезным идеям, касающимся разработки. Установим модули, выполнив следующую команду в папке проекта:
```
$ npm i --save-dev ava standard chokidar-cli precommit-hook
```
После установки (скорость которой зависит только от настроения NPM), не забудьте создать файл `.gitignore` и добавить в него папку `node_modules`. Она в репозитории не нужна.
Настройка проекта
-----------------
Сами по себе, наши инструменты в настройке не нуждаются, но вот проект, всё же, настроить придётся. Правда, здесь всё предельно просто. Откройте `package.json` и добавьте в него следующие скрипты:
```
"scripts": {
"test": "ava",
"lint": "standard",
"dev": "chokidar '**/*.js' -c 'standard && ava'"
},
"pre-commit": ["test", "lint"],
```
Вот, собственно, и всё. Как только вы выполнит команду `npm run dev`, `chokidar` начнёт наблюдать за состоянием файлов, запуская, при необходимости, `standard` для статического анализа, и `ava` для тестирования кода. Если обнаружатся проблемы, вы тут же об этом узнаете. То же самое касается и внесения изменений в репозиторий. Наша среда не даст зафиксировать транзакцию до тех пор, пока проект не будет успешно проанализирован и протестирован.
Здесь хотелось бы обратить внимание на две вещи.
1. Не нужно устанавливать `standard` или `ava` глобально, так как они исполняются изнутри контекста `node`.
2. Так как мы используем `&&` вместо `;` в скрипте `dev`, тесты не будут вызваны до тех пор, пока код не пройдёт проверку статическим анализатором. Это ускоряет работу.
Как этим пользоваться
---------------------
Среда разработки рассчитана на программирование в стиле разработки через тестирование (TDD). Как только будет запущен скрипт `dev`, можно создавать тесты, они будут автоматически добавляться к набору испытаний кода, без необходимости перезапуска средства наблюдения за файлами или выполнения любых других операций.
Создадим первый тест.
```
// test/meaningOfLife.test.js
const test = require('ava')
const meaningOfLife = require('../lib/meaningOfLife')
test('Real meaning of life', (t) => {
t.is(meaningOfLife(), 42)
})
```
После сохранения этого файла система тут же сообщит о том, что один из тестов провален. Исправим это.
```
// lib/meaningOfLife.js
module.exports = () => 42
```
Теперь всё работает как надо! Проще некуда. Создадим модуль, который умножает числовые параметры. Сразу же подготовим модульный тест для него, а также посмотрим, правильно ли работает новый модуль с `meaningOfLife`. Это, кстати, будет уже интеграционный, а не модульный тест. Вот код модуля:
```
// lib/multiply.js
module.exports = (number) => {
if (typeof number !== 'number') throw new TypeError('Only numbers can be multiplied!')
return number * 2
}
```
Вот тест к нему:
```
// test/multiply.test.js
const test = require('ava')
const multiply = require('../lib/multiply')
test('Can multiply numbers', (t) => {
t.is(multiply(10), 20)
})
test('Throws when you try to multiply non-number value', (t) => {
t.throws(() => multiply('ohai!'), 'Only numbers can be multiplied!')
})
```
Теперь протестируем всё вместе:
```
// test/index.test.js
const test = require('ava')
const awesomeModule = require('../index')
test('Works nicely together', (t) => {
t.is(awesomeModule(), 84)
})
```
И внесём следующее в index.js:
```
// index.js
const meaningOfLife = require('./lib/meaningOfLife')
const multiply = require('./lib/multiply')
module.exports = () => multiply(meaningOfLife())
```
Тесты пройдены! Как видите, благодаря простоте инструментов, мы очень быстро приступили к работе над проектом, потратив совсем немного времени на подготовку окружения.
Итоги
-----
Новые сверкающие инструменты часто буквально гипнотизируют программистов, заставляя забыть о главном. А главное – это упрощение и ускорение работы и борьба с ошибками. Обычно, гораздо чаще, чем может показаться, для решения этих задач достаточно самых простых средств. Таких, которые позволяют тратить время на создание программ, а не на настройку вспомогательных систем.
Когда проект начнёт расти, возможно, вы почувствуете, что вам нужно что-нибудь гораздо более продвинутое, нежели простая комбинация ava, standard, chokidar-cli и precommit-hook. Но в большинстве случаев, однако, больше ничего не понадобится. И те простые и понятные инструменты, о которых я рассказал, прослужат вам верой и правдой очень и очень долго.
А в какой среде создаёте программы вы? | https://habr.com/ru/post/317238/ | null | ru | null |
# Rust 1.65.0: GAT, let-else, break от помеченных блоков, отказ от RLS
Команда Rust рада сообщить о новой версии языка — 1.65.0. Rust — это язык программирования, позволяющий каждому создавать надёжное и эффективное программное обеспечение.
Если у вас есть предыдущая версия Rust, установленная через `rustup`, то для обновления до версии 1.65.0 вам достаточно выполнить команду:
```
rustup update stable
```
Если у вас ещё нет `rustup`, то можете установить его со страницы на нашем веб-сайте, а также ознакомиться с [подробным описанием выпуска 1.65.0](https://github.com/rust-lang/rust/blob/stable/RELEASES.md#version-1650-2022-11-03) на GitHub.
Если вы хотите помочь нам протестировать будущие выпуски, вы можете использовать beta (`rustup default beta`) или nightly (`rustup default nightly`) канал. Пожалуйста, [сообщайте](https://github.com/rust-lang/rust/issues/new/choose) обо всех встреченных вами ошибках.
Что стабилизировано в 1.65.0
----------------------------
### Генерализованные ассоциативные типы (GAT)
Времена жизни, типы и константные обобщения теперь могут быть объявлены с ассоциированными типами:
```
trait Foo {
type Bar<'x>;
}
```
Сложно в двух словах описать, насколько это может оказаться полезным, так что представим несколько примеров типажей, чтобы прочувствовать их силу:
```
/// `Iterator`-подобный типаж, который может заимствовать `Self`
trait LendingIterator {
type Item<'a> where Self: 'a;
fn next<'a>(&'a mut self) -> Option>;
}
/// Может быть реализован через умные указатели, вроде `Rc` или `Arc`,
/// так как типаж обобщён для типа указателя.
trait PointerFamily {
type Pointer: Deref;
fn new(value: T) -> Self::Pointer;
}
/// Разрешается заимствовать массив элементов. Удобно для
/// `NdArray`-подобных типов. которым неважно непрерывное хранение данных.
trait BorrowArray {
type Array<'x, const N: usize> where Self: 'x;
fn borrow\_array<'a, const N: usize>(&'a self) -> Self::Array<'a, N>;
}
```
Как вы можете видеть, GAT'ы довольно универсальны и позволяют использовать ряд шаблонов, которые сейчас нельзя написать. Для получения дополнительной информации, смотрите [прошлогодний пост](https://blog.rust-lang.org/2021/08/03/GATs-stabilization-push.html), в котором было анонсировано принятие решения о работе над ними — или [пост о стабилизации](https://blog.rust-lang.org/2022/10/28/gats-stabilization.html), опубликованный на прошлой неделе. Первый углубляется в приведённые выше примеры, а второй рассказывает об ограничениях текущей реализации.
Больше деталей можно найти в секции ассоциированных типов [справочника nightly](https://doc.rust-lang.org/nightly/reference/items/associated-items.html#associated-types) или в [оригинальном RFC](https://rust-lang.github.io/rfcs/1598-generic_associated_types.html) (который был открыт более 6,5 лет назад!).
### `let`-`else` выражения
Данный выпуск представляет новый тип оператора `let` с условным шаблоном и отдельным блоком `else`, который исполняется при несовпадении образца.
```
let PATTERN: TYPE = EXPRESSION else {
DIVERGING_CODE;
};
```
Обычные операторы `let` могут использовать только *неопровержимые* шаблоны, о которых статически известно, что они всегда совпадают. Этот шаблон часто представляет собой просто связывание одной переменной, но может также распаковывать составные типы, такие как структуры, кортежи и массивы. Однако это нельзя было использовать для условных совпадений, например для извлечения варианта перечисления — до сих пор! С помощью `let` `else` опровержимый шаблон может сопоставлять и связывать переменные в окружающей области видимости, как обычный `let`, или расходиться (как `break`, `return`, `panic!`), когда шаблон не совпадает.
```
fn get_count_item(s: &str) -> (u64, &str) {
let mut it = s.split(' ');
let (Some(count_str), Some(item)) = (it.next(), it.next()) else {
panic!("Can't segment count item pair: '{s}'");
};
let Ok(count) = u64::from_str(count_str) else {
panic!("Can't parse integer: '{count_str}'");
};
(count, item)
}
assert_eq!(get_count_item("3 chairs"), (3, "chairs"));
```
Область действия привязок имён — это главное, что отличает их от выражений `match` или `if let` — `else`. Раньше вы могли аппроксимировать эти шаблоны неудачным повторением и внешним `let`:
```
let (count_str, item) = match (it.next(), it.next()) {
(Some(count_str), Some(item)) => (count_str, item),
_ => panic!("Can't segment count item pair: '{s}'"),
};
let count = if let Ok(count) = u64::from_str(count_str) {
count
} else {
panic!("Can't parse integer: '{count_str}'");
};
```
### `break` от помеченных блоков
Простые блочные выражения теперь могут быть помечены как цель `break`, завершающая этот блок раньше. Это может звучать как `goto`, но это не произвольный переход, а только изнутри блока в его конец. Это уже было возможно с блоками `loop`, и вы, возможно, видели, как люди пишут циклы, которые всегда выполняются только один раз, просто чтобы получить помеченный `break`.
Теперь для этого появилась специальная языковая возможность! Помеченный `break` также может включать значение выражения, как и в случае с циклами, что позволяет блоку с несколькими операторами иметь раннее значение «возврата».
```
let result = 'block: {
do_thing();
if condition_not_met() {
break 'block 1;
}
do_next_thing();
if condition_not_met() {
break 'block 2;
}
do_last_thing();
3
};
```
### Разделение отладочной информации в Linux
Ещё в Rust 1.51 команда компилятора добавила поддержку [разделения отладочной информации](https://blog.rust-lang.org/2021/03/25/Rust-1.51.0.html#splitting-debug-information) в macOS — и теперь эта опция стабильна для использования и в Linux.
* `-Csplit-debuginfo=unpacked` разделит отладочную информацию на несколько `.dwo` — объектных файлов DWARF.
* `-Csplit-debuginfo=packed` создаст один DWARF-пакет `.dwp` вместе с вашим выходным двоичным файлом со всей отладочной информацией, упакованной вместе.
* `-Csplit-debuginfo=off` по-прежнему является поведением по умолчанию, которое включает данные DWARF в `.debug_*` ELF-объектов и окончательный двоичный файл.
Split DWARF позволяет компоновщику избежать обработки отладочной информации (поскольку её больше нет в компонуемых объектных файлах), что может ускорить время компоновки!
Другие цели теперь также принимают `-Csplit-debuginfo` в качестве стабильной опции со своим значением по умолчанию для конкретной платформы, но указание других значений по-прежнему нестабильно.
### Стабилизированные API
Стабилизированы следующие методы и реализации трейтов:
* [`std::backtrace::Backtrace`](https://doc.rust-lang.org/stable/std/backtrace/struct.Backtrace.html)
* [`Bound::as_ref`](https://doc.rust-lang.org/stable/std/ops/enum.Bound.html#method.as_ref)
* [`std::io::read_to_string`](https://doc.rust-lang.org/stable/std/io/fn.read_to_string.html)
* [`<*const T>::cast_mut`](https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.cast_mut)
* [`<*mut T>::cast_const`](https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.cast_const)
Особо отметим, что `Backtrace` API позволяет захватить трассировку стека в любое время, используя те же платформо-зависимые реализации, которые обычно используются в трассировке паники. Это может быть полезно, например, для ошибок контекста времени выполнения.
Следующие API теперь возможно использовать в контексте `const`:
* [`<*const T>::offset_from`](https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.offset_from)
* [`<*mut T>::offset_from`](https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.offset_from)
### Замечания о совместимости
* В качестве заключительного шага [отказа от RLS](https://blog.rust-lang.org/2022/07/01/RLS-deprecation.html), в данном выпуске RLS заменяется небольшим LSP-сервером, который показывает предупреждение об отказе, советующем перейти на `rust-analyzer`.
### Прочие изменения
Выпуск Rust 1.65 включает и другие изменения:
* MIR inlining теперь включено для оптимизированной компиляции. Это позволяет улучшить компиляцию на 3-10% для крейтов.
* При планировании сборок Cargo теперь сортирует очередь ожидающих заданий для повышения производительности.
Проверьте всё, что изменилось в [Rust](https://github.com/rust-lang/rust/blob/stable/RELEASES.md#version-1650-2022-11-03), [Cargo](https://github.com/rust-lang/cargo/blob/master/CHANGELOG.md#cargo-165-2022-11-03) и [Clippy](https://github.com/rust-lang/rust-clippy/blob/master/CHANGELOG.md#rust-165).
### Участники 1.65.0
Многие люди собрались вместе, чтобы создать Rust 1.65.0. Без вас мы бы не справились. [Спасибо!](https://thanks.rust-lang.org/rust/1.65.0/)
От переводчиков
---------------
С любыми вопросами по языку Rust вам смогут помочь в [русскоязычном Телеграм-чате](https://t.me/rustlang_ru) или же в аналогичном [чате для новичковых вопросов](https://t.me/rust_beginners_ru). Если у вас есть вопросы по переводам или хотите помогать с ними, то обращайтесь в [чат переводчиков](https://t.me/rustlang_ru_translations).
Данную статью совместными усилиями перевели [andreevlex](https://habr.com/ru/users/andreevlex/), [TelegaOvoshey](https://habr.com/ru/users/telegaovoshey/) и [funkill](https://habr.com/ru/users/funkill/). | https://habr.com/ru/post/697430/ | null | ru | null |
# Как улучшить производительность вашего Flutter приложения
Есть много вопросов, решений и заблуждений, как мы можем улучшить производительность нашего Flutter приложения. Необходимо сразу уточнить, что Flutter является производительным по умолчанию, но мы должны избегать некоторых ошибок при написании кода, чтобы приложение всегда работало хорошо и быстро. Ниже я подготовил для вас ряд советов и подсказок, как можно писать, чтобы не приходилось постоянно обращаться к инструментам профилирования.
**Содержание:**
* [Не выносите виджеты в методы класса](#ne-vynosite-vidzhety-v-metody-klassa)
* [Избегайте повторных перестроений всех виджетов](#izbegayte-povtornyh-perestroeniy-vseh-vidzhetov)
* [Используйте const](#ispolzuyte-const)
* [Используйте itemExtent в ListView для больших списков](#ispolzuyte-itemextent-v-listview-dlya-bolshih-spiskov)
* [Избегайте ненужных перестроений виджетов внутри AnimatedBuilder](#izbegayte-nenuzhnyh-perestroeniy-vidzhetov-vnutri-animatedbuilder)
* [Не используйте виджет Opacity в анимациях](#ne-ispolzuyte-vidzhet-opacity-v-animaciyah)
* [Заключение](#zaklyuchenie)
Не выносите виджеты в методы класса
-----------------------------------
Когда у нас есть сложное представление, чтобы реализовать в один виджет, то обычно мы разделяем его на виджеты поменьше, которые помещаем в методы класса.
В следующем примере представлен виджет, содержащий заголовок, основной контент и "подвал" *(footer)*.
```
class MyHomePage extends StatelessWidget {
Widget _buildHeaderWidget() {
final size = 40.0;
return Padding(
padding: const EdgeInsets.all(8.0),
child: CircleAvatar(
backgroundColor: Colors.grey[700],
child: FlutterLogo(
size: size,
),
radius: size,
),
);
}
Widget _buildMainWidget(BuildContext context) {
return Expanded(
child: Container(
color: Colors.grey[700],
child: Center(
child: Text(
'Hello Flutter',
style: Theme.of(context).textTheme.display1,
),
),
),
);
}
Widget _buildFooterWidget() {
return Padding(
padding: const EdgeInsets.all(8.0),
child: Text('This is the footer '),
);
}
@override
Widget build(BuildContext context) {
return Scaffold(
body: Padding(
padding: const EdgeInsets.all(15.0),
child: Column(
mainAxisSize: MainAxisSize.min,
children: [
_buildHeaderWidget(),
_buildMainWidget(context),
_buildFooterWidget(),
],
),
),
);
}
}
```
То, что мы увидели выше, – это антипаттерн. Почему так? Всё потому, что, когда мы вносим изменения и обновляем `MyHomePage` виджет, то виджеты, которые у нас вынесены методах, также обновляются, даже если в этом нет никакой необходимости.
Чтобы не было лишних вычислений, мы можем переделать эти методы в `StatelessWidget` следующим образом.
```
class MyHomePage extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Scaffold(
body: Padding(
padding: const EdgeInsets.all(15.0),
child: Column(
mainAxisSize: MainAxisSize.min,
children: [
HeaderWidget(),
MainWidget(),
FooterWidget(),
],
),
),
);
}
}
class HeaderWidget extends StatelessWidget {
@override
Widget build(BuildContext context) {
final size = 40.0;
return Padding(
padding: const EdgeInsets.all(8.0),
child: CircleAvatar(
backgroundColor: Colors.grey[700],
child: FlutterLogo(
size: size,
),
radius: size,
),
);
}
}
class MainWidget extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Expanded(
child: Container(
color: Colors.grey[700],
child: Center(
child: Text(
'Hello Flutter',
style: Theme.of(context).textTheme.display1,
),
),
),
);
}
}
class FooterWidget extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.all(8.0),
child: Text('This is the footer '),
);
}
}
```
У `Stateful`/`Stateless` виджетов есть специальный механизм "кэширования", учитывающий ключ, тип виджета и его атрибуты, который позволяет не перестраивать виджет без необходимости. Кроме того, это помогает нам инкапсулировать и рефакторировать наши виджеты. ([Разделяй и властвуй](https://en.wikipedia.org/wiki/Divide-and-conquer_algorithm))
И было бы неплохо добавить `const` в наши виджеты. Позже мы увидим, почему это важно.
Избегайте повторных перестроений всех виджетов
----------------------------------------------
Это обычная ошибка, которую многие совершают, когда начинают использовать Flutter и впервые сталкиваются с необходимостью обновить `StatefulWidget` с помощью `setState`.
Следующий пример — это представление, содержащее квадрат в центре и `FloatingActionButton` кнопку, при каждом нажатии на которую вызывается изменение цвета. О, а еще на странице также есть виджет с фоновым изображением. Кроме того, мы добавим вызов `print` оператора внутри `build` метода каждого виджета, чтобы посмотреть, как он работает.
```
class _MyHomePageState extends State {
Color \_currentColor = Colors.grey;
Random \_random = new Random();
void \_onPressed() {
int randomNumber = \_random.nextInt(30);
setState(() {
\_currentColor = Colors.primaries[randomNumber % Colors.primaries.length];
});
}
@override
Widget build(BuildContext context) {
print('building `MyHomePage`');
return Scaffold(
floatingActionButton: FloatingActionButton(
onPressed: \_onPressed,
child: Icon(Icons.colorize),
),
body: Stack(
children: [
Positioned.fill(
child: BackgroundWidget(),
),
Center(
child: Container(
height: 150,
width: 150,
color: \_currentColor,
),
),
],
),
);
}
}
class BackgroundWidget extends StatelessWidget {
@override
Widget build(BuildContext context) {
print('building `BackgroundWidget`');
return Image.network(
'https://cdn.pixabay.com/photo/2017/08/30/01/05/milky-way-2695569\_960\_720.jpg',
fit: BoxFit.cover,
);
}
}
```
После клика по кнопке в консоли мы увидим два вывода
```
flutter: building `MyHomePage`
flutter: building `BackgroundWidget`
```
Каждый раз, когда мы нажимаем кнопку, мы обновляем весь экран: `Scaffold`, `BackgroundWidget` и, наконец, то, что и хотели обновить, – квадрат-`Container`.
Как мы уже выяснили выше, перестраивать виджеты без необходимости – нехорошая практика. Обновляем только то, что нам нужно. Многие знают, что это можно сделать с помощью различных пакетов управления состоянием: [flutter\_bloc](https://pub.dev/packages/flutter_bloc), [mobx](https://pub.dev/packages/mobx), [provider](https://pub.dev/packages/provider) и т. д. Но мало кто знает, что также это можно сделать с помощью классов, которые Flutter уже предлагает из коробки, без каких-либо сторонных библиотек.
Давайте, рассмотрим тот же пример, но обновленный с помощью `ValueNotifier`.
```
class _MyHomePageState extends State {
final \_colorNotifier = ValueNotifier(Colors.grey);
Random \_random = new Random();
void \_onPressed() {
int randomNumber = \_random.nextInt(30);
\_colorNotifier.value =
Colors.primaries[randomNumber % Colors.primaries.length];
}
@override
void dispose() {
\_colorNotifier.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
print('building `MyHomePage`');
return Scaffold(
floatingActionButton: FloatingActionButton(
onPressed: \_onPressed,
child: Icon(Icons.colorize),
),
body: Stack(
children: [
Positioned.fill(
child: BackgroundWidget(),
),
Center(
child: ValueListenableBuilder(
valueListenable: \_colorNotifier,
builder: (\_, value, \_\_) => Container(
height: 150,
width: 150,
color: value,
),
),
),
],
),
);
}
}
```
Кликнем по кнопке и… ничего не увидим в консоли. Это работает, как и ожидалось, мы просто обновляем только тот виджет, который нам нужен *(прим. подробнее про [ValueListenableBuilder и ValueNotifier](https://www.youtube.com/watch?v=s-ZG-jS5QHQ))*.
Но есть еще один интересный виджет, который мы также можем использовать в этом случае, если мы хотим дополнительно разделить бизнес-логику и представление (но, возможно, добавив немного логики в него) и обрабатывать больше данных вне виджета *(в уведомителе)*.
Снова тот же пример, но уже с `ChangeNotifier`.
```
//------ ChangeNotifier class ----//
class MyColorNotifier extends ChangeNotifier {
Color myColor = Colors.grey;
Random _random = new Random();
void changeColor() {
int randomNumber = _random.nextInt(30);
myColor = Colors.primaries[randomNumber % Colors.primaries.length];
notifyListeners();
}
}
//------ State class ----//
class _MyHomePageState extends State {
final \_colorNotifier = MyColorNotifier();
void \_onPressed() {
\_colorNotifier.changeColor();
}
@override
void dispose() {
\_colorNotifier.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
print('building `MyHomePage`');
return Scaffold(
floatingActionButton: FloatingActionButton(
onPressed: \_onPressed,
child: Icon(Icons.colorize),
),
body: Stack(
children: [
Positioned.fill(
child: BackgroundWidget(),
),
Center(
child: AnimatedBuilder(
animation: \_colorNotifier,
builder: (\_, \_\_) => Container(
height: 150,
width: 150,
color: \_colorNotifier.myColor,
),
),
),
],
),
);
}
}
```
Самое прекрасное, что и в этом случае у нас нет ненужных обновлений.
Используйте `const`
-------------------
Рекомендуется использовать ключевое слово `const` для значений, которые возможно инициализировать во время компиляции, а также при вызове конструктора виджета (если он поддерживает `const`, конечно), что позволяет работать с одним и тем же каноническим экземпляром, тем самым избегая повторных вычислений *(прим. подробнее про [работу const](https://habr.com/ru/post/501804/))*.
Давайте ещё раз используем наш пример с `setState`, но в этот раз мы добавим счетчик, который будет увеличивать значение на 1 каждый раз при нажатии на кнопку.
```
class _MyHomePageState extends State {
int \_counter = 0;
void \_onPressed() {
setState(() {
\_counter++;
});
}
@override
Widget build(BuildContext context) {
print('building `MyHomePage`');
return Scaffold(
floatingActionButton: FloatingActionButton(
onPressed: \_onPressed,
child: Icon(Icons.colorize),
),
body: Stack(
children: [
Positioned.fill(
child: BackgroundWidget(),
),
Center(
child: Text(
\_counter.toString(),
style: Theme.of(context).textTheme.display4.apply(
color: Colors.white,
fontWeightDelta: 2,
),
)),
],
),
);
}
}
class BackgroundWidget extends StatelessWidget {
@override
Widget build(BuildContext context) {
print('building `BackgroundWidget`');
return Image.network(
'https://cdn.pixabay.com/photo/2017/08/30/01/05/milky-way-2695569\_960\_720.jpg',
fit: BoxFit.cover,
);
}
}
```
У нас снова 2 вывода в консоли, один из которых относится к основнову виджету, а другой – к `BackgroundWidget`. Каждый раз, когда мы нажимаем кнопку, мы видим, что дочерний виджет также перестраивается, хотя его содержимое никак не меняется.
```
flutter: building `MyHomePage`
flutter: building `BackgroundWidget`
```
А сейчас добавим `const` при работе с виджетом `BackgroundWidget`:
```
class _MyHomePageState extends State {
int \_counter = 0;
void \_onPressed() {
setState(() {
\_counter++;
});
}
@override
Widget build(BuildContext context) {
print('building `MyHomePage`');
return Scaffold(
floatingActionButton: FloatingActionButton(
onPressed: \_onPressed,
child: Icon(Icons.colorize),
),
body: Stack(
children: [
Positioned.fill(
child: const BackgroundWidget(),
),
Center(
child: Text(
\_counter.toString(),
style: Theme.of(context).textTheme.display4.apply(
color: Colors.white,
fontWeightDelta: 2,
),
)),
],
),
);
}
}
class BackgroundWidget extends StatelessWidget {
const BackgroundWidget();
@override
Widget build(BuildContext context) {
print('building `BackgroundWidget`');
return Image.network(
'https://cdn.pixabay.com/photo/2017/08/30/01/05/milky-way-2695569\_960\_720.jpg',
fit: BoxFit.cover,
);
}
}
```
Теперь после клика по кнопке мы видим вывод только для основного виджета (конечно, если использовать те подходы, что я описал выше, избавиться можно и от этого вывода) и избегаем перестроения виджета, вызванного с `const`.
Используйте `itemExtent` в `ListView` для больших списков
---------------------------------------------------------
Иногда, когда у нас есть очень длинный список, и мы хотим быстро переместиться по нему, например, в самый конец, очень важно использовать `itemExtent`.
Давайте рассмотрим простой пример. У нас есть список из 10 тысяч элементов. При нажатии на кнопку мы перейдем к последнему элементу. В этом примере мы не будем использовать `itemExtent` и позволим элементам списка самим определить свой размер.
```
class MyHomePage extends StatelessWidget {
final widgets = List.generate(
10000,
(index) => Container(
height: 200.0,
color: Colors.primaries[index % Colors.primaries.length],
child: ListTile(
title: Text('Index: $index'),
),
),
);
final _scrollController = ScrollController();
void _onPressed() async {
_scrollController.jumpTo(
_scrollController.position.maxScrollExtent,
);
}
@override
Widget build(BuildContext context) {
return Scaffold(
floatingActionButton: FloatingActionButton(
onPressed: _onPressed,
splashColor: Colors.red,
child: Icon(Icons.slow_motion_video),
),
body: ListView(
controller: _scrollController,
children: widgets,
),
);
}
}
```
Как можно увидеть на анимации выше, переход происходит очень долго (~10 секунд). Так получается из-за того, что дочерние элементы сами определяют свой размер. Это даже блокирует UI!
Чтобы избежать этого, мы должны использовать свойство `itemExtent`, благодаря которому при прокрутке не совершается лишней работы по расчету позиции скролла, так как размеры элементов заранее известны.
```
class MyHomePage extends StatelessWidget {
final widgets = List.generate(
10000,
(index) => Container(
color: Colors.primaries[index % Colors.primaries.length],
child: ListTile(
title: Text('Index: $index'),
),
),
);
final _scrollController = ScrollController();
void _onPressed() async {
_scrollController.jumpTo(
_scrollController.position.maxScrollExtent,
);
}
@override
Widget build(BuildContext context) {
return Scaffold(
floatingActionButton: FloatingActionButton(
onPressed: _onPressed,
splashColor: Colors.red,
child: Icon(Icons.slow_motion_video),
),
body: ListView(
controller: _scrollController,
children: widgets,
itemExtent: 200,
),
);
}
}
```
С этим небольшим изменением мы мгновенно переходим в самый низ без каких-либо задержек.
Избегайте ненужных перестроений виджетов внутри `AnimatedBuilder`
-----------------------------------------------------------------
Часто мы хотим, чтобы наши виджеты были анимированы. В таких случаях обычно мы просто добавляем слушателя *(addListener)* для нашего `AnimationController` и вызываем `setState`. Но, как мы видели в самом начале, так работает не лучшим образом. Вместо этого мы будем использовать виджет `AnimatedBuilder` для обновления только того виджета, который мы хотим анимировать.
Давайте создадим экран, который содержит виджет в центре со значением счетчика и кнопку, при нажатии на которую виджет вращается на 360 градусов. После этого добавим вывод в консоль в виджет счетчика `CounterWidget`, и нажмём на кнопку, чтобы посмотреть, что произойдет.
```
class _MyHomePageState extends State
with SingleTickerProviderStateMixin {
AnimationController \_controller;
int counter = 0;
void \_onPressed() {
setState(() {
counter++;
});
\_controller.forward(from: 0.0);
}
@override
void initState() {
\_controller = AnimationController(
vsync: this, duration: const Duration(milliseconds: 600));
super.initState();
}
@override
void dispose() {
\_controller.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
return Scaffold(
floatingActionButton: FloatingActionButton(
onPressed: \_onPressed,
splashColor: Colors.red,
child: Icon(Icons.slow\_motion\_video),
),
body: AnimatedBuilder(
animation: \_controller,
builder: (\_, child) => Transform(
alignment: Alignment.center,
transform: Matrix4.identity()
..setEntry(3, 2, 0.001)
..rotateY(360 \* \_controller.value \* (pi / 180.0)),
child: CounterWidget(
counter: counter,
),
),
),
);
}
}
class CounterWidget extends StatelessWidget {
final int counter;
const CounterWidget({Key key, this.counter}) : super(key: key);
@override
Widget build(BuildContext context) {
print('building `CounterWidget`');
return Center(
child: Text(
counter.toString(),
style: Theme.of(context).textTheme.display4.apply(fontWeightDelta: 3),
),
);
}
}
```
Получили в консоли ряд сообщений.
```
flutter: building `CounterWidget`
flutter: building `CounterWidget`
flutter: building `CounterWidget`
flutter: building `CounterWidget`
flutter: building `CounterWidget`
...
flutter: building `CounterWidget`
```
Мы видим, что в начале вращения число в нашем виджете увеличивается на 1, но в консоли слишком много логов, хотя должен был появиться только один, после того, как мы задали значение счетчика с помощью `setState`. Как избавиться от лишних обновлений `CounterWidget`?
Всё просто! Надо использовать у `AnimatedBuilder` свойство `child`, которое позволяет нам кэшировать виджеты для повторного использования их в анимации. Мы делаем это потому, что этот виджет не будет меняться, единственное, что он будет делать, это вращаться, но для этого у нас есть `Transform` виджет.
```
@override
Widget build(BuildContext context) {
return Scaffold(
floatingActionButton: FloatingActionButton(
onPressed: _onPressed,
splashColor: Colors.red,
child: Icon(Icons.slow_motion_video),
),
body: AnimatedBuilder(
animation: _controller,
child: CounterWidget(
counter: counter,
),
builder: (_, child) => Transform(
alignment: Alignment.center,
transform: Matrix4.identity()
..setEntry(3, 2, 0.001)
..rotateY(360 * _controller.value * (pi / 180.0)),
child: child,
),
),
);
}
```
Внешне поведение никак не изменилось, но если заглянем в консоль, то увидим там только одну запись, соответствующую увеличению счетчика, других обновлений нет. Таким образом мы оптимизировали нашу анимацию.
Не используйте виджет `Opacity` в анимациях
-------------------------------------------
Давайте еще немного про анимации поговорим.
Если нам что-то надо скрыть или показать, то мы обычно применяем виджет `Opacity`. Давайте переделаем предыдущий пример, но вместо `Transform`, мы будем использовать `Opacity`, чтобы наш виджет исчезал и появлялся снова и снова.
```
class _MyHomePageState extends State
with SingleTickerProviderStateMixin {
AnimationController \_controller;
int counter = 0;
void \_onPressed() {
setState(() {
counter++;
});
\_controller.forward(from: 0.0);
}
@override
void initState() {
\_controller = AnimationController(
vsync: this, duration: const Duration(milliseconds: 600));
\_controller.addStatusListener((status) {
if (status == AnimationStatus.completed) {
\_controller.reverse();
}
});
super.initState();
}
@override
void dispose() {
\_controller.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
return Scaffold(
floatingActionButton: FloatingActionButton(
onPressed: \_onPressed,
splashColor: Colors.red,
child: Icon(Icons.slow\_motion\_video),
),
body: AnimatedBuilder(
animation: \_controller,
child: CounterWidget(
counter: counter,
),
builder: (\_, child) => Opacity(
opacity: (1 - \_controller.value),
child: child,
),
),
);
}
}
```
Мы видим, что анимация работает, однако, виджет `Opacity` (и, возможно, его поддерево) перестраивается каждый кадр, что не очень здорово.
Но у нас для оптимизации есть следующие варианты:
1 – Использовать `FadeTransition`
```
class _MyHomePageState extends State
with SingleTickerProviderStateMixin {
AnimationController \_controller;
int counter = 0;
void \_onPressed() {
setState(() {
counter++;
});
\_controller.forward(from: 0.0);
}
@override
void initState() {
\_controller = AnimationController(
vsync: this, duration: const Duration(milliseconds: 600));
\_controller.addStatusListener((status) {
if (status == AnimationStatus.completed) {
\_controller.reverse();
}
});
super.initState();
}
@override
void dispose() {
\_controller.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
return Scaffold(
floatingActionButton: FloatingActionButton(
onPressed: \_onPressed,
splashColor: Colors.red,
child: Icon(Icons.slow\_motion\_video),
),
body: FadeTransition(
opacity: Tween(begin: 1.0, end: 0.0).animate(\_controller),
child: CounterWidget(
counter: counter,
),
),
);
}
}
```
2 – Использовать `AnimatedOpacity`
```
const duration = const Duration(milliseconds: 600);
class _MyHomePageState extends State {
int counter = 0;
double opacity = 1.0;
void \_onPressed() async {
counter++;
setState(() {
opacity = 0.0;
});
await Future.delayed(duration);
setState(() {
opacity = 1.0;
});
}
@override
Widget build(BuildContext context) {
return Scaffold(
floatingActionButton: FloatingActionButton(
onPressed: \_onPressed,
splashColor: Colors.red,
child: Icon(Icons.slow\_motion\_video),
),
body: AnimatedOpacity(
opacity: opacity,
duration: duration,
child: CounterWidget(
counter: counter,
),
),
);
}
}
```
Оба эти варианта намного эффективнее, чем простое использование виджета `Opacity`.
Заключение
----------
Как я уже упоминал ранее, Flutter достаточно мощен, чтобы запускать наши приложения без проблем. Однако, всегда полезно следовать хорошим практикам и максимально оптимизировать наше приложение.
Если хотите ещё больше узнать по данной теме, рекомендую видео-выступление Filip Hráček на Flutter Europe, где он рассказывает об оптимизации и [профилировании Flutter приложений](https://www.youtube.com/watch?v=vVg9It7cOfY).
**Дополнительные материалы:**
* <https://flutter.dev/docs/perf/rendering/best-practices>
* <https://api.flutter.dev/flutter/widgets/StatefulWidget-class.html#performance-considerations>
* <https://api.flutter.dev/flutter/widgets/Opacity-class.html#transparent-image>
**Об авторе:**
Diego Velásquez – это Flutter и Dart [GDE](https://en.wikipedia.org/wiki/Google_Developer_Expert) из Лимы, Перу. Он также входит в комитет по Flutter. Diego увлечен мобильными приложениями и работает в качестве архитектора мобильного программного обеспечения. Вы можете подписаться на него в [Twitter](https://twitter.com/diegoveloper).
---
P.S. Ещё раз ссылка на оригинальную статью [How to improve the performance of your Flutter app](https://blog.codemagic.io/how-to-improve-the-performance-of-your-flutter-app./) от Diego Velásquez | https://habr.com/ru/post/502882/ | null | ru | null |
# Node.js + Chromium = node-webkit: ещё более перспективный вариант второго шага эволюции веборазработчика
**Предисловие от переводчика.** В постскриптуме к моей [вчерашней блогозаписи](http://habrahabr.ru/post/153013/) я указал, что AppJS — это не единственное такое средство, которое позволяет создавать приложения с GUI (графическим интерфейсом пользователя) при помощи вебоподобных методов разработки на языках HTML, CSS и JavaScript с использованием движка Node.js. Естественной иллюстрацией к этому постскриптуму является нижеследующий перевод гитхабовской страницы проекта **node-webkit**. И сразу скажу: я предвижу заранее, что непредвзятый взгляд ваш сочтёт node-webkit ещё более удобным и развитым средством, чем AppJS.
---
Введение
--------
node-webkit — среда для запуска приложений, основанная на Chromium и Node.js. При помощи node-webkit можно создавать традиционные графические приложения посредством HTML и JavaScript. Также node-webkit позволяет вызывать модули Node.js прямо из DOM и тем обеспечивает новый способ создания таких приложений и употребления веботехнологий в них.
node-webkit создан и разрабатывается в Интеловском Центре технологий с открытым исходным кодом *(Intel Open Source Technology Center).*
[Введение в node-webkit](https://speakerdeck.com/u/zcbenz/p/node-webkit-app-runtime-based-on-chromium-and-node-dot-js) (слайды).
Достоинства
-----------
* Приложения создаются при помощи современных HTML5, CSS3, JS и WebGL.
* Полная поддержка [API Node.js](http://nodejs.org/api/) и созданных другими разработчиками [модулей](https://npmjs.org/).
* Вызов API Node.js без потерь в производительности.
* Лёгкость упаковки и распространения приложений.
Файлы для скачивания
--------------------
[Примечания к выпуску v0.2.6](https://groups.google.com/forum/?fromgroups=#!topic/node-webkit/dIYKeL6fPRM)
Сборки версии v0.2.6:
* для Linux: [32bit](http://s3.amazonaws.com/node-webkit/nw_release_linux_x32.tar.gz) / [64bit](https://s3.amazonaws.com/node-webkit/nw_release_linux_x64.tar.gz)
* для Windows: [win32](http://s3.amazonaws.com/node-webkit/nw_release_win32.zip)
* для Mac: [32bit](http://s3.amazonaws.com/node-webkit/nw_release_mac.zip)
[Ищете более старые версии?](https://github.com/rogerwang/node-webkit/wiki/Downloads-of-old-versions)
Демонстрационные приложения:
* [Hello World](http://s3.amazonaws.com/node-webkit/hello_world2.nw)
* [Файловый менеджер](https://github.com/zcbenz/nw-file-explorer)
Руководство по быстрому началу работы
-------------------------------------
Создайте **index.html**:
```
Hello World!
Hello World!
============
Мы используем Node.js версии document.write(process.version).
```
Создайте **package.json**:
```
{
"name": "nw-demo",
"main": "index.html"
}
```
Упакуйте **index.html** и **package.json** в ZIP-архив, а затем переименуйте его в **app.nw**:
```
app.nw
|-- package.json
`-- index.html
```
Скачайте сборку node-webkit для вашей системы и используйте её для открытия файла **app.nw**:
```
$ ./nw app.nw
```
**Примечание:** в Windows можно перетащить **app.nw** и кинуть на **nw.exe**, чтобы открылся.
Читайте дальнейшие сведения о написании, упаковке и запуске приложений:
* [Как запускать приложения](https://github.com/rogerwang/node-webkit/wiki/How-to-run-apps)
* [Как упаковывать и распространять приложения](https://github.com/rogerwang/node-webkit/wiki/How-to-package-and-distribute-your-apps)
Ещё больше сведений изложено [в нашей вики](https://github.com/rogerwang/node-webkit/wiki).
Сообщество
----------
В качестве списка рассылки мы используем [node-webkit на Google Groups](http://groups.google.com/group/node-webkit), подписывайтесь при помощи [node-webkit+subscribe@googlegroups.com](mailto:node-webkit+subscribe@googlegroups.com).
Лицензия
--------
node-webkit распространяется по Лицензии MIT (см. прилагаемый файл [LICENSE](https://github.com/rogerwang/node-webkit/blob/master/LICENSE)).
---
**Послесловие переводчика.** Итак, вот список заметных достоинств node-webkit по сравнению с тем проектом AppJS, о котором я [сообщил вчера](http://habrahabr.ru/post/153013/):
* Более непосредственный стиль обращения к API Node.js: в вышеизложенном примере node-webkit использует **process.version**, тогда как в AppJS пришлось бы использовать **node.process.version**.
* AppJS [не издаёт звук](https://github.com/appjs/appjs/issues/170) при помощи тега , тогда как node-webkit не имеет этой проблемы.
* В node-webkit есть поддержка [ZIP-упаковки приложений](https://github.com/rogerwang/node-webkit/wiki/How-to-package-and-distribute-your-apps) и даже пристыковывания их в хвост к файлу движка. AppJS не имеет (ещё) ничего подобного.
* Документация node-webkit более или менее подробна ([вики](https://github.com/rogerwang/node-webkit/wiki) особенно). Документация AppJS почти совершенно отсутствует.
* [Манифест приложения](https://github.com/rogerwang/node-webkit/wiki/Manifest-format) node-webkit позволяет ограничить минимальную и максимальную ширину окна приложения. Средствами AppJS этого не достигнуть (по крайней мере, так просто).
* node-webkit поддерживает [значок и меню в системном лотке](https://github.com/rogerwang/node-webkit/wiki/Tray), а AppJS — (ещё) [нет](https://github.com/appjs/appjs/issues/50). То же самое можно сказать и о некоторых других ништяках ([получение имён файлов](https://github.com/rogerwang/node-webkit/wiki/File-dialogs), [управление меню](https://github.com/rogerwang/node-webkit/wiki/Menu), [доступ к буферу обмена](https://github.com/rogerwang/node-webkit/wiki/Clipboard)).
* Как сказано на Гитхабе, создание и разработка node-webkit идёт при некоторой поддержке Intel. | https://habr.com/ru/post/153095/ | null | ru | null |
# Сборка бинарных файлов Android с помощью исходников и Android NDK. Прокачиваем утилиту screencap
Я занимаюсь автоматизацией Android устройств и часто SDK или ОС Android не имеют нужного функционала или его работа выполняется медленно/очень медленно.
Используя возможности Native Development Kit (NDK) мы можем написать функционал, который будет выполняться быстрей, чем тот же функционал на Java. За счет данного кита мы можем добавлять в свое приложение код, написанный на C/C++ или создавать свои бинарные файлы под мобильные Android устройства.
В данной статье я расскажу каким образом мы можем настроить компиляцию бинарного файла под ОС Android, а так же покажу процесс, как мы можем дополнить функционал уже существующих бинарных файлов в этой ОС.
Для примера я «прокачаю» screencap, который сможет не только получать скриншот всего экрана или выдавать «сырые данные», но и возвращать цвет пикселя по указанной точки или получать изображение только нужной области. Итак, поехали!
### Установка NDK
Скачиваем [Android NDK](https://developer.android.com/ndk/downloads/index.html) и распаковываем архив или устанавливаем через [SDK Manager](https://developer.android.com/ndk/guides).
Если еще нет, то можете добавить доп. инструменты:
```
sudo apt-get install android-tools-adb android-tools-fastboot
```
И создаем «проект» под архитектуру вашего мобильного устройства:
```
./android-ndk-r12b/build/tools/make_standalone_toolchain.py --arch --install-dir ~/arm
```
Так как у моего HOMTOM HT16 архитектура armeabi-v7a то я буду использовать команду:
```
./android-ndk-r12b/build/tools/make_standalone_toolchain.py --arch arm --install-dir ~/arm
```
И ждем, пока скрипт создаст все необходимые файлы (до 5 мин. примерно).
### Проверка на работоспособонсть
Создадим файл hello\_world.c с простым кодом:
```
#include
int main () {
puts("hello world");
}
```
И попробуем его скомпилировать:
```
~/arm/bin/clang -pie hello_world.c -o hello_world
```
С помощью атрибута **-o** указываем имя файла, а с помощью ключа **-pie** мы указываем, что бинарный файл PIE и все его зависимости загружаются в случайные расположения в виртуальной памяти каждый раз, когда приложение выполняется.
Если компиляция прошла успешно, то заливаем файл на телефон:
```
adb push ./hello_world /data/local/tmp
```
И попробуем бинарник:
```
adb shell
/data/local/tmp/hello_world
```
Если вы увидели вывод фразы «hello world» — значит вы всё сделали правильно!
Если у вас все таки появились ошибки, возможно вы выбрали не правильную архитектуру, тогда просто удалите данную директорию и заново создайте с нужной.
Для определения архитектуры можете выполнить команду
```
adb shell cat /proc/cpuinfo
```
### Исходники и библиотеки
Так как анализ скомпилированного бинарного файла очень затратно по времени, а Android является открытой системой, то почему бы не воспользоваться этим качеством!
Заходим [сюда](https://android.googlesource.com/platform/frameworks/base/+refs) и ищем нужную версию Android. Ну а так уже — скачиваем архив и ищем нужный исходник бинарного файла. Хотя, конечно же есть вариант — Google и «правильный запрос».
В моем случае нужный мне файл находится по [этой ссылке](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-6.0.0_r1/cmds/screencap/screencap.cpp).
**screencap.cpp**
```
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
// TODO: Fix Skia.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#include
#include
#pragma GCC diagnostic pop
using namespace android;
static uint32\_t DEFAULT\_DISPLAY\_ID = ISurfaceComposer::eDisplayIdMain;
static void usage(const char\* pname)
{
fprintf(stderr,
"usage: %s [-hp] [-d display-id] [FILENAME]\n"
" -h: this message\n"
" -p: save the file as a png.\n"
" -d: specify the display id to capture, default %d.\n"
"If FILENAME ends with .png it will be saved as a png.\n"
"If FILENAME is not given, the results will be printed to stdout.\n",
pname, DEFAULT\_DISPLAY\_ID
);
}
static SkColorType flinger2skia(PixelFormat f)
{
switch (f) {
case PIXEL\_FORMAT\_RGB\_565:
return kRGB\_565\_SkColorType;
default:
return kN32\_SkColorType;
}
}
static status\_t vinfoToPixelFormat(const fb\_var\_screeninfo& vinfo,
uint32\_t\* bytespp, uint32\_t\* f)
{
switch (vinfo.bits\_per\_pixel) {
case 16:
\*f = PIXEL\_FORMAT\_RGB\_565;
\*bytespp = 2;
break;
case 24:
\*f = PIXEL\_FORMAT\_RGB\_888;
\*bytespp = 3;
break;
case 32:
// TODO: do better decoding of vinfo here
\*f = PIXEL\_FORMAT\_RGBX\_8888;
\*bytespp = 4;
break;
default:
return BAD\_VALUE;
}
return NO\_ERROR;
}
static status\_t notifyMediaScanner(const char\* fileName) {
String8 cmd("am broadcast -a android.intent.action.MEDIA\_SCANNER\_SCAN\_FILE -d file://");
String8 fileUrl("\"");
fileUrl.append(fileName);
fileUrl.append("\"");
cmd.append(fileName);
cmd.append(" > /dev/null");
int result = system(cmd.string());
if (result < 0) {
fprintf(stderr, "Unable to broadcast intent for media scanner.\n");
return UNKNOWN\_ERROR;
}
return NO\_ERROR;
}
int main(int argc, char\*\* argv)
{
ProcessState::self()->startThreadPool();
const char\* pname = argv[0];
bool png = false;
int32\_t displayId = DEFAULT\_DISPLAY\_ID;
int c;
while ((c = getopt(argc, argv, "phd:")) != -1) {
switch (c) {
case 'p':
png = true;
break;
case 'd':
displayId = atoi(optarg);
break;
case '?':
case 'h':
usage(pname);
return 1;
}
}
argc -= optind;
argv += optind;
int fd = -1;
const char\* fn = NULL;
if (argc == 0) {
fd = dup(STDOUT\_FILENO);
} else if (argc == 1) {
fn = argv[0];
fd = open(fn, O\_WRONLY | O\_CREAT | O\_TRUNC, 0664);
if (fd == -1) {
fprintf(stderr, "Error opening file: %s (%s)\n", fn, strerror(errno));
return 1;
}
const int len = strlen(fn);
if (len >= 4 && 0 == strcmp(fn+len-4, ".png")) {
png = true;
}
}
if (fd == -1) {
usage(pname);
return 1;
}
void const\* mapbase = MAP\_FAILED;
ssize\_t mapsize = -1;
void const\* base = NULL;
uint32\_t w, s, h, f;
size\_t size = 0;
// Maps orientations from DisplayInfo to ISurfaceComposer
static const uint32\_t ORIENTATION\_MAP[] = {
ISurfaceComposer::eRotateNone, // 0 == DISPLAY\_ORIENTATION\_0
ISurfaceComposer::eRotate270, // 1 == DISPLAY\_ORIENTATION\_90
ISurfaceComposer::eRotate180, // 2 == DISPLAY\_ORIENTATION\_180
ISurfaceComposer::eRotate90, // 3 == DISPLAY\_ORIENTATION\_270
};
ScreenshotClient screenshot;
sp display = SurfaceComposerClient::getBuiltInDisplay(displayId);
if (display == NULL) {
fprintf(stderr, "Unable to get handle for display %d\n", displayId);
return 1;
}
Vector configs;
SurfaceComposerClient::getDisplayConfigs(display, &configs);
int activeConfig = SurfaceComposerClient::getActiveConfig(display);
if (static\_cast(activeConfig) >= configs.size()) {
fprintf(stderr, "Active config %d not inside configs (size %zu)\n",
activeConfig, configs.size());
return 1;
}
uint8\_t displayOrientation = configs[activeConfig].orientation;
uint32\_t captureOrientation = ORIENTATION\_MAP[displayOrientation];
status\_t result = screenshot.update(display, Rect(), 0, 0, 0, -1U,
false, captureOrientation);
if (result == NO\_ERROR) {
base = screenshot.getPixels();
w = screenshot.getWidth();
h = screenshot.getHeight();
s = screenshot.getStride();
f = screenshot.getFormat();
size = screenshot.getSize();
} else {
const char\* fbpath = "/dev/graphics/fb0";
int fb = open(fbpath, O\_RDONLY);
if (fb >= 0) {
struct fb\_var\_screeninfo vinfo;
if (ioctl(fb, FBIOGET\_VSCREENINFO, &vinfo) == 0) {
uint32\_t bytespp;
if (vinfoToPixelFormat(vinfo, &bytespp, &f) == NO\_ERROR) {
size\_t offset = (vinfo.xoffset + vinfo.yoffset\*vinfo.xres) \* bytespp;
w = vinfo.xres;
h = vinfo.yres;
s = vinfo.xres;
size = w\*h\*bytespp;
mapsize = offset + size;
mapbase = mmap(0, mapsize, PROT\_READ, MAP\_PRIVATE, fb, 0);
if (mapbase != MAP\_FAILED) {
base = (void const \*)((char const \*)mapbase + offset);
}
}
}
close(fb);
}
}
if (base != NULL) {
if (png) {
const SkImageInfo info = SkImageInfo::Make(w, h, flinger2skia(f),
kPremul\_SkAlphaType);
SkAutoTUnref data(SkImageEncoder::EncodeData(info, base, s\*bytesPerPixel(f),
SkImageEncoder::kPNG\_Type, SkImageEncoder::kDefaultQuality));
if (data.get()) {
write(fd, data->data(), data->size());
}
if (fn != NULL) {
notifyMediaScanner(fn);
}
} else {
write(fd, &w, 4);
write(fd, &h, 4);
write(fd, &f, 4);
size\_t Bpp = bytesPerPixel(f);
for (size\_t y=0 ; y
```
Частично разберем данный код.
**DEFAULT\_DISPLAY\_ID** — идентификатор дисплея, с которого необходимо получить скриншот. В нашем случае 0.
**flinger2skia** и **vinfoToPixelFormat** — отвечает за определение, в каком формате должно быть изображение.
**notifyMediaScanner** — после того, как изображение будет создано в файловой системе необходимо послать broadcast, чтобы файл смог корректно отображаться. Если не вызывать данный broadcast, то не все приложении смогут увидеть созданный файл.
Функция main не является сложной для «чтения», поэтому разберем только важные моменты, которые непосредственно отвечают за получение данных о изображении.
**/dev/graphics/fb0** — это так называемый framebuffer. Framebuffer — это область видеопамяти для кратковременного хранения одного или нескольких видеокадров. Исходя из кода main видно, что существуют версии Android устройств, которые хранят изображение экрана в этом файле. Таким образом, если вы «счастливчик», то узнав vinfo.xoffset и vinfo.yoffset (в большинстве случаев они будут равны 0) и используя консоль вы с легкостью сможете получить информацию о цвете:
```
dd if=/dev/graphics/fb0 bs= count=1 skip= 2>/dev/null | hd
```
В моём случае оказалось все не так просто и данный файл не содержать какую либо информацию о изображении.
**screenshot.update** — это второй способ, как можно получить изображение. Данная функция имеет несколько перегруженных методов с которыми можно ознакомиться [тут](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-6.0.0_r1/libs/gui/SurfaceComposerClient.cpp).
Рассмотрим описание функции с самым большим количеством параметров:
```
ScreenshotClient::update(const sp& display,
Rect sourceCrop, uint32\_t reqWidth, uint32\_t reqHeight,
uint32\_t minLayerZ, uint32\_t maxLayerZ,
bool useIdentityTransform, uint32\_t rotation)
```
**display** — ссылка на необходимый display.
**sourceCrop** — кроп выбранной области изображения. Может содержать координаты верхней левой точки и нижней правой (всего 4 параметра xLeft, yTop, xRight, yBottom). Начальная точка координат — верхний левый угол.
**reqWidth** — ширина возвращаемого изображения
**reqHeight** — высота возвращаемого изображения
**minLayerZ** и **maxLayerZ** — как именно работают данные параметры не удалось понять. Перебор значений выдавал иногда черный кран
**useIdentityTransform** — Если true, то отключает слой наложения поверх приложений, т.е. тех Activity, которые используют [ACTION\_MANAGE\_OVERLAY\_PERMISSION](https://developer.android.com/reference/android/provider/Settings)
**rotation** — поворот изображения.
Таким образом, чтобы нам получить цвет пикселя, нам необходимо задать xLeft и yTop, сдвинув их на 1, т.к. отсчет будет идти с 0, а указанные координаты установить в xRight, yBottom. В reqWidth и reqHeight установить значение равным 1. Изменяя параметры данной функции мы сможем определять границы нужной для нас области.
### Компиляция базового screencap.cpp
На самом деле это самая сложная часть, которая может занять несколько дней или целую неделю. К сожалению мне не удалось найти каких-то быстрых решений сборки новой версии screencap в сети, поэтому пришлось конкретно помучаться с clang'ом и его параметрами.
Если вы сразу же попробуете скомпилировать данный код, компилятор будет постоянно ругаться, что нет какого-то файла, а иногда может и сообщить, что файл то есть, но вот нет нужного конструктора.
Поэтому, первоначально я добавил все файлы, которые отсутствовали в библиотеке NDK. Ошибки дают представления, где примерно должен находиться тот или иной файл. Для этого, вам необходимо добавить недостающие файлы, а чтобы узнать где находится sysroot (директория, где ищет clang), можно воспользоваться следующей «фичей»:
```
echo "#include int main(){}" > t.c; ~/arm/bin/clang -v t.c; rm t.c
```
В ошибке будет виден путь до данной директории. Если clang у вас находится в другом месте — измените путь до него.
**Log**
```
Android (4751641 based on r328903) clang version 7.0.2 (https://android.googlesource.com/toolchain/clang 003100370607242ddd5815e4a043907ea9004281) (https://android.googlesource.com/toolchain/llvm 1d739ffb0366421d383e04ff80ec2ee591315116) (based on LLVM 7.0.2svn)
Target: armv7a-none-linux-android16
Thread model: posix
InstalledDir: /Users/macbookair/arm/bin
Found candidate GCC installation: /Users/macbookair/arm/bin/../lib/gcc/arm-linux-androideabi/4.9.x
Selected GCC installation: /Users/macbookair/arm/bin/../lib/gcc/arm-linux-androideabi/4.9.x
Candidate multilib: thumb;@mthumb
Candidate multilib: armv7-a;@march=armv7-a
Candidate multilib: armv7-a/thumb;@march=armv7-a@mthumb
Candidate multilib: .;
Selected multilib: armv7-a;@march=armv7-a
"/Users/macbookair/arm/bin/clang70" -cc1 -triple armv7-none-linux-android16 -emit-obj -mrelax-all -disable-free -disable-llvm-verifier -discard-value-names -main-file-name t.c -mrelocation-model pic -pic-level 2 -pic-is-pie -mthread-model posix -mdisable-fp-elim -fmath-errno -masm-verbose -mconstructor-aliases -fuse-init-array -target-cpu generic -target-feature +soft-float-abi -target-abi aapcs-linux -mfloat-abi soft -fallow-half-arguments-and-returns -dwarf-column-info -debugger-tuning=gdb -target-linker-version 241.9 -v -resource-dir /Users/macbookair/arm/lib64/clang/7.0.2 -isysroot /Users/macbookair/arm/bin/../sysroot -internal-isystem /Users/macbookair/arm/bin/../sysroot/usr/local/include -internal-isystem /Users/macbookair/arm/lib64/clang/7.0.2/include -internal-externc-isystem /Users/macbookair/arm/bin/../sysroot/include -internal-externc-isystem /Users/macbookair/arm/bin/../sysroot/usr/include -fdebug-compilation-dir /Users/macbookair/Downloads/sji-android-screen-capture-master/src/android/capture -ferror-limit 19 -fmessage-length 80 -fno-signed-char -fobjc-runtime=gcc -fdiagnostics-show-option -fcolor-diagnostics -o /var/folders/_4/7d51802j1hz2rnmql8kngx5w0000gn/T/t-9f5ef7.o -x c t.c
clang -cc1 version 7.0.2 based upon LLVM 7.0.2svn default target x86_64-apple-darwin18.0.0
ignoring nonexistent directory "/Users/macbookair/arm/bin/../sysroot/include"
#include "..." search starts here:
#include <...> search starts here:
/Users/macbookair/arm/bin/../sysroot/usr/local/include
/Users/macbookair/arm/lib64/clang/7.0.2/include
/Users/macbookair/arm/bin/../sysroot/usr/include
End of search list.
t.c:1:10: error: expected "FILENAME" or
#include int main(){}
^
1 error generated.
```
Обращаемся к Google и ищем все необходимые файлы. В моем случае пришлось добавить следующие директории и файлы:
**Директории и файлы**
```
//Добавлены директории
~/arm/sysroot/usr/include/binder
~/arm/sysroot/usr/include/utils
~/arm/sysroot/usr/include/cutils
~/arm/sysroot/usr/include/log
~/arm/sysroot/usr/include/system
~/arm/sysroot/usr/include/gui
~/arm/sysroot/usr/include/ui
~/arm/sysroot/usr/include/hardware
~/arm/sysroot/usr/ports
//Добавлены файлы
~/arm/sysroot/usr/include/SkAnnotation.h
~/arm/sysroot/usr/include/SkAtomics.h
~/arm/sysroot/usr/include/SkBBHFactory.h
~/arm/sysroot/usr/include/SkBitmap.h
~/arm/sysroot/usr/include/SkBitmapDevice.h
~/arm/sysroot/usr/include/SkBlitRow.h
~/arm/sysroot/usr/include/SkBlurTypes.h
~/arm/sysroot/usr/include/SkCanvas.h
~/arm/sysroot/usr/include/SkChunkAlloc.h
~/arm/sysroot/usr/include/SkClipStack.h
~/arm/sysroot/usr/include/SkColor.h
~/arm/sysroot/usr/include/SkColorFilter.h
~/arm/sysroot/usr/include/SkColorPriv.h
~/arm/sysroot/usr/include/SkColorTable.h
~/arm/sysroot/usr/include/SkComposeShader.h
~/arm/sysroot/usr/include/SkData.h
~/arm/sysroot/usr/include/SkDataTable.h
~/arm/sysroot/usr/include/SkDeque.h
~/arm/sysroot/usr/include/SkDevice.h
~/arm/sysroot/usr/include/SkDither.h
~/arm/sysroot/usr/include/SkDocument.h
~/arm/sysroot/usr/include/SkDraw.h
~/arm/sysroot/usr/include/SkDrawable.h
~/arm/sysroot/usr/include/SkDrawFilter.h
~/arm/sysroot/usr/include/SkDrawLooper.h
~/arm/sysroot/usr/include/SkDrawPictureCallback.h
~/arm/sysroot/usr/include/SkEndian.h
~/arm/sysroot/usr/include/SkError.h
~/arm/sysroot/usr/include/SkFilterQuality.h
~/arm/sysroot/usr/include/SkFixed.h
~/arm/sysroot/usr/include/SkFlattenable.h
~/arm/sysroot/usr/include/SkFlattenableSerialization.h
~/arm/sysroot/usr/include/SkFloatBits.h
~/arm/sysroot/usr/include/SkFloatingPoint.h
~/arm/sysroot/usr/include/SkFont.h
~/arm/sysroot/usr/include/SkFontHost.h
~/arm/sysroot/usr/include/SkFontLCDConfig.h
~/arm/sysroot/usr/include/SkFontStyle.h
~/arm/sysroot/usr/include/SkGraphics.h
~/arm/sysroot/usr/include/SkImage.h
~/arm/sysroot/usr/include/SkImageDecoder.h
~/arm/sysroot/usr/include/SkImageEncoder.h
~/arm/sysroot/usr/include/SkImageFilter.h
~/arm/sysroot/usr/include/SkImageGenerator.h
~/arm/sysroot/usr/include/SkImageInfo.h
~/arm/sysroot/usr/include/SkInstCnt.h
~/arm/sysroot/usr/include/SkLazyPtr.h
~/arm/sysroot/usr/include/SkMallocPixelRef.h
~/arm/sysroot/usr/include/SkMask.h
~/arm/sysroot/usr/include/SkMaskFilter.h
~/arm/sysroot/usr/include/SkMath.h
~/arm/sysroot/usr/include/SkMatrix.h
~/arm/sysroot/usr/include/SkMetaData.h
~/arm/sysroot/usr/include/SkMultiPictureDraw.h
~/arm/sysroot/usr/include/SkMutex.h
~/arm/sysroot/usr/include/SkOnce.h
~/arm/sysroot/usr/include/SkOSFile.h
~/arm/sysroot/usr/include/SkPackBits.h
~/arm/sysroot/usr/include/SkPaint.h
~/arm/sysroot/usr/include/SkPath.h
~/arm/sysroot/usr/include/SkPathEffect.h
~/arm/sysroot/usr/include/SkPathMeasure.h
~/arm/sysroot/usr/include/SkPathRef.h
~/arm/sysroot/usr/include/SkPicture.h
~/arm/sysroot/usr/include/SkPictureRecorder.h
~/arm/sysroot/usr/include/SkPixelRef.h
~/arm/sysroot/usr/include/SkPixelSerializer.h
~/arm/sysroot/usr/include/SkPoint.h
~/arm/sysroot/usr/include/SkPostConfig.h
~/arm/sysroot/usr/include/SkPreConfig.h
~/arm/sysroot/usr/include/SkRasterizer.h
~/arm/sysroot/usr/include/SkRect.h
~/arm/sysroot/usr/include/SkRefCnt.h
~/arm/sysroot/usr/include/SkRegion.h
~/arm/sysroot/usr/include/SkRRect.h
~/arm/sysroot/usr/include/SkScalar.h
~/arm/sysroot/usr/include/SkShader.h
~/arm/sysroot/usr/include/SkSize.h
~/arm/sysroot/usr/include/SkSpinlock.h
~/arm/sysroot/usr/include/SkStream.h
~/arm/sysroot/usr/include/SkString.h
~/arm/sysroot/usr/include/SkStrokeRec.h
~/arm/sysroot/usr/include/SkSurface.h
~/arm/sysroot/usr/include/SkSurfaceProps.h
~/arm/sysroot/usr/include/SkTArray.h
~/arm/sysroot/usr/include/SkTDArray.h
~/arm/sysroot/usr/include/SkTDict.h
~/arm/sysroot/usr/include/SkTDStack.h
~/arm/sysroot/usr/include/SkTemplates.h
~/arm/sysroot/usr/include/SkTextBlob.h
~/arm/sysroot/usr/include/SkThread.h
~/arm/sysroot/usr/include/SkTime.h
~/arm/sysroot/usr/include/SkTInternalLList.h
~/arm/sysroot/usr/include/SkTLazy.h
~/arm/sysroot/usr/include/SkTRegistry.h
~/arm/sysroot/usr/include/SkTSearch.h
~/arm/sysroot/usr/include/SkTypeface.h
~/arm/sysroot/usr/include/SkTypes.h
~/arm/sysroot/usr/include/SkUnPreMultiply.h
~/arm/sysroot/usr/include/SkUserConfig.h
~/arm/sysroot/usr/include/SkUtils.h
~/arm/sysroot/usr/include/SkWeakRefCnt.h
~/arm/sysroot/usr/include/SkWriteBuffer.h
~/arm/sysroot/usr/include/SkWriter32.h
~/arm/sysroot/usr/include/SkXfermode.h
//И небольшая правка кода
~/arm/sysroot/usr/include/android/log.h
```
И казалось бы, что вот он успех, все что надо добавлено. Выполняем компиляцию
```
~/arm/bin/clang -pie screencap.cpp -o ./screencap
```
и получаем ужасный результат:
**Слабонервным не смотреть**
```
/var/folders/_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::ProcessState::self()'
/var/folders/_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::ProcessState::startThreadPool()'
/var/folders/_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::ScreenshotClient::ScreenshotClient()'
/var/folders/_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::SurfaceComposerClient::getBuiltInDisplay(int)'
/var/folders/_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::SurfaceComposerClient::getDisplayConfigs(android::sp const&, android::Vector\*)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::SurfaceComposerClient::getActiveConfig(android::sp const&)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::ScreenshotClient::update(android::sp const&, android::Rect, unsigned int, unsigned int, unsigned int, unsigned int, bool, unsigned int)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::ScreenshotClient::getPixels() const'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::ScreenshotClient::getWidth() const'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::ScreenshotClient::getHeight() const'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::ScreenshotClient::getStride() const'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::ScreenshotClient::getFormat() const'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::ScreenshotClient::getSize() const'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::bytesPerPixel(int)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'SkImageEncoder::EncodeData(SkImageInfo const&, void const\*, unsigned int, SkImageEncoder::Type, int)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::bytesPerPixel(int)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::ScreenshotClient::~ScreenshotClient()'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'android::ScreenshotClient::~ScreenshotClient()'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'stderr'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'stderr'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function main: error: undefined reference to 'stderr'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function usage(char const\*): error: undefined reference to 'stderr'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function notifyMediaScanner(char const\*): error: undefined reference to 'android::String8::String8(char const\*)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function notifyMediaScanner(char const\*): error: undefined reference to 'android::String8::String8(char const\*)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function notifyMediaScanner(char const\*): error: undefined reference to 'android::String8::append(char const\*)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function notifyMediaScanner(char const\*): error: undefined reference to 'android::String8::append(char const\*)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function notifyMediaScanner(char const\*): error: undefined reference to 'android::String8::append(char const\*)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function notifyMediaScanner(char const\*): error: undefined reference to 'android::String8::append(char const\*)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function notifyMediaScanner(char const\*): error: undefined reference to 'android::String8::~String8()'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function notifyMediaScanner(char const\*): error: undefined reference to 'android::String8::~String8()'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function notifyMediaScanner(char const\*): error: undefined reference to 'android::String8::~String8()'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function notifyMediaScanner(char const\*): error: undefined reference to 'android::String8::~String8()'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o(.ARM.extab+0x0): error: undefined reference to '\_\_gxx\_personality\_v0'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o(.ARM.extab+0x48): error: undefined reference to '\_\_gxx\_personality\_v0'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function android::sp::~sp(): error: undefined reference to 'android::RefBase::decStrong(void const\*) const'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o(.ARM.extab.text.\_ZN7android2spINS\_12ProcessStateEED2Ev+0x0): error: undefined reference to '\_\_gxx\_personality\_v0'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function android::Vector::Vector(): error: undefined reference to 'android::VectorImpl::VectorImpl(unsigned int, unsigned int)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function android::Vector::operator[](unsigned int) const: error: undefined reference to '\_\_android\_log\_assert'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o(.ARM.extab.text.\_ZN12SkAutoTUnrefI6SkDataED2Ev+0x0): error: undefined reference to '\_\_gxx\_personality\_v0'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function android::Vector::~Vector(): error: undefined reference to 'android::VectorImpl::finish\_vector()'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function android::Vector::~Vector(): error: undefined reference to 'android::VectorImpl::~VectorImpl()'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function android::Vector::~Vector(): error: undefined reference to 'android::VectorImpl::~VectorImpl()'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function android::sp::~sp(): error: undefined reference to 'android::RefBase::decStrong(void const\*) const'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function \_\_clang\_call\_terminate: error: undefined reference to '\_\_cxa\_begin\_catch'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function \_\_clang\_call\_terminate: error: undefined reference to 'std::terminate()'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function android::Vector::~Vector(): error: undefined reference to 'operator delete(void\*)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:function SkRefCntBase::unref() const: error: undefined reference to 'SkDebugf(char const\*, ...)'
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:typeinfo for android::Vector: error: undefined reference to 'vtable for \_\_cxxabiv1::\_\_vmi\_class\_type\_info'
/Users/macbookair/Documents/test/bin/../lib/gcc/arm-linux-androideabi/4.9.x/../../../../arm-linux-androideabi/bin/ld: the vtable symbol may be undefined because the class is missing its key function
/var/folders/\_4/7d51802j1hz2rnmql8kngx5w0000gn/T/screencap-175810.o:screencap.cpp:typeinfo for android::Vector: error: undefined reference to 'typeinfo for android::VectorImpl'
clang70: error: linker command failed with exit code 1 (use -v to see invocation)
```
По мне, это был реальный ад, т.к. множество файлов имело ошибки, чего по идее быть не должно, ведь содержимое данных файлов не менялось. На данном этапе я на долго «присел» и начал активно гуглить ошибки, но нужного ответа не нашел. Каким образом я решил поизучать туториал по clang я уже не помню, но это решение меня спасло!
Как оказалось, у clang есть параметр (а точнее у [ld](https://linux.die.net/man/1/ld)) --unresolved-symbols, который отвечает за работу с неразрешенными (unresolved) символами. Хотя по самой ошибки и не скажешь, что дело в этом. Добавляем параметр и выполняем компиляцию снова:
```
~/arm/bin/clang -pie screencap.cpp -o ./screencap -Wl,--unresolved-symbols=ignore-all -s
```
Наконец-то компиляция прошла успешно! На самом деле, я уже думал, что большая часть проблем ушла, но не тут то было. Начали появляться ошибки, наподобие следующей:
```
CANNOT LINK EXECUTABLE: cannot locate symbol "_ZN7android12ProcessState4selfEv"
```
Как оказалось, компилятору было достаточно наших добавленных файлов, но на Android устройстве все эти файлы хранятся в .so библиотеках. Позже разобравший более менее хорошо в этом вопросе, я нашел относительно простой способ поиска необходимых библиотек. Для этого нужно открыть бинарных файл screencap, который находится на Android-устройстве (/system/bin/screencap) в текстовом редакторе и посмотреть все названия .so библиотек, которые используются в данном файле. В моем случае вот эта часть:
**Часть с названиями используемых библиотек**
```
...libdl.so__libc_initlibc.so__cxa_atexit__register_atfork__gnu_Unwind_Find_exidxLIBC_PRIVATE_ZNK7android6VectorINS_11DisplayInfoEE12do_constructEPvj__snprintf_chk__aeabi_memset__aeabi_memcpy_ZNK7android6VectorINS_11DisplayInfoEE10do_destroyEPvj_ZNK7android6VectorINS_11DisplayInfoEE7do_copyEPvPKvj_ZNK7android6VectorINS_11DisplayInfoEE8do_splatEPvPKvj_ZNK7android6VectorINS_11DisplayInfoEE15do_move_forwardEPvPKvj_ZNK7android6VectorINS_11DisplayInfoEE16do_move_backwardEPvPKvj_ZN7android10VectorImpl13finish_vectorEv_ZN7android10VectorImplD2Ev_ZTVN7android6VectorINS_11DisplayInfoEEE_ZdlPvsignal__android_log_print_ZN7android12ProcessState4selfEv_ZN7android12ProcessState15startThreadPoolEv_ZNK7android7RefBase9decStrongEPKvgetoptatoidupopen__errnostrerrorfprintfstrlenstrcmp_ZN7android16ScreenshotClientC1Ev_ZN7android21SurfaceComposerClient17getBuiltInDisplayEi_ZN7android10VectorImplC2Ejj_ZN7android21SurfaceComposerClient17getDisplayConfigsERKNS_2spINS_7IBinderEEEPNS_6VectorINS_11DisplayInfoEEE_ZN7android21SurfaceComposerClient15getActiveConfigERKNS_2spINS_7IBinderEEE_ZN7android16ScreenshotClient6updateERKNS_2spINS_7IBinderEEENS_4RectEjjjjbj_ZNK7android16ScreenshotClient9getPixelsEv_ZNK7android16ScreenshotClient8getWidthEv_ZNK7android16ScreenshotClient9getHeightEv_ZNK7android16ScreenshotClient9getStrideEv_ZNK7android16ScreenshotClient9getFormatEv_ZNK7android16ScreenshotClient7getSizeEvioctlclose_ZN7android13bytesPerPixelEi_ZN14SkImageEncoder10EncodeDataERK11SkImageInfoPKvjNS_4TypeEiwrite_ZN7android7String8C1EPKc_ZN7android7String86appendEPKcsystemfputs_ZN7android7String8D1Evmunmap_ZN7android16ScreenshotClientD1Evmmapoptargstderroptindabort_edata__bss_start_endlibcutils.solibutils.solibbinder.solibskia.solibui.solibgui.solibc++.solibm.so...
```
Вы можете сравнить данную часть с вашим скомпилированным файлом и найти, каких же библиотек вам не хватает. В данном случае ими оказались: libgui.so, libui.so, libcutils.so, libutils.so, libbinder.so, libskia.so. Ищем их расположение (на самом деле, они находятся в одном и том же месте):
```
find -name 'libskia.so' 2>/dev/null
/system/lib/libskia.so
```
Выполняем копирование на sdcard/libs всех библиотек (пример для libskia.so):
```
./system/lib/libskia.so /sdcard/
```
Используя adb pull копируем файлы с моб. устройства на компьютер:
```
adb pull /sdcard/libs ~/arm
```
Располагаем их в нужной для вас директории и выполняем компиляцию, но уже с новым параметром \*.so, который указывает на то, что нужно так же использовать все .so библиотеки при сборке, а точнее — указать ссылки на них в файле.
```
~/arm/bin/clang -pie screencap.cpp *.so -o ./screencap -Wl,--unresolved-symbols=ignore-all -s
```
Теперь и компиляция пройдет успешно и запуск бинарного файла на моб. устройстве будет без ошибок.
### Заключение и результат
Как вы могли заметить, добавление своего функционала «в чужой код» является не очень простым занятием.
Измененный код файла screencap приведен ниже. Сборка его происходит таким же образом, как и оригинального. Добавленные изменения думаю будут понятны большинству читателей, поэтому решил его не комментировать.
**Улучшенный screencap.cpp**
```
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
// TODO: Fix Skia.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#include
#include
#pragma GCC diagnostic pop
using namespace android;
static uint32\_t DEFAULT\_DISPLAY\_ID = ISurfaceComposer::eDisplayIdMain;
static void usage(const char\* pname)
{
fprintf(stderr,
"usage: %s [-hpcr] [-d display-id] [FILENAME] [x1 y1] [x2 y2]\n"
" -h: this message\n"
" -p: save the file as a png.\n"
" -d: specify the display id to capture, default %d.\n"
" -c: print pixel color [x y].\n"
" -r: get rectangle area [x1 - left y1 - top x2 - right y2 - bottom].\n"
"If FILENAME ends with .png it will be saved as a png.\n"
"If FILENAME is not given, the results will be printed to stdout.\n",
pname, DEFAULT\_DISPLAY\_ID
);
}
static SkColorType flinger2skia(PixelFormat f)
{
switch (f) {
case PIXEL\_FORMAT\_RGB\_565:
return kRGB\_565\_SkColorType;
default:
return kN32\_SkColorType;
}
}
static status\_t vinfoToPixelFormat(const fb\_var\_screeninfo& vinfo,
uint32\_t\* bytespp, uint32\_t\* f)
{
switch (vinfo.bits\_per\_pixel) {
case 16:
\*f = PIXEL\_FORMAT\_RGB\_565;
\*bytespp = 2;
break;
case 24:
\*f = PIXEL\_FORMAT\_RGB\_888;
\*bytespp = 3;
break;
case 32:
// TODO: do better decoding of vinfo here
\*f = PIXEL\_FORMAT\_RGBX\_8888;
\*bytespp = 4;
break;
default:
return BAD\_VALUE;
}
return NO\_ERROR;
}
static status\_t notifyMediaScanner(const char\* fileName) {
String8 cmd("am broadcast -a android.intent.action.MEDIA\_SCANNER\_SCAN\_FILE -d file://");
String8 fileUrl("\"");
fileUrl.append(fileName);
fileUrl.append("\"");
cmd.append(fileName);
cmd.append(" > /dev/null");
int result = system(cmd.string());
if (result < 0) {
fprintf(stderr, "Unable to broadcast intent for media scanner.\n");
return UNKNOWN\_ERROR;
}
return NO\_ERROR;
}
int main(int argc, char\*\* argv)
{
ProcessState::self()->startThreadPool();
const char\* pname = argv[0];
int x1,x2,y1,y2;
bool png = false;
bool color = false;
bool rectangle = false;
int32\_t displayId = DEFAULT\_DISPLAY\_ID;
int c;
while ((c = getopt(argc, argv, "phdcr:")) != -1) {
switch (c) {
case 'p':
png = true;
break;
case 'd':
displayId = atoi(optarg);
break;
case 'c':
color = true;
break;
case 'r':
rectangle = true;
break;
case '?':
case 'h':
usage(pname);
return 1;
}
}
argc -= optind;
if (color) {
x1 = atoi(argv[2])-1;
y1 = atoi(argv[3])-1;
x2 = atoi(argv[2]);
y2 = atoi(argv[3]);
}
else if (rectangle) {
x1 = atoi(argv[3]);
y1 = atoi(argv[4]);
x2 = atoi(argv[5]);
y2 = atoi(argv[6]);
optind--;
}
argv += optind;
int fd = -1;
const char\* fn = NULL;
if (argc == 0) {
fd = dup(STDOUT\_FILENO);
} else if (argc == 1 || argc == 4) {
fn = argv[0];
fd = open(fn, O\_WRONLY | O\_CREAT | O\_TRUNC, 0664);
if (fd == -1) {
fprintf(stderr, "Error opening file: %s (%s)\n", fn, strerror(errno));
return 1;
}
const int len = strlen(fn);
if (len >= 4 && 0 == strcmp(fn+len-4, ".png")) {
png = true;
}
}
if (fd == -1 && !color && !rectangle) {
usage(pname);
return 1;
}
void const\* mapbase = MAP\_FAILED;
ssize\_t mapsize = -1;
void const\* base = NULL;
uint32\_t w, s, h, f;
size\_t size = 0;
// Maps orientations from DisplayInfo to ISurfaceComposer
static const uint32\_t ORIENTATION\_MAP[] = {
ISurfaceComposer::eRotateNone, // 0 == DISPLAY\_ORIENTATION\_0
ISurfaceComposer::eRotate270, // 1 == DISPLAY\_ORIENTATION\_90
ISurfaceComposer::eRotate180, // 2 == DISPLAY\_ORIENTATION\_180
ISurfaceComposer::eRotate90, // 3 == DISPLAY\_ORIENTATION\_270
};
ScreenshotClient screenshot;
sp display = SurfaceComposerClient::getBuiltInDisplay(displayId);
if (display == NULL) {
fprintf(stderr, "Unable to get handle for display %d\n", displayId);
return 1;
}
Vector configs;
SurfaceComposerClient::getDisplayConfigs(display, &configs);
int activeConfig = SurfaceComposerClient::getActiveConfig(display);
if (static\_cast(activeConfig) >= configs.size()) {
fprintf(stderr, "Active config %d not inside configs (size %zu)\n",
activeConfig, configs.size());
return 1;
}
uint8\_t displayOrientation = configs[activeConfig].orientation;
uint32\_t captureOrientation = ORIENTATION\_MAP[displayOrientation];
status\_t result;
if (color || rectangle) {
result = screenshot.update(display, Rect(x1,y1,x2,y2), x2-x1, y2-y1, 0, -1U,
false, captureOrientation);
}
else {
result = screenshot.update(display, Rect(), 0, 0, 0, -1U,
false, captureOrientation);
}
if (result == NO\_ERROR) {
base = screenshot.getPixels();
w = screenshot.getWidth();
h = screenshot.getHeight();
s = screenshot.getStride();
f = screenshot.getFormat();
size = screenshot.getSize();
if (color) {
size\_t Bpp = 4; //bytesPerPixel
char\* rawImageData;
rawImageData = (char \*)base;
base = (void \*)((char \*)base + Bpp);
for (int i=0; i= 0) {
struct fb\_var\_screeninfo vinfo;
if (ioctl(fb, FBIOGET\_VSCREENINFO, &vinfo) == 0) {
uint32\_t bytespp;
if (vinfoToPixelFormat(vinfo, &bytespp, &f) == NO\_ERROR) {
size\_t offset = (vinfo.xoffset + vinfo.yoffset\*vinfo.xres) \* bytespp;
w = vinfo.xres;
h = vinfo.yres;
s = vinfo.xres;
size = w\*h\*bytespp;
mapsize = offset + size;
mapbase = mmap(0, mapsize, PROT\_READ, MAP\_PRIVATE, fb, 0);
if (mapbase != MAP\_FAILED) {
base = (void const \*)((char const \*)mapbase + offset);
}
}
}
close(fb);
}
}
if (base != NULL) {
if (png) {
const SkImageInfo info = SkImageInfo::Make(w, h, flinger2skia(f), kPremul\_SkAlphaType);
SkAutoTUnref data(SkImageEncoder::EncodeData(info, base, s\*bytesPerPixel(f),
SkImageEncoder::kPNG\_Type, SkImageEncoder::kDefaultQuality));
if (data.get()) {
write(fd, data->data(), data->size());
}
if (fn != NULL) {
notifyMediaScanner(fn);
}
} else {
write(fd, &w, 4);
write(fd, &h, 4);
write(fd, &f, 4);
size\_t Bpp = bytesPerPixel(f);
for (size\_t y=0 ; y
```
Пример получения цвета пикселя:
```
./screencap -c 100 100
```
Пример получения изображения по заданной области:
```
./screencap -r /sdcard/test.png 0 0 720 640
```
Данный проект залит на [GitHub](https://github.com/AGENTxXx/improve-screencap-for-android), так что кому интересно — заходите.
P.S. Если вы знаете лучший способ, как найти нужный исходный код исполняемого файла или необходимых библиотек для компиляции — прошу добавить комментарий и я добавлю данный совет в статью. | https://habr.com/ru/post/456264/ | null | ru | null |
# Осторожно, snap
Из к/ф "Иван Васильевич меняет профессию"Использую KeePassXC уже года три. Жил, работал, радовался и проблем не знал с паролями. Решил, что лучше так, чем забуду или каждый раз вспоминать: какой пароль откуда, и где какие цифровые личности.
Недавно решил попробовать функционал, который подсказали коллеги. Это хранение SSH-ключей во вложениях записей и автоматическая загрузка их в SSH-agent операционной системы.
Создал связку приватный-публичный ключ. Добавил во вложение к записи. А дальше в разделе SSH-agent поставил галки и выбрал ключ во вложении. Пара галок в настройках - ошибиться негде.
Меню Сервис-Параметры-SSH-агентСтал проверять загрузку ключа в SSH-agent при открытии базы. Фокус не получился - встретило сухое сообщение: “Сбой подключения агента”.
Ошибка без описания причин сбояПопробовал переопределить *SSH\_AUTH\_SOCK* - не помогло. Стал гуглить подобную проблему и решение. Не буду приводить этот мусор здесь. Чаще проблемы попадались старые или с другим функционалом SSH.
Поиски и попытки выяснить, что я делаю не так заняли три дня. В очередной момент, насторожила мысль, что у коллеги на соседней Kubuntu автоматическая загрузка в SSH-агент работает (он с недоумением смотрел на мои мучения). Закралась мысль: а что, если дело в источнике установки самого KeePassXC?
Спросил у коллеги - и да, он ставил через консоль и подключение репозитория. У меня же ключница из магазина приложений (пользователь, что поделать). Решил перепроверить, зашел в установленные приложения своей Xubuntu и убедился - источник Snap Store.
Удалил приложение и поставил заново, только уже через консоль:
```
sudo add-apt-repository ppa:phoerious/keepassxc
sudo apt-get update
sudo apt install keepassxc
```
После этого останется открыть файл базы и проверить настройки SSH-агента. Затем, зайти в запись и нажать “Добавить в агент”. Всё.
Как итог: дьявол в мелочах. Пользователи Linux - будьте внимательны и осторожны.
А какие у вас были приключения со snap-ами? Поделитесь в комментариях =) | https://habr.com/ru/post/559270/ | null | ru | null |
# Blazor: SPA без джаваскрипта для SaaS на практике
 Когда в любой момент времени стало понятно, что такое this... Когда неявное преобразование типов осталось только в былинах аксакалов эпохи зарождения веба... Когда умные книжки по Javascript нашли свой бесславный конец в мусорках...
Всё это случилось когда мир фронтенда спас Он.
Ну ладно, сбавим обороты у нашей машины пафоса.
Сегодня я предлагаю вам взглянуть на возможности Blazor в версии .Net 6. Внезапно, под катом не будет очередного ПриветМир, а окажется полноценное SaaS веб-приложение, написанное на Блейзоре, пощупав которое вы сможете гораздо лучше оценить: убийца или чижика съел?
Приложение
----------
Мы написали приложение-парсер для поиска рекламной аудитории в социальной сети ВКонтакте, где в качестве фронтенда выступает Blazor в клиентском варианте (WebAssembly). Приложение достаточно простое (всего несколько страниц), тем не менее, в нём удалось реализовать следующий функционал:
* Аутентификация пользователей
* Совместная работа пользователей (тенанты, права доступа)
* Валидация в формах ввода
* Интеграция с внешними Javascript-компонентами
* Использование браузерных API (локальное хранилище, Page Visibility API)
Работающее приложение можно посмотреть здесь: <https://app.venando.ru>
Для любителей обмазаться, исходники доступны здесь: <https://github.com/a-postx/YA.BlazorVkParser>
Приступим к препарированию.
Компоненты
----------
Несмотря на то, что технология WebAssembly (WASM) поддерживается большинством браузеров, скорость её распространения пока достаточно скромная. В случае с Blazor, одним из главных тормозов остаётся скудная система компонентов. Но сегодня (конец 2021-го года) на рынке даже сугубо бесплатных компонентов уже появился какой-никакой выбор.
Мы в своём WASM-клиенте воспользовались одним из самых развитых наборов компонент, который не привязан к конкретному визуальному стеку - [Blazorise](https://blazorise.com). С помощью него можно очень просто создавать компоненты уже под свои конкретные нужды и эти компоненты будут изменяться, если вы решите сменить визуал, скажем, с Bootstrap на Material.
Например, мы хотим создать диалоговое окно подтверждения действия, которое будет открываться пользователю в самых разных местах приложения. Для этого с помощью компонентов Блейзорайса создаём сам компонент
```
@using System.ComponentModel
@using YA.WebClient.Application.Interfaces
@inject IJSRuntime JS
@inject IThemeOptionsState ThemeOptions
@MessageText
Да
Отмена
@code
{
[Parameter]
public string MessageText { get; set; }
[Parameter]
public EventCallback MessageTextChanged { get; set; }
[Parameter]
public Action OnYesAction { get; set; }
[Parameter]
public EventCallback OnYesActionChanged { get; set; }
// если уже открыто, то выпадает исключение, поэтому контролируем это на нашей стороне
public bool IsShowing { get; set; }
private Modal \_modal;
public void Show()
{
if (!IsShowing)
{
\_modal.Show();
IsShowing = true;
}
}
public void Hide()
{
if (IsShowing)
{
\_modal.Hide();
}
}
private void Confirm()
{
Hide();
OnYesAction?.Invoke();
}
private void OnModalClosing(CancelEventArgs e)
{
IsShowing = false;
}
}
```
И используем его во всех нужных местах, задав привязку к соответствующим колбекам.
```
@code
{
private ActionConfirmationModal _confirmationModal;
private string _confirmationText = string.Empty;
private Action _confirmationAction = () => Empty();
private void ShowInvitationDeletionConfirmation(InvitationVm invitation)
{
_confirmationAction = async () => await DeleteInvitation(invitation.YaInvitationID);
_confirmationText = $"Вы действительно хотите отменить приглашение в аккаунт для {invitation.Email}?";
_confirmationModal.Show();
}
private void ShowMembershipDeletionConfirmation(MembershipVm membership)
{
_confirmationAction = async () => await DeleteMembership(membership.MembershipID);
_confirmationText = $"Вы действительно хотите удалить доступ {membership.User?.Email} к этому аккаунту?";
_confirmationModal.Show();
}
}
```
Также просто мы ловим события из дочернего компонента в родительском.
Как вы видите по комментарию в коде, в Blazorise ещё довольно много болячек, но с ними уже можно как-то уживаться.
Несмотря на подобного рода болезни роста, ключевым моментом, который побуждает к использованию Blazor как технологии, остаётся то, что на фронте появляется вся мощь .Net.
Обильный послужной список дотнета в бекенде даёт условному фронтендеру широчайший набор средств по решению тех или иных задач в коде, но когда дело доходит до браузеров, HTML и прочих этих ваших компонентов, то тут уже не всё так радужно.
Безусловно, экосистема Блейзора пока не идёт ни в какое сравнение с джаваскриптовой. Хоть сообщество и активно притаскивает из окружающего мира всё новые компоненты, и дотнетчику в дилемме "взять готовый компонент из сообщества" и "написать компонент самому, погрузившись в Javascript" всё меньше приходится прибегать к последнему варианту, но для сколь-либо масштабного приложения без JS не обойтись.
С другой стороны, в папке js нашего SPA-клиента всего пяток файлов, поэтому в итоге можно сказать, что для написания схожего по функционалу приложения Джаваскрипта уже *почти* не нужно. В кои-то веке кликбейтный заголовок оказался правдой.
Аутентификация
--------------
В нашем проекте хочется обслуживать только аутентифицированных пользователей. Для реализации достаточно в корневом компоненте (App.razor) обрамить приложение в компонент CascadingAuthenticationState, после чего на любой странице (или в компоненте) вы сможете получить текущее состояние аутентификации с помощью проброса параметра AuthenticationState
```
@code
{
[CascadingParameter]
public Task AuthState { get; set; }
}
```
Вам остаётся разместить атрибут [Authorize] в файле \_Imports.razor соответствующего уровня приложения, чтобы закрыть анонимный доступ ко всем нижележащим страницам. Можно также размещать атрибуты на каждой странице, если у вас будут и страницы для анонимусов.
Сама по себе настройка аутентификации в Blazor очень простая и много где описана. В нашем приложении в качестве поставщика мы выбрали Auth0, поскольку не было желания поддерживать свой сервер токенов и дополнительную логику. Единственный нюанс при использовании Auth0 - необходимость указывать аудиторию вашего бекенд-АПИ в дополнительном параметре AdditionalProviderParameters. Если этого не сделать, то вместо JWT-токена на клиент будет возвращаться токен внутреннего формата Auth0, с помощью которого на ваше серверное приложение аутентифицироваться уже не получится.
```
"OauthOptions": {
"Authority": "https://yaapp-80.eu.auth0.com",
"ClientId": "OYXLTT9VPs2Ll6w0e6tOI3g4RAT3fZNS",
"MetadataUrl": "https://yaapp-80.eu.auth0.com/.well-known/openid-configuration",
"RedirectUri": "https://app.venando.ru/authentication/login-callback",
"AdditionalProviderParameters": {
"audience": "https://yaapp-prod.ru"
}
}
```
Состояние
---------
Сервисы в серверной части нашего приложения бессостоятельные, но во фронтальной части без контроля состояния не обойтись. Например, нам надо контролировать какой тарифный план у нашего пользователя в текущем тенанте или какую тему он сейчас выбрал для визуальных элементов.
Поскольку наше приложение достаточно простое и не имеет большого количества изменений состояния из разных компонентов, мы воспользовались простым синглтоном, в котором и стали хранить соответствующее состояние, а также модифицировать его.
```
public class RuntimeState : IRuntimeState
{
public RuntimeState()
{
}
public event EventHandler TenantUpdated;
private TenantVm \_tenant;
private TenantVm Tenant
{
get
{
return \_tenant;
}
set
{
if (value != \_tenant)
{
\_tenant = value;
NotifyTenantUpdated(value);
}
}
}
private void NotifyTenantUpdated(TenantVm tenant)
{
TenantUpdated?.Invoke(this, new TenantUpdatedEventArgs { Tenant = tenant });
}
public TenantVm GetTenant() => Tenant;
public void PutTenant(TenantVm tenant)
{
Tenant = tenant;
}
public void RemoveTenant()
{
Tenant = null;
}
}
```
Компоненты, которые используют модель арендатора, просто подписываются на событие TenantUpdated и выполняют необходимую для себя логику.
Планируете разрабатывать более развесистое приложение? Отлично, тогда вам в помощь будет редукс-подобный контроль состояния - например, проект [Fluxor](https://github.com/mrpmorris/Fluxor).
Мультитенант
------------
Когда нам нужно отделить пользователя от сущностей, которыми он оперирует в приложении, то необходимо добавить слой тенанта. Работа пользователей через абстрактного "арендатора" также даст им возможность шарить сущности между собой, что весьма полезно при создании корпоративных приложений и является частой фишкой продвинутых тарифных планов SaaS-сервисов.
Поскольку аутентификация на бекенде нашего приложения работает через JWT-токены, в клиенте мы добавили шаг по созданию идентификатора арендатора при регистрации нового пользователя: клиент дёргает соответствующий метод сервера, после чего переполучает токен.
На клиенте интересная дилемма возникла при добавлении переключения между тенантами: в Блейзоре существует стандартный механизм переопределения удостоверений пользователя, которым можно воспользоваться, чтобы добавить идентификатор арендатора или любые другие атрибуты.
```
public class CustomUserFactory : AccountClaimsPrincipalFactory
{
public CustomUserFactory(IAccessTokenProviderAccessor accessor) : base(accessor)
{
\_tokenProviderAccessor = accessor;
}
private readonly IAccessTokenProviderAccessor \_tokenProviderAccessor;
private readonly JsonSerializerOptions \_serializerOptions = new() { PropertyNameCaseInsensitive = true };
public override async ValueTask CreateUserAsync(CustomUserAccount account, RemoteAuthenticationUserOptions options)
{
ClaimsPrincipal user = await base.CreateUserAsync(account, options);
if (user.Identity.IsAuthenticated)
{
ClaimsIdentity identity = (ClaimsIdentity)user.Identity;
AccessTokenResult tokenResult = await \_tokenProviderAccessor.TokenProvider.RequestAccessToken();
if (tokenResult.TryGetToken(out AccessToken token))
{
JwtSecurityTokenHandler handler = new();
SecurityToken jsonToken = handler.ReadToken(token.Value);
JwtSecurityToken tokenS = jsonToken as JwtSecurityToken;
Claim metadataClaim = tokenS.Claims.FirstOrDefault(e => e.Type == "http://yaapp.app\_metadata");
if (metadataClaim != null)
{
AppMetadata appMetadata = JsonSerializer
.Deserialize(metadataClaim.Value, \_serializerOptions);
if (!string.IsNullOrEmpty(appMetadata.Tid))
{
identity.AddClaim(new Claim("tid", appMetadata.Tid));
}
}
}
}
return user;
}
}
```
Однако этот механизм работает только при смене статуса пользователя (напр. с НеАутентифицирован на Аутентифицирован), поэтому для переключения между тенантами пользователю приходится делать дополнительный цикл выхода-входа, что ухудшает пользовательский опыт (в случае OAuth цикл не такой уж быстрый).
Ввиду этой печали для работы с арендаторами было решено отказаться от встроенного механизма удостоверений - идентификатор тенанта просто стал частью состояния приложения, что дало полный контроль над механизмом его переключения. Для этого в корне приложения (App.razor) мы добавили компонент UserAndTenantManager, который и отвечает за подготовку состояния перед тем, как пользователь сможет что-то делать в приложении.
```
@\* этап определения пользователя и арендатора, установки состояния.
Из-за асинхронности страницы инициализируются ещё до окончания установки состояния после логина,
поэтому объектам приложения необходимо подписываться на обновления соответствующих данных \*@
@if (context.User.Identity?.IsAuthenticated ?? false)
{
}
else
{
}
```
Интеграции
----------
В любом клиентском приложении скорее рано, чем поздно встаёт вопрос интеграции сторонних JS-компонентов и внешних сервисов. В нашем случае потребовалось прикрутить чат и плеер Ютуба.
С плеером всё получилось достаточно просто, благо в мире Джаваскрипт есть [VideoJs](https://github.com/videojs/video.js). Добавляем в наше приложение скрипт плеера, плагина к нему и мааааленький скриптик
```
```
Скриптик нужен потому что запуск плеера из Blazor не работает, а вот из JS - работает (не спрашивайте меня почему).
Затем на странице мы просто добавляем элемент плеера и передаём в него необходимые параметры.
```
@code
{
private string _playerId;
protected override void OnInitialized()
{
_playerId = "home-player";
base.OnInitialized();
}
protected override async Task OnAfterRenderAsync(bool firstRender)
{
await JS.InvokeVoidAsync("loadPlayer", _playerId, new
{
controls = true,
autoplay = false,
preload = "auto",
width = 640,
height = 360,
techOrder = new[] { "youtube" },
sources = new[] {
new { type = "video/youtube", src = "https://www.youtube.com/watch?v=YhrzIDkNYPk" }
},
youtube = new { ytControls = 2 }
});
await base.OnAfterRenderAsync(firstRender);
}
}
```
Это конечно мало похоже на идеальный код, но что есть то есть.
С чатом повозиться пришлось побольше, но в итоге и он был побеждён. Среди большого количества разработок выбор пал на [Чатру](https://chatra.com/ru/). Для добавления чата в наше Blazor-приложение мы традиционно добавляем их скрипт.
```
window.ChatraSetup = {
startHidden: true
};
(function (d, w, c) {
w.ChatraID = '9Fff8PkPWdEwP6fAG';
var s = d.createElement('script');
w[c] = w[c] || function () {
(w[c].q = w[c].q || []).push(arguments);
};
s.async = true;
s.src = 'https://call.chatra.io/chatra.js';
if (d.head) d.head.appendChild(s);
})(document, window, 'Chatra');
```
Обратите внимание на скрытый виджет при запуске. Мы не хотим, чтобы чат показывался не аутентифицированным пользователям, но при загрузке документа index.html все скрипты оттуда выполняются автоматически, запуская наш чат ещё до того, как запустится WASM. При запуске мы скрываем виджет, а уже после входа пользователя из C# мы дёргаем за ручки управления чатом.
```
@using YA.WebClient.Application.Interfaces
@using YA.WebClient.Application.Models.ViewModels
@using YA.WebClient.Application.Models.Dto
@using YA.WebClient.Extensions
@using YA.WebClient.Application.Events
@inject IJSRuntime JS
@inject IThemeOptionsState ThemeOptions
@inject IRuntimeState RuntimeState
@implements IDisposable
@code
{
[CascadingParameter]
public Task AuthState { get; set; }
[CascadingParameter]
public UserAndTenantManager UserManager { get; set; }
private TenantVm \_userTenant;
private EventHandler \_tenantUpdatedHandler;
protected async override Task OnInitializedAsync()
{
TenantVm tenantVm = UserManager.GetTenant();
if (tenantVm != null)
{
\_userTenant = tenantVm;
}
\_tenantUpdatedHandler = async (s, args) => await RefreshTenantAsync(args);
RuntimeState.TenantUpdated += \_tenantUpdatedHandler;
await ShowSupportChat();
await base.OnInitializedAsync();
}
private async Task RefreshTenantAsync(TenantUpdatedEventArgs args)
{
\_userTenant = args.Tenant;
StateHasChanged();
await ShowSupportChat();
}
private async Task ShowSupportChat()
{
SupportChatUserInfo userInfo = new SupportChatUserInfo();
if (\_userTenant != null)
{
userInfo.TenantId = \_userTenant.TenantId.ToString();
userInfo.ТарифныйПлан = \_userTenant.PricingTier?.Title;
}
AuthenticationState authState = await AuthState;
userInfo.name = !string.IsNullOrEmpty(authState?.User?.Identity?.Name)
? authState?.User?.Identity?.Name
: null;
await JS.InvokeVoidAsync("Chatra", "setIntegrationData", userInfo);
await JS.InvokeVoidAsync("Chatra", "show");
}
public void Dispose()
{
RuntimeState.TenantUpdated += \_tenantUpdatedHandler;
}
}
```
Chatra также позволяет добавлять свои атрибуты в виджет, поэтому мы передаём туда идентификатор арендатора (компонент обновляет его, если пользователь переключился в другой тенант) и его тарифный план, чтобы агент поддержки не запрашивал у пользователя дополнительную информацию.
Таким образом, в Blazor худо-бедно можно использовать сервисы и код с пометкой "только для Javascript", чтобы брать лучшее из двух миров.
А поясни за скорость загрузки
-----------------------------
Демо-приложение <https://app.venando.ru> лежит в статическом хранилище Azure, поверх которого подключён CDN от Майкрософта, поэтому загрузка должна быть достаточно быстрой как во Владивостоке, так и в Калининграде. Желающие могут самостоятельно оценить насколько внезапность загрузки клиента на Blazor отличается от стремительности на вашем любимом фреймворке.
Итоги
-----
Что можно сказать по итогам этого опыта: писать SPA на .Net очень приятно, его возможности дают разработчику отличные инструменты для создания надёжного кода.
Самая большая боль остаётся в долгой перекомпиляции и запуске приложения под дебагом. Хорошая новость в том, что в .Net 6 и VS2022 появилась горячая перезагрузка, которая заметно улучшает эффективность разработчика при дебаге.
Плохая новость в том, что по части производительности всё ещё есть куда стремиться: представленная AOT-компиляция помогает только ценой сильного раздувания размера приложения, что для публичных одностраничников неприемлемо.
Итак: убийца? Пока нет, но технология из разряда "вот поднатореет..."
Пишите в комментариях, насколько плох или хорош Блейзор, поплачем/посмеёмся вместе.
Напоминаю: рассмотреть детальки можно в <https://github.com/a-postx/YA.BlazorVkParser> | https://habr.com/ru/post/586130/ | null | ru | null |
# Работа с большими файлами экселя
Что такое большой файл? Ну так чтобы реально большой? В бытность свою я думал, что это файлик на 50-60 тыс строк записей. И оставался я бы в таком неведении до сих пор, но пришлось выполнять один проект, в котором надо было работать с файлами на 600-800 тыс строк. Хождение по мукам — под катом:
#### Что сначала
А сначала, друзья мои, ринулись мы в самое простое, что можно придумать. Interop.Excell, и все дела. Казалось. Ага, щаз. Как показали тестовые испытания, данный способ открытия приводил к тому, что за час было прочитано 200 тыс строк экселя, приложение активно потребляло оперативку, и раздвигало плечами остальные процессы на машине. Кончилось все ожидаемо, но следственный эксперимент надо было довести до конца — на 260 тысячах приложение свалилось в OutOfMemory на машине с 4 Гб. Стало понятно, что в лоб решить проблему не получится
#### Google it
Сколько нам открытий чудных… Гугль привел, как ни странно, в msdn, где я познакомился с двумя методами открытия очень больших файлов: DOM и SAX. Уж за давностью времен не вспомню, но какой то из них отвалился по причине опостылевшей уже на тот момент OutOfMemory, а второй был совершенно неюзабелен в плане доступа к данным. Почему — читаем ниже.
#### Из чего же, из чего же
Сделаны наши эксельки. Ни для кого, кто решил копнуть формат чуть глубже, не станет секретом, что в отличие от бинарным xls, xlsx — по сути zip архив с данными. Достаточно поменять расширение ручками и распаковать архив в папку — и мы получим всю внутреннюю структуру документа, что есть не что иное, как набор xml файлов и сопутствующей информации. Как оказалось, в корневом xml нет текстовых данных. Вместо этого мы имеем набор индексов, которые ссылаются на вспомогательный файл, в котором представлены пары «ключ/значение» Одним из вышеприведенных способов открыть то файл можно, но при этом нужно копаться в сопутствующих файлах и вытаскивать из них текстовые значения. Мрак.
#### И отступила тьма
После долгих мытарств и стенаний родилось следующее:
Наши любимые юзинги, которые некоторые личности забывают указывать:
``> using System;
>
> using System.Collections.Generic;
>
> using System.Data;
>
> using System.Data.OleDb;
>
> using System.IO;
>
> using System.Linq;
>
> using DocumentFormat.OpenXml;
>
> using DocumentFormat.OpenXml.Packaging;
>
> using DocumentFormat.OpenXml.Spreadsheet;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Собственно, сам код:
``> public delegate void MessageHave(string message);
>
>
>
> public delegate void \_DataLoaded(List<string> data);
>
>
>
> public delegate void \_NewProcent(int col);
>
>
>
> public static \_DataLoaded DataLoaded;
>
>
>
> public static \_NewProcent NewProcent;
>
>
>
> public static MessageHave MessageHave\_Event;
>
>
>
> public static void ReadData(object data)
>
> {
>
> //Приводим объект с переданной парой "имя файла"-"выбранный лист экселя"
>
> var keyValuePair = (KeyValuePair<string, string>)data;
>
> using (var cnn = new OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" +
>
> keyValuePair.Key + @";Extended Properties=""Excel 12.0;HDR=No;IMEX=1""")
>
> )
>
> {
>
> int calc = 1000;
>
> MessageHave\_Event("Открытие соединения провайдера");
>
> cnn.Open();
>
> try
>
> {
>
> var cmd = new OleDbCommand(String.Format("select \* from [{0}]", keyValuePair.Value), cnn);
>
> using (OleDbDataReader dr = cmd.ExecuteReader())
>
> {
>
> var lines = new List<string>();
>
> int id = 0;
>
> if (dr != null)
>
> while (dr.Read())
>
> {
>
> string text = "";
>
> for (int i = 0; i < dr.FieldCount; ++i)
>
> {
>
> if (dr[i] != null)
>
> text += dr[i] + "^";//добавляем разделитель между ячейками
>
> else
>
> text += "^";
>
> }
>
> lines.Add(text);
>
>
>
> id++;
>
> if (id == calc)
>
> {
>
> NewProcent(id);
>
> calc += 1000;
>
> }
>
> }
>
> DataLoaded(lines);
>
> }
>
> cnn.Close();
>
> }
>
> catch (Exception ex)
>
> {
>
> MessageHave\_Event("Exception: " + ex.Message);
>
> cnn.Close();
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Код показал производительность порядка 15-20 минут на файлах в 600-800 тыс строк записей.
Если кому то реализация покажется кривой — сильно не пинать :) Выслушаю все комментарии`` | https://habr.com/ru/post/139706/ | null | ru | null |
# Вредные советы для «идеального» REST API
Всем привет!
**Почему 'идеального' написано в кавычках?!**
То, что написано ниже относится к разряду "так делать не надо", однако, если вы считаете иначе — интересно будет услышать ваше мнение на этот счёт )
Наверное, многие из нас делали REST API, либо пользовались чьим-то готовым. Разберём в статье "невероятные" трюки, которые помогут сделать ваше API на голову выше, чем у других.
### Белый пояс
#### Все значения в json — строка и не иначе!
Ну что ж, возьмём простейший объект:
```
{
"stringValue" : "value",
"intValue": 123
}
```
Вот к чему *123* тут задавать числом, зачем подобная путаница? Пусть будет строкой, десериализатор разберётся:
```
{
"stringValue" : "value",
"intValue": "123"
}
```
Гораздо лучше, не так ли? Хм… А что если у нас объект в качестве значения свойства?
```
{
"stringValue" : "value",
"intValue": "123",
"complexValue": {
"key": "value"
}
}
```
Мда… Непорядок! Надо сделать по-нормальному:
```
{
"stringValue" : "value",
"intValue": "123",
"complexValue": "{
\"key\": \"value\"
}"
}
```
Что? Там ещё одно вложенное свойство? Ну, так в чем проблема? Рецепт есть уже, всё продумано!
```
{
"stringValue" : "value",
"intValue": "123",
"complexValue": "{
\"key\": \"value\",
\"anotherComplexValue\": {
\"superKey\": \"megaValue\"
}
}"
}
```
Вот, везде строка! Не надо заморачиваться с типами! Попарсил строчки и будь здоров!… Что? Библиотека не парсит как надо? Ну, так бери нормальную, которая всё правильно сделает. *complexValue* как строка воспринимается? Ну, это вообще ерунда, очевидно, что там объект, просто грамотно обёрнутый в строку.
#### "Key": Value — это скучно, да и на сеть нагрузка большая...
Если в объекте 2-3 свойства, зачем городить сложный объект? Есть хорошее решение:
```
[
25000,
"Петька",
{
"key1": "value1",
"key2": "value2"
}
]
```
Супер! Надо Петькину зарплату вытащить? Так бери первое значение! Как Петьку зовут? Второе. Так, а с третьим то непорядок!
```
[
25000,
"Петька",
"{
\"key1\": \"value1\",
\"key2\": \"value2\"
}"
]
```
Во! Теперь по уму! А нет, надо же нагрузку снизить на сеть, у нас ведь 5 запросов в секунду:
```
[
25000,
"Петька",
[
"value1",
"value2"
]
]
```
Просто супер! Вот бы весь *json* такой был, цены бы ему не было!
### Желтый пояс
#### Порядок не важен
Если проблемка с последним примером: все значения — строки, помнишь?
```
[
"Петька",
"[
\"value1\",
\"value2\"
]",
"25000"
]
```
Что случилось? Зарплата 3-им значением теперь стала? Ну, да, возможно, но так даже лучше. А какая разница? Там ведь значение 25000, понятно же, что число. Сделать числом? Зачем? Все значения — только строки, запомни!
#### Хранимые процедуры. Ммм… Лакомство
Давай что-нибудь с этим *джейсоном* полезное сделаем. Например, универсальный исполнитель запросов сделаем, без него любой бэкенд не бэкенд. Берём объект:
```
{
"queryType": "select",
"table": "lyudi",
"where": "name = Витька AND zarplata > 15000"
}
```
и в хранимую процедуру его! Она сама разберётся и запрос твой оптимизирует! Где такую взять? А вот сделал добрый человек, пользуйся на здоровье, да добрым словом поминай)
Супер, да?
Не надо спрашивать как это под капотом работает, штука огонь!
Хотя… Постой! Можно же лучше сделать:
```
{
"query": "select * from lyudi where name = Витька AND zarplata > 15000"
}
```
Красота да и только! Что? Обычный запрос проще сделать? А кто права на это даст? Вот есть хранимая процедура для универсального выполнения запросов, права даём только на неё и ей одной родимой и пользуемся. ORM? Это что за база такая? Нет-нет. MSSQL и точка.
### Красный пояс
#### Всё переводим на "хранимки"! Ням-ням
Вот может вопрос возникнуть: при чем тут API и хранимые процедуры? Всё очевидно: избавляемся от накладных расходов! Вызвал *хэпэшку* и вуаля! Поэтому никакого rest'а не надо. Смысл такой: из хранимой процедуры возвращаем несколько курсоров, по ним проходимся и всё готово! И быстро и красиво!
**А где пример сего чуда?!**
Простите, люди добрые, под рукой примера не было, столь он "идеален", что с наскоку не воспроизведу, но ежели сильно нужно, то просьбам вниму, добавлю примерчик)
Ну, а ежели партнёры со сторонних компаний захотят api использовать так vpn можно сделать, пускай тоже по уму делают: хранимые процедуры используют.
### Коричневый пояс
Не надо насчёт коричнего цвета что-то не то думать, это почти чёрный! Высокий уровень то-есть!
#### JSON произвольной структуры
Если с тех. заданием есть проблемы и заказчик не знает до конца чего он хочет, есть отличный метод! Для данных, о которых пока мало-что знаем заготовим объект произвольной структуры:
```
{}
```
Вот так он выглядит на начальном этапе:
```
{
"key1": "value1",
"key2": 2
}
```
потом свойства добавятся:
```
{
"key1": "value1",
"key2": 2,
"key3": {
"123": 456
}
}
```
но ничего страшного, возможно что вообще всё поменяется:
```
{
"objectAsArray": ["Vasya", 123, 456, "Piter"]
}
```
Вот и объект красивый получился! Конфетка просто!
#### Хранение произвольных данных
Тут вообще проблем нет! Произвольный JSON пишем в базу: для этого заводим столбец с типом *VARCHAR(MAX)*. Всё гениальное просто!
#### Оптимизация и ничего кроме!
Вот был раньше формат dbf, отчего про него забыли нынче? Применим!
```
{
"data": "Vasya 123 456 Piter "
}
```
10 символов для имени, 5 для номера квартиры, 5 для номер дома, 20 для города. Универсально, красиво! Да, иногда символы лишние, но зато какая структура красивая!
### Чёрный пояс
#### Быть ближе к железу!
Строка — это что? Массив байтов, ну, так и давайте следовать определению!
```
{
"data": [56, 61, 73, 79, 61, 20, 20, 20, 20, 20, 31, 32, 33, 20, 20, 34, 35, 36, 20, 20, 50, 69, 74, 65, 72, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20]
}
```
Чуть не забыл! Значения должны быть строкой:
```
{
"data": "[56, 61, 73, 79, 61, 20, 20, 20, 20, 20, 31, 32, 33, 20, 20, 34, 35, 36, 20, 20, 50, 69, 74, 65, 72, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20]"
}
```
И универсально, и красиво!
### P.S. Не столь "идеальный" P.S. как всё написанное выше...
Если вам показалось, что автор утрирует и выдумывает, то… Автор хотел бы, чтобы так оно и было. Однако, сталкиваться приходилось с каждым из этих случаев. Давайте уважать друг друга и делать добро, а не какую-то ерунду) Спасибо за внимание, надеюсь, местами было не только грустно, но и весело! | https://habr.com/ru/post/528110/ | null | ru | null |
# Шпоры по сертификатам X.509
> *Чудище обло, озорно, огромно, стозевно и лаяй*.
Набор технологий, который мы по привычке именуем сертификатами SSL, представляет из себя здоровенный айсберг, на вершине которого зеленый замочек слева от доменного имени в адресной строке вашего браузера. Правильное название `X.509 сертификат`, который восходит к `X.500` стандарту ITU-T `DAP (Directory Access Protocol)`. DAP не взлетел, в IETF его посчитали неудобным для использования со всеми этими OSI нагромождениями и вместо него придумали LDAP, Lightweight DAP где первая буква обозначает «легковесный». Те, кому пришлось настраивать, или что хуже производить его отладку могут оценить иронию в полной мере. Никогда еще первая буква аббревиатуры так не лгала, не считая SNMP.
Кстати что общего между LDAP, SNMP и X.509 ну кроме того, что им еще не скоро предстоит собрать стадионы фанатов? Их объединяет **ASN.1** — мета-язык описания объектов древности. Если бы эти технологии создавали сейчас, в ход бы пошли *XML, DTD* или какой-нибудь другой ML. Но в то время стандарты создавались титанами, для которых даже SNMP был простым делом.
Словарный запас
---------------
Определение X.509 сертификатов есть в [архиве ITU-T](http://www.itu.int/rec/T-REC-X.509-200508-S)
```
Certificate ::= SEQUENCE {
tbsCertificate TBSCertificate,
signatureAlgorithm AlgorithmIdentifier,
signatureValue BIT STRING }
TBSCertificate ::= SEQUENCE {
version [0] EXPLICIT Version DEFAULT v1,
serialNumber CertificateSerialNumber,
signature AlgorithmIdentifier,
issuer Name,
validity Validity,
subject Name,
subjectPublicKeyInfo SubjectPublicKeyInfo,
issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL,
-- If present, version MUST be v2 or v3
```
Для того, чтобы досконально понять обозначения и синтаксис, придется читать [спеки X.680 редакции 2008 г.](https://www.itu.int/rec/T-REC-X.680-201403-S!Cor2/en), где есть полное описание **ASN.1**. В понятиях **ASN.1** `SEQUENCE` обозначает примерно то же самое, что и `struct` в Си. Это может сбить с толку, ведь по семантике оно должно было соответствовать скорее массиву. И тем не менее.
Стандарт X.690 определяет следующие правила кодирования структур данных, созданных в соответствии с **ASN.1**: `BER` (Basic Encoding Rules), `CER` (Canonical Encoding Rules), `DER` (Distinguished Encoding Rules). Есть даже `XER` (XML Encoding Rules), [который](https://www.itu.int/en/ITU-T/asn1/Pages/xer.aspx) на практике мне никогда не встречался.
Да, но для чего нужны сертификаты X.509, которые доставляют столько головной боли? **Первая** и основная функция сертификатов X.509 — служить хранилищем *открытого или публичного ключа* PKI (public key infrastructure). К этой функции нареканий нет, а вот со второй не все так однозначно.
**Вторая** функция сертификатов X.509 заключается в том, чтобы предъявитель сего был принят человеком, либо программой в качестве истинного владельца некоего цифрового актива: доменного имени, веб сайта и пр. Это получается по-разному, далеко не все сертификаты имеют высокую ликвидность, если пользоваться финансовой терминологией. Полгода назад Гугл [пригрозил](https://goo.gl/i4ovo5) компании Симантек, что перестанет доверять их сертификатам из-за того, что те выпустили аж 30,000 неисправных сертификатов.
Номенклатура сертификатов
-------------------------
Давайте рассмотрим, какие сертификаты X.509 встречаются в природе, если рассматривать их по расположению в ~~пищевой~~ цепочке доверия.
* **Корневые сертификаты** — изготовлены в корневом УЦ (удостоверяющий центр) и имеют следующие признаки: атрибуты `issue` и `subject` идентичны, а в расширении `basicConstraints` атрибут `cA` принимает значение `TRUE`.
* **Промежуточные сертификаты** — расплывчатый термин, обозначающий сертификаты не подписанные корневым УЦ, которые могут формировать цепочку произвольной длины, начиная от *корневого сертификата* и заканчивая *сертификатом конечного субъекта*.
* **Сертификаты конечного субъекта** — конечные сертификаты в цепочке, которые не могут подписывать другие *промежуточные сертификаты* своим закрытым ключом.
По степени ~~крутизны~~ дороговизны и надежности сертификаты делятся на 3 вида: **DV**, **OV** и **EV**.
* **DV** — сертификаты удостоверения доменного имени получить проще простого. Они выдаются автоматически и моментально после того, как центр сертификации проверит, что заявитель имеет право на доменное имя. Чаще всего для этого достаточно открыть сообщение и перейти по указанной ссылке. Естественно, что сообщение будет отправлено на почтовый ящик с доменным именем, которое следует удостоверить.
* **OV** — в сертификате будет уже указано не доменное имя, а название самой организации заявителя. Тут уже ни а какой автоматической выдачи речи быть не может, это займет несколько рабочих дней. Проверке подлежит наличие в базе `whois` домена название организации заявителя. Могут проверить государственную регистрацию и валидность телефонного номера.
* **EV** — эти сертификаты и получить сложно и стоят они недешево. Их можно опознать по названию организации на зеленом замочке на панели адресной строки.
Редко, кто на это готов раскошелиться. Навскидку Яндекс, StackOverflow.com и Хабр могут жить и без него. Но те, кто готов пойти ради этого на жертвы должны выполнить следующие требования:
1. Аудит правовой, физической и операционной деятельности организации.
2. Следует убедиться в том, что организация имеет эксклюзивное право на использование доменного имени.
3. Следует убедиться в том, что организация авторизована для выпуска сертификата данного типа.
Более подробно можно прочитать в [Хабрапоспе компании TutHost](https://habrahabr.ru/company/tuthost/blog/150433/). Также атрибут `subject` X.509 EV сертификата содержит значения `jurisdictionOfIncorporationCountryName`, `businessCategory`, и `serialNumber`.
По свои свойствам сертификаты бывают следующих типов.
* **Мульти-доменные сертификаты** — сертификат может охватывать несколько доменных имен с помощью `SAN` — атрибута `subjectAltName`.
* **Мульти-хостовые сертификаты** — в тех случаях, когда атрибут `subject` содержит запись `CN=example.net`, в время как DNS сервер может иметь несколько записей `A / AAAA` типа, где одно имя узла может соответствовать нескольким IP адресам. В этом случае сертификат X.509 с одним и тем же `hostname` может быть успешно восстановлен на всех подобных узлах.
* **Сертификаты с возможностью подстановки, wildcard сертификаты** — это когда атрибут `subject` содержит запись `CN=*.example.net`. Действует так же, как и в привычных регулярных выражениях, то есть может быть использован на всех под-доменах `*.example.net`.
* **Квалифицированные сертификаты** — [RFC 3739](https://tools.ietf.org/html/rfc3739) определяет этот термин, как относящийся *персональным* сертификатам, ссылаясь на *Директиву Европейского Союза об электронной подписи*. В частности RFC позволяет в атрибуте `subject` содержать значения:
+ commonName (CN=),
+ givenName (GN=),
+ pseudonym=.
Также `subjectDirectoryAttributes` включает в себя значения:
+ dateOfBirth=,
+ placeOfBirth=,
+ gender=,
+ countryOfCitizenship=,
+ countryOfResidence=.
В России понятие КС *квалифицированного сертификата* [определено законодательно](http://r77.center-inform.ru/support/qualified-certificate/) в связи с доступом к ГосУслугам. По [ссыске](https://habrahabr.ru/post/325998/) Хабрапост с былиной об извлечении персональных данных из КС.
Откуда берутся сертификаты?
---------------------------
Еще совсем недавно было всего 2 способа заполучить X.509 сертификат, но времена меняются и с недавнего времени есть и третий путь.
1. Создать свой собственный сертификат и самому же его подписать. Плюсы — это бесплатно, минусы — сертификат будет принят лишь вами и, в лучшем случае, вашей организацией.
2. Приобрести сертификат в УЦ. Это будет стоить денег в зависимости от различных его характеристик и возможностей, указанных выше.
3. [Получить](https://habrahabr.ru/post/270273/) бесплатный сертификат [LetsEncrypt](https://letsencrypt.org/), доступны только самые простые **DV** сертификаты.
Для первого сценария достаточно пары команд и чтобы 2 раза не вставать создадим сертификат с алгоритмом **эллиптических кривых**. Первым шагом нужно создать закрытый ключ. Считается, что шифрование с алгоритмом эллиптических кривых дает [больший выхлоп](https://blog.cloudflare.com/ecdsa-the-digital-signature-algorithm-of-a-better-internet/), если измерять в тактах CPU, либо байтах длины ключа. Поддержка ECC *не* определена однозначно в TLS < 1.2.
```
openssl ecparam -name secp521r1 -genkey -param_enc explicit -out private-key.pem
```
Далее, создает CSR — запрос на подписание сертификата.
```
openssl req -new -sha256 -key private.key -out server.csr -days 730
```
И подписываем.
```
openssl x509 -req -sha256 -days 365 -in server.csr -signkey private.key -out public.crt
```
Результат можно посмотреть командой:
```
openssl x509 -text -noout -in public.crt
```
`Openssl` имеет огромное количество опций и команд. Man страница не очень полезна, справочник удобнее использовать так:
```
openssl -help
openssl x509 -help
openssl s_client -help
```
Ровно то же самое можно сделать с помощью `java` утилиты `keytool`.
```
keytool -genkey -keyalg RSA -alias selfsigned -keystore keystore.jks -storepass password -validity 360 -keysize 2048
```
Следует серия вопросов, чтобы было чем запомнить поля `owner` и `issuer`
```
What is your first and last name?
What is the name of your organizational unit?
What is the name of your organization?
What is the name of your City or Locality?
What is the name of your State or Province?
What is the two-letter country code for this unit?
Is CN=Johnnie Walker, OU=Unknown, O=Unknown, L=Moscow, ST=Moscow, C=RU correct?
```
Конвертируем связку ключей из проприетарного формата в PKCS12.
```
keytool -importkeystore -srckeystore keystore.jks -destkeystore keystore.jks -deststoretype pkcs12
```
Смотрим на результат:
**keytool -list -v -alias selfsigned -storepass password -keystore keystore.jks**
```
Alias name: selfsigned
Creation date: 20.01.2018
Entry type: PrivateKeyEntry
Certificate chain length: 1
Certificate[1]:
Owner: CN=Johnnie Walker, OU=Unknown, O=Unknown, L=Moscow, ST=Moscow, C=RU
Issuer: CN=Johnnie Walker, OU=Unknown, O=Unknown, L=Moscow, ST=Moscow, C=RU
Serial number: 1f170cb9
Valid from: Sat Jan 20 18:33:42 MSK 2018 until: Tue Jan 15 18:33:42 MSK 2019
Certificate fingerprints:
MD5: B3:E9:92:87:13:71:2D:36:60:AD:B5:1F:24:16:51:05
SHA1: 26:08:39:19:31:53:C5:43:1E:ED:2E:78:36:43:54:9B:EA:D4:EF:9A
SHA256: FD:42:C9:6D:F6:2A:F1:A3:BC:24:EA:34:DC:12:02:69:86:39:F1:FC:1B:64:07:FD:E1:02:57:64:D1:55:02:3D
Signature algorithm name: SHA256withRSA
Subject Public Key Algorithm: 2048-bit RSA key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: 30 95 58 E3 9E 76 1D FB 92 44 9D 95 47 94 E4 97 0.X..v...D..G...
0010: C8 1E F1 92 ....
]
]
```
Значению `ObjectId: 2.5.29.14` соответствует определение ASN.1, согласно [RFC 3280](https://tools.ietf.org/html/rfc3280.html) оно всегда `non-critical`. Точно так же можно узнать смысл и возможные значения других `ObjectId`, которые присутствуют в сертификате X.509.
```
subjectKeyIdentifier EXTENSION ::= {
SYNTAX SubjectKeyIdentifier
IDENTIFIED BY id-ce-subjectKeyIdentifier
}
SubjectKeyIdentifier ::= KeyIdentifier
```
### LetsEncrypt
Можно бесплатно получить X.509 сертификат *LetsEncrypt* и для этого не нужно даже заходить на вебсайт, достаточно установить `certbot`.
```
sudo emerge -av certbot #для Gentoo
sudo apt-get install certbot -t stretch-backports #Debian
sudo dnf install certbot #Fedora
sudo certbot certonly --standalone -d example.com -d www.example.com
```
Сценарий №1 — найти следующего в связке
---------------------------------------
**Связка сертификатов** — Объединение нескольких X.509 сертификатов в один файл, чаще всего в формате `PEM`. Связка передается по сети в момент протокола рукопожатия SSL/TLS.
Самый сок начинается, когда имеете дело со связкой сертификатов, a. k. a `certificate chain`. Часто просматривая лапшу в связке ключей `jks` непросто понять как найти родительский сертификат, когда там россыпь новых и старых сертификатов на несколько доменных имен.
Рассмотрим связку сертификатов `*.novell.com`. Расширение `Authority Key Identifier (AKI)` должно совпадать с `Subject Key Identifier (SKI)` старшего в связке.
```
Certificate Authority Key Identifier
Size: 20 Bytes / 160 Bits
51 68 ff 90 af 02 07 75 3c cc d9 65 64 62 a2 12 b8 59 72 3b
```
Так и есть, `SKI` сертификат DigiCert имеет то же значение.
```
Certificate Subject Key ID
Size: 20 Bytes / 160 Bits
51 68 ff 90 af 02 07 75 3c cc d9 65 64 62 a2 12 b8 59 72 3b
```
Для корневого сертификата `AKI = SKI`, а также `isCa=true`
```
Certificate Basic Constraints
Critical
Is a Certificate Authority
```
Сценарий №2 — используй subjectAltnName, Люк
--------------------------------------------
Вот представьте у вас приложение, использующее веб сервер: вики, WordPress или Cacti. Вы настроили доступ по `https`, приобрели или сами сгенерировали и подписали сертификат. Все должно быть в порядке, но зеленого замочка все равно нет. Браузер подозревает, что сертификат готовили неправильные пчелы, из-за того, что `FQDN` сервера и `hostname`, который указан в адресной строке не совпадают. Так иногда бывает, что DNS сервера указывает на `mars.domain.com`, а веб-сервер настроен на `venus.domain.com`.
Если администратору в силу перфекционизма нужны помимо езды нужны еще и шашечки — вожделенный зеленый замочек, то нужно переделать сертификат X.509, определив в нем `subjectAltName`.
Откройте файл `openssl.cnf` и в секции `req` добавьте следующие линии.
```
[ alternate_names ]
DNS.1 = example.com
DNS.2 = www.example.com
DNS.3 = mail.example.com
DNS.4 = ftp.example.com
```
Далее, в секции `[ v3_ca ]` укажите.
```
subjectAltName = @alternate_names
```
А дальше все как обычно, создаем закрытый ключ и подписываем сертификат.
```
openssl genrsa -out private.key 3072
openssl req -new -x509 -key private.key -sha256 -out certificate.pem -days 730
```
### Использованные материалы
* [Survival guides — TLS/SSL and SSL (X.509) Certificates](http://zytrax.com/tech/survival/ssl.html#x509-usage)
* [Разбираем x.509 сертификат](https://habrahabr.ru/post/194664/)
* [Creating ECDSA SSL Certificates in 3 Easy Steps](https://zonena.me/2016/02/creating-ssl-certificates-in-3-easy-steps/)
* [Implementing SSL/TLS Using Cryptography and PKI](https://www.safaribooksonline.com/library/view/implementing-ssltls-using/)
* [Certificate Chaining Engine — how it works](https://www.sysadmins.lv/blog-en/certificate-chaining-engine-how-this-works.aspx)
* [How can I generate a self-signed certificate with SubjectAltName using OpenSSL? [closed]](https://stackoverflow.com/questions/21488845/how-can-i-generate-a-self-signed-certificate-with-subjectaltname-using-openssl) | https://habr.com/ru/post/346798/ | null | ru | null |
# Как мы развернули коммунальный Apache Airflow для 30+ команд и сотни разработчиков
Всем привет!
В этой статье я расскажу, как мы внедряли сервис Apache Airflow для использования различными командами в нашей компании, какие задачи мы хотели решить этим сервисом, опишу архитектуру деплоя и наш IaC (Infrastructure as Code).
До того как у нас в data платформе появился Airflow регламентные процессы запускались или вручную, или настраивался регулярный запуск задач через NiFi, что вызывало определенные неудобства: невозможно было отслеживать state задач, логи работы задач не были недоступны через интерфейс, да и в целом, NiFi как инструмент предназначен для задач потоковой обработки данных.
Поэтому было принято решение внедрить более специализированный инструмент от которого требовалось запускать задачи по расписанию с возможностью перезапуска, контролем статуса и уведомлением всех заинтересованных сторон. Также нужно было обеспечить разделение доступов для пользователей по выполняемым задачам, поскольку на кластере работают разные команды.
При выборе мы рассматривали Oozie и Airflow. И выбрали [Apache Airflow](https://airflow.apache.org) по причине наличия у нас в команде практик по работе с этим инструментом, и как одно из самых используемых и развивающихся open source решений для оркестрации процессов работы с данными.
### Структура сервиса
Ниже приведена текущая схема деплоя и связей компонентов платформенного кластера Apache Airflow:
Сервисы Airflow развёрнуты в Docker контейнерах на VM в облаке. В качестве базы данных используется PostgreSQL и Redis как MQ (мы используем Airflow CeleryExecutor).
Логи DAGов сохраняются на S3 через настройки Airflow, логи самих сервисов (Docker контейнеров) через Fluentd пересылаются в Elasticsearch.
Пользователи обращаются через reverse proxy (Nginx) к развёрнутым инстансам Airflow Webserver.
### Модули
Набор DAG’ов, который относится к одной команде разработки или имеет общие библиотеки-зависимости, мы называем модулем и для каждого такого модуля разработчики создают отдельный репозиторий GIT (module-репозиторий).
Репозитории в общем случае имеют следующую структуру:
```
├── dags/
├── tests/
├── Dockerfile
├── Jenkinsfile
└── requirements.txt
```
* `dags/` — в этот каталог, как вы уже догадались, мы помещаем все разработанные DAGи.
* `tests/` — опциональный каталог, в который разработчики могут поместить свои тесты, которые запустятся во время pipeline.
* `requirements.txt` — здесь разработчики указывают свои Python зависимости для установки в Docker образ.
* `Dockerfile` — инструкции для сборки образа. В общем случае он почти всегда один и тот-же, и наследуется с нашего базового образа Apache Airflow.
* `Jenkinsfile` — инструкции для самого pipeline, который у нас запускается через Jenkins.
В результате pipeline каждого такого module-репозитория собирается Docker образ с необходимыми зависимостями. Эти образы в дальнейшем будут используются для запуска контейнеров Airflow Worker.
Стоит заметить, что тесты запускаются на нашем базовом образе Apache Airflow, чтобы проверить логику импорта python зависимостей. Поскольку зависимости у каждого модуля свои и находятся только в образе Worker, то необходимо проверить, что Airflow сможет корректно импортировать такие DAGи на базовых образах. Для этого все импорты кастомных библиотек разработчики выполняют внутри PythonOperator.
Например:
```
from airflow.operators.python_operator import PythonOperator
dag = DAG(
# ...
)
def myfunc():
import hvac
# Code with hvac lib goes here...
my_task = PythonOperator(
task_id='my_task_id',
python_callable=myfunc,
dag=dag)
my_task
```
> Для интересующихся, советую к прочтению статью об опыте наших data-инженеров по разработке самогенерирующихся DAGов на основе метаданных - [DAG’и без напрягов: наш опыт использования метаданных при работе с Apache Airflow](https://habr.com/ru/company/leroy_merlin/blog/564276/).
>
>
### Deploy репозиторий
Доставку и настройку компонентов Airflow мы производим через Ansible, конфигурации которого хранятся в отдельном *deploy-репозитории*.
У deploy-репозитория есть свой pipeline, который в результате публикует в наш Docker Registry образ с необходимыми ansible конфигурациями для деплоя. На основе этого образа производится запуск docker container, из которого производится выполнения установок (как через pipeline, так и локально).
Репозиторий с Ansible конфигурацией в общем случае имеет следующую структуру:
```
├── group_vars
│ ├── all/
│ ├── stage/
│ ├── prod/
├── playbooks/
├── plugins/
├── roles/
│ ├── requirements.yml
├── Dockerfile
├── ansible.cfg
├── inventory.stage
└── inventory.prod
```
* `group_vars` — переменные для разных окружений.
* `playbooks` — ansible playbooks файлы.
* `roles/requirements.yml` — конфиг с используемыми ansible ролями и их версиями (устанавливаем через ansible-galaxy).
* `Dockerfile` — инструкция для сборки образа с установленным ansible и всеми конфигурациями для него.
* `аnsible.cfg` — конфигурация ansible.
* `inventory.*` — inventory файлы ansible для разных окружений.
### Modules deploy pipeline
У каждого *module-репозитория* есть свой pipeline, результатом которого является опубликованный (в Docker Registry) образ со всеми конфигурациями Ansible (roles, playbooks, vars, plugins и т.д.) для запуска. Этот образ используется для запуска контейнера, в котором и выполняется ansible-playbook.
В каждом отдельном module-репозитории по различным событиям GIT запускаются соответствующие pipeline. На схеме ниже приведён самый распространённый из всех:
1. Pull request в main/master ветки запускает только проверку сборки Docker образа и тесты.
2. Push в main/master ветку запускает сборку и публикацию Docker образа (в Docker Registry) с latest версией, и следом деплой на Stage кластер Airflow.
3. Установка тега запускает сборку и публикацию Docker образа и релиз модуля на Airflow Prod.
Чтобы построить такую схему деплоя с использованием Jenkins, мы используем Jenkins Pipeline Library репозиторий. Таким образом сам Jenkinsfile в module-репозиториях предельно простой:
```
@Library(['dp--jenkins-pipe-libs@main']) _
AirflowPipeline()
```
Причём настройки уникальные для module-репозитория всегда можно передать параметром в функцию вызова pipeline. Например, в следующем Jenkinsfile указано, что DAGи нужно будет устанавливать сразу на два кластера:
```
@Library(['dp--jenkins-pipe-libs@main']) _
AirflowPipeline(deployClusters: ['communal', 'hi42'])
```
Весь код pipeline храниться и обновляется отдельно от репозиториев модулей. Это позволяет легко модифицировать deploy pipeline централизованно, без обновлений в module-репозиториях.
### Airflow cluster configuration
Всю конфигурацию для Airflow мы передаём через environment variables для запускаемых Docker контейнеров. Конфигурация содержится в deploy-репозитории, в который обычные пользователи не контрибьютят.
Для каждого модуля так же существует конфигурация, в которой мы указываем какие worker для этого модуля нужно развернуть, на каких хостах, с какими переменными или секретами внутри.
Т.к. кластер коммунальный, а в Airflow нет гибкого RBAC для разграничения доступа на создание и изменение подключений, настройки подключений производятся администраторами кластера по запросам пользователей.
Пример для конфигурации одного модуля, для которого деплоятся два Airflow Worker с разными очередями и конфигами:
```
raw_to_ods:
- id: raw_to_ods
# Название группы ansible куда нужно установить Worker.
hosts_group: airflow_worker_raw2ods_tpnet
# Celery очереди которые будет обслуживать Worker.
queues: "raw_to_ods__tpnet,raw_to_ods__nav"
# Hostname для красивого отображения в Airflow Flower.
hostname: "{{ inventory_hostname_short }}"
# Expose порты Worker для отображения логов online в UI Airflow.
ports: ["8793:8793"]
# Секреты и подключения для работы DAG.
env:
AIRFLOW_CONN_GP_DUMMY1_ETLBOT: "..."
- id: raw_to_ods
hosts_group: airflow_worker_default
container_name: raw_to_ods_dr
queues: "raw_to_ods__other_dr"
hostname: "{{ inventory_hostname_short }}"
env:
AIRFLOW_CONN_GP_DUMMY2_ETLBOT: "..."
```
### Pools, variables and roles
Для предоставления пользователям возможности задавать на кластерах необходимые переменные, пулы или роли у нас используется разработанный в компании сервис metadata. Сервис представляет собой приложение, которое преобразует загруженные yaml файлы и отдаёт их в JSON формате через REST API.
Все yaml файлы находятся в репозитории GIT и пользователи кластера контрибьютят в соответствующие yaml конфигурации для изменения общих параметров кластера.
В самом Airflow присутствуют технические даги, которые синхронизируют мету, указанную пользователями, в роли, переменные и пулы Airflow.
### Технические DAG
Помимо дагов, которые синхронизируют некоторые параметры кластеров (см. главу Pools, variables and roles) нами написан canary DAG для мониторинга задержек между запусками task внутри DAGов.
Сам DAG не выполняет никакой работы, просто запускает dummy задачи каждые 15 минут.
Код DAGа:
```
import os
import time
import airflow
from airflow import DAG
from airflow.operators.python_operator import PythonOperator
MODULE_NAME = "tech"
DAG_ID = (
MODULE_NAME
+ "__"
+ os.path.basename(__file__).replace(".pyc", "").replace(".py", "")
)
dag = DAG(
dag_id=DAG_ID,
description="Canary Ariflow dag for monitoring",
default_args={
"email_on_failure": True,
"email_on_retry": False,
"start_date": airflow.utils.dates.days_ago(1),
"queue": MODULE_NAME,
"retries": 1,
},
max_active_runs=1,
schedule_interval="*/15 * * * *",
catchup=False,
is_paused_upon_creation=True,
tags=["tech", "airflow"],
access_control={"dataplatform": {"can_dag_edit"}},
)
def sleep10():
time.sleep(10)
def sleep20():
time.sleep(20)
def sleep30():
time.sleep(30)
t1 = PythonOperator(
task_id="t1",
python_callable=sleep10,
dag=dag,
)
t2 = PythonOperator(
task_id="t2",
python_callable=sleep20,
dag=dag,
)
t3 = PythonOperator(
task_id="t3",
python_callable=sleep30,
dag=dag,
)
t1 >> t2 >> t3
```
Работу этого DAG’а анализирует Airflow Exporter (см. главу про мониторинг ниже) и отдаёт метрику `airflow_dag_task_lag`, которая показывает средний лаг между dummy-задачами. Эта метрика позволяет нам выявить проблемы взаимодействия компонент сервиса.
### Плагины
Мы собрали базовый Docker образ на основе официально образа от Apache Airflow (c этого образа наследуют все module-репозитории). В этот образ, в том числе, входят несколько написанных нами плагинов.
#### Modules view plugin
Чтобы пользователи могли увидеть, какая версия их DAG’ов установлена на кластер, мы разработали плагин, который отображает модули и установленные версию на кластер.
#### RBAC API plugin
В нашей команде есть сервис по централизованному управлению доступами к сервисам платформы и нам требовалось выдавать доступы на кластера Airflow через API.
В используемой нами версии Airflow 1.10.14 отсутствует rest api по управлению доступом, поэтому мы написали плагин для grant и revoke Airflow ролей у пользователей через rest api и используем его для автоматизаций.
### Мониторинг
В команде используется Prometheus, как хранилище метрик и для мониторинга кластеров мы разработали свой собственный Prometheus Exporter с нужными нам метриками.
Exporter содержит общие метрики по состоянию кластера для SRE платформы. Например:
* Состояние компонент кластера (webserver/scheduler/metadatabase);
* Состояние запущенных Celery Worker (через Flower API);
* Кол-во запущенных задач на кластере;
* Лаг между задачами внутри DAG (см. Главу Технические DAG);
* Размеры и использование Airflow Pool;
* Кол-во XCOM;
* Кол-во ошибок импорта DAGов;
* и т.п.
Также exporter предоставляет метрики для команд, которые хотят настроить свои собственные алерты по разработанным DAG. Например, метрика, показывающая статус DAG или лаг с момента последнего запуска DAG.
### Заключение
На текущий момент по описанным выше методам и конфигурациям у нас установлены и успешно используются и сопровождаются три кластера: коммунальные кластера (stage и prod окружения) и кластер для отдельного проекта.
Мы считаем, что выбор и использование Apache Airflow как инструмента оправдало себя. Сервис стабилен и успешно справляется с выполняемыми задачами, и возлагаемой на него нагрузкой.
Стоит заметить, что в большинстве случаев мы используем Airflow в основном как оркестратор процессов. Основные операционные нагрузки на текущий момент находятся на стороне Greenplum и сервисах-источниках.
> Узнать больше о нашем хранилище и в целом об архитектуре платформы можно [здесь](https://habr.com/ru/company/leroy_merlin/blog/561072/)
>
>
Но так же на Airflow выполняются и задачи, несущие ресурсную нагрузку типа MLOps, которые выполняются на отдельных Airflow Worker.
> Подробнее про то как наши data scientist’ы строят свои data-pipeline можно посмотреть [здесь](https://youtu.be/6U6siWhR5sw).
>
>
Немного статистики:
* На прод окружении коммунального кластера создано ~ 700 DAGов;
* В среднем ~100 одновременно работающих DAG (~70 одновременно запущенных DAG task, ~65000 DAG tasks за день;
* В базе хранится ~300K XCOM;
* Порядка 100 пользователей в Airflow Webserver;
Со всем этим успешно справляются (и даже с запасом):
* VM (Airflow Scheduler) - 8 vCPU 8 GB RAM;
* VM (Airflow Webserver) - 4 vCPU 6 GB RAM;
* Postgres 12 - 8 vCPU, 32 GB RAM (на этом кластере живут два прод кластера Airflow; Сама БД Airflow текущим размером в 45 GB);
* Redis 5 - 2 vCPU, 8 GB RAM;
Некоторые параметры тюнинга процессов Airflow, что мы используем на указанных выше ресурсах, без тюнинга которых невозможно добиться производительности кластера:
```
AIRFLOW__CORE__DAG_CONCURRENCY: "200"
AIRFLOW__CORE__PARALLELISM: "200"
AIRFLOW__SCHEDULER__PARSING_PROCESSES: "40"
AIRFLOW__SCHEDULER__JOB_HEARTBEAT_SEC: "5"
AIRFLOW__SCHEDULER__SCHEDULER_HEARTBEAT_SEC: "5"
AIRFLOW__SCHEDULER__SCHEDULER_HEALTH_CHECK_THRESHOLD: "120"
AIRFLOW__SCHEDULER__DAG_DIR_LIST_INTERVAL: "300"
AIRFLOW__SCHEDULER__PRINT_STATS_INTERVAL: "0"
AIRFLOW__SCHEDULER__SCHEDULER_ZOMBIE_TASK_THRESHOLD: "300"
# Restart scheduler every 8 hours
AIRFLOW__SCHEDULER__RUN_DURATION: "28800"
AIRFLOW__WEBSERVER__DEFAULT_DAG_RUN_DISPLAY_NUMBER: "5"
AIRFLOW__WEBSERVER__PAGE_SIZE: "25"
AIRFLOW__WEBSERVER__WEB_SERVER_WORKER_TIMEOUT: "300"
AIRFLOW__WEBSERVER__WEB_SERVER_MASTER_TIMEOUT: "300"
```
Из планов на будущее:
* Конечно же обновление на Airflow 2.x (хотим отказоустойчивый Scheduler).
* Переезд в Kubernetes для отказоустойчивости и более оптимального использования ресурсов в облаках. | https://habr.com/ru/post/580944/ | null | ru | null |
# Визуализация данных при помощи Angular и D3
D3.js — это JavaScript библотека для манипулирования документами на основе входных данных. Angular — фреймворк, который может похвастаться высокой производительностью привязки данных.
Ниже я рассмотрю один хороший подход по использованию всей этой мощи. От симуляций D3 до SVG-инъекций и использования синтаксиса шаблонизатора.
*Демо: положительные числа до 300 соединенные со своими делителями.*
Для кулхацкеров, которые не будут читать данную статью, ссылка на репозиторий с кодом примера находится ниже. Для всех же остальных середнячков (конечно же, это не ты) код в этой статье упрощен для удобочитаемости.
[Исходный код](https://github.com/lsharir/angular-d3-graph-example) (недавно обновлен до Angular 5)
[Демо](https://lsharir.github.io/angular-d3-graph-example/)
Как запросто делать такие крутые ништяки
----------------------------------------
Ниже я представлю один подход к использованию Angular+D3. Мы пройдем следующие шаги:
1. Инициализация проекта
2. Создание интерфейсов d3 для angular
3. Генерация симуляции
4. Привязка данных симуляции к документу через angular
5. Привязка пользовательского взаимодействия к графу
6. Оптимизация производительности через механизм отслеживания изменений(change detection)
7. Публикация и нытье по поводу стратегии версионирования angular
Итак, открывайте свой терминал, запускайте редакторы кода и не забудьте разгореть буфер обмена, начинаем погружение в код.
### Структура приложения
Мы отделим код связанный с d3 и svg. Я опишу все поподробнее, когда будут созданы необходимые файлы, а пока вот структура нашего будущего приложения:
```
d3
|- models
|- directives
|- d3.service.ts
visuals
|- graph
|- shared
```
### Инициализация Angular приложения
Запустите проект Angular приложения. Angular 5, 4 или 2 наш код был протестирован на всех трех версиях.
Если у вас еще нет angular-cli, быстренько его установите
```
npm install -g @angular/cli
```
Затем сгенерируйте новый проект:
```
ng new angular-d3-example
```
Ваше приложение создастся в папке `angular-d3-example`. Запустите команду `ng serve` из корня этой директории, приложение будет доступно по адресу `localhost:4200`.
### Инициализация D3
Не забудьте установить и его TypeSctipt объявление.
```
npm install --save d3
npm install --save-dev @types/d3
```
### Создание интерфейсов d3 для angular
Для корректного использования d3 (или любой другой библиотек) внутри фреймворка, лучше всего взаимодействовать через кастомный интферфейс, который мы определим посредством классов, angular сервисов и директив. Поступая таким образом, мы отделим главную функциональность от компонентов, которые будут ее использовать. Это сделает структуру нашего приложения более гибкой и масштабируемой, и изолирует баги.
Наша папка с D3 будеть иметь следующую структуру:
```
d3
|- models
|- directives
|- d3.service.ts
```
`models` обеспечат безопасность типов и будут предоставлять объекты datum.
`directives` будут указывать элементам, как использовать функционал d3.
`d3.service.ts` предоставит все методы, в пользование моделям d3, директивам, а также внешним компонентам приложения.
Этот сервис будет содержать вычислительные модели и поведения. Метод `getForceDirectedGraph` будет возвращать экземпляр ориентированного графа. Методы `applyZoomableBehaviour` и`applyDraggableBehaviour` позволят связать пользовательское взаимодействие с соответствующими поведениями.
```
// path : d3/d3.service.ts
import { Injectable } from '@angular/core';
import * as d3 from 'd3';
@Injectable()
export class D3Service {
/** This service will provide methods to enable user interaction with elements
* while maintaining the d3 simulations physics
*/
constructor() {}
/** A method to bind a pan and zoom behaviour to an svg element */
applyZoomableBehaviour() {}
/** A method to bind a draggable behaviour to an svg element */
applyDraggableBehaviour() {}
/** The interactable graph we will simulate in this article
* This method does not interact with the document, purely physical calculations with d3
*/
getForceDirectedGraph() {}
}
```
### Ориентированный граф(Force Directed Graph)
Приступим к созданию класса ориентированного графа и сопутствующих моделей. Наш граф состоит из вершин(nodes) и дуг(links), давайте определим соответствующие модели.
```
// path : d3/models/index.ts
export * from './node';
export * from './link';
// To be implemented in the next gist
export * from './force-directed-graph';
```
```
// path : d3/models/link.ts
import { Node } from './';
// Implementing SimulationLinkDatum interface into our custom Link class
export class Link implements d3.SimulationLinkDatum {
// Optional - defining optional implementation properties - required for relevant typing assistance
index?: number;
// Must - defining enforced implementation properties
source: Node | string | number;
target: Node | string | number;
constructor(source, target) {
this.source = source;
this.target = target;
}
}
```
```
// path : d3/models/node.ts
// Implementing SimulationNodeDatum interface into our custom Node class
export class Node extends d3.SimulationNodeDatum {
// Optional - defining optional implementation properties - required for relevant typing assistance
index?: number;
x?: number;
y?: number;
vx?: number;
vy?: number;
fx?: number | null;
fy?: number | null;
id: string;
constructor(id) {
this.id = id;
}
}
```
После объявления основных моделей манипуляцией графом, давайте объявим модель самого графа.
```
// path : d3/models/force-directed-graph.ts
import { EventEmitter } from '@angular/core';
import { Link } from './link';
import { Node } from './node';
import * as d3 from 'd3';
const FORCES = {
LINKS: 1 / 50,
COLLISION: 1,
CHARGE: -1
}
export class ForceDirectedGraph {
public ticker: EventEmitter> = new EventEmitter();
public simulation: d3.Simulation;
public nodes: Node[] = [];
public links: Link[] = [];
constructor(nodes, links, options: { width, height }) {
this.nodes = nodes;
this.links = links;
this.initSimulation(options);
}
initNodes() {
if (!this.simulation) {
throw new Error('simulation was not initialized yet');
}
this.simulation.nodes(this.nodes);
}
initLinks() {
if (!this.simulation) {
throw new Error('simulation was not initialized yet');
}
// Initializing the links force simulation
this.simulation.force('links',
d3.forceLink(this.links)
.strength(FORCES.LINKS)
);
}
initSimulation(options) {
if (!options || !options.width || !options.height) {
throw new Error('missing options when initializing simulation');
}
/\*\* Creating the simulation \*/
if (!this.simulation) {
const ticker = this.ticker;
// Creating the force simulation and defining the charges
this.simulation = d3.forceSimulation()
.force("charge",
d3.forceManyBody()
.strength(FORCES.CHARGE)
);
// Connecting the d3 ticker to an angular event emitter
this.simulation.on('tick', function () {
ticker.emit(this);
});
this.initNodes();
this.initLinks();
}
/\*\* Updating the central force of the simulation \*/
this.simulation.force("centers", d3.forceCenter(options.width / 2, options.height / 2));
/\*\* Restarting the simulation internal timer \*/
this.simulation.restart();
}
}
```
Раз уж мы определили наши модели, давайте также обновим метод `getForceDirectedGraph` в `D3Service`
```
getForceDirectedGraph(nodes: Node[], links: Link[], options: { width, height} ) {
let graph = new ForceDirectedGraph(nodes, links, options);
return graph;
}
```
Создание экземпляра `ForceDirectedGraph` вернет следующий объект
```
ForceDirectedGraph {
ticker: EventEmitter,
simulation: Object
}
```
Этот объект содержит свойство `simulation` с переданными нами данными, а также свойство `ticker` содержащее event emitter, который срабатывает при каждом тике симуляции. Вот как мы будем этим пользоваться:
```
graph.ticker.subscribe((simulation) => {});
```
Остальные методы класса `D3Service` мы определим попозже, а пока попробуем привязять данные объекта `simulation` к документу.
### Привязка симуляции
У нас есть экземляр объекта `ForceDirectedGraph`, он содержит постоянно-обновляемые данные вершин(node) и дуг(link). Вы можете привязать эти данные к документу, по-d3'шному (как дикарь):
```
function ticked() {
node
.attr("cx", function(d) { return d.x; })
.attr("cy", function(d) { return d.y; });
}
К счастью, на улице 21ый век, человечество эволюционировало к использованию инструментов эффективной привязки данных, вместо бездумного изменения аттрибутов элементов. Вот где Angular засверкает своими мышцами.
### *Интермедия: SVG и Angular*
### SVG шаблонизация с Angular
Запоздалая имплементация SVG, вылилась в создание ограничивающего пространства имен svg внутри html документа. Вот почему Angular не может распознать объявленные SVG элементы в темплейтах Angular компонентов (Если только они не есть явными потомками тега `svg`).
Чтобы правильно скомпилировать наши SVG элементы у нас есть два варианта:
1. Занудно держать их всех внутри тега `svg`.
2. Добавлять префикс “svg”, чтобы объяснить Angular'у, что происходит
```
app.component.html
link-example.component.html
### SVG компоненты в Angular
Назначение селекторов компонентам, которые находятся в пространстве имен SVG не будет работать, как обычно. Они могут быть применены только через селектор аттрибута
```
```
app.component.html
```
import { Component } from '@angular/core';
@Component({
selector: '[lineExample]',
template: ``
})
export class LineExampleComponent {
constructor() {}
}
```
link-example.component.ts
*Заметьте префикс svg в шаблоне компонента*
### *Конец интермедии*
### Привязка симуляции — визуальная часть
Вооружившись древним знаением svg, мы можем начать создавать компоненты, которые будут одображать наши данные. Изолировав их в папке `visuals`, затем мы создадим папку `shared` (куда поместим компоненты, которые могут быть использованны другими видами графов) и главную папку `graph`, которая будет содержать весь код необходимый для отображения ориентированного графа (Force Directed Graph).
```
visuals
|- graph
|- shared
```
### Визуализация графа
Создадим наш корневой компонент, который будет генерировать граф и привязывать его к документу. Мы передаем ему вершины(nodes) и дуги(links) через input-аттрибуты компонента.
Компонент принимает свойства `nodes` и `links` и создает экземпляр класса `ForceDirectedGraph`
```
// path : visuals/graph/graph.component.ts
import { Component, Input } from '@angular/core';
import { D3Service, ForceDirectedGraph, Node } from '../../d3';
@Component({
selector: 'graph',
template: `
`,
styleUrls: ['./graph.component.css']
})
export class GraphComponent {
@Input('nodes') nodes;
@Input('links') links;
graph: ForceDirectedGraph;
constructor(private d3Service: D3Service) { }
ngOnInit() {
/** Receiving an initialized simulated graph from our custom d3 service */
this.graph = this.d3Service.getForceDirectedGraph(this.nodes, this.links, this.options);
}
ngAfterViewInit() {
this.graph.initSimulation(this.options);
}
private _options: { width, height } = { width: 800, height: 600 };
get options() {
return this._options = {
width: window.innerWidth,
height: window.innerHeight
};
}
}
```
### Компонент NodeVisual
Дальше, давайте добавим компонент для визуализации вершины(node), он будет отображать кружок с id вершины.
```
// path : visuals/shared/node-visual.component.ts
import { Component, Input } from '@angular/core';
import { Node } from '../../../d3';
@Component({
selector: '[nodeVisual]',
template: `
{{node.id}}
`
})
export class NodeVisualComponent {
@Input('nodeVisual') node: Node;
}
```
### Компонент LinkVisual
А вот и компонент для визуализации дуги(link):
```
// path : visuals/shared/link-visual.component.ts
import { Component, Input } from '@angular/core';
import { Link } from '../../../d3';
@Component({
selector: '[linkVisual]',
template: `
`
})
export class LinkVisualComponent {
@Input('linkVisual') link: Link;
}
```
### Поведения
Вернемся как к d3-части приложения, начнем создание директив и методов для сервиса, которые дадут нам крутые способы взаимодействия с графом.
### Поведение — зум
Добавим-ка привязки для функции зума, так чтобы потом это можно было запросто использовать:
```
```
```
// path : d3/d3.service.ts
// ...
export class D3Service {
applyZoomableBehaviour(svgElement, containerElement) {
let svg, container, zoomed, zoom;
svg = d3.select(svgElement);
container = d3.select(containerElement);
zoomed = () => {
const transform = d3.event.transform;
container.attr("transform", "translate(" + transform.x + "," + transform.y + ") scale(" + transform.k + ")");
}
zoom = d3.zoom().on("zoom", zoomed);
svg.call(zoom);
}
// ...
}
```
```
// path : d3/directives/zoomable.directive.ts
import { Directive, Input, ElementRef } from '@angular/core';
import { D3Service } from '../d3.service';
@Directive({
selector: '[zoomableOf]'
})
export class ZoomableDirective {
@Input('zoomableOf') zoomableOf: ElementRef;
constructor(private d3Service: D3Service, private _element: ElementRef) {}
ngOnInit() {
this.d3Service.applyZoomableBehaviour(this.zoomableOf, this._element.nativeElement);
}
}
```
### Поведение—перетаскивание
Для добавления возможности перетаскивани, нам необходимо иметь доступ к объекту симуляции, чтобы можно было приостанавливать прорисовку при перетаскивании.
```
```
```
// path : d3/d3.service.ts
// ...
export class D3Service {
applyDraggableBehaviour(element, node: Node, graph: ForceDirectedGraph) {
const d3element = d3.select(element);
function started() {
/** Preventing propagation of dragstart to parent elements */
d3.event.sourceEvent.stopPropagation();
if (!d3.event.active) {
graph.simulation.alphaTarget(0.3).restart();
}
d3.event.on("drag", dragged).on("end", ended);
function dragged() {
node.fx = d3.event.x;
node.fy = d3.event.y;
}
function ended() {
if (!d3.event.active) {
graph.simulation.alphaTarget(0);
}
node.fx = null;
node.fy = null;
}
}
d3element.call(d3.drag()
.on("start", started));
}
// ...
}
```
```
// path : d3/directives/draggable.directives.ts
import { Directive, Input, ElementRef } from '@angular/core';
import { Node, ForceDirectedGraph } from '../models';
import { D3Service } from '../d3.service';
@Directive({
selector: '[draggableNode]'
})
export class DraggableDirective {
@Input('draggableNode') draggableNode: Node;
@Input('draggableInGraph') draggableInGraph: ForceDirectedGraph;
constructor(private d3Service: D3Service, private _element: ElementRef) { }
ngOnInit() {
this.d3Service.applyDraggableBehaviour(this._element.nativeElement, this.draggableNode, this.draggableInGraph);
}
}
```
Итак, что мы в итоге имеем:
1. Генерация графа и симуляция через D3
2. Привязка данных симуляции к документу при помощи Angular
3. Пользовательское взаимодействие с графом через d3
Вы наверняка сейчас думаете: “Мои данные симуляции постоянно изменяются, angular при помощи отслеживания изменений(change detection) постоянно привязывает эти данные к документу, но зачем мне так делать, я хочу самостоятельно обновлять граф после каждого тика симуляции.”
Ну, вы отчасти правы, я сравнил результаты тестов производительности при разных механизмах отслеживания изменений и оказывается, что при потиковом применении изменений, мы получаем хороший прирост в производительности.
Angular, D3 и отслеживание изменений(Change Detection)
------------------------------------------------------
Установим отслеживание изменений в метод onPush (изменения будут отслежены только при полной замене ссылок на объекты).
Ссылки на объекты вершин и дуг не изменяются, соответсвенно и изменения не будут отслежены. Это замечательно! Теперь мы можем контроллировать отслеживание изменений и отмечать его на проверки при каждом тике симуляции (используя event emitter тикера, который мы установили).
```
import {
Component,
ChangeDetectorRef,
ChangeDetectionStrategy
} from '@angular/core';
@Component({
selector: 'graph',
changeDetection: ChangeDetectionStrategy.OnPush,
template: ``
})
export class GraphComponent {
constructor(private ref: ChangeDetectorRef) { }
ngOnInit() {
this.graph = this.d3Service.getForceDirectedGraph(...);
this.graph.ticker.subscribe((d) => {
this.ref.markForCheck();
});
}
}
```
Теперь Angular будет обновлять граф на каждом тике, это то что нам надо.
Вот и все!
----------
Вы пережили эту статью и создали крутую, масштабируемую визуализацию. Надеюсь что все было понятно и полезно. Если нет — дайте мне знать!
Спасибо за чтение!
[Liran Sharir](http://ng2.lsharir.com/) | https://habr.com/ru/post/414785/ | null | ru | null |
# Как настроить Linux для входа в домен с использованием алгоритмов ГОСТ
Введение
--------
Протокол Kerberos 5 сейчас активно используется для аутентификации. Особенностью данного протокола является то, что он осуществляет аутентификацию, базируясь на четырех китах:
1. Симметричное шифрование;
2. Хеширование;
3. ЭЦП;
4. Третья доверенная сторона.
Начиная с пятой версии появилась возможность использовать еще асимметричное шифрование (для электронной подписи). Более подробно на работе протокола Kerberos останавливаться не имеет смысла, ибо описание алгоритма можно посмотреть [тут](https://en.wikipedia.org/wiki/Kerberos_(protocol)).
К сожалению, количество алгоритмов шифрования, хеширования и ЭЦП, которые использует данный протокол, не настолько велико, насколько хотелось бы, поэтому в данной статье я хочу показать, как добавить ~~легко и просто~~ собственные алгоритмы в [реализацию данного протокола MIT'ом](https://github.com/krb5/krb5). Добавлять же мы будем наши отечественные алгоритмы: ГОСТ 28147-89 (aka Магма), ГОСТ Р 34.11-2012 (aka Стрибог) и ГОСТ Р 34.10-2012 (хотелось бы тоже иметь для него aka, но я не знаю:(). Готовое решение для данных алгоритмов можно его найти в [моем репозитории](https://github.com/lo1ol/krb5/tree/gost_impl). На стороне клиента мы будем использовать аппаратные реализации алгоритмов ГОСТ в Рутокене ЭЦП 2.0 и их программные реализации в engine GOST для openssl. Но самый безопасный вариант хранения ключей – когда они генерируются непосредственно на Рутокене и никогда не покидают его память во время криптографических операций. Для такого варианта работы потребуется rtengine.
Перед тем, как приступить к внедрению алгоритмов, опишем основные места, где будут производится изменения. Внутри директории *src/lib/crypto/* находятся реализации всех алгоритмов, отвечающих за симметричную криптографию и хеширование. В ней имеются 2 реализации этих криптографических алгоритмов: встроенная(builtin) и openssl. Дабы сэкономить время и место, мы, естественно, будем добавлять реализации алгоритмов с помощью openssl, в котором они уже есть (ну или почти есть, но об этом чуть позже). Для добавления же асимметричных алгоритмов, нужно будет подправить плагин *src/plugins/preauth/pkinit*
Если у вас еще не настроен Kerberos, то инструкцию по его первичной настройки и эксплуатации можно взять [тут](https://dev.rutoken.ru/pages/viewpage.action?pageId=21332045). В дальнейшем автор полагает, что вы работаете с доменом AKTIV-TEST.RU
Добавление алгоритмов хеширования и симметричного шифрования
------------------------------------------------------------
Как уже было ранее озвучено, мы не будем писать алгоритмы шифрования и хеширования с нуля, а воспользуемся готовой реализацией данных алгоритмов в openssl. Напрямую openssl не поддерживает в себе реализацию отечественных алгоритмов, но обладает мобильностью в данном вопросе и позволяет добавлять новые алгоритмы, используя механизм engine GOST для работы с ключами в файловой системе и, хранящие на токене — rtengine.
### Небольшое введение в механизм engine openssl и подключение engine GOST
Engine в openssl – это небольшая динамическая библиотека, которую openssl подгружает в runtime по требованию. Каждая такая библиотека, должна содержать в себе определенные символы (функции) для загрузки необходимых алгоритмов. В данной работе мы воспользуемся engine gost, который содержит в себе все необходимые отечественные криптографические алгоритмы.
Установка дичайше проста, например, и происходит следующим образом:
1. Выкачиваете из [репозитория](https://github.com/gost-engine/engine) реализацию данного энджина.
2. собираете библиотеку с ним (mkdir build && cd build && cmake… && make):
```
mkdir build
cd build
cmake ..
make
```
3. В директории bin (КОТОРАЯ ПОЯВИТСЯ В КОРНЕВОМ КАТАЛОГЕ ПРОЕКТА!!!) будет лежать динамическая библиотека gost.so – это и есть наш энджин. Его нужно будет перенести в директорию, где хранятся энджины openssl. Узнать месторасположение данной директории можно с помощью:
```
openssl version -a | grep ENGINESDIR
```
4. Дело за последним – нужно сказать openssl, где находится данный энджин и как он называется. Сделать можно это с помощью изменения файла конфигурации openssl.cnf. Месторасположение которого можно узнать с помощью:
```
openssl version -a | grep OPENSSLDIR
```
В конец данного файла нужно будет внести следующее содержимое:
```
# в начало файла написать
openssl_conf = openssl_def
...
# в конец файла
# OpenSSL default section
[openssl_def]
engines = engine_section
# Engine section
[engine_section]
gost = gost_section
# Engine gost section
[gost_section]
engine_id = gost
dynamic_path = /path/to/engines/dir/with/gost.so
default_algorithms = ALL
init = 0
```
После этого данный энджин должен появится в openssl. Проверить его работоспособность можно заставив, например, сгенерировать приватный ключ в файле по ГОСТ Р 34.10-2012:
```
openssl genpkey -engine gost -algorithm gost2012_512 -pkeyopt paramset:A -out client_key.pem
```
Флаг -engine как раз говорит о том, какой engine нужно подгрузить перед началом работы для того, чтобы стал виден алгоритм генерации ключей для ГОСТ Р 34.10-2012.
### Реализация алгоритма хеширования
Начнем с самого простого – с реализации алгоритма Стрибог. Kerberos обладает жесткой связью алгоритма хеширования и шифрования, то есть вы не можете просто так взять и выбрать для шифрования один алгоритм, а для хеширования другой – вам нужно будет встроить связку алгоритма хеширования и шифрования. Причина этого мне не известна, но раз там бытуют такие правила – давайте попробуем создать связку алгоритма Стрибог и AES.
1. Т.к. нам понадобится уверенность в подключении в разных местах нашей программы, давайте создадим сначала небольшую библиотеку *gost\_helper*, которая будет содержать в себе функцию инициализации энджина в openssl, а так же для удобства несколько функций, возвращающих контексты некоторых алгоритмов хеширования – нам это поможет в дальнейшем. Назовем эту библиотеку gost\_helper и создадим для нее соответствующий заголовочник и исходный файл в директории *src/lib/crypto/openssl/*:
```
// gost_helper.h
#include
// функция инициализация энджина GOST
void krb5int\_init\_gost();
// вспомогательные функции, возвращающие контексты алгоритмов хеширования
const EVP\_MD \* EVP\_gostR3411\_2012\_256();
const EVP\_MD \* EVP\_gostR3411\_2012\_512();
// gost\_helper.c
#include "gost\_helper.h"
#include
// указатель на подключенный энджин
static ENGINE \*eng = NULL;
void
krb5int\_init\_gost()
{
// для ускорения работы проверяем, не подключен ли энджин уже
if (eng) return;
OPENSSL\_add\_all\_algorithms\_conf();
ERR\_load\_crypto\_strings();
if (!(eng = ENGINE\_by\_id("gost"))) {
printf("Engine gost doesn’t exist");
return;
}
ENGINE\_init(eng);
ENGINE\_set\_default(eng, ENGINE\_METHOD\_ALL);
}
const EVP\_MD \*
EVP\_gostR3411\_2012\_256()
{
krb5int\_init\_gost();
return EVP\_get\_digestbynid(NID\_id\_GostR3411\_2012\_256);
}
const EVP\_MD \*
EVP\_gostR3411\_2012\_512()
{
krb5int\_init\_gost();
return EVP\_get\_digestbynid(NID\_id\_GostR3411\_2012\_512);
}
```
2. После добавления вспомогательной библиотеки необходимо будет объявить о ее существовании в Makefile и выписать ее зависимости от файлов. Для этого добавим следующее:
```
# добавим в шаблон src/lib/crypto/openssl/Makefile.in описание зависимостей объектных файлов от исходников:
STLIBOBJS=\
hmac.o \
...
stubs.o \
gost_helper.o
OBJS=\
$(OUTPRE)hmac.$(OBJEXT) \
...
$(OUTPRE)stubs.$(OBJEXT) \
$(OUTPRE)gost_helper$(OBJEXT)
SRCS=\
$(srcdir)/hmac.c \
...
$(srcdir)/stubs.c \
$(srcdir)/gost_helper.c
# В файл зависимостей src/lib/crypto/openssl/deps добавим, от чего будут зависеть наши объектные файлы и библиотеки:
gost_helper.so gost_helper.po $(OUTPRE)gost_helper.$(OBJEXT):
$(BUILDTOP)/include/autoconf.h \
$(BUILDTOP)/include/krb5/krb5.h $(BUILDTOP)/include/osconf.h \
$(BUILDTOP)/include/profile.h $(COM_ERR_DEPS) $(top_srcdir)/include/k5-buf.h \
$(top_srcdir)/include/k5-err.h $(top_srcdir)/include/k5-gmt_mktime.h \
$(top_srcdir)/include/k5-int-pkinit.h $(top_srcdir)/include/k5-int.h \
$(top_srcdir)/include/k5-platform.h $(top_srcdir)/include/k5-plugin.h \
$(top_srcdir)/include/k5-thread.h $(top_srcdir)/include/k5-trace.h \
$(top_srcdir)/include/krb5.h $(top_srcdir)/include/krb5/authdata_plugin.h \
$(top_srcdir)/include/krb5/plugin.h $(top_srcdir)/include/port-sockets.h \
gost_helper.c gost_helper.h
```
3. Стоит заметить, что в дальнейшем при подключении данной библиотеки, нам надо будет добавлять зависимости некоторых файлов от заголовочника данной библиотеки. Делается это очень просто – отыскивается цель, куда надо добавить зависимость в deps файле и записывается зависимость от *rel/path/to/gost\_helper.h*. Например, в *src/lib/crypto/openssl/hash\_provider/deps* нужно будет добавить следующее:
```
hash_evp.so hash_evp.po $(OUTPRE)hash_evp.$(OBJEXT): \
$(BUILDTOP)/include/autoconf.h $(BUILDTOP)/include/krb5/krb5.h \
...
$(srcdir)/../gost_helper.h hash_evp.c
```
В целях экономии места в статье и чтобы размять ваши мозги, я больше не буду обращать на это внимание: будьте внимательны и осторожны!
4. Добавим теперь реализации функций хеширования, все их реализации у нас лежат в *src/lib/crypto/openssl/hash\_provider/hash\_evp.c*. Туда нужно будет дописать следующее:
```
// Не забываем про изменение deps файла!!! Так уж и быть на первый раз предупрежу невнимательных
#include "crypto_int.h"
#include "gost_helper.h"
#include
...
static krb5\_error\_code
hash\_sha384(const krb5\_crypto\_iov \*data, size\_t num\_data, krb5\_data \*output)
{
return hash\_evp(EVP\_sha384(), data, num\_data, output);
}
static krb5\_error\_code
hash\_stribog256(const krb5\_crypto\_iov \*data, size\_t num\_data, krb5\_data \*output)
{
return hash\_evp(EVP\_gostR3411\_2012\_256(), data, num\_data, output);
}
static krb5\_error\_code
hash\_stribog512(const krb5\_crypto\_iov \*data, size\_t num\_data, krb5\_data \*output)
{
return hash\_evp(EVP\_gostR3411\_2012\_512(), data, num\_data, output);
}
// структура функции хеширования
/\*
первый атрибут -- название алгоритма
второй -- размер хеша в байтах
третий -- размер блока передаваемых данных в байтах
четвертый -- указатель на функцию хеширования
\*/
const struct krb5\_hash\_provider krb5int\_hash\_sha384 = {
"SHA-384", 48, 128, hash\_sha384
};
const struct krb5\_hash\_provider krb5int\_hash\_stribog256 = {
"GOSTR34.11-2012-256", 32, 64, hash\_stribog256
};
const struct krb5\_hash\_provider krb5int\_hash\_stribog512 = {
"GOSTR34.11-2012-512", 64, 64, hash\_stribog512
};
```
5. Теперь надо объявить эти контексты во всей библиотеке. Для этого нужно создать их описание в файле *src/lib/crypto/krb/crypto\_int.h*.
```
// Параллельно заметим, что компилятор начнет ругаться, что имя функций не помещается в указанный массив, поэтому немного поправим структуру krb5_hash_provider и добавим кол-во символов в массиве имени алгоритма:
...
struct krb5_hash_provider {
char hash_name[32]; // было 8
size_t hashsize, blocksize;
krb5_error_code (*hash)(const krb5_crypto_iov *data, size_t num_data,
krb5_data *output);
};
...
extern const struct krb5_hash_provider krb5int_hash_sha384;
extern const struct krb5_hash_provider krb5int_hash_stribog256;
extern const struct krb5_hash_provider krb5int_hash_stribog512;
...
```
6. Объявим идентификатор связки Стрибог и AES, внедря макросы, которые мы назовем **CKSUMTYPE\_STRIBOG\_256\_AES256**, **CKSUMTYPE\_STRIBOG\_512\_AES256**, **ENCTYPE\_AES256\_CTS\_STRIBOG\_256**, **ENCTYPE\_AES256\_CTS\_STRIBOG\_512**. Их надо объявить в шаблоне заголовочного файла *src/include/krb5/krb5.hin*. Выглядеть это будет примерно так:
```
#define ENCTYPE_ARCFOUR_HMAC_EXP 0x0018 /**< RFC 4757 */
#define ENCTYPE_CAMELLIA128_CTS_CMAC 0x0019 /**< RFC 6803 */
#define ENCTYPE_CAMELLIA256_CTS_CMAC 0x001a /**< RFC 6803 */
#define ENCTYPE_AES256_CTS_STRIBOG_256 0x001b /**< NO RFC */
#define ENCTYPE_AES256_CTS_STRIBOG_512 0x001c /**< NO RFC */
#define ENCTYPE_UNKNOWN 0x01ff
...
#define CKSUMTYPE_CMAC_CAMELLIA256 0x0012 /**< RFC 6803 */
#define CKSUMTYPE_MD5_HMAC_ARCFOUR -137 /* Microsoft netlogon */
#define CKSUMTYPE_HMAC_MD5_ARCFOUR -138 /**< RFC 4757 */
#define CKSUMTYPE_STRIBOG_256_AES256 -139 /**< NO RFC */
#define CKSUMTYPE_STRIBOG_512_AES256 -140 /**< NO RFC */
```
7. Теперь необходимо добавить две связки функции хеширования и шифрования и функции шифрования и хеширования. Зачем две, если они эквиваленты, спросите вы? Ответ: не знаю, или это исторический костыль или способ оптимизации. Тем не менее, давайте добавим в необходимые файлы новые структуры:
```
// в файле src/lib/crypto/krb/cksumtypes.c добавить в конец списка структуру алгоритмов хеширования и шифрования
/*
первый атрибут -- идентификатор
второй -- название связки
в третьем -- можно добавить алиасы связок
в четвертом -- описание
в пятом -- указатель на функцию шифрования
в шестом -- указатель на функцию хеширования
в седьмом -- указатель на функцию "работы с хешом"
в восьмом -- размер блока
в девятом -- размер хеша
в десятом -- различные флаги
*/
const struct krb5_cksumtypes krb5int_cksumtypes_list[] = {
...
{ CKSUMTYPE_STRIBOG_256_AES256,
"stribog-256-aes256", { 0 }, "STRIBOG256 AES256 key",
&krb5int_enc_aes256, &krb5int_hash_stribog256,
krb5int_etm_checksum, NULL,
64, 32, 0 },
{ CKSUMTYPE_STRIBOG_512_AES256,
"stribog-512-aes256", { 0 }, "STRIBOG512 AES256 key",
&krb5int_enc_aes256, &krb5int_hash_stribog512,
krb5int_etm_checksum, NULL,
64, 64, 0 },
};
// в файле src/lib/crypto/krb/etypes.c добавить в конец списка структуру алгоритмов шифрования и хеширования:
/*
первый атрибут -- идентификатор
второй -- название
третий -- алиас
четвертый -- описание
пятый -- указатель на функцию шифрования
шестой -- указатель на функцию хеширования
седьмой -- размер возвращаемых данных функцией получения случайных чисел из данных
восьмой -- указатель на функцию, возвращающую характеристики алгоритмов
девятый -- указатель на функцию шифрования, использующую алгоритмы хеширования и шифрования
десятый -- указатель на функцию расшифрования, использующую алгоритмы хеширования и шифрования
одиннадцатый -- указатель на функцию преобразования строки в ключ
двенадцатый -- указатель на функцию выработки случайного ключа
тринадцатый -- различные флаги
четырнадцатый -- размер ключа
*/
const struct krb5_keytypes krb5int_enctypes_list[] = {
...
{ ENCTYPE_AES256_CTS_STRIBOG_256,
"aes256-cts-stribog-256", { "aes256-stribog256" },
"AES-256 CTS mode with 256-bit stribog",
&krb5int_enc_aes256, &krb5int_hash_stribog256,
16,
krb5int_aes2_crypto_length, krb5int_etm_encrypt, krb5int_etm_decrypt,
krb5int_aes2_string_to_key, k5_rand2key_direct,
krb5int_aes2_prf,
CKSUMTYPE_STRIBOG_256_AES256,
0 /*flags*/, 256 },
{ ENCTYPE_AES256_CTS_STRIBOG_512,
"aes256-cts-stribog-512", { "aes256-stribog512" },
"AES-256 CTS mode with 512-bit stribog",
&krb5int_enc_aes256, &krb5int_hash_stribog512,
16,
krb5int_aes2_crypto_length, krb5int_etm_encrypt, krb5int_etm_decrypt,
krb5int_aes2_string_to_key, k5_rand2key_direct,
krb5int_aes2_prf,
CKSUMTYPE_STRIBOG_512_AES256,
0 /*flags*/, 256 },
};
```
8. Казалось бы уже все, а вот и нет! Далее наступают проблемы, которые будут видны только в процессе отладки, некоторых из них можно было бы избежать, указав, например, другие указатели на функции в вышеуказанных структурах, но мы пойдем более сложным путем, чтобы показать, что еще возможно придется исправить по дороге. Обо всех этих проблемах я узнал только пользуясь отладчиком:
```
// В файле src/lib/crypto/openssl/hmac.c будет задействоваться функция map_digest -- которая возвращает контекст хеш-функции по переданной структуре. Сейчас эта функция ничего не знает о наших ГОСТах. Исправим это:
#include "crypto_int.h"
#include "gost_helper.h"
#include
#include
static const EVP\_MD \*
map\_digest(const struct krb5\_hash\_provider \*hash)
{
if (!strncmp(hash->hash\_name, "SHA1",4))
return EVP\_sha1();
...
else if (!strncmp(hash->hash\_name, "GOSTR34.11-2012-256", 19))
return EVP\_gostR3411\_2012\_256();
else if (!strncmp(hash->hash\_name, "GOSTR34.11-2012-512", 19))
return EVP\_gostR3411\_2012\_512();
else
return NULL;
}
// В файле src/lib/crypto/openssl/pbkdf2.c вызывается krb5int\_pbkdf2\_hmac, которая сейчас ничего не знает о новых хешах:
krb5\_error\_code
krb5int\_pbkdf2\_hmac(const struct krb5\_hash\_provider \*hash,
const krb5\_data \*out, unsigned long count,
const krb5\_data \*pass, const krb5\_data \*salt)
{
const EVP\_MD \*md = NULL;
/\* Get the message digest handle corresponding to the hash. \*/
if (hash == &krb5int\_hash\_sha1)
md = EVP\_sha1();
...
else if (hash == &krb5int\_hash\_stribog256)
md = EVP\_gostR3411\_2012\_256();
else if (hash == &krb5int\_hash\_stribog512)
md = EVP\_gostR3411\_2012\_512();
...
return 0;
}
// в файле src/lib/krb5/krb/init\_ctx.c нужно добавить в список связок алгоритмов, идентификатор новых алгоритмов:
static krb5\_enctype default\_enctype\_list[] = {
...
ENCTYPE\_AES256\_CTS\_STRIBOG\_256, ENCTYPE\_AES256\_CTS\_STRIBOG\_512,
0
};
```
После всех этих изменений можно проверить работу алгоритма. Соберем все, что мы наделали.
```
autoconf
./configure --with-crypto-impl=openssl # использовать реализацию алгоритмов из openssl
make
sudo make install
```
Теперь приступим к проверке. Для этого давайте выставим принудительное использование внедренных нами алгоритмов в файлы конфигурации Kerberos. Выполните следующее:
1. Остановите krb5kdc:
```
service krb5-kdc stop
```
2. Подправим файл конфигурации kdc.conf (у меня это /usr/local/var/krb5kdc/kdc.conf). Выставим принудительное хеширование с помощью нововведенного алгоритма:
```
[realms]
AKTIV-TEST.RU = {
master_key_type = aes256-stribog512
supported_enctypes = aes256-stribog512:normal
default_tgs_enctypes = aes256-stribog512
default_tkt_enctypes = aes256-stribog512
permitted_enctypes = aes256-stribog512
}
# Так же можно использовать хеш длиной 256 бит
```
3. Аналогичные изменения в файле конфигурации всего протокола krb5.conf (у меня он находится по адресу /etc/krb5.conf):
```
[libdefaults]
supported_enctypes = aes256-stribog512:normal
default_tgs_enctypes = aes256-stribog512
default_tkt_enctypes = aes256-stribog512
permitted_enctypes = aes256-stribog512
# Также можно использовать хеш длиной 256 бит
```
4. Далее запустим krb5kdc т.к. изменился master\_key, то возможно придется создать базу данных principals заново с помощью krb5\_newrealm.
5. После этого создаем всех необходимых принципалов и можно начать работу. Попробуйте аутентифицироваться с помощью kinit.
6. Проверим, что хеширование происходит по указанному алгоритму можно с
помощью klist -e.
Если сервис не запускается, то его можно запустить из-под рута с помощью *src/kdc/krb5kdc*. Если все запустилось, прошло гладко – поздравляю вас! Иначе – увы, панацею от всех проблем я не предлагаю, а лишь предлагаю "небольшую" инструкцию, содержащую основные шаги, которые вам придется совершить, дабы внедрить новый алгоритм в Kerberos. И если у вас ничего не вышло – берите в руки gdb и смотрите, где что выходит не так. Вам лишь могу дать несколько советов:
1. собирать проект в режиме отладки можно, если передать в ./configure CFLAGS=" -g -O0";
2. запустить krb5kdc не в фоновом режиме можно с помощью флага -n;
3. надеюсь до этого не дойдет (хотя при реализации асимметричных алгоритмов у меня все-таки дошло) – возможно вам потребуются отладочные символы openssl – установите их или взяв из репозитория, или установив openssl из [исходников](https://github.com/openssl/openssl) с отладочными символами;
4. то же самое касается gost engine.
По идее этого набора советов вам должно хватить для того чтобы избавить себя от лишней траты времени в поисках "неизведанного".
### Реализация алгоритма шифрования
В этом разделе я покажу, как можно добавить свой алгоритм шифрования данных в Kerberos, и мы попробуем создать связку Магмы и Стрибога, добавленного в прошлом разделе. Тут я уже предполагаю, что небольшая библиотека gost\_helper уже была добавлена в прошлом разделе. Ну что же, разминаем пальцы и приступаем:
1. Сначала опишем алгоритм в нашей библиотеке libk5crypto описав их в заголовочном файле *src/lib/crypto/krb/crypto\_int.h*.
```
...
extern const struct krb5_enc_provider krb5int_enc_camellia256;
extern const struct krb5_enc_provider krb5int_enc_gost89;
...
```
2. В директории *src/lib/crypto/openssl/enc\_provider* добавим исходник gost.c, содержащий в себе реализацию всех необходимых алгоритмов (за основу я взял исходник алгоритма des). Важно заметить, что мы реализуем только режим шифрования cbc, так что для самопроверки вы можете взять любой другой режим шифрования и добавить его:
```
#include "crypto_int.h"
#include "gost_helper.h"
#include
#define BLOCK\_SIZE 8
static krb5\_error\_code
krb5int\_gost\_encrypt(krb5\_key key, const krb5\_data \*ivec, krb5\_crypto\_iov \*data,
size\_t num\_data)
{
int ret, olen = BLOCK\_SIZE;
unsigned char iblock[BLOCK\_SIZE], oblock[BLOCK\_SIZE];
struct iov\_cursor cursor;
EVP\_CIPHER\_CTX \*ctx;
// я бы перенес вызов этой функции в функцию инициализации состояния, но функция krb5int\_gost\_encrypt, иногда вызывается без нее:
krb5int\_init\_gost();
ctx = EVP\_CIPHER\_CTX\_new();
if (ctx == NULL)
return ENOMEM;
ret = EVP\_EncryptInit\_ex(ctx, EVP\_get\_cipherbynid(NID\_gost89\_cbc), NULL,
key->keyblock.contents,
(ivec) ? (unsigned char\*)ivec->data : NULL);
if (!ret) {
EVP\_CIPHER\_CTX\_free(ctx);
return KRB5\_CRYPTO\_INTERNAL;
}
EVP\_CIPHER\_CTX\_set\_padding(ctx,0);
k5\_iov\_cursor\_init(&cursor, data, num\_data, BLOCK\_SIZE, FALSE);
while (k5\_iov\_cursor\_get(&cursor, iblock)) {
ret = EVP\_EncryptUpdate(ctx, oblock, &olen, iblock, BLOCK\_SIZE);
if (!ret)
break;
k5\_iov\_cursor\_put(&cursor, oblock);
}
if (ivec != NULL)
memcpy(ivec->data, oblock, BLOCK\_SIZE);
EVP\_CIPHER\_CTX\_free(ctx);
zap(iblock, sizeof(iblock));
zap(oblock, sizeof(oblock));
if (ret != 1)
return KRB5\_CRYPTO\_INTERNAL;
return 0;
}
static krb5\_error\_code
krb5int\_gost\_decrypt(krb5\_key key, const krb5\_data \*ivec, krb5\_crypto\_iov \*data,
size\_t num\_data)
{
int ret, olen = BLOCK\_SIZE;
unsigned char iblock[BLOCK\_SIZE], oblock[BLOCK\_SIZE];
struct iov\_cursor cursor;
EVP\_CIPHER\_CTX \*ctx;
krb5int\_init\_gost();
ctx = EVP\_CIPHER\_CTX\_new();
if (ctx == NULL)
return ENOMEM;
ret = EVP\_DecryptInit\_ex(ctx, EVP\_get\_cipherbynid(NID\_gost89\_cbc), NULL,
key->keyblock.contents,
(ivec) ? (unsigned char\*)ivec->data : NULL);
if (!ret) {
EVP\_CIPHER\_CTX\_free(ctx);
return KRB5\_CRYPTO\_INTERNAL;
}
EVP\_CIPHER\_CTX\_set\_padding(ctx,0);
k5\_iov\_cursor\_init(&cursor, data, num\_data, BLOCK\_SIZE, FALSE);
while (k5\_iov\_cursor\_get(&cursor, iblock)) {
ret = EVP\_DecryptUpdate(ctx, oblock, &olen,
(unsigned char \*)iblock, BLOCK\_SIZE);
if (!ret)
break;
k5\_iov\_cursor\_put(&cursor, oblock);
}
if (ivec != NULL)
memcpy(ivec->data, iblock, BLOCK\_SIZE);
EVP\_CIPHER\_CTX\_free(ctx);
zap(iblock, sizeof(iblock));
zap(oblock, sizeof(oblock));
if (ret != 1)
return KRB5\_CRYPTO\_INTERNAL;
return 0;
}
static krb5\_error\_code
krb5int\_gost\_init\_state (const krb5\_keyblock \*key, krb5\_keyusage usage,
krb5\_data \*state)
{
state->length = 8;
state->data = (void \*) malloc(8);
if (state->data == NULL)
return ENOMEM;
memset(state->data, 0, state->length);
return 0;
}
static void
krb5int\_gost\_free\_state(krb5\_data \*state)
{
free(state->data);
\*state = empty\_data();
}
/\*
первый атрибут -- как неожиданно, размер блока
второй -- кол-во байтов для хранения первичного ключа
третий -- размер байтов для хранения развернутого ключа
четвертый -- указатель на функцию шифрования
пятый -- указатель на функцию расшифровки
шестой -- указатель на функцию cbc-mac checksum, не вдавался в подробности что это, т.к. наш алгоритм этого не имеет
седьмой -- указатель на функцию инициализации шифрования
восьмой -- указатель на функцию освобождения памяти под первичное состояние
\*/
const struct krb5\_enc\_provider krb5int\_enc\_gost89 = {
BLOCK\_SIZE,
32, 32,
krb5int\_gost\_encrypt,
krb5int\_gost\_decrypt,
NULL,
krb5int\_gost\_init\_state,
krb5int\_gost\_free\_state
};
```
3. В шаблоне *src/lib/crypto/openssl/enc\_provider/Makefile.in* укажем, что появился новый исходник:
```
STLIBOBJS= \
des.o \
...
gost.o
OBJS= \
$(OUTPRE)des.$(OBJEXT) \
...
$(OUTPRE)gost$(OBJEXT)
SRCS= \
$(srcdir)/des.c \
...
$(srcdir)/gost.c
```
4. Не забываем про указание зависимостей в *src/lib/crypto/openssl/enc\_provider/deps*:
```
gost.so gost.po $(OUTPRE)gost.$(OBJEXT): $(BUILDTOP)/include/autoconf.h \
$(BUILDTOP)/include/krb5/krb5.h $(BUILDTOP)/include/osconf.h \
$(BUILDTOP)/include/profile.h $(COM_ERR_DEPS) $(srcdir)/../../krb/crypto_int.h \
$(srcdir)/../crypto_mod.h $(top_srcdir)/include/k5-buf.h \
$(top_srcdir)/include/k5-err.h $(top_srcdir)/include/k5-gmt_mktime.h \
$(top_srcdir)/include/k5-int-pkinit.h $(top_srcdir)/include/k5-int.h \
$(top_srcdir)/include/k5-platform.h $(top_srcdir)/include/k5-plugin.h \
$(top_srcdir)/include/k5-thread.h $(top_srcdir)/include/k5-trace.h \
$(top_srcdir)/include/krb5.h $(top_srcdir)/include/krb5/authdata_plugin.h \
$(top_srcdir)/include/krb5/plugin.h $(top_srcdir)/include/port-sockets.h \
$(top_srcdir)/include/socket-utils.h $(srcdir)/../gost_helper.h gost.c
```
5. Добавим идентификаторы связок к *src/include/krb5/krb5.hin*:
```
...
#define ENCTYPE_AES256_CTS_STRIBOG_256 0x001b /**< NO RFC */
#define ENCTYPE_AES256_CTS_STRIBOG_512 0x001c /**< NO RFC */
#define ENCTYPE_GOST89_CBC_STRIBOG_256 0x001d /**< SOME GOST */
#define ENCTYPE_GOST89_CBC_STRIBOG_512 0x001e /**< SOME GOST */
#define ENCTYPE_UNKNOWN 0x01ff
...
#define CKSUMTYPE_STRIBOG_256_AES256 -139 /**< NO RFC */
#define CKSUMTYPE_STRIBOG_512_AES256 -140 /**< NO RFC */
#define CKSUMTYPE_STRIBOG_256_GOST89 -141 /**< SOME GOST */
#define CKSUMTYPE_STRIBOG_512_GOST89 -142 /**< SOME GOST */
```
6. Опишем структуру связок функции хеширования и шифрования, как в прошлом разделе:
```
// src/lib/crypto/krb/cksumtypes.c
const struct krb5_cksumtypes krb5int_cksumtypes_list[] = {
...
{ CKSUMTYPE_STRIBOG_256_GOST89,
"stribog-256-gost89", { 0 }, "STRIBOG256 GOST89 key",
&krb5int_enc_gost89, &krb5int_hash_stribog256,
krb5int_dk_checksum, NULL,
64, 32, 0 },
{ CKSUMTYPE_STRIBOG_512_GOST89,
"stribog-512-gost89", { 0 }, "STRIBOG512 GOST89 key",
&krb5int_enc_gost89, &krb5int_hash_stribog512,
krb5int_dk_checksum, NULL,
64, 64, 0 },
};
// src/lib/crypto/krb/etypes.c
// тут я использовал только функции по умолчанию, но вы можете попробовать поэкспериментировать с различными другими функциями, например, с такими же как в aes
const struct krb5_keytypes krb5int_enctypes_list[] = {
...
{ ENCTYPE_GOST89_CBC_STRIBOG_256,
"gost89-cbc-stribog-256", { "gost89-stribog256" },
"GOST 28147-89 CBC mode with 256-bit stribog",
&krb5int_enc_gost89, &krb5int_hash_stribog256,
16,
krb5int_dk_crypto_length, krb5int_dk_encrypt, krb5int_dk_decrypt,
krb5int_dk_string_to_key, k5_rand2key_direct,
krb5int_dk_prf,
CKSUMTYPE_STRIBOG_256_GOST89,
0 /*flags*/, 256 },
{ ENCTYPE_GOST89_CBC_STRIBOG_512,
"gost89-cbc-stribog-512", { "gost89-stribog512" },
"GOST 28147-89 CBC mode with 512-bit stribog",
&krb5int_enc_gost89, &krb5int_hash_stribog512,
16,
krb5int_dk_crypto_length, krb5int_dk_encrypt, krb5int_dk_decrypt,
krb5int_dk_string_to_key, k5_rand2key_direct,
krb5int_dk_prf,
CKSUMTYPE_STRIBOG_512_GOST89,
0 /*flags*/, 256 },
};
```
7. Добавим в список режимов шифрования по умолчанию в файле *src/lib/krb5/krb/init\_ctx.c*:
```
static krb5_enctype default_enctype_list[] = {
...
ENCTYPE_AES256_CTS_STRIBOG_256, ENCTYPE_AES256_CTS_STRIBOG_512,
ENCTYPE_GOST89_CBC_STRIBOG_256, ENCTYPE_GOST89_CBC_STRIBOG_512,
0
};
```
После этих манипуляций можно попробовать протестировать нововведенный алгоритм. Тестирование происходит аналогичным образом, что и в [прошлом разделе](#check_algor). Имя связки можно взять в виде алиаса (например, gost89-stribog512) или с помощью имени самого алгоритма (например, gost89-cbc-stribog-512). Надеюсь, что все заработает, иначе не забывайте о том, что я [сказал ранее](#my_remark).
Добавление алгоритма цифровой подписи
-------------------------------------
Ура! Мы приступаем к финальному разделу данной статьи и попробуем добавить собственный алгоритм электронной подписи. Не стоит пугаться, его добавить проще чем что-либо еще, так что давайте поскорее приступим… Хотя нет, подождите, для начала небольшая ремарка.
Асимметричное шифрование, достаточно, тяжеловесная штука. Одна из его главных особенностей – возможность аутентификации: все это построено на удостоверяющих центрах, сертификатах и всякой-всякой сложной лабуде. Как говорится...
> Ребята, не стоит вскрывать эту тему. Вы молодые, шутливые, вам все легко. Это не то. Это не Чикатило и даже не архивы спецслужб. Сюда лучше не лезть. Серьезно, любой из вас будет жалеть. Лучше закройте тему и забудьте, что тут писалось. Я вполне понимаю, что данным сообщением вызову дополнительный интерес, но хочу сразу предостеречь пытливых — стоп. Остальные просто не найдут.
Как-то так. Ну что же, если у вас хватило смелости приступить к этому, то давайте начнем. В данной статье я покажу вам два способа получения и хранения приватных ключей и сертификатов: в файловой системе и на токене. В сущности, для обоих применима [Аксиома Эскобара](https://memepedia.ru/aksioma-eskobara/), но для второго способа потребуется дополнительный энджин, так что если вы решитесь пойти путем шиноби, то милости просим в данный раздел, остальные могут его пропустить.
### Настройка openssl для работы с токенами (на примере Рутокен)
Для работы с Рутокенами, аппаратно поддерживающими ГОСТ-криптографию, для openssl существует rtengine. Его установка достаточно проста и не сильно отличается от GOST, нужно только знать, что и где брать.
1. Скачиваете [отсюда](https://www.rutoken.ru/developers/sdk/) SDK rutoken разработчика и достаете из папки *sdk/openssl/rtengine/bin/* собранную под вашу платформу библиотеку с энжином и помещаете в папку с engine.
2. Скачать и установить модуль librtpkcs11ecp.so. [отсюда](https://www.rutoken.ru/support/download/pkcs/)
3. Собирать утилиту из ветки master OpenSC взяв коммит [8cf1e6f](https://github.com/OpenSC/OpenSC/tree/8cf1e6f769b36bdcadc3958574305b90e88c816d)
4. После того как мы все это сделали, осталось настроить конфигурационный файл openssl.cnf:
```
# в начала файла написать
openssl_conf = openssl_def
...
# в конец файла
# OpenSSL default section
[openssl_def]
engines = engine_section
# Engine section
[engine_section]
gost = gost_section
rtengine = rtengine_section
# Engine gost section
[gost_section]
engine_id = gost
dynamic_path = /usr/lib/x86_64-linux-gnu/engines-1.1/gost.so
default_algorithms = ALL
# Engine rtengine section
[rtengine_section]
engine_id = rtengine
dynamic_path = /path/to/engine/librtengine.so
MODULE_PATH = /path/to/module/librtpkcs11ecp.so
RAND_TOKEN = pkcs11:manufacturer=Aktiv%20Co.;model=Rutoken%20ECP
default_algorithms = CIPHERS, DIGEST, PKEY, RAND
```
Работоспособность engine мы проверим на деле.
### Создание приватного ключа и сертификата для принципала, KDC и УЦ
За основу данной инструкции была взята [инструкция по настройке kerberos](https://dev.rutoken.ru/pages/viewpage.action?pageId=21332045). Я лишь адаптировал ее для работы с русскими алгоритмами, так что частично заглядывайте туда.
1. Создадим приватный ключ и сертификат удостоверяющего центра, а также приватный ключ, запрос на сертификат и сам сертификат, подписанный УЦ для KDC:
```
openssl genpkey -engine gost -algorithm gost2012_256 -pkeyopt paramset:B -out CA_key.pem # приватный ключ УЦ
openssl req -engine gost -key CA_key.pem -new -x509 -out CA_cert.pem # самоподписанный сертификат УЦ
openssl genpkey -engine gost -algorithm gost2012_256 -pkeyopt paramset:B -out KDC_key.pem # приватный ключ KDC
openssl req -engine gost -new -out KDC.req -key ./KDC_key.pem # заявка на подписание сертификата для KDC
# !!! ТУТ ВАЖНО СОЗДАТЬ РАСШИРЕНИЕ pkinit_extensions ИЗ ИНСТРУКЦИИ ВЫШЕ
REALM=AKTIV-TEST.RU; export REALM # устанавливаем домен KDC
CLIENT=127.0.0.1; export CLIENT # устанавливаем имя клиента, для которого подписываем сертификат (в нашем случае имя KDC). Я все воспроизвожу локально, поэтому ставлю localhost
openssl x509 -engine gost -req -in ./KDC.req -CAkey ./CA_key.pem -CA ./CA_cert.pem -out ./KDC.pem -extfile ./pkinit_extensions -extensions kdc_cert -CAcreateserial # подписываем сертификат для KDC.
sudo cp ./KDC.pem ./KDC_key.pem ./CA_cert.pem /var/lib/krb5kdc # отправляем все ключи и сертификаты у директорию kdc.
```
2. Изменим конфигурационный файл kdc, чтобы он знал, откуда брать ключи и сертификаты:
```
[kdcdefaults]
...
pkinit_identity = FILE:/var/lib/krb5kdc/KDC.pem,/var/lib/krb5kdc/KDC_key.pem
pkinit_anchors = FILE:/var/lib/krb5kdc/CA_cert.pem
```
[libdefaults]
spake\_preauth\_groups = edwards25519
```
3. Зададим принудительную предварительную аутентификацию для принципала:
```bash
sudo kadmin.local
kadmin.local$: modprinc +requires_preauth user
```
1. Создадим приватный ключ и заявку на сертификат для нашего принципала. Тут будет развилка, и надо выполнить разные действия в зависимости от того, где мы будем хранить приватный ключ: на токене или в ФС:
1. Для создания ключа и заявки в ФС все делаем почти аналогично, как для KDC:
```
openssl genpkey -engine gost -algorithm gost2012_256 -pkeyopt paramset:B -out client_key.pem # приватный ключ клиента
openssl req -engine gost -new -out client.req -key ./client_key.pem # заявка на подписание сертификата для клиента
```
2. Для создания ключа на токене и подписания сертификата для него нужно выполнить следующее:
```
pkcs11-tool --module /path/to/module/librtpkcs11ecp.so --keypairgen --key-type GOSTR3410-2012-256:B -l --id 45 # создаем приватный и публичный ключ и помещаем их на токен и присваеваем id=45
openssl req -engine rtengine -new -key="pkcs11:id=E" -keyform engine -out client.req # создаем заявку на сертификат для ключа хранящегося на токене. E -- ascii запись 45
```
2. Теперь подпишем нашу заявку:
```
REALM=AKTIV-TEST.RU; export REALM # имя домена
CLIENT=user; export CLIENT # имя пользователя, для которого подписываем сертификат
openssl x509 -engine gost -CAkey ./CA_key.pem -CA ./CA_cert.pem -req -in ./client.req -extensions client_cert -extfile ./pkinit_extensions -out client.pem
openssl x509 -engine gost -in client.pem -out client.crt -outform DER # Конвертируем сертификат из формата PEM в формат CRT
```
3. Теперь дело за малым: в первом случае загружаем сертификат в специальную директорию, во втором – на токен:
```
sudo cp ./client_key.pem client.pem /etc/krb5 # первый случай
pkcs11-tool --module /usr/lib/librtpkcs11ecp.so -l -y cert -w ./client.crt --id 45 # второй случай (сертификат должен иметь тот же id, что и ключ)
```
4. Настраиваем файл конфигурации клиента (у меня это /etc/krb5.conf):
```
[libdefaults]
...
pkinit_anchors = FILE:/var/lib/krb5kdc/CA_cert.pem
# для аутентификации через ФС
pkinit_identities = FILE:/etc/krb5/client.pem,/etc/krb5/client_key.pem
# для аутентификации через токен
#pkinit_identities = PKCS11:/usr/lib/librtpkcs11ecp.so
```
Надеюсь, что на данном этапе проблем не возникнет. Мы совсем близко! Добавим реализацию новых алгоритмов.
### Добавление нового алгоритма цифровой подписи
Алгоритмы ЭЦП добавить куда проще чем те, что рассматривались ранее – придется заменить всего-то 2 файли! *src/plugins/preauth/pkinit/pkcs11.h* и *src/plugins/preauth/pkinit/pkinit\_crypto\_openssl.c*
1. Начнем с добавления идентификаторов новых механизмов и ключей в заголовочник *pkcs11.h*. Идентификатор механизма – это название алгоритма, который подается токену для того, чтобы он его совершил. Все эти идентификаторы стандартизированы и их можно найти в интернете (хоть и с большим трудом). Наши я нашел [здесь](https://www.rutoken.ru/developers/sdk/) в *sdk/pkcs11/include/rtpkcs11t.h*. Добавим в заголовочник следующие идентификаторы ключей и механизмов:
```
...
#define CKK_TWOFISH (0x21)
#define CKK_GOSTR3410 (0x30)
#define CKK_GOSTR3411 (0x31)
#define CKK_GOST28147 (0x32)
#define CKK_VENDOR_DEFINED (1UL << 31)
// A mask for new GOST algorithms.
// For details visit https://tc26.ru/standarts/perevody/guidelines-the-pkcs-11-extensions-for-implementing-the-gost-r-34-10-2012-and-gost-r-34-11-2012-russian-standards-.html
#define NSSCK_VENDOR_PKCS11_RU_TEAM (CKK_VENDOR_DEFINED | 0x54321000)
#define CK_VENDOR_PKCS11_RU_TEAM_TK26 NSSCK_VENDOR_PKCS11_RU_TEAM
#define CKK_GOSTR3410_512 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x003)
...
#define CKM_AES_MAC_GENERAL (0x1084)
#define CKM_AES_CBC_PAD (0x1085)
#define CKM_GOSTR3410_KEY_PAIR_GEN (0x1200UL)
#define CKM_GOSTR3410 (0x1201UL)
#define CKM_GOSTR3410_WITH_GOSTR3411 (0x1202UL)
#define CKM_GOSTR3410_KEY_WRAP (0x1203UL)
#define CKM_GOSTR3410_DERIVE (0x1204UL)
#define CKM_GOSTR3410_512_KEY_PAIR_GEN (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x005)
#define CKM_GOSTR3410_512 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x006)
#define CKM_GOSTR3410_12_DERIVE (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x007)
#define CKM_GOSTR3410_WITH_GOSTR3411_12_256 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x008)
#define CKM_GOSTR3410_WITH_GOSTR3411_12_512 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x009)
#define CKM_GOSTR3411 (0x1210UL)
#define CKM_GOSTR3411_HMAC (0x1211UL)
#define CKM_GOSTR3411_12_256 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x012)
#define CKM_GOSTR3411_12_512 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x013)
#define CKM_GOSTR3411_12_256_HMAC (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x014)
#define CKM_GOSTR3411_12_512_HMAC (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x015)
#define CKM_GOST28147_KEY_GEN (0x1220UL)
#define CKM_GOST28147_ECB (0x1221UL)
#define CKM_GOST28147 (0x1222UL)
#define CKM_GOST28147_MAC (0x1223UL)
#define CKM_GOST28147_KEY_WRAP (0x1224UL)
```
Всеми ими мы не воспользуемся, но на будущее можно добавить.
2. В файле *pkinit\_crypto\_openssl.c*, в первую очередь, нужно добавить подгрузку энджинов перед началом работы. Вызов этой функции также нужно вставить перед get\_key, т.к. эта функция почему-то вызывается перед подгрузкой энджинов:
```
#include
#include
#include
static ENGINE \*eng = NULL;
krb5int\_init\_engines()
{
if (eng) return;
OPENSSL\_add\_all\_algorithms\_conf();
ERR\_load\_crypto\_strings();
if (!(eng = ENGINE\_by\_id("rtengine"))) {
printf("Engine rtengine doesn’t exist");
return;
}
ENGINE\_init(eng);
ENGINE\_set\_default(eng, ENGINE\_METHOD\_ALL);
if (!(eng = ENGINE\_by\_id("gost"))) {
printf("Engine gost doesn’t exist");
return;
}
ENGINE\_init(eng);
ENGINE\_set\_default(eng, ENGINE\_METHOD\_ALL);
}
...
get\_key(krb5\_context context, pkinit\_identity\_crypto\_context id\_cryptoctx,
char \*filename, const char \*fsname, EVP\_PKEY \*\*retkey,
const char \*password)
{
...
krb5\_error\_code retval;
krb5int\_init\_engines();
...
}
...
int
pkinit\_openssl\_init()
{
/\* Initialize OpenSSL. \*/
ERR\_load\_crypto\_strings();
OpenSSL\_add\_all\_algorithms();
krb5int\_init\_engines();
return 0;
}
```
3. После инициализации энджинов можно приступить к замене механизмов и электронной подписи. В данный момент жестко зашит только один алгоритм – RSA с хешом, полученным из sha1. Мы же встроим выбор между возможными режимами в зависимости от типа ключа, хранящегося на токене или в ФС. Для этого введем несколько функций, которые будут на вход получать контексты шифрования, а на выходе выдавать необходимые идентификаторы алгоритмов и механизмов. Также будет необходимо немного подправить функцию получения хендла приватного ключа с токена, т.к. она возвращает только RSA ключи:
```
// закомментируем фильтр на тип приватного ключа
krb5_error_code
pkinit_find_private_key(pkinit_identity_crypto_context id_cryptoctx,
CK_ATTRIBUTE_TYPE usage,
CK_OBJECT_HANDLE *objp)
{
...
true_false = TRUE;
attrs[nattrs].type = usage;
attrs[nattrs].pValue = &true_false;
attrs[nattrs].ulValueLen = sizeof true_false;
nattrs++;
#endif
// keytype = CKK_RSA;
// attrs[nattrs].type = CKA_KEY_TYPE;
// attrs[nattrs].pValue = &keytype
// attrs[nattrs].ulValueLen = sizeof keytype;
// nattrs++;
...
}
// функция получения типа идентификатора алгоритма цифровой подписи в зависимости от полученного типа ключа:
static int
ckk_key_to_nid(CK_KEY_TYPE type)
{
switch(type){
case CKK_GOSTR3410:
return NID_id_GostR3410_2012_256;
case CKK_GOSTR3410_512:
return NID_id_GostR3410_2012_512;
default:
return NID_rsa;
}
}
// функция, возвращающая идентификатор алгоритма цифровой подписи, если он хранится на токене:
static int
pkinit_get_pkey_type(krb5_context context,
pkinit_identity_crypto_context id_cryptoctx)
{
CK_OBJECT_HANDLE obj;
CK_ATTRIBUTE attrs[1];
CK_KEY_TYPE key_type;
int r;
// открываем сессию:
if (pkinit_open_session(context, id_cryptoctx)) {
pkiDebug("can't open pkcs11 session\n");
return NID_rsa;
}
// находим приватный ключ:
if (pkinit_find_private_key(id_cryptoctx, CKA_SIGN, &obj)) {
return NID_rsa;
}
// вытаскиваем тип ключа:
attrs[0].type = CKA_KEY_TYPE;
attrs[0].pValue = &key_type;
attrs[0].ulValueLen = sizeof (key_type);
if ((r = id_cryptoctx->p11->C_GetAttributeValue(id_cryptoctx->session,
obj, attrs, 1)) != CKR_OK) {
pkiDebug("C_GetAttributeValue: %s\n Used RSA\n", pkinit_pkcs11_code_to_text(r));
return NID_rsa;
}
// возвращаем идентификатор алгоритма:
return ckk_key_to_nid(key_type);
}
// функция, возвращающая идентификатор алгоритма хеширования в зависимости от того, какой алгоритм цифровой подписи используется:
static int
pkey_to_digest_nid(const EVP_PKEY* const pkey)
{
switch (EVP_PKEY_id(pkey)) {
case NID_id_GostR3410_2012_256:
return NID_id_GostR3411_2012_256;
case NID_id_GostR3410_2012_512:
return NID_id_GostR3411_2012_512;
case NID_id_GostR3410_2001:
return NID_id_GostR3411_2012_256;
default:
return NID_sha1;
}
}
// функция, возвращающая идентификатор алгоритма хеширования для данного контекста:
static int
get_digest_nid(krb5_context context, const pkinit_identity_crypto_context id_cryptctx)
{
int nid;
// если ключ указан (он находится в ФС), значит достаем NID оттуда, иначе из токена
if (id_cryptctx->my_key) {
nid = EVP_PKEY_id(id_cryptctx->my_key);
} else {
nid = pkinit_get_pkey_type(context, id_cryptctx);
}
switch (nid) {
case NID_id_GostR3410_2012_256:
return NID_id_GostR3411_2012_256;
case NID_id_GostR3410_2012_512:
return NID_id_GostR3411_2012_512;
case NID_id_GostR3410_2001:
return NID_id_GostR3411_2012_256;
default:
return NID_sha1;
}
}
// функция, возвращающая идентификатор алгоритма цифровой подписи:
static int
get_alg_nid(krb5_context context, const pkinit_identity_crypto_context id_cryptctx)
{
int nid;
if (id_cryptctx->my_key) {
nid = EVP_PKEY_id(id_cryptctx->my_key);
} else {
nid = pkinit_get_pkey_type(context, id_cryptctx);
}
switch (nid) {
case NID_id_GostR3410_2012_256:
return NID_id_tc26_signwithdigest_gost3410_2012_256;
case NID_id_GostR3410_2012_512:
return NID_id_tc26_signwithdigest_gost3410_2012_512;
case NID_id_GostR3410_2001:
return NID_id_tc26_signwithdigest_gost3410_2012_256;
default:
return NID_sha1WithRSAEncryption;
}
}
// функция возвращающая идентификатор механизма:
static CK_MECHANISM_TYPE
get_mech_type(krb5_context context, const pkinit_identity_crypto_context id_cryptctx)
{
int nid;
if (id_cryptctx->my_key) {
nid = EVP_PKEY_id(id_cryptctx->my_key);
} else {
nid = pkinit_get_pkey_type(context, id_cryptctx);
}
switch (nid) {
case NID_id_GostR3410_2012_256:
return CKM_GOSTR3410_WITH_GOSTR3411_12_256;
case NID_id_GostR3410_2012_512:
return CKM_GOSTR3410_WITH_GOSTR3411_12_512;
case NID_id_GostR3410_2001:
return CKM_GOSTR3410_WITH_GOSTR3411_12_256;
default:
return CKM_RSA_PKCS;
}
}
```
4. Теперь лишь осталось в функциях создания цифровой подписи *cms\_signeddata\_create* и *create\_signature* заменить жесткую установку алгоритма на выбор алгоритма в зависимости от контекста:
```
krb5_error_code
cms_signeddata_create(krb5_context context,
pkinit_plg_crypto_context plg_cryptoctx,
pkinit_req_crypto_context req_cryptoctx,
pkinit_identity_crypto_context id_cryptoctx,
int cms_msg_type,
int include_certchain,
unsigned char *data,
unsigned int data_len,
unsigned char **signed_data,
unsigned int *signed_data_len)
{
...
/* Set digest algs */
p7si->digest_alg->algorithm = OBJ_nid2obj(
get_digest_nid(context, id_cryptoctx));
...
p7si->digest_enc_alg->algorithm = OBJ_nid2obj(get_alg_nid(context, id_cryptoctx));
...
EVP_DigestInit_ex(ctx, EVP_get_digestbynid(get_digest_nid(context, id_cryptoctx)), NULL);
...
alen = (unsigned int )ASN1_item_i2d((ASN1_VALUE *) sk, &abuf,
ASN1_ITEM_rptr(PKCS7_ATTR_SIGN));
...
// заменяем проверку механизма, на проверку идентификатора алгоритма хеширования (сделать это в двух местах):
if (id_cryptoctx->pkcs11_method == 1 &&
get_digest_nid(context, id_cryptoctx) == NID_sha1) {
}
static krb5_error_code
create_signature(unsigned char **sig, unsigned int *sig_len,
unsigned char *data, unsigned int data_len, EVP_PKEY *pkey)
{
...
EVP_SignInit(ctx, EVP_get_digestbynid(pkey_to_digest_nid(pkey)));
...
}
// узнаем механизм теперь на этапе создания подписи:
static krb5_error_code
pkinit_sign_data_pkcs11(krb5_context context,
pkinit_identity_crypto_context id_cryptoctx,
unsigned char *data,
unsigned int data_len,
unsigned char **sig,
unsigned int *sig_len)
{
...
mech.mechanism = get_mech_type(context, id_cryptoctx);
mech.pParameter = NULL;
mech.ulParameterLen = 0;
...
}
```
После всех этих манипуляций вы можете попробовать зайти, используя токен или сертификат в файловой системе (во втором случае, вероятно, потребуются права рута):
```
sudo kinit user
```
Если после запроса пароля токена не потребовалось вводить пароль user, значит, все отработало правильно.
Все замечания и вопросы вы можете писать в комментариях, а я постараюсь на них оперативно ответить. | https://habr.com/ru/post/467707/ | null | ru | null |
# Блокчейн на JavaScript
В последнее время криптовалюты и блокчейн-технологии стали невероятно популярными. Сегодня я расскажу о моём подходе к созданию блокчейн-платформы на JavaScript с использованием всего 60 строк кода. Я — начинающий блокчейн-разработчик, поэтому если я в чём-то ошибаюсь — поправьте меня в комментариях.
[](https://habr.com/ru/company/ruvds/blog/587726/)
Что такое блокчейн?
-------------------
Прежде чем мы займёмся программированием — надо разобраться с тем, что такое блокчейн (blockchain, цепочка взаимосвязанных блоков). С технической точки зрения, в минимальном представлении, это всего лишь список объектов, содержащих некую информацию — вроде отметки времени, сведений о транзакциях, хешей. Эти данные должны быть иммутабельными и надёжно защищёнными от взлома. Современные платформы, вроде Ethereum, Cardano, Polkadot, обладают гораздо более широкими возможностями, чем просто хранение неких данных, но мы тут будем стремиться к простоте.
Подготовка среды разработки
---------------------------
Для этого проекта мы будем использовать Node.js, поэтому вам, если у вас эта платформа не установлена, понадобится её установить.
Я применяю объектно-ориентированный стиль программирования, поэтому ожидаю от читателя хотя бы базовых знаний в этой сфере.
Создание блока
--------------
Как я уже сказал, блок — это просто объект, в котором хранится какая-то информация. Нам, следовательно, понадобится класс `Block`:
```
class Block {
constructor(timestamp = "", data = []) {
this.timestamp = timestamp;
// в this.data должна содержаться информация наподобие сведений о транзакциях.
this.data = data;
}
}
```
Итак, у нашего объекта будут поля `timestamp` и `data`, но он ещё нуждается в иммутабельности. Добиться этого можно, используя хеш-функцию, с помощью которой обрабатывают все остальные свойства блока. Советую вам почитать о хеш-функциях в Википедии, так как они играют ключевую роль в блокчейн-разработке. В целом их работу можно описать так: они принимают сообщения и выводят «хешированные» сообщения фиксированной длины. Даже небольшое изменение входных данных приведёт к появлению совершенно других выходных данных.
Я применяю алгоритм `sha256`. Для того чтобы реализовать хеширующую функцию — я собираюсь просто воспользоваться возможностями стандартного Node.js-пакета `crypto`:
```
const crypto = require("crypto"), SHA256 = message => crypto.createHash("sha256").update(message).digest("hex");
```
Вышеприведённый код даст нам то, что нужно. Но если вы хотите разобраться с тем, как именно он работает — взгляните на официальную документацию Node.js по классу [Hash](https://nodejs.org/api/crypto.html#class-hash).
На данном этапе работы у нас должно получиться нечто вроде следующего кода:
```
// Подключим хеш-функцию sha256.
const crypto = require("crypto"), SHA256 = message => crypto.createHash("sha256").update(message).digest("hex");
class Block {
constructor(timestamp = "", data = []) {
this.timestamp = timestamp;
this.data = data;
this.hash = this.getHash();
this.prevHash = ""; // хеш предыдущего блока
}
// Наша хеш-функция.
getHash() {
return SHA256(this.prevHash + this.timestamp + JSON.stringify(this.data));
}
}
```
Всякий раз, когда что-то в содержимом блока меняется, хеш-функция выдаёт результат, совершенно не похожий на предыдущий. Это поможет нам в обеспечении иммутабельности блоков.
Свойство `prevHash` тоже играет большую роль в деле обеспечения иммутабельности блоков. Оно позволяет обеспечить то, что блок останется неизменным всё то время, пока существует блокчейн, содержащий этот блок. Оно содержит хеш предыдущего блока, поэтому можно гарантировать иммутабельность этого блока, так как даже небольшое изменение его содержимого приведёт к изменению результатов вызова функции `getHash` текущего блока. Сейчас, как видите, это свойство не содержит никакого значения, но мы ещё к этому вернёмся.
Блокчейн
--------
Займёмся теперь классом `Blockchain`.
Как я уже говорил, блокчейн — это список блоков. Поэтому простейший блокчейн можно описать с помощью следующего класса.
```
class Blockchain {
constructor() {
// В этом свойстве будут содержаться все блоки.
this.chain = [];
}
}
```
Ещё нам необходим так называемый первичный блок (genesis block), который, с технической точки зрения, представляет собой всего лишь самый первый блок:
```
class Blockchain {
constructor() {
// Создаём первичный блок
this.chain = [new Block(Date.now().toString())];
}
}
```
И я, для удобства, создал функцию, которая выдаёт самый последний блок:
```
getLastBlock() {
return this.chain[this.chain.length - 1];
}
```
Теперь нам нужен механизм добавления блоков в блокчейн:
```
addBlock(block) {
// Так как мы добавляем новый блок, prevHash будет хешем предыдущего последнего блока
block.prevHash = this.getLastBlock().hash;
// Так как теперь в prevHash имеется значение, нужно пересчитать хеш блока
block.hash = block.getHash();
this.chain.push(block);
}
```
Проверка блокчейна
------------------
Нам нужно знать о том, корректны ли данные, хранящиеся в блокчейне. Поэтому нам нужен метод, который проверяет хеши блоков. Блокчейн корректен в том случае, если хеши блоков равны тому, что возвращает метод хеширования, и если свойство блока `prevHash` равно хешу предыдущего блока.
```
isValid() {
// Перед перебором цепочки блоков нужно установить i в 1, так как до первичного блока никаких блоков нет. В результате мы начинаем со второго блока.
for (let i = 1; i < this.chain.length; i++) {
const currentBlock = this.chain[i];
const prevBlock = this.chain[i-1];
// Проверка
if (currentBlock.hash !== currentBlock.getHash() || prevBlock.hash !== currentBlock.prevHash) {
return false;
}
}
return true;
}
```
Алгоритм доказательства выполнения работы
-----------------------------------------
Оказывается, что система поддержания иммутабельности блоков, основанная на полях `hash` и `prevHash`, имеет определённые недостатки. Так, кто-то может модифицировать некий блок и пересчитать хеши всех следующих блоков для получения вполне корректной цепочки блоков. Кроме того, нам хотелось бы реализовать некий механизм, позволяющий пользователям приходить к консенсусу по поводу единой хронологической истории цепочки блоков, расположенных в правильном порядке, соответствующем порядку выполнения транзакций. Bitcoin и многие другие криптовалюты включают в себя системы, основанные на алгоритме доказательства выполнения работы (Proof-of-Work, PoW), направленные на решение этой проблемы.
Подобная система направлена на то, чтобы значительно увеличить объём работ, необходимых для создания нового блока. Если нужно модифицировать некий блок — понадобится выполнить работу, необходимую для создания этого блока и всех блоков, которые идут за ним. Это требует поиска значений, которые, после хеширования, дают результат, начинающийся с определённого количества нулевых битов. Речь идёт о так называемом значении `nonce` (number that can only be used once — число, которое может быть использовано один раз), а количество нулевых битов в начале такого числа известно как «сложность». По мере увеличения сложности задача добычи (майнинга, mining) нового блока становится всё сложнее и сложнее. Это позволяет предотвратить модификацию предыдущих блоков, так как тому, кто хотел бы модифицировать некий блок, пришлось бы выполнить работу, необходимую для создания этого блока и всех блоков, которые идут за ним. А это практически невозможно.
Реализовать эту систему можно, добавив в класс `Block` метод `mine` и свойство `nonce`:
```
class Block {
constructor(timestamp = "", data = []) {
this.timestamp = timestamp;
this.data = data;
this.hash = this.getHash();
this.prevHash = ""; // хеш предыдущего блока
this.nonce = 0;
}
// Наша хеш-функция.
getHash() {
return SHA256(this.prevHash + this.timestamp + JSON.stringify(this.data) + this.nonce);
}
mine(difficulty) {
// Тут запускается цикл, работающий до тех пор, пока хеш не будет начинаться со строки
// 0...000 длины .
while (!this.hash.startsWith(Array(difficulty + 1).join("0"))) {
// Инкрементируем nonce, что позволяет получить совершенно новый хеш.
this.nonce++;
// Пересчитываем хеш блока с учётом нового значения nonce.
this.hash = this.getHash();
}
}
}
```
Из-за того, что даже маленькое изменение данных блока ведёт к появлению совершенно нового хеша, мы просто снова и снова инкрементируем `nonce` до тех пор, пока хеш не окажется таким, как нам нужно.
(Учтите, что Bitcoin и другие блокчейн-системы используют другой способ настройки сложности, но мы тут, как уже говорилось, стремимся к простоте.)
Вернёмся к классу `Blockchain` и создадим в нём свойство для хранения сложности — `difficulty`:
```
this.difficulty = 1;
```
В него записано число 1, оно должно меняться в зависимости от количества добытых блоков.
Нам надо отредактировать и код метода `addBlock` класса `Blockchain`:
```
addBlock(block) {
block.prevHash = this.getLastBlock().hash;
block.hash = block.getHash();
block.mine(this.difficulty);
this.chain.push(block);
}
```
Теперь каждый блок, прежде чем его можно будет добавить в блокчейн, нужно добыть.
Примечание
----------
Я использовал для этого блокчейна PoW-систему из-за стремления к простоте. Большинство современных блокчейнов используют гораздо лучшую систему, основанную на механизме консенсуса «доказательство доли владения» (Proof-of-Stake, PoS), или одну из многих усовершенствованных систем такого типа.
Тестирование блокчейна!
-----------------------
Создадим новый файл, `index.js`, он будет играть роль точки входа в систему.
Воспользуемся только что созданным блокчейном. Я назвал его `JeChain`.
Сначала экспортируем необходимые классы:
```
module.exports = { Block, Blockchain };
```
Импортируем их в `index.js` и приступим к испытанию:
```
const { Block, Blockchain } = require("./your-blockchain-file.js");
const JeChain = new Blockchain();
// Добавим новый блок
JeChain.addBlock(new Block(Date.now().toString(), { from: "John", to: "Bob", amount: 100 }));
// (Это - всего лишь интересный эксперимент, для создания настоящей криптовалюты обычно нужно сделать намного больше, чем сделали мы).
// Вывод обновлённого блокчейна
console.log(JeChain.chain);
```
Запуск системы должен выглядеть примерно так:
*Испытание блокчейна*
Первый блок — это первичный блок, а второй — это тот блок, который мы добавили в блокчейн.
Дополнение: сложность и время блока
-----------------------------------
### ▍Время блока
Время блока (block time) — это константное значение, которое представляет собой приблизительное время, необходимое на добавление блока в блокчейн. Платформа Bitcoin, например, имеет время блока, равное 10 минутам, а время блока Ethereum равняется 13 секундам.
### ▍Формула сложности Bitcoin
Сложность Bitcoin меняется после добычи каждых 2016 блоков. Для вычисления сложности используется следующая формула:
```
старая сложность * (2016 блоков * 10 минут) / время добычи предыдущих 2016 блоков
```
Теперь займёмся программированием!
Для начала нужно задать время блока. Я использовал тут значение 30 секунд, то есть — 30000 миллисекунд. Я использую именно миллисекунды, так как такое выражение времени лучше подходит для работы с `Date.now()`.
```
blockTime = 30000;
```
(Мы работаем сейчас с кодом класса `Blockchain`.)
Просто для примера я создам собственную систему: сложность будет увеличиваться на 1 если время блока меньше, чем реальное время, за которое был добыт блок. В противном случае она будет уменьшаться на 1.
```
addBlock(block) {
block.prevHash = this.getLastBlock().hash;
block.hash = block.getHash();
block.mine(this.difficulty);
this.chain.push(block);
this.difficulty += Date.now() - parseInt(this.getLastBlock().timestamp) < this.blockTime ? 1 : -1;
}
```
### ▍Важное примечание
Учитывая то, как ранее мы проверяли сложность, эта система должна работать нормально. Но лучше проверять сложность с использованием `log16(difficulty)`, а не самого значения сложности. Мы, поступая так, теперь можем воспользоваться формулой настройки сложности Bitcoin.
Можете, правда, создать и собственную формулу. Но при этом нужно ориентироваться на безопасность и на хорошую производительность решения.
Итоги
-----
[Вот](https://github.com/nguyenphuminh/JeChain) исходный код моего проекта на GitHub.
Хочу сказать, что многое узнал о блокчейне из материалов YouTube-канала [Simply Explained](https://www.youtube.com/c/Savjee). Я не написал бы эту статью, если бы не серия учебных видео по блокчейну с этого канала. Я, кроме того, почерпнул кое-что из [этой](https://www.activestate.com/blog/how-to-build-a-blockchain-in-python/) статьи. Рекомендую эти материалы всем, кому интересна тема блокчейна.
Доводилось ли вам пользоваться блокчейн-технологиями?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=blokchejn_na_javascript) | https://habr.com/ru/post/587726/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.