text
stringlengths 20
1.01M
| url
stringlengths 14
1.25k
| dump
stringlengths 9
15
⌀ | lang
stringclasses 4
values | source
stringclasses 4
values |
|---|---|---|---|---|
# Notes about OpenTracing and Logs
**1)** OpenTracing (OT) **!=** Logs but they are very similar.
**2)** Every application has 2 types of scopes: ApplicationScope (AScope) and RequestScope (RScope).
ApplicationScope is everything about configs and DI.
Think about it as a singleton. This is the thing that starts, does some work, and stops.
RequestScope is everything about user request / amqp request / etc..
It starts when the application receives a request from a client. It encapsulates an execution context.
**3)** What is the difference between OpenTracing and Logs?
**Logs are about AScope and OpenTracing is about RScope.**
**4)** Your real application can have more then one AScope at the same time (for example if you are using graceful reload - create new/destroy old), but usually, only one AScope exists.
**5)**Logs and OT use the same approach for the messages. This approach called structured logging.
This approach is very easy. There is only one important thing. **Your log message must not contain variable params.**
**6)**Real application has different layers.
PrimaryAdapter → **UseCase → DomainService → DAO** → Client (Secondary Adapter) → ExternalResource
The central part of this chain usually builds by DI.
For example:
```
type CService struct {}
func NewCService(..., logger logger.ILogger) *CService {}
```
And as you can see above Logger is an AScope object, because it should be created when we build our DI-container.
**7) Logger is a global object. We should not create a new logger on every request and store it into ctx.**
**8)** **We should pass context everywhere.**
Context is the thing that contains our RScope. (function arguments contain request scope too - because they change between requests)
OpenTracing widely uses context. (<https://github.com/opentracing/opentracing-go#creating-a-span-given-an-existing-go-contextcontext>)
So if you do not pass context - you do not have OpenTracing.
**9)** Small piece of code.
**/pkg/logger/interface.go**
```
// ==== FIELD ====
type Field struct {
Key string
Value interface{}
}
func F(key string, value interface{}) Field {
return Field{Key: key, Value: value}
}
// func FError - returns field based on error
// ==== LOGGER ====
type Logger interface {
WithFields(with ...Field) Logger
Debug(ctx context.Context, msg string, with ...Field)
Info(ctx context.Context, msg string, with ...Field)
Warn(ctx context.Context, msg string, with ...Field)
Error(ctx context.Context, msg string, with ...Field)
}
```
**/pkg/logger/context.go**
```
type key int
var loggerKey key
func NewContextWithFields(ctx context.Context, with ...Field) context.Context {
fields := make([]Field, 0)
fields = append(fields, fetchFieldsFromContext(ctx)...)
fields = append(fields, with...)
return context.WithValue(ctx, loggerKey, fields)
}
func fetchFieldsFromContext(ctx context.Context) []Field {
if fields, ok := ctx.Value(loggerKey).([]Field); ok {
return fields
}
return nil
}
```
**/example.go**
```
func (uc *UseCase) SomeOperation(ctx context.Context, param uint64) {
span, ctx := opentracing.StartSpanFromContext(ctx, "operation_name")
defer span.Finish()
uc.logger.Info(ctx, "Starting domain operation", logger.F("param", param))
if err := uc.domainSvc.SomeOperation(ctx, param); err != nil {
uc.logger.Error(ctx, "Unable to perform domain operation", logger.FError(err))
return
}
uc.logger.Info(ctx, "Domain operation finished")
}
```
As you can see above Logger receives the context as the first argument.
Why? - Because inside of Logger implementation we can define either we need to send this message to OpenTracing collector (if ctx contains span) or just to stdout. (backward compatibility)
**10)** One more thing. We need to process our errors only one time. SO if we return an error we need only return it. We should not log it inside the same function. | https://habr.com/ru/post/675010/ | null | en | null |
# Свой асинхронный tcp-сервер за 15 минут с подробным разбором
[](https://habr.com/company/alfa/blog/354728/)
Ранее я представил пару небольших [постов](https://habr.com/post/342498/) о потенциальной роли *Spring Boot 2* в реактивном программировании. После этого я получил ряд вопросов о том, как работают асинхронные операции в программировании в целом. Сегодня я хочу разобрать, что такое *Non-blocking I/O* и как применить это знание для создания небольшого *tcp*–сервера на *python*, который сможет обрабатывать множество открытых и тяжелых (долгих) соединений в один поток. Знание *python* не требуется: все будет предельно просто со множеством комментариев. Приглашаю всех желающих!
Мне, как и многим другим разработчикам, очень нравятся эксперименты, поэтому вся последующая статья будет состоять как раз из серии экспериментов и выводов, которые они несут. Предполагается, что вы недостаточно хорошо знакомы с тематикой, и будете охотно экспериментировать со мной. Исходники примеров можно найти на [github](https://github.com/Faoxis/async-py-server).
Начнем с написания очень простого [tcp](https://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D1%82%D0%B5%D0%B2%D0%B0%D1%8F_%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C_OSI)–сервера. Задача сервера будет заключаться в получении и печати данных из сокета и возвращения строки *Hello from server!*. Примерно так это выглядит:
**Синхронный tcp-сервер**
```
import socket
# Задаем адрес сервера
SERVER_ADDRESS = ('localhost', 8686)
# Настраиваем сокет
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(SERVER_ADDRESS)
server_socket.listen(10)
print('server is running, please, press ctrl+c to stop')
# Слушаем запросы
while True:
connection, address = server_socket.accept()
print("new connection from {address}".format(address=address))
data = connection.recv(1024)
print(str(data))
connection.send(bytes('Hello from server!', encoding='UTF-8'))
connection.close()
```
Здесь все довольно просто. Если вы не знакомы с понятием сокета, то [вот](https://habr.com/post/149077/) очень простая и практическая статья. Мы создаем сокет, ловим входящие соединения и обрабатываем их согласно заданной логике. Здесь стоит обратить внимание на сообщения. При создании нового соединения с клиентом мы пишем об этом в консоль.
Хочу сразу заметить, что не стоит серьезно вникать в листинги программ до полного прочтения статьи. Совершенно нормально, если что-то будет не совсем понятно в самом начале. Просто продолжайте чтение.
Нет особого смысла в сервере без клиента. Поэтому на следующем этапе необходимо написать небольшой клиент для использования сервера:
**tcp-клиент**
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import socket
MAX_CONNECTIONS = 20
address_to_server = ('localhost', 8686)
clients = [socket.socket(socket.AF_INET, socket.SOCK_STREAM) for i in range(MAX_CONNECTIONS)]
for client in clients:
client.connect(address_to_server)
for i in range(MAX_CONNECTIONS):
clients[i].send(bytes("hello from client number " + str(i), encoding='UTF-8'))
for client in clients:
data = client.recv(1024)
print(str(data))
```
Важной особенностью здесь является тот факт, что мы в начале устанавливаем максимально возможное количество соединений, а только потом используем их для передачи/хранения данных.
Давайте запустим сервер. Первое, что мы видим:
```
server is running, please, press ctrl+c to stop
```
Это означает, что мы успешно запустили наш сервер и он готов принимать входящие запросы. Запустим клиент и сразу увидим в консоли сервера (у вас порты могут быть другими):
```
server is running, please, press ctrl+c to stop
new connection from ('127.0.0.1', 39196)
b'hello from client number 0'
new connection from ('127.0.0.1', 39198)
b'hello from client number 1'
...
```
Что и следовало ожидать. В бесконечном цикле мы получаем новое соединение и сразу же обрабатываем данные из него. В чем тут проблема? Ранее мы использовали опцию *server\_socket.listen(10)* для настройки сервера. Она означает максимальный размер очереди из еще не принятых подключений. Но в этом нет совершенно никакого смысла, ведь мы принимаем по одному соединению. Что предпринять в такой ситуации? На самом деле, существует несколько выходов.
1. Распараллелить с помощью потоков/процессов (для этого можно, например, использовать fork или пул). Подробнее [здесь](https://docs.python.org/3/library/multiprocessing.html).
2. Обрабатывать запросы не по мере их подключения к серверу, а по мере наполнения этих соединений нужным количеством данных. Проще говоря, мы можем открыть сразу максимальное количество ресурсов и читать из них столько, сколько сможем (сколько необходимо на это процессорного времени в идеальном случае).
Вторая идея кажется заманчивой. Всего один поток и обработка множества соединений. Давайте посмотрим, как это будет выглядеть. Не стоит пугаться обилия кода. Если что-то сразу не понятно, то это вполне нормально. Можно попробовать запустить у себя и подебажить:
**Асинхронный сервер**
```
import select
import socket
SERVER_ADDRESS = ('localhost', 8686)
# Говорит о том, сколько дескрипторов единовременно могут быть открыты
MAX_CONNECTIONS = 10
# Откуда и куда записывать информацию
INPUTS = list()
OUTPUTS = list()
def get_non_blocking_server_socket():
# Создаем сокет, который работает без блокирования основного потока
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setblocking(0)
# Биндим сервер на нужный адрес и порт
server.bind(SERVER_ADDRESS)
# Установка максимального количество подключений
server.listen(MAX_CONNECTIONS)
return server
def handle_readables(readables, server):
"""
Обработка появления событий на входах
"""
for resource in readables:
# Если событие исходит от серверного сокета, то мы получаем новое подключение
if resource is server:
connection, client_address = resource.accept()
connection.setblocking(0)
INPUTS.append(connection)
print("new connection from {address}".format(address=client_address))
# Если событие исходит не от серверного сокета, но сработало прерывание на наполнение входного буффера
else:
data = ""
try:
data = resource.recv(1024)
# Если сокет был закрыт на другой стороне
except ConnectionResetError:
pass
if data:
# Вывод полученных данных на консоль
print("getting data: {data}".format(data=str(data)))
# Говорим о том, что мы будем еще и писать в данный сокет
if resource not in OUTPUTS:
OUTPUTS.append(resource)
# Если данных нет, но событие сработало, то ОС нам отправляет флаг о полном прочтении ресурса и его закрытии
else:
# Очищаем данные о ресурсе и закрываем дескриптор
clear_resource(resource)
def clear_resource(resource):
"""
Метод очистки ресурсов использования сокета
"""
if resource in OUTPUTS:
OUTPUTS.remove(resource)
if resource in INPUTS:
INPUTS.remove(resource)
resource.close()
print('closing connection ' + str(resource))
def handle_writables(writables):
# Данное событие возникает когда в буффере на запись освобождается место
for resource in writables:
try:
resource.send(bytes('Hello from server!', encoding='UTF-8'))
except OSError:
clear_resource(resource)
if __name__ == '__main__':
# Создаем серверный сокет без блокирования основного потока в ожидании подключения
server_socket = get_non_blocking_server_socket()
INPUTS.append(server_socket)
print("server is running, please, press ctrl+c to stop")
try:
while INPUTS:
readables, writables, exceptional = select.select(INPUTS, OUTPUTS, INPUTS)
handle_readables(readables, server_socket)
handle_writables(writables)
except KeyboardInterrupt:
clear_resource(server_socket)
print("Server stopped! Thank you for using!")
```
Давайте запустим наш новый сервер и посмотрим на консоль:
**Вывод асинхронного сервера**
```
server is running, please, press ctrl+c to stop
new connection from ('127.0.0.1', 56608)
new connection from ('127.0.0.1', 56610)
new connection from ('127.0.0.1', 56612)
new connection from ('127.0.0.1', 56614)
new connection from ('127.0.0.1', 56616)
new connection from ('127.0.0.1', 56618)
new connection from ('127.0.0.1', 56620)
new connection from ('127.0.0.1', 56622)
new connection from ('127.0.0.1', 56624)
getting data: b'hello from client number 0'
new connection from ('127.0.0.1', 56626)
getting data: b'hello from client number 1'
getting data: b'hello from client number 2'
```
Как можно понять по выводу, мы принимаем новые коннекты и данные почти параллельно. Более того, мы не ждем данных от нового подключения. Вместо этого мы устанавливаем новое.
#### Как это работает?
Дело в том, что все наши операции с ресурсами (а обращение к сокету относится к этой категории) происходят через системные вызовы операционной системы. Если говорить коротко, то системные вызовы представляют собой обращение к *API* операционной системы.
Рассмотрим, что происходит в первом случае и во втором.
#### Синхронный вызов
Давайте разберем рисунок:
Первая стрелка показывает, что наше приложение обращается к операционной системе для получения данных из ресурса. Далее наша программа блокируется до появления нужного события. Минус очевиден: если у нас один поток, то другие пользователи должны ждать обработку текущего.
#### Асинхронный вызов
Теперь посмотрим на рисунок, который иллюстрирует асинхронный вызов:
Первая стрелка, как и в первом случае, делает запрос к ОС (операционной системе) на получение данных из ресурсов. Но посмотрите, что происходит далее. Мы не ждем данных из ресурса и продолжаем работу. Что же делать нам? Мы отдали распоряжение ОС и не ждем результат сразу. Простейшим ответом будет самостоятельно опрашивать нашу систему на наличие данных. Таким образом, мы сможем утилизировать ресурсы и не блокировать наш поток.
Но самом деле такая система не является практичной. Такое состояние, в котором мы постоянно смотрим на данные и ждем какого-то события, называется активным ожиданием. Минус очевиден: мы впустую тратим процессорное время в случае, когда информация не обновилась. Более правильным решением было бы оставить блокировку, но сделать ее «умной». Наш поток не просто ждет какого-то определенного события. Вместо этого он ожидает любое изменение данных в нашей программе. Именно так и работает функция select в нашем асинхронном сервере:
Теперь можно вернуться к реализации нашего асинхронного сервера и взглянуть на него с новым знанием. Первое, что бросается в глаза, – метод работы. Если в первом случае наша программа выполнялась “сверху вниз”, то во втором случае мы оперируем событиями. Такой подход в разработке ПО называется событийно-ориентированным (event-driven development).
Сразу стоит отметить, что такой подход не является серебряной пулей. У него имеется масса недостатков. Во-первых, такой код сложнее поддерживать и менять. Во-вторых, у нас есть и всегда будут блокирующие вызовы, которые все портят. Например, в программе выше мы воспользовались функцией *print*. Дело в том, что такая функция тоже обращается к ОС, следовательно, наш поток выполнения блокируется и другие источники данных терпеливо ждут.
### Заключение
Выбор подхода напрямую зависит от решаемой нами задачи. Позвольте задаче самой выбрать наиболее продуктивный подход. Например, популярный *Java*веб -сервер *Tomcat* использует потоки. Не менее популярный сервер *Nginx* использует асинхронный подход. Создатели популярного веб-сервера *gunicorn* на *python* пошли по пути *prefork*.
Спасибо, что прочитали статью до конца! В следующий раз (уже скоро) я расскажу о прочих возможных неблокирующих ситуациях в жизни наших программ. Буду рад вас видеть и в следующих постах. | https://habr.com/ru/post/354728/ | null | ru | null |
# Получаем IP-адреса HTTPS-клиентов с HAProxy (frontend) на Nginx (backend) в режимах HTTP и TCP-балансировки
Довольно часто требуется балансировать нагрузку между несколькими веб-серверами. При этом, как правило, необходимо, чтобы веб-приложения получали реальные IP-адреса клиентов, а не IP балансировщика.
В случае балансировки и терминации HTTP(S)-трафика на HAProxy (Layer 7 [[1](https://ru.wikipedia.org/wiki/Протоколы_прикладного_уровня)]) данная задача легко решается добавлением заголовка “X-Real-IP” и его обработкой на Nginx при помощи модуля ngx\_http\_realip\_module [[2](http://nginx.org/ru/docs/http/ngx_http_realip_module.html)]. При балансировке TCP-трафика от HTTPS-клиентов и передаче его на веб-сервера напрямую без модификации или терминации (Layer 4 [[3](https://ru.wikipedia.org/wiki/Транспортный_уровень)]) добавить данный заголовок невозможно, поэтому требуется воспользоваться возможностями, предоставляемыми Proxy Protocol [[4](http://www.haproxy.org/download/1.5/doc/proxy-protocol.txt), [5](http://cbonte.github.io/haproxy-dconv/configuration-1.5.html#send-proxy), [6](http://nginx.org/ru/docs/http/ngx_http_core_module.html#listen)].
Рассмотрим оба варианта (балансировка L7 и L4) на примере выдержек из конфигурационных файлов haproxy 1.5.9 и nginx 1.6.2
### Балансировка на прикладном уровне (Layer 7): терминация HTTPS-трафика на HAProxy и передача по HTTPS на Nginx
В данном примере HTTPS-трафик от клиента терминируется на HAProxy, модифицируется и передается на Nginx так же по HTTPS.
#### haproxy.cfg
```
global
maxconn 4096
chroot /usr/share/haproxy
uid 99
gid 99
daemon
tune.ssl.default-dh-param 2048
defaults
log global
option redispatch
option tcp-smart-accept
option tcp-smart-connect
retries 3
maxconn 2000
timeout connect 5000
timeout check 3000
timeout client 50000
timeout server 50000
frontend http_frontend *:80
mode http
redirect scheme https code 301 if !{ ssl_fc }
frontend https_frontend_ssl_terminate
mode http
bind *:443 ssl crt /etc/haproxy/ssl/public.example.com.pem
option forwardfor header X-Real-IP
default_backend web_server_http
backend web_server_http
mode http
balance roundrobin
# Отправляем трафик на backend по HTTPS
server s1_https 192.168.1.10:443 ssl verify none
server s2_https 192.168.1.20:443 ssl verify none
```
#### nginx.conf
```
server {
server_name localhost;
listen 443 ssl default_server;
ssl_certificate /etc/nginx/ssl/internal.example.com.pem;
ssl_certificate_key /etc/nginx/ssl/internal.example.com.key;
# Адрес HAProxy
set_real_ip_from 192.168.1.254;
real_ip_header X-Real-IP;
root /usr/share/nginx/html;
index index.html index.htm;
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root /usr/share/nginx/html;
}
location ~ /\.ht {
deny all;
}
}
```
### Балансировка на транспортном уровне (Layer 4): передача TCP-трафика с HAProxy на Nginx
В данном примере HTTPS-трафик клиентов не модифицируется (HAProxy вмешивается в транспортный уровень) и его терминация происходит непосредственно на Nginx.
#### haproxy.cfg
```
global
maxconn 4096
chroot /usr/share/haproxy
uid 99
gid 99
daemon
defaults
log global
option redispatch
option tcp-smart-accept
option tcp-smart-connect
retries 3
maxconn 2000
timeout connect 5000
timeout check 3000
timeout client 50000
timeout server 50000
frontend http_frontend *:80
mode http
redirect scheme https code 301 if !{ ssl_fc }
frontend https_frontend_ssl_pass
mode tcp
bind *:443
default_backend web_server_tcp
backend web_server_tcp
mode tcp
balance roundrobin
# ВНИМАНИЕ! Работа с send-proxy возможна только,
# когда принимающая сторона понимает, что это такое.
# Для Nginx необходимо включить в директиву listen
# опцию proxy_protocol.
server s1_tcp 192.168.1.10:443 send-proxy
server s2_tcp 192.168.1.20:443 send-proxy
```
#### nginx.conf
```
server {
server_name localhost;
# ВНИМАНИЕ! Работа с директивой proxy_protocol возможна только в связке с haproxy.
# Для прямого доступа данную директиву необходимо отключить.
listen 443 ssl default_server proxy_protocol;
ssl_certificate /etc/nginx/ssl/public.example.com.pem;
ssl_certificate_key /etc/nginx/ssl/public.example.com.key;
# Адрес HAProxy
set_real_ip_from 192.168.1.254;
real_ip_header proxy_protocol;
root /usr/share/nginx/html;
index index.html index.htm;
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root /usr/share/nginx/html;
}
location ~ /\.ht {
deny all;
}
}
```
### Заключение
Используя описанные выше настройки мы смогли передать веб-серверу Nginx, расположенному за HAProxy, реальные IP-адреса клиентов при работе по HTTPS. Подобным подходом так же можно воспользоваться при работе со сторонними балансировщиками нагрузки, например CloudFlare [[7](https://danielmiessler.com/getting-real-ip-addresses-using-cloudflare-nginx-and-varnish/), [8](http://www.babaei.net/blog/2013/03/09/getting-real-ip-addresses-using-nginx-and-cloudflare/)] и AWS ELB [[9](https://chrislea.com/2014/03/20/using-proxy-protocol-nginx/), [10](http://aws.amazon.com/elasticloadbalancing/)].
### Литература
1. [Протоколы прикладного уровня сетевой модели OSI](https://ru.wikipedia.org/wiki/Протоколы_прикладного_уровня) — ru.wikipedia.org
2. [Модуль ngx\_http\_realip\_module](http://nginx.org/ru/docs/http/ngx_http_realip_module.html) — nginx.org
3. [Транспортный уровень сетевой модели OSI](https://ru.wikipedia.org/wiki/Транспортный_уровень) — ru.wikipedia.org
4. [The PROXY protocol](http://www.haproxy.org/download/1.5/doc/proxy-protocol.txt) — haproxy.org
5. [HAProxy Configuration Manual: send-proxy](http://cbonte.github.io/haproxy-dconv/configuration-1.5.html#send-proxy) — cbonte.github.io
6. [Модуль ngx\_http\_core\_module: директива listen](http://nginx.org/ru/docs/http/ngx_http_core_module.html#listen) — nginx.org
7. [Getting Real IP Addresses Using CloudFlare, Nginx, and Varnish](https://danielmiessler.com/getting-real-ip-addresses-using-cloudflare-nginx-and-varnish/) — danielmiessler.com
8. [Getting Real IP Addresses Using Nginx and CloudFlare](http://www.babaei.net/blog/2013/03/09/getting-real-ip-addresses-using-nginx-and-cloudflare/) — babaei.net
9. [Using Proxy Protocol With Nginx](https://chrislea.com/2014/03/20/using-proxy-protocol-nginx/) — chrislea.com
10. [AWS Elastic Load Balancing](http://aws.amazon.com/elasticloadbalancing/) — aws.amazon.com | https://habr.com/ru/post/247297/ | null | ru | null |
# SLO и SLI на практике — что это такое, как внедрить и как контролировать на примере инструмента Instana
Сегодня мы хотим обсудить практическую сторону внедрения концепций Service Level Objectives и Service Level Indicators. Рассмотреть, что входит в понятия SLI, SLO и Error budget, как рассчитывать эти показатели, как за 7 шагов внедрить их отслеживание и как в последствии контролировать эти показатели на примере инструмента [Instana](https://habr.com/ru/company/proto/blog/530158/).
Определимся с терминологией
---------------------------
**Service Level Indicator (SLI)** – это количественная оценка работы сервиса, как правило, связанная с удовлетворенностью пользователей производительностью приложения или сервиса за заданный период времени (месяц, квартал, год). А если говорить конкретнее – это индикатор пользовательского опыта, который отслеживает одну из многочисленных возможных метрик (рассмотрим их ниже) и, чаще всего, представляется в процентном эквиваленте, где 100 % - означает отличный пользовательский опыт, а 0% - ужасный.
**Service Level Objectives (SLO)** – это желаемое, целевое значение нашего SLI или группы SLI. При установке SLO необходимо указывать реально достижимое значение для каждого конкретного SLI. Ниже мы рассмотрим логику установки SLO на примере конкретных SLI.
Также важно понимать, что SLO – это наш внутренний показатель качества работы сервиса и/или приложения, в отличие от **Service Level Agreement (SLA)**, который обычно устанавливается бизнесом как внешнее обязательство по доступности сервиса перед клиентами компании.
Если компания предоставляет SLA клиентам, обычно при прописывании SLO берутся в расчет установленные показатели SLA. Так как в случае не достижения SLO это напрямую отразиться на SLA, что приведет к определенным последствиям для бизнеса в лице нарушения договорных обязательств перед клиентами или даже штрафам.
В концепции SLI и SLO присутствует индикатор **Error Budget** или, как его иногда называют, «право на ошибку». Error Budget – это степень невыполнения наших SLO. Например, если наш SLO учитывает доступность, то error budget – это максимальное время, в течение которого наша система может быть недоступной без последствий для нас и нашей команды.
Использование данного показателя упрощает командам процесс контроля времени недоступности приложений/сервисов посредством ввода наглядного индикатора. Устанавливая Error Budget, мы ставим для себя цель – не выйти за рамки разрешенного нам самим downtime.
Например, если в качестве SLI для одного из наших приложений у нас указана метрика Availability, а в качестве SLO для этого SLI мы указали значение 99,95% в месяц, то наш Error Budget за месяц (30 дней) составит 21 минуту 54 секунды. Конкретную цифру Error Budget можно не рассчитывать самостоятельно, а воспользоваться готовым [калькулятором](https://uptime.is/).
Для анализа текущего положения дел с Error Budget с учетом установленного SLO/SLA и среднего показателя Availability на момент расчета, можно использовать вот такой [калькулятор](https://dastergon.gr/error-budget-calculator/).
И так, мы разобрались, что из себя представляют SLI и SLO, теперь давайте перейдем к тому, как это внедрить. Для этих целей мы составили пошаговый план.
7 последовательных шагов по имплементации SLO
---------------------------------------------
1. Определяем сервисы, критичные с точки зрения пользовательского опыта.
Если сервисов много или у нас нет четкого представления о том, производительность каких сервисов непосредственно влияет на наших пользователей, то можно начать с определения критичных для бизнеса транзакций и путей транзакций, например – транзакция добавления товара в корзину, транзакция оплаты, транзакция регистрации, транзакция входа в личный кабинет и т.п.
Например, пользователи жалуются на долгий процесс чекаута, тогда нам нужно определить транзакции или сервисы, которые участвуют в процессе подтверждения заказа.
2. Для выбранных сервисов определяем набор метрик, которые войдут в наш SLI.
Чаще всего в SLI включают метрики, непосредственно связанные с пользовательским опытом, доступностью и производительностью, такие как время исполнения транзакций, время отклика, процент ошибок, доступность.
3. Определяем текущее распределение значений выбранных метрик.
Если вы используете промышленное APM решение, то скорей всего вам уже доступно определение baseline метрик. Например, мы видим, что у транзакции чекаута время исполнения по 90-му перцентилю равняется 110 мс за последние две недели.
4. Определяем SLO, учитывая нормальное поведение выбранных метрик или данных по baseline и устанавливаем Error Budget.
Использовать «в лоб» текущие значения производительности как целевые - не совсем корректная практика, ведь SLO – это цель, к которой нужно стремиться, и она может и должна формироваться не только исходя из технических критериев и текущей ситуации. Но на практике проще оттолкнуться от измеренного значения и подкорректировать целевое, с учетом тех действий, которые позволят достичь этой цели.
Например, можно установить порог 110 мс по 90-му перцентилю и SLO в 95%. Это будет означать, что мы допускаем 5% времени, в которое время исполнения транзакции по 90-му перцентилю будет выше 110 мс.
5. Прописываем процедуру действий на случай истощения Error Budget
Важно заранее продумать, что мы будем делать в случае истощения Error Budget. В процедуру реагирования можно включить следующие действия:
1. Оповещение при превышении Error Budget
2. Повышение приоритета для команд разработки и DevOps у работ по восстановлению доступности сервиса перед работами по выкатке новых фич на определенный период времени.
3. Lessons learned, post mortem и другие документы – фиксация причин превышения Error Budget в каждом конкретном случае в базу знаний и работа над ошибками.
6. Отслеживаем выполнение установленных нами SLO для соответствующих SLIs во времени.
7. Оцениваем результаты внедрения SLI SLO, как и с любым процессом, следующим логике Plan-Do-Check-Act. Лучше начать с небольшого количества SLO, определить достижимые цели, научиться отслеживать показатели и проводить улучшения постепенно.
А теперь давайте посмотрим, как концепция SLI SLO реализована в инструменте Instana.
Реализация концепции SLO и SLI в Instana
----------------------------------------
Инженеры Google [рекомендуют](https://cloud.google.com/blog/products/management-tools/practical-guide-to-setting-slos) начинать установку SLO с определения критичных путей пользователя по приложению, а именно конкретных действий пользователя, совершаемых в нашем приложении с целью достижения определенного бизнес результата. Например, путь пользователя по приложению с целью добавить товар в корзину.
В Instana определить пути пользователя по приложению можно с помощью функции Application Perspective. Подробнее о том, как еще использовать Application Perspective, можно прочитать в нашем посте - [Observability система для микросервисов на примере Instana, часть 1](https://habr.com/ru/company/proto/blog/530158/)
Для создания Application Perspective перейдем в интерфейсе Instana к разделу Application, кликнем на «New Application Perspective».
 В появившемся окне будут предложены варианты Application Perspective. Выбрав «a critical user journey», мы укажем, какие сервисы и эндпоинты входят в «путь пользователя». А если говорить проще – то мы определили какие сервисы и эндпоинты входят в одну из бизнес-транзакций, по которой необходимо определить SLO.
После того, как мы определили пути пользователя необходимо определить метрики, которые войдут в наш SLI и установить значение SLO. Теперь мы можем перейти к созданию SLI.
Конфигурация SLI
----------------
Создадим новый кастомный дашборд.
На котором добавим SLO виджет и выберем созданное ранее Application Perspective.
Кликнув на «Manage SLI» перейдем к списку всех доступных индикаторов для выбранного Application Perspective.
Выбрав «Create SLI», мы перейдем к созданию SLI.
Для создания индикатора:
1. Укажем имя индикатора.
2. Определим тип индикатора: Time-Based или Event-Based.
3. Определим границы для вызовов: Inbound Calls или All Calls.
1. Inbound calls: Все входящие вызовы в рамках сервисов входящих в Application Perspective.
2. All calls: Все входящие вызовы в рамках Application Perspective и исходящие вызовы из Application Perspective.
4. Укажем необходимую конфигурацию в зависимости от выбранного типа индикатора.
5. Сохраним SLI кликнув на “Create”.
### Time Based SLI
Time-Based индикатор – основывается на значениях выбранной метрики (временного ряда). Среди доступных метрик:
* Latency – время исполнения вызовов;
* Call Count – количество вызовов;
* Error Rate – процент ошибок;
* Erroneous Calls – количество вызовов, содержащих ошибку.
Важно отметить, что значения этих метрик собираются напрямую из автоматически инструментированных приложений - для их получения достаточно установить агента Instana, не нужны настройка инструментации, ручное описание метрики или какие-либо внешние service mesh или другие системы.
В процессе установки SLI мы:
* Определяем область действия этого индикатора - можем выбрать как конкретный сервис, так и использоваться все сервисы входящие в Application Perspective. Для более детального определения можем указать конкретный эндпоинт сервиса.
* Выбираем метрику, которая войдет в SLI. Это может быть - Latency, Call Count, Error Rate, Erroneous Calls.
* Определяем, как будем агрегировать значение метрики: по перцентилям (90, 50, 99 и т.д.), по среднему значению, по минимальному или максимальному значению.
* Определяем пороговое значение метрики.
После того, как мы указали метрику и ее пороговое значение, SLI рассчитается по формуле:
```
SLI = (1 - #minutes_where_threshold_is_violated / #minutes_in_time_window) * 100%
```
Посмотрим на пример настройки Time-Based индикатора.
 Все вызовы сервиса proto.group должны исполняться в среднем не более чем за 25мс.
Event-Based SLI
---------------
Event-Based индикатор основывается на «хороших» и «плохих» событиях.
«Хорошие» события - это набор вызовов, которые указывают на положительное качество работы сервиса, например, 2хх HTTP статус коды.
«Плохие» события – это набор вызовов, которые указывают на отрицательное качество работы сервиса, например, 5хх HTTP статус коды.
В ходе настройки Event-Based SLI мы:
* С помощью фильтров определим, какие вызовы указывают на положительное качество работы сервиса;
* С помощью фильтров, определим, какие вызовы указывают на отрицательное качество работы сервиса.
SLI в таком случае рассчитывается по формуле:
```
SLI = #good_events / (#good_events + #bad_events) * 100%
```
Рассмотрим пример настройки Event-Based индикатора.
 Мы определили, что «хорошие» события – это все вызовы с 2хх HTTP статус кодом, а «плохие» - все вызовы с 5хх HTTP статус кодом.
SLO отчет
---------
В Instana SLO отчет предоставляется в виде «виджетов», которые можно добавить на свои кастомные дашборды. Виджеты позволяют проанализировать качество работы предоставляемого нами приложения/сервиса за определенный период времени.
На представленном примере виджета – Robot Shop SLO. Мы используем метрику времени исполнения транзакции добавлении товара в корзину, как ключевой индикатор SLI, значение метрики должно не превышать 20мс.
SLO рассматриваем за выбранный промежуток времени – 24 часа, и нам доступно 72 минуты на простой нашего сервиса (Error Budget). На дашборде выше мы видим, что SLO нарушался 116 минут за выбранный промежуток времени, наш Error Budget превышен на 44 минуты.
Еще пример SLO отчета для Event-Based SLI:
Конфигурация SLO виджета
------------------------
В этом разделе мы расскажем, как создать SLO Widget для любого Application Perspective.
Перейдем на свой кастомный дашборд и добавим SLO виджет, просто кликнув на “Add Widget”:
 В открывшемся окне перейдем на вкладку SLO и для настройки сделаем следующее:
1. Укажем имя виджета.
2. Выберем Application Perspective/критически важный пользовательский путь, по которому нужно задать SLO
3. Выберем заранее созданный целевой индикатор SLI для выбранного Application Perspective.
4. Определим цель SLO которую нужно достичь
5. Выберем временной период, за который будет рассчитываться SLO:
1. Dynamic time window – SLO будет рассчитываться за период, который указан в тайм пикере. Тайм пикер доступен в правом верхнем углу интерфейса Instana, в нем мы выбираем период времени, за который будут отображаться данные.
2. Rolling Time Window – SLO будет рассчитываться за выбранный период времени, где конечная дата периода указана в тайм пикере. Например, мы всегда можем посмотреть данные за предыдущую неделю, без необходимости изменять период времени в тайм пикере.
3. Fixed time interval – SLO будет рассчитываться за фиксированный период времени с определенной датой начала и длительностью. Например, ежемесячно начиная с 2020-01-01.
6. Убедимся, что мы заполнили все необходимые поля конфигурации. Нажав на «Highlight missing configuration» нам подсветятся все не заполненные поля.
7. Сохраним виджет, нажав на «Create»
Итоги
-----
Мы рассмотрели, что такое SLI и SLO, как они соотносятся с пользовательским опытом, какие метрики обычно входят в SLI и как внедрить концепцию SLO на практике.
Также с помощью Instana мы настроили SLI и SLO для сервисов, начали с выбора критичного пути пользователя по сайту, определили какие метрики использовать для SLI, указали error budget и настроили виджет, визуализирующий текущий статус SLO. Метрики приложений мы собрали автоматически, путем установки агента, реализующего инструментацию приложений - метрики не потребовалось описывать вручную.
Подробнее про основные возможности observability системы Instana можно почитать в нашем [обзоре продукта](https://habr.com/ru/company/proto/blog/530158/).
Также приглашаем на наш [вебинар](https://habr.com/ru/company/proto/news/t/537918/), посвященный использованию [Instana](https://www.instana.com/) для мониторинга Kubernetes и снижения MTTR. | https://habr.com/ru/post/538966/ | null | ru | null |
# Dart. Всё, что надо знать про константы
Константы — это не просто странная версия `final` переменных, которая будет преследовать вас во сне со всеми связанными с ними ошибками. `Compile-time` константы – это хороший способ повысить производительность вашего приложения, не создавая один и тот же объект несколько раз, а так сказать, «предварительно создавая» объекты во время компиляции.
const или final?
----------------
Давайте, разберемся с этим вопросом, прежде чем перейти к более глубокому изучению констант. Со стороны может показаться, что не имеет значения, у вас ключевое слово `const` или `final` перед переменной. Эти переменные **не могут** быть изменены после их объявления.
```
void run() {
const myConstNumber = 5;
final myFinalNumber = 5;
myConstNumber = 42; // ошибка
myFinalNumber = 42; // ошибка
}
```
В большинстве случаев подойдет `final`, в то время как `const` можно использовать только для **глобальных**, **статических** или **локальных** переменных. Это значит, что вы не можете определить *нестатическое* `const` поле в классе.
```
class MyClass {
final int myFinalField;
const int myConstField; // ошибка
MyClass(this.myFinalField, this.myConstField);
}
```
Обычно чтобы избежать обременительного процесса принятия решений всякий раз, когда надо создать переменную, многие разработчики просто выбирают `final`, даже не думая о `const`. Я надеюсь, что это изменится, как только вы увидите преимущества **канонических экземпляров** *(прим. подробнее [о канонических экземплярах](https://stackoverflow.com/questions/280107/what-does-the-term-canonical-form-or-canonical-representation-in-java-mean))*. Но сначала...
Встроенные константы
--------------------
Литералы типов в Dart являются константами. Написание строковых литералов таких, как `"hello"`, или числовых литералов таких, как `3.14`, в коде естественным образом создает объекты, которые известны во время компиляции.
Более того, даже литералы коллекций могут быть присвоены константам.
```
void run() {
const myList = [1, 2, 3];
const myMap = {'one': 1};
const mySet = {1, 2, 3};
}
```
> Примечание: также внутри литералов коллекций можно использовать генерацию списка, **[if](https://dart.dev/guides/language/language-tour#collection-operators)**, `spread` оператор, проверку и приведение типов.
Взгляд компилятора на константы
-------------------------------
Как вы уже могли заметить, с точки зрения программиста между константами `const` и `final` практически нет разницы, кроме того, что с константами работать сложнее. Однако у компилятора Dart есть совершенно другая пара глаз, и он видит огромную разницу, проиллюстрированную на фрагменте кода ниже. **Выделенные ниже** части кода рассматриваются компилятором **как константы**.
Это может быть неочевидно на первый взгляд, но есть большое преимущество в том, когда не только значение константно, но и сама переменная. Такие переменные могут быть использованы далее по коду в местах, требующих констант.
```
void run() {
final finalVariable = 123456;
const constVariable = 123456;
const notWorking = finalVariable; // ошибка
const working = constVariable;
}
```
Возможно, передача значений одних констант другим – это не то, что вы делаете каждый день, но есть место, где это может быть полезным...
Константные конструкторы
------------------------
У многих классов во Flutter есть `const` конструкторы, например, у [EdgeInsets](https://api.flutter.dev/flutter/painting/EdgeInsets-class.html), используемого для определения отступов. Это чрезвычайно полезно с точки зрения производительности из-за того, что известно как **канонические экземпляры**.
> Если в приложении вы напишите сотни раз `const EdgeInsets.all(8)`, то ваша память **не** будет загромождена сотнями различных экземпляров. Вместо этого всякий раз, когда вы определяете одни и те же аргументы для `const` конструктора или фабрики, будет использован один и тот же канонический экземпляр.
Разумеется, вы можете создать свой собственный класс с `const` конструктор. Есть только одно правило: все поля таких классов являются `final` и могут хранить константное значение.
```
class MyConstClass {
final int field1;
final List field2;
const MyConstClass(this.field1, this.field2);
}
void run() {
// прокидываем в качестве аргумента константную переменную
const constVariable = 123456;
const x = MyConstClass(constVariable, ['hello', 'there']);
}
```
Это означает, что у вас не может быть поля типа, в котором нет `const` конструктора.
```
class MyWannabeConstClass {
// у Future нет const конструктора или фабрики
final Future field;
// Dart позволяет определить, казалось бы, бессмысленный конструктор:
const MyWannabeConstClass(this.field);
}
void run() {
// Dart не позволяет нам использовать конструктор const:
const x = MyWannabeConstClass(Future.value(123)); // ошибка
}
```
Так почему же Dart позволяет нам определить конструктор, который, по идее, всегда "ломается"? А потому что он отработает без падений, если к нему обратиться иначе. Наличие у класса `const` конструктора не означает, что вы всегда должны получать канонические экземпляры. Вы также можете создавать обычные экземпляры.
```
void run() {
// Передача Future не вызовет ошибки при работе с неконстантным конструктором
final implicitNew = MyWannabeConstClass(Future.value(123));
final explicitNew = new MyWannabeConstClass(Future.value(123));
}
```
Возможность создания новых неканонических экземпляров класса с помощью конструктора `const` меня несколько расстраивает, поскольку мы теряем все удивительные преимущества в производительности при повторном использовании одного и того же экземпляра тысячи раз, а то и больше, в большом Flutter приложении.
Как вы можете видеть выше, замена ключевого слова `const` на `final` автоматически приводит к созданию нового экземпляра.
Так же, как ключевое слово `new` является необязательным при создании новых экземпляров, ключевое слово `const` необязательно при попытке получить существующие канонические экземпляры.
```
void run() {
const implicitConst = MyConstClass(1);
const explicitConst = const MyConstClass(1);
}
```
Но все же важно явно указывать вызов `const` конструктора, когда вы хотите сохранить константное значение, например, канонический экземпляр внутри неконстантной переменной.
```
void run() {
final regularVariable = const MyConstClass(1);
}
```
Заключение
----------
Надеюсь, это руководство смогло прояснить значение `const` конструкторов и в целом констант в Dart. Попробуйте использовать `const`, где это возможно, и вы внесете небольшие улучшения по производительности в свои приложения строка за строкой. А вы знаете, как это бывает с небольшими улучшениями, — они дают общий результат. | https://habr.com/ru/post/501804/ | null | ru | null |
# Работа с иерархиями в lsFusion
В различных приложениях часто возникает потребность в реализации иерархического представления объектов. Как правило, это используется для их классификации путем задания групп. Эти группы образуют дерево динамической глубины, которая в дальнейшем используется для навигации, агрегирования данных, задания параметров.
В этой статье я покажу, каким образом эту логику можно реализовать в открытой и бесплатной платформе [lsFusion](https://lsfusion.org).
В качестве примера возьмем простую логику, в которой нужно реализовать логику товаров, объединенных в определенные группы, которые образуют иерархию динамической глубины. При этом товар может быть привязан и к промежуточному узлу дерева.
Для начала по стандартной схеме объявим сущность *Группа товаров* в виде простого плоского класса с формами редактирования и списка:
| |
| --- |
| `CLASS Group 'Группа';
name 'Имя' = DATA ISTRING[50] (Group);
FORM group 'Группа'
OBJECTS g = Group PANEL
PROPERTIES(g) name
EDIT Group OBJECT g
;
FORM groups 'Группы'
OBJECTS g = Group
PROPERTIES(g) READONLY name
PROPERTIES(g) NEWSESSION NEW, EDIT, DELETE
LIST Group OBJECT g
;
NAVIGATOR {
NEW groups;
}` |
Теперь сделаем из групп иерархию. Для этого введем свойство, которое будет содержать ссылку на родительскую группу:
| |
| --- |
| `parent = DATA Group (Group);
nameParent 'Родительская группа' (Group g) = name(parent(g));` |
Дальше сделаем свойство, которое будет рекурсивно определять связь между двумя группами:
| |
| --- |
| `level 'Уровень' (Group child, Group parent) =
RECURSION 1l IF child IS Group AND parent = child
STEP 2l IF parent = parent($parent) MATERIALIZED;` |
По какому именно принципу работает оператор *RECURSION*, в данной статье я описывать не буду, но свойство *level* будет возвращать 2 в степени “длина пути между *child* и *parent* в соответствующем направленном дереве”. *MATERIALIZED* указывает, что платформа должна хранить его в отдельной таблице, где для каждой пары связанных узлов будет отдельная запись со значением *level* в соответствующей колонке. При любом изменении структуры дерева эта таблица будет автоматически пересчитываться.
Например, для вот такого дерева:
Таблица будет выглядеть вот так:
В ней *key0* — это код потомка, а *key1* — код родителя. Количество записей в этой таблице будет приблизительно равно количеству групп, умноженное на среднюю глубину дерева. Такая схема хранения будет полезна тем, что при необходимости считать всех потомков группы не придется прибегать к CTE запросам, а можно будет воспользоваться обычным JOIN к этой таблице.
Дальше на основании построенного свойства можно высчитать каноническое имя группы:
| |
| --- |
| `canonicalName 'Каноническое имя' (Group group) =
GROUP CONCAT name(Group parent), ' / ' ORDER DESC level(group, parent) CHARWIDTH 50;` |
Например, для группы *Молоко* на приведенной выше картинке каноническое имя будет *равно Все / Продовольственные товары / Молочные продукты / Молоко*. *CHARWIDTH* указывается для того, чтобы сказать платформе какую под это свойство отводить ширину (в символах) при построении интерфейса.
Теперь расширим форму просмотра и редактирования групп вновь созданными свойствами:
| |
| --- |
| `EXTEND FORM group
PROPERTIES(g) nameParent, canonicalName
;
EXTEND FORM groups
PROPERTIES(g) READONLY nameParent, canonicalName
;` |
Форма со списком групп в плоском виде будет выглядеть следующим образом:
После того, как логика групп завершена, добавляем сущность *Товар*:
| |
| --- |
| `CLASS Product 'Товар';
name 'Имя' = DATA ISTRING[50] (Product);` |
Создаем ссылку товара на группу товара, к которой он относится:
| |
| --- |
| `group 'Группа' = DATA Group (Product);
canonicalNameGroup 'Каноническое имя группы' (Product p) = canonicalName(group(p));` |
Наконец, сделаем форму по вводу товаров, в которой будет два элемента: дерево групп и список товаров. Для выбранной группы дерева в списке будут отображаться только товары, которые принадлежат любому потомку выбранного узла. Сначала объявим форму и добавим на нее дерево со списком групп:
| |
| --- |
| `FORM products 'Товары'
TREE groups g = Group PARENT parent
PROPERTIES READONLY name(g)
;` |
При помощи команды *TREE* создается дерево из объектов класса *Group*, иерархия которых определяется по ранее созданному свойству *parent*.
Добавляем форму в навигатор:
| |
| --- |
| `NAVIGATOR {
NEW products;
}` |
В данном примере, ввод и редактирование товаров будут осуществляться не через отдельные диалоги, а непосредственно в самой форме. Для этого создадим действие по созданию товара с привязкой к выбранной группе:
| |
| --- |
| `newProduct 'Добавить' (Group g) {
NEW p = Product {
group(p) <- g;
}
}` |
Теперь, на созданную ранее форму, добавляем список товаров с редактируемыми колонками:
| |
| --- |
| `EXTEND FORM products
OBJECTS p = Product
PROPERTIES(p) name, canonicalNameGroup
FILTERS level(group(p), g)
;` |
Закидываем на форму кнопки по добавлению и удалению товаров:
| |
| --- |
| `EXTEND FORM products
PROPERTIES newProduct(g) DRAW p TOOLBAR, DELETE(p)
;` |
Так как действие *newProduct* определено для группы товаров, то в явную нужно указать, что оно должно быть добавлено в тулбар со списком товаров (p).
Осталось настроить дизайн, чтобы дерево отображалось слева, а список товаров — справа, а между ними был разделитель, при помощи которого можно изменять размеры объектов:
| |
| --- |
| `DESIGN products {
OBJECTS {
NEW pane {
type = SPLITH;
fill = 1;
MOVE BOX(TREE groups);
MOVE BOX(p);
}
}
}` |
Итоговая форма будет выглядеть следующим образом:
После того, как иерархия товаров и групп создана, часто возникает потребность в задании некоторого параметра на любом из уровней. При этом, чем на более низком уровне иерархии он задан, тем его значение приоритетнее. Например, если для группы *Молочная продукция* задано значение 30, а для группы *Молоко* — 20, то выбраться должно последнее из них.
Предположим нужно таким образом определить параметр *Надбавка*. Для этого нужно сначала создать соответствующее свойство для группы:
| |
| --- |
| `markup 'Надбавка, %' = DATA NUMERIC[10,2] (Group);` |
Для того, чтобы найти нужное значение, достаточно просто воспользоваться группировкой с выбором последнего значения:
| |
| --- |
| `parentMarkup 'Надбавка (от верхней группы), %' (Group child) =
GROUP LAST markup(Group parent) ORDER DESC level(child, parent) WHERE markup(parent);` |
Если переводить на обычный язык, то это выражение находит (*GROUP*) последнюю (*LAST*) надбавку (*markup*) по верхней группе (*Group parent*), в порядке убывания расстояния до нее (*ORDER DESC level(child, parent)*), для которой эта надбавка задана (*WHERE markup(parent)*). Здесь хочется отметить, насколько язык lsFusion соответствует естественному языку.
Добавим созданные выше свойства на форму с товарами в дерево групп:
| |
| --- |
| `EXTEND FORM products
PROPERTIES (g) markup, parentMarkup READONLY
;` |
Предположим, что существует потребность задавать надбавку непосредственно для товара, и чтобы она была приоритетнее надбавки для группы. Для этого сначала создаем первичное свойство для товара:
| |
| --- |
| `dataMarkup 'Надбавка по товару, %' = DATA NUMERIC[10,2] (Product);` |
Затем объявляем свойство, которое будет возвращать надбавку от товара, если она задана, или надбавку от группы:
| |
| --- |
| `markup 'Надбавка, %' (Product p) = OVERRIDE dataMarkup(p), parentMarkup(group(p));` |
После этого добавляем оба свойства на форму:
| |
| --- |
| `EXTEND FORM products
PROPERTIES(p) dataMarkup, markup READONLY
;` |
Механизм задания надбавок для групп и товаров будет выглядеть следующим образом:
### Заключение
В приведенной статье мы смогли создать логику товаров, объединить их в группы с иерархией динамической глубины, а также предоставить пользователю возможность задавать надбавки на любом из уровней. Все это заняло около 70 значимых строчек кода. Попробовать, как это работает в онлайне, а также внести свои изменения в код, можно в соответствующем [разделе](https://lsfusion.org/try) сайта (вкладка Платформа). Вот весь исходный код, который нужно вставить в соответствующее поле:
**Исходный код**
| |
| --- |
| `CLASS Group 'Группа';
name 'Имя' = DATA ISTRING[50] (Group);
FORM group 'Группа'
OBJECTS g = Group PANEL
PROPERTIES(g) name
EDIT Group OBJECT g
;
FORM groups 'Группы'
OBJECTS g = Group
PROPERTIES(g) READONLY name
PROPERTIES(g) NEWSESSION NEW, EDIT, DELETE
LIST Group OBJECT g
;
NAVIGATOR {
NEW groups;
}
parent = DATA Group (Group);
nameParent 'Родительская группа' (Group g) = name(parent(g));
level 'Уровень' (Group child, Group parent) =
RECURSION 1l IF child IS Group AND parent = child
STEP 2l IF parent = parent($parent) MATERIALIZED;
canonicalName 'Каноническое имя' (Group group) =
GROUP CONCAT name(Group parent), ' / ' ORDER DESC level(group, parent) CHARWIDTH 50;
EXTEND FORM group
PROPERTIES(g) nameParent, canonicalName
;
EXTEND FORM groups
PROPERTIES(g) READONLY nameParent, canonicalName
;
CLASS Product 'Товар';
name 'Имя' = DATA ISTRING[50] (Product);
group 'Группа' = DATA Group (Product);
canonicalNameGroup 'Каноническое имя группы' (Product p) = canonicalName(group(p));
FORM products 'Товары'
TREE groups g = Group PARENT parent
PROPERTIES READONLY name(g)
;
NAVIGATOR {
NEW products;
}
newProduct 'Добавить' (Group g) {
NEW p = Product {
group(p) <- g;
}
}
EXTEND FORM products
OBJECTS p = Product
PROPERTIES(p) name, canonicalNameGroup
FILTERS level(group(p), g)
;
EXTEND FORM products
PROPERTIES newProduct(g) DRAW p TOOLBAR, DELETE(p)
;
DESIGN products {
OBJECTS {
NEW pane {
type = SPLITH;
fill = 1;
MOVE BOX(TREE groups);
MOVE BOX(p);
}
}
}
markup 'Надбавка, %' = DATA NUMERIC[10,2] (Group);
parentMarkup 'Надбавка (от верхней группы), %' (Group child) =
GROUP LAST markup(Group parent) ORDER DESC level(child, parent) WHERE markup(parent);
EXTEND FORM products
PROPERTIES (g) markup, parentMarkup READONLY
;
dataMarkup 'Надбавка по товару, %' = DATA NUMERIC[10,2] (Product);
markup 'Надбавка, %' (Product p) = OVERRIDE dataMarkup(p), parentMarkup(group(p));
EXTEND FORM products
PROPERTIES(p) dataMarkup, markup READONLY
;` |
Описанный выше шаблон может различным образом модифицироваться и использоваться путем добавления дополнительных параметров в свойства. Например, в одной из реализаций [ERP-системы](https://github.com/lsfusion-solutions/erp) надбавки для групп и товаров задаются подобным образом не глобально, а для каждого вида цены отдельно. При этом реализация по сложности ничем не отличается от описанного выше примера. | https://habr.com/ru/post/468047/ | null | ru | null |
# Японская поэзия на службе изучения английского: приложение для запоминания произношения слов
Одним из самых необычных проектов нашего осеннего хакатона был Skyeng Haiku: медитативное мультимедийное приложение про сбор слов в строчки. Сегодня его авторы расскажут, что это, зачем оно нужно, почему полезно, как они его сделали, ну и дадут ссылку на рабочую версию.
*Мы продолжаем публиковать рассказы о проектах, доведенных до состояния MVP во время [нашего двухдневного марафона](https://habrahabr.ru/company/skyeng/blog/339248/).*
### Задумка
В основе была идея помочь ученикам запоминать правильное произношение слов. Среди характерных ошибок произношения – проговаривание букв, которые на самом деле или беззвучны, или образуют дифтонги. Хотелось придумать что-то, что бы избавило от этой вредной привычки. Так появилась тема с [хайку](https://ru.wikipedia.org/wiki/%D0%A5%D0%B0%D0%B9%D0%BA%D1%83): это короткое стихотворение из трех строк, в котором не нужна рифма, но соблюдается правило: в первой строке 5 слогов, во второй 7, и в третьей снова 5. Например:
*Patient little snail
Slides across the morning dew
In the zen garden*
**Примечание**
Современная поэтическая мысль отказывается от единой 17-сложной структуры хайку для иностранных языков, но в нашем случае строгое ограничение количества слогов было важно.
Еще источник вдохновения – [Magnetic Poetry](http://play.magneticpoetry.com/poem/Original/kit/): наборы магнитиков на холодильник, из которых можно собирать стихотворения; забава, придуманная американским поэтом-песенником во время творческого кризиса. Дополнительная плюшка — у Magnetic Poetry можно скачать готовые наборы слов (грамотно подобранные по количеству слогов, соотношению частей речи и т.д.); как раз то, что было нужно для MVP-версии.
Соединив хайку и «магнетическую поэзию», мы получаем прототип продукта, где пользователю нужно перетаскивать слова из набора в соответствии с правилом 5-7-5 слогов. Смысл и грамматика не важны, важно понимание количества слогов в каждом слове, японский антураж, фоновая музыка и озвучка получившегося стихотворения. Чем безумнее будет его содержание, тем лучше – сработают мнемонические связи, слово запомнится.
### Движок
Простенькое приложение на пару десятков строк кода, написанное на фреймворке [vue.js](https://vuejs.org/). Это один из набирающих популярность фреймворков для написания «богатых» приложений, его часто [сравнивают с Angular, React](https://habrahabr.ru/post/338068/) и им подобным. У автора движка в реальной рабочей жизни нет возможности что-либо писать руками, поэтому хакатон помог вспомнить навыки и попутно подкинул идею для хобби – сейчас движок периодически немного допиливается по выходным.
Приложение состоит из нескольких компонентов:
**слово** — минимальный компонент, с которым работает приложение, знает только про себя и количество слогов в себе
**строка** — умеет подсчитывать количество слогов во входящих в нее словах и сигнализировать, когда достигнуто нужное значение слогов (в нашем случае таких строк три, но вообще может быть произвольное количество, это задается через настройки приложения)
**плеер**, управляющий проигрыванием музыки
**компонент SpeakFromMyHeart**, склеивающий слова в строках в текст и проигрывающий синтезированную речь
и, конечно, **основное приложение**, которое собирает это все вместе, отслеживает состояние хайку в целом, управляет подгрузкой слов, проигрывает звуки интерфейса. Напрашивается дальнейшее разделение логики по компонентам, в какой-нибудь выходной так и сделаем.
Для перетаскивания слов пробовали несколько библиотек драг-н-дропа, остановились на [Dragula](https://github.com/bevacqua/dragula). Как выяснилось, она хорошо работает на десктопе, но странно на мобильных устройствах – вместе со словом перетаскивается весь экран. Все, кто проходил мимо группы разработки, пытался как-то помочь, за что им спасибо, но решить проблему за время хакатона так и не получилось. В дальнейшем Dragula и vue-dragula были заменены на [VDDL для drag-and-drop](http://hejx.space/vddl), потому что эта библиотека лучше документирована и не имеет проблем с вложенными компонентами
### Определение слогов
На свете есть ряд библиотек, которые призваны помогать поэтам, ищущим рифмы: они дают оценки слов, подсказывают, сколько в рифмующемся слове должно быть слогов и т.д. Изначально предполагалось использовать [Words API](https://www.wordsapi.com/) – самую известную такую библиотеку, умеющую, помимо прочего, определять количество слогов в слове. Однако в ходе ее тестирования появились некоторые сомнения относительно корректности выдаваемых результатов, а возможности разрулить эти сомнения с помощью методистов на хакатоне не было.
Поэтому решили, что уж коли у нас и так фиксированный набор слов, то для MVP будет проще посчитать слоги вручную, а Words API пока отключить и разобраться после хакатона. Сейчас мы пришли к выводу, что глюк скорее посетил нас, а не эту библиотеку – при работе с произвольными наборами слов будем использовать ее.
### Озвучка
Эксперименты с озвучкой получающихся строк были веселые. Для нас важна атмосфера приложения – нужен был печальный задумчивый голос… ну, хайку же. Сперва мы пробовали использовать встроенную озвучку с [Web Speech API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Speech_API). Выяснилось, что набор голосов зависит от платформы и браузера: например, на Маке получался приятный женский тембр, а на Ubuntu – довольно-таки отвратительный. Поигравшись с наборами, мы в итоге пришли к Amazon Polly, где есть голос, чем-то напоминающий атмосферу «Твин Пикс». Работать с Полли одно удовольствие – ей отправляется сгенерированная строка, она в ответ присылает поток байтов, который надо отправить в браузер с соответствующими заголовками для проигрывания. Полли поддерживает разметку SSML, позволяющую выбирать голоса, размечать интонацию, паузы, скорость и т.д. Например, вот так:
```
Слова из первой строкиСлова из второй строкиСлова из третьей строки
```
— задаем медленную речь с задумчивыми паузами между строками.
Сперва, кстати, мы задействовали библиотечку [ChattyKathy](https://github.com/ejbeaty/ChattyKathy), небольшую обертку AWS SDК, позволяющую очень легко использовать его для отправки запроса к Polly и проигрывания синтезированной речи. Но в итоге стали синтезировать речь на бэкенде, чтобы не заморачиваться с авторизацией через AmazonCognito.
Проблема Полли в том, что она платная. Для хакатона это мелочь, но выкладывать наружу мы ее не можем, поэтому услышать, как звучали наши хайку на хакатоне, в текущей версии нельзя – только на видео:
Ну а мы пока [вернулись к Web Speech API](http://haikuthon.herokuapp.com/) (да, это ссылка на текущую версию). В отличие от Полли, он пока не поддерживает SSML, экспериментальный (поддерживается не всеми браузерами), зато бесплатный.
Кстати, в «Хроме» нашли забавный баг: по спецификации Web Speech API, если в тексте встречается неподдерживаемый тег, он должен игнорироваться; «Хром» же зачитывает всю разметку. Мы не сразу поняли, что происходит, когда в первый раз услышали из динамиков 'less then prosody rate equals slash…'
### Возможности развития
* Подключение пользовательских наборов слов из Words. Совмещая слова на изучение со служебными и вспомогательными словами, можно расширять словарь и составлять новые фразы. Здесь кроется сложность: нужно, чтобы, во-первых, в наборе было достаточно слов разной длины для составления хайку, а во-вторых, пользовательский набор надо разбавлять словами общей лексики и следить за разнообразием частей речи. А это уже тема для отдельного достаточно сложного продукта.
* Интеграция в Vimbox. У нас есть раздел с играми, пока в зачаточном состоянии, и его нужно развивать. Возможно, дать к нему доступ не только ученикам, но и тем, кто только задумывается об обучении в Skyeng — в качестве завлекалки.
* Standalone приложение для мобильных платформ. Подключаем новые медиа ресурсы: музыку и темы. В первую очередь — ночной режим с темным фоном и пониженной контрастностью, чтобы залипать в кровати перед сном.
* Добавление геймификации – счетчик времени, игра вдвоем и т.д.
* Возможность делиться результатами в соцсетях.
На всякий случай, еще раз [ссылка на текущую версию Skyeng Haiku](http://haikuthon.herokuapp.com/).
Ну и как всегда напоминаем, что мы [активно ищем таланты](https://moikrug.ru/companies/skyeng/vacancies)! Приходите к нам работать, у нас весело!
 | https://habr.com/ru/post/344678/ | null | ru | null |
# POHMELFS: NFS по-новому
Те, кто следил за обновлениями ядра, могли заметить, что в релиз 2.6.30 была добавлена поддержка POHMELFS.
Что же это такое — Похмельная файлуха?
Изучение окрестностей [странички](http://www.ioremap.net/projects/pohmelfs) проекта позволило предположить, что разработку ФС ведет московский программист Евгений Поляков (и только он!), у которого на том же сайте есть немало других интересных проектов, таких, например, как [порт CARP под Linux](http://www.ioremap.net/projects/carp). В общем, сложилось впечатление, что программист на редкость грамотный и упорный.
Вернемся к **PohmelFS**. [статья](http://en.wikipedia.org/wiki/POHMELFS) в Википедии подтверждает причастность похмелья к названию, которое для приличия расшифровывается как **Parallel Optimized Host Message Exchange Layered File System**. Документация на страничке проекта говорит о том, что в перспективе PohmelFS — распределенная ФС с избыточностью, контролем доступа и прочими прелестями, разрабатываемая так, чтобы не сильно отставать по производительности от локальных ФС. Этакая альтернатива разнообразным GFS, GlusterFS и прочим Coda. Но это все будет после интеграции проекта с двумя другими — [DST](http://www.ioremap.net/projects/dst) и [Elliptics](http://www.ioremap.net/projects/elliptics). На текущий момент PohmelFS — это альтернатива старому недоброму NFS, почти всюду показывающая бо́ льшую производительность ([пруфлинк](http://www.ioremap.net/node/134)).
под хабракатом процесс настройки на небольшом зоопарке
Вещь новая, неизвестная, как ею пользоваться — никто толком не знает. Я в Сети нашел один-единственный howto, и тот не особо толковый. Поэтому здесь публикую грамотный (на мой взгляд) метод элементарной настройки.
Первое, что надо сделать — это скачать исходники ядра 2.6.30 и собрать ядро с модулем pohmelfs. На момент публикации драйвер имеел статус staging, поэтому его включение в menuconfig нетривиально. Нужно включить опцию **Device Drivers -> Staging drivers** и *выключить* **Device Drivers -> Staging drivers -> Exclude Staging drivers from being built**, после чего можно включать POHMELFS, находящийся там же.
Следует отметить, что ядро надо обновлять *только* на клиенте. Серверная часть работает в userspace.
Второе, что нужно для работы ФС — userspace утилиты и сервер. Нужно компилировать исходники. Я скачал [отсюда](http://www.ioremap.net/cgi-bin/gitweb.cgi?p=pohmelfs-server.git;a=summary) последний снэпшот pohmelfs-server.git. Тем, кто будет делать так же, подскажу, что снэпшоты раздаются в формате tar.bz2, о чем нужно если не знать, то догадываться.
Распаковываем, читаем README, подкладываем /usr/src/linux/drivers/staging/pohmelfs/netfs.h туда, куда рекомендует начало README, то есть, /usr/src/linux/fs/pohmelfs/netfs.h (это очень важно, поскольку на сервере этому файлу взяться неоткуда, а для сборки сервера он необходим). Аккуратно, путь к исходникам ядра может быть другим. После этого
`$ ./autogen.sh
$ ./configure`
автоген может на что-нибудь пожаловаться, это лечится очевидным способом.
А вот configure у меня под Gentoo ругался на невозможность найти инклюды POHMELFS, и только при чтении лога выяснилось, что проблема, на самом деле, не в netfs.h, а в bitsperlong.h, который он по каким-то неведомым причинам не нашел. Пришлось конфигурить так:
`$ CPPFLAGS=-I/usr/src/linux-2.6.30-git18/arch/x86/include ./configure --with-kdir-path=/usr/src/linux`
Далее можно делать make, тогда он соберет все, что может. Я пошел другим путем.
На сервере сборка и установка выглядела так:
`$ cd server; make
# cp fserver /usr/local/sbin`
На клиенте, в свою очередь:
`$ cd cfg; make; cd ../utils; make; cd ..
# cp cfg/cfg /usr/local/sbin/pohmelcfg; cp utils/flush /usr/local/sbin/pohmelflush`
Это важное отступление от Makefile, поскольку теперь на сервере установлена только серверная часть, а на клиенте — только клиентская, а пока что ненужные инклюды не установлены вообще. Также переименованы клиентские бинарники в более понятные названия, поскольку, например, «cfg» абсолютно не говорит о том, что конфигурирует он только pohmelfs.
Юзерспейс утилиты успешно собрались как на Gentoo x86\_64, так и на Arch Linux i686.
Наступает момент истины. Запускаем!
Сначала запустим серверную часть. fserver работает в фореграунде, поэтому для начала сделаем вот так:
`# /usr/local/sbin/fserver -a 192.168.1.10 -r /mnt/HD_a2/ -w5 2>&1 >>/var/log/fserver.log &`
(Подставьте желаемые параметры, -w — это количество рабочих процессов)
Далее — настройка и монтирование ФС на клиенте.
`# modprobe pohmelfs
# pohmelcfg -A add -a 192.168.1.10 -p 1025 -i 1
# mount -t pohmel -o idx=1 /mnt/pohmel`
Здесь -i для cfg и idx= для mount должны быть одинаковыми, по умолчанию 0. Как я понял, это просто ID монтируемой расшарки.
У меня запуск сервера и кллиента не вызвал никаких трудностей, все сразу заработало.
Маленький тест на производительность (файл весом в 700МБ):
`stolen@stolen ~/soft/pohmelfs-server.git $ time cat /mnt/pohmel/share/GRTMPVOL_RU_20.10.08.iso >/dev/null
real 1m37.150s
user 0m0.010s
sys 0m1.270s
stolen@stolen ~/soft/pohmelfs-server.git $ time cat /mnt/pohmel/share/GRTMPVOL_RU_20.10.08.iso >/dev/null
real 0m0.591s
user 0m0.003s
sys 0m0.257s
stolen@stolen ~/soft/pohmelfs-server.git $ time cat /mnt/upload/share/GRTMPVOL_RU_20.10.08.iso >/dev/null
real 1m3.719s
user 0m0.003s
sys 0m0.400s`
Третье — NFS, немного выигравающий по чтению. По записи 100МБ POHMELFS оказался в 10 раз быстрее, видимо, за счет фонового I/O. | https://habr.com/ru/post/62685/ | null | ru | null |
# Kaggle: Amazon from Space — трюки и хаки при обучении нейросетей
Летом прошлого года закончилось [соревнование](https://www.kaggle.com/c/planet-understanding-the-amazon-from-space) на площадке kaggle, которое было посвящено классификации спутниковых снимков лесов Амазонки. Наша команда заняла 7 место из 900+ участников. Не смотря на то, что соревнование закончилось давно, почти все приемы нашего решения применимы до сих пор, причём не только для соревнований, но и для обучения нейросетей для прода. За подробностями под кат.
**tldr.py**
```
import kaggle
from ods import albu, alno, kostia, n01z3, nizhib, romul, ternaus
from dataset import x_train, y_train, x_test
oof_train, oof_test = [], []
for member in [albu, alno, kostia, n01z3, nizhib, romul, ternaus]:
for model in member.models:
model.fit_10folds(x_train, y_train, config=member.fit_config)
oof_train.append(model.predict_oof_tta(x_train, config=member.tta_config))
oof_test.append(model.predict_oof_tta(x_test, config=member.tta_config))
for model in albu.second_level:
model.fit(oof_train)
y_test = model.predict_proba(oof_test)
y_test = kostia.bayes_f2_opt(y_test)
kaggle.submit(y_test)
```
Описание задачи
Planet подготовила набор спутниковых снимков в двух форматах:
1. TIF — 16 bit RGB + N, где N — Near Infra Red
2. JPG — 8bit RGB, которые производные от TIF и которые были предоставлены для уменьшения порога входа в задачу, а также для упрощения визуализации. В предыдущем соревновании на Kaggle, необходимо было работать с мультиспектральными изображениями. невизуальные, то есть инфракрасный, а также каналы с большей длиной волны очень сильно улучшали качество предсказания, причем как сети, так и unsupervised методы.
Географически данные были взяты с территории бассейна реки Амазонки, и с территорий стран Бразилия, Перу, Уругвай, Колумбия, Венесуэла, Гайана, Боливия и Эквадор, в которых были выбраны интересные участки поверхности, снимки с которых и были предложены участникам.
После того, как из tif создавались jpg, все сцены резались на мелкие куски размером 256x256. И по полученным jpg силами работников Planet из Берлинского и Сан Францисского офиса, а также через платформу Crowd Flower, производилась маркировка.
Перед участниками ставилась задача для каждого 256x256 тайла предсказать одну из взаимоисключающих погодных меток:
Cloudy, Partly cloudy, Haze, Clear
А также 0 или более непогодных: Agriculture, Primary, Selective Logging, Habitation, Water, Roads, Shifting Cultivation, Blooming, Conventional Mining
Итого 4 погодных и 13 не погодных, причем погодные взаимоисключающие, а непогодные нет, но при этом если на картинке метка cloudy, то других меток там не должно быть.
Точность модели оценивалась по метрике F2:
Причем все метки имели одинаковый вес и сначала высчитывалось F2 по каждой картинке, а потом шло общее усреднение. Обычно делают чуть по другому, то есть высчитывается некая метрика по каждому классу, а потом усредняется. Логика в том, что последний вариант более интерпретируем, так как позволяет ответить на вопрос как модель себя ведет на каждом конкретном классе. В данном случае организаторы пошли по первому варианту, что, видимо, связано со спецификой их бизнеса.
Всего в трейне 40к сэмплов. В тесте 40к. Из-за небольшого размера датасета, но большого размера картинок, можно сказать, что это “MNIST на стероидах”
**Лирическое отступление**
Как видно из описания, задача довольно понятна и решение не представляет из себя рокет саенс: нужно просто зафайнтюнить сетку. А с учетом специфики кэггла, еще и настакать кучу моделей поверх. Однако, чтобы получить золотую медаль, необходимо не просто как-то обучить кучу моделей. Крайне важно иметь много базовых разнообразных моделей, каждая из которых сама по себе показывает выдающийся результат. И уже поверх этих моделей можно накручивать стэккинг и другие хаки.
| member | net | 1crop | TTA | diff, % |
| --- | --- | --- | --- | --- |
| alno | densenet121 | 0.9278 | 0.9294 | 0.1736 |
| nizhib | densenet169 | 0.9243 | 0.9277 | 0.3733 |
| romul | vgg16 | 0.9266 | 0.9267 | 0.0186 |
| ternaus | densenet121 | 0.9232 | 0.9241 | 0.0921 |
| albu | densenet121 | 0.9294 | 0.9312 | 0.1933 |
| kostia | resnet50 | 0.9262 | 0.9271 | 0.0907 |
| n01z3 | resnext50 | 0.9281 | 0.9298 | 0.1896 |
В таблице приведены F2 score моделей всех участников для single crop и TTA. Как видно, разница невелика для реального использования, однако это важно для режима соревнования.
**Командное взаимодействие**
Александр Буслаев *[albu](https://habr.com/users/albu/)*
На момент участия в соревновании руководил всем мл направлением в компании Geoscan. Но с тех пор затащил кучу соревнований, стал отцов вся ODS по семантической сегментации и уехал в Минск, грести в Mapbox, про что вышла [статья](https://dev.by/lenta/main/zachem-pobeditel-kaggle-i-topcoder-pereehal-v-minsk?utm_source=twitter.com&utm_medium=social&utm_campaign=4-h-kratnyy-pobeditel-sorevnovaniy-po-m)
Алексей Носков *[alno](https://habr.com/users/alno/)*
Универсальный мл боец. Работал в Evil Martians. Сейчас перекатился в Yandex.
Константин Лопухин *[kostialopuhin](https://habr.com/users/kostialopuhin/)*
Работал и продолжает работать в Scrapinghub. С тех пор Костя успел получить еще несколько медалей и без 5 минут Kaggle Grandmaster
Артур Кузин *[n01z3](https://habr.com/users/n01z3/)*
На момент участия в этом соревновании я работал в Avito. Но в районе нового года перекатился в блокчейн стартап [Dbrain](https://dbrain.io) на должность Lead Data Scientist. Надеюсь, скоро порадуем комьюнити своими конкурсами с докерами и ламповой разметкой.
Евгений Нижибицкий *@nizhib*
Lead Data Scientist в Rambler & Co. С этого соревнования Женя открыл в себе тайное умение находить лики в картиночных конкурсах. Что помогло ему затащить пару соревнований на платформе Topcoder. Об одном из них я [рассказывал](https://dev.by/lenta/main/zachem-pobeditel-kaggle-i-topcoder-pereehal-v-minsk?utm_source=twitter.com&utm_medium=social&utm_campaign=4-h-kratnyy-pobeditel-sorevnovaniy-po-m).
Руслан Байкулов *[romul](https://habr.com/users/romul/)*
Занимается трекингом спортивных событий в компании Constanta.
Владимир Игловиков *[ternaus](https://habr.com/users/ternaus/)*
Мог вам запомниться по остросюжетным [статье](https://habr.com/company/ods/blog/330118/) о притеснении британской разведкой. Работал в TrueAccord, но затем перекатился в модный-молодежный Lyft. Где занимается Computer Vision для Self-Driving car. Продолжается тащить соревнования и недавно получил Kaggle Grandmaster.
Наше объединение и формат участия можно назвать типичным. Решение объединиться было связано с тем, что у нас всех были близкие реузльтаты на лидерборде. И каждый из нас пилил свой независимый пайплайн, которые представлял полностью автономное решение от начала и до конца. Также после объединения несколько участников занимались стэккингом.
Первое, что мы сделали — это общие фолды. Мы сделали так, чтобы распределение классов в каждом фолде было такое же как во всем датасете. Для этого сначала выбрали самый редкий класс, стратифицировали по нему, потому оставшиеся картинки стратифицировали по второму по популярности классу и так далее пока картинок не осталось.
Гистограмма классов по фолдам:
Также у нас был общий репозиторий, где у каждого члена команды была своя папка, в рамках который он организовывал код как хотел.
И еще мы договорились о формате предиктов, поскольку это была единственная точка взаимодействия по объединению наших моделей.
**Обучение нейросетей**
Поскольку у каждого из нас была независимый пайплайн, то мы представляли собой гридсерч оптимального процесса обучения распараллеленный по людям.
**Общий подход**
Картинка из [github.com/tornadomeet/ResNet](https://github.com/tornadomeet/ResNet)
Типичный процесс обучения представлен на графике обучения Resnet нейросетей на imagenet’e. Стартуют с рандомно инициализированных весов с SGD (lr 0.1 Nesterov Momentum 0.0001 WD 0.9) и затем через 30 эпох понижают learning rate в 10 раз.
Концептуально каждый из нас использовал такой же подход, однако чтобы не состариться пока обучается каждая сеть, понижение LR происходило если на валидации лосс не падал 3-5 эпох подряд. Либо некоторые участники просто сократили количество эпох на каждом уроне LR и понижали по расписанию.
**Аугментации**
Выбор правильных аугментаций очень важен при обучении нейросетей. Аугментации должны отражать вариативность природы данных. Условно аугментации можно разделить на два типа: те, которые вносят смещение в данные, и те, которые не вносят. Под смещением можно понимать разные низкоуровневые статистики, типа гистограмм цветов или характерный размер. В этом плане, скажем, HSV аугментации и скейл — вносят смещение, а рандомный кроп — нет.
На первых стадиях обучения сети можно сильно переборщить с аугментациями и использовать очень жесткий набор. Однако ближе к концу обучения необходимо либо выключить аугментации, либо оставить только те, которые не вносят смещения. Это позволяет нейросети немного оверфитнутся под трейн и показать чуть лучший результат на валидации.
**Замораживание слоев**
В подавляющем большинстве задач нет смысла обучать нейросеть с нуля, намного эффективней файнтюнить с предобученных сетей, скажем с Imagenet. Однако можно пойти дальше и не просто менять полносвязный слой под слой с нужным количеством классов, а обучать сначала его с заморозкой всех сверток. Если не замораживать свертки и обучать сразу всю сеть с рандомно инициализированными весами полносвязного слоя, то веса сверток корраптятся и финальный перфоманс нейросети будет ниже. На этой задаче это было особенно заметно из-за небольшого размера обучающей выборки. На других соревнованиях с большим объемом данных типа cdiscount можно было отмораживать не всю нейросеть, а группы сверток начиная с конца. Таким образом можно было сильно ускорить обучение, поскольку для замороженных слоев не считались градиенты.
**Циклический отжиг**
Этот процесс выглядит так. После завершений базового процесса обучения нейросети берутся лучшие веса и процесс обучения повторяется. Но стартует он с более низкого Learning rate и происходит за короткое время, скажем 3-5 эпох. Это позволяет нейросети спуститься в более низкий локальный минимум и показать лучший перформанс. Этот поход стабильного улучшает результат в довольно широком числе конкурсов.
Более подробно про два приема [здесь](https://habr.com/post/332534/)
**Test time augmentations**
Поскольку речь идет о соревновании и у нас нет формального ограничения на время инференса, то можно использовать аугментации во время теста. Выглядит это так, что картинка искажается также, как это происходило во время обучения. Скажем, отражается по вертикали, по горизонтали, поворачивается на угол и т.д. Каждая аугментация дает новую картинку от которой получаем предсказания. Затем предсказания таких искажений одной картинки усредняются (как правило геометрическим средним). Это также дает профит. В других конкурсах я экспериментировал также с рандомными аугментациями. Скажем, можно применять не по одной, а просто уменьшить амплитуду для случайных поворотов, контрастов и цветовых аугментаций в два раза, зафиксировать сид и сделать несколько таких рандомно искаженных картинок. Это тоже давало прирост.
**Snapshot Ensembling (Multicheckpoint TTA)**
Идеей отжига можно развить дальше. На каждой стадии отжига нейросеть залетает в немного разные локальные минимумы. А это значит, что это по сути немного разные модели, которые можно усреднить. Таким образом во время предсказаний теста можно взять три лучших чекпоинта и усреднить их предсказания. Я также пробовал брать не три лучших, а три самых разнообразных из топ10 чекпоинтов — было хуже. Ну и для продакшена такой трюк не применим и я пробовал усреднять веса моделей. Это давало очень незначительный, но стабильный прирост.
**Подходы каждого члена команды**
Соответственно в той или иной степени каждый член нашей команды использовал разную комбинацию вышеописанных приемов.
| nick | Conv freeze,
epoch | Optimizer | Strategy | Augs | TTA |
| --- | --- | --- | --- | --- | --- |
| albu | 3 | SGD | 15 epoch LR decay,
Circle 13 epochs | D4,
Scale,
Offset,
Distortion,
Contrast,
Blur | D4 |
| alno | 3 | SGD | LR decay | D4,
Scale,
Offset,
Distortion,
Contrast,
Blur,
Shear,
Channel multiplier | D4 |
| n01z3 | 2 | SGD | Drop LR, patient 10 | D4,
Scale,
Distortion,
Contrast,
Blur | D4, 3 checkpoint |
| ternaus | - | Adam | Cyclic LR (1e-3: 1e-6) | D4,
Scale,
Channel add,
Contrast | D4,
random crop |
| nizhib | - | Adam | StepLR, 60 epochs, 20 per decay | D4,
RandomSizedCrop | D4,
4 corners,
center,
scale |
| kostia | 1 | Adam | | D4,
Scale,
Distortion,
Contrast,
Blur | D4 |
| romul | - | SGD | base\_lr: 0.01 — 0.02
lr = base\_lr \* (0.33 \*\* (epoch / 30))
Epoch: 50 | D4,Scale | D4, Center crop,
Corner crops |
**Стеккинг и хаки**
Каждую модель с каждым набором параметров мы обучили на 10 фолдах. И затем на out of fold (OOF) предиктах обучили модели второго уровня: Extra Trees, Linear Regression, Neural Network и просто усреднение моделей.
И уже на OOF предиктах моделей второго уровня подобрали веса для смешивания. Более подробно про стэккинг можно почитать [тут](https://mlwave.com/kaggle-ensembling-guide/) и [тут](https://habr.com/post/318518/).
В реальном продакшене как ни странно такой подход тоже имеет место. Например, когда есть разномодальные данные (картинки, текст, категории и т.д.) и хочется объединить предсказания моделей. Можно просто усреднить вероятности, но обучение модели второго уровня дает лучший результат.
**Оптимизация F2 по Баесу**
Также финальные предсказания немного тюнились используя оптимизацию по байесу. Предположим, что у нас есть идеальные вероятности, тогда F2 с наилучшим мат ожиданием (т.е. типа оптимальный) получается по такой формуле:
Что это означает? Надо перебрать все комбинации (т.е. для каждого лейбла 0 и 1), посчитать вероятность каждой комбинации, и домножить на F2 — получаем ожидаемое F2. Для какой комбинации оно лучше, да и даст оптимальный F2. Вероятности считались просто перемножением вероятностей отдельных лейблов (если у лейбла 0, берем 1 — p), а чтобы не перебирать 2 в 17 вариантов, шатались только лейблы у которых вероятность от 0.05 до 0.5 — таких было 3-7 в строке, так что вариантов немного (сабмит делался за пару минут). По идее, было бы круто получать вероятность комбинации лейблов не просто перемножая индивидуальные вероятности (т.к. лейблы не независимы), но это не зашло.
что это дало? когда модели стали хорошими, подбор порогов после ансамбля перестал работать, а эта штука давала небольшой но стабильный прирост и на валидации, и на public/private.
**Послесловие**
В итоге мы обучили 48 разных моделей, каждую на 10 фолдах, т.е. 480 моделей первого уровня. Такой человеческий гридсерч позволил попробовать разные приемы при обучении глубоких сверточных нейросетей, которые я до сих пор использую в работе и соревнованиях.
Можно ли было обучить меньше моделей и получить такой же или лучший результат? Да, вполне. Наши соотечественники с 3го места Станислав [stasg7](https://www.kaggle.com/stasg7) Семенов и Роман [ZFTurbo](https://www.kaggle.com/zfturbo) Соловьев обошлись меньшим числом моделей первого уровня и компенсировали 250+моделями второго уровня. Про решение можно [посмотреть](https://youtu.be/G5UkWXehS_s) разбор и [почитать](https://www.kaggle.com/c/planet-understanding-the-amazon-from-space/discussion/38831) пост.
Первое место занял таинственный bestfitting. Вообще этот парень очень крут, и сейчас стал топ1 рейтинга кэггла, затащив много картиночных конкурсов. Он долго оставался анонимусом, пока Nvidia не сорвала покровы, взяв у него [интервью](https://blogs.nvidia.com/blog/2017/12/12/how-a-bike-trip-led-to-a-win-for-rainforest-protection/). В котором он признался, что ему репортят 200 подчиненных… Про решение также есть [пост](https://www.kaggle.com/c/planet-understanding-the-amazon-from-space/discussion/36809).
Еще из интересного: широко известный в узких кругах [Jeremy Howard](https://www.kaggle.com/jhoward), отец [fastai](https://www.fast.ai/about/) финишировал 22м. И если подумали, что он просто по фану отправил пару сабмитов, то не угадали. Он участвовал в команде и отправил 111 посылок.
Также аспиранты Стэнфорда, которые проходили в то время легендарный курс CS231n, и которым разрешили эту задачу использовать как курсовой проект, всем коллективом закончили в середине лидерборда.
В качестве бонуса, я [выступал](https://youtu.be/lUH9QGBODPg) в Mail.ru с материалом этого поста и вот еще [презентация](https://slides.com/vladimiriglovikov/deck-5/fullscreen) Владимира Игловикова с митапа в Долине. | https://habr.com/ru/post/413667/ | null | ru | null |
# Corona SDK — игра давилка насекомых (Crush)
Пишем простую, но весьма азартную игрушку. Игра называется Crush т.е. в ней нужно будет давить насекомых, пытаясь избежать давления Ос, так как они отнимают очки, другие насекомые добавляют очки. Все насекомые имеют различные показатели размеров, награды и скорости перемещения. На игру дается определенное время поэтому в мастерстве давления правильных зверьков вы вполне сможете посоревноваться с друзьями. Лучший результат фиксируется и сохраняется в настройках игры.
Настройки проекта
-----------------
Все настройки проекта содержатся в файлах config.lua и build.settings. Все содержимое config.lua я решил удалить оставив только строку:
`application = {
}`
теперь проект на пытается на любом устройстве «думать» что экран имеет фиксированный размер 320\*480(как это было по умолчанию), мы работаем всегда с текущим разрешением экрана. В файл build.settings я добавил в секцию *settings.android.usesPermissions* новое разрешение дающее право жужжать вибросигналом при касании к осам, добавлены следующая строка: *«android.permission.VIBRATE»*, Теперь при установке приложения на устройство android спрашивает вашего разрешения на использование виброзвонка, а строка кода system.vibrate() эти права использует.
Точка входа main.lua
--------------------
Театр начинается с вешалки, а проект в короне с перовой строки файла main.lua. В этом файле принято хранить глобальные переменные и константы, а так же подключать к проекту остальные файлы которые в проекте будут нужны. В конце файла загружается главная сцена проекта.
Полный код файла main.lua имеет вид:
```
--[[ТОЧКА ВХОДА]]
--Скрыть StatusBar
display.setStatusBar (display.HiddenStatusBar)
--[[ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ]]
--параметры экрана
_W = display.contentWidth
_H = display.contentHeight
font = 'a_LCDNova'--шрифт игры
time_battle = 10--время боя
--файл игровых настроек
filePath = system.pathForFile( 'config.dat', system.DocumentsDirectory )
composer = require("composer")--инструмент работы со сценами
--пути к ресурсам
path = 'assets/images/'
path_interface = path .. 'interface/'
path_bugs = path .. 'bugs/'
path_plods = path .. 'plods/'
--подключение библиотек и сервисов
widget = require( "widget" )--GUI компоненты
ls = require "libLoadSave"--загрузка/сохранение настроек
api = require "libAPI"--универсальные функции
bugs = require "svcBugs"--сервис создания насекомых
finish = require "svcFinish"--сервис окна "Финиш"
game = require "svcGame"--статические компоненты игры
battle = nil--боевые переменные
ls.load()
--загружаем игровую сцену вместо этой строки
--можно написать game.init() и тем самым сделать файл
--scMain бесполезным, но в учебном примере лучше так
composer.gotoScene( "scMain", "crossFade", 0 )
```
Главная сцена
-------------
Файл scMain.lua — главная сцена игры. В данном проекте его применение сомнительно, так как сцена всего одна, но проект учебный и сцена может пригодится если в своих экспериментах вы решите добавить еще сцены. В главной сцене выполняется всего одно действие — запуск функции init() из библиотеки libGame. И дальше эта функция отрисовывает весь постоянный интерфейс игры, т.е. те части которые не будут удаляться до конца использования приложения. Код файла такой:
```
---------------------------------------
-- Главная и единственная сцена игры --
---------------------------------------
local scene = composer.newScene()
scene:addEventListener( "show", scene )
function scene:show( event )
if "will" == event.phase then
game.init()
end
end
return scene
```
Сервис статических компонентов игры.
------------------------------------
Этот сервис хранится в файле svcGame.lua и ее подключение к проекту выполняется строкой в main.lua: game = require «svcGame» т.е. дальше по коду для вызова функций библиотеки мы дописываем к названию game. Библиотека имеет следующие функции:
* *game.init()* — выполняется один раз, при этом создается трава, верхний и нижний бортик меню, компоненты отображения текущего и лучшего результата, кнопка запуска игры, компоненты показывающие таймер боя.
* *game. refresh()* — эта функция выполняется каждый раз при любой изменении в параметрах игры, а это убийство насекомого (*обновление счета*) и тика таймера боя (*обновление полосы прогресса*). Функция актуализирует текущее состояние всех индикаторов.
* *game. startGame()* — обработчик нажатия на кнопку start. Функция обнуляет текущий результат и запускает таймер игры на период указанный в константе time\_battle. В таймере создаются насекомые.
Полный код svcGame.lua:
```
-------------------------------------------------------
-- Сервис обслуживает статические игровые компоненты --
-------------------------------------------------------
local M = {
GR = {},--основные группы
GUI = {},--визуальные компоненты
}
--нажатие на кнопку старт
M.startGame = function(event)
if event.phase == 'ended' then
--запуск таймера боя
battle.timer = time_battle
battle.cur_score = 0
M.refresh()
--создание таймера
timer.performWithDelay(100, function(event)
if event.count%10==0 then--каждый 10-й такт
--уменьшаем таймер оставшегося времени
battle.timer = battle.timer - 1
M.refresh()
end
if event.count%2==1 then--каждый второй такт
--создаем насекомое
bugs.create(M.GR.bugs)
end
if event.count == time_battle*10 then--на последнем такте игры
--удаляем живность открываем окно результат
finish.show()
end
end,time_battle*10)
end
end
--функция обновляет параметры индикаторов
M.refresh = function()
--очки текущего результата
M.GUI.txt_count.text = battle.cur_score
--лучший рекорд
M.GUI.txt_best.text = battle.best_score
--кол-во секунд до конца боя
M.GUI.pr_txt.text = battle.timer
--полоса прогресса
M.GUI.pr.width = _W * .79 * (time_battle - battle.timer) / time_battle
M.GUI.pr.x = _W * .105 + M.GUI.pr.width * .5
--делаем видимым компоненты прогресса если таймер больше 0
M.GUI.pr.isVisible = battle.timer > 0
M.GUI.pr_txt.isVisible = battle.timer > 0
M.GUI.pr_bg.isVisible = battle.timer > 0
--делаем видимым кнопку запуска игры если таймер 0
M.GUI.btn_start.isVisible = battle.timer == 0
end
--стартовая инициализация
M.init = function()
--создаем группы
M.GR.back = display.newGroup()--группа заднего плана
M.GR.bugs = display.newGroup()--группа заднего плана
M.GR.front = display.newGroup()--группа переднего плана
--[[задний план]]
--трава
M.GUI.bg = display.newImage(M.GR.back,path_interface..'bg.jpg', _W*.5, _H * .5)
M.GUI.bg.width = _W
M.GUI.bg.height = _H
--[[передний план]]
--верхний борт меню
M.GUI.up = display.newRect(M.GR.front, _W * .5, _H * .05, _W, _H * .1)
M.GUI.up.strokeWidth = _H * .01
M.GUI.up:setStrokeColor(0,.5,0)
M.GUI.up:setFillColor(0,.3,0)
M.GUI.up:addEventListener('touch', function() return true end)--делаем бортик непробиваемым для клика
--картинка количество очков в текущем бое
M.GUI.img_count = display.newImage(M.GR.front, path_interface..'count.png', _H * .06, _H * .05)
local img = M.GUI.img_count
img.width = _H * .07
img.height = _H * .07
--текст количество очков в текущем бое
M.GUI.txt_count = display.newText(M.GR.front, '', _W * .3, _H * .05, font, _W * .1)
--картинка лучший результат
M.GUI.img_best = display.newImage(M.GR.front, path_interface..'best.png', _W * .5 + _H * .06, _H * .05)
local img = M.GUI.img_best
img.width = _H * .07
img.height = _H * .07
--text лучший результат
M.GUI.txt_best = display.newText(M.GR.front, '', _W * .8, _H * .05, font, _W * .1)
--нижний борт меню
M.GUI.down = display.newRect(M.GR.front, _W * .5, _H * .95, _W, _H * .1)
M.GUI.down.strokeWidth = _H * .01
M.GUI.down:setStrokeColor(0,.5,0)
M.GUI.down:setFillColor(0,.3,0)
M.GUI.down:addEventListener('touch', function() return true end)
--кнопка старт
M.GUI.btn_start = widget.newButton(
{
width = _H * .07,
height = _H * .07,
defaultFile = path_interface .. "btn_start_1.png",
overFile = path_interface .. "btn_start_2.png",
onEvent = M.startGame,
x = _W * .5,
y = _H * .95,
}
)
--прогресс бар
--подкладка под прогресс
M.GUI.pr_bg = display.newRoundedRect(M.GR.front, _W * .5, _H * .95, _W * .8, _H * .04, _H * .01)
M.GUI.pr_bg.strokeWidth = _H * .005
M.GUI.pr_bg:setStrokeColor(0,.5,0)
M.GUI.pr_bg:setFillColor(.4,.7,.4)
--полоска прогресса
M.GUI.pr = display.newRoundedRect(M.GR.front, _W * .5, _H * .95, _W * .79, _H * .035, _H * .006)
M.GUI.pr:setFillColor(.7,.1,.1)
--текст с остатком секунд до конца боя
M.GUI.pr_txt = display.newText(M.GR.front, '', _W * .5, _H * .955, font, _W * .07)
M.GUI.pr_txt:setFillColor(0)
--актуализируем параметры индикаторов
M.refresh()
end
return M
```
Сервис создания насекомых
-------------------------
Сервис имеет несколько составных частей, которые обслуживают возможность удобного создания живности в игре:
* *bugs.bugs* — настройки насекомых. Насекомое можно настроить, увеличив или уменьшим его доступность
* *bugs.create* — создается насекомое, вычисляется его траектория пути, отправляется в путь. На каждом насекомом имеется обработчик, который делает насекомое непробиваемы для клика, т.е. вы не можете одним кликом убить это насекомое и то которое находится под ним. Так же обработчик при клике удаляет насекомое, обновляет счет игры и вызывает функцию создания нового насекомого, если часто убивать насекомых их количество будет увеличиваться быстрей чем если просто на них смотреть.
* *bugs.plod* — создает кляксу на месте смерти насекомого. Клякса удаляется сама через пол секунды
Код сервиса svcBugs.lua имеет вид:
```
------------------------------------------------
-- Сервис обслуживает создание насекомых, --
-- содержит их характеристики и обеспечивает --
-- создание клякс после их уничтожения --
------------------------------------------------
local M = {
GR = {},--группа
bugs = {--характеристики насекомых
--клоп
{
size = {20,30},--пределы размеров - % ширины экрана
bonus = 2,--награда за уничтожение
file = '1.png',--файл с картинкой
speed = {30,50},--пределы скорости перемещения - % ширины экрана в секунду
},
--таракан
{
size = {25,35},
bonus = 3,
file = '2.png',
speed = {50,70},
},
--божья коровка
{
size = {15,25},
bonus = 3,
file = '3.png',
speed = {40,60},
},
--муравей
{
size = {20,30},
bonus = 6,
file = '4.png',
speed = {60,80},
},
--оса
{
size = {35,50},
bonus = -10,--отрицательная награда = вибрация
file = '5.png',
speed = {25,50},
},
},
AR_BUGS = {},--тут находятся все насекомые
}
--создание кляксы
M.plod = function(obj)
local count_plod = 3--всего видов клякс
--создаем случайную кляксу
local blod = display.newImage(M.GR, path_plods..math.random(count_plod)..'.png',obj.x, obj.y)
--размер кляксы равен размеру убитого насекомого
blod.width = obj.width
blod.height = obj.height
--случайный цвет (без градаций зеленого)
blod:setFillColor(math.random(),0,math.random())
--транзакция плавного скрытия
transition.to(blod,{time = 500, alpha = 0, onComplete = function()
--после скрытия происходит удаление кляксы
display.remove(blod)
end})
end
--создание насекомого
M.create = function(GR)
M.GR = GR and GR or M.GR
--выбираем настройки случайного насекомого
local sets = M.bugs[math.random(#M.bugs)]
--вычисляем параметры текущего экземпляра
local bug_sets = {
file = sets.file,
bonus = sets.bonus,
size = (math.random(sets.size[1],sets.size[2]) / 100) * _W,
speed = (math.random(sets.speed[1],sets.speed[2]) / 100) * _W,
}
--вычисляем начальную и конечную точки маршрута
local ar = {--четрые отрезка из которых нужно будет выбрать 2 разных
{x1 = 0, y1 = 0, x2 = _W, y2 = 0}, --верх
{x1 = 0, y1 = _H, x2 = _W, y2 = _H}, --низ
{x1 = -_H*.1, y1 = _H*.1, x2 = -_H*.1, y2 = _H*.9}, --справа
{x1 = _H*1.1, y1 = _H*.1, x2 = _H*1.1, y2 = _H*.9}, --слева
}
--выбираем 2 отрезка
local l1,l2 = math.random(#ar),math.random(#ar)
if l1 == l2 then
if l2 == 1 then
l2 = math.random(2,#ar)
else
l2 = l2 - 1
end
end
--получаем точки маршрута
local x1,y1 = api.get_xy_line(ar[l1])
local x2,y2 = api.get_xy_line(ar[l2])
--создаем насекомое
local n = #M.AR_BUGS+1
M.AR_BUGS[n] = display.newImage(M.GR, path_bugs..bug_sets.file, 0, 0)
M.AR_BUGS[n].width = bug_sets.size
M.AR_BUGS[n].height = bug_sets.size
M.AR_BUGS[n].x = x1
M.AR_BUGS[n].y = y1
M.AR_BUGS[n].sets = bug_sets
M.AR_BUGS[n].rotation = api.get_angle{x1 = x1, y1 = y1, x2 = x2, y2 = y2}--поворот в сторону цели
M.AR_BUGS[n]:addEventListener('touch',function(event)
if event.phase == 'began' then
api.play_sound('tits')
M.plod(event.target)
local sets = event.target.sets
battle.cur_score = battle.cur_score + sets.bonus
if sets.bonus < 0 then--если бонус меньше нуля
system.vibrate()--жужжим;)
end
game.refresh()
M.create()
display.remove(event.target)
end
return true
end)
--запускаем его в путь
local len = api.get_line_len{x1 = x1, y1 = y1, x2 = x2, y2 = y2}--длина пути
local t = len / bug_sets.speed * 1000--время в пути
transition.to(M.AR_BUGS[n],{time = t, x = x2, y = y2, onComplete = function()
display.remove(M.AR_BUGS[n])
end})
end
return M
```
Сервис «Финиш»
--------------
Этот простой сервис имеет всего одну функцию finish.show() которая вызывается в таймере боя при достижении конца сражения. Эта функция удаляет всех насекомых и открывает форму с выводом результата. Если результат выше прошлого лучшего значение выдается текст «NEW SCORE». Под формой создается защитный слой не дающий заново запустить игру до закрытия окна. При клике по окну оно закрывается результат сохранять в файл настроек. Код сервиса имеет вид:
```
------------------------------------------------
-- Сервис создает окно с результатом сражения --
------------------------------------------------
local M = {
GUI = {},
GR = {},
}
--конец игры
M.show = function()
api.play_sound('win')
--удаляем всех жуков
for k,v in pairs(bugs.AR_BUGS) do
display.remove(bugs.AR_BUGS[k])
end
--определяем наличие нового рекорда
local is_new_score = battle.cur_score > battle.best_score
if is_new_score then
battle.best_score = battle.cur_score
end
--группа для всплывающего окна
M.GR = display.newGroup()
--ставим защитный экран
M.GUI.safe = display.newRect(M.GR, _W * .5, _H * .5, _W, _H)
M.GUI.safe.alpha = .5
M.GUI.safe:setFillColor(0)
M.GUI.safe:addEventListener('touch', function() return true end)
--Форма с информацией о бое
M.GUI.wnd = display.newRoundedRect(M.GR, _W * .5, _H * .5, _W * .5, _H * .2, _H * .01)
M.GUI.wnd.strokeWidth = _H * .005
M.GUI.wnd:setStrokeColor(0,.5,0)
M.GUI.wnd:setFillColor(0,.3,0)
M.GUI.wnd:addEventListener('touch',function(event)
if event.phase == 'began' then
display.remove(M.GR)
end
end)
M.GUI.txt_1 = display.newText(M.GR, 'FINISH', _W * .5, _H * .45, font, _W * .07)
M.GUI.txt_2 = display.newText(M.GR, 'NEW SCORE', _W * .5, _H * .5, font, _W * .07)
M.GUI.txt_2:setFillColor(1,1,0)
M.GUI.txt_2.isVisible = is_new_score
M.GUI.txt_2 = display.newText(M.GR, 'SCORE: '..battle.cur_score, _W * .5, _H * .55, font, _W * .07)
game.refresh()
ls.save()--сохрание настроек
end
return M
```
Библиотека хранения и загрузки настроек
---------------------------------------
Эта простая библиотека содержит две функции позволяющие обеспечить хранение результата между игровыми сессиями.
* *ls.load()* — выполняется один раз при старте игры и если этот старт первый, происходит создание шаблона сохранения, если не первый происходит загрузка результата прошлых игр.
* *ls.save()* — выполняется после каждого сражения, при этом текущий результат сохраняется в файл.
Хранение настроек осуществляется в файле config.dat в формате json. Код библиотеки имеет вид:
```
-------------------------------------
-- Библиотека обслуживает хранение --
-- и загрузку игровых настроек --
-------------------------------------
local M = {}
local json = require("json")
M.tmp_battle = {
cur_score = 0,--текущее значение
best_score = 0,--лучший рекорд
timer = 0,--секунд до конца боя
}
--Сохранение основных настроек в файл
M.save = function(new)
local file = io.open(filePath, "w")
if file then
local write_data = ''
write_data = json.encode(battle)
file:write( write_data )
io.close( file )
end
end
--Загрузка основных настроек из файла
M.load = function()
local str = ""
local file = io.open( filePath, "r" )
--если файл существует
if file then
local read_data = file:read("*a")
battle = json.decode(read_data)
io.close( file )
--если файла нет
else
battle = M.tmp_battle
M.save()
end
end
return M
```
Библиотека универсальных функций.
Тут хранятся все функции которые нужны в игре но в явной форме не относятся к какому-то модулю и в последствии могут быть использованы для других целей. Имеются следующие функции:
* *api.play\_sound* — воспроизводит музыкальный файл(.wav), расположенный в assets/music/ имя которого передано в параметре
* *api.get\_xy\_line* — возвращает координаты случайной точки лежащей на отрезке двух переданных в параметре точек. Функция используется при генерации случайных начальных и конечных точек движения насекомых.
* *api.get\_line\_len* — возвращает длину отрезка переданного двумя точками. Функция используется при вычислении времени в пути насекомого через длину и скорость.
* *api.get\_angle* — определяет угол между первой переданной точкой из которой проведен луч идущий вверх и лучом направленным на вторую точку. Функция используется для определения угла поворота картинки насекомого.
```
---------------------------------------------------
-- Библиотека содержит функции общего назначения --
---------------------------------------------------
local M = {}
--воспроизведение звука
M.play_sound = function(track)
local msg = audio.loadSound("assets/music/" .. track .. ".wav")
audio.play( msg,{
loops = 0,
oncomplete = function(e)
audio.dispose(e.handle);
e.handle = nil;
end})
end
--функции передается отрезок, а она возвращает случайную точку на нем
M.get_xy_line = function(line)
local x1,y1,x2,y2 = line.x1,line.y1,line.x2,line.y2
local x,y = 0,0
if x1 == x2 then
x = x1
y = math.random(y1,y2)
else
y = y1
x = math.random(x1,x2)
end
return x,y
end
--длина отрезка
M.get_line_len = function(p)
--√ ((X2-X1)²+(Y2-Y1)²)
local len = math.sqrt((p.x2 - p.x1)^2 + (p.y2 - p.y1)^2)
return len
end
--угол между двумя точками
M.get_angle = function(p)
return ((math.atan2(p.y1 - p.y2, p.x1-p.x2) / (math.pi / 180)) + 270) % 360
end
return M
```
Заключение
----------
Полный исходник игры представленной в статье вы найдет в [тут](http://x-id.ru/crush_src.zip)
Если ваши знания языка Lua не позволяют вам уверено читать исходник можете ознакомиться с [моей статьей](https://habrahabr.ru/post/344304/) по этому вопросу.
Статью для вас подготовил Денис Гончаров aka [execom](http://vk.com/execom)
Всем удачи! | https://habr.com/ru/post/344638/ | null | ru | null |
# Первые шаги в визуализации данных с использованием Geopandas и OSM
У многих хоть раз возникала необходимость быстро нарисовать карту города или страны, нанеся на нее свои данные (точки, маршруты, тепловые карты и т.д.).
Как быстро решить такую задачу, откуда взять карту города или страны для отрисовки — в подробной инструкции под катом.
Введение
========
Недавно в работе возникла необходимость в отрисовке карты России на различных уровнях детальности (субъекты, города, городские районы) и подтягивании к ней ряда данных.
Грубо говоря, нужно было подготовить тепловую карту наподобие такой:
**Плотность населения Москвы по районам**
[Источник](http://www.statdata.ru/karta/moscow-density)
Задача осложнялась тем фактом, что у нас не было подходящего файла с картой для визуализации, а данные, которые мы планировали отобразить, хранятся в привязке к почтовому коду (то есть, у нас нет привязки к субъекту федерации / городу / району).
В этой статье я поделюсь своим опытом касательно поиска подходящего источника данных, использования формата .shp и библиотеки geopandas.
Формирование подхода
====================
Формально, решение задачи сводится к трем шагам:
1. **Поиск** данных — карты России на разных уровнях детализации
2. **Мэтчинг** данных с картой из шага "1"
3. **Проверка** результатов, празднование
Ниже я опишу процесс выполнения каждого из этих шагов, поделюсь релевантным кодом, а также приведу ссылки на полезные ресурсы, которые встретились на моем пути.
Поиск
=====
### Формат файлов
Оптимальным для нашей задачи оказался формат Shapefile.
Не вдаваясь в подробности, Shapefile — это векторный формат, с помощью которого можно отобразить геометрические фигуры (например, районы города), а также привязать к ним ряд параметров для отображения (например, население в каждом районе).
Основные релевантные термины, которыми мы будем оперировать:
* **Точка** — Сочетание широты и долготы
* **Линия** — Последовательность из нескольких точек, соединенных между собой в фиксированном порядке
* **Полигон** — Замкнутая линия, у которой совпадают первая и последняя точка\
Подробнее про различные элементы можно почитать в замечательной [**статье**](https://habr.com/ru/post/270513/).
### Источник данных
Источником данных был выбран **OpenStreetMap** (он же OSM). Это картографический сервис, наполняемый по принципу Википедии — желающие могут редактировать данные, добавлять недостающую информацию и так далее.
Быстрая проверка качества карт показала вполне адекватное отображение как крупных городов, так и мелких деревень и сел. Подробнее про качество данных и способы их наполнения можно почитать на [**официальной странице OSM**](https://welcome.openstreetmap.org/working-with-osm-data/how-good-is-osm/).
Чтобы выгрузить данные с OSM, мы воспользовались помощью специализированного агентства (как делать выгрузки самостоятельно, можно почитать [**тут**](https://wiki.openstreetmap.org/wiki/Downloading_data)).
Мы выбрали [**NextGis**](https://data.nextgis.com/ru/?lvl=regions&country=RU), однако есть и [**другие**](https://wiki.openstreetmap.org/wiki/Commercial_OSM_Software_and_Services) агентства, чьей помощью можно воспользоваться для выгрузки и обработки данных.
На NextGis можно за символическую плату подготовить [**карту Москвы**](https://data.nextgis.com/ru/region/RU-MOW/) (заняла ~30 минут) и за чуть менее символическую — [**всей России**](https://data.nextgis.com/ru/region/RU/) (заняла ~4 дня). Также можно подготовить выгрузку по [**произвольной области**](https://data.nextgis.com/ru/custom_region/).
Мэтчинг
=======
Карта есть — теперь нужно понять, как выстроить связь между почтовыми кодами (к которым привязаны наши данные) и нужными нам уровнями детализации (город / район и тд).
Исходно была надежда на [**эталонный справочник Почты России**](https://vinfo.russianpost.ru/database/ops.html), однако оказалось, что наполнение его далеко от идеала (например, для почтового кода может быть указано, в каком городе он находится, но не в каком районе). К тому же в России, в отличие, например, от США, здания с одним и тем же почтовым кодом могут находиться в разных районах города, или даже в разных городах.
В результате было решено опереться на все тот же OpenStreetMap. На одном из слоев карты представлены отдельные здания, у части из которых заполнено поле с почтовым кодом.
Если найти все дома с определенным почтовым кодом, а потом определить, в каком районе города находится большинство из них, можно определить, какой район является для данного индекса "основным".
Понятно, что такой подход имеет ряд ограничений. Например, могут найтись районы, в которых нет ни одного здания с заполненным индексом, могут быть ошибки при его написании и многие другие потенциальные косяки.
В то же время, в итоге выполнения этого упражнения мы увидели вполне удовлетворительные результаты (подробнее о них будет написано в разделе "Проверка").
В общем, проще показать, чем объяснить, так что переходим к делу!
### Установка и импорт библиотек
Для всей нашей работы понадобится библиотека Geopandas, а также всем известные Pandas, Matplotlib и Numpy.
При установке Geopandas через pip на Windows выскакивает ошибка, так что рекомендую воспользоваться `conda install geopandas` .
```
import pandas as pd
import numpy as np
import geopandas as gpd
from matplotlib import pyplot as plt
```
### Открываем Shapefile
Карты наши поставляются в виде zip архива.
При его открытии в папке data можно найти множество файлов с разными расширениями. Это различные слои, для каждого из которых есть основной файл (расширение .shp) и вспомогательные (расширения .cpg, .dbf, .prj, .shx).
**Несколько моментов, на которые следует обратить внимание при начале работы с geopandas:**
* Архив крайне эффективно ужимает карту. Например, архив с картой всей России весит 1.2GB, а при распаковке он занимает уже 22.8GB. Таким образом, не стоит распаковывать архив — лучше выгрузить из него нужные нам слои (благо geopandas позволяет это делать без использования дополнительных библиотек)
* Разные поля могут быть в разных кодировках. Например, в нашем примере административные границы были в кодировке 'cp1251', а остальные поля — в 'utf-8'
* При работе с несколькими слоями, взятыми из разных источников, могут возникнуть проблемы с их отображением из-за разных проекций карт. Подробнее об этой проблеме и способах ее решения можно почитать [**тут**](https://geopandas.org/projections.html).
```
# Путь к папке data в нашем архиве
# Обратите внимание на формат обращения к zip-архиву и к папке в нем
ZIP_PATH = 'zip://C:/Users/.../Moscow.zip!data/'
# Названия для переменных слоев и названия соответствующих shp Файлов
LAYERS_DICT = {
'boundary_L2': 'boundary-polygon-lvl2.shp', # Административные границы различных уровней
'boundary_L4': 'boundary-polygon-lvl4.shp',
'boundary_L5': 'boundary-polygon-lvl5.shp',
'boundary_L8': 'boundary-polygon-lvl8.shp',
'building_point': 'building-point.shp', # Здания, отмеченные в виде полигонов
'building_poly': 'building-polygon.shp' # Здания, отмеченные в виде точек
}
# Подгружаем слои в соответствующие переменные в рамках цикла
i = 0
for layer in LAYERS_DICT.keys():
path_to_layer = ZIP_PATH + LAYERS_DICT[layer]
if layer[:8]=='boundary':
encoding = 'cp1251'
else:
encoding = 'utf-8'
globals()[layer] = gpd.read_file(path_to_layer, encoding=encoding)
i+=1
print(f'[{i}/{len(LAYERS_DICT)}] LOADED {layer} WITH ENCODING {encoding}')
```
**Результат:**
```
[1/6] LOADED boundary_L2 WITH ENCODING cp1251
[2/6] LOADED boundary_L4 WITH ENCODING cp1251
[3/6] LOADED boundary_L5 WITH ENCODING cp1251
[4/6] LOADED boundary_L8 WITH ENCODING cp1251
[5/6] LOADED building_point WITH ENCODING utf-8
[6/6] LOADED building_poly WITH ENCODING utf-8
```
В результате мы имеем шесть переменных GeoDataFrame, в каждой из которых находятся разные варианты отображения карты Москвы. Отрисовать их можно очень просто:
**Рисуем административные границы разных уровней**
```
fig, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4, figsize=(15,15))
boundary_L2.plot(ax=ax1, color='white', edgecolor='black')
boundary_L4.plot(ax=ax2, color='white', edgecolor='black')
boundary_L5.plot(ax=ax3, color='white', edgecolor='black')
boundary_L8.plot(ax=ax4, color='white', edgecolor='black')
```
Результат:
Чтобы разобраться, что именно мы видим на каждом уровне отрисовки, советую взглянуть на [**соответствующую страницу**](https://wiki.openstreetmap.org/wiki/RU:Tag:boundary=administrative) на сайте OSM. Это будет особенно важно при отрисовке карты всей России — слои в Москве и Питере могут хранить отличные от остальной России уровни детализации.
Аналогичным образом можем отрисовать слой со зданиями. Из-за большого количества объектов отрисовка займет чуть больше времени, зато и картинка получится красивая.
**Рисуем здания Москвы**
```
building_poly.plot(figsize=(10,10))
```
Также можно наложить несколько слоев карты один на другой:
**Отображаем одновременно два слоя административных границ Москвы**
```
base = boundary_L2.plot(color='white', alpha=.8, edgecolor='black', figsize=(50,50))
boundary_L8.plot(ax=base, color='white', edgecolor='red', zorder=-1)
```
[**Тут**](https://geopandas.org/mapping.html) можно почитать про разные варианты отрисовки слоев в gpd.
Приятно удивило, что в Geopandas работают привычные команды из Pandas. Можно посмотреть все атрибуты слоя в виде таблицы, где каждая строка будет описывать отдельный объект (точку, линию или полигон), изменение и создание атрибутов также можно выполнять, как при работе с обычным Датафреймом.
**Пример**
```
boundary_L8.head()
```
**Среди всех атрибутов нам наиболее важны 2:**
* **OSM\_ID** — уникальный идентификатор объекта OpenStreetMap
* **geometry** — координаты для отрисовки полигона или точки
### Обработка данных
Для нашей задачи нам необходимо соотнести между собой почтовые индексы зданий и районы города.
Чтобы не обрабатывать лишних зданий, оставим только те из них, у которых заполнено поле с индексом:
```
print('POLYGONS')
print('# buildings total', building_poly.shape[0])
building_poly = building_poly.loc[building_poly['A_PSTCD'].notna()]
print('# buildings with postcodes', building_poly.shape[0])
print('\nPOINTS')
print('# buildings total', building_point.shape[0])
building_point = building_point.loc[building_point['A_PSTCD'].notna()]
print('# buildings with postcodes', building_point.shape[0])
```
Результат:
```
POLYGONS
# buildings total 241511
# buildings with postcodes 13198
POINTS
# buildings total 1253
# buildings with postcodes 4
```
Как видим, на слое с точками почти не осталось зданий, поэтому **дальше будем использовать только слой с полигонами зданий** (несмотря на то, что в нем это поле оказалось заполнено только у 5%, 13 тысяч нам должно хватить).
**В целевой таблице мы хотим увидеть следующие колонки:**
1. Почтовый индекс
2. OSM-ID района города, в котором чаще всего встречаются здания с этим индексом
3. Доля зданий с этим индексом, которые находятся в его "основном" районе. Эта метрика нужна, чтобы проверить, не слишком ли разбросаны по городу здания с этим почтовым кодом.
**Код для создания такой таблицы**
```
%%time
building_areas = gpd.GeoDataFrame(building_poly[['A_PSTCD', 'geometry']])
building_areas['area'] = 'NF'
# Создаем цикл из районов города, для каждого из которых определяем находящиеся в нем здания
# Для проверки нахождения здания в районе, мы будем преобразовывать полигон здания в точку с помощью .centroid.
# Это позволит избежать сложностей со зданиями, которые находятся на границе двух районов
for area in boundary_L8['OSM_ID']:
area_geo = boundary_L8.loc[boundary_L8['OSM_ID']==area, 'geometry'].iloc[0]
nf_buildings = building_areas['area']=='NF' # В каждом цикле проверяем только те здания, для которых еще не нашли района
building_areas.loc[nf_buildings, 'area'] = np.where(building_areas.loc[nf_buildings, 'geometry'].centroid.within(area_geo), area, 'NF')
# Создаем таблицу, где по строкам находятся индексы, а по колонкам - районы города.
# Число на пересечении строки и колонки показывает, сколько нашлось зданий с таким индесом.
codes_pivot = pd.pivot_table(building_areas,
index='A_PSTCD',
columns='area',
values='geometry',
aggfunc=np.count_nonzero)
# Добавляем колонку, в которой будет указан наиболее часто встречающийся район с нужным индексом
codes_pivot['main_area'] = codes_pivot.idxmax(axis=1)
# Добавляем колонку с долей зданий в "основном" для индекса районе
for pst_code in codes_pivot.index:
main_area = codes_pivot.loc[codes_pivot.index==pst_code, 'main_area']
share = codes_pivot.loc[codes_pivot.index==pst_code, main_area].iloc[0,0] / codes_pivot.loc[codes_pivot.index==pst_code].sum(axis=1)*100
codes_pivot.loc[codes_pivot.index==pst_code, 'share_in_main_area'] = int(share)
# Оставляем только нужные нам колонки
codes_pivot = codes_pivot.loc[:, ['main_area', 'share_in_main_area']].fillna(0)
```
**Итоговая таблица выглядит следующим образом:**
### Рисуем тепловую карту
Поделиться данными, которые мне необходимо отобразить, я, к сожалению, не могу (не могу даже рассказать, что это за данные).
Чтобы все же нарисовать красивую тепловую карту я вместо этого постараюсь ответить на необычайно важный вопрос: **в индексах каких районов можно встретить больше цифр "1"**.
```
# Создаем колонку с нашей супер-важной метрикой
codes_pivot['count_1'] = codes_pivot.index.str.count('1')
# Считаем средние значения для районов города
areas_pivot = pd.pivot_table(codes_pivot, index='main_area', values='count_1', aggfunc=np.mean)
areas_pivot.index = areas_pivot.index.astype('int64')
# Подтягиваем наши значения к слою с районами города
boundary_L8_w_count = boundary_L8.merge(areas_pivot, how='left', left_on='OSM_ID', right_index=True)
# Рисуем тепловую карту
boundary_L8_w_count.plot(column='count_1', legend=True, figsize=(10,10))
```
**Результат:**
Видно, что часть районов не отобразилась — к сожалению, в них не было ни одного здания с заполненным почтовым индексом
Проверка
========
С точки зрения проверки качество результатов, основной риск заключался в том, что будет много почтовых индексов, разбросанных по разным районам города.
**Ниже — распределение метрики share\_in\_main\_area**
Считаем долю индексов, у которых меньше половины зданий находятся в "основном" для них районе:
```
codes_pivot[codes_pivot['share_in_main_area']>50].shape[0]/codes_pivot.shape[0]
```
Результат:
```
0.9568345323741008
```
Такие результаты нас вполне устраивают.
Заключение
==========
**Geopandas** — крайне удобный инструмент. При наличие даже небольшого опыта работа с Matplotlib и Pandas разобраться в нем не составит труда.
**OSM** — кладезь информации для визуализации различных геоданных, которые можно использовать без необходимости серьезных преобразований.
Ну а я с вами прощаюсь и надеюсь, что статья оказалась полезной!
Если возникнут вопросы или конструктивная критика — буду ждать вас в комментариях. | https://habr.com/ru/post/515328/ | null | ru | null |
# Создание и интегрирование бота VK в группу через VkBotLongPoll [Python]
В этой статье мы создадим бота и интегрируем его в группу VK на Python 3.x
### Для кого эта статья?
Для тех, кто хочет написать простого бота для своего сообщества, умеющего определять команды и выводить соответствующий ответ
### Основные стадии
* [Для начала создадим бота в ВК, настроим API-ключ и включим Long Poll API](https://habr.com/post/427691/)
* Настроим Long Poll
* Добавим определения команд, которые будет обрабатывать бот
* Создадим ассоциации команд
* Добавим клавиатуру
### Создание группы-бота
Начнем мы с создания бота, а именно группы в ВК.
Для это нужно зайти в «группы» → «создать сообщество».
Выберите любой тип сообщества и введите название, тематику группы.
На открывшейся странице настроек, выберите «Работа с API».
Далее, необходимо создать API-ключ.
Затем выберите нужные вам параметры с доступом для вашего API-ключа.
Скорее всего, вам придётся подтверждать действие в ВК с помощью мобильного телефона. Затем скопируйте полученный API-ключ где-нибудь в файл. Он нам еще понадобится.
Затем нужно разрешить сообщения. Для этого переходим в «сообщения» и включаем их. Также включим «Возможности ботов» в «Сообщения» -> «Настройки для бота».
Там же разрешим добавить сообщество в группы, если мы хотим чтобы бот мог получать сообщения из группы.
### Настройка Long Poll
Для работы с Long Poll API используем библиотеку [vk\_api](https://github.com/python273/vk_api). Установить его можно через pip.
Перед работой сохраним наш API-токен в файл config.py оттуда мы будем загружать наш ключ.
Создадим наш первый скрипт. Назовем server.py, который будет основным скриптом сервера.
Импортируем нужные нам модули:
```
import vk_api.vk_api
from vk_api.bot_longpoll import VkBotLongPoll
from vk_api.bot_longpoll import VkBotEventType
```
Создадим класс-сервер:
```
class Server:
def __init__(self, api_token, group_id, server_name: str="Empty"):
# Даем серверу имя
self.server_name = server_name
# Для Long Poll
self.vk = vk_api.VkApi(token=api_token)
# Для использования Long Poll API
self.long_poll = VkBotLongPoll(self.vk, group_id)
# Для вызова методов vk_api
self.vk_api = self.vk.get_api()
def send_msg(self, send_id, message):
"""
Отправка сообщения через метод messages.send
:param send_id: vk id пользователя, который получит сообщение
:param message: содержимое отправляемого письма
:return: None
"""
self.vk_api.messages.send(peer_id=send_id,
message=message)
def test(self):
# Посылаем сообщение пользователю с указанным ID
self.send_msg(255396611, "Привет-привет!")
```
Теперь создадим файл server\_manager.py, в котором будет управлять разными серверами. Пока для тестов пропишем лишь вызов класса Server:
```
# Импортируем созданный нами класс Server
from server import Server
# Получаем из config.py наш api-token
from config import vk_api_token
server1 = Server(vk_api_token, 172998024, "server1")
# vk_api_token - API токен, который мы ранее создали
# 172998024 - id сообщества-бота
# "server1" - имя сервера
server1.test()
```
> #### Важно!
>
> Бот может писать сообщения только тем пользователям, которые разрешили боту присылать сообщения. Сделать это можно на странице сообщества или же первым написать боту
Если все сделано правильно, то бот пришлет нам личное сообщение.
Теперь добавим бота в группу и научим его обрабатывать сообщения.
Для добавления бота в группу нужно нажать «Пригласить в беседу» в правом меню сообщества.
Добавим боту функцию start, после вызова которой он начнет «слушать» сообщения через Long Poll (не забудьте добавить разрешения в типы событий в разделе «Работа с API» -> «Long Poll API» и поставить последнюю версию):
```
def start(self):
for event in self.long_poll.listen():
print(event)
```
Запустим его через server\_manager.py:
```
server1.start()
```
Теперь, если напишем сообщение в группу, то сможем увидеть объект event'a:
> <({'type': 'message\_new', 'object': {'date': 1541273151, 'from\_id': 25599999999, 'id': 0, 'out': 0, 'peer\_id': 2000000001, 'text': '[club172998024|bot in da Vk] this is a text!', 'conversation\_message\_id': 187, 'fwd\_messages': [], 'important': False, 'random\_id': 0, 'attachments': [], 'is\_hidden': False}, 'group\_id': 172998024})>
Также, если мы напишем в личные сообщения:
> <({'type': 'message\_new', 'object': {'date': 1541273238, 'from\_id': 25599999999, 'id': 47, 'out': 0, 'peer\_id': 255396611, 'text': 'это личное сообщение', 'conversation\_message\_id': 47, 'fwd\_messages': [], 'important': False, 'random\_id': 0, 'attachments': [], 'is\_hidden': False}, 'group\_id': 172998024})>
Из этих данных нам следует обратить внимание на *type, object.from\_id, object.id, object.peer\_id, object.text*. Данные полученные из сообщений и из группы ничем сильно не отличаются, кроме *object.peer\_id* и *object.id*.
Если присмотреться, object.id у всех сообщений из группы равен 0, а сообщения из личных нет. Таким образом, можно разделить сообщения получаемые из группы и из личных.
Обработаем полученные данные внутри класса Server:
```
def start(self):
for event in self.long_poll.listen(): # Слушаем сервер
# Пришло новое сообщение
if event.type == VkBotEventType.MESSAGE_NEW:
print("Username: " + self.get_user_name(event.object.from_id))
print("From: " + self.get_user_city(event.object.from_id))
print("Text: " + event.object.text)
print("Type: ", end="")
if event.object.id > 0:
print("private message")
else:
print("group message")
print(" --- ")
def get_user_name(self, user_id):
""" Получаем имя пользователя"""
return self.vk_api.users.get(user_id=user_id)[0]['first_name']
def get_user_city(self, user_id):
""" Получаем город пользователя"""
return self.vk_api.users.get(user_id=user_id, fields="city")[0]["city"]['title']
```
Напишем боту два сообщения: один из группы, один в личку. Тогда получим:
> Username: Артур
>
> From: Санкт-Петербург
>
> Text: [club172998024|@club172998024] this is a message from group
>
> Type: group message
>
> —
>
> Username: Артур
>
> From: Санкт-Петербург
>
> Text: this is a private message
>
> Type: private message
>
> —
> #### Примечание
>
>
>
> Как вы могли заметить перед сообщением в группе есть [club172998024|@club172998024], для правильной обработки команды следует избавиться от всего содержимого в квадратных скобках, либо разрешить боту доступ ко всей переписке
Как мы видим, vk\_api позволяет нам легко использовать методы VK API. К примеру, сейчас мы использовали метод *users.get*
Список всех методов доступен по ссылке: [vk.com/dev/methods](https://vk.com/dev/methods)
Советую изучить и поэкспериментировать с методами, которые вас заинтересуют. Благо VK предоставило нам очень хорошую документацию, еще и на русском языке.
Чтобы закрепить материал, давайте добавим функцию отправки сообщения через метод *messages.send*:
```
def send_message(self, peer_id, message):
self.vk_api.messages.send(peer_id=peer_id, message=message)
```
— идентификатор назначения. Чтобы ответить на чье-то сообщение, в качестве параметра *peer\_id* укажем *event.object.peer\_id*. То есть, пошлем сообщение туда, откуда пришел запрос.
Изменим метод start:
```
def start(self):
for event in self.long_poll.listen(): # Слушаем сервер
# Пришло новое сообщение
if event.type == VkBotEventType.MESSAGE_NEW:
username = self.get_user_name(event.object.from_id)
print("Username: " + username)
print("From: " + self.get_user_city(event.object.from_id))
print("Text: " + event.object.text)
print("Type: ", end="")
if event.object.id > 0:
print("private message")
else:
print("group message")
print(" --- ")
self.send_message(event.object.peer_id, f"{username}, я получил ваше сообщение!")
```
Теперь, если бот примет сообщение, то он нам ответит в таком стиле:
> Артур, я получил ваше сообщение!
**Весь код**#### server.py
```
import vk_api.vk_api
from vk_api.bot_longpoll import VkBotLongPoll
from vk_api.bot_longpoll import VkBotEventType
class Server:
def __init__(self, api_token, group_id, server_name: str="Empty"):
# Даем серверу имя
self.server_name = server_name
# Для Long Poll
self.vk = vk_api.VkApi(token=api_token)
# Для использоания Long Poll API
self.long_poll = VkBotLongPoll(self.vk, group_id, wait=20)
# Для вызова методов vk_api
self.vk_api = self.vk.get_api()
def send_msg(self, send_id, message):
"""
Отправка сообщения через метод messages.send
:param send_id: vk id пользователя, который получит сообщение
:param message: содержимое отправляемого письма
:return: None
"""
self.vk_api.messages.send(peer_id=send_id,
message=message)
def test(self):
self.send_msg(255396611, "Привет-привет!")
def start(self):
for event in self.long_poll.listen(): # Слушаем сервер
# Пришло новое сообщение
if event.type == VkBotEventType.MESSAGE_NEW:
username = self.get_user_name(event.object.from_id)
print("Username: " + username)
print("From: " + self.get_user_city(event.object.from_id))
print("Text: " + event.object.text)
print("Type: ", end="")
if event.object.id > 0:
print("private message")
else:
print("group message")
print(" --- ")
self.send_message(event.object.peer_id, f"{username}, я получил ваше сообщение!")
def get_user_name(self, user_id):
""" Получаем имя пользователя"""
return self.vk_api.users.get(user_id=user_id)[0]['first_name']
def get_user_city(self, user_id):
""" Получаем город пользователя"""
return self.vk_api.users.get(user_id=user_id, fields="city")[0]["city"]['title']
def send_message(self, peer_id, message):
self.vk_api.messages.send(peer_id=peer_id, message=message)
```
#### server\_manager.py
```
# Импортируем созданный нами класс Server
from server import Server
# Получаем из config.py наш api-token
from config import vk_api_token
server1 = Server(vk_api_token, 172998024, "server1")
server1.start()
```
#### Задачка для закрепления материала:
Создайте функцию, которая принимает параметр peer\_id и посылает пользователю фотографию загруженную в сообщество. Полезный док: [vk.com/dev/messages.send](https://vk.com/dev/messages.send)
**Решение**Сначала, загрузим фото в группу и открыв её в ВК рассмотрим ссылку:
> ~~[vkcom/club172998024?z=](https://vkcom/club172998024?z=)~~***photo-172998024\_456239017***~~%2Falbum-172998024\_256250731~~
Нас интересует лишь выделенная часть: *photo-172998024\_456239017*. Передадим её в качестве аргумента метода messages.send:
```
def send_img(self, peer_id):
self.vk_api.messages.send(peer_id=peer_id,
attachment="photo-172998024_456239017")
```
Добавим его в метод start и получим:
Вот и все основы. Главное, научиться пользоваться vk\_api, используя различные методы, весь их список: [vk.com/dev/methods](https://vk.com/dev/methods). Если вы научитесь работать с документацией VK API, то сможете создавать ботов различной сложности и назначений. Пример моего бота для учебной группы: [github.com/AppLoidx/GroupAssistant/tree/master](https://github.com/AppLoidx/GroupAssistant/tree/master)
### Теперь приступим к созданию логики бота
Создадим commander.py, который будет принимать команды и возвращать ответ, передаваемый пользователю Vk:
```
class Commander:
def __init__(self, vk_api, user_id):
self.vk_api = vk_api
self.user_id = user_id
def input(self, msg):
"""
Функция принимающая сообщения пользователя
:param msg: Сообщение
:return: Ответ пользователю, отправившему сообщение
"""
pass
```
#### Построим архитектуру нашей программы:
«Слушаем» сервер Long Poll и получаем сообщение пользователя ->
Передаем сообщение в Commander.input() -> Определяем режим -> Определяем команду ->
Возвращаем ответ -> Передаем пользователю
Чтобы определить режим и команду, создадим два файла command\_enum.py и mode\_enum.py. С помощью них мы будем определять режимы и команды через методы класса Enum:
#### command\_enum.py:
```
from enum import Enum
class Command(Enum):
""" weather """
weather = ["weather", "погода"]
""" myanimelist """
anime_top = ["top anime", "топ аниме"]
```
#### mode\_enum.py:
```
from enum import Enum
class Mode(Enum):
default = ["Обычный режим", "default"]
translate = ["Режим переводчика", "translate"]
get_ans = 0
```
Для смены режимов используем [слэш("/")+<имя\_режима>], а все остальные команды примем как команды.
Реализуем это в Commander.py:
```
# Перечисления команд, режимов
from command_enum import Command
from mode_enum import Mode
# Рабочие модули
from translate.yandex_translate import Translator
from weather import Weather
from myanimelist import Myanimelist
# Config
from config import yandex_translate_api
class Commander:
def __init__(self):
# Текущий, предыдущий режимы
self.now_mode = Mode.default
self.last_mode = Mode.default
self.last_command = None
# Для запомминания ответов пользователя
self.last_ans = None
# Работа с переводом
self.translator = Translator(yandex_translate_api)
def change_mode(self, to_mode):
"""
Меняет режим приема команд
:param to_mode: Измененный мод
"""
self.last_mode = self.now_mode
self.now_mode = to_mode
self.last_ans = None
def input(self, msg):
"""
Функция принимающая сообщения пользователя
:param msg: Сообщение
:return: Ответ пользователю, отправившему сообщение
"""
# Проверка на команду смены мода
if msg.startswith("/"):
for mode in Mode:
if msg[1::] in mode.value:
self.change_mode(mode)
return "Режим изменен на " + self.now_mode.value[0]
return "Неизвестный мод " + msg[1::]
# Режим получения ответа
if self.now_mode == Mode.get_ans:
self.last_ans = msg
self.now_mode = self.last_mode
return "Ok!"
if self.now_mode == Mode.default:
# Погода
if msg in Command.weather.value:
return Weather.get_weather_today()
# Топ аниме
if msg in Command.anime_top.value:
res = ""
top = Myanimelist.get_top()
for anime in top:
res += anime + " : " + top[anime] + "\n"
return res
if self.now_mode == Mode.translate:
if self.last_ans is None:
# Если язык не выбран, просим пользователя ввести
self.change_mode(Mode.get_ans)
self.last_command = msg
return "Выберите язык на который следует перевести"
elif self.last_ans == "change":
# Меняем переводимый язык
self.last_ans = None
self.change_mode(Mode.default)
else:
# Переводим
return self.translator.translate_to(msg, self.last_ans)
return "Команда не распознана!"
```
**weather.py**
```
import requests
from bs4 import BeautifulSoup
class Weather:
@staticmethod
def get_weather_today(city: str = "санкт-петербург") -> list:
http = "https://sinoptik.com.ru/погода-" + city
b = BeautifulSoup(requests.get(http).text, "html.parser")
p3 = b.select('.temperature .p3')
weather1 = p3[0].getText()
p4 = b.select('.temperature .p4')
weather2 = p4[0].getText()
p5 = b.select('.temperature .p5')
weather3 = p5[0].getText()
p6 = b.select('.temperature .p6')
weather4 = p6[0].getText()
result = ''
result = result + ('Утром :' + weather1 + ' ' + weather2) + '\n'
result = result + ('Днём :' + weather3 + ' ' + weather4) + '\n'
temp = b.select('.rSide .description')
weather = temp[0].getText()
result = result + weather.strip()
return result
```
**myanimelist.py**
```
import requests
import bs4
class Myanimelist:
@staticmethod
def get_top(count: int=5, by: str="") -> dict:
types = ["", "airing", "upcoming", "tv", "movie", "ova", "special", "bypopularity", "favorite"]
if by not in types:
return {"error: ": "Неизвестный тип!"}
html = requests.get("https://myanimelist.net/topanime.php?type="+by)
soup = bs4.BeautifulSoup(html.text, "html.parser")
res = {}
for anime in soup.select(".ranking-list", limit=count):
url = anime.select(".hoverinfo_trigger")[0]['href']
anime = anime.select(".hoverinfo_trigger")[0].findAll("img")[0]
name = anime['alt'].split(":")[1].strip(" ")
res[name] = url
return res
```
**yandex\_translate.py**
```
import requests
from config import yandex_translate_api
class Translator:
"""
Класс-переводчик использующий API Yandex Translate
Параметры:
_key -- ключ от API Yandex.Translate
_yandex_comment -- согласовано с правилами офомления и использования API Yandex.Translate
"""
def __init__(self, key, comment=None):
"""
:param key: ключ от API Yandex.Translate
:param comment: Комментарий к каждому переводу
"""
self._key = key
if comment is None:
self._yandex_comment = "\nПереведено сервисом «Яндекс.Переводчик» http://translate.yandex.ru/"
else:
self._yandex_comment = comment
def translate(self, text, lang, to_lang=None):
"""
Переводит текст с указанного языка в другой указанный
:param text: Текст, который нужно перевести
:param lang: исходный язык
:param to_lang: конечный язык
:return: Переведенный текст
"""
if to_lang is not None:
lang = f"{lang}-{to_lang}"
main_url = "https://translate.yandex.net/api/v1.5/tr.json/translate"
response = requests.get(f"{main_url}?"
f"key={self._key}&"
f"lang={lang}&"
f"text={text}")
return response.json()['text'][0] + self._yandex_comment
def lang_identify(self, text, hint="ru,en"):
"""
Идентифицирует язык
:param text: Текст
:param hint: Подсказки для определения языка
:return: код языка
"""
main_url = "https://translate.yandex.net/api/v1.5/tr.json/detect"
response = requests.get(f"{main_url}?"
f"key={self._key}&"
f"hint={hint}&"
f"text={text}")
return response.json()['lang']
def translate_ru_en(self, text):
"""
Переводит текст с русского на английский
:param text: Текст, который нужно перевести
:return: Текст переведенный на английский язык
"""
if self.lang_identify(text) == "ru":
to_lang = "en"
from_lang = "ru"
else:
to_lang = "ru"
from_lang = "en"
return self.translate(text, from_lang, to_lang)
def translate_to_ru(self, text, hint=None):
"""
Переводит текст на русский
:param text: Текст, который нужно перевести
:param hint: Подсказки к определению языка
:return: Текст переведенный на русский язык
"""
if hint is None:
hint = "ru,en"
from_lang = self.lang_identify(text, hint)
return self.translate(text, from_lang, "ru")
def translate_to(self, text, to_lang, hint=None):
"""
Переводит текст в нужный язык
:param text: Текст, который нужно перевести
:param to_lang: Код результирующего языка
:param hint: Подсказки к определению языка
:return: Переведенный текст
"""
if hint is None:
hint = "ru,en"
from_lang = self.lang_identify(text, hint)
return self.translate(text, from_lang, to_lang)
```
Весь код доступен на гитхабе: [github.com/AppLoidx/VkLongPollBot](https://github.com/AppLoidx/VkLongPollBot)
#### Добавляем клавиатуру:
Это очень легкий процесс, осложнения могут быть вызваны, когда мы будем изменять клавиатуру под определенную сигнатуру команд, которая отличается для каждого режима.
Чтобы добавить в окне диалогов клавиатуру, необходимо в методе messages.send указать параметр keyboard, принимающий json. Выглядит это следующим образом:
```
vk_api.messages.send(...,keyboard=keyboard_json,...)
```
Или же можно передать клавиатуру прямо с файла .json:
```
vk_api.messages.send(...,keyboard=open(filename,"r",encoding="UTF-8").read()
```
Документация: [vk.com/dev/bots\_docs\_3?f=4.%2BКлавиатуры%2Bдля%2Bботов](https://vk.com/dev/bots_docs_3?f=4.%2B%D0%9A%D0%BB%D0%B0%D0%B2%D0%B8%D0%B0%D1%82%D1%83%D1%80%D1%8B%2B%D0%B4%D0%BB%D1%8F%2B%D0%B1%D0%BE%D1%82%D0%BE%D0%B2)
Рассмотрим на примере нашей программы, добавив клавиатуру.
Для начала создадим файл keyboard.json:
```
{
"one_time": false,
"buttons": [
[{
"action": {
"type": "text",
"label": "top anime"
},
"color": "positive"
},
{
"action": {
"type": "text",
"label": "weather"
},
"color": "positive"
}],
[{
"action": {
"type": "text",
"label": "translate"
},
"color": "default"
}]
]
}
```
Чтобы убрать клавиатуры необходимо передать json с пустым buttons:
```
{"buttons":[],"one_time":true}
```
Переопределим send\_message в server.py:
```
def send_msg(self, send_id, message):
"""
Отправка сообщения через метод messages.send
:param send_id: vk id пользователя, который получит сообщение
:param message: содержимое отправляемого письма
:return: None
"""
return self.vk_api.messages.send(peer_id=send_id,
message=message,
keyboard=open("keyboards/default.json", "r", encoding="UTF-8").read())
```
И также в методе start:
```
def start(self):
for event in self.long_poll.listen(): # Слушаем сервер
if event.type == VkBotEventType.MESSAGE_NEW:
if event.object.from_id not in self.users:
self.users[event.object.from_id] = Commander()
# Пришло новое сообщение
if event.type == VkBotEventType.MESSAGE_NEW:
self.send_msg(event.object.peer_id,
self.users[event.object.from_id].input(event.object.text))
```
В результате получим:
### Последнее слово
Не стоит использовать голый листинг исходников представленных здесь, они использованы лишь для того чтобы вы лучше понимали что происходит под капотом. Разумеется, они все юзабельны и можно использовать их по частям.
Лично я использовал такого бота для группового ассистента, который умел:
* создавать очереди из участников группы, в том числе и множество команд редактировавших очередь, таких как добавление, удаление, создание и тд.
* рассылать всем участникам сообщения
* задавал вопросы (например, по языку Java)
* давал возможность создавать заявки на обмен мест и т.п.
[Проект на гитхабе](https://github.com/AppLoidx/GroupAssistant)
[Исходники представленные здесь](https://github.com/AppLoidx/VkLongPollBot) | https://habr.com/ru/post/428680/ | null | ru | null |
# iTrace. Как пишутся буквы?
Что это за приложение?
----------------------
[iTrace](http://itraceapp.com) — это мобильное приложение для того, чтобы научить детей писать буквы. Электронные прописи на iPad. Сейчас она используется в нескольких странах мира (в основном в США) для обучения детей письму. Придумал и организовал всю работу по проекту Миша Богорад, а мне довелось участвовать в проекте разработчиком всяких внутренностей, главным образом, отрисовкой букв и анализом качества их рисования.
Идея, сложности
---------------
Идея iTrace ничем не отличается от обычных прописей. Берём букву, просим ребёнка её нарисовать, подсказывая, если ему трудно. Сначала буква большая и ошибиться можно сильно, потом она уменьшается, и допуск тоже всё меньше и меньше. В конце-концов ребёнок, благодаря привычке, запоминает, как пишется буква.
В статье я расскажу про сложности, с которыми пришлось столкнуться и то, как их удалось решить. Если тема окажется интересной, спрашивайте в комментариях, про техническую часть я могу рассказать подробнее.
Помимо организационных трудностей (нарисовать несколько тысяч картинок для призов и анимаций, найти специалистов по обучению, которые помогли проработать методологию, понять, где найти музыку и озвучку к приложению, и так далее), встретились и технические сложности. Три главных — оптимизация для работы на старых устройствах, отрисовка букв разной толщины и контроль качества ввода букв ребёнком.
Оптимизация
-----------
Задача оптимизации появилась из аудитории приложения. Дети часто используют старые Айпады, и, в частности, первый. Это не самое быстрое устройство, с не самым большим количеством памяти. Пришлось придумать, как работать с анимацией, какого она должна быть размера, чтобы работать на старом железе, сколько можно сделать кадров в секунду и так далее.
Также пришлось оптимизировать работу с ресурсами в приложении. Казалось бы, просто положи их в бандл и всё, что там оптимизировать, но, увы. Во-первых, сами ресурсы большие. Потребовалось каждую картинку прогнать через оптимизатор, проанализировать, какой формат минимальный, выбрать лучший. Частично это делает система сборки проекта, но лучше контролировать самому. Во-вторых, установка тестовой сборки (и, как следствие, установка самого приложения на Айпад) занимала огромное количество времени. Оба этих процесса связаны с копированием и распаковкой файлов, и когда количество файлов — несколько тысяч, процесс может занять существенное время. Я не зря сначала вспомнил про первый Айпад. Установка тестовой версии на это устройство занимало порядка 10 минут.
В этот момент я вспомнил про пак-файлы. Это техника, которая давным-давно применяется в играх, где много-много текстур. Все файлы запаковываются в один файл, работу с которым можно организовать очень эффективно (смаппить, например). Можно было бы придумать свой формат, но мне удачно подумалось попробовать zip без сжатия и по тестам, скорость была почти такой же, как и доступ к файлам напрямую.
Единственная проблема, которая немного мешала — zip-файлы лишены случайного доступа к файлам, пришлось строить свою собственную таблицу соответствия именам местоположения файлов, которая в простейшем случае выглядит вот так:
```
{"Levels":{"":[3149,48427877],"iphone_cursive_word_levels.csv":[3153,48428251],"iphone_cursive_levels.csv":[3152,48428149],"iphone_regular_levels.csv":[3154,48428358],"regular_word_levels.csv":[3157,48428662],"save_before_rollback.zip":[3158,48428762] ...
```
После чего немного соптимизировать её по памяти (для большого количества файлов она занимает существенное место), по скорости загрузки (она кешируется при старте приложения), но после этого приложение стало устанавливаться за 20–40 секунд.
Код DPLPacker'а можно глянуть тут: [<https://github.com/bealex/DPLPacker>](https://github.com/bealex/DPLPacker) А простейшая работа с паком выглядит так:
Создаем файл
```
_zipFile = [[DPLZipFile alloc] initWithZipFile:_zipFilePath];
```
Проверяем, что файл есть в архиве, получаем его (по пути и имени):
```
NSData *data = nil;
if ([_zipFile fileExistsForPath:filePath]) {
data = [_zipFile dataForPath:filePath];
}
return data;
```
Нужно не забыть аккуратно разобраться с @2x-картинками, если пакуем их. В отличие от штатных файлов, система не загрузит за нас нужную версию:
```
- (UIImage *)imageAtPath:(NSString *)filePath {
CGFloat scale = 1;
if (DPL_isRetina()) {
if (![filePath contains:@"@2x"]) {
NSString *filePath2x = [filePath stringByReplacingOccurrencesOfString:@".png"
withString:@"@2x.png"];
if ([self fileExistsAtPath:filePath2x]) {
filePath = filePath2x;
if (DPL_isIPad()) {
scale = 2;
} else {
scale = 1;
}
}
} else {
scale = 2;
}
} else {
if (![filePath contains:@"@2x"] && ![self fileExistsAtPath:filePath]) {
NSString *filePath2x = [filePath stringByReplacingOccurrencesOfString:@".png"
withString:@"@2x.png"];
if ([self fileExistsAtPath:filePath2x]) {
filePath = filePath2x;
scale = 2;
}
} else {
scale = 1;
}
}
NSData *data = [self dataWithContentsOfFile:filePath];
if (fabs(scale - 1) > 0.01) {
if (DPL_OSVersionMajor() >= 6) {
return [UIImage imageWithData:data scale:scale];
} else {
return [UIImage imageWithCGImage:[UIImage imageWithData:data].CGImage
scale:scale
orientation:UIImageOrientationUp];
}
}
return [UIImage imageWithData:data];
}
```
Насколько кривая эта кривая?
----------------------------
Во всех остальных приложениях, которые обучают детей письму букв, самого обучения не происходит. Ребенку просто показывают, как должна писаться буква, а дальше он может рисовать её, как хочет. Нет никакой обратной связи, никакой возможности проверить правильность, поправить при необходимости. Почему это важно? Потому что есть школа, которая учит определённым образом (в США три базовых варианта написания букв, плюс курсив, варианты для правой/левой руки и мелкие отличия между разными школами).
Если ребёнок научится в приложении писать «как попало», ему придётся переучиваться. Это будет сложно, больно и неприятно.
Поэтому основной фичей, которую хотелось реализовать, должна была стать проверка корректности написания. Если ребёнок повёл линию не туда, нужно сразу ему подсказать, что не туда. Если начал не из начала — подсказать, где оно, начало. Эту задачу и пришлось решать.
Сложность составилась из двух частей. Первая — как сделать обработку быстрой. Она не должна существенно задерживать рисование буквы даже на старом, первом, Айпаде. Вторая — как именно определить, что ребёнок сделал «не то». Вот примеры ошибок, которые iTrace отлавливает:
```
IWTaskErrorCodeErrorTooBig = 1, // накопилась слишком большая ошибка
IWTaskErrorCodeLineExitedCorridor = 2, // вышли за коридор
IWTaskErrorCodeCornerDrawingDistanceWrong = 3, // слишком срезали или "накрутили" угол
IWTaskErrorCodeStraightLineDrawingDistanceWrong = 4, // далеко отошли от середины
IWTaskErrorCodeCornerDoubleEnter = 5, // вернулись уже в нарисованный угол
IWTaskErrorCodeLineNotCovered = 6, // не около любой точки идеальной кривой нарисовали
IWTaskErrorCodeWrongStart = 7, // если начали не оттуда (надо это как-то проверять — грубо говоря, если первая точка вне первого угла, или если ошибка в первом углу)
IWTaskErrorCodeTooOverextended = 8 // если перевели за конец. Это, видимо, чуть сложнее, но это важно, поскольку это очень частая ошибка. Идея примерно такова — если мы дошли до последнего (финального) угла, а потом обломали пользователя по причине того, что слишком длинная кривая в углу или по причине выхода за границы коридора — сохраняем в истории вот эту ошибку.
```
Первая часть решилась сравнительно обычными приёмами. Сначала я реализовал все алгоритмы, используя высокоуровневые структуры (классы Objective-C, коллекции оттуда же), но, увидев в профайлере, что слишком много времени тратится на работу с ними (даже на боксинг/анбоксинг чисел из NSNumber), перешёл на обычные С-структуры. После чего ввёл несколько кешей, чтобы пересчитывать только конец нарисованной линии, а не её всю. Это позволило убрать тормоза при рисовании длинных линий, и добиться нужной производительности.
Главная задача определения «что ребёнок сделал не то» состояла в том, чтобы определить, что такое «не то». Какие бывают ошибки? Мы выделили несколько:
* начало рисования не из правильной точки,
* незавершение линии,
* слишком далеко отошли вбок от идеальной линии,
* пошли «не в ту сторону». Эта ошибка отличается от предыдущей, так как мы можем пойти обратно по идеальной же линии,
* срезали угол,
После чего попробовали придумать, как формализовать все эти ошибки. Понятно, что нужно сравнивать идеальную линию и нарисованную. Понятно, что нужно разбивать их на небольшие отрезки, сравнивать их и потом аккумулировать накапливаемую ошибку. Сложность оказалась в углах. Совсем выкидывать их нельзя, углы — важная часть буквы. Но ошибка в них накапливается очень просто и очень быстро.
После двух месяцев проб и ошибок получился примерно такой алгоритм:
* разбиваем кривую на «линейные отрезки»,
* между отрезками у нас появляются области, которые мы назовём «углы». Угол — это просто небольшой отрезок, где направление линии меняется резко. Это может быть либо настоящий угол, либо какая-нибудь петелька, либо начало/конец линии.
* на линейных отрезках мы считаем, как раньше считали. Смотрим схожесть направлений отрезков и расстояние между идеальной/нарисованной кривой. Накапливаем ошибку.
* в углах мы смотрим на разницу между длиной идеальной и нарисованной кривой. И всё. Удивительным образом оказалось, что если правильно подобрать допустимую разницу, то это простое правило хорошо проверяет рисование углов.
На изображении видны углы (большие окружности). Ищутся они автоматически, по кривой, заданной в SVG-формате.
Русский язык
------------
Логично было предположить, что приложение потребуется локализовывать на разные языки. Но какие языки это будут и когда именно после старта это будем делать, не было понятно. И разработка велась без оглядки на какой-то другой язык.
Когда же появилось желание и возможность поддержать русский язык, выяснилось, что это не совсем просто.
Во-первых, нужно переводить интерфейс. Причём, если интерфейс должен быть привязан к языку системы, то язык обучения может быть другой. Нужно уметь их переключать. И нужно сделать так, чтобы длиннющий русский влезал везде в интерфейсе.
Во-вторых, красивый шрифт, который мы использовали, не содержал русские буквы. Пришлось заказать доработку шрифта.
В третьих, понадобилось больше картинок. В русском языке больше букв, больше упражнений. Кроме картинок необходима была также новая озвучка.
В четвёртых, потребовалось доработать алгоритм работы с буквами. Диакритика («й», «ё»), мелкие штрихи («ц» или «щ») — всё это усложняло алгоритм контроля качества рисования.
Очень кстати пришлась запаковка ресурсов в файл. Создав несколько таких пакетов и переключая эти файлы, оказалось очень удобно переключаться между языками.
Мелочи
------
Конечно же, было и много мелочей в разработке. Например, iTrace умеет печатать «настоящие» прописи, бумажные. Чтобы детям было интереснее, снизу каждой прописи рисуется лабиринт. Он генерируется каждый раз заново, занятно было подобрать параметры так, чтобы детям было и интересно, и не сильно просто/сложно.
Были проблемы и с апрувом. Например, когда мы попробовали в первый раз включить Touch ID для парент-гейта (спец-задачи, которую решают родители, но не дети, для входа в настройки приложения), нам отказали, сказав «нельзя». Пришлось пообщаться с представителями Apple, придумать более аккуратный алгоритм работы с Touch ID, после чего фичу приняли.
Также мы не сразу придумали, как правильно делать покупку внутри бесплатной версии. Сначала хотели сделать покупку каждой мелкой фичи, но после обсуждения решили сделать только одну покупку «на всё».
Интересно было и сами буквы рисовать. Они рисуются много где, и в прописях пунктиром, и разной толщиной на экране рисования, и в истории, где можно просмотреть попытки ребёнка рисовать буквы вместе с ошибками… везде свои требования, свои сложности.
В результате получилось отличное приложение. Посмотрите. Есть и бесплатная версия, с покупкой внутри, и платная. Более 350 тысяч человек уже посмотрели, и многим нравится. :-) | https://habr.com/ru/post/278683/ | null | ru | null |
# Преобразование dxf в svg
Речь в статье пойдёт о программе на С/С++, написанной под Ubuntu, редактор — CodeBlocks. dxf — открытый формат, спецификация которого написана компанией Autodesk. Предполагаемое назначение — отображение dxf чертежей в веб проектах. Да, можно экспортировать из кое-каких редакторов, например, Librecad под Ubuntu или Acme CAD Converter под Windows, но это не во всех случаях может подходить, например, если нужна кастомизация.
Сначала подробнее про сам формат dxf. Он составлен из пар кодов и ассоциированных значений.
[**Пример**](https://images.autodesk.com/adsk/files/autocad_2012_pdf_dxf-reference_enu.pdf)
Существую готовые библиотеки для парсинга dxf. Я рассматривал [github.com/bert/libdxf](https://github.com/bert/libdxf), но свободная и небольшая библиотека от QCAD оказалась удобнее. Она есть в репозиториях Ubuntu, пакет под названием dxflib. Так как размер библиотеки маленький и она достаточно старая, без сторонних зависимостей, было решено скопировать её прямо в папку проекта. Также совместная компиляция при сборке с -О3, возможно, ускорит работу.
В более новых версиях формата сохраняется совместимость со старыми, то есть просто добавились пары кодов и ассоциированных значений. В dxfsvg я реализовал какую-то базовую часть спецификации — это основные примитивы. К дополнительным примитивам можно отнести, например, размерные стрелочки. Тут может быть вопрос — как я определил, какие примитивы основные? Взял чуть более 26000 файлов, в основном это экспорт из SolidWorks, добавил многопоточное чтение и накопление статистики. Это файлы catalog\_array.c и str\_array.c папки dir\_explore.
str\_array.c реализует массив строк названий dxf файлов. Перед строками я также подсунул битовый массив флагов с примитивами для определения их встречаемости. Да, можно было написать через vector, но это я взял из другого своего проекта.
catalog\_array.c реализует обход каталогов и подкаталогов
```
void catalog_contents::processing_files(void* (*start_routine)(void*))
{
if(filename==nullptr)
{
int i=0;
int THREAD_COUNT=sysconf(_SC_NPROCESSORS_ONLN);
pthread_t id[THREAD_COUNT];
printf("thread_count=%d\n", THREAD_COUNT);
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);
//создаём рабочие потоки
for(i = 0; i < THREAD_COUNT; i++)
{
thread_param param;
param.contents=this;
param.thread_count=THREAD_COUNT;
param.thread_num=i;
param.mutex=mutex;
pthread_create(&id[i], NULL, start_routine, ¶m);
}
pthread_mutex_destroy(&mutex);
//ждем завершения рабочих потоков
for(i = 0; i < THREAD_COUNT; i++)
{
pthread_join(id[i], NULL);
pthread_detach(id[i]);
}
}
else
{
svg_gen svg;
if (!svg.dxf.in(filename, svg.dxf_filter))
{
printf("File %s could not be opened\n", filename);
}
else
{
this->evaluate_dxf_stats(svg.func_bit_flags);
svg.svg_generate();
}
}
}
```
Если указано название файла, то будет обрабатываться 1 dxf файл, иначе будет обрабатываться весь каталог. Поскольку применяется dirent.h, то это даёт ухудшение портируемости, так как под Windows понадобится C POSIX library. Многопоточность нужна при обработке большого количества файлов, так как упор идёт в процессор (Xeon 2660v2). Включение HT практически не влияет, даёт прибавку всего в несколько процентов.
Далее про структуру наследования. Она достаточно простая в проекте. Основной класс — svg\_gen.
```
class svg_gen : public dxf_filter, public stats
class dxf_filter : public DL_CreationAdapter, public data_vectors
```
Если в С++ не было бы множественного наследования, то пришлось бы рассовывать родительские классы в конструкторы. DL\_CreationAdapter идёт от dxflib. data\_vectors содержит непосредственно примитивы. Формат dxf имеет такое понятие как блоки — набор примитивов, который может вставляться много раз в чертёж. На текущий момент программа не поддерживает вставки (Inserts) из-за невысокой встречаемости и отсутствия необходимости как-то обрабатывать эту геометрию, там где вставки есть. Всё что за пределами блоков — это основная часть, которую нужно парсить.
Как можете видеть, перевод в svg написан достаточно прямолинейно, трудности вызвала обработка сплайнов. Пробелы в математике я устранял при помощи Maple. В итоге образуется многочлен с индексами
Многочлен может быть получен командами Maple
with(CurveFitting):
xydata2 := [[x[0], 1], [x[1], 1], [x[2], 1], [x[3], 1], [x[4], 1], [x[5], 1], [x[6], 1], [x[7], 1], [x[8], 1], [x[9], 1]]
BSplineCurve(xydata2, t, order = 4, knots = [k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14])
order=3 — это квадратичные сплайны, order=4 — это кубические.
Сплайны задаются в терминах точек и узлов. Как вывести эти формулы путём математических доказательств и рассуждений я не знаю, так как сильно не заморачивался, но литературы с примерами по такому представлению сплайнов мало, а большинство того что загуглилось — англоязычное.
Все примитивы, кроме линий, окружностей и дуг представлены в виде аппроксимирующих линий. Для оптимизации веса svg файла можно применить кривые Безье второго порядка.
Допустим, есть 3 точки: P0, P(t), P2 вида (из Википедии)
Надо найти опорную точку P1 из уравнения 
Из этого уравнения выражаем P1, принимаем t=0.5, так как точки расположены равномерно.
В итоге получился достаточно простой код
```
string svg_gen::solve_quadratic_beizer(vector pt)
{
if(pt.size()>=4)
{
string res;
char pair[32]={0};
snprintf(pair,31,"%.3f,%.3f ", pt[0].x, pt[0].y);
res.append(pair);
int i=0;
start:
double Px=2\*pt[i+1].x-0.5\*(pt[i].x+pt[i+2].x);
double Py=2\*pt[i+1].y-0.5\*(pt[i].y+pt[i+2].y);
res=res+'Q';
memset(pair, 0, 32);
snprintf(pair,31,"%.3f,%.3f ", Px, Py);
res.append(pair);
memset(pair, 0, 32);
snprintf(pair,31,"%.3f,%.3f ", pt[i+2].x, pt[i+2].y);
res.append(pair);
if(pt.size()>i+4) {i=i+2; goto start;}
else
{ i=i+3;
while(i
```
Функцию Безье можно использовать в эллиптических дугах и сплайнах. Я добавил только в сплайны второго порядка. Рассмотрим пример. Вычисления опираются на формулы, полученные из Maple. Как видно, наличие препроцессора в С++ хорошо помогает сократить длину формул.
```
class spline_koeff
{
public:
double b1;
double b2;
double b3;
int n=0;
void coeffs(double t, vector pt, vector k);
};
void spline\_koeff::coeffs(double t,vector pt, vector k)
{
#define k2 k[n+1]
#define k3 k[n+2]
#define k4 k[n+3]
#define k5 k[n+4]
if(k2-k4!=0&&k3-k4!=0&&k3-k5!=0&&n<(int)pt.size())
{
b1=pow(k4-t,2)/(-k4+k2)/(-k4+k3);
b2=-(t\*t\*k2+k2\*k3\*k5+k2\*k3\*k4-k4\*k2\*k5-2\*t\*k3\*k2-k4\*t\*t+2\*t\*k4\*k5-t\*t\*k5+t\*t\*k3-k3\*k4\*k5)/(-k4+k2)/(-k4+k3)/(-k5+k3);
b3=pow(-t+k3,2)/(-k4+k3)/(-k5+k3);
}
else
{b1=0;b2=0;b3=0;}
}
void svg\_gen::spline\_points\_and\_knots\_degree2(vector pt, vector k, double x\_min, double y\_max)
{
point pt1, pt2;
string res=" pair;
spline\_koeff b123;
for(int j=3; j<(int)k.size()-2; ++j)
{
double ink=(k[j]-k[j-1])/10;
b123.n=j-3;
t=k[j-1];
int i=0;
while(i<10)
{
b123.coeffs(t, pt, k);
#define b1 b123.b1
#define b2 b123.b2
#define b3 b123.b3
#define n b123.n
pt1.x=b1\*pt[n].x+b2\*pt[n+1].x+b3\*pt[n+2].x;
pt1.y=b1\*pt[n].y+b2\*pt[n+1].y+b3\*pt[n+2].y;
t=t+ink;
printf("t1=%f\n",t);
b123.coeffs(t, pt, k);
pt2.x=b1\*pt[n].x+b2\*pt[n+1].x+b3\*pt[n+2].x;
pt2.y=b1\*pt[n].y+b2\*pt[n+1].y+b3\*pt[n+2].y;
t=t-ink;
printf("t2=%f\n",t);
char buf[72]= {0};
snprintf(buf,71,"%.3f,%.3f %.3f,%.3f ", pt1.x-x\_min, y\_max-pt1.y, pt2.x-x\_min, y\_max-pt2.y);
point pt={pt1.x-x\_min, y\_max-pt1.y};
pair.emplace\_back(pt);
if(i==9)
{
point pt={pt2.x-x\_min, y\_max-pt2.y};
pair.emplace\_back(pt);
}
// res.append(buf);
t=t+ink;
++i;
}
}
res=res+solve\_quadratic\_beizer(pair);
res.append("\"/>\n");
this->resulting\_svg=this->resulting\_svg+res;
}
```
Если поменять комметирование, то получим аппроксимацию линиями
```
/*point pt={pt1.x-x_min, y_max-pt1.y};
pair.emplace_back(pt);
if(i==9)
{
point pt={pt2.x-x_min, y_max-pt2.y};
pair.emplace_back(pt);
}*/
res.append(buf);
```
Я уменьшил в 2 раза количество точек для аппроксимации Безье. В итоге результат на каких-то сплайнах.
При линейной интерполяции
Кривыми
Размер 12,2кб против 7,1кб в пользу интерполяции квадратичными кривыми Безье.
Исследования выборки показали, что SolidWorks применяет сплайны третьего порядка, но эти кривые достаточно короткие и их можно просто аппрокисимровать линиями.
В LibreCad есть тоже открытая реализация экспорта в SVG /LibreCAD-master/librecad/src/lib/generators/ Там экспорт идёт из внутренних структур редактора. Это существенно усложняет процесс извлечения нужной части кода.
**[Ссылка на репозиторий](https://github.com/SanyaZ7/dxf_to_svg).**
Спасибо за внимание. | https://habr.com/ru/post/569552/ | null | ru | null |
# Нестандартное использование Protected Configuration Provider в проектах ASP.NET Web Forms
Сегодня я хотел бы рассказать об одной интересной, на мой взгляд, возможности, которую можно получить от Protected Configuration Provider.
Итак, что такое Protected Configuration Provider? Это класс, который позволяет производить шифрование и дешифрование содержимого определённых секций файла конфигурации web.config. Обычно это используется при развёртывании готового проекта на хостинге для защиты конфиденциальной информации — имена пользователей, пароли, строки подключения к базе данных, ключи шифрования, и т.д.
Прописывается в секции configProtectedData:
```
```
Используется в секциях appSettings и connectionStrings:
```
...
...
```
Попробуем использовать возможности этого класса нестандартно, а именно, для создания ветвлений в конфигурации в рамках одного проекта – профилей конфигурации, в зависимости от имени виртуальной директории приложения в рамках одного веб сайта.
Для чего это нужно? Прежде всего, для развертывания тестовых линеек сайтов основанных на одном и том же проекте, но имеющих разные строки подключения к базе данных, и другие установки в секции appSettings и connectionStrings.
Другими словами говоря, это может сильно упростить жизнь, когда вам нужно развернуть, к примеру несколько одинаковых сайтов, только с разными настройками, но имеющих общий код. Например, с разными именами темы или строками подключения к базе данных.
Напишем и установим такой провайдер.
В IIS менеджере создадим сайт “DemoSite”, который будет ссылаться пока на пустую папку. Далее создадим два приложения (виртуальные директории), которые будут ссылаться на корневую папку нашего проекта, там где лежит наш web.config.
В файле web.config изменим секцию appSettings и connectionStrings, чтобы получилось, что то вроде этого:
```
xml version="1.0" encoding="UTF-8"?
...
...
...
...
...
...
...
...
...
```
Теперь у нас появились в конфиге секции profile1 и profile2, а также мы указали в качестве провайдера класс DemoConfigurationProvider.
После этих манипуляций вы можете обращаться к своему сайту с использованием этих профилей. Примерно так: [localhost/DemoSite/profile1](http://localhost/DemoSite/profile1/) или [localhost/DemoSite/profile2](http://localhost/DemoSite/profile2/). Соответственно будут применяться соответствующие настройки из секций profile1 и profile2.
Надеюсь, идея понятна и будет кому то полезна. Теперь нам осталось только реализовать класс DemoConfigurationProvider.
Подробно рассматривать этот класс в данной статье я не стану, просто дам ссылку на готовый демо проект, включающий исходный текст.
После запуска демо проекта вы должны получить примерно следующее:
Скачать: [демо на github](https://github.com/dimaby/DemoProvider) | https://habr.com/ru/post/152521/ | null | ru | null |
# Бот для аркады. Часть №2: подключаем OpenCV
#### Введение
Продолжаем ~~управлять миром~~ разрабатывать бота для игры. Предыдущий разговор остановился на том, что контакт установлен: мышь бегает, изображение получается. Пора выделять объекты, это требует использование множества различных функции по обработке изображений. Можно, конечно, изобрести велосипед и написать эти функции самостоятельно, но лучше воспользоваться готовыми наработками.
Для обработки изображений возьмем широкораспространенную библиотеку [OpenCV](http://opencv.org/). Она неродная (unmanaged) для .net, поэтому подключим ее через wrapper [OpenCvSharp](https://github.com/shimat/opencvsharp).
OpenCV нам нужна для того, чтобы, применяя различные преобразования к изображениями, выбрать такое преобразование, которое отделит фон и тени от объектов, а объекты друг от друга. К этой цели и будем сегодня двигаться.
---
**Затрагиваемые темы**: *выбор библиотеки для обработки изображений, выбор wrapper-а для работы с OpenCV, основные функции OpenCV, выделение движущихся объектов, цветовая модель HSV.*
---
#### Почему OpenCV?
Для обработки изображений есть и другие хорошие библиотеки, на одной [OpenCV](http://opencv.org/) свет клином не сошелся.
При программировании под .net также стоит обратить внимание на библиотеку [Accord.Net](http://code.google.com/p/accord/) (и ее более раннюю версию [AForge.Net](http://code.google.com/p/aforge/)). Эти две библиотеки также бесплатные, но родные(managed) для .net-платформы, в отличии от OpenCV.
При разработке продукта на продажу, а не «for fun» — я скорее остановился бы на managed-библиотеках. Выбор хороших managed-библиотек не ухудшает производительность, но здорово упрощает развертывание, переносимость и последующее сопровождение. Но в стартапах и при разработке «for fun» важнее большое community, чем будущее упрощение сопровождения. И это возвращает нас к библиотеке OpenCV, у которой намного более широкая известность.
##### Большое community
При самостоятельном выборе библиотек имеет смысл ориентироваться на те, что имеют большое активное community. Большое количество последователей дает высокую оттестированность библиотеки, малый процент неудобств использования, разнообразие документации, и делает простым гугление вопросов, возникающих по ходу работы.
OpenCV целиком поддерживает данный тезис. По ней есть книжка: [Learning OpenCV](http://shop.oreilly.com/product/0636920022497.do) (*честно говоря, еще не читал, но собираюсь исправить это в ближайщем времени*), есть ее перевод на русский [locv.ru](http://locv.ru/) (*сейчас у меня не открывается*), есть [online-документация](http://docs.opencv.org/), есть куча вопросов с ответами на [stackoverflow](http://stackoverflow.com/questions/tagged/opencv?sort=frequent).
Всё это наем дает быстрый старт, обеспечивая подход «Пли! Готовсь! Целься» (когда изучение библиотеки идет по ходу работы) вместо классического «Готовсь! Целься! Пли!» (когда сначала значительное время уходит на предварительное ознакомление с устройством библиотеки).
##### Гуглим вопросы
Большинство задач решалось с помощью быстрого гугления: в гугл забиваются ключевые слова в тему вопроса, и в первых ссылках сразу же находится ответ. При самостоятельном поиске ответов обязательно обращаем внимание на то, какие ключевые слова используются для описания искомой проблематики. Гуглу не важна красота и граматическая правильность вопроса, для него значимо только наличие ключевых слов, по которым он и будет выбирать ответ.
Примеры решаемых вопросов:
— выделить R-компоненту из изображения — запрос в гугл: [google: opencv get single channel](https://www.google.ru/webhp?q=opencv+get+single+component), и первая же ссылка говорит, что это делается с помощью функции Split
— найти различия между изображениями: [google: opencv difference images](https://www.google.ru/webhp?q=opencv+difference+images), и пример из первого же ответа говорит, что это делает функция absdiff. Если же при поиске использовать слово compare вместо difference, то гугл начнет показывать совсем другие страницы, и это даст более общие ответы с рекомендацией использовать сравнение гистограмм и т.д. Это показывает важность выбора ключевых слов при поиске ответа на свой вопрос.
#### Выбираем .net-wrapper для OpenCV
Библиотеку выбрали, осталось подружить ее с C#-ом. Эта задача уже решена до нас, и нам опять остается только сделать выбор между имеющимися вариантами. Распространенных wrapper-а два: [Emgu Cv](http://www.emgu.com) и [OpenCvSharp](https://github.com/shimat/opencvsharp). Emgu Cv более старая и более кондовая, OpenCvSharp более современная. Выбор остановился на OpenCvSharp, подкупили слова автора о том, что поддерживается IDisposable. Это означает, что автор не просто 1 в 1 перенес структуры и функции из C/C++ в C#, но и допилил их напильником, чтобы их было удобнее использовать в C#-стиле написания кода.
##### Подключаем OpenCvSharp к проекту
Подключение OpenCvSharp к проекту делается стандартным способом, без каких-то особых закавык. Есть небольшой [tutorial](https://github.com/shimat/opencvsharp/wiki/Tutorial-for-Windows) от автора, также есть возможность подключения [OpenCvSharp через nuget](https://www.nuget.org/packages/OpenCvSharp-x64/).
#### Основные базовые функции
OpenCV имеет множество функции для работы с изображениями. Остановимся только на основных базовых функциях, которые используются при решении задачи выделения объектов из изображения. OpenCV имеет два варианта использования: C-стиль и C++-стиль. Для упрощения кода будем использовать C++-стиль (вернее его аналог через OpenCvSharp).
Основных класса два: Mat и Cv2. Оба находятся в namespace-е OpenCvSharp.CPlusPlus. Mat — это само изображение, а Cv2 — это набор действий над изображениями.
Функции:
```
//загрузка изображения
var mat = new Mat("test.bmp");
//сохранение изображения
mat.ImWrite("out.bmp");
//преобразование в bitmap
var bmp = mat.ToBitmap();
//преобразование из bitmap (требуется подключение OpenCvSharp.Extensions)
var mat2 = new Mat(bmp.ToIplImage(), true);
//показ изображения
using (new Window("изображение", mat))
{
Cv2.WaitKey();
}
//преобразование цветового пространства (например, из цветного в градации серого)
Cv2.CvtColor(mat, dstMat, ColorConversion.RgbToGray);
//разделение изображения на отдельные цветовые каналы
Cv2.Split(mat, out mat_channels)
//сборка многоцветного изображения из отдельных каналов
Cv2.Merge(mat_channels, mat)
//разница между двумя изображениями
Cv2.Absdiff(mat1, mat2, dstMat);
//приведение точек, которые темнее/светлее определенного уровня(50) к черному(0) или белому цвету(255)
Cv2.Threshold(mat, dstMat, 50, 255, OpenCvSharp.ThresholdType.Binary);
//рисование примитивов
mat.Circle(x, y, radius, new Scalar(b, g, r));
mat.Line(x1, y1, x2, y2, new CvScalar(b, g, r));
mat.Rectangle(new Rect(x, y, width, height), new Scalar(b, g, r));
mat.Rectangle(new Rect(x, y, width, height), new Scalar(b, g, r), -1); //закрашенный прямоугольник
mat.PutText("test", new OpenCvSharp.CPlusPlus.Point(x, y), FontFace.HersheySimplex, 2, new Scalar(b, g, r))
```
Также в OpenCV есть специальные функции для выделения объектов([Structural Analysis and Shape Descriptors](http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html), [Motion Analysis and Object Tracking](http://docs.opencv.org/modules/imgproc/doc/motion_analysis_and_object_tracking.html), [Feature Detection](http://docs.opencv.org/modules/imgproc/doc/feature_detection.html), [Object Detection](http://docs.opencv.org/modules/imgproc/doc/object_detection.html)), но наскоком выжать из них полезный результат не получилось (*надо, наверное, все-таки книжку почитать*), поэтому оставим их на потом.
#### Выделение объектов
Простой метод выделения объектов сводится к придумыванию фильтра, который отсечет фон от объектов, а объекты друг от друга. К сожалению, изображение поля Zuma-ы очень пестрое, и простая отсечка по яркости не срабатывает. Ниже приведены исходное изображение, ее черно-белый вариант, и лесенка различных отсечек. На последнем изображении видно, что во всех случаях фон сливается с шарами, или либо и то, и другое присутствует, либо одновременно — отсутствуют.
Выделение объектов сильно затрудняет их «полосатость». Вот, например, как реагирует функция Canny, выделяющая контуры объектов.
Использование отдельных цветовых компонент жизнь лучше не делает.
#### Выделение движущихся объектов
Основа выделения движушихся объектов — проста: сравниваются два файла — изменившиеся точки и являются искомыми объектами. На практике всё сложнее, и дьявол, как всегда, кроется в мелочах…
##### Формирование серии изображении
Для формирования серии изображений добавим небольшой код в нашего бота. Бот будет вести историю последних кадров, и по нажатию на пробел сбрасывать их на диск.
```
var history = new List();
for (var tick = 0; ;tick++)
{
var bmp = GetScreenImage(gameScreenRect);
history.Insert(0, bmp);
const int maxHistoryLength = 10;
if (history.Count > maxHistoryLength)
history.RemoveRange(maxHistoryLength, history.Count - maxHistoryLength);
if (Console.KeyAvailable)
{
var keyInfo = Console.ReadKey();
if (keyInfo.Key == ConsoleKey.Spacebar)
{
for (var i = 0; i < history.Count; ++i)
history[i].Save(string.Format("{0}.png", i));
}
[..]
}
[..]
}
```
Запускаем, жмем и вуаля — у нас на руках есть два кадра.
##### Сравнение соседних
Вычитаем одно изображение из другого… и что называется «смешались в кучу кони, люди». Шары превратились во что-то «странное» (это хорошо видно, на полноразмерном фрагменте), но это ладно, главное что шары получилось отделить от фона.
##### Сравнение со специально подготовленным фоном
Сравнение соседних кадров хорошо подходит для «отдельно стоящих» движущихся объектов. Если же необходимо выделить плотно движущиеся объекты, то лучше работает сравнение со специально подготовленным статичным фоном.
Подготавливаем такой фон:
Сравниваем:
Много лучше, но всё портят тени. От теней я пытался избавиться множеством способов, но самый лучший эффект дала мысль, что тень, по сути, есть изменение яркости, а это уже меня навело на мысль о цветовой модели HSV.
#### HSV
Цветовая модель HSV, также как и RGB, состоит из трех каналов. Но в отличии от него (и того же CMYK) — это не просто смешение цветов.
— Первый канал, H(Hue) — цветовой тон. В первом приближении, это номер цвета из радуги.
— Второй канал, S(Saturation) — насыщенность. Чем меньше значение этого канала, тем цвет ближе к серому, чем больше — тем более цвет выражен. Цвета с высокой насыщенностью известны под разговорным названием — «кислотные».
— Третий канал, V(Value) — яркость. Это самый простый для понимания канал, чем больше освещенность, тем выше значение по данному каналу.
Картинка справа показывает взаимосвязь каналов и цветов между собой. По кругу идет радуга — это канал H. Треугольник для конкретного цвета (сейчас это красный) показывает изменение канала S — насыщенности (направление в верх-право) и изменение канала V — яркости (в верх-лево). Классически, значения канала H лежат в диапазоне 0-360, S — 0-100, V — 0-100. В OpenCV значения всех каналов приведены к диапазону 0-255 для того, чтобы по-максимуму использовать размерность одного байта.
Цветовая модель RGB близка к человеческому глазу, к тому как он устроен. Цветовая модель HSV близка к тому, как цвет воспринимается мозгом. Ниже я специально привел серию изображений того, что будет, если каждый канал поменять на плюс/минус 50 попугаев. На них видно, что даже после изменения каналов S и V на 100 единиц (а это половина диапазона) изображение воспринимается почти как тоже самое, а вот даже небольшое изменение канала H сильно меняет восприятие, делая изображение «наркоманским». Это связано с тем, что мозг за долгие годы эволюции научился отделять более стабильные данные от менее стабильных.
Что значит «стабильные»? Это та часть информации, которая меньше всего меняется от каких-то внешних условий. Возьмем реальный предмет, например, однотонный мячик. Он обладает каким-то собственным цветом, но восприятие этого цвета будет меняться в зависимости от внешних условий: освещенности, прозрачности воздуха, отсвета соседних объектов и т.д. Соответственно, если стоит задача выделять мячик из окружающего мира вне зависимости от внешних условий, то необходимо больше ориентироваться на ту часть информации, которая слабо меняется от внешних условий, и игнорировать ту часть, что меняется сильнее всего. Наименее стабильной является яркость (канал V): переместились в тень и яркость окружающего мира поменялась, небо затянуло тучами — и яркость опять поменялась. Насыщенность (канал S) также меняется в течении дня, точнее меняется восприятие цвета — чем меньше освещенность, тем больше дают вклад [колбочки](http://ru.wikipedia.org/wiki/%CA%EE%EB%E1%EE%F7%EA%E8) (черно-белое зрение) и меньше поступает информации от [палочек](http://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D0%BB%D0%BE%D1%87%D0%BA%D0%B8_(%D1%81%D0%B5%D1%82%D1%87%D0%B0%D1%82%D0%BA%D0%B0)) (цветное зрение). Цветовой тон (канал H) меняется слабее всего и наиболее стабильно отражает цвет объекта.
##### Сравнение с фоном в hsv-пространстве
Повторяем вычитание из статичного фона, но теперь уже после преобразования в пространство hsv, и О! Чудо! В каналах H и S шарики четко отделены от теней, все тени почти целиком ушли в канал V. В H-канале даже пропадает «изрезанность» шариков, но, к сожалению, желтые шары начинают сливаются с фоном. В S-канале изрезанность остается, но зато все шары хорошо видны, и перевод в двухцветное изображение (с обрезанием «мусора» меньше значения 25) дает четкие круги и убирает всё лишнее.
##### Резюме
Поставленная на сегодня цель достигнута (шары отделены от фона и от своих теней), и со спокойной душой можно идти спать.
##### PS
Все приведенные изображения сформированы с помощью использования OpenCV (код под катом).
**Скрытый текст**
```
var resizeK = 0.2;
var dir = "Example/";
var src = new Mat("0.bmp");
var src_g = new Mat("0.bmp", LoadMode.GrayScale);
var src_1 = new Mat("1.bmp");
var src_1_g = new Mat("1.bmp", LoadMode.GrayScale);
var background = new Mat("background.bmp");
var background_g = new Mat("background.bmp", LoadMode.GrayScale);
src.Resize(resizeK).ImWrite(dir + "0.png");
src_g.Resize(resizeK).ImWrite(dir + "0 g.png");
src_g.ThresholdStairs().Resize(resizeK).ImWrite(dir + "0 g th.png");
var canny = new Mat();
Cv2.Canny(src_g, canny, 50, 200);
canny.Resize(0.5).ImWrite(dir + "0 canny.png");
Mat[] src_channels;
Cv2.Split(src, out src_channels);
for (var i = 0; i < src_channels.Length; ++i)
{
var channels = Enumerable.Range(0, src_channels.Length).Select(j => new Mat(src_channels[0].Rows, src_channels[0].Cols, src_channels[0].Type())).ToArray();
channels[i] = src_channels[i];
var dst = new Mat();
Cv2.Merge(channels, dst);
dst.Resize(resizeK).ImWrite(dir + string.Format("0 ch{0}.png", i));
src_channels[i].ThresholdStairs().Resize(resizeK).ImWrite(dir + string.Format("0 ch{0} th.png", i));
}
if (true)
{
src.Resize(0.4).ImWrite(dir + "0.png");
src_1.Resize(0.4).ImWrite(dir + "1.png");
background.Resize(0.4).ImWrite(dir + "bg.png");
var dst_01 = new Mat();
Cv2.Absdiff(src, src_1, dst_01);
dst_01.Resize(resizeK).ImWrite(dir + "01.png");
dst_01.Cut(new Rect(50, src.Height * 4 / 5 - 50, src.Width / 5, src.Height / 5)).ImWrite(dir + "01 part.png");
dst_01.Cut(new Rect(50, src.Height * 4 / 5 - 50, src.Width / 5, src.Height / 5)).CvtColor(ColorConversion.RgbToGray).ImWrite(dir + "01 g.png");
dst_01.CvtColor(ColorConversion.RgbToGray).ThresholdStairs().Resize(resizeK).ImWrite(dir + "01 g th.png");
var dst_01_g = new Mat();
Cv2.Absdiff(src_g, src_1_g, dst_01_g);
dst_01_g.Cut(new Rect(50, src.Height * 4 / 5 - 50, src.Width / 5, src.Height / 5)).ImWrite(dir + "0g1g.png");
dst_01_g.ThresholdStairs().Resize(resizeK).ImWrite(dir + "0g1g th.png");
}
if (true)
{
var dst_0b = new Mat();
Cv2.Absdiff(src, background, dst_0b);
dst_0b.Resize(0.6).ImWrite(dir + "0b.png");
var dst_0b_g = new Mat();
Cv2.Absdiff(src_g, background_g, dst_0b_g);
dst_0b_g.Resize(0.3).ImWrite(dir + "0b g.png");
dst_0b_g.ThresholdStairs().Resize(0.3).ImWrite(dir + "0b g th.png");
}
if (true)
{
var hsv_src = new Mat();
Cv2.CvtColor(src, hsv_src, ColorConversion.RgbToHsv);
var hsv_background = new Mat();
Cv2.CvtColor(background, hsv_background, ColorConversion.RgbToHsv);
var hsv_background_channels = hsv_background.Split();
var hsv_src_channels = hsv_src.Split();
if (true)
{
var all = new Mat(src.ToIplImage(), true);
for (var i = 0; i < hsv_src_channels.Length; ++i)
{
hsv_src_channels[i].CvtColor(ColorConversion.GrayToRgb).CopyTo(all, new Rect(i * src.Width / 3, src.Height / 2, src.Width / 3, src.Height / 2));
}
src_g.CvtColor(ColorConversion.GrayToRgb).CopyTo(all, new Rect(src.Width / 2, 0, src.Width / 2, src.Height / 2));
all.Resize(0.3).ImWrite(dir + "all.png");
}
foreach (var pair in new[] { "h", "s", "v" }.Select((channel, index) => new { channel, index }))
{
var diff = new Mat();
Cv2.Absdiff(hsv_src_channels[pair.index], hsv_background_channels[pair.index], diff);
diff.Resize(0.3).With_Title(pair.channel).ImWrite(dir + string.Format("0b {0}.png", pair.channel));
diff.ThresholdStairs().Resize(0.3).ImWrite(dir + string.Format("0b {0} th.png", pair.channel));
hsv_src_channels[pair.index].Resize(resizeK).With_Title(pair.channel).ImWrite(dir + string.Format("0 {0}.png", pair.channel));
foreach (var d in new[] { -100, -50, 50, 100 })
{
var delta = new Mat(hsv_src_channels[pair.index].ToIplImage(), true);
delta.Rectangle(new Rect(0, 0, delta.Width, delta.Height), new Scalar(Math.Abs(d)), -1);
var new_channel = new Mat();
if (d >= 0)
Cv2.Add(hsv_src_channels[pair.index], delta, new_channel);
else
Cv2.Subtract(hsv_src_channels[pair.index], delta, new_channel);
var new_hsv = new Mat();
Cv2.Merge(hsv_src_channels.Select((channel, index) => index == pair.index ? new_channel : channel).ToArray(), new_hsv);
var res = new Mat();
Cv2.CvtColor(new_hsv, res, ColorConversion.HsvToRgb);
res.Resize(resizeK).With_Title(string.Format("{0} {1:+#;-#}", pair.channel, d)).ImWrite(dir + string.Format("0 {0}{1}.png", pair.channel, d));
}
}
}
static class OpenCvHlp
{
public static Scalar ToScalar(this Color color)
{
return new Scalar(color.B, color.G, color.R);
}
public static void CopyTo(this Mat src, Mat dst, Rect rect)
{
var mask = new Mat(src.Rows, src.Cols, MatType.CV_8UC1);
mask.Rectangle(rect, new Scalar(255), -1);
src.CopyTo(dst, mask);
}
public static Mat Absdiff(this Mat src, Mat src2)
{
var dst = new Mat();
Cv2.Absdiff(src, src2, dst);
return dst;
}
public static Mat CvtColor(this Mat src, ColorConversion code)
{
var dst = new Mat();
Cv2.CvtColor(src, dst, code);
return dst;
}
public static Mat Threshold(this Mat src, double thresh, double maxval, ThresholdType type)
{
var dst = new Mat();
Cv2.Threshold(src, dst, thresh, maxval, type);
return dst;
}
public static Mat ThresholdStairs(this Mat src)
{
var dst = new Mat(src.Rows, src.Cols, src.Type());
var partCount = 10;
var partWidth = src.Width / partCount;
for (var i = 0; i < partCount; ++i)
{
var th_mat = new Mat();
Cv2.Threshold(src, th_mat, 255 / 10 * (i + 1), 255, ThresholdType.Binary);
th_mat.Rectangle(new Rect(0, 0, partWidth * i, src.Height), new Scalar(0), -1);
th_mat.Rectangle(new Rect(partWidth * (i + 1), 0, src.Width - partWidth * (i + 1), src.Height), new Scalar(0), -1);
Cv2.Add(dst, th_mat, dst);
}
var color_dst = new Mat();
Cv2.CvtColor(dst, color_dst, ColorConversion.GrayToRgb);
for (var i = 0; i < partCount; ++i)
{
color_dst.Line(partWidth * i, 0, partWidth * i, src.Height, new CvScalar(50, 200, 50), thickness: 2);
}
return color_dst;
}
public static Mat With_Title(this Mat mat, string text)
{
var res = new Mat(mat.ToIplImage(), true);
res.Rectangle(new Rect(res.Width / 2 - 10, 30, 20 + text.Length * 15, 25), new Scalar(0), -1);
res.PutText(text, new OpenCvSharp.CPlusPlus.Point(res.Width / 2, 50), FontFace.HersheyComplex, 0.7, new Scalar(150, 200, 150));
return res;
}
public static Mat Resize(this Mat src, double k)
{
var dst = new Mat();
Cv2.Resize(src, dst, new OpenCvSharp.CPlusPlus.Size((int)(src.Width * k), (int)(src.Height * k)));
return dst;
}
public static Mat Cut(this Mat src, Rect rect)
{
return new Mat(src, rect);
}
public static Mat[] Split(this Mat hsv_background)
{
Mat[] hsv_background_channels;
Cv2.Split(hsv_background, out hsv_background_channels);
return hsv_background_channels;
}
}
```
---
[Бот для DirectX-аркады. Часть №1: устанавливаем контакт](http://habrahabr.ru/post/214955/)
[Бот для аркады. Часть №2: подключаем OpenCV](http://habrahabr.ru/post/216757/)
--- | https://habr.com/ru/post/216757/ | null | ru | null |
# Управление семисегментным дисплеем с помощью ПЛИС
Привет, Хабр! Хочу внести свою посильную лепту в продвижение ПЛИС. В этой статье я постараюсь объяснить, как на языке VHDL описать устройство, управляющее семисегментным дисплеем. Но перед тем как начать, хочу кратко рассказать о том как я пришел к ПЛИС и почему я выбрал язык VHDL.
Где-то пол года назад решил попробывать свои силы в программировании ПЛИС. До этого со схемотехникой никогда не сталкивался. Был небольшой опыт использования микроконтроллеров (Atmega328p, STM32). Сразу после решения освоиться с ПЛИС, встал вопрос выбора языка, который я буду использовать. Выбор пал на VHDL из-за его строгой типизации. Мне, как новичку, хотелось как можно больше возможных проблем отловить на этапе синтеза, а не на рабочем устройстве.
Почему именно семисегментный дисплей? Мигать светодиодом уже надоело, да и логика мигания им не представляет из себя ничего интересного. Логика управления дисплеем с одной стороны сложнее, чем мигание светодиодом (т. е. писать ее интереснее), а с другой достаточно простая в реализации.
Что я использовал в процессе создания устройства:
* ПЛИС Altera Cyclone II (знаю, что он безнадежно устарел, зато у китайцев его можно купить за копейки)
* Quartus II версии 13.0.0 (на сколько я знаю это последняя версия поддерживающая Cyclone II)
* Симулятор ModelSim
* Семисегментный дисплей со сдвиговым регистром
### Задача
Создать устройство, которое будет в цикле показывать числа 0 — 9. Раз в секунду отображаемое на дисплее значение должно увеличиваться на 1.
Реализовать данную логику можно по-разному. Я разделю данное устройство на модули, каждый из которых будет выполнять какое-то действие и результат этого действия будет передаваться следующему модулю.
### Модули
* Данное устройство должно уметь отсчитывать время. Для подсчета времени я создал модуль «delay». Этот модуль имеет 1 входящий и 1 исходящий сигнал. Модуль принимает частотный сигнал ПЛИС и, через указанное количество периодов входящего сигнала, меняет значение исходящего сигнала на противоположное.
* Устройство должно считать от 0 до 9. Для этого будет использоваться модуль bcd\_counter.
* Для того, чтобы зажечь сегмент на дисплее, нужно выставить в сдвиговом регистре дисплея соответствующий сегменту бит в 0, а для того, чтобы погасить сегмент в бит нужно записать 1 (мой дисплей имеет инвертированную логику). Установкой и сбросом нужных битов будет заниматься декодер bcd\_2\_7seg.
* За передачу данных будет отвечать модуль transmitter.
Главное устройство будет управлять корректной передачей сигналов между модулями, а также генерировать сигнал rclk по завершению передачи данных.
**Для наглядности, привожу схему данного устройства**
Как видно из схемы устройство имеет 1 входящий сигнал (clk) и 3 исходящих сигнала (sclk, dio, rclk). Сигнал clk приходит в 2 делителя сигнала (sec\_delay и transfer\_delay). Из устройства sec\_delay выходит исходящий сигнал с периодом 1с. По переднему фронту этого сигнала счетчик (bcd\_counter1) начинает генерировать следующее число для отображения на дисплее. После того, как число сгенерировано, декодер (bcd\_2\_7seg1) преобразует двоичное представление числа в горящие и не горящие сегменты на дисплее. Которые, с помощью передатчика (transmitter1), передаются на дисплей. Тактирование передатчика осуществляется с помощью устройства transfer\_delay.
### Код
Для создания устройства в VHDL используется конструкция из двух составляющих entity и architecture. В entity декларируется интерфейс для работы с устройством. В architecture описывается логика работы устройства.
**Вот как выглядит entity устройства delay**
```
entity delay is
-- При объявлении entity, поле generic не является обязательным
generic (delay_cnt: integer);
-- Описываем входные и выходные сигналы устройства
port(clk: in std_logic; out_s: out std_logic := '0');
end entity delay;
```
Через поле generic мы можем задать устройству нужную задержку. А в поле ports описываем входящие и исходящие сигналы устройства.
**Архитектура устройства delay выглядит следующим образом**
```
-- В секции architecture описывается то, как устройство будет работать
-- С одной entity может быть связано 0 или более архитектур
architecture delay_arch of delay is
begin
delay_proc: process(clk)
variable clk_cnt: integer range 0 to delay_cnt := 0;
variable out_v: std_logic := '0';
begin
-- Если имеем дело с передним фронтом сигнала
if(rising_edge(clk)) then
clk_cnt := clk_cnt + 1;
if(clk_cnt >= delay_cnt) then
-- switch/case в языке VHDL
case out_v is
when '0' =>
out_v := '1';
when others =>
out_v := '0';
end case;
clk_cnt := 0;
-- Устанавливаем в сигнал out_s значение переменной out_v
out_s <= out_v;
end if;
end if;
end process delay_proc;
end delay_arch;
```
Код внутри секции process исполняется последовательно, любой другой код исполняется параллельно. В скобках, после ключевого слова process указываются сигналы, по изменению которых данный процесс будет запускаться (sensivity list).
Устройство bcd\_counter в плане логики выполнения идентично устройству delay. Поэтому на нем я подробно останавливаться не буду.
**Вот как выглядит entity и architecture декодера**
```
entity bcd_to_7seg is
port(bcd: in std_logic_vector(3 downto 0) := X"0";
disp_out: out std_logic_vector(7 downto 0) := X"00");
end entity bcd_to_7seg;
architecture bcd_to_7seg_arch of bcd_to_7seg is
signal not_bcd_s: std_logic_vector(3 downto 0) := X"0";
begin
not_bcd_s <= not bcd;
disp_out(7) <= (bcd(2) and not_bcd_s(1) and not_bcd_s(0)) or
(not_bcd_s(3) and not_bcd_s(2) and not_bcd_s(1)
and bcd(0));
disp_out(6) <= (bcd(2) and not_bcd_s(1) and bcd(0)) or
(bcd(2) and bcd(1) and not_bcd_s(0));
disp_out(5) <= not_bcd_s(2) and bcd(1) and not_bcd_s(0);
disp_out(4) <= (not_bcd_s(3) and not_bcd_s(2) and not_bcd_s(1)
and bcd(0)) or
(bcd(2) and not_bcd_s(1) and not_bcd_s(0)) or
(bcd(2) and bcd(1) and bcd(0));
disp_out(3) <= (bcd(2) and not_bcd_s(1)) or bcd(0);
disp_out(2) <= (not_bcd_s(3) and not_bcd_s(2) and bcd(0)) or
(not_bcd_s(3) and not_bcd_s(2) and bcd(1)) or
(bcd(1) and bcd(0));
disp_out(1) <= (not_bcd_s(3) and not_bcd_s(2) and not_bcd_s(1)) or
(bcd(2) and bcd(1) and bcd(0));
disp_out(0) <= '1';
end bcd_to_7seg_arch;
```
Вся логика данного устройства выполняется параллельно. О том как получить формулы для данного устройства я рассказывал в одном из видео на своем канале. Кому интересно, вот ссылка на [видео](https://youtu.be/whWZJPnMx6s).
**В устройстве transmitter я комбинирую последовательную и параллельную логику**
```
entity transmitter is
port(enable: in boolean;
clk: in std_logic;
digit_pos: in std_logic_vector(7 downto 0) := X"00";
digit: in std_logic_vector(7 downto 0) := X"00";
sclk, dio: out std_logic := '0';
ready: buffer boolean := true);
end entity transmitter;
architecture transmitter_arch of transmitter is
constant max_int: integer := 16;
begin
sclk <= clk when not ready else '0';
send_proc: process(clk, enable, ready)
variable dio_cnt_v: integer range 0 to max_int := 0;
variable data_v: std_logic_vector((max_int - 1) downto 0);
begin
-- Установка сигнала dio происходит по заднему фронту сигнала clk
if(falling_edge(clk) and (enable or not ready)) then
if(dio_cnt_v = 0) then
-- Прежде всего передаем данные, потом позицию на дисплее
-- Нулевой бит данных идет в нулевой бит объединенного вектора
data_v := digit_pos & digit;
ready <= false;
end if;
if(dio_cnt_v = max_int) then
dio_cnt_v := 0;
ready <= true;
dio <= '0';
else
dio <= data_v(dio_cnt_v);
dio_cnt_v := dio_cnt_v + 1;
end if;
end if;
end process send_proc;
end transmitter_arch;
```
В сигнал sclk я перенаправляю значение входящего в передатчик сигнала clk, но только в том случае, если устройство в данный момент выполняет передачу данных (сигнал ready = false). В противном случае значение сигнала sclk будет равно 0. В начале передачи данных (сигнал enable = true), я объединяю данные из двух входящих в устройство 8-и битных векторов (digit\_pos и digit) в 16-и битный вектор (data\_v) и передаю данные из этого вектора по одному биту за такт, устанавливая значение передаваемого бита в исходящий сигнал dio. Из интересного в этом устройстве хочу отметить то, что данные в dio устанавливаются на задний фронт сигнала clk, а в сдвиговый регистр дисплея данные с пина dio будут записаны по приходу переднего фронта сигнала sclk. По завершению передачи, установкой сигнала ready <= true сигнализирую другим устройствам, что передача завершилась.
**Вот как выглядит entity и architecture устройства display**
```
entity display is
port(clk: in std_logic; sclk, rclk, dio: out std_logic := '0');
end entity display;
architecture display_arch of display is
component delay is
generic (delay_cnt: integer);
port(clk: in std_logic; out_s: out std_logic := '0');
end component;
component bcd_counter is
port(clk: in std_logic; bcd: out std_logic_vector(3 downto 0));
end component;
component bcd_to_7seg is
port(bcd: in std_logic_vector(3 downto 0);
disp_out: out std_logic_vector(7 downto 0));
end component;
component transmitter is
port(enable: in boolean;
clk: in std_logic;
digit_pos: in std_logic_vector(7 downto 0);
digit: in std_logic_vector(7 downto 0);
sclk, dio: out std_logic;
ready: buffer boolean);
end component;
signal sec_s: std_logic := '0';
signal bcd_counter_s: std_logic_vector(3 downto 0) := X"0";
signal disp_out_s: std_logic_vector(7 downto 0) := X"00";
signal tr_enable_s: boolean;
signal tr_ready_s: boolean;
signal tr_data_s: std_logic_vector(7 downto 0) := X"00";
-- Этот флаг, совместно с tr_ready_s контролирует
-- установку и сброс rclk сигнала
signal disp_refresh_s: boolean;
signal transfer_clk: std_logic := '0';
begin
sec_delay: delay generic map(25_000_000)
port map(clk, sec_s);
transfer_delay: delay generic map(10)
port map(clk, transfer_clk);
bcd_counter1: bcd_counter port map(sec_s, bcd_counter_s);
bcd_to_7seg1: bcd_to_7seg port map(bcd_counter_s, disp_out_s);
transmitter1: transmitter port map(tr_enable_s,
transfer_clk,
X"10",
tr_data_s,
sclk,
dio,
tr_ready_s);
tr_proc: process(transfer_clk)
variable prev_disp: std_logic_vector(7 downto 0);
variable rclk_v: std_logic := '0';
begin
if(rising_edge(transfer_clk)) then
-- Если передатчик готов к передаче следующей порции данных
if(tr_ready_s) then
-- Если передаваемые данные не были только что переданы
if(not (prev_disp = disp_out_s)) then
prev_disp := disp_out_s;
-- Помещаем передаваемые данные в шину данных передатчика
tr_data_s <= disp_out_s;
-- Запускаем передачу данных
tr_enable_s <= true;
end if;
else
disp_refresh_s <= true;
-- Флаг запуска передачи данных нужно снять
-- до завершения передачи,
-- поэтому снимаю его по приходу следующего частотного сигнала
tr_enable_s <= false;
end if;
if(rclk_v = '1') then
disp_refresh_s <= false;
end if;
if(tr_ready_s and disp_refresh_s) then
rclk_v := '1';
else
rclk_v := '0';
end if;
rclk <= rclk_v;
end if;
end process tr_proc;
end display_arch;
```
Это устройство управляет другими устройствами. Здесь, перед объявлением вспомогательных сигналов, я объявляю компоненты которые буду использовать. В самой архитектуре (после ключевого слова begin) я создаю экземпляры устройств:
* sec\_delay — экземпляр компонента delay. Исходящий сигнал направляется в сигнал sec\_s.
* transfer\_delay — экземпляр компонента delay. Исходящий сигнал направляется в сигнал transfer\_clk.
* bcd\_counter1 — экземпляр компонента bcd\_counter. Исходящий сигнал направляется в сигнал bcd\_counter\_s.
* bcd\_to\_7seg1 — экземпляр компонента bcd\_to\_7seg. Исходящий сигнал направляется в сигнал disp\_out\_s.
* transmitter1 — экземпляр компонента transmitter. Исходящие сигналы направляются в сигналы sclk, dio, tr\_ready\_s.
После экземпляров компонентов объявляется процесс. Этот процесс решает несколько задач:
1. **Если передатчик не занят, то процесс инициализирует начало передачи данных**
```
if(tr_ready_s) then
if(not (prev_disp = disp_out_s)) then
prev_disp := disp_out_s;
-- Помещаем передаваемые данные в
-- шину данных передатчика
tr_data_s <= disp_out_s;
-- Запускаем передачу данных
tr_enable_s <= true;
end if;
else
...
```
2. Если передатчик занят (tr\_ready\_s = false), то процесс устанавливает значение сигнала disp\_refresh\_s <= true (этот сигнал обозначает, что по завершении передачи нужно обновить данные на дисплее). Также устанавливается значение сигнала tr\_enable\_s <= false, если этого не сделать до завершения передачи, то загруженные в передатчик данные будут переданы повторно
3. **Устанавливает и сбрасывает сигнал rclk после завершения передачи данных**
```
if(rclk_v = '1') then
disp_refresh_s <= false;
end if;
if(tr_ready_s and disp_refresh_s) then
rclk_v := '1';
else
rclk_v := '0';
end if;
rclk <= rclk_v;
```
### Временная диаграмма
**Вот как выглядит временная диаграмма передачи числа 1 на первую позицию дисплея**
Сначала передаются данные “10011111“. Затем передается позиция числа на дисплее “00010000“ (этот параметр приходит в передатчик, как константа X”10”). В обоих случаях первым передается крайний правый бит (lsb).
Весь код можно посмотреть на [github](https://github.com/LLDevLab/FPGA_7seg_display.git). Файлы с припиской \*\_tb.vhd — это отладочные файлы для соответствующих компонентов (например transmitter\_tb.vhd — отладочный файл для передатчика). Их я на всякий случай тоже залил на github. Данный код был загружен и работал на реальной плате. Кому интересно, иллюстрацию работы кода можно посмотреть вот [тут](https://youtu.be/QdgdvQHXAwQ) (начиная с 15:30). Спасибо за внимание. | https://habr.com/ru/post/447454/ | null | ru | null |
# Красивые трейсбеки в Python
Как часто вам присылают подобные отчеты об ошибке?
```
Traceback (most recent call last):
...
File "...", line ..., in ...
process(lst[index])
IndexError: list index out of range
```
*Ох, если бы только узнать значение lst и index на тот момент...*
**python-catcher — автоматическая генерация HTML-трейсбеков с локальными переменными и исходниками, + загрузка в интернет** — пользуйтесь на здоровье.
Пример самого настоящего отчета: [ajenti.org/catcher/view/10](http://ajenti.org/catcher/view/10)
Пример использования:
```
import catcher
try:
launch_important_stuff()
except Exception, e:
report = catcher.collect(e)
html = catcher.formatters.HTMLFormatter().format(report, maxdepth=4)
url = catcher.uploaders.AjentiOrgUploader().upload(html)
print 'Application has crashed. Please submit this link along with the bug report:'
print url
```
[PyPI](https://pypi.python.org/pypi/python-catcher), [Github](https://github.com/Eugeny/catcher), свежие deb [здесь](http://docs.ajenti.org/man/install/general.html).
Больше и добавить нечего :) | https://habr.com/ru/post/188400/ | null | ru | null |
# Беги, PHPUnit, беги: как я оптимизировал время выполнения тестов
С самого начала работы над одним из web-проектов мы стремились к высокому уровню покрытия кода тестами, и на начальном этапе разработки я не задумывался об оптимизациях скорости их выполнения. Как результат, с ростом проекта, всё большим покрытием его тестами и ростом команды время выполнения тестов выросло с нескольких секунд до десятков минут. А наличие быстрых тестов может быть также важно как и производительность всего приложения.
Как я с этим боролся и что получилось в итоге?
Что было до оптимизаций
-----------------------
Приложение разрабатывается на PHP 7.2 и Symfony 4.2. Для написания тестов пользуемся PHPUnit. Большая часть тестов представляет собой интеграционные тесты для REST API.
Запускаем тесты:
```
> bin/phpunit
...
Time: 20.17 minutes, Memory: 400.25 MB
OK (1494 tests, 5536 assertions)
```
На все тесты ушло около 20 минут. Это приводило к следующим проблемам:
* автоматический процесс CI стал блокироваться на время выполнения тестов, приводя к исчерпанию свободных CI runners,
* разработчики были вынуждены выстраиваться в виртуальную очередь, ожидая завершения CI pipelines,
* на время выполнения всех тестов локально можно было пойти заварить чашечку кофе и полистать новости, что только подогревало желание просто игнорировать их запуск.
Начинаем искать основные узкие места и экспериментировать!
DAMADoctrineTestBundle
----------------------
Эта [библиотека](https://github.com/dmaicher/doctrine-test-bundle) позволяет изолировать работу с базой данных для каждого теста, в результате чего нам нужно подготовить тестовые данные и схему БД только один раз перед запуском тестов.
С помощью специального PHPUnit Listener перед запуском каждого теста открывается новая транзакция и откатывается после завершения теста. Также библиотека предоставляет средство кэширования метаданных и запросов для всех `EntityManager`. Пример конфигурации:
```
dama_doctrine_test:
enable_static_connection: true
enable_static_meta_data_cache: true
enable_static_query_cache: true
```
Мы уже использовали эту библиотеку, но если у вас её нет, то обязательно попробуйте.
Рекомендуемая конфигурация Symfony
----------------------------------
У фреймворка Symfony прекрасная документация, в которой в частности есть [раздел про производительность](https://symfony.com/doc/current/performance.html). Советую ознакомиться с ним и проверить вашу конфигурацию.
Если вы уже используете PHP 7.4 и последние версии Symfony, то обязательно попробуйте предварительную загрузку классов.
У нас уже были выставлены все рекомендуемые параметры OPcache и PHP, поэтому возникла идея обновиться до PHP версии 7.4 и Symfony 4.4, проверив будет ли прирост производительности в тестах, тем более это не должно было занять много времени.
PHP 7.4 + Symfony 4.4
---------------------
Заодно обновим PHPUnit до текущей последней версии — 9.1.5.
Перед обновлением ознакомимся с документацией по переходу на новые минорные версии Symfony:
* [Общие рекомендации](https://symfony.com/doc/current/setup/upgrade_minor.html)
* [4.2 -> 4.3](https://github.com/symfony/symfony/blob/4.3/UPGRADE-4.3.md)
* [4.3 -> 4.4](https://github.com/symfony/symfony/blob/4.4/UPGRADE-4.4.md)
Обновляем зависимости, исправляем проблемные места и начинаем настраивать OPcache и предварительную загрузку классов.
Вносим изменения в php.ini для dev, test и prod окружений:
```
;php.ini
opcache.preload=/var/www/web/var/cache/dev/srcApp_KernelDevDebugContainer.preload.php
```
И `services.yaml`:
```
parameters:
container.dumper.inline_factories: true
container.dumper.inline_class_loader: true
```
Запускаем наши тесты и...
```
Time: 17:15.483, Memory: 451.00 MB
OK (1494 tests, 5536 assertions)
```
Ускорились на 3 минуты, но нам этого мало.
XDebug
------
Для сборки и запуска приложения используется Docker с multistage сборкой. Для локальной отладки кода в dev сборку подключается PHP-расширение XDebug, которое также влияет на скорость выполнения кода. Во время прогона всех тестов отладка кода нам не нужна, поэтому для этого случая отключаем расширение с помощью небольшого скрипта (спасибо [stackoverlow](https://stackoverflow.com/a/36723363/4295626)):
```
#!/bin/sh
php_no_xdebug() {
temporaryPath="$(mktemp -t php.XXXXXX).ini"
# Using awk to ensure that files ending without newlines do not lead to configuration error
php -i | grep "\.ini" | grep -o -e '\(/[a-z0-9._-]\+\)\+\.ini' | grep -v xdebug | xargs awk 'FNR==1{print ""}1' | grep -v xdebug >"$temporaryPath"
php -n -c "$temporaryPath" "$@"
rm -f "$temporaryPath"
}
php_no_xdebug $@
```
Проверяем:
```
> php-no-xdebug.sh bin/phpunit
Time: 14:11.561, Memory: 445.00 MB
OK (1494 tests, 5536 assertions)
```
Отлично! Выиграли дополнительные 3 минуты.
Алгоритм хэширования паролей
----------------------------
Я уже упоминал, что большая часть тестов — интеграционные, которые начинаются с создания клиента:
```
protected function createAuthenticatedClient($username, $password): HttpKernelBrowser
{
$client = static::createClient();
// Отправляем HTTP запрос на аутентификацию, получаем JWT токен и устанавливаем его для последующих запросов.
...
$client->setServerParameter('HTTP_Authorization', sprintf('Bearer %s', $data['token']));
return $client;
}
```
Посмотрим конфигурацию Symfony:
```
# config/packages/security.yaml
security:
encoders:
App\Entity\User: bcrypt
```
Encoder описывает каким образом будут проверяться и храниться пользовательские пароли.
А теперь получим полную актуальную конфигурацию с учётом стандартных параметров:
```
> php bin/console debug:config security
Current configuration for extension with alias "security"
=========================================================
security:
encoders:
App\Entity\User:
algorithm: bcrypt
migrate_from: { }
hash_algorithm: sha512
key_length: 40
ignore_case: false
encode_as_base64: true
iterations: 5000
cost: null
memory_cost: null
time_cost: null
threads: null
```
Для тестов нам абсолютно не нужна такая криптоустойчивость, попробуем использовать md5 без каких-либо итераций:
```
# config/packages/test/security.yaml
security:
encoders:
App\Entity\User:
algorithm: md5
encode_as_base64: false
iterations: 0
```
Проверяем:
```
Time: 02:49.090, Memory: 439.00 MB
OK (1494 tests, 5536 assertions)
```
Hoooraaay! Давайте посмотрим сможем ли мы побежать еще быстрее...
Настраиваем логирование
-----------------------
В Doctrine ORM есть возможность логировать каждый выполняемый SQL запрос:
```
doctrine:
dbal:
logging: '%kernel.debug%'
```
Явно отключаем логирование для тестовой среды и изменяем уровень для остальных логов с debug на critical:
```
# config/packages/test/doctrine.yaml
doctrine:
dbal:
logging: false
# config/packages/test/monolog.yaml
monolog:
handlers:
docker:
type: stream
path: "php://stderr"
level: critical
channels: ["!event"]
```
Как результат, получаем ускорение в 20-30 секунд:
```
Time: 02:21.818, Memory: 445.00 MB
OK (1494 tests, 5537 assertions)
```
ParaTest
--------
Все тесты запускаются последовательно один за другим и я решил посмотреть возможность запускать тесты параллельно. Для PHPUnit есть библиотека [ParaTest](https://github.com/paratestphp/paratest), которая как раз делает то, что мне нужно. Устанавливаем через composer, дополнительной конфигурации не требуется, поэтому запускаем и смотрим:
```
> php-no-xdebug.sh vendor/bin/paratest
Running phpunit in 8 processes with /var/www/web/vendor/phpunit/phpunit/phpunit
Configuration read from /var/www/web/phpunit.xml.dist
..............................
Time: 02:03.122, Memory: 12.00 MB
OK (1494 tests, 5537 assertions)
```
К сожалению, большого прироста скорости здесь не получили. Возможно, это связано с самими тестами и, если у вас много unit-тестов, то результаты будут лучше.
Заключение
----------
Используя все эти оптимизации, играясь с настройками и библиотеками я достиг оптимального времени выполнения всех тестов, снизив его с 20 до 2 минут.
Если у вас есть советы как ещё можно ускориться, буду рад их услышать и опробовать. | https://habr.com/ru/post/505736/ | null | ru | null |
# Самодокументируемый код – это (как правило) чушь
Всем привет!
Предваряя сегодняшнюю переводную публикацию, сразу отметим, что этот текст задуман как follow-up недавнему дискуссионному материалу "[Прекратите усердствовать с комментариями в коде](https://habr.com/ru/company/piter/blog/458990/)". Нас настолько впечатлила развернувшаяся там дискуссия и 189 комментариев по состоянию на 19.07.2019, что мы решили дать здесь слово и другому автору с портала Medium (Кристоферу Лейну), который практически по всем принципиальным вопросам полемизирует с тезисами Брайана Норлендера, автора первой статьи. Отметим, что в оригинале данная статья вышла на месяц позже предыдущей (16 мая и 16 июня), но собрала практически вдвое меньше аплодисментов (706 против 1,5K на момент публикации перевода). Посмотрим, что будет на Хабре…
Снимок взят с сайта [rawpixels.com](https://www.pexels.com/@rawpixel?utm_content=attributionCopyText&utm_medium=referral&utm_source=pexels&source=post_page---------------------------) от автора [Pexels](https://www.pexels.com/photo/person-holding-pen-point-on-blueprint-1537008/?utm_content=attributionCopyText&utm_medium=referral&utm_source=pexels&source=post_page---------------------------)
Я внимательно прочел отличную [статью Синди Чеунг](https://medium.com/@cindyscheung/pleeeeaase-explain-your-code-e1fdfdf19566) о технической документации и о том, почему разработчики должны лучше объяснять собственный код – и должен сказать, что полностью с ней согласен.
Я уже чертовски долго подвизаюсь в этом вашем IT, и мой опыт подсказывает, что есть в нашем деле такой самообман, которому разработчики и инженеры просто не в силах сопротивляться.
> Мой код самодокументирующийся — Заблуждающийся разраб
В теории код хорошего инженера должен быть настолько ясен и удобочитаем, что ни в какой документации просто не нуждается.
Знаете, это чушь… как правило.
### Почему «самодокументирующийся код» — это чушь?
Допустим, вы пишете код так же круто, как [Хемингуэй писал прозу](https://habr.com/ru/company/piter/blog/275245/). Возможно, ваш код супер-пупер чистый и понятный (другому разработчику). В конце концов, этот код написан технарем для технаря, и, независимо от того, каким чистым и лаконичным может казаться ваш код, он все равно не предназначен для чтения не-программистами, которые могли бы проворчать: «что, черт возьми, все это значит?!»
Почему же я считаю, что самодокументирующийся код – это полная ерунда? Позвольте изложить в деталях.
**Причина 1: В программировании полно всяких приемчиков, которые не самодокументируются**
Просто потому, что большинство людей, и разработчики в том числе – не машины. Да, скорее всего я продерусь через ваш код, верно пойму названия ваших методов и классов, даже пойму, что именно вы делаете в каждом методе.
Но код пишут ДЛЯ машин. Они куда лучше нас разбираются, что с ним делать, и именно для того, чтобы описать им это, у нас есть языки программирования. С людьми же нужно общаться на более человеческом языке, чтобы человек смог понять, что делает ваш софт.
Между «читаю код и вижу, что в нем происходит» и документацией – очень большая разница. В коде можно со всеми подробностями прописать, что в нем делается, но можно ли в таком случае называть его «самодокументирующимся»? Думаю, каждому понятно, что нельзя.
Рассмотрим следующий простой блоб на C#. Я считываю файл, получаю его содержимое, а затем получаю кодировку файла при помощи StreamReader.
```
var fileContents = “”;
Encoding fileEncoding; using (var reader = new StreamReader(filePath, Encoding.Default, true))
{
reader.Peek();
fileEncoding = reader.CurrentEncoding;
fileContents = reader.ReadToEnd();
}
```
Если абстрагироваться от возможных неясностей со StreamReader, в остальном этот код достаточно прост, верно? Тогда… помилуйте, а что делается в этой строке?
```
reader.Peek();
```
Оказывается, считыватель должен совершить это действие, чтобы получить кодировку файла. Скажите, где тут самодокументация? Но достаточно потратить какие-нибудь 10 секунд, чтобы код стал гораздо понятнее.
```
reader.Peek(); //Вот так нужно заглянуть в файл, чтобы получить его кодировку.
```
Это всего лишь один пример, причем, чертовски простой. По мере того, как ваш код усложняется, такие мелкие детали начинают всплывать повсюду и постепенно захламляют некогда чистый код. Человеку, который будет его читать, становится все сложнее улавливать, что в коде происходит.
**Причина 2: Сложность по сути своей не самодокументируется**
Если вам доводилось писать файлы BASH или BAT, то вы знаете, что действия, изложенные в таком файле, выполняются последовательно. Одна задача за другой. Файл напоминает коротенькую историю, которая читается от первой до последней строчки.
Однако, если вы пишете программу, и в особенности – веб-приложение, такой последовательной истории там не будет, если не считать кода для начальной загрузки и конфигурации всех веб-сервисов.
Сами классы, образующие современное веб-приложение, не выполняются последовательно. В сущности, они представляют собой совокупность веб- или API-контроллеров, вызываемых именно в процессе взаимодействия клиента с веб-приложением. Каждый веб- или API-контроллер может предусматривать потоки выполнения, при которых ответвляются новые процессы, отсылаются сообщения другим сервисам, ожидаются отклики, чтобы по их результатам сработали веб-хуки у слушателей. Ничто это и близко невозможно изложить в «сюжетном» формате. Из всего вашего «самодокументирующегося кода» новичок или не-программист выудит только «кажется, я понимаю, что тут происходит». Опять же, едва ли кто-то решится доверять подобной «документации».
Чем сложнее ваше приложение, тем выше вероятность, что его классы, методы и весь каркас не будут работать в последовательном режиме. Полагая, что любой, кто столкнется с таким приложением, легко поймет из кода, что в нем происходит, вы вступаете на все более скользкую дорожку.
**Причина 3: Синтаксис языков программирования в принципе не назовешь удобочитаемым**
Просто взгляните на эту функцию jquery, вызывающую конечную точку API.
```
var myURL="https://some.url/path?access_token=my_token";
$.ajax({
url: myURL+"&callback=?",
data: "message="+someOtherData,
type: 'POST',
success: function (resp) {
alert(resp);
},
error: function(e) {
alert('Error: '+e);
}
});
```
Уф…
Нет, я не хочу сказать, что здесь что-то не так с синтаксисом. Для вызова jquery здесь все вполне приемлемо. Но я подчеркиваю, что, если взглянуть на это глазами программиста-новичка или не-программиста, то этот листинг вполне может оказаться ему не более понятен, чем байт-код. Смысла в нем будет не больше.
Синтаксически языки программирования устроены так, чтобы в них можно было активно использовать ограничения, задаваемые самим языком, а также полезные шорткаты, помогающие держать код компактным и с легкостью менять его по мере необходимости. Язык программирования не задумывается как однозначно надежное средство коммуникации, в котором разберется каждый. Он рассчитан на специалистов, хорошо знающих сам язык, его синтаксис и шорткаты.
Для всех остальных язык программирования непонятен.
**Что же делать?**
Существуют некоторые приемы, пользуясь которыми, вы поможете неспециалистам разобраться в вашем коде.
### Этап 1: Попробуйте написать документацию
Кощунственно звучит, верно? Написать документацию?! Ничего смешнее вы не могли придумать!
Серьезно, никто и не требует от вас написать «Войну и мир». Но постарайтесь описать в технической документации основные действия, валидацию и обработку ошибок – простым последовательным стилем.
* Клиент вызывает конечную точку API `/someurl/object/{id}`
* Контроллер API использует `{id}` (типа `int`), чтобы найти искомый объект в базе данных.
* Если объект возвращает `null`, то контроллер API выдает клиенту HTTP-отклик 404 (файл не найден). API-контроллер логирует это в качестве предупреждения.
* Если возвращенный объект — `NOT null`, то контроллер API преобразует этот объект в формат JSON и возвращает его вызывающей стороне с HTTP-откликом 200 (OK).
Едва ли это сложно сделать, но, написав такую документацию, вы кому-то облегчите жизнь. Если вам ближе боле эгоистичная мотивация, задумайтесь: если к вам то и дело будут обращаться за помощью и объяснениями, то вы сможете просто указать им на документацию, а не растолковывать раз за разом одно и то же.
### Этап 2: Нарисуйте схемы
Если написать простую документацию для вас все-таки затруднительно, то, как минимум, попробуйте начертить самые необходимые схемы, так как они зачастую служат тем самым «клеем», который помогает человеку со стороны соотнести ваш код с тем, что в нем происходит.
Посмотрите сайт [websequencediagrams.com](https://www.websequencediagrams.com/?source=post_page---------------------------), где в простом текстовом формат можно описывать отличные диаграммы последовательностей – и затем их создавать.
*Текст*
```
title Service one to service two
Service two requester -> Service two http client: Get Contract
Service two http client -> Service one REST API: GET /api/contracts/{123}
Service one REST API -> Service one app logic: get Contract with id 123
Service one app logic -> Service one REST API: Contract
Service one REST API -> Service one REST API: Serialise to JSON / XML / etc.
Service one REST API -> Service two http client: Serialised data
Service two http client -> Service two http client : Deserialise to Contract
Service two http client -> Service two requester: Contract
```
Диаграмма, которая из него получается
Красиво!
Избитая фраза о том, что одна картинка стоит тысячи слов – тем не менее, верна. Подобные диаграммы и блок-схемы помогут не-программисту разобраться в поведении вашего приложения, и для этого ему нужно будет всего лишь внимательно изучить картинку. Коллеги это оценят, а с вашей стороны это будет небольшая инвестиция в общее дело.
### Этап 3: Называйте ваши классы и действия на Едином Языке (Ubiquitous Language)
Как известно, [Единый Язык](https://habr.com/ru/post/232881/) – это концепция из DDD (предметно-ориентированного проектирования), где команде и пользователям требуется выработать язык, который описывал бы все классы и их взаимодействия. Такой язык понятен неспециалисту, поэтому клиенты, тестировщики, инструкторы и представители бизнеса смогут на нем прочитать и понять, что именно делает наша программа и каким образом решает проблемы пользователя в данной предметной области.
После того, как Единый Язык согласован, вы должны добиться, чтобы все ваши классы, их методы, события и все остальное именовались настолько близко к Единому Языку, насколько это возможно.
```
///
/// Клиент сам отвечает за собственный вход в систему/выход из нее, а также за извлечение информации из своего профиля и управление ею
/// settings
///
public interface ICustomer
{
Task Login(string username, EncryptedString password);
Task Logout();
Task GetMyProfile();
Task SaveMyProfile(CustomerProfileInformation);
Task GetMySettings();
Task SaveMySettings(CustomerSettings);
```
Хотя, это просто фрагмент кода, над ним простым и общепонятным языком написано, что здесь происходит.
### Этап 4: Просто напишите комментарии
Если все вышеперечисленное кажется вам слишком, слишком обременительным – просто снабдите ваш код информативными комментариями. Возможно, прямо сейчас они вам не понадобятся (вы-то сейчас с головой погружены в код, вам и так все ясно), но в будущем они могут вам весьма пригодиться.
Всего нескольких правильно расставленных строк с комментариями, комментария к классу или методу, будет достаточно, чтобы код стал намного понятнее. Я не призываю вас комментировать каждую строку (от этого код только усложнится). Просто сопроводите комментариями самые сложные участки кода, чтобы тот, кто будет через него пробираться, понимал, куда этот код его приведет.
Надеюсь, эти советы будут вам полезны | https://habr.com/ru/post/460725/ | null | ru | null |
# Гениальные комменты в коде
Блуждая в поиске работы, попал на [сайт Клинической больницы №122 им. Л.Г. Соколова](http://med122.com). После блуждания по сайту, что то потонуло код страницы посмотреть (ибо на сайте я не чего не нашел) и увидел чудо.
`...
...
...` | https://habr.com/ru/post/36698/ | null | ru | null |
# Реактивное программирование
Как известно, функциональный подход к программированию имеет свою специфику: в нём мы преобразовываем данные, а не меняем их. Но это накладывает свои ограничения, например при создании программ активно взаимодействующих с пользователем. В императивном языке намного проще реализовать такое поведение, ведь мы можем реагировать на какие либо события «в реальном времени», в то время как в чистых функциональных языках нам придётся откладывать общение с системой до самого конца. Однако относительно недавно стала развиваться новая парадигма программирования, решающая эту проблему. И имя ей — **Functional Reactive Programming** (FRP). В этой статье я попытаюсь показать основы FRP на примере написания змейки на Haskell с использованием библиотеки reactive-banana.
*Далее в этой статье предполагается, что читатель знаком с функторами. Если это не так, я настоятельно рекомендую ознакомиться с ними, так как от этого зависит понимание всей статьи.*
#### Основные идеи
В FRP появляются два новых типа данных: **Event** и **Behavior**. Оба этих типа являются функторами, и многие действия над ними будут производиться комбинаторами функторов. Опишем эти типы.
##### Event
Event представляет собой поток событий, имеющих точную временную отметку. Его можно представить себе как (только представить, потому что в реальности всё не так просто):
```
type Event a = [(Time, a)]
```
Например, Event String может представлять собой поток событий о входящих в чат пользователях.
Как было уже сказано, Event относится к классу функторов, значит мы можем производить кое-какие действия с ним.
Например:
```
("Wellcome, " ++) <$> eusers
```
создаст поток приветствий пользователей вошедших в чат.
##### Behavior
Behavior обозначает значение, меняющееся со временем.
```
type Behavior a = Time -> a
```
Этот тип хорошо подходит для игровых объектов, змейка в нашей игре как раз будет Behavior.
Мы можем комбинировать Behavior и Event с помощью функции apply:
```
apply :: Behavior t (a -> b) -> Event t a -> Event t b
apply bf ex = [(time, bf time x) | (time, x) <- ex]
```
Как видно из этого определения, apply применяет функцию внутри Behavior на Event-ы, с учётом времени.
Перейдём непосредственно к змейке.
#### Механика игры
Пока забудем о реактивном программировании и займёмся механикой игры. Для начала типы:
```
module Snake where
type Segment = (Int, Int)
type Pos = (Int, Int)
type Snake = [Segment]
```
Один сегмент змейки — это пара координат, а сама змейка есть цепочка этих сегментов. Тип Pos нужен только для удобства.
```
startingSnake :: Snake
startingSnake = [(10, 0), (11, 0), (12, 0)]
wdth = 64
hdth = 48
```
Создадим начальную позицию змейки и константы для размеров игрового поля.
```
moveTo :: Pos -> Snake -> Snake
moveTo h s = if h /= head s then h : init s else s
keepMoving :: Snake -> Snake
keepMoving s = let (x, y) = head s
(x', y') = s !! 1
in moveTo (2*x - x', 2*y - y') s
ifDied :: Snake -> Bool
ifDied s@((x, y):_) = x<0 || x>=wdth || y<0 || y>=hdth || head s `elem` tail s
```
Функция moveTo сдвигает змейку в указанное место, keepMoving продолжает движение, а ifDied проверяет не умерла ли змейка от самоедства или столкновения с границами.
На этом механика заканчивается, теперь предстоит наиболее сложная часть — логика поведения.
#### Логика
Подключим необходимые модули и опишем некоторые константы:
```
{-# LANGUAGE ScopedTypeVariables #-}
import Control.Monad (when)
import System.IO
import System.Random
import Graphics.UI.SDL as S hiding (flip)
import Graphics.Rendering.OpenGL hiding (Rect, get)
import Reactive.Banana as R
import Data.Word (Word32)
import Snake
screenWidth = wdth*10
screenHeight = hdth*10
screenBpp = 32
ticks = 1000 `div` 20
```
screenWidth, screenHeight — ширина и высота экрана соответственно, ticks — количество миллисекунд на которые кадр задержится на экране.
Теперь определимся с входами. Из внешнего мира к нам будут приходить только два события: нажатие клавиши и сигнал часов. Значит нам нужно только два «слота» для событий и они создаются функцией newAddHandler:
```
main :: IO ()
main = withInit [InitEverything] $ do
initScreen
sources <- (,) <$> newAddHandler <*> newAddHandler
network <- compile $ setupNetwork sources
actuate network
eventLoop sources network
```
В setupNetwork будет строиться «сеть» из Event-ов и Behavior-ов, compile скомпилирует NetworkDescription в EventNetwork, а actuate запустит её. События будут посылаться в сеть из функции eventLoop, словно сигналы в мозг из рецепторов.
```
eventLoop :: (EventSource SDLKey, EventSource Word32) -> EventNetwork -> IO ()
eventLoop (essdl, estick) network = loop 0 Nothing
where
loop lt k = do
s <- pollEvent
t <- getTicks
case s of
(KeyDown (Keysym key _ _)) -> loop t (Just key)
NoEvent -> do maybe (return ()) (fire essdl) k
fire estick t
loop t Nothing
_ -> when (s /= Quit) (loop t k)
```
Это и есть «рецептор» нашей программы. fire essdl — запускает событие essdl, содержащее в себе название клавиши, если её вообще нажали. estick запускается вне зависимости от поведения пользователя и несёт в себе время с начала запуска программы.
Вот, кстати, как происходит переход от EventSource, который возвращает newAddHandler, к AddHandler:
```
type EventSource a = (AddHandler a, a -> IO ())
addHandler :: EventSource a -> AddHandler a
addHandler = fst
fire :: EventSource a -> a -> IO ()
fire = snd
```
Теперь начнём самую ответственную часть: описание сети событий.
```
setupNetwork :: forall t. (EventSource SDLKey, EventSource Word32) -> NetworkDescription t ()
setupNetwork (essdl, estick) = do
-- Keypress and tick events
esdl <- fromAddHandler (addHandler essdl)
etick <- fromAddHandler (addHandler estick)
```
Сначала получим Event-ы из тех событий таймера и клавиатуры, которые мы запустили в eventLoop.
```
let ekey = filterE (flip elem [SDLK_DOWN, SDLK_UP, SDLK_LEFT, SDLK_RIGHT]) esdl
moveSnake :: SDLKey -> Snake -> Snake
moveSnake k s = case k of
SDLK_UP -> moveTo (x, y-1) s
SDLK_DOWN -> moveTo (x, y+1) s
SDLK_LEFT -> moveTo (x-1, y) s
SDLK_RIGHT -> moveTo (x+1, y) s
where (x, y) = head s
```
Теперь создадим событие, означающее нажатие стрелочки — другие клавиши нам не нужны. Как Вы наверное уже догадались, filterE отсеивает события не удовлетворяющие предикату. moveSnake просто двигает змейку в зависимости от нажатой клавиши.
```
brandom <- fromPoll randomFruits
-- Snake
let bsnake :: Behavior t Snake
bsnake = accumB startingSnake $
(const startingSnake <$ edie) `union`
(moveSnake <$> ekey) `union`
(keepMoving <$ etick) `union` ((\s -> s ++ [last s]) <$ egot)
edie = filterApply ((\s _ -> ifDied s) <$> bsnake) etick
```
fromPoll реализовывает ещё один способ взаимодействия с реальным миром, но он отличается от того, что мы использовали до этого. Во-первых, мы получаем Behavior, а не Event. И во-вторых действие в fromPoll не должно быть затратным. Например, хорошо использовать fromPoll вкупе с переменными.
Далее, мы описываем змейку с помощью accumB (отметим, что тип змейки не просто Behavior Snake, а Behavior t Snake. Это имеет свой глубокий смысл, которой знать нам не обязательно).
accumB «собирает» Behavior из Event-ов и начального значения:
```
accumB :: a -> Event t (a -> a) -> Behavior t a
```
То есть, грубо говоря, когда какое-либо событие произойдёт, функция внутри него будет применена к текущему значению.
Например:
```
accumB "x" [(time1,(++"y")),(time2,(++"z"))]
```
создаст Behavior, который в момент времени time1 будет держать в себе «xy», а в time2 — «xyz».
Ещё одна неизвестная нам функция — union. Она объединяет события в одно (если два события произошли одновременно, union отдаёт приоритет тому, что из первого аргумента).
Теперь мы можем понять как работает bsnake. Сначала змейка равна startingSnake, а потом с ней происходит ряд изменений:
* Она возвращается в начало, если умерла (событие edie)
* Поворачивает, когда нажата стрелочка
* Продолжает двигаться по сигналу
* И растёт, если съела фрукт (событие egot)
Событие edie запускается когда змейка умерла, и достигается это использованием filterApply:
```
filterApply :: Behavior t (a -> Bool) -> Event t a -> Event t a
```
Эта функция отбрасывает события, не удовлетворяющие предикату внутри Behavior. Как следует из названия, это что-то вроде filter + apply.
Заметьте, как часто мы используем комбинаторы функторов, чтобы превратить что-либо в функцию.
Теперь перейдём к фруктам:
```
-- Fruits
bfruit :: Behavior t Pos
bfruit = stepper (hdth `div` 2, wdth `div` 2) (brandom <@ egot)
egot = filterApply ((\f s r _ -> elem f s && notElem r s) <$> bfruit <*> bsnake <*> brandom) etick
```
Новый фрукт с координатами в brandom появляется как только змейка собрала текущий. Комбинатор <@ «переносит» содержимое одного Behavior в Event, то есть в данном случае, содержимое события egot будет заменено случайной координатой из brandom. Новая для нас функция stepper создаёт Behavior из Event-ов и начального значения, и единственное её отличие от accumB в том, что новое событие Behavior не будет зависеть от предыдущего.
Событие egot запускается в тот сигнал таймера, когда змейка собрала фрукт и новый фрукт не попадает в её тело.
```
-- Counter
ecount = accumE 0 $ ((+1) <$ egot) `union` ((const 0) <$ edie)
```
ecount — это событие увеличения набранных очков. Как несложно догадаться, accumE создаёт Event, а не Behavior. Счётчик будет увеличен на единицу при событии egot, и обнулён при edie.
```
let edraw = apply ((,,) <$> bsnake <*> bfruit) etick
```
edraw запускается в каждый сигнал таймера, и содержит текущее положение змейки и фрукта.
Теперь дело осталось за малым: вывести изображение на экран.
```
reactimate $ fmap drawScreen edraw
reactimate $ fmap (flip setCaption [] . (++) "Snake. Points: " . show) ecount
```
Функция reactimate запускает IO действие из Event-а. drawScreen отрисовывает экран, а setCaption меняет имя окна.
На этом setupNetwork заканчивается, и нам остаётся только дописать недостающие функции.
Инициализация экрана:
```
initScreen = do
glSetAttribute glDoubleBuffer 1
screen <- setVideoMode screenWidth screenHeight screenBpp [OpenGL]
setCaption "Snake. Points: 0" []
clearColor $= Color4 0 0 0 0
matrixMode $= Projection
loadIdentity
ortho 0 (fromIntegral screenWidth) (fromIntegral screenHeight) 0 (-1) 1
matrixMode $= Modelview 0
loadIdentity
```
Генератор случайных позиций:
```
randomFruits :: IO Pos
randomFruits = (,) <$> (randomRIO (0, wdth-1)) <*> (randomRIO (0, hdth-1))
```
Ну, и наконец функции отрисовки:
```
showSquare :: (GLfloat, GLfloat, GLfloat, GLfloat) -> Pos -> IO ()
showSquare (r, g, b, a) (x, y) = do
-- Move to offset
translate $ Vector3 (fromIntegral x*10 :: GLfloat) (fromIntegral y*10) 0
-- Start quad
renderPrimitive Quads $ do
-- Set color
color $ Color4 r g b a
-- Draw square
vertex $ Vertex3 (0 :: GLfloat) 0 0
vertex $ Vertex3 (10 :: GLfloat) 0 0
vertex $ Vertex3 (10 :: GLfloat) 10 0
vertex $ Vertex3 (0 :: GLfloat) 10 0
loadIdentity
showFruit :: Pos -> IO ()
showFruit = showSquare (0, 1, 0, 1)
showSnake :: Snake -> IO ()
showSnake = mapM_ (showSquare (1, 1, 1, 1))
drawScreen (s, f, t) = do
clear [ColorBuffer]
showSnake s
showFruit f
glSwapBuffers
t' <- getTicks
when ((t'-t) < ticks) (delay $ ticks - t' + t)
```
Вот и всё. Для компиляции Вам понадобится: reactive-banana, opengl, sdl. Отсюда можно скачать исходные файлы программы: [minus.com/mZyZpD4Hx/1f](http://minus.com/mZyZpD4Hx/1f)
#### Заключение
На примере небольшой игры я попытался показать основные принципы работы с FRP: представление механики программы как сеть из Event-ов и Behavior-ов, разделение входных и выходных данных. Даже на такой простой программе можно увидеть преимущества FRP, например, нам не пришлось заводить тип для состояния игры, как мы бы сделали без использования этой парадигмы. Надеюсь, что эта статья поможет в изучении реактивного программирования и облегчит его понимание.
#### Ссылки
[hackage.haskell.org/package/reactive-banana](http://hackage.haskell.org/package/reactive-banana) — reactive-banana на hackage
[github.com/HeinrichApfelmus/reactive-banana](http://github.com/HeinrichApfelmus/reactive-banana) — репозиторий проекта на github. Имеются примеры. | https://habr.com/ru/post/140719/ | null | ru | null |
# Рецепты под Android: IoC со вкусом Gradle
Android-проекты бывают большими. Иногда действительно большими. Один из наших проектов — новостное приложение, которое разрабатывается одновременно под две альтернативные платформы: Android и FireOS, что от Amazon. Это позволяет расширить круг читателей новостей, ведь пользователи читалок Kindle Fire любят почитать:). Однако, это же накладывает обязательство считаться с особенностями каждой из платформ. Например, если в Android вы используете GCM для push-сообщений, то в FireOS вы должны использовать для этого Amazon AWS. Аналогично и для систем покупок внутри приложения: Google in-app billing vs. In-App Purchasing. Но большой размер проекта != большой размер приложения!
В этой статье мы покажем, как используем альтернативные билды для оптимизации приложения и поддерживаем их без вреда для процесса разработки.
Что готовим?
------------
Разрабатывая мультиплатформенное приложение, разработчик может иметь дело с кодом, который исполняется только на одной из платформ, но будучи запущенным на других будет лежать мертвым грузом. Помимо своего существования такой код наверняка привнесет в проект тем же грузом и все свои зависимости. Это уже само по себе не очень хорошо, а учитывая специфику разработки под Android: “проблему 65k”, best practice сделать загружаемый размер файла как можно меньше, с таким кодом уже обязательно нужно что-то сделать. А бесконечные проверки ifAndroid() или ifAmazon() хочется видеть чуть реже чем никогда.
Если вы опытный Android-разработчик, то наверняка уже сталкивались с такой опцией Android Gradle плагина как ProductFlavor.
***Flavor (англ.) — вкус, аромат***
Эта опция позволяет создавать альтернативные сборки одного и того же проекта, включая в билд файлы из разных директорий в зависимости от имени собираемого flavor-а. Зачастую ProductFlavor используют для разного рода “брендирования” приложения, подменяя ресурсы (картинки, тексты, ссылки). Другой частый случай – разделение приложения на demo- и полную версии, потому что имя собранного flavor’а автоматически попадает в поле класса BuildConfig.FLAVOR. Его значение позже можно проверить в runtime и не позволять выполнять какие-нибудь действия в demo-версии.
Разделять на flavor’ы можно не только ресурсы, но и код. Но нужно понимать, что код, используемый во flavor1, никогда не сможет взаимодействовать с кодом из flavor2. А код, лежащий в основном модуле всегда может видеть только из один flavor’ов в одно время. Всё это значит, к примеру, то, что вы не сможете написать в одном flavor’е набор utility-методов и воспользоваться ими в другом. Разделять код нужно с умом и очень аккуратно, максимально изолированно, так, что бы переключение альтернативных билдов проходило незаметно для основного модуля. Большую помощь в этом нам окажет паттерн Dependency Injection. Следуя ему, мы оставим в основном модуле только общие интерфейсы, а конкретные реализации и разложим по flavor’ам. Весь процесс рассмотрим на примере создания простого приложения для поиска репозиториев на GitHub.
Ингредиенты
-----------
Итак, нам потребуется:
1. Экран с полем ввода, кнопкой и списком результатов (1 шт.).
2. Класс для работы с Github Web API: его mock и настоящая реализации (итого 2 шт.).
3. Класс для кеширования результатов поиска: также настоящая и mock-реализации (итого 2 шт.).
4. Иконки, тексты, прогрессбары – по вкусу.
Мы будем придерживаться подхода разделения приложения на слои и сразу создадим 3 пакета: .view для представления, .models для моделей бизнеслогики и .data для классов-провайдеров контента. В пакете data нам еще понадобятся 2 пакета services и storages. В итоге вся структура должна выглядеть так:
Модельки нам хватит всего одной: “Repository”. Можно хранить в ней что захочется, а нам захотелось иметь в ней description, name и htmlUrl.
Теперь определимся с интерфейсом класса-сервиса, который будет искать репозитории AppService:
```
public interface AppService {
List searchRepositories(String query);
}
```
Сразу создадим и интерфейс класса, кэширующего результаты поиска RepositoryStorage:
```
public interface RepositoryStorage {
void saveRepositories(String query, List repositoryList);
List getRepositories(String query);
}
```
Мы будем создавать и хранить наши сервис и репозиторий внутри Application-класса:
```
public class App extends Application {
private AppService appService;
private RepositoryStorage repositoryStorage;
public AppService getAppService() {
return appService;
}
public RepositoryStorage getRepositoryStorage() {
return repositoryStorage;
}
}
```
Для подготовительного этапа осталось только создать сам экран и написать в нём получение и отображение результатов. В рамках демонстрационного приложения нам хватит и AsyncTask, чтобы выполнить фоновую работу, но вы всегда можете использовать свой любимый подход.
```
public class MainActivity extends AppCompatActivity {
@Bind(R.id.actionSearchView) Button actionSearchView;
@Bind(R.id.recyclerView) RecyclerView recyclerView;
@Bind(R.id.searchQueryView) EditText searchQueryView;
@Bind(R.id.progressView) View progressView;
private SearchResultsAdapter adapter;
private AppService appService;
private SearchTask searchTask;
private RepositoryStorage repositoryStorage;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ButterKnife.bind(this);
appService = ((App) getApplication()).getAppService();
repositoryStorage = ((App) getApplication()).getRepositoryStorage();
recyclerView.setLayoutManager(new LinearLayoutManager(this));
adapter = new SearchResultsAdapter();
recyclerView.setAdapter(adapter);
searchQueryView.setOnEditorActionListener(new TextView.OnEditorActionListener() {
@Override
public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
querySearch(searchQueryView.getText().toString());
return true;
}
});
}
@OnClick(R.id.actionSearchView)
void onActionSearchClicked() {
querySearch(searchQueryView.getText().toString());
}
private void querySearch(String query) {
if (TextUtils.isEmpty(query)) {
return;
}
if (searchTask != null) {
return;
}
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(searchQueryView.getWindowToken(), 0);
searchTask = new SearchTask();
searchTask.execute(query);
showProgress(true);
}
private void showData(List repositories) {
searchTask = null;
adapter.setData(repositories);
}
private void showProgress(boolean inProgress) {
progressView.setVisibility(inProgress ? View.VISIBLE : View.GONE);
actionSearchView.setEnabled(!inProgress);
}
private void showError(@Nullable ApiException exception) {
searchTask = null;
new AlertDialog.Builder(this)
.setMessage(exception != null ? exception.getMessage() : getString(R.string.unknown\_error))
.setTitle(R.string.error\_title)
.show();
}
private class SearchTask extends AsyncTask {
@Override
protected SearchTaskResult doInBackground(String... params) {
String q = params[0];
SearchTaskResult result = new SearchTaskResult();
try {
result.repositories = appService.searchRepositories(q);
repositoryStorage.saveRepositories(q, result.repositories);
} catch (ApiException e) {
result.exception = e;
//try to show some cached results
result.repositories = repositoryStorage.getRepositories(q);
}
return result;
}
@Override
protected void onPostExecute(SearchTaskResult result) {
if (result.exception != null) {
showError(result.exception);
}
showData(result.repositories);
showProgress(false);
}
}
private class SearchTaskResult {
List repositories;
ApiException exception;
}
}
```
Реализацию адаптера и вообще весь демо-проект можно посмотреть на [GitHub](https://github.com/EBTRussia/FlavorDI/).
На этом этапе наш проект уже может быть скомпилирован и запущен, но в этом нет никакого смысла, ведь мы не написали никакой реализации наших интерфейсов **AppService** и **RepositoryStorage**, так что самое время это сделать.
Добавляем вкус
--------------
Для начала нужно открыть **build.gradle** в основном модуле проекта и добавить в него наши flavor-ы. Назовем их, к примеру, **“mock”** и **“prod”**
```
productFlavors {
mock {}
prod {}
}
```
Добавлять их следует в секцию **android {...}** на том же уровне, что и **buildTypes {...}**.
Обязательно после этого нажмите на кнопку Sync Project With Gradle Files
Как только синхронизация будет завершена в окне Build Variants появятся новые flavor’ы
Сейчас выберем **mockDebug**.
Как только мы определили в проекте product flavor’ы, мы можем создавать для них одноименные директории на том же уровне, что и **main**. Из этих директорий и будут браться файлы во время сборки какого-то из flavor’ов.
Добавим папку **mock**, повторив в ней структуру пакетов **services** и **storages**:
Наконец, можно приступить к mock-реализации наших интерфейсов:
```
public class AppServiceImpl implements AppService {
@Override
public List searchRepositories(String query) {
if (query.equals("error")) {
throw new ApiException("Manual exception");
}
List results = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
results.add(new Repository("Mock description " + i, "Mock Repository " + i, "http://mock-repo-url"));
}
return results;
}
}
public class MockRepositoryStorage implements RepositoryStorage {
@Override
public void saveRepositories(String q, List repositoryList) {}
@Override
public List getRepositories(String q) {
return null;
}
}
```
Как видите, mock-сервис отдает нам 10 очень информативных моделек Repository, а mock-storage не делает вообще ничего. Инициализируем их в нашем App-классе:
```
@Override
public void onCreate() {
super.onCreate();
appService = new AppServiceImpl();
repositoryStorage = new MockRepositoryStorage();
}
```
Вот теперь то наше приложение готово быть собраным и запущеным. Вот теперь то мы можем протестировать и скорректировать работу UI. Вот теперь то мы… можем перейти к настоящей реализации наших интерфейсов.
В окне Build Variants выбирем вариант **prodDebug** и аналогично папке **mock** создадим папку **prod** с теми же пакетами и классами:
Мы прибегнем к помощи retrofit2 для сетевых запросов, он будет работать внутри нашей реализации AppServiceImpl:
```
public class AppServiceImpl implements AppService {
private final RetroGithubService service;
public AppServiceImpl() {
service = new Retrofit.Builder()
.baseUrl("https://api.github.com/")
.addConverterFactory(GsonConverterFactory.create())
.build().create(RetroGithubService.class);
}
@Override
public List searchRepositories(String query) {
Call call = service.searchRepositories(query);
try {
Response response = call.execute();
if (response.isSuccess()) {
ApiRepositorySearchEntity body = response.body();
List results = new ArrayList<>();
RepositoryMapper mapper = new RepositoryMapper();
for (RepositoryEntity entity : body.items) {
results.add(mapper.map(entity));
}
return results;
} else {
throw new ApiException(response.message());
}
} catch (Exception e) {
throw new ApiException(e);
}
}
}
public interface RetroGithubService {
@GET("search/repositories")
Call searchRepositories(@Query("q") String query);
}
```
Как можно заметить из кода, мы сделали еще несколько вспомогательных классов: **\*Entity** для парсинга ответов и **RepositoryMapper** для маппинга ответов в модель **Repository**.
***Обратите внимание, что все классы, связанные с реальной работой с сервером, такие как RepositoryEntity, RepositoryMapper, RetroGithubService, лежат в папке flavor’а “prod”. Это значит, что при сборке любого другого flavor’а, например mock, эти классы не попадут в результирующий apk-файл*.**
Внимательный читатель может заметить, что имя класса, реализующего реальную работу в сервером и имя его mock-аналога совпадают: **AppServiceImpl.java**. Это сделано специально и благодаря этому в основном коде проекта, который находится в папке main, при смене flavor’а ничего менять не надо. При выбранном flavor’е **mock** приложение видит класс AppServiceImpl, расположенный в папке mock и не видит класс, расположенный в папке **prod**. Аналогично и при выбранном flavor’е **prod**.
Столь же внимательный читатель может заметить, что класс реализации кеша мы назвали **MockRepositoryStorage** и, возможно, опечатались. Но нет, мы это сделали специально, чтобы показать один из вариантов как можно иметь разные имена классов-реализаций и даже разные конструкторы у каждого из них.
Трюк в сущности простой, мы сделаем одноименный для разных flavor’ов класс **RepositoryStorageBuilder**, который в зависимости от выбранного flavor’а отдаст нам нужную реализацию.
productFlavor = prod
```
public class RepositoryStorageBuilder {
private int maxSize;
public RepositoryStorageBuilder setMaxSize(int maxSize) {
this.maxSize = maxSize;
return this;
}
public RepositoryStorage build() {
return new InMemoryRepositoryStorage(maxSize);
}
}
```
productFlavor = mock
```
public class RepositoryStorageBuilder {
public RepositoryStorageBuilder setMaxSize(int maxSize) {
return this;
}
public RepositoryStorage build() {
return new MockRepositoryStorage();
}
}
```
И общая для обоих инициализация в Application:
```
@Override
public void onCreate() {
super.onCreate();
...
repositoryStorage = new RepositoryStorageBuilder()
.setMaxSize(5)
.build();
}
```
Теперь и “честную” реализацию работы можно считать выполненной, но если мы остановимся здесь, то не воспользуемся всей мощью ProductFlavor. Дело в том, что используемые в честной реализации поиска библиотеки, которые объявлены в секции **dependencies**, попадают в нашу сборку вне зависимости от выбранного flavor’а. К счастью, мы можем указать для каждой зависимости отдельно хотим ли мы её видеть в билде, дописав нужное имя flavor перед словом compile:
```
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
testCompile 'junit:junit:4.12'
prodCompile 'com.squareup.retrofit:retrofit:2.0.0-beta2'
prodCompile 'com.squareup.retrofit:converter-gson:2.0.0-beta2'
prodCompile 'com.google.code.gson:gson:2.5'
compile 'com.android.support:appcompat-v7:23.1.1'
compile 'com.android.support:recyclerview-v7:23.1.1'
compile 'com.jakewharton:butterknife:7.0.1'
}
```
Это не только сократит размер приложения, но и увеличит скорость его сборки, если зависимости по-настоящему большие.
Зачем?
------
Зачем использовать такой подход к Dependency Injection, если есть Dagger2, Roboguice, если можно написать это даже вручную?
Конечно, ключевое отличие этого подхода в том, что определение реализаций происходит еще на этапе компиляции и в билд попадают только те зависимости, которые действительно будут использоваться, со всеми вытекающими из этого последствиями. При этом для определения зависимостей в runtime можно продолжать использовать полюбившийся DI-фрэймворк.
True Story
----------
Как мы упоминали вначале, один из наших проектов мы разрабатываем сразу под две платформы: Android и Amazon FireOS. Эти операционные системы в основном похожи друг на друга (конечно мы все понимаем кто и на кого похож :)), но у каждой их них есть своя реализация push-уведомлений и свой механизм встроенных покупок. Для этих и других отличий платформ мы, как и в демо-проекте, оставили в основном модуле только общие интерфейсы: одинаковую регистрацию девайса на сервере push-сообщений, одинаковый процесс покупки подписки, а конкретные платформозависимые реализации храним в соответствующих flavor’ах.
Такой подход мы применяем уже давно и готовы поделиться своими впечатлениями от использования:
Плюсы
1. Исключение из результирующей сборки всего кода и его зависимостей, которые никогда не будут использоваться на какой-то из платформ.
2. Сокращение времени сборки проекта, т.к. собирается только выбранный (активный) flavor.
3. Все преимущества использования IoC, разделения интерфейса от реализации и никаких уродливых ветвлений в стиле if isAndroid()
Минусы
1. Android Studio видит одновременно только выбранный flavor и его директорию. Из-за этого не работает в полной мере автоматический рефакторинг, поиск по java-классам, поиск по ресурсам. Не работает в том плане, что не распространяется на неактивные flavor’ы. После рефакторинга иногда приходится переключаться между flavor’ами и повторять рефакторинг отдельно для каждого из них.
Как видите, мы считаем, что плюсов в 3 раза больше :) Всем приятного аппетита! | https://habr.com/ru/post/276927/ | null | ru | null |
# Прототип многопользовательской игры за 3 вечера?
И снова здравствуйте! Часто ли вам в голову приходили идеи проектов, которые буквально мешали вам спать? То чувство, когда ты волнуешься, переживаешь и не можешь нормально работать над другими вещами. У меня такое бывает несколько раз в год. Какие-то идеи пропадают сами собой после углубления в тему и понимания, что извлечь пользу из такого начинания будет крайне сложно. Но есть такие идеи, развивая которые даже пару часов, захватывают меня настолько, что аж кушать не могу. Этот пост о том, как мне удалось воплотить одну из таких идей за пару вечеров после работы и не помереть с голоду. А ведь сама идея изначально звучало довольно амбициозно — **PvP игра, в которой игроки соревнуются друг с другом, отвечая на вопросы.**
Последнее время я был занят собственным проектом "Конструктор чат-ботов для бизнеса Botlify", первую часть истории создания которого вы можете прочитать [по ссылке](https://habr.com/ru/post/487340/) на Хабре. Но я решил отвлечься и попробовать использовать чат-ботов не для бизнеса, а для игр. Честно признаюсь, лет с 14-15 я почти не играю в компьютерные и мобильные игры, но каждый раз получаю огромное удовольствие от их программирования.
### Идея
В очередной раз пролистывая ленту небезызвестной социальной сети я наткнулся на игру, над которой работал в одной компании в далеком 2013 году. Помимо того проекта, над которым работал я, у этой компании была еще одна игра, которая представляла собой адаптацию телевизионного шоу "100 к 1". К моему удивлению, я узнал, что телевизионная игра до сих пор существует, а вот в социальной сети она не работала. Я подумал, что было бы круто сделать адаптацию для мессенджеров, ведь сам формат игры по моим представлениям очень легко укладывался в концепцию чат-бота. Дополнительным преимуществом для меня в этом проекте был бесценный опыт работы с Telegram API, который мне очень пригодился при разработке моего конструктора чат-ботов.
Думаю, многим из вас знакомо: заводишь новый пет-проджект, начинаешь проектировать, продумывать архитектуру, пытаешься предусмотреть гипотетические ситуации(вероятность наступления которых, как правило не больше 1% — **YAGNI**), кучу разных фич без которых, как ошибочно кажется, нельзя выпускать релиз. Итогом, как правило становится то, что проект так и остается на задворках никогда не увидев свет. Я проходил это много раз и у меня без преувеличения есть добрая сотня незавершенных проектов. В этот раз я четко решил установить дедлайн и дал себе на разработку *максимум 3 вечера*. Разрабатывать прототип дольше — роскошь, ведь у меня все-таки есть и основной проект в котором есть прорва задач. Итак, я хочу сформулировать первое правило разработки прототипов: "Если вы нацелены на результат, а не планируете вечно наслаждаться процессом разработки, **определите дедлайн**". Даже если работаете в одиночку, как в этом случае было со мной. Вы всегда найдете что сделать лучше, надежнее, быстрее. Не ведитесь — это коварный мозг загоняет вас в ловушку. **Лучше упасть под нагрузкой в 10 запросов в секунду, чем иметь приложение, способное обработать тысячи, но так и не увидившее свет.**
Признаюсь честно, я не знаком с тонкостями оригинальной телевизионной игры, по сути я делал адаптацию адапции и хотел в первую очередь добиться того, чтобы было занимательно играть через Telegram.
### Шаг 1. Правила
При разработке игры, первым делом бывает полезным формализовать правила и сыграть несколько тестовых партий с друзьями. Без Telegram или любого другого ПО. Описать правила для такой игры оказалось чертовски легко. Через пару часов игр в аналогичные игры я сформулировал текст правил:
Каждая партия состоит из **3 раундов**. Во время раунда игроки по очереди отвечают на случайный вопрос из базы вопросов. Ответив на вопрос, пользователь получает баллы в соответствии со списком и и передает ход другому игроку. Каждый **раунд состоит из 6 ходов**, таким образом у каждого игрока есть по 3 попытки ответа на один вопрос.
1. Наиболее популярный — 8 баллов
2. Второй по популярности — 5 баллов
3. Третий — 3 балла
4. Четвертый — 2 балла
5. Пятый — 1 балл
6. Шестой — 1 балл
7. Все менее популярные — 0 баллов
Как можно догадаться, суть состоит в том, чтобы набрать наибольшее количество очков. Чем более популярный ответ вы даете — тем больше очков. Если вы даете существующий ответ, добавляем за него 1 "голос". Если такого ответа еще никто не давал — добавляем его в список существующих ответов с одним "голосом". Чем больше у ответа голосов — тем более популярны считается ответ. Чтобы игра не затягивалась, а игроки чувствовали напряжение, существует **ограничение на ответ в 20 секунд.** Не успел? Ход переходит другому игроку, а тебе начисляется утешительные 0 баллов. По завершению 3 раунда подсчитываем очки и определяем победителя.
Показал правила своей жене и спросил, понятны ли они, а получив утвердительный ответ, предложил сыграть несколько партий "на словах", выбирая вопросы из открытой базы в интернете(конечно, я жульничал, ведь видел еще и ответы). Процесс показался жене достаточно увлекательным, а правила простыми и, получив одобрение, я сел кодить
### Шаг 2. Абстракции
Перед началом написания кода я люблю заранее попробовать определить с какими абстракциями мне вообще предстоит иметь дело, а заодно попытаться описать за что каждая из них будет отвечать. Из одного только текста правил можно определить, что нам, скорее всего, придется иметь дело со следующими "сущностями":
* Игрок(Player) — здесь будем хранить уникальный id игрока, количество его игр, побед, поражений, рейтинг и любую другую инфу, непосредственно связанную с каждым отдельновзятым игроком.
* Игра(Game) — храним информацию о состоянии конкретной партии, статус игры, кто с кем играет, какой сейчас раунд, у кого сколько очков и т.п.
* Раунд(Round) — в каждом раунде разные вопросы. Неплохо бы сохранить какой вопрос задавался игрокам в этом раунде, какие ответы мы получили, чей сейчас ход.
* Вопрос(Question) — тут понятно, нужно как-то хранить вопросы. Просто текст
* Ответ(Answer) — здесь тоже без неожиданностей, нужно как-то хранить ответы на вопросы и иметь возможность ранжировать их по популярности
Все самое необходимое для игры в первом приближении мы продумали. Для того, чтобы игра была больше похожа на игру, я решил также озадачится общим рейтингом игроков, добавляя тем самым мотивацию играть больше, ведь многие хотят быть где-то первым, любят разного рода баллы, очки, голоса, карму(да, дорогой Хабр?), рейтинг — соревновательный интерес.
Определив необходимый минимум для игрового процесса, я задал себе простой вопрос: "Что помимо самого игрового процесса мне нужно реализовать, чтобы это было похоже на законченный продукт?". Я решил, что было бы неплохо дать возможность:
* Посмотреть правила
* Посмотреть свой рейтинг
* Посмотреть ТОП игроков
* Присоединится к списку ожидания для начала новой игры со случайным соперником
* Создать приватную игру для игры с друзьями
Здесь явно нарисовалась потребность в каком-то меню и тут же появились неигровые состояния, а именно: главное меню и разного рода подменю, ожидание своей очереди в играх со случайным соперником, ожидание подтверждения игры, ожидание начала игры. По моему замыслу все вместе это должно было работать так:
По команде /start бот показывает приветственное сообщение и главное меню. Далее, игрок выбрает игру со случайным соперником и ему показывается сообщение о том, что он добавлен в список ожидания и как только мы найдем оппонента — сообщим. Раз в N-секунд я планировал проверять список игроков в очереди, составлять пары и отправлять им сообщение с просьбой подтвердить матч. Когда матч подтвержден обоими игроками — уведомляем их о скором начале партии и даем немного времени на подготовку, то есть переходим в состояние "ожидание начала игры". Потом просто по таймеру стартуем игру и переходим к игровым состояниям.
### Поехали!
Согласитесь, все что я описал до сих пор звучит чертовски просто. В своем предыдущем материале я уже писал, что самая быстрая для разработки технология — та, которую ты знаешь лучше всего. Потому для реализации бекенда я взял знакомый мне **NodeJS c TypeScript** и начал колбасить. Без чего невозможна ни одна игра? Конечно же без игрока. 10 минут в редакторе кода и я получаю простенький интерфейс:
```
interface Player {
id: string; // уникальный идентификатор игрока
rating: number; // рейтинг игрока
username: string; // имя для отображения
games: number; // к-во игр всего
wins: number; // к-во побед
losses: number; // к-во поражений
createdAt: number; // timestamp "регистрации" игрока
lastGame: number|null; // timestamp окончания последней сыграной игры
}
```
Ни необходимости в сложных связях между моделями, ни особых требований к сохранности данных, ни каких-то сложных структур я не обнаружил. При выборе СУБД я подумал, что большая часть того, что мне предлагают "тяжелые" решения вроде MySQL, Postgres или MongoDB мне попросту ненужны. Я решил тряхнуть стариной и вспомнить **Redis**. Я его использовал до этого в основном как кэш, или для организации очередей и думал, что буду использовать его просто как key-value хранилище и сохранять туда JSON. На всякий случай открыл документацию и тут меня озарило, что использование именно Redis позволит мне сохранить немало времени. Мне понравилось, что используя Redis я не только могу автоматически "подчищать" данные, которые мне больше не нужны, но и использовать встроенную систему "очков"(scores), pub/sub, а про скорость работы Redis я думаю, вы все и так знаете.
Выбрав СУБД, я быстренько накидал простейший сервис с функциями сохранения игрока в БД, получения его оттуда, а так же функциями winGame и looseGame, которые обновляют соответствующие данные у пользователя и рейтинг игроков. Рейтинг я сделал сразу же, еще до игры, ведь Redis предоставляет замечательную структуру данных **sorted set**, которая позволяет по ключу хранить набор значений, каждому из которых можно задать вес(**score**). В соответствии с весом список будет отсортирован. То есть глобальный рейтинг игроков в моей игре это просто sorted set в котором хранятся id всех игроков, а вес(score) соответствует рейтингу игрока.
Конечно, рейтинг нужен не только для того, чтобы мериться с другими игроками. Он также нужен был для того, чтобы более опытные игроки по возможности играли с такими же опытными игроками, а менее опытные с менее опытными соответственно. Писать самому алгоритм рассчета рейтинга? Мой проект совсем не об этом и я пошел в гугл с запросом в духе "Rating system". Тут же мне выпала какая-то статья про рейтинговую систему, применяемую в шахматах под названием **ELO Rating.** Если честно, я не вникал в детали особо глубоко, но быстро понял, что это мне вполне подойдет. Идем на [npmjs.com](http://npmjs.com) и вводим запрос elo-rating и тут же **БИНГО!** <https://www.npmjs.com/package/elo-rating>. Пусть либа и не особо популярная, но зато работает. Взял, пару раз вызвал функцию рассчета нового рейтинга по результатам игры — сработало, внедрил. Теперь у меня есть игрок, который умеет проигрывать и побеждать и рейтинговая система, отлично! При этом весь "сервис" player.service.ts с учетом админской функции вывода списка, возможностью удаления, создания игрока, а также методами "выиграть" и "проиграть" уместился в 130 строк кода. На всякий случай, для понимания того, чем он занят — вот его интерфейс, весь код я выкладывать не буду, но внимательный читатель, глядя на интерфейс сущности Player легко сможет представить себе реализацию каждого из методов в пару-тройку строк.
```
interface IPlayerService {
createPlayer(id: string, name?: string): Promise;
getPlayerName(id: string): Promise;
countPlayers(): Promise;
getRatingPosition(id: string): Promise;
getTopPlayerIds(): Promise;
getTopPlayerScores(): Promise<{id: string, value: number}[]>;
listPlayers(): Promise;
getPlayerRating(id: string): Promise;
getPlayerScores(id: string): Promise;
getPlayerScorePosition(id: string): Promise;
getPlayerGames(id: string): Promise;
getPlayerWins(id: string): Promise;
winGame(id: string, newRating: number): Promise;
looseGame(id: string, newRating: number): Promise;
setSession(id: string, data: any): Promise;
getSession(id: string): Promise;
}
```
После этого я посчитал, что непосредственной работы на этот день мне хватит, заварил чашечку "каркадэ" с сахарочком и начал представлять себе, как я скоро опубликую игру и буду играть в нее со своей женой. С этими мыслями я и отправился спать.
### Второй вечер
Следующий день в моем основном проекте выдался очень бурным, а я никак не мог сконцентрироваться — мысли были об игре. Мне хотелось как можно быстрее сесть программировать. И вот, дождавшись окончания рабочего дня, я наконец открыл редактор кода, пробежался по вчерашним наработкам и наметил такой план:
* Создать сервис для управления вопросами\ответами
* Запилить игровой процесс
* Организоваать матчмейкинг
Вопросы и ответы в игре имеют ключевое значение. Все-таки, механика игры завязана именно на них. Вопрос в нашем случае это просто какой-то вопросительный текст, идентификатор и дата добавления(на всякий случай).
```
interface Question {
id: string;
message: string;
createdAt: number;
}
```
Сохранять вопросы я решил в обычный key-value, в качестве ключа — ID, в качестве значения JSON-строка объекта вопроса. Дополнительно я завел себе **неупорядоченный список(set)** в котором хранятся ID всех доступных вопросов, чтобы было удобно их выбирать. Какие операции над вопросами нам необходимы? Я определил следующие:
* Добавить вопрос
* Получить вопрос по ID
* Получить случайный вопрос
Не обошлось и без небольших вспомогательных функций, но даже с ними сервис чертовски прост и выглядит примерно так:
**Код**
```
class QuestionService {
/**
* Get redis key of question by id
* @param id
*/
public static getQuestionKey(id: string) {
return `questions:${id}`;
}
/**
* Get redis key of questions list
*/
public static getQuestionsListKey() {
return 'questions';
}
/**
* Return question object
* @param id
*/
async getQuestion(id: string) {
return JSON.parse(
await this.redisService.getClient().get(QuestionService.getQuestionKey(id))
);
}
/**
* Add new question to the store
* @param question
*/
async addQuestion(message: string): Promise {
const data = {
id: randomStringGenerator(),
createdAt: Date.now(),
message,
};
await this.redisService.getClient()
.set(QuestionService.getQuestionKey(data.id), JSON.stringify(data));
await this.redisService.getClient()
.sadd(QuestionService.getQuestionsListKey(), data.id);
return data.id;
}
/\*\*
\* Return ID of the random question
\*/
async getRandomQuestionId(): Promise {
return this.redisService.getClient()
.srandmember(QuestionService.getQuestionsListKey());
}
/\*\*
\* Return random question
\*/
async getRandomQuestion() {
const id = await this.getRandomQuestionId(gameId);
return this.getQuestion(id);
}
}
```
Обратите внимание на то, что выбор случайного вопроса я просто отдал на откуп Redis. Уверен, каждый из Вас найдет множество способов улучшить этот код, но давайте простим мне его качество и двинемся дальше. Следующее, чем нужно было озадачиться — ответы на вопросы.
Во-первых, ответы на вопросы добавляют сами игроки. Во-вторых, у ответов есть свой рейтинг, который влияет на то, сколько очков получит игрок. И, наконец, каждый ответ жестко привязан к определнномму вопросу. Также, мне хотелось, чтобы ответы не только не зависили от регистра, ведь было бы обидно, если ты ответил правильно, а из-за регистра ты не получил положенные по праву очки, но и допускали бы небольшие опечатки и разнообразие форм. Тут же в памяти всплыл какой-то коэффициент Жаккара, пошел гуглить как бы опредилить сходство строк и, немного почитав одернул себя. Все ведь уже сделали до меня, а значит нужно сначала попробовать загуглить готовый пакет для определения сходства строк по какому-то коэффициенту. Буквально через 5 минут у меня уже был выбор из нескольких готовых решений и я решил остановиться на <https://github.com/aceakash/string-similarity> основанном на коэффициенте Сёренсена. Кому интересно, как это работает — велкам в [википедию](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D1%8D%D1%84%D1%84%D0%B8%D1%86%D0%B8%D0%B5%D0%BD%D1%82_%D0%A1%D1%91%D1%80%D0%B5%D0%BD%D1%81%D0%B5%D0%BD%D0%B0). Поигравшись с библиотекой в песочнице, методом научного тыка я выяснил, что коэффициент сходства 0.75 мне вполне подходит, хоть иногда и не пропускает неккоторые опечатки и формы слов. Но все же — лучше, чем ничего.
Для каждого существующего вопроса я решил завести отдельный **упорядоченный набор(sorted set)** ответов в котором порядок ответов определен непосредственно популярностью. Поскольку ответы настолько тесно связаны с вопросами я решил делать все в том же самом QuestionService, добавив туда методы добавления ответа, получения списка всех существующих ответов, получение списка ТОП-ответов(за которые начисляются баллы), определения существует ли уже такой ответ на этот вопрос, определения очков, положенных за этот ответ и т.п.
Конечно, нужно было исключить возможность дважды получить баллы за один и тот же ответ на один и тот же вопрос в рамках одной игры. А потому, ответы в какой-то степени сопряжены с конкретной игрой. В итоге, мой QuestionService пополнился следующим кодом:
**Еще код**
```
private turnScores: number[] = [8, 5, 3, 2, 1, 1];
/**
* Get key of list of the answers
* @param questionId
*/
public static getAnswersKey(questionId: string): string {
return `answers:${questionId}`;
}
async addAnswer(questionId: string, answer: string): Promise {
return this.redisService.getClient()
.zincrby(QuestionService.getAnswersKey(questionId), 1, answer);
}
/\*\*
\* Get all answers for the given question
\* @param questionId
\*/
async getQuestionAnswers(questionId: string): Promise {
return this.redisService.getClient()
.zrevrange(QuestionService.getAnswersKey(questionId), 0, -1);
}
/\*\*
\* Top 6 answers
\* @param questionId
\*/
async getTopAnswers(gameId: string, questionId: string): Promise {
const copiedAnswers = await this.redisService.getClient()
.get(`answers:game:${gameId}:q:${questionId}`);
if (!copiedAnswers) {
const ans = await this.redisService.getClient()
.zrevrange(QuestionService.getAnswersKey(questionId), 0, 5);
await this.redisService.getClient()
.set(`answers:game:${gameId}:q:${questionId}`, JSON.stringify(ans));
return ans;
}
return JSON.parse(copiedAnswers);
}
/\*\*
\* Find if answer already exists and return it if found
\* null if answer doesnt exist
\* @param questionId
\* @param answer
\*/
async existingAnswer(questionId: string, answer: string): Promise {
const answers = await this.getQuestionAnswers(questionId);
const matches = stringSimilarity.findBestMatch(answer, answers);
return matches.bestMatch.rating >= 0.75
?
matches.bestMatch.target
:
null;
}
/\*\*
\* Existing answer scores
\* @param questionId
\* @param answer
\*/
async getExistingAnswerScore(
gameId: string, questionId: string, answer: string
): Promise {
const topAnswers = await this.getTopAnswers(gameId, questionId);
const matches = stringSimilarity.findBestMatch(answer, topAnswers);
return matches.bestMatch.rating >= 0.75
?
this.turnScores[matches.bestMatchIndex]
:
0;
}
/\*\*
\* Submit the new answer. Updates answer counter, save if doesn't exist, return answer score
\* @param questionId
\* @param answer
\*/
async submitAnswer(gameId: string, questionId: string, answer: string): Promise {
answer = answer.toLowerCase();
const existingAnswer = await this.existingAnswer(questionId, answer);
if (!existingAnswer) {
await this.addAnswer(questionId, answer);
return 0;
} else {
await this.addAnswer(questionId, existingAnswer);
return this.getExistingAnswerScore(gameId, questionId, existingAnswer);
}
}
```
Как можно понять из этого куска, логика добавления ответа примерно следующая: приводим ответ к нижнему регистру. Проверяем, существует ли уже такой ответ и, если нет — добавляем его в базу и возвращаем 0 очков за него. Если ответ уже есть, то добавляем "голос" за ответ, делая его более популярным в нашей системе, продвигая в общем рейтинге ответов на этот вопрос. Дальше, мы пытаемся узнать, положены ли игроку очки за этот ответ. Для этого мы получаем топовые ответы на этот вопрос и смотрим, есть ли среди них те, коэффициент Сёренсена которых ≥ 0.75 для ответа игрока. Чтобы "баллы" за ответы на вопрос не менялись прямо во время игры, я решил копировать ТОП-ответы на вопросы из общего списка ответов и использовать копию для каждой конкретной игры. Почему я решил засунуть это в getTopAnswers? Возможно, я был пьян — не делайте так ;) Со всеми этими и несколькими другими функциями, весь сервис занял у меня < 300 строк и при этом не только давал возможность управлять ответами и вопросами, но и определять сколько баллов должен получить игрок за ответ в рамках конкретной игры(точнее в рамках какого-то gameId, ведь игры еще и в помине нет).
Уже чувствуете, как на ваших глазах игра приобретает очертания? У нас уже есть игроки, вопросы к которым эти самые игроки могут добавлять ответы и даже возможность определить сколько баллов положено конкрентному игроку за ответ. Пора бы приступить непосредственно к игровому циклу, не так ли?
### Игра
Как я уже писал выше, каждая партия(игра) состоит из раундов и ходов. В каждой игре будет участвовать 2 игрока — player1 и player2 соответственно. У игры есть несколько состояний: ожидание игроков, в процессе, завершена. Саму игру я решил создавать только в тот момент, когда оба игрока уже известны, а статус "ожидание игроков" нужен для того, чтобы после создания игры игроки успели подключится и подтвердили свое участие. Когда оба игрока подтвердили — можно переходить к самой игре.
```
enum GameStatus {
WaitingForPlayers,
Active,
Finished,
}
```
Игры я решил хранить как *key-value*, где ключ как всегда = ID, а value = JSON.stringify(data). В итоге, получился такой вот незатейливый интерфейс игры
```
interface Game {
id: string;
player1: string;
player2: string;
joined: string[];
status: GameStatus;
round?: number;
winner?: string;
createdAt: number;
updatedAt?: number;
}
```
Игровой раунд же должен иметь порядковый номер, информацию о текущем ходе, содержать вопрос(помните? 1 раунд — 1 вопрос), а также ответы игроков.
```
interface GameRound {
index: number;
question: string;
currentPlayer: string;
turn: number;
answers: UserAnswer[];
updatedAt?: number;
}
```
Теперь мы можем перейти к *game.service.ts* в котором и будем описывать логику, а именно: инициализация игры, старт игры, смена раундов, смена ходов, начисление баллов за ответы и подведение итогов. В игре есть ряд событий, при наступлении которых нам стоит совершать каакие-то действия, например, уведомлять игроков о смене хода или конце игры. Для работы с этими событиями я использовал Redis pub/sub. Внимательный читатль возможно помнит, что время хода игрока ограничено. Для этого я решил использовать максимально простой, но довольно опасный подход — стандартные таймеры, но мы тут не строим какую-то масштабируемую систему, а получаем удовольствие от процесса, так что и так сойдет.
**Кусок GameService**
```
class GameService {
// Перечислим наиболее важные для нас игровые события
public static CHANNEL_G_CREATED = 'game-created';
public static CHANNEL_G_STARTED = 'game-started';
public static CHANNEL_G_ENDED = 'game-ended';
public static CHANNEL_G_NEXT_ROUND = 'game-next-round';
public static CHANNEL_G_NEXT_TURN = 'game-next-turn';
public static CHANNEL_G_ANSWER_SUBMIT = 'game-next-turn';
private defaultRounds: number; // количество раундов
private defaultTurns: number; // количество ходов в одном раунде
private timers: any = {}; // таймеры. Да-да, any - зло
// Внедрим сервисы, от которых зависит наша игра и загрузим
// настройки раундов и ходов из конфига
constructor(
private readonly redisService: RedisService,
private readonly playerService: PlayerService,
private readonly questionService: QuestionService,
@Inject('EventPublisher') private readonly eventPublisher,
) {
this.defaultRounds = config.game.defaultRounds;
this.defaultTurns = config.game.defaultTurns;
}
/**
* Get redis key of game
* @param id string identifier of game
*/
public static getGameKey(id: string) {
return `game:${id}`;
}
/**
* Get game object by id
* @param gameId
*/
async getGame(gameId: string): Promise {
const game = await this.redisService.getClient()
.get(GameService.getGameKey(gameId));
if (!game) {
throw new Error(`Game ${gameId} not found`);
}
return JSON.parse(game);
}
/\*\*
\* Save the game state to database
\* @param game
\*/
async saveGame(game: Game) {
return this.redisService.getClient().set(
GameService.getGameKey(game.id),
JSON.stringify(game)
);
}
/\*\*
\* Save round
\* @param gameId
\* @param round
\*/
async saveRound(gameId: string, round: GameRound) {
return this.redisService.getClient().set(
GameService.getRoundKey(gameId, round.index),
JSON.stringify(round)
);
}
/\*\*
\* Initialize default game structure, generate id
\* and save new game to the storage
\*
\* @param player1
\* @param player2
\*/
async initGame(player1: string, player2: string): Promise {
const game: Game = {
id: randomStringGenerator(),
player1,
player2,
joined: [],
status: GameStatus.WaitingForPlayers,
createdAt: Date.now(),
};
await this.saveGame(game);
this.eventPublisher.emit(
GameService.CHANNEL\_G\_CREATED, JSON.stringify(game)
);
return game;
}
/\*\*
\* When the game is created and is in the "Waiting for players" state
\* users can approve participation
\* @param playerId
\* @param gameId
\*/
async joinGame(playerId: string, gameId: string) {
const game: Game = await this.getGame(gameId);
if (!game) throw new Error('Game not found err')
if (isUndefined(game.joined.find(element => element === playerId))) {
game.joined.push(playerId);
game.updatedAt = Date.now();
await this.saveGame(game);
}
if (game.joined.length === 2) return this.startGame(game);
}
/\*\*
\* Start the game
\* @param game
\*/
async startGame(game: Game) {
game.round = 0;
game.updatedAt = Date.now();
game.status = GameStatus.Active;
this.eventPublisher.emit(
GameService.CHANNEL\_G\_STARTED, JSON.stringify(game)
);
await this.questionService.pickQuestionsForGame(game.id);
await this.nextRound(game);
}
/\*\*
\* Start the next round
\* @param game
\*/
async nextRound(game: Game) {
clearTimeout(this.timers[game.id]);
if (game.round >= this.defaultRounds) {
return this.endGame(game);
}
game.round++;
const round: GameRound = {
index: game.round,
question: await this.questionService.getRandomQuestionId(game.id),
currentPlayer: game.player1,
turn: 1,
answers: [],
};
await this.saveGame(game);
await this.saveRound(game.id, round);
// Начиная новый раунд мы также начинаем новый ход
// и устанавливваем таймер в 20 секунд по истичению котрого
// игроку засчитается пустой ответ за который положено 0 баллов
this.timers[game.id] = setTimeout(async () => {
await this.submitAnswer(round.currentPlayer, game.id, '');
}, 20000);
await this.eventPublisher.emit(
GameService.CHANNEL\_G\_NEXT\_ROUND,
JSON.stringify({game, round})
);
}
/\*\*
\* Switch round to next turn
\* @param game
\* @param round
\*/
async nextTurn(game: Game, round: GameRound) {
clearTimeout(this.timers[game.id]);
if (round.turn >= this.defaultTurns) {
return this.nextRound(game);
}
round.turn++;
round.currentPlayer = this.anotherPlayer(round.currentPlayer, game);
round.updatedAt = Date.now();
await this.eventPublisher.emit(
GameService.CHANNEL\_G\_NEXT\_TURN,
JSON.stringify({game, round})
);
this.timers[game.id] = setTimeout(async () => {
await this.submitAnswer(round.currentPlayer, game.id, '');
}, 20000);
return this.saveRound(game.id, round);
}
async answerExistInRound(round: GameRound, answer: string) {
const existingKey = round.answers.find(
rAnswer => stringSimilarity.compareTwoStrings(answer, rAnswer.value) >= 0.85
);
return !isUndefined(existingKey);
}
async submitAnswer(playerId: string, gameId: string, answer: string) {
const game = await this.getGame(gameId);
const round = await this.getCurrentRound(gameId);
if (playerId !== round.currentPlayer) {
throw new Error('Its not your turn');
}
if (answer.length === 0) {
round.updatedAt = Date.now();
this.eventPublisher.emit(
GameService.CHANNEL\_G\_ANSWER\_SUBMIT,
JSON.stringify({game, answer, score: 0, playerId})
);
return this.nextTurn(game, round);
}
if (await this.answerExistInRound(round, answer)) {
throw new Error('Такой ответ уже был в этом раунде');
}
round.answers.push({ value: answer, playerId, turn: round.turn });
const score = await this.questionService.submitAnswer(
gameId, round.question, answer
);
if (score > 0) {
await this.addGameScore(gameId, playerId, score);
}
round.updatedAt = Date.now();
this.eventPublisher.emit(
GameService.CHANNEL\_G\_ANSWER\_SUBMIT,
JSON.stringify({game, answer, score, playerId})
);
return this.nextTurn(game, round);
}
/\*\*
\* Adds game score in specified game for specified player
\* @param gameId
\* @param playerId
\* @param score
\*/
async addGameScore(gameId: string, playerId: string, score: number) {
await this.redisService.getClient()
.zincrby(`game:${gameId}:player:scores`, score, playerId);
}
async endGame(game: Game) {
clearTimeout(this.timers[game.id]);
game.updatedAt = Date.now();
game.status = GameStatus.Finished;
game.updatedAt = Date.now();
// опредилимм победителя
const places = await this.redisService.getClient()
.zrevrange(`game:${game.id}:player:scores`, 0, -1);
game.winner = places[0];
// Рейтинги ДО игры
const winnerRating: number = await this.playerService.getPlayerRating(game.winner);
const looserRating: number = await this.playerService.getPlayerRating(places[1]);
// считаем нновые рейтинги
const newRatings = rating.calculate(winnerRating, looserRating);
await this.playerService.winGame(game.winner, newRatings.playerRating);
await this.playerService.looseGame(places[1], newRatings.opponentRating);
await this.redisService.getClient().expire(GameService.getGameKey(game.id), 600)
this.eventPublisher.emit(GameService.CHANNEL\_G\_ENDED, JSON.stringify(game));
return game;
}
}
```
Отлично, уже что-то. Теперь оставалось решить вопрос с тем, чтобы игроки могли подключаться к игре. Поскольку проблему с рейтингом игроков мы уже решили, а матчмейкинг я хотел организовать именно на его основе — половина проблемы уже решена. Предполагается, что когда игрок хочет поучаствовать в игре, он добавляется в некий список ожидания, из которого мы создаем пары игроков с наиболее близким рейтингом. В этом нам снова поможет Redis с его упорядоченными наборами(sorted sets). Таким образом мы можем организовать добавление игрока в список ожидания буквально в пару строку(можно и в одну в ущерб читабельности и константа тут лишняя, но простите мне это). При подключении к игре мы должы удалять игрока из списка ожидания. Сформированные пару должны инициализировать новую игру. Поскольку матчмейкинг в моем случае настолько простой я засунул его прямо в *game.service.ts*, добавив туда нечто такое
```
async addPlayerToMatchmakingList(id: string) {
const playerRating = await this.playerService.getPlayerRating(id);
return this.redisService.getClient().zadd('matchmaking-1-1', playerRating, id);
}
async removePlayerFromMatchmakingList(id: string) {
return this.redisService.getClient().zrem('matchmaking-1-1', id);
}
async getMatchmakingListData() {
return this.redisService.getClient().zrange('matchmaking-1-1', 0, -1);
}
async matchPlayers(): Promise {
const players = await this.redisService.getClient()
.zrevrange('matchmaking-1-1', 0, -1);
while (players.length > 0) {
const pair = players.splice(0, 2);
if (pair.length === 2) {
return this.coinflip()
?
this.initGame(pair[0], pair[1])
:
this.initGame(pair[1], pair[0]);
}
}
}
```
Круто, игровой процесс есть, игроки могут добавиться в список ожидания и подключиться к игре. Замечу, что опубликован не весь код и в планах публиковать его весь у меня нет. Мне приходится восстанавливать события по кусочкам и это немного затруднительно, что-то я мог упустить.
Немножко потестировав, довольный собой я отправился спать. Вечер следующего дня обещал быть не менее интересным, ведь я планировал сделать интерфейс самой игры.
### Пользовательский интерфейс
Чат-бот — всего лишь интерфейс. Я безумно рад тому, что в отличии от веб-сайтов тут не пришлось ничего верстать, писать css и клиентский JS-код — за нас это все уже сделали разработчики Telegram. А я просто могу воспользоваться результатами их труда. Как мне кажется, в процессе чтения API документации я немного неверно уловил несколько концепций. Тем не менее, на работоспособности игры это особо не сказалось, а скорее касается удобства.
Первым делом, я озадачился текстами, ведь наш будующий бот должен как-то приветствовать игрока, рассказать куда он попал и что нужно делать.
> Добро пожаловать в игру "100 к 1", AndreyDegtyaruk!
>
> В этой игре тебе нужно сражаться против других игроков, выясняя, чья же интуиция развита лучше! Играй против своих друзей, или случайных игроков из интернета. Введи команду /help чтобы узнать правила игры и получить более подрообную информацию о доступных командах
Немного переписал правила, чтобы они лучше отражали суть происходящего и были более понятны игрокам, получился такой текст:
> В игре "100 к 1" Вам предстоит сразиться с другими игроками в умении угадывать наиболее популярные ответы на вопросы. Неправильных ответов нет! Важно выбирать те ответы, которые наиболее часто выбирают другие игроки
>
> Каждая партия состоит из 3 раундов. Во время раунда игроки по очереди отвечают на случайный вопрос из нашей базы вопросов. Отправив ответ на вопрос, пользователь получает баллы в соответствии с таблицей ниже и передает ход другому игроку. Каждый раунд состоит из 6 ходов, таким образом у каждого игрока есть по 3 попытки ответа на один вопрос
>
> Таблица наград за ответы
>
> 1. Наиболее популярный — 8 баллов
> 2. Второй по популярности — 5 баллов
> 3. Третий по популярности — 3 балла
> 4. Четвертый по популярности — 2 балла.
> 5. Пятый — 1 балл.
> 6. Шестой — 1 балл.
> 7. Все менее популярные — 0 баллов
>
>
>
>
>
> Торопись! Время на раздумья ограничено! У игроков есть всего 20 секунд на ответ. Не успели отправить? Вам засчитывается 0 баллов и ход переходит другому игрооку. По окончании 3 раунда производится определение победителя и начисление очков, а значит и Ваше продвижение в рейтинговой таблице
Поработав над текстами, я задумался о том, как в принципе работают чат-боты в телеграм, а точнее о том, как получать обновления от игроков(команды боту, ответы на вопросы). Существует 2 подхода: pull и push. Pull подход подразумевает, что мы "опрашиваем" Telegram на предмет изменений, для этого в API Telegram существует метод getUpdates. Push это когда телеграм сам присылает нам обновления, если они есть, иными словами — дергает webhook. Вебхуки показались мне более хорошей идей, поскольку избавляют от необходимости часто "опрашивать" телеграм на предмет обновлений даже если их нет, а так же от необходимости реализации механизма самого получения этих данных. Значит, вебхукам быть!
Осмотрев доступные библиотеки для создания ботов и официальный SDK я выбрал [Telegraf](https://telegraf.js.org), ибо мне показалось, что его уровень абстракции как раз подходит для моих нужд — удобные, простые и понятные интерфейсы. Да еще и довольно большое коммунити, активная поддержка и разработка.
Останавливаться на том, как "зарегистрировать" бота в телеграм, получить API key я не буду, это все подробно описано в документации, так что предлагаю сразу перейти к делу. Для работы с ботами я создал очередной сервис — *bot.service.ts*, который и должен взять на себя все взаимодействие с Telegram. Для начала, я решил определиться с тем, какие команды будет понимать мой бот. Почитав документацию и порисовав на листочке схему работы я получил такой список:
* /start — показывает приветственнное сообщение и главное меню(зачем-то я сделал его inline, возможно, custom keyboard был бы более удачным выбором)
* /help — показывает правила игры и главное меню
* /player\_info — информация об игроке(победы, поражения, рейтинг) и главное меню
* /global\_rating — выводит глобальный рейтинг игроков и главное меню
* /go — добавляет игрока в лист ожидания игр
Можно заметить, что главное меню выводится почти на любую команду. Потому, его описание я вынес в отдельную функцию и получил что-то вроде этого
```
getMainMenuKeyboard() {
return {
inline_keyboard: [
[
{
text: ' Игра со случайным соперником',
callback_data: JSON.stringify({type: 'go'})
}
],
[
{
text: ' Рейтинг игроков',
callback_data: JSON.stringify({type: 'player-rating'})
}
],
[
{
text: ' Правила',
callback_data: JSON.stringify({type: 'rules'})
}
],
[
{
text: ' Моя статистика',
callback_data: JSON.stringify({type: 'stats'})
}
],
],
};
}
```
Можно обратить внимание на свойство *callback\_data.* Telegram пришлет эти данные при нажатии на кнопку, а я, в свою очередь смогу определить что же за кнопку нажали и отреагировать верным образом.
Для обработки таких вот коллбеков я сделал отдельную функцию, в которой повесил switch/case statement по полю type, внутри которого просто вызываю нужный метод. Далее я попробовал реаализовать информационные команды start и help, чтобы попробовать протестировать бота и узнать дойдет ли до меня вебхук, залогировать его и попробовать ответить. Тут же я узнал, что Telegram шлет запросы только по https, да еще и какой-то домен мне бы не повредил. Для того, чтобы все это получить локально и желательно не тратить на это пол дня я взял небезызвестный **[Ngrok](https://ngrok.com)** с которым справится даже ребенок.
```
async commandStart(ctx) {
let name = `${escapeHtml(ctx.from.first_name)}`;
name += ctx.from.last_name ? escapeHtml(ctx.from.last_name) : '';
await this.playerService.createPlayer(ctx.from.id.toString(10), name);
await this.bot.telegram.sendMessage(ctx.from.id, messages.start(name), {
parse_mode: 'HTML',
reply_markup: this.getMainMenuKeyboard(),
});
}
```
Как видно, в команде старт я просто создаю игрока и отправляю ему приветственное сообщение с клавиатурой. Как ни странно, все заработало и у меня отлегло от сердца. Весь предыдущий труд был не напрасен и, судя по всему, у меня получится сделать все что я хотел. Дальше, как говорится, дело техники. Я думаю, что большого смысла писать тут реализацию всех команд нет.
Когда я добрался до матчмейкинга, мне пришлось вспомнить тот самый Redis pub/sub. Раньше мы уже сделали публикацию игровых событий. Теперь нужно было организовать слушателя, который отправлял бы соответствующие сообщения при нахождении пары, начале матча, принятии ответа оппонента(чтобы показать что он ответил и сколько очков заработал). Временно засунул этого слушателя прямо в свой main.ts, но все мы знаем, что нет ничего более постоянного, чем временное. Переделать руки так и не дошли. Типичный "слушатель" в итоге выглядит так
```
const redisClient = app.get('EventSubscriber');
redisClient.on(GameService.CHANNEL_G_CREATED, async (data) => {
try {
await botService.sendGameCreated(JSON.parse(data));
} catch (error) {
console.log('Error in CHANNEL_G_CREATED');
console.log(error);
}
});
```
В BotService.sendGameCreated, как не трудно догадаться мы просто отправляем обоим игрокам соответсвующие сообщения о том, что мы нашли пару и просим подтвердить участие в игре.
Когда дело дошло до работы внутри самой игры(и еще нескольких других функций, добавленных позже), возникла необходимость где-то хранить состояние игроков, чтобы бот понимал, находится ли игрок внутри игры, или в меню. А если в меню, то в каком? Я немного поковырял механизм Stages и Scenes, предоставленный Telegraf, поскольку по документации мне показалось что это именно то, что мне нужно. Но, к сожалению, за 30 минут мне так и не удалось заставить его работать и я воспользовался старыми добрыми сессиями, которые просто сохранил в Redis.
Когда боту приходит текстовое сообщение от игрока, бот проверяет, находится ли приславший сообщение в актвной игре. Если да, то мы смотрим чей сейчас ход и, если ход того, кто прислал сообщение — засчитываем ответ(если его еще не было). Если же ход другого игрока — присылаем сообщение о том, что сейчас ход оппонента, подождите его ответа.
```
this.bot.on('text', async (ctx: any) => {
ctx.message.text = escapeHtml(ctx.message.text);
ctx.message.text = ctx.message.text.toLowerCase();
try {
const state = await this.playerService.getSession(ctx.from.id.toString());
if (!state.currentGame) {
return ctx.reply(
'Используйте команды, чтобы начать игру.
Воспользуйтесь командой /help, чтобы увидеть список доступных команд'
);
}
await this.gameIncomingMessage(ctx, state);
} catch (error) {
console.log('Error during processing TEXT message');
console.log(error);
}
});
this.bot.on('message', async ctx => {
ctx.reply('Поддерживаются только текстовые сообщения');
});
```
На все сообщения, кроме текстовых бот отвечает, что поддерживает только текст.
Доделав Telegram-обертку над игрой, я отправил ссылку на бота жене и парочке друзей. Конечно, в процессе находились какие-то баги. Особенно позабавило то, что у одного из знакомых в имени было нечто вро , а поскольку я использую parseMode HTML, телеграм начал мне выдавать ошибку: "Не могу спарсить html" и при этом сообщения ВСЕМ перестали доходить. Тем не менее от игр со случайными соперниками получил удовольствие не только я, но и мои знакомые. Некоторые из них даже делились им со своими друзьями и за несколько часов тестирования на localhost количество игроков достигло 50 человек. Я посчитал этот эксперимент удачным, убил NodeJS процесс и успешно вернулся к своим повседневным делам. Идея написать об этом пост зрела очень долго и к моменту его написания я даже не удосужился выгрузить бота на какой-нибудь сервер, однако, к моменту публикации все-таки заставил себя это сделать.
Я очень надеюсь, что мой пост вдохновит кого-то на реализацию своих идей, заставит делать пет-проджекты быстрей и доводить их до релиза, поможет целиком представить процесс создания проектов от идеи до реалиазации, или просто позволит получить хоть немного удовольствия от чтения. Я почти уверен в том, что бот не выдержит большое количество игроков. Все-таки таймеры, subscriber прямо в main, один процесс и т.д и т.п. Тем не менее, если кому-то интересно посмотреть на результат — ищите бота [@QuizMatchGameBot](https://t.me/QuizMatchGameBot). Всем мир! | https://habr.com/ru/post/488152/ | null | ru | null |
# Непредсказуемые инвестиции с Python
**О чем эта статья**: В основном, о том, как создать рандомайзер биржевых активов используя данные Московской и Питерской бирж на Python.
Кому не важна реализация то вот [готовый код](https://github.com/wolf24ru/CrazyInvest) с минимальными инструкциями по запуску. Ну или можно воспользоваться [телеграмм ботом](https://t.me/CrazyInvestBot) для всего того же самого, но в удобном формате (если он не работает, то скорее всего, я перестал платить за админку 😞). А в самом низу есть небольшое [подведение итогов](#money).
---
Многие классные проекты начинались с “А что если …?”, моя идея не нова и не претендует на “классность”. Но все же, а что если сделать рандомайзер для акций российского рынка и можно ли на нем заработать в долгую?
Что же, на вопрос “А что если …” я и отвечу в этой статье. А вот про "заработать"... тут сложнее. Но обо всем по порядку.
**Пожалуй, начать надо с того, что данная статья не является финансовой рекомендацией. У меня нет финансового образования и богатого финансового опыта. Все что вы прочтете далее основано исключительно на моих наблюдениях, опыте и субъективном мнении. И помните: инвестиции всегда сопряженный с риском.**
---
Начало пути
-----------
Зайду издалека. Несколько лет назад я, как и многие обыватели, начал пробовать себя в инвестициях. Используя различные инвестиционные, и не очень, инструменты я периодически вгонял состояние своего баланса в "отрицательный рост", тем самым получая какой-никакой опыт. Что и подтолкнуло к изучению всей этой денежной темы более подробно. В итоге прочитав кучу статей, подписавшись на каналы всякого рода "финансовых гуру", просмотрев множество роликов и даже пройдя на "Нетологии" курсы Сергея Спирина (классный дядька и рассказывает классно) который пропагандирует [Asset Allocation](https://assetallocation.ru/asset-allocation/). Я понял, что никто не владеет супер методом зарабатывания на биржи, и большая часть вообще не представляет как оно там все устроено. По сути, люди делятся на 2 глобальных вида биржевых игроков: те кто играет в откровенную "угадайку", порой даже диверсифицируя свои портфели в надежде минимизировать риски, и на тех кто играет "нечестно" зарабатывая на инсайдерской информации.
Причем же тут рандом? Во время изучения всей этой “финансовой грамотности” я не раз наталкивался на примеры случайного приобретения активов, которые в долгосроке приносили неплохую прибыль. И конечно вы хотите примеры, их есть у меня:
* [Обезьянка Лукерья](https://vc.ru/flood/34471-v-2008-godu-obezyana-naugad-vybrala-akcii-i-za-devyat-let-zarabotala-bolshe-professionalnyh-investorov) (Наверное, самый известный пример на постсоветском пространстве)
* Хомяк инвестор [Mr.Goxx](https://www.bbc.co.uk/news/technology-58707641)
* Специально обученные [крысы инвесторы](https://www.businessinsider.com/forex-and-commodities-rat-traders-2014-9)
* Попугай [Ddalgi](https://www.impactlab.com/2009/08/08/parrot-beats-investors-in-south-korean-stock-market-contest/)
* Кот [Орландо](https://www.forbes.com/sites/frederickallen/2013/01/15/cat-beats-professionals-at-stock-picking/?sh=6414e40f621a)
И это только примеры, которые есть на поверхности, подобных экспериментов множество. Но объединяет их одно (точнее "два"). Во-первых, у всех крайне странная выборка (за исключением хомяка, он шикарен… был). Во-вторых, это все очень похоже на ошибку выжившего.
Исходя из замечаний выше, нам нужно увеличить выборку, значит возьмем весь доступный в России рынок активов (на момент начала написании программы и статьи еще можно было торговать на Питерской бирже “неквалам”). Ну а проверить второй тезис можно только совершив тысячи сделок и создав сотни портфелей, что крайне затратно (да, конечно можно смоделировать, но это не так весело).
И так, для того чтобы проверить прибыльность рандомизированного инвестирования нам необходим генератор случайных активов. По началу, в планах было задействовать для этих целей одну из кошек друга. Но они отказались от предложенной “должности”.
 Реакция кошки на предложение стать инвестором. А в свете того, что сейчас каждый второй знает python и пихают его куда можно и куда нельзя. Решено было написать простенький рандомайзер на python.
---
Немного кода.
-------------
Прежде чем изобретать велосипед, нужно понять, а не сделал ли его кто-то другой. Поэтому я начал поиски проектов подходящих по тематике. То ли я плохо искал, то ли собрался делать особо бесполезную программу, но нашел только [один пример реализации](https://habr.com/ru/post/495324/) (этот же проект на [GitHab](https://github.com/empenoso/MOEX-Random-Picker)) написанный @[@empenoso](/users/empenoso). Проект написан на JS и выдает только акции МосБиржи. На момент написания программы мне хотелось получать данные не только с Московской, но и с Питерской биржи, также помимо акций получать и другие виды активов, а еще было бы просто замечательно иметь возможность устанавливать лимит по стоимости актива. Так что было решено написать все самостоятельно.
Я решил не нагружать статью обилием кода. Поэтому буду приводить в качестве примера только основные функции реализованного мной класса. Кому интересна вся структура без труда сможет посмотреть [код целиков в GitHub-е](https://github.com/wolf24ru/CrazyInvest).
По началу идея была такой:
> Каждый месяц инвестировать согласно рандомному выбору 3000руб (примерно 10% от медианной ЗП по России). Смотреть на "Доходность\Потери" в различные промежутки времени и сравнивать с инвестиционными фондами
>
>
Чуть позже от идеи пришлось отказаться, ибо для покупок остался только рынок МБ, что на мой взгляд крайне маленькая выборка активов, да и он последнее время... не стабилен. А еще, я решил попробовать инвестировать в крипту (да, время я выбрал просто лучшее). Возможно, чуть позже я пересмотрю свое решение. Но пока так. Да и скрипт уже написан.
Приступим к написанию кода.
### Подготовка данных.
Для получения рандомного актива, нужно сначала получить весь список необходимых активов. Начнем с самого простого. МосБиржа - тут есть достаточно не плохой и крайне дружелюбный [API](https://iss.moex.com/iss/reference/) который помогает получать любые данные с биржи, к тому же абсолютно бесплатно. Как оказалось это нонсенс, остальные биржи, по большей части требуют плату за предоставление данных, особенно для данных в реальном времени.
Меня на МосБирже интересовали 4 вида актива: акции, ПИФы, ОФЗ, облигации. Их мы и будем доставать из МБ и класть каждый вид актива в отельный JSON файл.
Получаем данные из МосБиржи
```
import asyncio
import json
import config
import requests
# ссылки на получения данных с API
url_shares = 'https://iss.moex.com/iss/engines/stock/markets/shares/boards/TQBR/securities.json?first=350'
url_bpif = 'https://iss.moex.com/iss/engines/stock/markets/shares/boards/TQTD/securities.json?first=500'
url_ofz = 'https://iss.moex.com/iss/engines/stock/markets/bonds/boards/TQOB/securities.json?first=200'
url_bonds = 'https://iss.moex.com/iss/engines/stock/markets/bonds/boards/TQCB/securities.json?first=3000'
async def _download_stock_market_data(url, file_path):
with requests.get(url) as response:
if response.status_code == 200:
with open(file_path, 'w') as file:
json.dump(response.json(), file)
async def download_data():
await asyncio.gather(
_download_stock_market_data(url_ofz, config.ofz_file),
_download_stock_market_data(url_bonds, config.bonds_file),
_download_stock_market_data(url_bpif, config.bpif_file),
_download_stock_market_data(url_shares, config.stocks_file),
)
```
В [config.py](https://github.com/wolf24ru/CrazyInvest/blob/main/config.py) лежат пути к разным данным программы.
Отлично! Данные для МБ уже есть. (И если говорить откровенно то на момент переписывания этой статьи, получения данных с Питерской биржи особого смысла не имеет. Но будем надеяться на лучшее и верить в то, что очень скоро всем "неквалам" снова позволят торговать адекватными иностранными активами.).
Теперь все простое закончилось и начинаются костыли. Да, верно, необходимо получить активы с СПБ. Адекватного API, который по запросу отдавал бы все, что мне нужно, я не нашел, видимо его и нет. Можно воспользоваться сторонними API, от брокеров, допустим [Тинкоффским API](https://www.tinkoff.ru/invest/open-api/). Вот только у них, как правило, будет не весь список активов. Поэтому… как бы это прискорбно не было… придется городить костыли, в данном случаи вытаскивание данных будет реализована через [selenium](https://selenium-python.readthedocs.io/). Единственный способ, который я нашел, для получения данных - это [таблица](https://spbexchange.ru/ru/stocks/inostrannye/Instruments.aspx) на сайте Санкт-Петербургской биржи, которую можно получить в формате CSV. Так что, сначала происходит попытка получить данную таблицу цивильным requests, и в случае срабатывания тротлинга или просто неуспеха запускаются костыли.
Получаем данные из Санкт-Петербургской биржи
```
from webdriver_manager.chrome import ChromeDriverManager
import config
# получение имени последнего установленного файла
def latest_download_file():
path_download = config.path_file / 'spb_data'
os.chdir(path_download)
files = sorted(os.listdir(os.getcwd()), key=os.path.getmtime)
if files:
newest = files[-1]
return newest
else:
raise Exception('dir is empty')
async def download_data():
url_spb = 'https://spbexchange.ru/ru/stocks/inostrannye/Instruments.aspx?csv=download'
with requests.get(url_spb, allow_redirects=True) as r:
# попытка скачивания номральным способом
if r.status_code == 200:
with open(config.spb_file, 'wb') as f:
f.write(r.content)
else:
# попытка скачивания через браузер
option = webdriver.ChromeOptions()
prefs = {"download.default_directory": str(config.path_file / 'spb_data')}
option.add_experimental_option('prefs', prefs)
driver = webdriver.Chrome(ChromeDriverManager().install(), options=option)
driver.get(url_spb)
time.sleep(5)
driver.close()
file = latest_download_file()
if pathlib.Path(file).suffix == '.csv':
os.renames(file, 'SPB.csv')
```
Теперь у нас есть все доступные данные с СПБ. У них есть два недостатка. Во-первых, тут все в куче, и акции и облигации. Во-вторых, отсутствие стоимости активов, но об этом чуть позднее.
### Обработка данных
Самое время заняться вычленением нужной нам информации из уже имеющихся данных.
Начнем, как всегда, с МосБиржи. Тут необходимо объединить все подготовленные json файлы в базу знаний. Я решил что разумно будет разделить все на 2 таблицы. В первой таблицы собрать все акции и ПИФ-ы, во второй все облигации и ОФЗ. Реализуем слияние при помощи [pandas](https://pandas.pydata.org/). Но прежде чем соединить 2 таблицы из json в одну, необходимо их укоротить, оставив только столбцы, которые потребуются дальше. Я выбрал 5 столбцов: SECID, SECNAME, ISIN, PREVPRICE, BOARDID.
Преобразование json в таблицы
```
@staticmethod
def _get_short_table(json_dict: dict) -> pandas.DataFrame:
"""
Получение укороченной таблицы, только с необходимыми столбцами
Parameters:
json_dict (dict): json данные таблицы
"""
data = json_dict['securities']['data']
columns = json_dict['securities']['metadata']
df = pandas.DataFrame(data=data, columns=columns)
short_table = df[['SECID', 'SECNAME', 'ISIN', 'PREVPRICE', 'BOARDID']]
return short_table
def _get_mb_stock_exchange(self):
"""
Загрузка данных из json
"""
# open JSON
for file_name in [config.stocks_file, config.bpif_file,
config.ofz_file, config.bonds_file]:
self.file_exist(file_name, msbd)
with open(config.stocks_file, 'r') as file:
shares_json = json.load(file)
with open(config.bpif_file, 'r') as file:
bpif_json = json.load(file)
with open(config.ofz_file, 'r') as file:
ofz_json = json.load(file)
with open(config.bonds_file, 'r') as file:
bonds_json = json.load(file)
# Акции и пифы
self.main_table_stocks_ru = pandas.concat([self._get_short_table(shares_json),
self._get_short_table(bpif_json)],
ignore_index=True)
# Облигации и ОФЗ
self.main_table_bonds_ru = pandas.concat([self._get_short_table(ofz_json),
self._get_short_table(bonds_json)],
ignore_index=True)
```
Теперь у нас есть 2 таблицы на основе данных из МБ. Дальше необходимо обработать таблицы с СПБ. Тут все немного проще, ибо таблица будет одна, только с акциями. Почему я не учитываю облигации с СПБ? Потому что большая часть не торгуется на общедоступных биржах, да что уж там на биржах, даже на [Investing](https://www.investing.com/) и [Yahoo Finance](https://finance.yahoo.com/) их практически невозможно найти. Но функционал реализован, и кому он необходим всегда сможет просто раскомментировать последние две строчки в функции получения данных с СПБ и немногого подправить код в методе `choice()`.
Обработка данных с СПБ
```
def _get_spb_stock_exchange(self):
"""
Получить данные с питерской биржи """ self.file_exist(config.spb_file, spbd)
spb_table = pandas.read_csv(config.spb_file, sep=';')
# название e_full_name
# код s_RTS_code # ис_код s_ISIN_code # вид актива s_sec_type_name_dop spb_table = spb_table[['s_RTS_code', 's_ISIN_code', 'e_full_name', 's_sec_type_name_dop']]
spb_table.rename(columns={'s_RTS_code': 'SECID', 'e_full_name': 'SECNAME', 's_ISIN_code': 'ISIN'}, inplace=True)
# сортируем в разные таблицы по виду актива (акции, облигации)
spb_table_stock = spb_table[(spb_table.s_sec_type_name_dop == 'Акции')]
self.spb_table_stock = spb_table_stock[['SECID', 'SECNAME', 'ISIN']]
# spb_table_bond = spb_table[(spb_table.s_sec_type_name_dop == 'Облигации')]
# self.spb_table_bond = spb_table_bond[['SECID', 'SECNAME', 'ISIN']]
```
Просто великолепно. Осталось совсем немного, а именно: выбрать рандомный актив и вывести все это на экран.
### Итоговый выбор
Приступим к выбору.
Для начала нам нужно определиться с видом актива: мы хотим получить акцию или облигацию. Затем решить с какой из бирж мы хотим получить актив. И в конце получить рандомный актив, из подготовленной таблицы на предыдущих шагах.
Определяемся с начальными условиями выбора и получаем актив
```
def choice(self):
"""
Определения актива и биржи с дальнейшим получением конкретного актива
"""
match self.asset:
# Выбор актива
case 'stock':
# выбор биржи
if ('MB' in self.stock_market) & ('SPB' in self.stock_market):
self.choice_table = pandas.concat([self.spb_table_stock,
self.main_table_stocks_ru],
ignore_index=True).sample().values[0]
elif 'MB' in self.stock_market:
self.choice_table = self.main_table_stocks_ru.sample().values[0]
elif 'SPB' in self.stock_market:
self.choice_table = self.spb_table_stock.sample().values[0]
else:
print("O no. You didn't choose any stock market")
raise Exception('stock market not chosen')
case 'bond':
if ('MB' in self.stock_market) & ('SPB' in self.stock_market):
self.choice_table = self.main_table_bonds_ru.sample().values[0]
elif 'MB' in self.stock_market:
self.choice_table = self.main_table_bonds_ru.sample().values[0]
elif 'SPB' in self.stock_market:
raise Exception('At the moment you cannot use bonds from the St. Petersburg Stock Exchange')
else:
print("O no. You didn't choose any stock market")
raise Exception('stock market not chosen')
case _:
raise Exception('incorrect asset name')
# итоговое получение актива
self.asset_choice = self.choice_obj(self.choice_table)
```
Теперь остается только обработать выбранный актив для дальнейшего его представления в удобном формате. Берем выбранный объект и распределяем его внутренние компоненты по переменным. В конце функции, так же реализован выбор по лимиту, если стоимость акции окажется выше заранее веденного лимита, то рандомный выбор будет повторен до тех пор пока стоимость акции не будет удовлетворять условию. По умолчанию лимита нет, и проверка данного условия не выполняется. Во избежании зацикливания и долгого поиска не рекомендуется ставить лимит ниже **300руб**.
Обработка выбранного актива
```
def choice_obj(self, data: list) -> dict:
"""
Преобразование выбранного актива
Parameters:
data (list): Данные выбранного актива
Returns:
return (dict): Словарь преобразованных данных
"""
try:
data_nan = math.isnan(data[3])
except IndexError:
data_nan = True
if data_nan:
price = self._get_current_price(data[0])
price_str = f'({price["stock_current_prise"]} {price["currency"]}) {price["rub_prise"]:.{2}f} руб.' price_ru = price["rub_prise"]
price_increase = price["price_increase"]
else:
price = data[3]
price_ru = data[3]
price_str = f'{data[3]} руб.' price_increase = self.percentage_change(price_ru, data[0], data[4])
quantity = 1
if self.limit:
if self.limit >= price_ru:
int_div = int(self.limit // price_ru) + 1
quantity = random.choice(range(1, int_div))
return {
'sec_id': data[0],
'full_name': data[1],
'isn': data[2],
'price': price,
'price_str': price_str,
'price_ru': price_ru,
'quantity': quantity,
'price_increase': price_increase
}
```
При обработке выбранной акции есть один нюанс, у акций с Питерской биржи нет стоимости. Поэтому нам нужно её найти. Задача имеет множество решений. Я решил использовать готовый [API для Yahoo! Finance](https://github.com/ranaroussi/yfinance). Этот API не является официальным, и автор не раз повторяет, что использование в коммерческих целях не желательно и может караться самим Yahoo. Данный API самое просто и бесплатное, что я смог найти. Есть много других подобных API, но у них, в бесплатных версиях, имеется много всяких ограничений.
Получение данных об иностранной акции
```
def _get_current_price(self, sec_id_choice: str) -> dict:
"""
Получение текущей цены актива с СПБ
Parameters:
sec_id_choice(str): Тикер актива для поиска
Returns:
info(dict): Словарь с ключевыми значениями актива:
stock_current_prise - стоимость в валюте
currency - валюта
rub_prise - стоимость в рублях
price_increase - изменение в цены за месяц в процентах
"""
msft = yf.Ticker(sec_id_choice)
try:
stock_current_prise = msft.info['currentPrice']
currency = msft.info['financialCurrency']
dollar_prise = self._get_currency_price(currency)
rub_prise = stock_current_prise * dollar_prise
hist = msft.history(period="1mo")
open_1mo = hist['Open'][0]
price_increase = (stock_current_prise - open_1mo) / open_1mo * 100
return {'stock_current_prise': stock_current_prise,
'currency': currency,
'rub_prise': rub_prise,
'price_increase': price_increase}
except KeyError as er:
if msft.info['regularMarketPrice'] is None:
print('f')
self.choice()
Exception(er)
```
При получении цены иностранного актива, мы тут же переводим из валюты в рубли. Для этого нам, само собой, надо знать в какой валюте торгуется акция и стоимость данной валюты к рублю. Информацию о валюте получаем из API для Yahoo! Finance. А стоимость валюты к рублю с [сайта курса валют](https://www.cbr-xml-daily.ru/).
Получить стоимость валюты в рублях
```
@staticmethod
def _get_currency_price(currency: str) -> str:
"""
Получение текучего курса рубля относительно валюты.
Parameters:
currency(str): Валюта к которой необходимо найти курс.
Returns:
all_currencies(str): Текущая стоимость валюты в рублях
"""
all_currencies = requests.get('https://www.cbr-xml-daily.ru/daily_json.js').json()
return all_currencies['Valute'][currency]['Value']
```
### Вывод информации
Теперь осталось красиво вывести все это на экран. Для этого есть простая функция для вывода в консоль.
Вывод в консоль
```
@property
def inform(self) -> str:
"""
Подготовка информации для вывода
Returns:
(str) Возвращает готовую строку с данными
"""
return f'''
сокращенно: {self.asset_choice['sec_id']}
наименование: {self.asset_choice['full_name']}
цена: {self.asset_choice['price_str']}
количество: {self.asset_choice['quantity']}
изменение за месяц: {self.asset_choice['price_increase']:.{2}f} %isn: {self.asset_choice['isn']}
'''
def print_asset(self):
"""
Функция для вывода результата с подготовленными данными в консоль
"""
print(f'''
{'-' * 60}
{self.inform}
{'-' * 28}
{self.date_create}
{'-' * 60}
''')
```
Так же есть метод `crate_img()` который создает красивую картинку с формацией об активе, его я описывать не буду, ибо и так много текста получилось, а вывод картинки на основной функционал никак не влияет. На этом этапе можно закончить, ибо основной функционал получен.
---
Итоги
-----
По итогу весь скрипт умещается в одном "неказистом" классе.
Что было реализовано:
* Написан скрипт для рандомного получения активов доступных на Российском биржевом рынке
* По завершению все это было запихано в Docker
* Добавлена БД
* В docker создан контейнер под selenium
* Написан телеграмм бот
* Реализован графические вывод информации об активе:
* После небольшого пинка друга дизайнера, графический вывод был переделан:
---
### А что там с деньгами?
Теперь отвечаю на второй пункт, ну тот самый который в начале, по поводу доходности. Как только я закончил писать и тестить код, большинство бумаг СПБ были запрещены для покупки "неквалам" (А за некоторые акции можно и сесть), что грустно, и по сути уничтожает половину функционала программы. Но для размышления могу дать небольшую табличку. Это акции которые были куплены, на праздно валяющиеся деньги на основном брокерском счете, во время тестирования скрипта/бота, "ради интереса", само собой по его рекомендациям. Таблица актуальна на **16.11.2022**
| № | Наименование | дата покупки | количество (шт) | стоимость покупки одной акции | прибыль в% |
| --- | --- | --- | --- | --- | --- |
| 1 | United Medical Grou | 07.10.2022 | 2 | 332,7₽ | 2,64% |
| 2 | ГК Самолет | 07.10.2022 | 1 | 1975,5₽ | 32,86% |
| 3 | Rosseti Tsentr PAO | 12.09.2022 | 1000 | 0,2666₽ | 3,60% |
| 4 | Solid Biosciences | 12.09.2022 | 1 | $10,04 | -34.16% |
| 5 | Tactile Systems | 07.09.2022 | 1 | $8,36 | 0.71% |
| 6 | iRobot | 07.09.2022 | 1 | $58,89 | -10,86% |
| 7 | PetIQ | 07.09.2022 | 1 | $10,28 | 12,93% |
| 8 | Gap | 07.09.2022 | 1 | $9,17 | 39,69% |
По итогу за пару месяцев мы имеем активы купленные примерно на **8826,15₽** (с учетом комиссии), P/L по открытию в долларах **$6,42 / 4,43%** и в рублях **387,84 руб. / 4,43%**. Для двух месяцев результат очень даже неплохой. Но опять же, во-первых, надо понимать что больше половины акций иностранные, которые сейчас не купить, и на которые не так сильно влияют "действия" РФ. Во-вторых, покупки были не систематические и не выполняют поставленные ранее условия. В-третьих, нужно подождать хотя бы пол года (а лучше больше), что бы результат стал виден более отчетливо..
P.S: Немного боли и откровения. Статья была написана еще где-то месяц назад (сегодня 16.11.2022). Но я стал тем самым "счастливчиком" которые решил что хранить написанный текст на Хабре очень хорошая идея. Ибо в течении недели пока я писал статью, все было замечательно. А вот мой браузер видать решил что localStorage ему не нужны.... как и написанная мной статья лежавшая там. И в один "прекрасный" день я с грустью и досадой обнаружил, что кнопочки "Восстановить" больше нет, ничего нет, все пропало. Так что я начал практически с нуля, и переписывать было оочень тяжело, практически по строчки в день. А потом я столкнулся с [Obsidian](https://obsidian.md/) и обнаружил для себя, что писать статьи очень даже приятно. | https://habr.com/ru/post/700660/ | null | ru | null |
# Форд, Тойота и морские свинки
*— Какое отношение имеет морская свинка к морю?
— Примерно такое же, как утконос к проектированию дирижаблей.*
### Введение.
Я имею обыкновение во время прогулок прокручивать информацию из нескольких источников, сопоставляя куски. Одна из любопытных находок – почти полное соответствие статистических наблюдений Демарко и Листера в «Peopleware» и теоретических выкладок Голдратта в «Критической цепи».
Осенью 2011 я крутил в голове:
[1] «Стоя на плечах гигантов» Эли М. Голдратт © Eliyahu M. Goldratt, 2008
[2] «Производственный менеджмент: управление потоком» Одед Коуэн, Елена Федурко
[3] «История одной доски» (http://cartmendum.livejournal.com/tag/theboard).
Далее хотелось бы написать: «Как вдруг…», — но это будет неправдой. Это случилось не вдруг. Мне понадобилось пару недель, но, в конце концов, в голове сложилась достаточно цельная картинка.
За что именно я зацепился:* Таичи Оно (Öno Taiichi) не понимал, почему его система работает.
* Существует несколько разных типов производственных потоков – V, A, T, I. Каждый тип потока ставит особые задачи.
* Неудачи внедрения доски Максима Дорофеева в некоторых подразделениях
* Ряд компаний не смог внедрить систему Тойота, несмотря на все приложенные усилия.
* Система Тойота и система Форда основывается на одинаковых принципах, но прикладные решения ограничены определенными типами производства.
### Теория. Типы потоков
Типы потока принято классифицировать от доминирующего паттерна. В чистом (вырожденном) виде типы потоков можно изобразить следующим образом:
Если нужна более подробная информация, то лучше обратиться к статьям Одед Коуэна (Oded-Cohen) и Елены Федурко.
В мире производства ПО можно провести аналогию:
Главным отличием является то, что при производстве ПО часто нет материалов. Не совсем понятно, что использовать в качестве аналогии материалам в мире производства ПО. Заказы есть и там и там. Как правило, на заводе производство тоже не начинается без заказа. Вероятно, можно рассматривать в качестве материалов поступающие на вход идеи. В процессе разработки эти идеи трансформируются в спецификации требований, потом в архитектурные решения и, наконец, в конечный продукт.
| | |
| --- | --- |
| | Дисклаймер. Я не уверен, что проблемы одного и того же типа производственной цепочки одинаковы для миров материального производства и мира разработки ПО. Это гипотеза, у которой есть много подтверждающих примеров. Но даже одно исключение может поставить эту гипотезу под сомнение. |
Возможно, кому то захочется изменить классификацию. Мне, например, захотелось. Я предпочел бы добавить еще два типа:
Но это отступление от стандарта, а стандарта, даже плохого лучше придерживаться.
| | |
| --- | --- |
| | Есть подозрение, что Ж-тип это более правильное название Т-типа, просто американцам не повезло с алфавитом. ;-) |
### I-тип
Самый простой для управления поток I-типа.
Но даже для такого типа существует ряд часто допускаемых ошибок. Наиболее часто допускаемая ошибка это применение «вталкивающих» моделей управления.
Рассмотрим классический пример характерный для IT-индустрии. Возьмем простую, даже тривиальную цепочку «Отдел продаж» -> отдел программирования -> отдел тестирования.
Схема процесса:
Пусть отделы могут обработать соответственно:* Отдел продаж – 20 заказов в неделю
* Отдел программирования – 10 заказов в неделю
* Отдел тестирования – 5 заказов в неделю
К этому добавим систему премирования, зависящую от числа обработанных отделом заказов. Логично, что отдел продаж будет брать **все** заказы, которые могут обработать. Так же логично, что большинство топ-менеджеров будет приказывать брать все заказы. Вот пример дискуссии примерно годовой давности:
*> Бить сейлов по рукам и не давать им набирать проектов более чем успевают делать программисты. Естественно, что перед отделом программирования должен быть небольшой буфер проектов.
Первое, что сделает хоть минимально вменяемый руководитель фирмы, прочитав это — ударит по голове автора, потом выдаст ему Наполеоновскую треуголку и отправит в дурку. Это до какой степени охренения должны дойти программисты, чтобы решать, сколько фирме надо продавать? Я понимаю, что им трудно нарастить выработку до запрошенных продаж, но наличие возможности для продаж — это повод не бить сейлов, а работать над возможностями удовлетворения их запросов.
По-русски: в фирму деньги несут, а некоторые намерены их послать.*
Итог достаточно очевиден. Производственная цепочка очень быстро забьётся выполняемыми заказами и среднее время выполнения заказа возрастет до неприличной величины. Для данного случая всего через полгода среднее время исполнения заказов возрастет до двух лет. Что не слишком конкурентоспособно, но встречается сплошь и рядом.
Балансировка участков по производительности также не приносит счастья. В системе возникают «биения» и среднее время выполнения заказа опять-таки возрастает до неприличных величин.
У Макса Крамаренко в блоге описано моделирование сбалансированной производственной цепочки:* http://maximkr.livejournal.com/18940.html
* http://maximkr.livejournal.com/18971.html
Моделирование показывает, что в результате биений производственная цепочка быстро забивается. В конце эксперимента для короткой цепочки всего из 4 участков в производстве находилось полторы сотни задач. Переводя на «современный менеджерский» это означает, что задача трудоемкостью в четыре человеко-дня будет реализована через полгода. На вопрос менеджера: «Что ж так долго-то?!», — ответ прост: «Потому что так управляете».
| | |
| --- | --- |
| | Это важно. Вина за огромную длительность выполнения заказа почти всегда лежит на системе управления потоком работ (менеджменте), а не на исполнителях.
Ну а кто не верит – может сам попробовать написать имитатор и поэкспериментировать.
Справедливости ради, следует упомянуть, что сбалансированную цепочку вполне можно использовать, если выполнять правило: «Среднее время простоя сотрудников должно быть не менее 20-25%». Но опять же, кто из менеджеров на это пойдет? |
### A-тип и решение Форда
Проблема потока этого типа – недостающие компоненты на сборочных операциях.
Производственная цепочка I-типа примитивна как грабли и незатейлива как молодой редис. Я полагаю что оптимальный способ управления такими цепочками был известен давным-давно, но к сожалению я пока не нашел информации, в каком веке впервые была описана эта методика. Однако, в какой то момент детство заканчивается и перед менеджерами встают по настоящему сложные задачи. С подобным вызовом, наряду с другими столкнулся Генри Форд. В ту пору производство автомобилей на предприятии Форда было производством A-типа. Сложным, со многими ветвями, но имеющим одну вершину. Одна единственная марка автомобиля, один единственный цвет. Отсутствие запаса любой детали на любом участке сборки приводит к увеличению времени производства автомобиля. Но чрезмерный запас деталей также приводит к увеличению времени, которое необходимо, чтобы из железной породы получить готовый автомобиль. Время увеличивается, т.к каждая деталь существенную часть времени проводит в очереди ожидания.
В 1913 году Генри Форд внедрил на своём предприятии конвейерный метод сборки автомобилей. *А к 1926 году производственный цикл от добычи железной руды до получения готового автомобиля (состоящего более чем из 5000 деталей), находящегося на железнодорожной платформе и готового к отправке, достиг 81 часа!.. [1]* Выдающееся достижение. Представьте себе сложность настройки процесса производства ПО, состоящего хотя бы из 50 производственных участков. Полагаю, что большинство современных менеджеров запросило бы сложную АСУ (автоматизированную систему учета) для управления потоком работ. Но в начале века не было компьютеров…
Вопреки расхожему мнению поточная линия Генри Форда это не привычный нам ленточный конвейер, по которому синхронно движутся собираемые автомобили. Это отдельные рабочие центры, с ручной передачей деталей. *«Чтобы улучшить производственный поток, Форд **ограничил пространство, предназначенное для складирования запасов незавершенного производства между каждыми двумя рабочими центрами.** В этом и состоит сущность поточных линий, что подтверждается тем фактом, что первые поточные линии не имели никаких механических устройств, типа конвейеров, для перемещения запасов (незавершенного производства) от одного рабочего центра к другому.» [1].* За неимением компьютеров Форд создал визуальную систему управления работами. Предельно простую в использовании.
Да, естественно, эта система не заработала бы, если бы не было введено дополнительное правило: *«когда выделенное место заполнено, рабочие, которые его заполняют, должны прекратить производство»*. Пойти погулять, вздремнуть, посидеть вКонтакте,…
Форд отказался от одного из основных положений современного ему менеджмента. Впрочем, и сейчас, 99 лет спустя мало что изменилось. Полагаю, приди Форд в типичную российскую фирму на собеседование и озвучь, что неполная загрузка сотрудников является необходимым условием для повышения доходов фирмы, ему сказали бы, что он не умеет управлять реальным производством.
### Более сложные типы и система Тойоты
Проблемы потока V-типа – «кража материала»;
Проблемы потока T-типа — «кража» и недостающие компоненты;
Визуальная модель Форда прекрасно работает для А-типа. Но как только появляется не слияние, но разветвление (один рабочий центр поставляет детали для нескольких центров) начинаются проблемы. Именно эти проблемы ликвидировали преимущество поточных линий Форда в тот момент, когда Дженерал Моторс вышла на рынок с широким модельным рядом. Менеджерам компаний снова был брошен вызов.
Перчатку поднял Таичи Оно, начавший работу в Toyota Motor Corporation в 1943 году. В середине 1950-х годов он начал выстраивать особую систему организации производства, названную впоследствии «Производственная система Toyota» (также ошибочно именуемую канбан, Lean, Just-In-Time).
У Оно, как и у Форда не было АСУ и он разработал визуальную систему управления потоком работ, основанную на канбан (вариант перевода: визуальная карточка). Однако эта система не принесла бы такого эффекта без дополнительных требований. В каждый момент времени на участках, имеющих запас по мощности необходимо делать одно из двух улучшений: или уменьшать размер партии (увеличивать число переключений и сопутствующих им потерь), или уменьшать время переналадки.
*«В то время и до тех пор, пока TPS не получила всемирную известность, традиционным способом снижения времени переналадки считалось увеличение размера партии — «экономически обоснованный размер партии» был очень популярным термином, которому посвящались тысячи статей. Оно отбросил весь этот традиционный опыт.» [1]*
Оно бросил вызов современной ему системе менеджмента. Логично, что ему этого не простили. С конца 40-х до начала 60-х годов его систему называли «отвратительной системой Оно».
Впрочем, и сейчас, спустя шесть десятков лет среди людей называющих себя сторонниками Lean, устранение переключений считается одним из мощнейших методов увеличения прохода. Оно так не считал. Полагаю, приди Таичи Оно на конференцию по бережливому производству и озвучь свои положения, ему бы сказали, что он просто не умеет управлять реальным производством.
### Правила сложения
А далее начинается самое интересное. Если рабочий центр участвует более, чем в одной из цепочек, то эти цепочки необходимо на схеме сложить:
Левый и правый потоки A-типа и могли бы управляться визуальной моделью Форда, но ввиду совместного использования рабочих центров «3» и «4» схема усложняется и нужно переходить к модели Оно. Если же не хочется использовать настолько сложную модель, то следует разделить рабочие центры «3», «4» на «3’», «3”», «4’», «4”»
Понимание применимости моделей управления и их сложности должно оказывать существенное влияние на принятие решения об изменении организационной структуре предприятия и регламентов разработки.
| | |
| --- | --- |
| | Пример. Пусть исторически сложилось так, что в фирме есть четыре разных центра разработки, отвечающих за поддержку четырех разных внутренних продуктов. В какой-то момент при первом центре была создана группа тестирования. Это нововведение оказалось достаточно эффективным и рассматривается вопрос о выделении группы тестирования в отдельный сервис, предоставляющий услуги тестирования всем четырем центрам разработки. За и против?
Против: произойдет изменение типа потока, и возникнут проблемы управляемости. Вместо 4 цепочек I-типа будет одна сложная цепочка:
Если в рабочем центре тестирования будет обеспечен запас по мощности, то преобразование не приведет к негативным последствиям. Но что-то мне подсказывает (весь мой предыдущий опыт), что тестирование станет ограничением системы со всеми вытекающими печальными последствиями. |
| | |
| --- | --- |
| | Пусть исторически сложилось так, что в фирме есть один отдел, отвечающих за поддержку внутренних продуктов и выполняющий доработки для нескольких заказчиков. Возьмем достаточно распространенную структуру «программирование -> тестирование». Простейший, тривиальный I-поток, легкоуправляемый. В какой-то момент времени качество поставки перестало удовлетворять заказчиков и в фирме рассматривается вопрос о введении стадии приемки. За и против?
Против: произойдет изменение типа потока, и возникнут проблемы управляемости. Вместо одной цепочки I-типа будет одна сложная цепочка.
Если поставки доработок организованы в пакеты, общие для всех заказчиков, то один единственный заказчик может блокировать как текущую, так последующие поставки всем остальным. |
К негативным эффектам приводит и матричная система, когда у сотрудника сразу два руководителя: руководитель функционального подразделения и руководитель проекта. Даже Труффальдино плохо справлялся со службой двум господам. А в реальных фирмах на реальных проектах это приводит к фантастическому бардаку и чудовищному увеличению времени ВСЕХ проектов.
| | |
| --- | --- |
| | Отступление. В книжке Лайкера про систему разработки продукции в Toyota написано, что в исследовательских центрах Toyota как раз матричное управление. При чем, к этому они пришли осмысленно и менять этого не хотят. На самом деле у них есть много всяких других хитростей, делающих матрицу работоспособной. Одна из них то, что руководитель проекта является специалистом, обладающим огромным авторитетом у коллег. Как правило, он должен отработать в фирме 10-25 лет. В этом случае он лидер и формальные рычаги управления ему не обязательны. Матрица — это не зло, просто ее приготовить сложно |
Иногда в крупных фирмах идут на жесткое пресечение случаев проявлений «Слуга двух господ». Одним из вариантов, о которых я слышал – это внутренняя биржа труды. Инженер соответствующей специализации находится в структурном подразделении (программист в пуле программистов) и подчиняется менеджеру пула. Подчиняется до тех пор, пока не будет передан в проект. После этого оно подчиняется только руководителю проекта. Отдача прямого распоряжения инженеру, занятому в проекте, кем-то кроме руководителя проекта – это залет, который вполне может закончиться кадровыми перестановками. Фирма немного проседает ввиду неполной занятости сотрудников, но выгоды от простоты управления настолько огромны, что перевешивают эти потери. В дополнение к этому используется принцип «Вассал моего вассала – не мой вассал» — командир взвода не может отдать приказ напрямую солдату. А если отдаст, то будет искать новых сержантов. Или сержанты будут искать нового командира взвода.
### Канбан-доска и морская свинка
Популярный в РФ MSProject неплох для планирования проектов. Для планирования процессов он подходит несколько хуже. Для планирования процессов банальный трекер часто оказывается лучше. Но важно не это. И трекер и Project являются «Информационным холодильниками» (термин введен Алистером Коберном в одной из лучших книг по методологиям «Быстрая разработка программного обеспечения»). Для повышения эффективности разработки нужен «Информационный радиатор». И естественно, нужны правила управления работами.
Тут может сложиться впечатление, что доска — это информационный радиатор. На самом деле модные доски — это те же трекеры, то есть, те же холодильники. Что бы превратить доску в радиатор, нужно ее вешать в общедоступном месте. А как только под доску начинают использовать какой-либо web-инструмент, она тут же становится холодильником. Ну, если ее не выводить на плазму в коридоре или под потолком.
Несколько лет назад было предложено использовать доску, на которую помещаются стикеры с описанием задач. Сейчас это довольно модное увлечение. По запросу «Канбан доска» поисковик выдает массу ссылок на что-то вроде этого:
На рисунке явно изображена визуальная система управления для потоков I-типа. Не имеющая никакого отношения к системе Таичи Оно. Более того эта система более примитивнее чем даже система Генри Форда. Данная «прогрессивная» модель отстает от теории и практики науки управления потоком работ «всего» на 99 лет.
| | |
| --- | --- |
| | Что общего имеют между канбан доской и морской свинкой? Канбан-доска имеет примерно такое же отношение к канбану, как морская свинка к морю. |
Казалось бы, ну назвали неправильно и что? А то, что неправильный термин дает иллюзию всеобщей применимости инструмента. Слишком часто консультанты пытаются применить эту доску для неподходящих типов потоков. Естественно, попытка терпит неудачу, но консультанты почему-то обвиняют исполнителей. «Вы просто неправильно использовали XP / SCRUM / Kanban / …» Господа, если завинчивание гвоздя крестовой отверткой потерпело фиаско, то не стоит винить исполнителя в том, что он держал отвертку неправильно. Нужно просто дать ему молоток.
Рекомендую с опаской и настороженностью относиться к «консультантам» по «XP / SCRUM / Kanban», которые не знают теории производственных потоков. Не то чтобы их совсем нельзя было использовать, но неумение применять теорию потоков, карт Шухарта, неумение складывать вероятности выполнения при существенных девиациях срока исполнения и прочее и прочее должны вас насторожить.
В дальнейшем я буду называть такую доску I-доской.
Что же касается правил управления, то на семинаре Сурен Самарчан (видеокаст: http://spmguild.org/news/618/) говорил, что задачу в производство можно брать, только если кто-то из программистов освободился. Достаточно легко можно понять, что это будет работать, только если ограничение системы (часто ошибочно именуемое именуемое «бутылочным горлышком») находится в начале производственной цепочки (смотри управление колонной туристов в книге «Цель» Голдратта).
Достаточно часто в изолированных маленьких кроссфункциональных группах разработки именно так и происходит. Ограничение находится в начале производственной цепочки. И все идет хорошо. Но как только ограничение системы переходит куда-то еще, … Все finita la comedia. Нужно систему «Немного подшаманить». Максим Дорофеев нашел эмпирическое правило «Число задач в производстве не должно превышать число программистов более, чем на 2». Нормальное такое шаманское правило.
Более интересный тюнинг доски был предложен Олегом (не указал фамилии) в статье «Канбан в IT (Kanban Development)» (http://habrahabr.ru/blogs/development/64997/ ). *А теперь самое важное. Видите цифры под каждым столбцом? Это число задач, которые могут быть одновременно в этих столбцах. Цифры подбираются экспериментально, но считается, что они должны зависеть от числа разработчиков в команде.*
Напоминает поточную линию Форда, но примененную к потоку I-типа. Собственно, это и есть визуализация правила Генри Форда: *«Объем незавершенного производства между двумя рабочими центрами должен быть ограничен».*
Как ни странно, но часто ограничением системы выступает участок приемки задачи заказчиком. Мне известно минимум три фирмы, где наблюдался этот эффект.
Есть еще одно ограничение на использование I-доски. Это ограничение связано с эффективностью цикла на одном производственном участке (у одного исполнителя). Если эффективность цикла менее 50% то правило «у одного исполнителя только одна работа» начинает сбоить.
Примечание. Эффективностью цикла называют отношение времени обработки к общему времени нахождения на производственном участке. Если утром вам пришла задача, а сделали вы ее только перед уходом, то общее время – 8 часов. Если вы работали над задачей 2 часа, то эффективность цикла 25%.
Приведу примеры, когда ограничение в одну задачу у исполнителя в единицу времени будет неэффективным:* Полицейские проекты (www.toc-center.ru/politseiskie\_proekty.html )
* Написание ТЗ и ПМИ (ГОСТ 34.602 и 34.603). Документы сильно влияют друг друга и иногда проще писать одновременно два документа.
* Приготовление праздничного ужина. Поставленный вариться бульон требует участия человека во время варки от силы на пару минут. В это время вполне можно заняться приготовлением салатов. Если бы хозяйка готовила праздничный рождественский обед по системе Сурена Самарчана, то гости остались бы голодными. Просто там система неприменима.
* Часто в эту категорию попадают заявки, отправленные в службу техподдержки. Например, заявки требующие закупок часто имеют длительный период приостановки, во время которого сотрудник может заняться чем-то еще.
Если это случилось подтюньте правила использования. Разрешите исполнителю работать одновременно над несколькими задачами.
И еще одно ограничение. I-доска плохо визуализирует связи между задачами. Она неплохо подходит для процессов сопровождения с независимыми задачами и хуже для проектов. Хотя для коротких проектов со слабо связанными задачами может быть и подойдет.
Тем не менее, такая доска очень проста в использовании и если подразделение подходит для внедрения, то это один из эффективнейших способов управления потоками. Все таки и систему Форда и систему Оно достаточно сложно визуализировать.
Просто перед внедрением такой доски нужно пройтись по чеклисту:* Поток I-типа? Если нет, то скорее всего придется отказаться от попыток внедрения простой доски.
* Ограничение находится в начале цепочки?Если нет, то позаботьтесь о питающем буфере. Придумайте подшаманивающее правило.
* Эффективность цикла на одном производственном участке более 50%?Если нет, то снимите ограничение на обработку только одной задачи одновременно.
* Поступающие заказы связаны между собой или могут выполняться изолированно?Если связаны, то вам нужно что-то другое для визуализации. Возможно, придется перейти на рисование сетевого графика. Возможно еще что-то.
Часто камнем преткновения становится поток сложного типа. Для упрощения типа потока действенным лекарством является выделение и изоляция отдельных проектных групп и функциональных подразделений.
Но, слишком часто мы слышим фразы: «Мы не можем его не дергать. Кроме него этого никто сделать не может. И полностью перевести его к нам нельзя. Нам он нужен всего на четыре часа в неделю.»
Выход лежит в устранении эффекта незаменимости. Пойдет и XP-шное совместное владение кодом, и введение стандартов кодирования и обучение смежным специальностям (одно из экзотических сочетаний, которое нам сильно помогло в одном из проектов это «системный администратор» и «компьютерный художник» в одном лице).
От разделения фирмы на изолированные группы можно получать выгоду тем большую, чем более кроссфункциональны специалисты.
В одной из фирм вы всерьез обсуждали целесообразность приема в группу разработки системного администратора, а в группу системного администрирования программиста.Коллеги утверждают, что это правило, внедренное в порядке эксперимента показало неплохой результат.
Андрей Орлов в «Записках автоматизатора» предложил простое эмпирическое правило: «Если программист стал незаменимым, немедленно увольте его».
Предложение вполне имеет смысл. Незаменимый сотрудник вполне может иметь высочайшую локальную производительность, но его незаменимость слишком сильно дестабилизирует поток.
Другим вариантом является уменьшение длины потока. Уменьшение числа рабочих центров способно кардинально изменить картину.
Любопытная задача, основанная на наблюдениях за реальными процессами в реальных фирмах.
`Возьмем два потенциально интересных проекта. Оба они будучи выполненными прямо сейчас приносили бы по $2 000 каждый месяц в течении полутора лет (от момента сейчас). Потом рынок изменится и прибыль исчезнет. Соответственно, чем позднее окажется дата завершения проекта, тем меньше денег удастся получить.Будем считать, что человеконеделя трудозатрат стоит фирме $2 000Первый проект может быть реализован в рамках одного департамента по единым руководством по схеме:Двухнедельный цикл разработки в группе программирования + двухнедельный цикл тестирования и отладки совместно группами тестирования и программирования.Циклы жестко связаны, временного зазора нет. Чистое время реализации – 4 недели, трудозатраты – 6 человеконедель, расходы - $12 000Второй проект предполагает участие сотрудников 4 разных отделов, по неделе каждый. Параллельно запускать нельзя, только последовательно. Чистое время реализации – 4 недели, трудозатраты – 4 человеконедели, расходы - $8 000.Вопрос: «Каковы ROI проектов?»Совершенно неправильный ответ:Для первого проекта доход: 18*2000 = $36000…Дальше можно не продолжать, потому как вменяемому менеджеру, который знает теорию, известно, что проекты мгновенно не делаются.Просто неправильный ответ:Первый проект будет закончен через 1 месяц, итого доход (18-1)*…Дальше можно не продолжать, потому как вменяемому менеджеру, который знает не только теорию, но и жизнь, известно, что проекты мгновенно не начинаются.…Правильный ответ:Первый проект не может быть выполнен за месяц. Разве что прилетят инопланетяне и «соберут урожай». И невозможно это потому что очередь на реализацию длинная и забита «Задачами, которые давно обещали», «Задачами, которые поставил Сам» и «Просто важными задачами». Реальное время до финиша - месяца четыре. Вот теперь можно считать. Доход – (18-4)*2 000 = 28 000, прибыль – 28 000-12 000=16 000, ROI=133%.Второй проект продлится год. Еще раз. Год. И это в лучшем случае. Если за это время ничего не изменится и проект не заморозят. Большую часть времени проект проведет в очередях ожидания. Да, это реальные наблюдения за реальными проектами в реальной фирме. Доход (18-12)*2000 = 12 000. Прибыль – 4 000, ROI – 50%У второго проекта меньшее ROI, и несравненно более высокие риски. От второго проекта я рекомендовал бы отказаться, в пользу первого.`
Из наблюдений: Цепочки из пяти – шести рабочих центров не связанных жестким общим руководством, часто, делают бессмысленным запуск проекта в производство. Он станет ненужным раньше, чем его завершат.Относительно стабильны цепочки с двумя рабочими центрами. С тремя уже возникают проблемы. Цепочка 1->2->1, предположительно, более стабильна, чем 1->2->3.
Уменьшайте число рабочих центров в потоке создания ценности. Идите даже на увеличение прямых затрат. Стабилизация потока и уменьшение среднего времени выполнения заказа с лихвой покроет эти затраты.
Можете отказаться от выделенного аналитика – откажитесь. Можете отказаться от выделенного тестировщика – откажитесь. Если не можешь отказаться ни от выделенного тестирования, ни от выделенного анализа, попробуй объединить роли тестировщика и системного аналитика в одном лице.
### А если и система Оно не применима?
Тогда нужно переходить на полноценную TOC. А в качестве визуализации системы управления работами я хочу попробовать систему изменения приоритета, предложенную Голдраттом в статье «Стоя на плечах гигантов». Только вот как ее реализовать в «металле»? Интересная задача для системного аналитика: «Понять идею, выбрать движок и написать постановку на кастомизацию». Чутье подсказывает, что в качестве движка вполне можно взять трекинговую систему middle уровня. TrackStudio может подойти.
### Вместо послесловия
И постарайтесь не перепутать тип производственного потока вашей группы. Лечение диареи или запора достаточно простое. Но если перепутать лекарства, то результат вас может несколько удивить.
Если перепутаете тип потока и попробуете применить I-доску для потока T-типа, то результат, возможно, удивит вас меньше, но последствия для фирмы будут существенно хуже, чем если бы вы перепутали лекарство при диарее. | https://habr.com/ru/post/139194/ | null | ru | null |
# Алло! Это FreeSWITCH? Тогда мы проверим вас
По просьбам наших читателей для проверки с помощью PVS-Studio был взят проект с открытым исходным кодом FreeSWITCH. Первоначально он был основан разработчиками проекта, Asterisk, который мы уже проверяли. Проект FreeSWITCH активно разрабатывается и содержит много интересных предупреждений анализатора, которые будут описаны в статье.
Введение
--------
[FreeSWITCH](https://freeswitch.org/) — открытая телефонная платформа, распространяемая в исходных кодах, созданная для удовлетворения потребности в управляемых голосом или текстом системах, масштабируемых от софтфонa до софтсвичa. FreeSWITCH может быть использован в качестве коммутатора, АТС, медиа шлюза или медиа сервера для приложений IVR, использующих простые или XML скрипты для управления алгоритмом обработки звонка.
С помощью анализатора [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) 5.29 проект FreeSWITCH был с лёгкостью проверен в Visual Studio 2015.
If (bug) then find\_copy\_paste();
----------------------------------
[V593](http://www.viva64.com/ru/d/0197/) Consider reviewing the expression of the 'A = B != C' kind. The expression is calculated as following: 'A = (B != C)'. switch\_channel.c 493
```
typedef enum {
SWITCH_STATUS_SUCCESS,
SWITCH_STATUS_FALSE,
SWITCH_STATUS_TIMEOUT,
SWITCH_STATUS_RESTART,
....
} switch_status_t;
SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf(....)
{
....
switch_status_t status;
....
if ((status = switch_core_session_recv_dtmf(channel->session,
dtmf) != SWITCH_STATUS_SUCCESS)) {
goto done;
}
....
}
```
Источником логических ошибок в программе может являться неправильно написанное условие. Например, в этом фрагменте кода приоритет оператора сравнения выше приоритета оператора присваивания. Таким образом, в 'status' сохраняется результат логической операции, а не результат функции switch\_core\_session\_recv\_dtmf(). В коде присутствуют оператор перехода goto, поэтому испорченное значение переменной 'status' в дальнейшем может использоваться где угодно.
К сожалению, таких мест много:* V593 Consider reviewing the expression of the 'A = B != C' kind. The expression is calculated as following: 'A = (B != C)'. switch\_core\_db.c 208
* V593 Consider reviewing the expression of the 'A = B != C' kind. The expression is calculated as following: 'A = (B != C)'. switch\_core\_db.c 211
* V593 Consider reviewing the expression of the 'A = B != C' kind. The expression is calculated as following: 'A = (B != C)'. switch\_core\_db.c 214
* V593 Consider reviewing the expression of the 'A = B != C' kind. The expression is calculated as following: 'A = (B != C)'. switch\_core\_db.c 217
* V593 Consider reviewing the expression of the 'A = B != C' kind. The expression is calculated as following: 'A = (B != C)'. switch\_event.c 2986
* V593 Consider reviewing the expression of the 'A = B != C' kind. The expression is calculated as following: 'A = (B != C)'. switch\_ivr.c 3905
* V593 Consider reviewing the expression of the 'A = B == C' kind. The expression is calculated as following: 'A = (B == C)'. fsodbc.cpp 285
* V593 Consider reviewing the expression of the 'A = B != C' kind. The expression is calculated as following: 'A = (B != C)'. mod\_db.c 653
[V517](http://www.viva64.com/ru/d/0106/) The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 141, 168. mod\_easyroute.c 141
```
static switch_status_t load_config(void)
{
....
if (globals.db_dsn) { //<==
....
} else if (globals.db_dsn) { //<==
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT,
"Cannot Open ODBC Connection (did you enable it?!)\n");
}
....
}
```
В каскаде условий проверяется одна и та же переменная «globals.db\_dsn », поэтому сообщение о неудачном подключении к базе данных не будет залогировано.
[V523](http://www.viva64.com/ru/d/0112/) The 'then' statement is equivalent to the 'else' statement. sofia\_glue.c 552
```
char *sofia_overcome_sip_uri_weakness(....)
{
....
if (strchr(stripped, ';')) {
if (params) {
new_uri = switch_core_session_sprintf(session, "....",
uri_only ? "" : "<", stripped, sofia_glue_transport2str(
transport), params, uri_only ? "" : ">");
} else {
new_uri = switch_core_session_sprintf(session, "....",
uri_only ? "" : "<", stripped, sofia_glue_transport2str(
transport), uri_only ? "" : ">");
}
} else {
if (params) {
new_uri = switch_core_session_sprintf(session, "....",
uri_only ? "" : "<", stripped, sofia_glue_transport2str(
transport), params, uri_only ? "" : ">");
} else {
new_uri = switch_core_session_sprintf(session, "....",
uri_only ? "" : "<", stripped, sofia_glue_transport2str(
transport), uri_only ? "" : ">");
}
}
....
}
```
Большой фрагмент кода, содержащий много идентичного текста. В случае отсутствия ошибки этот фрагмент кода можно сократить в два раза, иначе здесь очередной забытый copy-paste.
[V590](http://www.viva64.com/ru/d/0194/) Consider inspecting the '\* data == ' ' && \* data != '\0'' expression. The expression is excessive or contains a misprint. mod\_curl.c 306
```
static char *print_json(switch_memory_pool_t *pool, ....)
{
....
while (*data == ' ' && *data != '\0') {
data++;
}
....
}
```
Здесь ошибки нет, но выражение избыточно, что может затруднять чтение кода. Проверка " \*data != '\0' " не имеет смысла. Сокращенный вариант кода:
```
while (*data == ' ') {
data++;
```
[V646](http://www.viva64.com/ru/d/0265/) Consider inspecting the application's logic. It's possible that 'else' keyword is missing. conference\_api.c 1532
```
switch_status_t conference_api_sub_vid_logo_img(....)
{
....
if (!strcasecmp(text, "allclear")) {
switch_channel_set_variable(member->channel, "....", NULL);
member->video_logo = NULL;
} if (!strcasecmp(text, "clear")) { //<==
member->video_logo = NULL;
} else {
member->video_logo = switch_core_strdup(member->pool, text);
}
....
}
```
По коду видно, что планировалось написать «else if'. Но видимо случайно пропустили ключевое слово 'else' и это привело к изменению логики программы.
Что-бы понять суть ошибки давайте рассмотрим упрощенный вариант кода. В начале правильный вариант:
```
if (A == 1) {
X();
} else if (A == 2) {
Y();
} else {
Z();
}
```
В зависти от значения переменной A будет вызвана одна из функций: X, Y или Z. Посмотрим, что будет если забыть 'else':
```
if (A == 1) {
X();
} if (A == 2) {
Y();
} else {
Z();
}
```
Теперь если A равно единице, то вызовется не только функция X, но ещё и Z!
Использование типа SOCKET
-------------------------
[V605](http://www.viva64.com/ru/d/0220/) Consider verifying the expression: context->curlfd > — 1. An unsigned value is compared to the number -1. mod\_shout.c 151
```
typedef SOCKET curl_socket_t;
curl_socket_t curlfd;
static inline void free_context(shout_context_t *context)
{
....
if (context->curlfd > -1) {
shutdown(context->curlfd, 2);
context->curlfd = -1;
}
....
}
```
Тип SOCKET является беззнаковым типом, поэтому сравнение с отрицательным числом [недопустимо](https://msdn.microsoft.com/ru-ru/library/windows/desktop/ms740128%28v=vs.85%29.aspx). В данном случае необходимо выполнять сравнение со специальными именованными константами для работы с типом SOCKET, например, SOCKET\_ERROR и т.д.
[V547](http://www.viva64.com/ru/d/0137/) Expression is always false. Unsigned type value is never < 0. esl.c 690
```
typedef SOCKET ws_socket_t;
static ws_socket_t prepare_socket(ips_t *ips)
{
ws_socket_t sock = ws_sock_invalid;
....
if ((sock = socket(family, SOCK_STREAM, IPPROTO_TCP)) < 0) {
die("Socket Error!\n");
}
....
}
```
Похожий пример неправильной работы с переменными типа SOCKET. Это беззнаковый тип, а для проверки статуса ошибки существуют специально определённые константы, например, SOCKET\_ERROR.
Двойные присваивания
--------------------
[V570](http://www.viva64.com/ru/d/0168/) The variable is assigned to itself. skypopen\_protocol.c 1512
```
struct SkypopenHandles {
HWND win32_hInit_MainWindowHandle;
HWND win32_hGlobal_SkypeAPIWindowHandle;
....
};
LRESULT APIENTRY skypopen_present(...., WPARAM uiParam, ....)
{
....
if (!tech_pvt->SkypopenHandles.currentuserhandle) {
tech_pvt->SkypopenHandles.api_connected = 1;
tech_pvt->SkypopenHandles.win32_hGlobal_SkypeAPIWindowHandle =
(HWND) uiParam;
tech_pvt->SkypopenHandles.win32_hGlobal_SkypeAPIWindowHandle =
tech_pvt->SkypopenHandles.win32_hGlobal_SkypeAPIWindowHandle;
}
....
}
```
Анализатор обнаружил, что переменная присваивается сама себе. Можно предположить, что во время написания кода, во втором присваивании было случайно выбрано не то поле структуры: „win32\_hGlobal\_SkypeAPIWindowHandle“ вместо „win32\_hInit\_MainWindowHandle“.
Возможно, код функции должен быть таким:
```
if (!tech_pvt->SkypopenHandles.currentuserhandle) {
tech_pvt->SkypopenHandles.api_connected = 1;
tech_pvt->SkypopenHandles.win32_hGlobal_SkypeAPIWindowHandle =
(HWND) uiParam;
tech_pvt->SkypopenHandles. win32_hInit_MainWindowHandle =
tech_pvt->SkypopenHandles.win32_hGlobal_SkypeAPIWindowHandle;
}
```
[V519](http://www.viva64.com/ru/d/0108/) The 'status' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 365, 368. fscoredb.cpp 368
```
JS_COREDB_FUNCTION_IMPL(BindInt)
{
bool status;
....
/* convert args */
status = !info[0].IsEmpty() && info[0]->IsInt32() ? true:false;
param_index = info[0]->Int32Value();
status = !info[1].IsEmpty() && info[1]->IsInt32() ? true:false;
param_value = info[1]->Int32Value();
if (param_index < 1) {
info.GetIsolate()->ThrowException(....);
return;
}
....
}
```
Анализатор обнаружил потенциально возможную ошибку, связанную с тем, что одной и той же переменной дважды подряд присваивается значение. Причем между этими присваиваниями сама переменная не используется. С помощью анализатора удалось найти пропущенную проверку: значение переменной 'status' нигде не используется.
Возможно, код должен быть таким:
```
....
param_index = status ? info[0]->Int32Value() : 0;
....
param_value = status ? info[1]->Int32Value() : 0;
```
[V519](http://www.viva64.com/ru/d/0108/) The 'status' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1239, 1240. switch\_core\_io.c 1240
```
SWITCH_DECLARE(switch_status_t)
switch_core_session_write_frame(...., int stream_id)
{
....
if (ptime_mismatch && status != SWITCH_STATUS_GENERR) {
status = perform_write(session, frame, flags, stream_id);
status = SWITCH_STATUS_SUCCESS;
goto error;
}
....
}
```
Почему здесь статус записи просто перезаписывают на успешный не понятно. Оставим изучение этого фрагмента авторам кода.
Ошибки в строках
----------------
[V694](http://www.viva64.com/ru/d/0330/) The condition (mode + 5) is only false if there is pointer overflow which is undefined behaviour anyway. mod\_ilbc.c 51
```
static switch_status_t switch_ilbc_fmtp_parse(....)
{
....
if (fmtp && (mode = strstr(fmtp, "mode=")) && (mode + 5)) {
codec_ms = atoi(mode + 5);
}
if (!codec_ms) {
/* default to 30 when no mode is defined for ilbc ONLY */
codec_ms = 30;
}
....
}
```
На первый взгляд здесь реализован простой алгоритм:1. Найти подстроку „mode=“;
2. Убедиться, что после подстроки не стоит нулевой символ;
3. Конвертировать следующий символ в число.
Ошибка кроется в этапе N2: убедившись, что указатель 'mode' на подстроку ненулевой, в коде смещают указатель на 5 символов, но он так и останется ненулевым. В операции (mode + 5) пропущено разыменование смещённого указателя. Из-за такой ошибки стали возможны ситуации, когда символ завершения строки конвертируют в число и получают значение ноль. Благодаря проверке „if (!codec\_ms) { codec\_ms = 30;}“ нулевое значение всегда сбрасывается на значение по умолчанию.
[V519](http://www.viva64.com/ru/d/0108/) The '\* e' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1438, 1439. switch\_xml.c 1439
```
static int preprocess(....)
{
....
if ((e = strstr(tcmd, "/>"))) {
*e += 2;
*e = '\0';
if (fwrite(e, 1, (unsigned) strlen(e),
write_fd) != (int) strlen(e)) {
switch_log_printf(....);
}
}
....
}
```
А в этом месте возникает ошибка как в предыдущем примере, только наоборот. Здесь в случае нахождения подстроки планируют сместить указатель и записать символ конца строки, но в операции „\*e += 2“ изменяется не указатель, а код символа, на который он указывает. Потом в этот символ просто записывается терминальный ноль.
Правильный код выглядит так:
```
if ((e = strstr(tcmd, "/>"))) {
e += 2;
*e = '\0';
....
}
```
[V600](http://www.viva64.com/ru/d/0211/) Consider inspecting the condition. The 'name' pointer is always not equal to NULL. fsodbc.cpp 323
```
JS_ODBC_FUNCTION_IMPL(GetData)
{
....
SQLCHAR name[1024] = ""; //<==
SQLCHAR *data = _colbuf;
SQLLEN pcbValue;
SQLDescribeCol(_stmt, x, name, sizeof(name), ....); //<==
SQLGetData(_stmt, x, SQL_C_CHAR, _colbuf, _cblen, &pcbValue);
if (name) { //<==
if (SQL_NULL_DATA == pcbValue) {
arg->Set(String::NewFromUtf8(GetIsolate(),
(const char *)name), Null(info.GetIsolate()));
} else {
arg->Set(String::NewFromUtf8(GetIsolate(),
(const char *)name), String::NewFromUtf8(GetIsolate(),
data ? (const char *)data : ""));
}
}
....
}
```
В этой функции выделяется память на стеке для массива символов „name“. В начало записывается нулевой символ и с массивом выполняются какие-то действия. В условии „if (name) {....} хотели проверить, осталась ли строка пустой (признаком является нулевой символ в начале строки). Но из-за пропущенного символа разыменования указателя, проверяют значение указателя, который всегда не равен нулю.
[V595](http://www.viva64.com/ru/d/0205/) The 'val' pointer was utilized before it was verified against nullptr. Check lines: 2496, 2499. switch\_ivr.c 2496
```
static int
switch_ivr_set_xml_chan_var(...., const char *val, int off)
{
char *data;
switch_size_t dlen = strlen(val) * 3 + 1; //<==
switch_xml_t variable;
if (!val) val = ""; //<==
....
}
```
В функцию может прийти нулевой указатель на массив символов “val», о чём свидетельствует наличие проверки. Но до этого такой указатель будет передан в функцию «strlen()» для вычисления длины строки, где выполнится разыменование нулевого указателя.
Опасные указатели
-----------------
[V713](http://www.viva64.com/ru/d/0354/) The pointer codec->cur\_frame was utilized in the logical expression before it was verified against nullptr in the same logical expression. mod\_opus.c 631
```
static switch_status_t
switch_opus_decode(switch_codec_t *codec, ....)
{
....
if (opus_packet_get_bandwidth(codec->cur_frame->data) != //<==
OPUS_BANDWIDTH_FULLBAND && codec->cur_frame && //<==
(jb = switch_core_session_get_jb(....))) {
....
}
....
}
```
Было непросто, но анализатор нашёл потенциальное разыменование нулевого указателя. Проблема из-за неправильного порядка логических выражений в условии. Сначала используется переменная «codec->cur\_frame->data», а потом выполняется проверка указателя «codec->cur\_frame» на равенство нулю.
[V595](http://www.viva64.com/ru/d/0205/) The 'a\_engine' pointer was utilized before it was verified against nullptr. Check lines: 6024, 6052. switch\_core\_media.c 6024
```
SWITCH_DECLARE(switch_status_t)
switch_core_media_activate_rtp(switch_core_session_t *session)
{
....
switch_port_t remote_rtcp_port = a_engine->remote_rtcp_port;
....
if (session && a_engine) {
check_dtls_reinvite(session, a_engine);
}
....
}
```
В отличии от диагностики [V713](http://www.viva64.com/ru/d/0354/), диагностика V595 ищет потенциальное разыменование нулевого указателя в пределах всех функции. Обратите внимание, как используется указатель «a\_engine».
Ещё список опасных мест:* V595 The 'session' pointer was utilized before it was verified against nullptr. Check lines: 6027, 6052. switch\_core\_media.c 6027
* V595 The 'session' pointer was utilized before it was verified against nullptr. Check lines: 6689, 6696. switch\_core\_media.c 6689
* V595 The 'v\_engine' pointer was utilized before it was verified against nullptr. Check lines: 6677, 6696. switch\_core\_media.c 6677
* V595 The 'stream.data' pointer was utilized before it was verified against nullptr. Check lines: 2409, 2411. switch\_event.c 2409
* V595 The 'stack' pointer was utilized before it was verified against nullptr. Check lines: 461, 466. switch\_ivr\_menu.c 461
* V595 The 'smin' pointer was utilized before it was verified against nullptr. Check lines: 3269, 3277. switch\_utils.c 3269
* V595 The 'key' pointer was utilized before it was verified against nullptr. Check lines: 111, 124. switch\_xml.c 111
[V547](http://www.viva64.com/ru/d/0137/) Expression 'fftstate->Perm == ((void \*) 0)' is always false. Pointer 'fftstate->Perm' != NULL. fft.c 339
```
typedef struct {
unsigned int SpaceAlloced;
unsigned int MaxPermAlloced;
double Tmp0[MAXFFTSIZE];
double Tmp1[MAXFFTSIZE];
double Tmp2[MAXFFTSIZE];
double Tmp3[MAXFFTSIZE];
int Perm[MAXFFTSIZE];
int factor [NFACTOR];
} FFTstr;
static int FFTRADIX (...., FFTstr *fftstate)
{
....
if (fftstate->Tmp0 == NULL || fftstate->Tmp1 == NULL ||
fftstate->Tmp2 == NULL || fftstate->Tmp3 == NULL ||
fftstate->Perm == NULL) {
return -1;
}
....
}
```
В коде присутствует большое, но бессмысленное условие, в котором проверяются адреса 5 массивов, являющихся членами класса FFTstr. При этом не важно, на стеке создан объект класса или в куче. Адреса массивов всегда будут отличаться он нуля. Даже если указатель 'fftstate' будет равен 0, всё равно проверки не имеют смысла, так члены Tmp0..Tmp3 имеют смещение относительно начала структуры.
Двойная защита
--------------
[V530](http://www.viva64.com/ru/d/0119/) The return value of function 'LoadLibraryExA' is required to be utilized. switch\_dso.c 42
[V581](http://www.viva64.com/ru/d/0183/) The conditional expressions of the 'if' operators situated alongside each other are identical. Check lines: 41, 45. switch\_dso.c 45
```
SWITCH_DECLARE(switch_dso_lib_t) switch_dso_open(....)
{
HINSTANCE lib;
lib = LoadLibraryEx(path, NULL, 0);
if (!lib) {
LoadLibraryEx(path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
}
if (!lib) {
DWORD error = GetLastError();
*err = switch_mprintf("dll open error [%ul]\n", error);
}
return lib;
}
```
На этом фрагменте кода возникла интересная ситуация, когда в одном месте сработали 2 разные диагностики анализатора. В V530 говорится, что у функции «LoadLibraryEx()» не используется возвращаемое значение, а в V581 говорится, что присутствуют 2 проверки с одинаковым логическим выражением.
Первая проверка дескриптора «lib» проверяет загрузку модуля функцией «LoadLibraryEx()», если дескриптор нулевой, то надо попробовать загрузить модуль ещё раз. В этот момент забывают перезаписать дескриптор 'lib' новым значением, возвращаемым функцией и при второй проверке дескриптор всё равно остаётся нулевым.
Правильный фрагмент кода:
```
lib = LoadLibraryEx(path, NULL, 0);
if (!lib) {
lib = LoadLibraryEx(path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
}
```
Про память
----------
[V597](http://www.viva64.com/ru/d/0208/) The compiler could delete the 'memset' function call, which is used to flush 'corrSurfBuff' buffer. The RtlSecureZeroMemory() function should be used to erase the private data. pitch\_estimator.c 158
```
void WebRtcIsac_InitializePitch(const double *in,
const double old_lag,
const double old_gain,
PitchAnalysisStruct *State,
double *lags)
{
....
for(k = 0; k < 2*PITCH_BW+3; k++)
{
CorrSurf[k] = &corrSurfBuff[10 + k * (PITCH_LAG_SPAN2+4)];
}
/* reset CorrSurf matrix */
memset(corrSurfBuff, 0, sizeof(double) * (10 + (2*PITCH_BW+3)
* (PITCH_LAG_SPAN2+4)));
....
}
```
Приведенный код может оставить матрицу неочищенной. Обратите внимание, что массив «corrSurfBuff» очищается в конце и более не используется. Поэтому при сборке Release версии программы, компилятор, скорее всего, удалит вызов функции memset(). На это компилятор имеет полное право. Анализатор предлагает использовать функцию RtlSecureZeroMemory() для Windows, но так как проект кроссплатформенный, следует найти ещё способ, чтобы избежать оптимизации других компиляторов.
Примечание. Это не паранойя. Компилятор действительно удаляет такие вызовы функций. Познакомьтесь с описанием диагностики V597, чтобы понять всю глубину кроличьей дыры. Для неверующих даже приводится ассемблерный листинг. Это серьезная и к сожалению очень распространенная ошибка безопасности.
[V701](http://www.viva64.com/ru/d/0340/) realloc() possible leak: when realloc() fails in allocating memory, original pointer 'abuf' is lost. Consider assigning realloc() to a temporary pointer. switch\_ivr\_play\_say.c 1535
```
SWITCH_DECLARE(switch_status_t) switch_ivr_play_file(....)
{
....
if (buflen > write_frame.buflen) {
abuf = realloc(abuf, buflen);
write_frame.data = abuf;
write_frame.buflen = buflen;
}
....
}
```
Данный код является потенциально опасным: рекомендуется результат функции realloc() сохранять в другой переменной. Функция realloc() производит изменение размера некоторого блока памяти. В случае, если изменение размера блока памяти в данный момент невозможно, функция вернёт нулевой указатель. Главная проблема заключается в том, что при использовании конструкции вида «ptr = realloc(ptr, ...)» указатель ptr на этот блок данных может быть утерян.
Ещё такие места:* V701 realloc() possible leak: when realloc() fails in allocating memory, original pointer 'buf' is lost. Consider assigning realloc() to a temporary pointer. switch\_event.c 1556
* V701 realloc() possible leak: when realloc() fails in allocating memory, original pointer 'buf' is lost. Consider assigning realloc() to a temporary pointer. switch\_event.c 1582
Остальные предупреждения
------------------------
[V665](http://www.viva64.com/ru/d/0290/) Possibly, the usage of '#pragma warning(default: X)' is incorrect in this context. The '#pragma warning(push/pop)' should be used instead. Check lines: 802, 837. switch\_utils.h 837
```
#ifdef _MSC_VER
#pragma warning(disable:6011)
#endif
static inline char *switch_lc_strdup(const char *it)
{
....
}
static inline char *switch_uc_strdup(const char *it)
{
....
}
#ifdef _MSC_VER
#pragma warning(default:6011)
#endif
```
Программисты часто считают, что после директивы «pragma warning(default: X)» опять начнут действовать предупреждения, отключенные ранее помощью «pragma warning(disable: X)». Это не так. Директива 'pragma warning(default: X)' устанавливает предупреждение с номером 'X' в состояние, которое действует ПО УМОЛЧАНИЮ. Это далеко не одно и то же.
Корректный вариант кода:
```
#pragma warning(push)
#pragma warning(disable: 6011)
....
// Correct code triggering the 6011 warning
....
#pragma warning(pop)
```
[V555](http://www.viva64.com/ru/d/0146/) The expression 'parser->maxlen — parser->minlen > 0' will work as 'parser->maxlen != parser->minlen'. switch\_ivr.c 2342
```
typedef uintptr_t switch_size_t;
switch_size_t maxlen;
switch_size_t buflen;
switch_size_t minlen;
SWITCH_DECLARE(void *) switch_ivr_digit_stream_parser_feed(....)
{
....
if (parser->maxlen - parser->minlen > 0 && ....) {
len = 0;
}
....
}
```
Разность беззнаковых чисел всегда больше нуля, если они не равны. Так здесь ошибка или имели ввиду проверку 'parser->maxlen != parser->minlen'?
[V612](http://www.viva64.com/ru/d/0228/) An unconditional 'goto' within a loop. mod\_verto.c 112
```
static void json_cleanup(void)
{
....
top:
for (hi = switch_core_hash_first_iter(....); hi;) {
switch_core_hash_this(hi, &var, NULL, &val);
json = (cJSON *) val;
cJSON_Delete(json);
switch_core_hash_delete(json_GLOBALS.store_hash, var);
goto top;
}
switch_safe_free(hi);
switch_mutex_unlock(json_GLOBALS.store_mutex);
}
```
В исходном коде проекта в нескольких местах используют операторы безусловного перехода, это затрудняет читаемость и поддержку кода, особенно при использовании в циклах.
Ещё несколько мест:* V612 An unconditional 'break' within a loop. mod\_event\_socket.c 1643
* V612 An unconditional 'goto' within a loop. mod\_verto.c 328
* V612 An unconditional 'break' within a loop. mod\_verto.c 1993
[V652](http://www.viva64.com/ru/d/0272/) The '!' operation is executed 3 or more times in succession. mod\_verto.c 3032
```
static switch_bool_t verto__modify_func(....)
{
....
switch_core_media_toggle_hold(session,
!!!switch_channel_test_flag(tech_pvt->channel, ....));
....
}
```
Непонятное место с использованием целых трёх операторов отрицания, возможно, имеет место опечатка.
[V567](http://www.viva64.com/ru/d/0162/) Unspecified behavior. The order of argument evaluation is not defined for 'strtol' function. Consider inspecting the 'exp' variable. switch\_utils.c 3759
```
SWITCH_DECLARE(int) switch_number_cmp(const char *exp, int val)
{
for (;; ++exp) {
int a = strtol(exp, (char **)&exp, 10);
if (*exp != '-') {
if (a == val)
return 1;
} else {
int b = strtol(++exp, (char **)&exp, 10); //<==
....
}
if (*exp != ',')
return 0;
}
}
```
Неизвестно, будет сначала изменён указатель 'exp' или взят его адрес. Соответственно, правильно работает выражение или нет, зависит от везения.
[V621](http://www.viva64.com/ru/d/0238/) Consider inspecting the 'for' operator. It's possible that the loop will be executed incorrectly or won't be executed at all. switch\_core.c 3014
```
SWITCH_DECLARE(int) switch_max_file_desc(void)
{
int max = 0; //<==
#ifndef WIN32
#if defined(HAVE_GETDTABLESIZE)
max = getdtablesize();
#else
max = sysconf(_SC_OPEN_MAX);
#endif
#endif
return max;
}
SWITCH_DECLARE(void) switch_close_extra_files(....)
{
int open_max = switch_max_file_desc();
int i, j;
for (i = 3; i < open_max; i++) { //<==
....
close(i);
skip:
continue;
}
}
```
Неизвестно, ошибка это или нет, но анализатор нашёл код-заглушку для Windows в функции «switch\_max\_file\_desc()». Если эта функция всегда возвращает ноль в Windows, то цикл после её вызова никогда не выполняется.
Заключение
----------
В статье я рассказал о самых подозрительных на мой взгляд участках кода проекта FreeSWITCH, найденных с помощью статического анализатора PVS-Studio. Это ещё один проект, связанный с компьютерной телефонией, как когда-то мною был проверен похожий проект [Asterisk](http://www.viva64.com/ru/b/0276/). Проект FreeSWITCH довольно больший и анализатором было выдано много интересных предупреждений, хотя предупреждений на используемые библиотеки в этом проекте было ещё больше, но это уже совсем другая история. До публикации статьи разработчики уже были уведомлены о проверке их проекта и получили полный отчёт анализатора. Поэтому какие-то участки кода могут быть исправлены.
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Svyatoslav Razmyslov. [Hello, Is That FreeSWITCH? Then We're Coming to Check You!](http://www.viva64.com/en/b/0351/).
[](http://www.viva64.com/en/b/0351/)
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/268603/ | null | ru | null |
# К статье о приближениях
[Часть I](https://habr.com/ru/post/419237/)
[Часть II](https://habr.com/ru/post/442330/)
*В данной статье рассматривается метод оценок диапазона принимаемых значений и связь этого метода с задачами, содержащими модуль.*
---
При решении некоторых задач необходимо рассматривать диапазон, в пределах которого может находиться искомая величина.
Рассмотрим **метод оценок** при решении неравенств.
Дать оценку сверху означает определить максимальное значение, которое может принимать искомая величина.
Предположим, что цена за одну единицу товара может колебаться в пределах от **5** до **10** RUB. Для двух единиц товара оценка сверху составляет **10+10=20** RUB, оценка снизу **5+5=10** RUB.
Рассмотрим задачу из *задачника профильной направленности* М.И. Башмакова
37. Известны оценки для переменных  и 
Дайте оценки *сверху* для следующих выражений:
1. 
2. 
5. 
6. 
8. 
9. 
**Указание к решению задач**
Для оценки этих значений необходимо воспользоваться следующим свойством числовых неравенств:
Если  и оба числа положительны, то 
Если  и оба числа положительны, то 
При умножении членов неравенства на одно и то же положительное число смысл неравенства не меняется, при умножении членов неравенства на одно и то же отрицательное число смысл неравенства меняется на противоположный.
Доказательство (Элементарная математика).
Пусть , тогда . Если , то , так как произведение положительных чисел положительно. Раскрыв скобки в левой части последнего неравенства, получим , т.е. . Аналогичным образом рассматривается случай .
Точно такой же вывод можно сделать и относительно деления частей неравенства на какое-либо отличное от нуля число, так как деление на число  равносильно умножению на число , а числа  и  имеют одинаковые знаки.
Вообще, анализ бесконечно малых величин использует критерий оценки. А модуль (как окрестность) присутствует в самом определении предела последовательности.
> Последовательность {a } называется сходящейся к числу *a*, если для любого  найдётся такое число N (зависящее от ), что при  выполняется неравенство 
>
>
Определение эпсилон-окресности на примере радиоактивонго распада приводится в учебнике «Математический анализ. Учебное пособие для IX — X классов»
> **Процесс радиоактивного распада.** Часто встречаются последовательности, которые «устанавливаются» лишь приближенно—все члены этих последовательностей, начиная с некоторого номера, весьма мало отличаются от некоторого числа *a*.
>
> Рассмотрим процесс радиоактивного распада. Предположим, что мы взяли кусок радиоактивного вещества весом в 1024 г, причем за одни сутки вес вещества уменьшается в результате распада вдвое. Будем взвешивать наш кусок на весах, чувствительность которых равна 10 г. Вес вещества (если измерения производятся каждые сутки) дает последовательность
>
> 
>
>
>
> Ясно, что по истечении 7 суток, когда вещества осталось 8 г, весы с чувствительностью 10 г не дадут нам возможности отличить истинное положение вещей (наличие 8 г вещества) от полного отсутствия данного вещества.
>
> Возьмем более точные весы, имеющие чувствительность в 1 г. Эти весы покажут, что после 7 суток вещество еще осталось. Но после 11 суток (когда вещества остается  г) и с их помощью не удается выяснить, есть еще вещество или нет. А весы с чувствительностью в 0,1 г покажут отсутствие вещества лишь по истечении 14 суток (когда на самом деле его останется  г). И какой бы чувствительности весы мы ни взяли, наступит момент, начиная с которого мы не сможем выяснить с их помощью, осталось вещество или нет.
>
> Итак, последовательность чисел (1) обладает следующим свойством: какое бы число  мы ни взяли (то есть какой бы чувствительности весы мы ни взяли), *найдется номер N, начиная с которого члены последовательности отличаются от нуля меньше, чем на* .
>
>
#### Определение бесконечеого ряда
> Пусть задана некоторая бесконечная последовательность чисел:
>
> 
>
>
>
> …
>
> Станем последовательно складывать члены ряда, составляя (в бесконечном количестве) суммы
>
> 
>
>
>
> Их называют частичными суммами ряда.
>
> Конечный или бесконечный предел А частичной суммы при 
>
> 
>
>
>
> называют суммой ряда…
>
> Если в ряде отбросить первые m членов, то получится ряд:
>
> 
>
>
>
> называемый остатком ряда после *m*-ного члена
>
> *Если сходится ряд, то сходится и любой из его остатков; обратно, из сходимости остатка вытекает сходимость исходного ряда.*
>
> …
>
> Положительный ряд всегда имеет сумму; эта сумма будет конечной (и, следовательно, ряд — сходящимся), если частичные суммы ряда ограничены сверху, и бесконечной (а ряд — расходящимся) в противном случае.
>
>
Вернёмся к задаче
38. Вычислить сумму
Ряд  ограничен сверху. К вопросу о верних и нижних оценках вернёмся после.
Отбросим первое слагаемое  и рассчитаем, чему равен остаток ряда после первого члена
**Код**
```
(define series_sum_1
( lambda (n)
(if (= n 0) 0
(+ (/ 1.0 (* (+ n 1.0 )(+ n 2.0))) (series_sum_1(- n 1.0)))
) ) )
(writeln (series_sum_1 10))
(writeln (series_sum_1 100))
(writeln (series_sum_1 1000))
(writeln (series_sum_1 10000))
(writeln (series_sum_1 100000))
(writeln (series_sum_1 1000000))
```
0.41666666666666663
0.49019607843137253
0.4990019960079833
0.4999000199960005
0.49999000019998724
0.4999990000019941
Проверить можно в ideone.com [здесь](https://ideone.com/ZZJ8W7)
**Этот же алгоритм на Python**
```
def series_sum(n):
if n==0:
return 0
else:
return 1.0/((n+1.0)*(n+2.0))+series_sum(n-1.0)
print(series_sum(10))
print(series_sum(100))
```
[Ссылка](https://ideone.com/BEwyP8) на ideone.com
Получим 
Отбросим первое и второе слагаемые и рассмотрим остаток ряда.
**Код**
```
(define series_sum_1
( lambda (n)
(if (= n 0) 0
(+ (/ 1.0 (* (+ n 2.0) (+ n 3.0))) (series_sum_1(- n 1.0)))
) ) )
(series_sum_1 1000000)
```
Получим 0.33333233333632745
*Если ряд сходится, то сумма его остатка после m-го члена с возрастанием m стремится к нулю.*
У нас сумма остатка с возрастанием *m* стремится к нулю.
#### Верхняя и нижняя оценка
Рассмотрим пример из «Курса дифференциального и интегрального исчисления» 363(6)
> Легко установить расходимость ряда
>
> 
>
>
>
> В самом деле, так как члены его убывают, то n-я частичная сумма
>
> 
>
>
>
> и растёт до бесконечности вместе с .
>
>
Для того, чтобы доказать, что  действительно больше , нужно произвести оценку снизу данного выражения. Получим систему неравенств
Произведя сложение всех неравенств данной системы, получим
Следовательно, данный ряд расходится.
Для [гармонического ряда](https://ru.wikipedia.org/wiki/%D0%93%D0%B0%D1%80%D0%BC%D0%BE%D0%BD%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D1%80%D1%8F%D0%B4) этот метод не проходит, потому что -я частичная сумма гармонического ряда
**Подсчитаем сумму гармонического ряда при увеличении n**
```
#lang racket
(define series_sum_1
( lambda (n)
(if (= n 0) 0
(+ (/ 1.0 n) (series_sum_1(- n 1.0)))
) ) )
(series_sum_1 10)
(series_sum_1 100)
(series_sum_1 1000)
(series_sum_1 10000)
(series_sum_1 100000)
(series_sum_1 1000000)
```
Получим:
2.9289682539682538
5.187377517639621
7.485470860550343
9.787606036044348
12.090146129863335
14.392726722864989
Воспользуемся *частичными суммами* для того, чтобы установить, что сумма гармонического ряда неограничена сверху и растёт до бесконечности
> Имеем очевидное неравенство:
>
> 
>
>
>
> Если, отбросив первые два члена, остальные члены гармонического ряда разбить на группы по  членов в каждой
>
> 
>
>
>
> 
>
>
>
> то каждая из этих сумм в отдельности будет больше .
>
> … Мы видим, что частичные суммы не могут быть ограничены сверху: ряд имеет бесконечную сумму.
>
>
Подсчитаем частичные суммы, которые получаются при отбрасывании  слагаемых.
**Рекурсивный алгоритм**
```
#lang racket
(* 1.0 (+ 1/3 1/4))
(* 1.0 (+ 1/5 1/6 1/7 1/8))
(* 1.0 (+ 1/9 1/10 1/11 1/12 1/13 1/14 1/15 1/16))
```
Получаем:
0.5833333333333334
0.6345238095238095
0.6628718503718504
Напишем программу, которая вычисляет сумму гармонического ряда от  до , где  при 
```
#lang racket
(define (Hn n )
(define half_arg (/ n 2.0))
(define (series_sum n)
(if (= n half_arg ) 0
(+ (/ 1.0 n) (series_sum(- n 1)) )
)
)
(series_sum n) )
(Hn 4)
(Hn 8)
(Hn 16)
(Hn 32)
```
Проверить можно в online ide [по ссылке](https://ideone.com/O93bkB)
Получаем:
0.5833333333333333
0.6345238095238095
0.6628718503718504
0.6777662022075267
Для диапазона ![$ \left[ 1+2^{70};2^{71}\right] $](https://habrastorage.org/getpro/habr/formulas/e34/5b7/fd6/e345b7fd6646007b5ede17919bb2d7f2.svg) получаем 0,693147…
Проверить моджно в Wolfram Cloud [здесь](https://www.wolframalpha.com/input/?i=sum+1%2Fn,+n%3D1%2B2%5E70+to+2%5E71).
#### Переполнение стека
Данный рекурсивный алгоритм вызывает быстрое переполнение стека.
В [этой статье](https://habr.com/ru/post/436698/) есть пример вычисления факториала с помощью итеративного алгоритма. Изменим этот итеративный алгоритм так, чтобы он вычислял частичную сумму **Hn** внутри определённых границ; назовём эти границы **a** и **b**
```
(define (Hn a b)
(define (iteration product counter)
(if (> counter b)
product
(iteration (+ product (/ 1.0 counter))
(+ counter 1))))
(iteration 0 a))
```
Нижней границей является число , верхней границей — число 
Напишем функцию, вычисляющую степень двойки
```
(define (power_of_two k)
(define (iteration product counter)
(if (> counter k)
product
(iteration (* product 2)
(+ counter 1))))
(iteration 1 1))
```
Будем в качестве нижней границы подставлять (+ 1 (power\_of\_two k)), а в качестве верхней можно использовать функцию (\* 2 (power\_of\_two k)) или эквивалентную ей функцию (power\_of\_two (+ 1 k))
Перепишем функцию **Hn**
```
(define (Hn k)
(define a (+ 1 (power_of_two k)) )
(define b (* 2 (power_of_two k)) )
(define (iteration product counter)
(if (> counter b)
product
(iteration (+ product (/ 1.0 counter))
(+ counter 1))))
(iteration 0 a ))
```
Теперь можно вычислять **Hn** при больших значениях .
Напишем на языке Си программу, которая замеряет время, необходимое на вычисление **Hn**. Будем использовать функцию [clock()](http://man7.org/linux/man-pages/man3/clock.3.html) из стандартной библиотеки
Статья про измерение процессорного времени есть на Хабре [здесь](https://habr.com/ru/post/282301/).
```
#include
#include
#include
int main(int argc, char \*\*argv)
{
double count;
// k от 1+2^30 до 2^31
for(unsigned long long int i=1073741825 ;i<=2147483648 ;i++)
{
count=count+1.0/i;
}
printf("Hn = %.12f ", count);
double seconds = clock() / (double) CLOCKS\_PER\_SEC;
printf("Программа работала %f сек \n", seconds);
return 0;
}
```
Обычно online ide ограничивают время выполнения запускаемых программ пятью секундами, поэтому эту программу можно проверить лишь в некоторых online ide, например, в [onlinegdb.com](https://www.onlinegdb.com/online_c_compiler) или [repl.it](https://repl.it/languages/c)
При k от 1+2^30 до 2^31 время работы составит ~5 сек.
При k от 1+2^31 до 2^32 время работы составит ~10 сек.
При k от 1+2^32 до 2^33 время работы составит ~20 сек.
При k от 1+2^33 до 2^34 время работы составит ~40 сек.
При k от 1+2^34 до 2^35 время работы составит больше одной минуты.
…
При k от 1+2^45 до 2^46 время работы составит больше 24 часов.
Предположим, что для k от 1+2^30 до 2^31 время выполнения алгоритма составляет ~2 сек.
Тогда для k=2^(30+n) время выполнения алгоритма составляет 2^n сек. (при )
Данный алгоритм имеет [экспотенциальную сложность](https://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C).
Вернёмся к модулям.
В интегральном исчислении модуль используется в формуле
Читайте также [Самый натуральный логарифм](https://habr.com/ru/post/209278/).
Присутствие модуля в формуле  обосновывается далее в «Курсе дифференциального и интегрального исчисления»
> Если… , то дифференцированием легко убедиться в том, что ![$ \left[ ln (-x) \right]' = \frac{1}{x} $](https://habrastorage.org/getpro/habr/formulas/845/890/a7c/845890a7cd43ad5c7bc3b809e02ce003.svg)
>
>
### Физическое приложение интеграла $ \int \frac{dx}{x} $
Этот интеграл используется для вычисления разности потенциалов обкладок цилиндрического конденсатора.
«Электричество и магнетизм»:
> Разность потенциалов между обкладками находим путем интегрирования:
>
> 
>
>
>
> (  и  — радиусы внутренней и внешней обкладок).
>
>
Здесь не используется знак модуля под знаком натурального логарифма , потому что  и  строго положительны и такая форма записи является избыточной.
#### «Модульное» рисование
С помощью модулей можно рисовать различные фигуры.
Если в программе [geogebra](https://www.geogebra.org/graphing) написать формулу **** получим
Можно рисовать более сложные фигуры. Нарисуем, например, «бабочку» в облаке WolframAlpha
Plot[ Sum[abs(x)/(n-abs(x))+abs(x+n)/(n)+abs(x-n)/(n),{n,1,20}], {x,-60,60} ]
В данном выражении *n* лежит в диапазоне от 1 до 20, *x* лежит в диапазоне от -60 до 60.
[Ссылка](https://www.wolframalpha.com/input/?i=Plot%5B+Sum%5Babs%28x%29%2F%28n-abs%28x%29%29%2Babs%28x%2Bn%29%2F%28n%29%2Babs%28x-n%29%2F%28n%29,%7Bn,1,20%7D%5D,+%7Bx,-60,60%7D+%5D) на рисунок.
#### Книги:
«Задачник профильной направленности» М.И. Башмаков
«Элементарная математика» В.В.Зайцев, В.В.Рыжков, М.И.Сканави
«Математический анализ. Учебное пособие для IX — X классов» Виленкин Н.Я., Шварцбурд С.И.
Курс общей физики: в 3-х т. Т. 2. «Электричество и магнетизм» И.В. Савельев | https://habr.com/ru/post/442330/ | null | ru | null |
# Старт работы с Excel на C#
В современном мире разработки приложений нередко встает необходимость работы с Excel документами. Чаще всего это разного рода отчеты, но иногда xls/x файлы используются в качестве хранилища данных. Например, если пользователь должен иметь возможность загрузить данные в приложение или выгрузить, в человеко-читаемом виде, Excel де-факто является стандартом. Относительно дружелюбный интерфейс, прозрачная структура, в купе с его распространенностью... трудно навскидку назвать решение лучше.
Однако, у многих **Excel до сих пор ассоциируется** с чем-то тяжелым, неповоротливым и сложным. Давайте посмотрим, как мы - обычные C# разработчики, можем легко сформировать простой Excel документ, на примере табличного отчета.
Историческая справка
--------------------
Времена, когда доминировал проприетарный формат .xls(Excel Binary File Format) давно прошли и сейчас мы имеем только .xlsx(Excel Workbook), в рамках Office Open XML. Последний представляет собой обычный .zip архив с XML файлами. Не будем углубляться в его структуру, я искренне надеюсь что вам это никогда не понадобится.
На github, и не только, можно найти **ряд библиотек**, бесплатных и не только. Пожалуй самой популярной является EPPlus. До определенной степени, она довольно хорошо отражает концепцию Excel, именно по этому я всегда использую EPPlus. Версия 4 полностью бесплатна, начиная с 5‐й версии вам потребуется приобрести лицензию для коммерческого использования.
Задача
------
Итак, **предположим**, продукт-мэнеджеру ударила в голову идея того, что возможность выгружать некий отчет в формате Excel увеличит кол-во пользователей на 100500%. Проджет-менеджер решает выкатить эту киллер-фичу как хотфикс прямо сегодня — ведь работы всего на пару часов.
Сам по себе, отчет содержит краткое описание компании и историю изменения некоторых экономических показателей. Для простоты все свойства компании — строки. Экономические показатели — большие целые числа и числа с плавающей точкой, а также даты. Предположим, что где-то в недрах микросервисного backend-да есть сервис-генератор подобных отчетов, например по id компании. Однако, поскольку id нет смысла выводить пользователю, идентификатор отсутствует в самой модели отчета.
Аналитик, в свою очередь, выдает задачу с феноменально точным описанием - "Сгенерировать excel отчет на базе данных MarketReport". Что ж, для нашего примера, создадим заглушку — **генератор** фейковых данных:
Первый запуск
-------------
Подключим EPPlus версии 4.5.3.3 и создадим базовую обвязку для будущего генератора.
Сердцем генератора будет метод Generate. ExcelPackage это модель документа, через которую мы и будем осуществлять все взаимодействия с ним. Также имеется конструктор для передачи пути к файлу или потока.
 В методе main создается генератор отчетов, а также генератор Excel файлов. Далее полученный файл просто записывается на диск.
При попытке **запустить приложение**, получаем exception:`InvalidOperationException: The workbook must contain at least one worksheet`
Все правильно, Excel документ не может существовать без страниц, должна быть хотя бы одна. Добавляем ее, все интуитивно понятно:
```
var sheet = package.Workbook.Worksheets
.Add("Market Report");
```
Запускаем снова и... вот оно! Теперь наше приложение **генерирует документ** и, хотя там еще ничего нет, он уже весит 2,5KB - значит мы работаем с Excel правильно и все идет как надо.
### Вывод данных
Давайте выведем основную информацию по компании в шапку. Для доступа к конкретной ячейки объект Cells на странице пакета снабжен удобным индексатором. При этом, до конкретной ячейки можно достучаться как через номер строки и столбца, так и по привычному всем **буквенно-числовому коду**:
```
sheet.Cells["B2"].Value = "Company:";
sheet.Cells[2, 3].Value = report.Company.Name;
```
Полный код вывода шапки.
```
sheet.Cells["B2"].Value = "Company:";
sheet.Cells[2, 3].Value = report.Company.Name;
sheet.Cells["B3"].Value = "Location:";
sheet.Cells["C3"].Value = $"{report.Company.Address}, " +
$"{report.Company.City}, " +
$"{report.Company.Country}";
sheet.Cells["B4"].Value = "Sector:";
sheet.Cells["C4"].Value = report.Company.Sector;
sheet.Cells["B5"].Value = report.Company.Description;
```
Для вывода исторических данных понадобится как минимум шапка таблицы и цикл по массиву History:
```
sheet.Cells[8, 2, 8, 4].LoadFromArrays(new object[][]{ new []{"Capitalization", "SharePrice", "Date"} });
var row = 9;
var column = 2;
foreach (var item in report.History)
{
sheet.Cells[row, column].Value = item.Capitalization;
sheet.Cells[row, column + 1].Value = item.SharePrice;
sheet.Cells[row, column + 2].Value = item.Date;
row++;
}
```
Предлагаю обратить внимание на метод **LoadFromArrays**, который заполняет диапазон ячеек рваным(зубчатым) массивом. Здесь мы можем видеть, что типизация теряется и передавая массив object мы ожидаем что EPPlus в конечном итоге использует ToString, чтобы записать переданное в ячейки.
Стилизация
----------
Если вы прямо сейчас откроете документ, то вы возможно увидите не то, что хотелось бы отдать **в продакшн в пятницу вечером**.
Как это выглядитВо-первых, шапка никак не выделяется, во-вторых таблица не имеет границ... выравнивание пляшет, даты отображаются магическими числами, а капитализация "уходит в какую-то математику" - как это прокомментировал аналитик.
Да, на все эти красивости у нас уйдет больше ~~года~~ кода, чем на сам вывод данных, и, в конечном тоге, получившаяся каша из логики вывода данных и разметки заставит некоторых усомниться в их компетентности... но, мы же **backend разработчики**, так давайте сверстаем Excel Sheet!
#### Размер ячеек
Из коробки у нас есть возможность сделать **автофит** а так же вручную выставить ширину в соответствии с нашей ситуацией. А ситуация у нас не самая хорошая — по задумке аналитика в шапке у ячеек должен быть автофит, а у ячеек таблицы — тоже автофит. Так в чем же подвох?
Если вы когда-нибудь до этого открывали Excel, то возможно знаете, что ширина ячеек не может отличаться в рамках столбца и автофит будет по самому широкому контенту ячейки. Однако, **простые вещи** бывает нетак то просто объяснить... Но если вы справитесь, то вот как это будет выглядеть в коде:
```
sheet.Cells[1, 1, row, column + 2].AutoFitColumns();
sheet.Column(2).Width = 14;
sheet.Column(3).Width = 12;
```
#### Формат данных
Как и большая часть стиля ячейки, он задается через **одноименное свойство** Style. Обратите внимание на вычисление 3-го аргумента индексатора. Это звоночек некачественного кода, но к этому мы вернемся в позже...
```
sheet.Cells[9, 4, 9 + report.History.Length, 4].Style.Numberformat.Format = "yyyy";
sheet.Cells[9, 2, 9 + report.History.Length, 2].Style.Numberformat.Format = "### ### ### ##0";
```
#### Выравнивание
Его можно задать как на ячейке, так и на **диапазоне**. На самом деле, для EPPlus, это одна и та же сущность — некий ExcelRange, описывающий диапазон ячеек, в том числе и со всего 1 ячейкой.
```
sheet.Column(2).Style.HorizontalAlignment = ExcelHorizontalAlignment.Left;
sheet.Cells[8, 3, 8 + report.History.Length, 3].Style.HorizontalAlignment = ExcelHorizontalAlignment.Center;
```
#### Стиль текста
Также легко задается, используя Style.Font, кстати, здесь, на 2-й строчке, мы впервые указываем **диапазон** так, как привыкли его видеть пользователи Excel:
```
sheet.Cells[8, 2, 8, 4].Style.Font.Bold = true;
sheet.Cells["B2:C4"].Style.Font.Bold = true;
```
#### Границы
Задаем стиль линии, а также ее толщину. К этому моменту от кол-ва **магических чисел-параметров** индексатора уже рябит в глазах, но мы уже на финишной прямой... не так ли?
```
sheet.Cells[8, 2, 8 + report.History.Length, 4].Style.Border.BorderAround(ExcelBorderStyle.Double);
sheet.Cells[8, 2, 8, 4].Style.Border.Bottom.Style = ExcelBorderStyle.Thin;
```
#### График
"Ну что за отчет без графиков, верно, **Карл**?" - ловко подметит специалист по тестированию, и не важно, что этого не было в ТЗ а на часах уже половина 9-го...
Хотя график как сущность сам по себе сложнее таблиц и с графиками мы не работаем каждый день, EPPlus предоставляет довольно понятный API. Давайте добавим **простейший график**, отражающий рост капитализации:
```
var capitalizationChart = sheet.Drawings.AddChart("FindingsChart", OfficeOpenXml.Drawing.Chart.eChartType.Line);
capitalizationChart.Title.Text = "Capitalization";
capitalizationChart.SetPosition(7, 0, 5, 0);
capitalizationChart.SetSize(800, 400);
var capitalizationData = (ExcelChartSerie)(capitalizationChart.Series.Add(sheet.Cells["B9:B28"], sheet.Cells["D9:D28"]));
capitalizationData.Header = report.Company.Currency;
```
Еще, может понадобиться защитить страницу **от редактирования**:
```
sheet.Protection.IsProtected = true;
```
На этом все, репозиторий с рабочим приложением [находится здесь](https://github.com/sstcvetkov/HowToExcel/tree/764e9fa64b5b68280a5ae47450b44d8dcefb217b).
Заключение
----------
О чем говорит финальная версия метода Generate?
```
public byte[] Generate(MarketReport report)
{
var package = new ExcelPackage();
var sheet = package.Workbook.Worksheets
.Add("Market Report");
sheet.Cells["B2"].Value = "Company:";
sheet.Cells[2, 3].Value = report.Company.Name;
sheet.Cells["B3"].Value = "Location:";
sheet.Cells["C3"].Value = $"{report.Company.Address}, " +
$"{report.Company.City}, " +
$"{report.Company.Country}";
sheet.Cells["B4"].Value = "Sector:";
sheet.Cells["C4"].Value = report.Company.Sector;
sheet.Cells["B5"].Value = report.Company.Description;
sheet.Cells[8, 2, 8, 4].LoadFromArrays(new object[][]{ new []{"Capitalization", "SharePrice", "Date"} });
var row = 9;
var column = 2;
foreach (var item in report.History)
{
sheet.Cells[row, column].Value = item.Capitalization;
sheet.Cells[row, column + 1].Value = item.SharePrice;
sheet.Cells[row, column + 2].Value = item.Date;
row++;
}
sheet.Cells[1, 1, row, column + 2].AutoFitColumns();
sheet.Column(2).Width = 14;
sheet.Column(3).Width = 12;
sheet.Cells[9, 4, 9+ report.History.Length, 4].Style.Numberformat.Format = "yyyy";
sheet.Cells[9, 2, 9+ report.History.Length, 2].Style.Numberformat.Format = "### ### ### ##0";
sheet.Column(2).Style.HorizontalAlignment = ExcelHorizontalAlignment.Left;
sheet.Cells[8, 3, 8 + report.History.Length, 3].Style.HorizontalAlignment = ExcelHorizontalAlignment.Center;
sheet.Column(4).Style.HorizontalAlignment = ExcelHorizontalAlignment.Right;
sheet.Cells[8, 2, 8, 4].Style.Font.Bold = true;
sheet.Cells["B2:C4"].Style.Font.Bold = true;
sheet.Cells[8, 2, 8 + report.History.Length, 4].Style.Border.BorderAround(ExcelBorderStyle.Double);
sheet.Cells[8, 2, 8, 4].Style.Border.Bottom.Style = ExcelBorderStyle.Thin;
var capitalizationChart = sheet.Drawings.AddChart("FindingsChart", OfficeOpenXml.Drawing.Chart.eChartType.Line);
capitalizationChart.Title.Text = "Capitalization";
capitalizationChart.SetPosition(7, 0, 5, 0);
capitalizationChart.SetSize(800, 400);
var capitalizationData = (ExcelChartSerie)(capitalizationChart.Series.Add(sheet.Cells["B9:B28"], sheet.Cells["D9:D28"]));
capitalizationData.Header = report.Company.Currency;
sheet.Protection.IsProtected = true;
return package.GetAsByteArray();
}
```
Во-первых, прежде всего, о том, что мы **успешно справились** с задачей, а именно, сгенерировали свой первый Excel отчет, поработали со стилями и даже решили пару попутных проблем.
Во-вторых, возможно имеет смысл искать новою работу, но, **забегая вперед**, я бы с этим не спешил... Если данная публикация наберет 1+ просмотров, то во второй части мы поговорим о том, как можно отделить стилизацию от логики заполнения данными, упростить манипуляции над ячейками и в целом сделаем код боле поддерживаемым. | https://habr.com/ru/post/525492/ | null | ru | null |
# Как реализовать игнор заблокированных пользователей в группах Telegram?
UPD: благодаря помощи [Tkachov](https://habr.com/ru/users/tkachov/) эта статья всё-таки превратилась из просьбы о помощи в работающую инструкцию. В [комментариях](https://habr.com/ru/post/487512/#comment_21255934) он дал работающий код для создания игнора в десктопном клиенте Телеграм. Я на всякий случай расположу объяснение в конце статьи. Далее статья продолжается в том же виде, в каком была написана.
UPD: Сделал «сайт» для распространения готового приложения [sites.google.com/view/ignoram](https://sites.google.com/view/ignoram)
\* \* \*
Я хотел бы попросить помощи у сообщества, потому что все собственные возможности я полностью исчерпал.
Можно было бы задать вопрос на сервисе Q&A (он же бывший Тостер) — только я это уже сделал, и пользы вышло не очень много.
Тем не менее, просто задавать вопрос под видом статьи мне кажется не очень корректным. Поэтому я попытаюсь добавить в текст предысторию всего этого процесса и рассказать, какие шаги уже предпринял.
Если повезёт, то кто-нибудь в комментариях подскажет решение. И тогда нашедшие эту статью в поисковиках тоже смогут эту проблему решить.
Проблема и предыстория
----------------------
Как хорошо знают все пользователи Telegram, в групповых чатах этого мессенджера не существует функции игнора пользователя. Вы можете заблокировать неприятного вам пользователя, но это всего лишь запрещает ему писать вам личные сообщения. В групповом чате — а нынче групповые чаты, кажется, вмещают до 10 тысяч пользователей — вы просто **обязаны** видеть всё, что скинут прочие участники группы.
В «Чёрном Зеркале» даже была серия про это.
*Продолжайте смотреть! Продолжайте смотреть! Продолжайте смотреть!*
Если мы попытаемся найти решение этой проблемы в интернете, мы столкнёмся с типичной историей войны крупной корпорации и маленькой группы недовольных людей. Этапы этой войны хорошо видны на Гитхабе.
Вот [первый запрос этой функции от 2015 года.](https://github.com/telegramdesktop/tdesktop/issues/1025) В этой теме можно найти ссылки на последующие темы, люди постоянно просили эту функцию в последующие годы, но каждое обращение оказывалось закрытым с довольно глупым ответом «Это не проблема клиента, а проблема API».
Даже не программисту понятно, что данные показывают пользователю с помощью клиента. И даже если API передаёт вам все сообщения с сервера — нет никакой проблемы спрятать часть из них на стороне клиента.
Но вот уже пять лет, каждый год, а иногда по нескольку раз в год, люди добираются до Гитхаба с просьбой ввести игнор в группах — и каждый раз получают отказ и закрытие темы. Больше полугода назад, видимо, утомившись от постоянных требований, разработчики [вывесили ни к чему не обязывающую отговорку](https://twitter.com/buunicubus/status/1151604995487338496): мол, да-да, мы всё сделаем, когда-нибудь в далёком будущем.
*Я тебя услышал! Я просто это озвучил, пока не готов тебе ответить, скажем так, я понял твою позицию. Давай, на созвоне, не теряйся!*
Польза от этой отговорки ровно одна — теперь на все жалобы администраторы tdesktop на Гитхабе отсылают к этому сообщению. Дескать — вот смотрите, они всё знают, они всё сделают, извините, ветка закрыта. За полгода в телеграме произошло множество трудоёмких изменений, например в чаты добавили анимированные стикеры и КрАсИвЕнЬкИе шевелящиеся формы для опросов. Но никакого игнора даже близко не появилось. Думаю, не появится и через год.
При этом ситуация выглядит даже немного зловеще — есть ощущение, что какими-то специальными инструкциями для официальных форков вводить эту функцию запрещается. У Телеграма есть не меньше десятка широко известных форков (вроде Unigram) и под сотню малоизвестных, но ни в одном из них эта функция не реализована. Я писал в поддержку самых популярных форков, но не получил никакого ответа.
При этом управлять со стороны клиента сообщениями заблокированных пользователей **можно**. Это подтверждается существованием [Telegreat](https://telegre.at/). Это форк Телеграма, в котором была заявлена опция игнора заблокированных пользователей.
Увы, этот игнор ненастоящий. Всё, что делает опция «Игнорировать заблокированных пользователей» — раскрашивает текст сообщений заблокированных пользователей в серый цвет. Картинки, видео, музыка или стикеры от заблокированных пользователей видны по-прежнему; кроме того серый цвет на тёмных темах отлично читается.
В чат к разработчику, где я сидел какое-то время, регулярно приходят люди и просят сделать «настоящий игнор». Раньше он просто отказывался; в последние же полгода и вовсе забросил свой проект, потому что у него «нет времени». Что ж, это обычное дело для бесплатных открытых проектов.
Я упоминаю об этом проекте по двум причинам.
* Во-первых, он рекламируется именно как «клиент с функцией игнора» и его советуют люди, которые читают только описание, не зная, как на самом деле там этот «игнор» реализован. Как было сказано выше, функция эта не работает.
* Во-вторых, он является живым подтверждением того, что в клиенте Телеграма можно определить сообщение заблокированного пользователя и изменить его. То есть на самом деле игнор на стороне клиента возможен.
Однако никто этого не делает.
Лучше всего передаёт мои чувства комментарий в похожей [теме на Реддите четырёхлетней давности:](https://www.reddit.com/r/Telegram/comments/3ytqaw/qa_block_user_in_group_chat/)
> I'm shocked you can't do it.
>
>
>
> Seriously?
>
>
>
> If I just don't want to read anything some user writes I should be able to do so… it's like, one of the very basic features of every communication protocols EVER!
>
>
>
> You could do it in the 90s with emails and newsgroups!
Причём всюду, где идёт речь о причинах отсутствия игнора, повторяются одни и те же вещи:
— Вы будете видеть не все сообщения и из-за этого не будете понимать что происходит в чате.
— Вы будете дублировать сообщения.
— Нарушится функциональность системы «ответов»
И, опять же, я использую цитату, просто чтобы показать вам — это не мои личные мысли, это наша общая позиция, людей, которые хотят ввести эту функцию:
> [I can assure you 100.00% of people asking for this feature, are fully aware of the side effects it has, and could not care less about those.
>
>
>
> Yes just not show it at all. Yes including if it's a reply. Yes if the admin needs to see everything to moderate, then they don't have the luxury of using ignore. And most certainly we can compare TG groups to IRC, because they are both a mechanism for accomplishing the same thing, namely multi-user communication.](https://github.com/telegramdesktop/tdesktop/issues/1281#issuecomment-359193447)
Вот просто пример из жизни, касающийся дублирования — я сижу в нескольких телеграм-чатах и в течение дня обязательно несколько пользователей бросают в чат одну и ту же новость / смешной скриншот / свежий популярный мем. Несмотря на то, что до них это уже было. Несмотря на то, что никакого игнора не существует — они всё равно просто не читают историю чата и дублируют сообщения. Про то, как люди не умеют пользоваться поиском на форумах, и многократно повторяют одинаковые вопросы — я даже не буду упоминать, наверняка большинство читателей с этим сталкивались. Опять же, безо всякого игнора эта проблема уже существует. И игнор её не усугубит.
Так почему же **на самом деле** эта функция не существует?
Ну, конспирологическая версия гласит, что основная цель Телеграма — это сбор персональных данных и графов взаимодействия пользователей. В этом смысле каждая телеграм-группа позволяет зафиксировать типовую малую группу, которую пользователь как минимум может выдержать, и которая может выдержать его. В противном случае либо его выкидывают из группы, либо он уходит сам. Введение игнора нарушит чистоту эксперимента.
Версия маркетинговая немного проще.
Когда в 1995 году Халед Мардам-Бей создал mIRC — он написал программу для людей. В смысле, для самостоятельных людей, которые знают, что они хотят, выбирают то, что считают правильным, и несут ответственность за последствия своих действий. С одной стороны это вызывало проблемы, например, со скриптовыми уязвимостями — запускаешь строку с командами и всё, ты взломан. С другой стороны — это был мессенджер, которым пользовались взрослые и ответственные люди. И они знали, как существовать в чате с игнором, где часть сообщений просто не видна.
Когда в 2013 году Паша Дуров сделал Telegram — он сделал программу «для домохозяек». Для тупого массового пользователя, которому нужен добрый опекун. Отсюда вся эта регистрация по номеру телефона, рассылка сообщений всем по телефонной книге, флажки и запреты со всех сторон. Ведь они «нажмут что-нибудь и всё исчезнет!». А потом будут писать жалобы в поддержку! Отсюда и такие глупые оправдания — «ведь если вы включите игнор, то вы не увидите сообщений других людей». Когда делаешь массовый продукт — ты вынужден ограничивать любую функциональность. Продукт для дурака должен иметь защиту от дурака.
Тут появляется коронный аргумент, который всегда приводят в конце: «не нравится — так не пользуйся». Я не буду объяснять, что с ним не так, это этический вопрос формата «почему нельзя есть людей» — кто его задаёт, тому бессмысленно объяснять.
Но в случае с Телеграмом этот аргумент немножко видоизменяют: **«не нравится — так сделай как тебе нравится, это же open source»**.
Попытка решения
---------------
Устав от многолетних поисков, я решил действительно попытаться что-то изменить самостоятельно. Мне показалось хорошей идеей сделать собственную сборку Телеграма. Не в смысле общедоступную сборку, с сайтом и размещением в магазине приложений, а просто собрать приложение для себя и самому им пользоваться.
В этом смысле меня бы не беспокоили ни возможные «тормоза» от скрытия сообщений, ни «проблема потери контекста в беседе», ни проблема «как же админить чат если не видишь части сообщений». Это всё меня не интересовало.
Мне казалось очевидным, что достаточно добавить строку вида:
> **if message.author.isBlocked == true then message.value= 'The message from blocked user'**
Извините за псевдокод, но мне кажется, что идею он передаёт верно. Я просто хотел отловить любое сообщение на самом раннем этапе, когда оно только приходит с сервера, и заменять его на строку о блокировке. Таким образом решалась бы проблема и с картинками / стикерами / гифками — они бы тоже заменялись на такое сообщение и их не было бы видно. И даже если бы кто-то отвечал на такое сообщение или цитировал его — всё равно оно бы заменялось.
Но с чего начать?
Поспрашивав у знакомых программистов, я выяснил, что есть два пути. Первый — это использовать родной клиент Телеграм, и второй — использовать сторонний клиент, который написан с помощью более новой библиотеки TDLib. Я отправился на упомянутый в начале статьи сервис вопросов и задал там [вопрос](https://qna.habr.com/q/703969). Как видите, очереди из отвечающих не выстроилось. Единственная ниточка вела к мессенджеру Котатограм.
Я пообщался с создателем этого мессенджера, и он дал мне два полезных совета.
Во-первых, он сказал, что сообщения в нативном клиенте выводятся обычным способом, а не генерируются (я, впрочем, и так это подозревал на примере Telegreat) — поэтому можно в качестве исходника использовать родной клиент.
Во-вторых, он рассказал, где искать сам вывод сообщений — в блоке history\_message.
К сожалению, у него, как и у создателя Telegreat, тоже не было свободного времени, чтобы самостоятельно добавлять функцию игнора, что в свой клиент, что для меня.
Как я действовал дальше? Инструкция по сборке существует на Гитхабе, но она не отражает всех этапов работы. Я их тут опишу, на случай, если в статью придёт кто-то ещё, с программированием не особенно знакомый, но желающий сделать для себя такой же клиент с игнором:
1. Я решил всё делать на виртуальной машине. Для этого я установил себе Oracle VM Virtual Box и скачал [с официального сайта Microsoft](https://developer.microsoft.com/ru-ru/windows/downloads/virtual-machines/) их официальную виртуальную машину с предустановленными Windows 10 и Visual Studio 2019
2. На втором этапе нужно расширить предустановленный Visual Studio. Как оказалось, по умолчанию в него не входит C++, поэтому нужно запустить Visual Studio Installer из главного меню. Нажать там кнопочку Modify и выбрать секцию с C++, он её докачает и установит. Ну и на всякий случай я ещё скачал и установил QT [отсюда](https://marketplace.visualstudio.com/items?itemName=TheQtCompany.QtVisualStudioTools2019).
3. Кроме того нужно установить Git c [git-scm.com](https://git-scm.com/)
4. Теперь можно начать выполнять [инструкцию с Гитхаба](https://github.com/telegramdesktop/tdesktop/blob/dev/docs/building-msvc.md). **Но будьте внимательны!**
Там есть 2 секции команд. И если первая секция содержит около десятка команд, которые легко просто копировать и вставлять в командную строку, то для второй секции из нескольких десятков команд естественным решением кажется скопировать весь код в bat-файл и запустить. Это ошибка, так как процесс останавливается как минимум дважды.
Первая остановка происходит после строки:
```
gyp --no-circular-check breakpad_client.gyp --format=ninja
```
Вторая — после четвёртой строки с конца, длинной инструкции конфигурирования QT:
```
configure -prefix "%LibrariesPath%\Qt-5.12.5" .......
```
Как мне подсказали знакомые, это связано с тем, что в ходе выполнения этих команд запускаются другие bat-файлы, в которых уже прописан прямой выход из процесса. В результате дальше нужно либо просто копировать и вставлять команды, либо разбить инструкцию на 3 bat файла (но в этом случае нужно не забыть, что команды следует продолжать выполнять из той же директории, в которой процесс остановился!).
Получение собственных api\_id [тоже описано на Гитхабе](https://github.com/telegramdesktop/tdesktop/blob/dev/docs/api_credentials.md).
В конечном счёте я скомпилировал вполне рабочий exe-файл Телеграма. Всего сборка занимает около трёх часов (не считая предварительных скачиваний и установок), возможно это время зависит от мощности компьютера.
Помощь зала (и найденное решение)
---------------------------------
И вот здесь наконец-то появляется моя просьба к хабрасообществу. Как читатели уже догадались, я не знаю, что и как менять. Мне кажется, что я нашёл место, где выводится сообщение, но я не уверен, потому что я же не знаю C++. Не говоря уж о том, что (возможно) правильно было бы что-то менять не в history\_message, а где-нибудь в history\_item.
[](https://habrastorage.org/webt/wx/r6/el/wxr6el7uy7ed5dhp2fexr-9yhli.png)
*«Что-то на эльфийском, не могу прочесть»*
Может быть кто-нибудь здесь уже сталкивался с кодом Telegram или просто имеет очень развитый скилл и сможет написать ту самую строку с заменой любого сообщения от заблокированного пользователя, а также сказать, куда её разместить в этом коде.
Я предполагаю, что сам механизм вывода у Телеграма не будет внезапно изменяться. Так что при обновлении клиента я буду просто скачивать с гитхаба обновлённый вариант и снова добавлять эту строку с блокировкой перед компиляцией.
UPD: Как я упомянул в начале статьи, в [комментариях](https://habr.com/ru/post/487512/#comment_21255934) появился работающий вариант кода. Привожу его и прямо в статье.
Первая часть кода заменяет текст на другое сообщение. Это необходимо, т.к. этот текст виден в цитатах, если другой пользователь отвечает заблокированному, или слева в окошке чата, где показываются последние сообщения в групповых чатах.
В файле History\_Message.cpp мы находим функцию как раз в том самом месте, что на скриншоте выше:
```
HistoryMessage::HistoryMessage(
not_null history,
const MTPDmessage &data,
MTPDmessage\_ClientFlags clientFlags)
```
И внутри заменяем оригинальный текст:
```
if (const auto media = data.vmedia()) {
setMedia(*media);
}
setText({
TextUtilities::Clean(qs(data.vmessage())),
Api::EntitiesFromMTP(data.ventities().value_or_empty())
});
```
На расширенный:
```
//UserId from = data.vfrom_id().value_or_empty();
// Это почему-то перестало работать, поэтому пришлось добавить другую строку
UserId from = data.vfrom_id() ? peerFromMTP(*data.vfrom_id()) : PeerId(0);
PeerData* pd = from ? history->owner().user(from) : history->peer;
if (pd->isUser() && pd->asUser()->isBlocked()) {
setText({
TextUtilities::Clean(qs("The message from blocked user")),
Api::EntitiesFromMTP(data.ventities().value_or_empty())
});
}
else {
// оригинальные строки 442-448:
if (const auto media = data.vmedia()) {
setMedia(*media);
}
setText({
TextUtilities::Clean(qs(data.vmessage())),
Api::EntitiesFromMTP(data.ventities().value_or_empty())
});
}
```
Если использовать только этот код — старые сообщения заблокированных пользователей будут видны, но новые уже нет.
Поэтому вторая часть решения, упомянутая в [этом](https://habr.com/ru/post/487512/#comment_21258198) комментарии
В файл history\_view\_message.cpp добавляется следующий код:
```
PeerData* pd = item->from();
if (pd->isUser() && pd->asUser()->isBlocked()) return;
```
UPD: в новой версии компилятор ругается на пустой return, поэтому я добавил вывод QSize(0,0) В другом случае можно наоборот убрать его.
```
PeerData* pd = item->from();
if (pd->isUser() && pd->asUser()->isBlocked()) return QSize(0,0);
```
Сразу после объявления переменной item в функциях
QSize Message::performCountOptimalSize()
и
void Message::draw(
Painter &p,
QRect clip,
TextSelection selection,
crl::time ms)
Это позволит совсем не видеть сообщения заблокированных пользователей в логе чата.
*Важное дополнение:* Если вдруг сообщения заблокированного пользователя всё равно видны — то нужно просто кликнуть на его профиль, информация о том, что он заблокирован, обновится, и все его сообщения исчезнут из лога чата.
Для желающих добавил на Дропбокс [скомпилированное приложение.](https://www.dropbox.com/s/y8k4m0x61lo75n3/Telegram.exe?dl=0) | https://habr.com/ru/post/487512/ | null | ru | null |
# Dojo Build System, собственный опыт создания сборки
[Dojo](http://dojotoolkit.org/) — не самый популярный JavaScript фреймворк, несмотря на все свою мощь и положительные качества. Информация, которую я хочу донести сегодня до читателя, требуется для абсолютно каждого проекта, построенного с использованием этой технологии.
А поговорим мы о системе сборки.
##### Что это и зачем это нужно
Сообщество предлагает нам уже готовый оптимизированный релиз, предназначенный для размещения на сервере и использования в веб-приложениях. Подключая необходимые модули через dojo.require() мы инициируем синхронные HTTP GET запросы для получения необходимых ресурсов. Так как браузер ожидает завершения каждого вызова, то время загрузки страницы серьезно увеличивается. Оптимизировать подключение ресурсов нам помогут так называемые “layers” (далее просто — слои).
Задачи использования dojo build system для создания собственной сборки:
* создание слоя используемых модулей. Все нужные модули соберутся в 1 файл, что заметно ускорит открытие страниц
* при необходимости изменений кода модулей dojo мы будем всегда работать только с исходным кодом (src-версий dojo)
* при наличии таких изменений действия по их встраиванию в очередные обновления сводятся к минимуму
##### Что необходимо для создания сборки
* Src-версия dojo, которую можно найти на [странице загрузки](http://dojotoolkit.org/download/)
* JRE 1.5 и выше
* Опционально, собственные ресурсы (js, css и тд), которые мы хотим включить в сборку.
* Профиль (profile) – js файл, который описывает создание новой сборки.
* Движок Rhino от Mozilla Foundation. Dojo в свои утилиты для сборки его не подложил, хотя активно на него ссылается. Взять можно на [сайте Mozilla](http://www.mozilla.org/rhino/)
##### Создание слоев
Слой на этапе подготовки сборки представляет собой конфигурационный файл, который включает в себя нужные нам подключения. Например, создадим основной слой, который будет подключаться на всех страницах веб-проекта, назовем его commonlayer.js.
```
dojo.provide("ourcompany.commonlayer");
//основные модули
dojo.require("dojo.parser");
dojo.require("dojo.NodeList-fx");
dojo.require("dojo.data.ItemFileReadStore");
dojo.require("dojox.data.AndOrReadStore");
dojo.require("dojo.back");
dojo.require("dojox.fx._base");
dojo.require("dojo.cookie");
//специфический
dojo.require("ourcompany.shadow");
```
ourcompany.shadow – допустим, это наш собственный модуль, кастомизация тени dojo.fx.shadow, которую мы хотим использовать.
И для сравнения дополнительный слой по работе с редактором dijit.Editor:
```
dojo.provide("ourcompany.editorlayer");
//подключение самого редактора и плагинов
dojo.require("dijit.Editor");
dojo.require("dijit._editor.plugins.FontChoice");
dojo.require("dijit._editor.plugins.TextColor");
dojo.require("dijit._editor.plugins.EnterKeyHandling");
//специфический
dojo.require("ourcompany.dijit._editor.plugins.LinkDialog");
```
Мы меняли плагин вставки ссылки LinkDialog под собственные нужды. Выносим его из стандартной сборки и обзываем по-своему, как в случае с тенью. Смена названия происходит просто: исходный js код плагина добавляется строчка с новым объявлением, например:
```
dojo.provide("ourcompany.dijit._editor.plugins.LinkDialog");
```
где название ourcompany.dijit.… также говорит о физическом размещении модуля в файловой системе, \ourcompany\dijit\\_editor\plugins\LinkDialog.js
##### Создание профиля
В профиле layers.profile.js описываются необходимые слои и области именования, в объекте dependencies:
```
dependencies = {
layers: [
//описание наших двух слоев
{
name: "../ourcompany/commonlayer.js",
resourceName: "ourcompany.commonlayer",
dependencies: [
"ourcompany.commonlayer"
]
},
{
name: "../ourcompany/editorlayer.js",
resourceName: "ourcompany.editorlayer",
dependencies: [
"ourcompany.editorlayer"
]
}
],
prefixes: [
//система знает, где искать папку /dojo, а остальные надо ей показать
//ourcompany - директория с нашими кастомизациями и ресурсами
[ "dijit", "../dijit" ],
[ "dojox", "../dojox" ],
[ "ourcompany", "../ourcompany" ]
]
}
```
Такой файл создаст только оптимизированные 2 слоя, остальные файлы просто скопируются при сборки без изменений. Но их мы можем взять из официального релиза. Возможно у кого-то будет желание дополнить профиль так, чтобы он создавал полную сборку dojo, я не стал.
##### Собираем
В src-версии dojo есть особенная папочка util, в которой можно найти скрипты сборки и утилиту shrinksafe для обфускации (оптимизирования) кода. Но не обольщайтесь, «из коробки» это не работает. Пришлось вникать и побеждать. Dojo предлагает два варианта сборки, для Windows через build.bat и для linux через build.sh. Сборку я проводил на родном компьютере, в окнах.
Непосредственно процесс сборки запускает файл \util\buildscripts\build.bat. Отредактируем его, указав правильный -classpath:
`java -classpath "../rhino/js.jar;../shrinksafe/js.jar;../shrinksafe/shrinksafe.jar" org.mozilla.javascript.tools.shell.Main build.js %*
pause`
где rhino — java-движок, о котором я говорил выше.
Запустить сборку, указав параметры, удобно через makeRelease.bat файл. Я сделал это так, но я не специалист в написании батников, думаю у вас выйдет изящнее:
`@echo off
E:
cd \js\dojoroot
set FLDR=E:\js\dojoroot
echo buid root directory: %FLDR%
cd %FLDR%\dojo-release-1.6.0-src\util\buildscripts
build.bat action=clean,release profileFile=%FLDR%\layers.profile.js version=ourcompany-1.6.0/2 releaseName=`
В файловой системе это выглядит так:
Как видите, сборку я проводил из исходников, директория «dojo-release-1.6.0-src», в которую подложил папку «ourcompany» с измененными модулями и ресурсами. Для запуска build.bat я использую следующие аргументы:
* action — необходимые действия, clean — очистить старую директорию сборки, release — создать сборку
* profileFile — путь к профилю
* version — версия сборки, можно будет возвращать через dojo.version
* releaseName — у меня пустое, если его задать, в папке release появится поддиректория с вашим названием
Полный список аргументов есть в [документации](http://dojotoolkit.org/reference-guide/build/buildScript.html#usage).
После выполнения сборки директория приобретет вид:
В release лежит практически новогодний подарок — наша первая кастомная сборка dojo. В \release\ourcompany\ находятся два наших слоя, каждый из которых представляет собой оптимизированную могучую кучку из необходимых нам модулей для подключения.
Подключение слоев на страницу проекта:
```
```
Работа со слоями не исключает стандартной работы с модулями через dojo.require(). Необходимо отметить, что перед подключением dojo.require() проверяет, подключался ли уже такой модуль, и предотвращает повторное подключение.
##### Результат
Данная статья не только продукт глубоких умозаключений и творческого поиска, а реальный опыт, примененный в реальном веб-проекте. Что мы получили после создания и использования собственной сборки:
* существенно выросла скорость загрузки всех страниц. Время загрузки по личным наблюдениям в Firebug и тестам webpagetest.org сократилось примерно на секунду
* на главной странице проекта, где не используется редактор, 129 последовательных HTTP GET запросов превратились в один (sic!)
* проект пережил обновление с dojo 1.4 на версию 1.6, и теперь легко будет обновляться на каждую новую версию
P.S. Внесение изменений в модули dojo часто несет за собой некоторые сложности с зависимостями. Например, при изменении плагина LinkDialog.js для dijit.Editor, который мы включили в сборку, потребовалось внести в src-версию папки ourcompany стандартные файлы ourcompany\dijit\nls\ru\common.js (loading.js). Без этой манипуляции слой editorlayer.js будет работать с ошибкой.
При изучении механизма создания сборок я использовал документацию на официальном сайте dojo toolkit:
<http://dojotoolkit.org/reference-guide/build/>
<http://dojotoolkit.org/reference-guide/build/simpleExample.html>
<http://dojotoolkit.org/reference-guide/build/buildScript.html> | https://habr.com/ru/post/122945/ | null | ru | null |
# Dagaz: Новое начало
***Бежит на юг и кружит на север, кружит, кружит на бегу своем ветер,
И на круги свои возвращается ветер;
Бегут все реки в море, — а море не переполнится,
К месту, куда реки бегут, — Туда они продолжают бежать;
[Книга Экклезиаста](http://lib.ru/HRISTIAN/ekkleziast.txt).***
В 1998 году, было разработано совершенно уникальное, для своего времени, приложение, позволяющее свести процесс разработки абстрактной настольной игры (или головоломки) к небольшому текстовому описанию на языке, отдалённо напоминающем [Lisp](http://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D1%81%D0%BF). Этот проект получил название [Zillions of Games](http://www.zillions-of-games.com/) и произвел настоящий фурор в среде любителей настольных игр. В настоящее время, создано более 2000 приложений, с использованием этой технологии.
Очень быстро выяснилось, что **ZoG** обладает множеством недостатков. Я уже [писал](http://habrahabr.ru/post/221779/) об этом на Хабре и не буду повторяться. Скажу лишь, что разработчики не учли особенностей огромного количества уже существующих игр, а часть важных опций «захардкодили» таким образом, что их изменение стало крайне проблематичным. Грэг Шмидт, в 2007 году, постарался исправить ситуацию, выпустив [Axiom Development Kit](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1452), но тесная интеграция этого решения с **ZoG** не позволила решить все проблемы.
Проект [Ludi](http://www.cameronius.com/cv/publications/ciaig-browne-maire-19.pdf) обозначил новые рубежи, используя универсальный игровой «движок» и [генетические алгоритмы](http://ru.wikipedia.org/wiki/%D0%93%D0%B5%D0%BD%D0%B5%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC) для автоматизации самого процесса разработки новых настольных игр. К сожалению, этот подход изначально предусматривал сознательное упрощение как игровых механик так и уровня используемого AI. Обсуждение целей этого проекта выходит за рамки настоящей статьи, но отдельные его технические решения, бесспорно, послужили отправной точкой для начала моей собственной разработки.
Моей целью является разработка более универсального и удобного в использовании «движка» для создания абстрактных настольных игр. Уже почти год я изучаю возможности **ZoG** и **Axiom** и узнал очень многое об их ограничениях. Я думаю, что смогу решить их проблемы, создав более универсальное и кроссплатформенное решение. О ходе работы над этим проектом я и собираюсь рассказать.
#### **Открытость и модульность**
Пожалуй, главным недостатком **ZoG** является его закрытость. Продукт собран «раз и навсегда» под одну единственную платформу — Windows. Будь исходные коды открытыми, можно было бы попытаться портировать их под Linux, Android, iOS… Другой проблемой является монолитность.
В **ZoG** имеются зачатки модульности, позволяющие подключать к играм [DLL](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8_%D0%BF%D0%BE%D0%B4%D0%BA%D0%BB%D1%8E%D1%87%D0%B0%D0%B5%D0%BC%D0%B0%D1%8F_%D0%B1%D0%B8%D0%B1%D0%BB%D0%B8%D0%BE%D1%82%D0%B5%D0%BA%D0%B0), содержащие кастомные реализации AI. **Axiom** идёт чуть дальше, позволяя запускать приложения в режиме **autoplay**, без использования ядра **ZoG**. Даже несмотря на серьёзное ограничение этого решения (поддерживаются приложения только для двух игроков), этот пример наглядно показывает, насколько модульность была бы полезна! Возможность организовать игру двух ботов (использующих различные настройки AI) и собрать статистику по большому количеству их игр трудно переоценить. Но насколько было бы лучше, если бы продукт был полностью модульным!
* Модуль генерации ходов
* Модуль выполнения хода
* Управляющий модуль
* Модуль AI
* Модуль визуализации
Вся работа с описанием игр должна выполняться модулем генерации ходов. Это «сердце» проекта. Перенос всей не связанной с его задачами функциональности в другие модули позволит сделать его максимально простым. Можно улучшать этот модуль, не оглядываясь на вопросы AI и взаимодействия с пользователем. Можно полностью изменить формат описания игр или добавить поддержку описаний в формате **ZoG**, **Axiom** и **Ludi**. Модульность — основа гибкости решения!
Модуль выполнения хода — это хранитель игрового состояния. Информация о текущем игровом состоянии передаётся всем остальным модулям по требованию. По причинам, о которых я скажу ниже, выполнение хода должно проходить через модуль генерации, задачей которого является формирование команды в терминах модуля выполнения хода. Также, задачей модуля генерации является первичное конфигурирование игрового пространства, на основании описания игры.
Управляющий модуль — это, по сути, само приложение. Он запрашивает у модуля генерации списки возможных ходов и изменяет игровое состояние, передавая выбранный ход в модуль выполнения хода. Управляющий модуль может подключить к игре один или несколько AI ботов. Столько, сколько требуется (и возможно различных)! Тип используемого управляющего модуля определяется решаемыми задачами. Это может быть **autoplay** для сбора игровой статистики, игровой сервер (он может управлять сразу несколькими хранилищами состояния, ведя большое количество игровых сессий) или индивидуальное приложение для игры в offline.
Возможность подключения различных реализаций AI позволит улучшить качество игры. Понятно, что модули для игры в Шахматы и Го должны использовать различные подходы. Игры с неполной информацией и игры использующие случайные данные также требуют индивидуального подхода. Универсальная реализация AI будет одинаково плохо играть во все игры! Модульное подключение AI позволит сравнивать «силу» используемых алгоритмов, включая их в режиме игры «между собой». Поскольку AI архитектурно отделён от хранилища игрового состояния, одна реализация игрового бота сможет поддерживать неограниченное количество игровых сессий одновременно.
Визуализация игрового процесса также может быть различной. Первое, что приходит в голову — это 2D и 3D реализации. Платформа, для которой разрабатывается приложение, также имеет значение. Менее очевидно, что визуализация может быть важной частью игрового процесса! Так например, в игре [Суракарта](http://www.iggamecenter.com/info/ru/surakarta.html), взятие фигур будет совершенно неочевидным при отсутствии правильной анимации ходов.
В целом, модульность видится хорошей идеей для подобного проекта, а открытые исходные коды позволят участвовать в нём всем желающим. В настоящее время, я не ставлю перед собой коммерческих целей, но думаю, что, при желании, я найду способ заработать, без закрытия исходных кодов.
#### **Игровое пространство**
Прежде чем начинать спектакль, необходимо подготовить сцену. Доска — это не просто место, на котором размещаются фигуры. Помимо этого, могут определяться направления перемещения фигур (фактически, связи полей доски между собой), игровые зоны (например, зоны превращения фигур), запрещенные поля и т.д. Вот как выглядит определение доски в **ZoG**-реализации шахмат:
**Определение доски в ZoG**
```
(define Board-Definitions
(image "images\Chess\SHaag\Chess8x8.bmp" "images\Chess\Chess8x8.bmp")
(grid
(start-rectangle 5 5 53 53)
(dimensions
("a/b/c/d/e/f/g/h" (49 0)) ; files
("8/7/6/5/4/3/2/1" (0 49)) ; ranks
)
(directions (n 0 -1) (e 1 0) (s 0 1) (w -1 0)
(ne 1 -1) (nw -1 -1) (se 1 1) (sw -1 1)
)
)
(symmetry Black (n s)(s n) (nw sw)(sw nw) (ne se)(se ne))
(zone
(name promotion-zone)
(players White)
(positions a8 b8 c8 d8 e8 f8 g8 h8)
)
(zone
(name promotion-zone)
(players Black)
(positions a1 b1 c1 d1 e1 f1 g1 h1)
)
(zone
(name third-rank)
(players White)
(positions a3 b3 c3 d3 e3 f3 g3 h3)
)
(zone
(name third-rank)
(players Black)
(positions a6 b6 c6 d6 e6 f6 g6 h6)
)
)
```
Можно заметить, что помимо собственно игровых настроек, здесь имеются настройки, связанные с визуализацией. Я твёрдо убеждён в том, что этим настройкам здесь не место. Реализаций модуля визуализации может использоваться несколько и настройки им потребуются различные. Более того, игровая симуляция может работать и без модуля визуализации вообще (как **autoplay** в **Axiom**). Действительно, поскольку **Axiom** использует для визуализации **ZoG**, определение не содержит ничего лишнего:
**Определение доски в Axiom**
```
{board
8 8 {grid}
board}
{directions
-1 0 {direction} n
1 0 {direction} s
0 1 {direction} e
0 -1 {direction} w
-1 -1 {direction} nw
1 -1 {direction} sw
-1 1 {direction} ne
1 1 {direction} se
directions}
{symmetries
Black {symmetry} n s
Black {symmetry} nw sw
Black {symmetry} ne se
symmetries}
```
К сожалению, определения игровых зон оно также не содержит (расположение игровых зон приходится определять в коде вручную). Это не единственное упрощение, на которое идёт **Axiom**. Определение доски в этом проекте не может содержать более одного **grid**-а и этот **grid** должен быть двумерным. Доска, определённая таким образом, представляет собой одномерный массив, но для удобства программиста, определяются синонимы для каждого из полей, по следующей схеме:
По сравнению с более гибкой схемой определения **grid**-ов в **ZoG**, эти ограничения довольно неудобны (особенно с учетом того, что навязанная схема именования полей используется и при визуализации). К счастью, имеется возможность определения доски произвольной формы. И **Axiom** и **ZoG** предоставляют возможность поэлементного определения каждой позиции доски с возможностью определения связей между произвольными парами позиций. Используя этот подход, можно определить доску любой топологии. Единственный его минус — крайняя многословность и трудоёмкость описания.
Помимо расположения фигур на доске и в резерве, должна иметься возможность хранения атрибутов как для отдельных фигур, так и для полей доски. Хорошим примером необходимости использования атрибутов является правило "[рокировки](http://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%BA%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0)" в [Шахматах](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B). Это сложный ход, включающий в себя одновременное перемещение короля и одной из ладей, возможный при условии, что ни одна из этих фигур, до выполнения этого хода, не передвигалась. Атрибут может быть использован для хранения булевского признака того, что фигура перемещалась когда либо. Атрибутам полей можно также найти довольно интересные применения.
Следует отметить, что атрибуты — не просто переменные, а часть игрового состояния. Значение атрибута может быть изменено при выполнении хода (в том числе модулем AI) и должно быть доступно для всех последующих ходов, но не для ходов, выполняемых в другой ветви игры. В настоящее время, **ZoG** поддерживает хранение булевских атрибутов фигур. **Axiom** хранение атрибутов не поддерживает, но позволяет добавлять в определение доски описание переменных и массивов. Такие переменные могут быть использованы, например, как счетчики количества съеденных фигур:
```
{board
5 18 {grid}
{variable} WhitePieces
{variable} BlackPieces
board}
```
Ещё одним ограничением как **ZoG**, так и **Axiom** является правило, по которому каждое поле доски может содержать не более одной фигуры. Если какая либо фигура завершает ход на поле, занятом другой фигурой, фигура ранее занимавшая поле, автоматически считается «съеденной». Это правило хорошо сочетается с «шахматным» принципом взятия фигур и позволяет упростить описания использующих его игр, но затрудняет реализацию таких игр как "[Столбовые шашки](http://www.iggamecenter.com/info/ru/bashni.html)" и "[Таврели](http://www.iggamecenter.com/info/ru/tavreli.html)".
В этих играх, фигуры могут выстраиваться в «столбики». Такой «столбик» может перемещаться целиком, как единая фигура. После некоторого размышления, я решил, что лучше не отказываться от автоматической реализации «шахматного» взятия, а усовершенствовать механизмы перемещения групп фигур. Действительно, для реализации «столбиков», всегда можно добавить к доске ещё одно измерение (это тем более просто, поскольку модуль визуализации будет отделён от модулей генерации ходов и AI и в нём можно будет использовать любую логику отображения трехмерной доски на её двумерную визуализацию). Дополнительным доводом, в пользу этого решения, явилось то, что «столбовое» перемещение фигур не является единственным видом группового перемещения. Например в "[Пентаго](https://s3-eu-west-1.amazonaws.com/mosigra.product.other/522/067/pentago.pdf)" фрагменты доски могут поворачиваться, вместе с установленными на них фигурами.
Резюмируя, можно сказать, что для своего игрового framework-а, я решил взять всё лучшее, что было придумано в **ZoG**, **Axiom** и **Ludi** и добавить то, чего, по моему мнению, им не хватает.
#### **Ходогенерация**
Генерация хода сродни [недетерминированному программированию](http://en.wikipedia.org/wiki/Nondeterministic_programming). Задача генератора ходов — предоставление, по требованию, списка всех возможных ходов, из текущей позиции. Какой именно ход, из этого списка, будет выбран игроком или AI — не его дело. Рассмотрим, как именно выполняется генерация ходов в **ZoG**. В качестве примера, возьмём макрос генерации хода дальнобойной фигурой (ферзём или слоном). Вот как он используется в определении фигуры:
```
(piece
(name Bishop)
(image White "images\Chess\SHaag\wbishop.bmp" "images\Chess\wbishop.bmp"
Black "images\Chess\SHaag\bbishop.bmp" "images\Chess\bbishop.bmp")
(moves
(slide ne)
(slide nw)
(slide se)
(slide sw)
)
)
```
В качестве параметра, в макрос передаётся направление перемещения по доске. Если не рассматривать возможность установки новых фигур на доску, генерация хода выглядит просто. Для каждой из фигур на доске, выполняется перебор всех определённых правилами ходов. Дальше начинается магия…
Каждое из определений может добавить в список несколько возможных ходов! Добавление хода в список осуществляется командой **add** (по совместительству устанавливающей перемещаемую фигуру на доску). Я уже [писал](http://habrahabr.ru/post/221779/) о том, что такое архитектурное решение крайне неудачно. Команда формирования хода должна быть отделена от команд, манипулирующих фигурами (так, как это было сделано в **Axiom**). Посмотрим, как работает макрос:
```
(define slide (
$1
(while empty?
add
$1
)
(verify not-friend?)
add
))
```
Сначала, выполняется перемещение на одну клетку, в заданном направлении, после чего, в цикле, достигнутое поле проверяется на отсутствие в нём фигур, формируется ход и происходит перемещение еще на одну клетку в том же направлении. Если остановиться на этом, фигура сможет «скользить» по пустым клеткам, но как брать вражеские фигуры?
Очень просто! Выполнив, командой **verify**, проверку того, что поле не занято дружественной фигурой, мы формируем ещё одну команду **add**, завершая ход. Если на этой клетке размещалась вражеская фигура, она будет взята автоматически (поскольку на одном поле доски, единовременно, не может размещаться более одной фигуры). Если фигура была дружественная, расчёт хода прервётся командой **verify** (нарушение условия, указанного в этой команде, немедленно прерывает расчёт текущего хода).
И в **ZoG** и в **Axiom** ходить можно только своими фигурами (вернее ходить фигурами противника можно, но только в том случае, если это указано в режиме расчёта хода). Я нахожу это ограничение крайне неудобным, поскольку имеется множество игр, в которых ходить фигурами противника можно (в "[Ставропольских шашках](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BA%D0%B8#.D0.A1.D1.82.D0.B0.D0.B2.D1.80.D0.BE.D0.BF.D0.BE.D0.BB.D1.8C.D1.81.D0.BA.D0.B8.D0.B5_.D1.88.D0.B0.D1.88.D0.BA.D0.B8)", например). Более последовательным было бы выполнять расчёт хода для всех фигур, независимо от их принадлежности. В макрос, определяющий ход, понадобилось бы добавить всего одну проверку, для того, чтобы ходить можно было только своими фигурами:
```
(define slide (
(verify friend?)
$1
(while empty?
add
$1
)
(verify not-friend?)
add
))
```
Важной является возможность выполнения хода, состоящего из нескольких «частичных» ходов. В реализациях шашках, эта возможность используется для выполнения «цепочек» взятий:
```
(define checker-jump
($1 (verify enemy?)
capture
$1
(verify empty?)
(if (not-in-zone? promotion-zone)
(add-partial jumptype)
else
(add-partial King jumptype)
)
)
)
```
Частичный ход формируется командой **add-partial** (для неё, как и для команды **add**, существует вариант хода, с «превращением» фигуры). Такой ход всегда является частью большего, «составного» хода. Как правило, для последующих ходов, устанавливается «режим», в котором должно осуществляться продолжение. Так в шашках, взятие можно продолжить лишь последующими взятиями, но не «тихим» ходом.
**Примечание**В **ZoG**, реализация частичных ходов оставляет желать лучшего. Попытка выполнения команды **add-partial** в цикле приводит к ошибке. В результате, взятие выполняемое дамкой, может быть реализовано лишь следующим, весьма неуклюжим образом:
```
(define king-jump-1
($1 (while empty?
$1
)
(verify enemy?)
capture
$1
(verify empty?)
(add-partial jumptype)
)
)
(define king-jump-2
($1 (while empty?
$1
)
(verify enemy?)
capture
$1
(verify empty?)
$1
(verify empty?)
(add-partial jumptype)
)
)
```
И так далее, вплоть до king-jump-7! Напомню, что в большинстве разновидностей шашек, с «дальнобойными» дамками, дамка, выполнив взятие, может остановиться на **любом** поле, из непрерывной цепочки пустых полей, следующих за взятой фигурой. Есть, впрочем, один [вариант](http://thaichess.narod.ru/index/0-36) этой игры, в котором правило «цепочки» взятий формулируется иначе. Именно это мне и нравится в шашках — каждый может найти вариант по своему вкусу.
Такая система описания правил очень гибкая, но иногда требуется более сложная логика. Например, если фигура, при выполнении «частичного» хода не должна повторно проходить через ранее пройденные поля, логично использовать флаги, связанные с позициями на доске. Посетив поле, мы взводим флаг, чтобы впоследствии не зайти на это поле повторно:
```
(verify (not-position-flag? my-flag))
(set-position-flag my-flag true)
```
Помимо «позиционных», в **ZoG** можно использовать и глобальные флаги. Эти возможности не следует путать с атрибутами фигур. В отличии от последних, они не являются частью игрового состояния. К сожалению, и атрибуты фигур и флаги в **ZoG** могут быть только булевскими (в **Axiom** атрибуты и вовсе не поддерживаются). Это ограничение затрудняет выполнение операций, связанных с различного рода подсчётами. Например, в [этой](http://zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=2233) небольшой головоломке, мне пришлось использовать для «подсчёта» фигур, попавших в «вилку», пару булевских флагов (точное количество мне было не нужно, главное, чтобы фигур было больше одной).
Другая вещь, которую стоит исправить — отсутствие внятного «жизненного цикла» выполнения хода. Все флаги автоматически сбрасываются перед началом выполнения хода, но было бы удобнее выделить фазы инициализации явно. По моему мнению, при расчёте хода, должны выполняться следующие фазы:
1. Инициализация переменных и проверка предусловий составного хода
2. Инициализация переменных и проверка предусловий частичного хода
3. Генерация частичного хода
4. Проверка постусловий частичного хода
5. Генерация завершения и проверка постусловий составного хода
6. Проверка выполнения условий завершения игры
Группа шагов со второго по четвёртый, при выполнении составного хода, может повторяться многократно. Идею пред- и постусловий, называемых мной инвариантами, я взял из проекта **Ludi**. Впрочем, об использовании инвариантов я подробнее расскажу в дальнейшем.
#### **О важности нотации**
Генерация всех возможных из позиции ходов — это только половина дела. Для управления игровым состоянием, требуется компактная форма представления сгенерированных ходов. В **ZoG**, для этой цели, используется **ZSG**-нотация. Вот как выглядит запись возможного начала шахматной партии в этой форме:
```
1. Pawn e2 - e4
1. Pawn e7 - e5
2. Knight g1 - f3
2. Knight b8 - c6
3. Bishop f1 - c4
3. Knight g8 - f6
4. King e1 - g1 Rook h1 - f1 @ f1 0 0 @ g1 0 0
4. Pawn d7 - d5
5. Pawn e4 x d5
5. Knight f6 x d5
```
Такая запись близка к привычной [шахматной нотации](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D0%BD%D0%B0%D1%8F_%D0%BD%D0%BE%D1%82%D0%B0%D1%86%D0%B8%D1%8F) и, в целом, понятна пользователю. Некоторое недоумение может вызвать лишь четвёртый ход белых. Так в **ZSG** выглядит [рокировка](https://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%BA%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0). Часть описания хода до символа '**@**' вполне понятна — это одновременное перемещение ладьи и короля, но что следует далее? Таким образом, в **ZSG**, выглядит сброс атрибутов фигур, выполнение которого необходимо для того чтобы не дать возможность выполнить рокировку повторно.
**Примечание****ZoG** использует **ZSG**-нотацию ещё и для того, чтобы показать ход игры в форме, понятной игроку. Справа от изображения доски, может быть открыто вспомогательное окно «Moves List». Этот список может использоваться для навигации по записи партии (не очень удобной, поскольку древовидное представление альтернативных ветвей игры не поддерживается). Часть записи ходов, связанная с изменением атрибутов фигур, пользователю не отображается.
Запись хода в **ZSG**-нотации должна содержать полную информацию, достаточную для корректного изменения игрового состояния. Если бы информация об изменении атрибутов не сохранялась, партия, по такой записи, могла бы быть воспроизведена некорректно (например, у игрока имелась бы возможность повторного выполнения рокировки). К сожалению, в DLL-расширения (такие как **Axiom**), расширенная информация может не передаваться.
Работая с DLL-расширениями, **ZoG** вынуждена производить довольно хитрую манипуляцию при выполнении позиционирования на выбранный ход (например, при откате хода). Из предыдущей позиции, генерируются **все** возможные ходы, после чего, в списке, выполняется поиск выбранного хода по его **ZSG**-представлению. Сгенерированный ход применяется к игровому состоянию, возможно выполняя побочные действия, не отражённые в его **ZSG**-представлении.
Ситуация усугубляется ещё и тем, что единственным способом получения игрового состояния, на момент какого-то хода в прошлом, является последовательное применение всех ходов, с начала партии, к начальному состоянию доски. В действительно [сложных случаях](http://habrahabr.ru/post/234587/), подобная навигация происходит не быстро. Другой недостаток **ZSG**-нотации может проиллюстрировать запись следующего хода из партии [Го](https://ru.wikipedia.org/wiki/%D0%93%D0%BE):
```
1. White Stone G19 x A19 x B19 x C19 x D19 x E19 x F19
```
Здесь, в позицию G19, устанавливается белый камень, что приводит к снятию группы чёрных камней. Поскольку все фигуры, задействованные при выполнении хода, должны быть упомянуты в **ZSG**-представлении, запись хода может оказаться очень длинной (в Го, одним ходом может быть снято до 360 камней). К чему это может привести, я уже писал [ранее](http://habrahabr.ru/post/235483/). Размера буфера, выделяемого **ZoG** под запись хода, может и не хватить. Кроме того, если по каким-то причинам порядок снятия камней изменится (в процессе разработки игры такое бывает), попытка применения хода, со старым порядком взятий, закончится ошибкой.
К счастью, имеется простой способ борьбы со всеми этими проблемами. Посмотрим на то, как определяются ходы фигур в **ZRF**:
```
(piece
(name Pawn)
(image White "images\Chess\SHaag\wpawn.bmp" "images\Chess\wpawn.bmp"
Black "images\Chess\SHaag\bpawn.bmp" "images\Chess\bpawn.bmp")
(moves
(Pawn-capture nw)
(Pawn-capture ne)
(Pawn-move)
(En-Passant e)
(En-Passant w)
)
)
```
Имена ходов, определяемых в **ZoG** макросами, генератору ходов недоступны. Но что нам мешает отказаться от макросов и сделать описания ходов именованными? Вот как будет выглядеть запись шахматной партии:
```
1. e2 - e4 Pawn-move
1. e7 - e5 Pawn-move
2. g1 - f3 leap2 n nw
2. b8 - c6 leap2 n ne
3. f1 - c4 slide nw
3. g8 - f6 leap2 n nw
4. e1 - g1 O-O
4. d7 - d5 Pawn-move
5. e4 x d5 Pawn-capture nw
5. f6 x d5 leap2 w nw
```
**Примечание**Внимательные читатели могут заметить, что в ходах «за чёрных» я использовал направления, не соответствующие направлениям на шахматной доске. Это связано с тем, что для чёрных определена «симметрия»:
```
(symmetry Black (n s)(s n) (nw sw)(sw nw) (ne se)(se ne))
```
Грубо говоря, то, что для белых является «севером», для чёрных является «югом», и наоборот.
Польза от такой записи не очевидна, но у неё есть одно важное достоинство. Все ходы описаны в единой форме и эти описания не содержат ничего лишнего (имена описаний ходов, конечно, можно было бы сделать и более «говорящими»). В описании рокировки удалось избавиться и от изменения атрибутов и даже от описания хода ладьи (такое описание больше не зависит от подробностей реализации хода). Еще более наглядна полезность такой записи в случае игры Го:
```
1. G19 drop-to-empty White Stone
```
И это всё! Если камни противника забираются, в соответствии с правилами игры, нет никакой необходимости перечислять их все в описании хода. Достаточно указать начальное и конечное поле перемещения (возможно с признаком взятия), имя выполняемого хода и строку передаваемых ему параметров. Разумеется, чтобы выполнить ход, по такому описанию, за расшифровкой, придётся обратиться к модулю генерации ходов, но **ZoG** и так это делает!
**Примечание**В очень редких, можно сказать, экзотических [случаях](http://www.chessvariants.org/other.dir/ultima.html), может потребоваться выполнение хода, заключающегося лишь во взятии фигуры (своей или противника). Запись такого хода, в новой нотации, будет выглядеть следующим образом:
```
1. x G19 capture-piece
```
Ещё одной возможностью, которую следует поддерживать, является функциональность «частичных» ходов. Вот пример из "[Русских шашек](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BA%D0%B8#.D0.A0.D1.83.D1.81.D1.81.D0.BA.D0.B8.D0.B5_.D1.88.D0.B0.D1.88.D0.BA.D0.B8)":
```
1. Checker g3 - f4
1. Checker f6 - g5
2. Checker e3 - d4
2. partial 2 Checker g5 - e3 = XChecker on f4
2. Checker e3 - c5 = XChecker on d4 x d4 x f4
```
Здесь чёрные, на втором ходу, берут две фигуры на d4 и f4. Предварительное «превращение» фигур в **XChecker** является особенностью реализации и служит для предотвращения возможности повторного взятия «битых» фигур на том же ходу. Фраза "**partial 2**" описывает начало «составного» хода, состоящего из двух «частичных» ходов. Такая форма описания неудобна, поскольку на момент генерации первого хода, длина последовательности «частичных» ходов может быть неизвестна. Вот как будет выглядеть это описание в новом формате:
```
1. g3 - f4 checker-shift nw
1. f6 - g5 checker-shift ne
2. e3 - d4 checker-shift nw
2. + g5 - e3 checker-jump nw
2. + e3 - c5 checker-jump sw
2. +
```
Подробности реализации, связанные с «превращением» фигур излишни. Взятие фигур также не следует указывать, поскольку, в шашках, взятие выполняется как «побочный эффект» хода фигуры, а не по «шахматному принципу». Частичный ход будет кодироваться символом "**+**" в начале строки. Одиночный "**+**" означает завершение «составного хода» (на самом деле, это обычный «частичный» ход, содержащий в себе пропуск хода — пустую строку).
Таким образом, используя именованные правила выполнения ходов, удалось создать универсальную нотацию, полностью удовлетворяющую нашим требованиям. Разумеется, она не имеет ничего общего ни с общепринятой шахматной ни с какой либо другой нотацией, но так уж сложилось, что общепринятые нотации для шахмат, шашек и прочих игр тоже не имеют ничего общего между собой. Модуль визуализации всегда может выполнить преобразование записи хода в более привычную форму, принятую для конкретной игры. Также, может быть выполнено преобразование в какую либо иную универсальную форму, например [SGF](http://ru.wikipedia.org/wiki/Smart_Game_Format).
#### **Жизненный цикл игры**
Наряду с информацией о размещении фигур на доске, очередность хода является составной частью состояния, изменяемого в процессе игры. В простейшем (и наиболее распространённом) случае, для хранения этой информации достаточно одного бита, но **ZoG** предоставляет чуть больше возможностей, для реализации более сложных случаев. Вот как могло бы выглядеть описание последовательности ходов для игры [Splut!](http://www.iggamecenter.com/info/ru/splut.html):
```
(players South West North East)
(turn-order
South
West West
repeat
North North North
East East East
South South South
West West West
)
```
В этой игре, каждый из игроков делает по три хода за раз, но если первому игроку дать возможность сделать три хода из начальной позиции, он сможет уничтожить одну из фигур противника, что даст ему серьёзное преимущество. По этой причине, первый игрок должен делать один ход (это даёт возможность подготовиться к атаке игрока, расположенного напротив, но не атаковать его), второй — два хода (этого также недостаточно для нападения на противостоящего игрока), после чего, каждый игрок всегда делает по три хода.
Метка **repeat** обозначает начало циклически повторяющейся последовательности ходов. Если она отсутствует, циклически повторяется всё описание. **ZoG** позволяет использовать метку **repeat** не более одного раза. Другой важной возможностью является определение **режима** хода. Вот как может выглядеть описание последовательности ходов игры, в которой каждый из игроков выполняет по два хода (первый ход — перемещение фигуры, второй — взятие фигуры противника):
```
(players White Black)
(turn-order
(White normal-move)
(White capture-move)
(Black normal-move)
(Black capture-move)
)
```
Есть ещё одна возможность, связанная с описанием ходов чужими фигурами, но она крайне неудобна в использовании. Дело в том, что такое описание безальтернативно. Если в описании указано, что ход должен осуществляться фигурой противника, игрок обязан выполнить такой ход! В **ZoG** невозможно описать ход "**на выбор**" своей или чужой фигурой. Если такая возможность в игре необходима (как например в "[Ставропольских шашках](http://zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=2247)"), приходится делать нейтральными все фигуры (создавая для этой цели игрока, не участвующего в игре) и определять для всех игроков возможность хода нейтральными фигурами. Выше, я уже говорил о том, что гораздо проще изначально разрешить игрокам возможность хода любыми фигурами (как своими так и противника), добавив необходимые проверки в алгоритмы генерации хода.
Как можно видеть, набор возможностей, предоставляемых **ZoG**, для описания последовательности ходов, крайне ограничен. **Axiom** также не добавляет новых возможностей, поскольку (обычно) выполняется поверх **ZoG**. **Ludi**, в этом отношении, еще беднее. С целью максимальной унификации игровых правил (необходимой для возможности использования генетических алгоритмов), в этом проекте, сознательно упрощаются все описательные возможности, что приводит к отсечению целых пластов игр.
"[Бао суахили](http://skyruk.livejournal.com/390109.html)" является хорошим примером игры со сложным жизненным циклом. В этой игре две фазы, правила выполнения хода в которых существенно различаются. В начале игры, часть камней находится «в руке» каждого из игроков. Пока камни «в руке» не кончились, происходит вброс камней в лунки, по одному камню. Когда камни «в руке» заканчиваются, начинается вторая фаза игры, связанная с перераспределением вброшенных камней. Нельзя сказать, что эту игру невозможно описать на **ZRF** (языке описания **ZoG**), но из за ограничений **ZoG**, подобная реализация получилась бы крайне запутанной (что безусловно не лучшим образом отразилось бы на качестве работы AI). Посмотрим, как описание подобной игры могло бы выглядеть в «идеальном мире»:
```
(players South North)
(turn-order
(turn-order
(South p-i-move)
(North p-i-move)
)
(label phase-ii)
(turn-order
(South p-ii-move)
(North p-ii-move)
)
)
```
Здесь, каждый список **turn-order** определяет свою повторяющуюся последовательность ходов (различающуюся режимом выполнения хода). Ключевое слово **label** определяет метку, переход по которой может быть сформирован при генерации очередного хода. Можно заметить, что здесь мы исходим из неявного предположения о том, что такой переход всегда происходит после хода второго игрока (в противном случае будет нарушена последовательность ходов). Как выполнить переход к следующей фазе в произвольный момент времени?
```
(players South North)
(turn-order
(turn-order
(South p-i-move)
(North p-i-move)
)
(turn-order
(labels - phase-ii)
(South p-ii-move)
(labels phase-ii -)
(North p-ii-move)
)
)
```
Здесь метки перенесены в тело цикла и содержат по два имени. Имена меток, в списках **labels** перечисляются в соответствии с порядком перечисления игроков в списке **players**. Имя, используемое для перехода, определяется в зависимости от того, какой из игроков выполнил ход последним. Если это был **North**, будет выполнен переход к первой метке, в противном случае — ко второй. Если какое либо из имён в **labels** не будет использоваться, соответствующую позицию можно заполнить прочерком.
Важным моментом, в управлении чередованием ходов, является возможность выполнения повторного хода. В играх семейства [Нард](https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D1%80%D0%B4%D1%8B), таких как [Ур](http://skyruk.livejournal.com/231444.html?thread=4494868), например, возможность выполнения повторных ходов является важным элементом игровой тактики. В **ZoG** можно использовать пропуск хода, для эмуляции этой возможности, но такой подход существенно запутывает описание игры (особенно при участии нескольких игроков). Гораздо логичнее использовать метку для повторения хода:
```
(players South North)
(turn-order
(label repeat)
South
(label repeat)
North
)
```
Выполнив переход к **repeat**, игрок вернётся к повторению последнего хода (при этом будет действовать метка, ближайшая к текущему положению в списке ходов). Мне нравится подход [Perl](https://ru.wikipedia.org/wiki/Perl) в части неявных определений. Неявная генерация управляющих структур может существенным образом упростить описание. Поскольку повторные ходы могут быть использованы во многих играх, метки **repeat**, предваряющие каждый ход, можно формировать неявно:
```
(players South North)
(turn-order
South
North
)
```
Более того, поскольку последовательность ходов полностью соответствует перечислению игроков в **players**, автоматически можно формировать всю фразу **turn-order**:
```
(players South North)
```
Чем проще получится описание — тем лучше.
#### **Нарушаемый инвариант**
Главное, что мне не нравится в **ZoG** можно выразить одним словом — **checkmated**. На первый взгляд, это просто условие (весьма распространённое в играх шахматного семейства), связывающее завершение игры с образованием [матовой ситуации](http://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%82_(%D1%88%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B)). Увы, при более пристальном рассмотрении, простота оказывается обманчивой. Использование этого ключевого слова подразумевает не только выполнение, после каждого хода, проверок завершения игры, но и навязывает игроку определённое «поведение».
И модуль генерации ходов и AI должны учитывать, что после выполнения хода, свой король не должен оказываться под [шахом](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85_(%D1%88%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B)). При этом, недостаточно выполнять проверку только для сходившей фигуры, шах вполне может быть "[открытым](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85_(%D1%88%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B)#.D0.92.D1.81.D0.BA.D1.80.D1.8B.D1.82.D1.8B.D0.B9_.D1.88.D0.B0.D1.85)". Правильно реализовать все необходимые проверки непросто (во всяком случае, в **ZoG** этого сделать не удалось):
От обычного [Сёги](http://ru.wikipedia.org/wiki/%D0%A1%D1%91%D0%B3%D0%B8) эта игра отличается только количеством игроков. К сожалению, этого отличия достаточно, чтобы сделать работу **checkmated** (и всей связанной с этим словом «магии») некорректной. Правильная проверка нахождения под шахом выполняется лишь по отношению к одному из игроков. В результате, король вполне может оказаться под ударом и быть съеденным! Разумеется это не лучшим образом отражается и на работе AI.
Если эта проблема кажется незначительной, стоит вспомнить о коалициях, обычно образуемых в играх четырёх игроков «пара на пару». В случае образования коалиций, мы должны учитывать, что дружественные фигуры королю не угрожают! Так, например, два дружественных короля вполне могут размещаться на соседних полях доски.
Еще больше всё усложняется если королей у игрока может быть несколько. В "[Шахматах Тамерлана](http://skyruk.livejournal.com/283735.html)", королевская пешка превращается в принца (фактически, во второго короля). Если такое произошло, победить можно лишь съев первого короля (любого из двух) и заматовав второго. В этой игре, можно получить и третьего короля, дважды проведя на поле превращения «пешку пешек»! Выразительных возможностей "**checkmated**" недостаточно для адекватного описания этой ситуации.
Другой сложностью может стать сам процесс матования. Так в монгольском варианте шахмат ([Шатар](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%82%D0%B0%D1%80_%D0%B8_%D1%85%D0%B8%D0%B0%D1%88%D0%B0%D1%82%D0%B0%D1%80)), результат матования зависит от порядка, в котором фигуры выполняют последовательные «шахи». Результатом может оказаться и победа и ничья (например при мате пешкой) и даже поражение (конём матовать запрещено, но можно ставить шах). Чуть менее экзотичны, в этом плане, японские Сёги. В этой игре, запрещено ставить мат сбросом пешки, но можно шаховать сбросом пешки, а также матовать ходом пешки.
**Примечание**Стоит упомянуть о ещё одном важном моменте. В некоторых играх, таких как [Ритмомахия](http://habrahabr.ru/post/234587/), вариантов завершения может быть несколько. Наиболее очевидный способ одержать победу, связанный с уничтожением фигур противника, в то же время, является наименее предпочтительным. Для более значимой победы, следует выстроить фигуры, на территории противника, определённым образом.
Следует различать типы побед (а также поражений и ничьих) на уровне описания игры, поскольку тип завершения игры может потребоваться игроку. Кроме того, должна иметься возможность назначения числовых приоритетов различным вариантам завершения. При одновременном выполнении различных условий завершения, должно рассматриваться то из них, которое имеет максимальный приоритет.
Очевидно, что необходимо отделять логику проверки завершения игры от проверки попадания короля под шах, являющейся, по сути, [инвариантом](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D0%B2%D0%B0%D1%80%D0%B8%D0%B0%D0%BD%D1%82_(%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)), проверяемым после выполнения каждого хода. Нарушение инварианта делает выполнение хода невозможным (ход изымается из списка доступных ходов). Вот так (упрощенно) может выглядеть проверка попадания короля под шах для «Шахмат Тамерлана»:
```
(verify
(or
(> (count (pieces my? (is-piece? King))) 1)
(= (count (pieces my? (is-piece? King) is-attacked?)) 0)
)
)
```
Важно понимать, что эта проверка должна выполняется только для собственных королей (я использовал предикат **my?**, поскольку, при поддержке коалиций, атрибут **friend?** будет удовлетворяться не только для собственных фигур, но и для фигур дружественного игрока). Допустима (и желательна) ситуация, в которой вражеский король попадает под шах, после выполнения хода, но в отношении собственного короля, такая ситуация должна быть невозможной! При условии поддержки проверки подобных инвариантов, проверка завершения игры матом становится тривиальной. Если нет возможных ходов и король находится под шахом — игра проиграна:
```
(loss-condition
(and
(= (count moves) 0)
(> (count (pieces my? (is-piece? King) is-attacked?)) 0)
)
)
```
Возможность определения инвариантов будет полезной и в других играх, например в [шашках](http://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BA%D0%B8). Наибольшая сложность, в реализации игр этого семейства, связана с реализацией «правила большинства». Практически во всех шашечных играх, ход со взятием является обязательным. Также, для большинства игр этого семейства, характерно выполнение «цепочек взятий», в рамках одного хода. Фигура, выполнившая взятие, продолжает брать другие фигуры, если это возможно. В большинстве игр, игрок обязан довести цепочку взятий до конца, но есть и исключения из этого правила, например [Фанорона](http://www.iggamecenter.com/info/ru/fanorona.html).
Используя механизм частичных ходов, «цепочки взятий» реализовать довольно просто. Сложности начинаются, когда, в дополнение к этому, накладывается условие, по которому, из всех возможных вариантов, требуется выбрать цепочку, берущую максимальное количество фигур. В **ZoG** эта логика вновь реализована на уровне «хардкода»:
```
(option "maximal captures" true)
```
Такая настройка подходит для "[Международных шашек](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BA%D0%B8#.D0.9C.D0.B5.D0.B6.D0.B4.D1.83.D0.BD.D0.B0.D1.80.D0.BE.D0.B4.D0.BD.D1.8B.D0.B5_.D1.88.D0.B0.D1.88.D0.BA.D0.B8)", но в "[Итальянских шашках](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BA%D0%B8#.D0.98.D1.82.D0.B0.D0.BB.D1.8C.D1.8F.D0.BD.D1.81.D0.BA.D0.B8.D0.B5_.D1.88.D0.B0.D1.88.D0.BA.D0.B8)" правило большинства формулируется иначе. В этом варианте игры, если имеется несколько вариантов с одинаковым количеством взятий, требуется выбрать вариант, в котором берётся больше превращенных шашек (дамок). Разработчики **ZoG** предусмотрели это, введя следующее значение настройки:
```
(option "maximal captures" 2)
```
При использовании этой настройки, учитывается не только количество взятых фигур, но и их тип. К сожалению, всего предусмотреть невозможно. Вот как формулируется «правило большинства» в "[Старофранцузских шашках](http://skyruk.livejournal.com/256132.html)":
> ***Если при серии взятий можно рубить одинаковое количество шашек простой шашкой или дамкой, игрок обязан брать дамкой. Однако если количество снимаемых шашек одинаково в обоих случаях, но в одной <ветке> есть дамки противника (или их там больше), игрок обязан выбрать именно этот вариант, даже если тогда придется рубить простой шашкой, а не дамкой***.
Конечно, в настоящее время, в этот вариант шашек почти никто не играет, но само его существование наглядно демонстрирует недостатки «хардкодной» реализации. Использование механизма инвариантов позволяет реализовать все возможные варианты «правила большинства» универсальным образом. Для «Старофранцузских шашек» реализация будет следующей:
```
(verify
(>= capturing-count max-capturing-count)
)
(if (> capturing-count max-capturing-count)
(let max-capturing-count capturing-count)
(let max-capturing-sum capturing-sum)
(let max-attacking-value attacking-value)
)
(verify
(>= capturing-sum max-capturing-sum)
)
(if (> capturing-sum max-capturing-sum)
(let max-capturing-sum capturing-sum)
(let max-attacking-value attacking-value)
)
(verify
(>= attacking-value max-attacking-value)
)
(let max-attacking-value attacking-value)
```
Здесь, мы исходим из предположения, что правила генерации хода корректным образом заполняют локальные переменные:
* **capturing-count** — количество взятых фигур
* **capturing-sum** — суммарное достоинство взятых фигур
* **attacking-value** — достоинство фигуры, выполняющей ход
С каждой из этих переменных связано значение-аккумулятор, сохраняемое в переменной с префиксом **max**. Последовательно выполняются три проверки. Нарушение любого из условий **verify** немедленно прерывает генерацию очередного хода (ход не сохраняется в списке возможных ходов). Поскольку выполняемые проверки связаны с изменяемыми значениями, этого недостаточно для корректной работы условий. Каждая такая проверка формирует «нарушаемый инвариант», связанный со сгенерированным ходом. После каждого изменения значения аккумулятора, повторно проверяются все связанные с ним инварианты. При нарушении любого из условий, ранее сгенерированный ход удаляется из списка возможных ходов.
**Примечание**Есть еще одна возможность **ZoG**, используемая в реализации шашек. В случае если есть возможность взятия или «тихого хода», ход, выполняющий взятие, считается более приоритетным:
```
(move-priorities jumptype nonjumptype)
(piece
(name Checker)
(image Red "images\Checkers\Shaag\chkrRM.bmp" "images\Checkers\chkrRM.bmp"
Black "images\Checkers\Shaag\chkrBM.bmp" "images\Checkers\chkrBM.bmp")
(moves
(move-type jumptype)
(checker-jump nw)
(checker-jump ne)
(move-type nonjumptype)
(checker-shift nw)
(checker-shift ne)
)
)
```
Подобное объявление приоритетов также становится излишним, при использовании механизма нарушаемых инвариантов.
#### **Заключение**
В этой статье я постарался рассказать о своих планах по созданию нового универсального «движка» для разработки абстрактных логических игр и головоломок. Я отдаю себе отчёт в том, что работа эта не на один месяц (возможно даже и не на год), но, в данном случае, процесс, для меня, намного важнее результата. Я не планирую извлекать из этой работы какой либо выгоды и уж, тем более, не планирую закрывать исходные коды проекта. Если и будет использоваться какая-то лицензия, то я постараюсь найти самый либеральный вариант. Я буду рад, если к моей работе кто-то присоединится, но если таковых не найдётся, тоже сильно переживать не буду.
***Viam supervadet vadens***. | https://habr.com/ru/post/242547/ | null | ru | null |
# 11 анонсов конференции Microsoft Build для разработчиков
Привет, Хабр! Сегодня, как и обещали\*, делимся подборкой самых интересных для разработчиков конференции Microsoft Build 2021. Их получилось 11, но это не значит, что это все. Чтобы узнать еще больше, изучайте [сайт](https://register.build.microsoft.com/) конференции.
*\* пообещали это мы во вчерашней подборке* [*8 анонсов конференции Microsoft Build 2021*](https://habr.com/ru/company/microsoft/blog/559252/)*, которую подготовила наша бизнес-команда.*
1. Представлен Windows Terminal Preview 1.9
-------------------------------------------
Поздравляем с Microsoft Build 2021 и вторым днем рождения Windows Terminal! Этот выпуск представляет версию 1.9 для Windows Terminal Preview и переносит Windows Terminal в версию 1.8. Как всегда, вы можете установить обе сборки из Microsoft Store, а также со страницы выпусков GitHub.
Среди новинок:
* Дефолтный терминал
* Quake mode
* Обновления Cascadia Code
* Обновления интерфейса настроек
* Другие улучшения
**Подробнее** [**здесь**](https://devblogs.microsoft.com/commandline/windows-terminal-preview-1-9-release/)**.**
### 2. Представляем Visual Studio 2019 v16.10 и v16.11 Preview 1
Мы рады объявить о выпуске Visual Studio 2019 v16.10 GA и v16.11 preview 1. Этот выпуск делает нашу тему продуктивности и удобства разработчиков общедоступной для пользователей Visual Studio! Мы добавили функции C ++ 20, улучшили интеграцию с Git, улучшили инструменты профилирования и множество функций, повышающих продуктивность.
**Подробнее** [**здесь**](https://devblogs.microsoft.com/visualstudio/visual-studio-2019-v16-10-and-v16-11-preview-1-are-available-today/)**.**
### 3. Представляем .NET 6 Preview 4
Мы рады выпустить .NET 6 Preview 4. Мы почти наполовину закончили выпуск .NET 6. Это хороший момент, чтобы еще раз взглянуть на .NET 6 в полном объеме, как и в первом Preview. Многие функции находятся в близкой к окончательной форме, а другие появятся в ближайшее время, когда основные блоки будут готовы к выпуску. Предварительная версия 4 создает прочную основу для выпуска в ноябре финальной сборки .NET 6 с готовыми функциями и возможностями. Она также готова к тестированию в реальных условиях, если вы еще не пробовали .NET 6 в своей среде.
Говоря о финальном выпуске, у нас теперь запланирована дата! Добавьте в календарь даты с 9 по 11 ноября и .NET Conf 2021. Мы выпустим .NET 6 9-го числа с множеством подробных докладов и демонстраций, которые расскажут вам все, что вы хотите знать о .NET 6.
**Подробнее** [**здесь**](https://devblogs.microsoft.com/dotnet/announcing-net-6-preview-4/)**.**
### 4. Представляем .NET MAUI Preview 4
Сегодня мы рады объявить о доступности .NET Multi-platform App UI (.NET MAUI) Preview 4. Каждая предварительная версия представляет больше элементов управления и функций для этого многоплатформенного инструментария, который станет общедоступным в ноябре этого года на .NET Conf. .NET MAUI теперь имеет достаточно блоков для создания функциональных приложений для всех поддерживаемых платформ, новые возможности для поддержки запуска Blazor на настольных компьютерах и впечатляющий прогресс в Visual Studio для поддержки .NET MAUI.
**Подробнее** [**здесь**](https://devblogs.microsoft.com/dotnet/announcing-net-maui-preview-4/)**.**
### 5. Обновления ASP.NET Core в .NET 6 Preview 4
Версия .NET 6 Preview 4 уже доступна и включает много новых крутых улучшений в ASP.NET Core.
Вот что нового в этой предварительной версии:
* Добавлены minimal APIs
* Async streaming
* HTTP logging middleware
* Использование Kestrel для профиля запуска по умолчанию в новых проектах
* `IConnectionSocketFeature`
* Илучшенные шаблоны single-page app (SPA)
* Обновления .NET Hot Reload
* Ограничения generic type в компонентах Razor
* Blazor error boundaries
* Компиляция Blazor WebAssembly ahead-of-time (AOT)
* Приложения .NET MAUI Blazor
* Другие улучшения производительности
**Подробнее** [**здесь**](https://devblogs.microsoft.com/aspnet/asp-net-core-updates-in-net-6-preview-4/)**.**
### 6. Представляем Entity Framework Core 6.0 Preview 4: Performance Edition
Группа Entity Framework Core анонсировала четвертый предварительный выпуск EF Core 6.0. Основная тема этого выпуска - производительность.
Что нового:
* Производительность EF Core 6.0 теперь на 70% выше в стандартном для отрасли тесте TechEmpower Fortunes по сравнению с 5.0.
* Улучшение производительности полного стека, включая улучшения в тестовом коде, среде выполнения .NET и т. д. Сам EF Core 6.0 на 31% быстрее выполняет запросы.
* Heap allocations уменьшены на 43%.
**Подробнее** [**здесь**](https://devblogs.microsoft.com/dotnet/announcing-entity-framework-core-6-0-preview-4-performance-edition/)**.**
### 7. Представляем .NET Hot Reload для редактирования кода во время выполнения
Рады представить вам возможность горячей перезагрузки .NET в Visual Studio 2019 версии 16.11 (предварительная версия 1) и с помощью инструментария командной строки dotnet watch в .NET 6 (предварительная версия 4). В полной статье коллеги познакомят вас с тем, что такое .NET Hot Reload, как вы можете начать использовать эту функцию, каково наше видение будущих запланированных улучшений и проснят, какой тип редактирования и языки в настоящее время поддерживаются.
**Подробнее** [**здесь**](https://devblogs.microsoft.com/dotnet/introducing-net-hot-reload/)**.**
### 8. SecretManagement Module v1.1.0
Следующая версия SecretManagement 1.1.0 содержит ряд мелких исправлений, а также два значительных изменения, одно из которых потенциально критично для авторов расширений. Для получения дополнительной информации об изменениях в этом выпуске см. [документ CHANGELOG](https://github.com/PowerShell/SecretManagement/blob/master/CHANGELOG.md). В статье ниже обсуждаются основные изменения, почему они потенциально очень важны и особенно актуальны для владельцев хранилищ расширений, которые могут захотеть протестировать свое хранилище и внести какие-либо изменения, пока эти обновления находятся в состоянии предварительной версии.
**Подробнее** [**здесь**](https://devblogs.microsoft.com/powershell/secretmanagement-module-v1-1-0-preview-update/)**.**
### 9. Новый бесплатный курс: создание бессерверных приложений с полным стеком в Azure
Независимо от того, новичок вы или опытный в облаке, разработке и SQL, создание и проектирование приложений в облаке стало необходимым навыком для многих ролей. Сегодня мы рады объявить о новом пути обучения, который поможет разработчикам с любым уровнем подготовки научиться быстро и эффективно создавать приложения с помощью Azure. Новый путь обучения - [создание бессерверных полнофункциональных приложений в Azure](https://docs.microsoft.com/ru-ru/learn/paths/build-serverless-full-stack-apps-azure/).
**Подробнее** [**здесь**](https://devblogs.microsoft.com/azure-sql/launch-build-serverless-full-stack-applications-in-azure/)**.**
### 10. .NET Framework May 2021
Выпущена предварительная версия накопительного обновления для .NET Framework за май 2021 года.
**Подробнее** [**здесь**](https://devblogs.microsoft.com/dotnet/net-framework-may-2021-cumulative-update-preview-for-windows-10-versions-2004-20h2-21h1/)**.**
### 11. Представляем сборку OpenJDK от Microsoft
Объявлена общая доступность сборки OpenJDK от Microsoft, нового бесплатного дистрибутива OpenJDK с открытым исходным кодом, доступного бесплатно для всех, с возможностью развертывания его где угодно. Корпорация Майкрософт активно использует Java, внутри компании работает более 500 000 JVM. Группа разработчиков Java очень гордится тем, что вносит свой вклад в экосистему Java и помогает управлять такими рабочими нагрузками, как LinkedIn, Minecraft и Azure!
Сборка включает двоичные файлы для Java 11, основанные на OpenJDK 11.0.11 + 9 x64 server и настольных средах в macOS, Linux и Windows. Мы также публикуем новый двоичный файл раннего доступа для Java 16 для Linux и Windows на ARM, основанный на последней версии OpenJDK 16.0.1 + 9.
Этот новый выпуск Java 16 уже используется миллионами игроков Minecraft с последней версией Minecraft Java Edition Snapshot [21W19A](https://www.minecraft.net/article/minecraft-snapshot-21w19a), которая была обновлена для объединения среды выполнения Java 16 на основе сборки Microsoft OpenJDK.
Посетите [страницу](https://www.microsoft.com/openjdk), чтобы узнать подробности.
**Подробнее** [**здесь**](https://devblogs.microsoft.com/java/announcing-general-availability-of-microsoft-build-of-openjdk/)**.** | https://habr.com/ru/post/559454/ | null | ru | null |
# Laravel-Дайджест (29 июня – 5 июля 2020)
Подборка новых статей по фреймворку Laravel. Разберемся как работает шифрование во фреймворке. Аутентифицируем пользователя по отпечатку пальца. Развернём приложение по методу zero-downtime. Спарсим данные с сайтов и выведем в удобной для себя форме. И устроим видео-стриминг.
Новости
-------
* В твиттере Тейлора 80% проголосовали за модельки в папке app/Models. В Laravel 4 модельки хранились в папке app/models, затем, начиная с пятой версии их, по дефолту, кидали в корень папки app. И, наконец, в 8-ой версии они снова получают свою собственную папку :)
* Samuel Stancl продавал pdf-версию «Laravel Clean Code Tactics» за 10$ с возможностью выбрать варианты: light/dark/markdown/printable-markdown/web. Сейчас он разрешил скачивать её бесплатно: [gumroad.com/l/laravel-clean-code/free](https://gumroad.com/l/laravel-clean-code/free)
* Судя по печеньке `laravel_session`, сайт «[Электронного голосования по поправкам в Конституцию РФ](https://2020og.ru)» написан на Laravel.
На русском языке
----------------
* **[Как работает Шифрование в Laravel](https://laravel.demiart.ru/kak-rabotaet-shifrovanie-v-laravel/)**
* **[Как устроен Laravel signed URL](https://medium.com/@butschster/%D0%BA%D0%B0%D0%BA-%D1%83%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD-laravel-signed-url-3f5465add3b4)**
* **[Продвинутый model attribute casting в Laravel](https://medium.com/@butschster/%D0%BF%D1%80%D0%BE%D0%B4%D0%B2%D0%B8%D0%BD%D1%83%D1%82%D1%8B%D0%B9-model-attribute-casting-%D0%B2-laravel-86d48e80b2b5)**
* **[Выводим работу с политиками в Laravel на новый уровень](https://medium.com/@butschster/%D0%B2%D1%8B%D0%B2%D0%BE%D0%B4%D0%B8%D0%BC-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%83-%D1%81-%D0%BF%D0%BE%D0%BB%D0%B8%D1%82%D0%B8%D0%BA%D0%B0%D0%BC%D0%B8-%D0%B2-laravel-%D0%BD%D0%B0-%D0%BD%D0%BE%D0%B2%D1%8B%D0%B9-%D1%83%D1%80%D0%BE%D0%B2%D0%B5%D0%BD%D1%8C-7c7e2d7e69da)**
На английском
-------------
### Релизы
* **[Laravel 7.18](https://github.com/laravel/framework/releases/tag/v7.18.0)**
6 нововведений и 2 исправления
* **[Guzzle 7](https://laravel-news.com/guzzle-7-released)**
Новая мажорная версия популярного http-клиента
* **[Laravel Livewire 1.3](https://github.com/livewire/livewire/releases)**
5 нововведений и пачка фиксов
* **[LaraLens 0.1.10](https://dev.to/robertobutti/laralens-a-laravel-command-for-inspecting-configuration-5b89)**
Пакет для показа текущей конфигурации проекта
* **[Laravel Media Uploader 2.0](https://laravel-news.com/laravel-media-uploader)**
Пакет загружает файлы с помощью Spatie Media Library перед сохранением модели
* **[Каркасный пресет Tailwind CSS для Laravel](https://github.com/tailwindcomponents/laravel-preset)**
### Уроки
* **[Laravel+WebAuthn. Биометическая аутентификация](https://medium.com/@DarkGhostHunter/laravel-login-users-with-their-fingerprints-5161ecdca63b)**
* **[Парсим сайты и выводим результаты на Laravel + TailwindCSS](https://medium.com/@emymbenoun/web-scraping-101-lets-build-a-curated-list-using-laravel-7-and-tailwind-css-beca3ca98651)**
* **[Развёртываем приложение на лету без остановки с помощью Laravel Envoy](https://collectednotes.com/lsfiege/how-to-do-zero-downtime-deploys-for-a-laravel-app-with-envoy)**
* **[Статические фабричные методы для Laravel-моделей](https://carlalexander.ca/static-factory-methods-laravel/)**
* **[Автоматическая валидация Моделей](https://ryangjchandler.co.uk/articles/unconventional-laravel-auto-validating-models)**
* **[Руководство по установке и настройке CKEditor в Laravel. Загрузка и сохранение изображений](https://www.positronx.io/how-to-install-integrate-ckeditor-in-laravel/)**
* **[Laravel+Nginx. Организуем сервер для потокового видео](https://medium.com/@GaonLabs/video-streaming-with-nginx-and-laravel-838b66aacb47)**
* **[5 советов по работе с Eloquent-запросами](https://youtu.be/TuPdEbEBvo0)**
### Pusher
* **[Создание видеочата на Laravel+Vue+Pusher](https://medium.com/@otacorporation0520/create-a-video-chat-application-with-laravel-7-vue-js-based-on-webrtc-58c88a503c17)**
* **[Создание мобильного Flutter-приложения на Laravel и Pusher](https://carnou.com/20200704-integrating-flutter-with-laravel-and-pusher/)**
**Самые свежие уроки смотрите в наших каналах: [Телеграм](https://t.me/laravel_it), [Вконтакте](https://vk.com/laravel_it) и [Твиттер](https://twitter.com/laravel_it)**. | https://habr.com/ru/post/509662/ | null | ru | null |
# Мультимедиа прошлого: как слушали музыку в MS-DOS
Всего каких-то 26 лет назад прослушивать музыку на компьютере было не таким уж и простым делом. Еще до появления Windows 95, смело заявляющей о своей мультимедийности, люди слушали музыку прямо в среде MS-DOS. Причем не только трекерную, но и MP3. Стряхнем пыль со старого софта и погрузимся в чудесный мир музыки начала 90-х.
Для начала вспомним о популярных музыкальных форматах и оборудовании тех годов. В основном это были поздние 486DX и пришедшие им на смену Пентиумы с тактовой частотой от 60 до 133 МГц. Технология MMX (MultiMedia eXtensions), ускоряющая декодирование аудио- и видеопотоков, появилась лишь в 1997 году. Меломанам 1994 года приходилось довольствоваться тем что есть.
Без чего нельзя слушать музыку на компьютере? Разумеется, без звуковой карты. Это сейчас звук встраивается прямо в материнские платы и работает, что называется, «из коробки». Но раньше звуковых карт было не так-то уж и много. С 1989 года на рынке безраздельно правила Creative Technology со своим знаменитым семейством звуковых карт Sound Blaster. Разумеется, были и альтернативы в виде редкой и очень дорогой Gravis UltraSound (его еще называли «гусь» по сокращению GUS), а также доброго десятка ее клонов.
Последнее десятилетие 20-го века ознаменовалось бурным развитием трекерной музыки, корнями уходящей в семейство компьютеров [Amiga](https://habr.com/ru/company/selectel/blog/519832/). Эти компьютеры имели крутой звуковой сопроцессор, что позволяло воспроизводить достаточно качественную сэмплированную музыку. Существовали соответствующие форматы (нечто среднее между аудиозаписью и MIDI), позволявшие хранить сэмплы, последовательности и параметры воспроизведения нот.
Работа композитора была сродни работе программиста, поскольку требовалось закодировать воспроизведение каждой ноты используемым инструментом в необходимой последовательности с нужной высотой и эффектами. Получившиеся файлы стали именовать модулями, а сами они получили расширение MOD.
Сформировалась целая плеяда музыкантов, пишущих такую музыку. Зародившаяся в конце 1970-х годов киберкультура демосцены активно стала использовать трекерную музыку и развивать собственные форматы.
Так, например, появился знаменитый формат XM, созданный демогруппой Triton. В нем был значительно расширен список команд для создания эффектов и каналов. 16-битная поддержка и гибкость сделали этот формат основным для большинства трекерной музыки. Сообщество MOD-музыкантов исповедует принцип открытости своих произведений, что делает его схожим с движением Open Source.
Если вы выписывали журнал Хакер в эти годы, то почти в каждом прилагаемом компакт-диске можно было найти целую коллекцию трекерной музыки. Проиграть ее можно было как с помощью оригинального приложения-трекера, так и с помощью сторонних плееров, таких как [Open Cubic Player](https://www.cubic.org/player/index.html).
Удивительно, но факт. Если у вас был процессор 486DX2 и Windows 95, то для проигрывания MP3 требовались некоторые «танцы с бубном». Дело все в том, что ресурсов процессора на все банально не хватало и звук периодически прерывался. Так что если хотелось послушать MP3 с помощью [WinAMP](https://www.winamp.com/), то приходилось либо переключаться в режим Mono, либо вдвое уменьшать частоту дискретизации выходного сигнала. «Секретным оружием» как раз и был Cubic Player, запускаемый из-под DOS. Его возможностей вполне хватало, чтобы послушать MP3-трек 128 kbit/s в стерео-режиме.
С тех пор прошло уже много времени. Тем не менее, оценить работу Open Cubic Player можно и сейчас, воспользовавшись старой версией под MS-DOS (с помощью DosBox) или современной версией, доступной в репозиториях своего Linux-дистибутива.
Поскольку я использую OpenSUSE, то установка плеера сводится к простой команде:
```
sudo zypper install ocp
```
Уверен, что для Debian-like систем это также сработает с пакетным менеджером *apt*. Запускается командой *ocp*, после чего открывается встроенный файловый менеджер. Выбрав композицию, подтверждаем нажатием *Enter* и воспроизведение начинается.
Прелестью трекерных форматов был, разумеется, малый размер файлов. Во времена, когда операционная система помещалась на трех дискетах, MP3 был почти непозволительной роскошью. Шутка ли, каждый MP3-трек, сжатый в среднем качестве, занимал от 3 до 5 мегабайт дискового пространства. Сжатый с помощью ZIP-архиватора XM-трек той же длительности занимал всего лишь 300-500 килобайт.
Даже если вы ни разу специально не слушали музыку в формате XM, то в любом случае сталкивались с ней в программах для взлома лицензионного ПО (кряки и кейгены). Среди взломщиков встраивание трекерной музыки стало своего рода традицией. Такие треки еще называли чиптюнами (от англ. chiptune) за свой малый размер, в несколько десятков килобайт.
Open Cubic Player был отнюдь не единственным плеером под MS-DOS. Широкую популярность также получил [Mpxplay](http://mpxplay.sourceforge.net/), требующий как минимум 100 Mhz процессора и имеющий поддержку вполне современного комплекта форматов. Среди них есть и ставшие весьма популярными форматы сжатия аудио — как без потерь (ALAC, FLAC), так и с ними (Vorbis, MP3, WMA, etc… ). Плеер обладал широчайшими возможностями для своего времени, поддерживая даже воспроизведение аудиопотоков по сети (интернет-радио).
Развитие мультимедийных возможностей компьютеров в середине 90-х стало мейнстримом. Увеличивающиеся мощности и новые модели звуковых карт стали воспроизводить звук все качественнее, а появление новых технологий объемного звука совершили революцию как в создании музыки, так и в кинематографе и компьютерных играх. Что нас ждет еще через 20 лет, сказать сложно. Но, видя столь значительный прогресс, можно осторожно предположить, что это будет здорово!
[](https://slc.tl/XGAzn) | https://habr.com/ru/post/526328/ | null | ru | null |
# Создаем современное веб приложение. Знакомство с проектом и подготовка к работе. Часть 1
> В этой серии статей мы пройдем полный цикл создания клиентской части приложения и напишем небольшую библиотеку компонентов с использованием современного стека технологий.
>
>
Я пишу эту статью для начинающих Frontend разработчиков которые хотят создать свой первый JavaScript проект, и показать его всему миру Для этой серии статей я выбрал базовый стек который можно встретить в большинстве современных проектов. Чтобы не заскучать вы всегда можете добавить что-то свое, поэтому я рекомендую вам параллельно чтению статьи писать собственную реализацию и публиковать результаты работы на GitHub. Наверняка у вас есть десяток технологий, библиотек, фреймворков, инструментов, которые хочется попробовать, и разработка такого пет-проекта – это отличный вариант попробовать что-то новое.
Знакомство с проектом
---------------------
Основная идея проекта, который мы будем реализовывать – написать библиотеку компонентов на React с TypeScript, документировать и визуализировать ее с помощью Storybook и опубликовать ее как пакет в npm. Также мы настроим линтеры, добавим тесты на Jest, автоматизируем процесс тестирования с помощью Travis CI. Возможно в ходе работы добавится что-то еще, не стесняйтесь комментировать и предлагать свои решения.
Статья будет разделена на несколько частей чтобы мы могли детально рассмотреть каждый этап создания проекта.
Начало работы
-------------
Для начала нам нужно создать репозиторий на GitHub для нашего проекта:
Так выглядит окно создания моего нового репозитория. Вам нужно придумать имя и небольшое описание вашего репозитория. Для всех своих пет-проектов я всегда выбираю публичный тип репозитория, но сейчас GitHub предоставляет возможность бесплатно создавать и приватный репозиторий если ваша команда не больше трех человек. Также я сразу добавил MIT лицензию – это самый простой и распространенный вариант лицензии для Open Source проектов, если вам интересно больше узнать про лицензии можете посмотреть [этот сайт](https://choosealicense.com/) созданный GitHub.
Теперь клонируем новый репозиторий. GitHub предлагает клонировать с использованием SSH или HTTPS. Обычно я использую второй способ.
```
git clone https://github.com/Alexandrshy/react-ant.git
```
Если вы видите сообщения об удачной распаковке значит клонирование прошло успешно.
Также нам нужно сразу выполнить кеширование пароля, если это не сделать при следующих попытках сделать git push, git fetch, git clone вам будет необходимо вводить логин и пароль ([Подробнее об этом](https://help.github.com/en/github/using-git/which-remote-url-should-i-use)).
```
git config --global credential.helper osxkeychain
```
Переходим к созданию файла package.json. Для этого выполним команду:
```
npm init -y
```
После выполнения команды в репозитории вы можете видеть package.json файл с некоторыми заполненными полями, мой выглядит так:
```
{
"name": "react-ant",
"version": "1.0.0",
"description": "A set of light React components ",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"repository": {
"type": "git",
"url": "git+https://github.com/Alexandrshy/react-ant.git"
},
"keywords": [],
"author": "",
"license": "ISC",
"bugs": {
"url": "https://github.com/Alexandrshy/react-ant/issues"
},
"homepage": "https://github.com/Alexandrshy/react-ant#readme"
}
```
Внесем сразу небольшие изменения:
```
"keywords": [
"react",
"css",
"UI"
],
"author": {
"name": "Alex",
"email": "alexandrshy@gmail.com",
"url": "https://github.com/Alexandrshy"
},
"license": "MIT",
```
Я думаю тут все понятно, а для более детальной конфигурации вам может понадобится [эта документация](https://docs.npmjs.com/files/package.json).
Мы еще будем возвращаться к конфигурации package.json в ходе работы над проектом. Но сейчас пришло время сделать первый коммит.
```
git status
git add package.json
git commit -m "Init npm package"
git push
```
В двух словах что мы сделали: проверили историю изменений, проиндексировали измененный package.json, сделали коммит с простым и понятным коммит сообщением и после этого положили наши изменения в удаленный репозиторий. Теперь package.json и информация о новом коммите появились в нашем репозитории. Для работы с Git вы можете использовать IDE или GUI, но мне комфортнее делать все в консоли.
Линтеры
-------
Чтобы ваш код был чище (это особенно важно если над проектом работает несколько человек) вам обязательно нужен инструмент для анализа и выявления ошибок. В своих проектах я использую ESLint для проверки JavaScript кода. Он прост в установке и гибко настраиваемый.
Установим ESLint:
```
npm i -D eslint
```
Настроим конфигурационный файл:
```
./node_modules/.bin/eslint --init
```
Вы можете сконфигурировать ESLint вручную или использовать готовый набор правил. Мне нравится гайд от [Airbnb](https://github.com/airbnb/javascript). Я воспользовался следующими настройками:
```
? How would you like to use ESLint? To check syntax, find problems, and enforce code style
? What type of modules does your project use? JavaScript modules (import/export)
? Which framework does your project use? React
? Does your project use TypeScript? Yes
? Where does your code run? Browser
? How would you like to define a style for your project? Use a popular style guide
? Which style guide do you want to follow? Airbnb (https://github.com/airbnb/javascript)
? What format do you want your config file to be in? JavaScript
```
Так как мы планируем использовать TypeScript я сразу выбрал этот пункт в диалоговом окне, из-за чего получил ошибку *Cannot find module 'typescript'*, что логично потому что TypeScript мы еще не установили, давайте сразу исправим это:
```
npm i typescript
npm i -D @typescript-eslint/parser
```
После установки у вас появится конфигурационный файл eslintrc. Он уже сконфигурирован, но если в ходе разработки вы захотите добавить или изменить какие-то правила он придет вам на помощь.
Чтобы проверить работу ESLint, давайте создадим файл index.ts и сохраним туда следующий код:
```
var a
console
.log('a = ' + a)
a = 100
```
И запустим проверку:
```
./node_modules/.bin/eslint index.ts
```
Отлично, код из 5 строк имеет 7 ошибок и 1 предупреждение. И сразу ESLint предлагает мне автоматически исправить эти ошибки, давайте попробуем это сделать:
```
./node_modules/.bin/eslint index.ts --fix
```
И мы получаем такой код, без ошибок и с одним предупреждением о использовании console.log:
```
var a;
console
.log(`a = ${a}`);
a = 100;
```
Как вы можете видеть автоматический фикс работает, ошибки были исправлены, но код все еще выглядит достаточно некрасиво. Для форматирования кода лучшим инструментом на мой взгляд является [Prettier](https://prettier.io/). Давайте добавим его в наш проект:
```
npm i -D prettier-eslint
npm i -D prettier-eslint-cli
```
```
"scripts": {
"format": "prettier-eslint '**/*.{js,ts,tsx}' --write"
},
```
Я добавил опцию --write чтобы все отформатированный файлы перезаписывались. Проверим результат:
```
npm run format
```
index.ts
```
let a;
console.log(`a = ${a}`);
a = 100;
```
Все отлично работает. Вы также можете установить плагины для своей IDE чтобы форматировать файлы с помощью комбинаций клавиш или при сохранении изменений. Теперь давайте добавим скрипты в package.json:
```
"scripts": {
"eslint": "./node_modules/.bin/eslint '**/*.{js,ts,tsx}'",
"eslint:fix": "npm run eslint -- --fix",
"format": "prettier-eslint '**/*.{js,ts,tsx}' --write"
},
```
Идеальный вариант когда вы начинаете новый проект сразу настроить все линтеры, потому что если вы попытаетесь внедрить их в уже готовый проект вы можете увидеть большое количество ошибок и на их исправление потребуется куда больше времени, чем если бы вы изначально позаботились о качестве вашего кода.
Сохраняем изменения:
```
git add .
git commit -m "Added ESLint and Prettier"
git push
```
Pre-commit хук
--------------
Мы настроили ESLint и Prettier и создали скрипты для запуска вручную, но было бы хорошо делать это автоматически перед коммитом. Для этого мы можем воспользоваться Git хуками. Пакет [Husky](https://github.com/typicode/husky) дает возможность запускать скрипты перед выполнением `git commit`, а пакет [Lint-staged](https://github.com/okonet/lint-staged) позволяет проверять только индексируемые файлы по определенным фильтрам.
```
npm i -D husky lint-staged
```
Вернемся к package.json и добавим следующий код:
```
"husky": {
"hooks": {
"pre-commit": "lint-staged"
}
},
"lint-staged": {
"*.(js|jsx|ts|tsx)": [
"npm run eslint:fix",
"npm run format",
"git add"
]
},
```
Теперь перед каждый коммитом мы будем запускать проверку ESLint и Prettier для всех измененных js и ts файлов и после форматирования добавлять эти файлы в наш коммит.
Давайте снова протестируем файл index.ts:
```
var a;
console
.log(`a = ${a}`);
a = 100;
```
Только на этот сразу сразу проиндексируем этот файл и сделаем коммит:
```
git add index.ts
git commit -m "Testing pre-commit hook"
```
Если вы сейчас проверите файл index.ts вы увидите, что код был отформатирован. Прежде чем сохранить изменения файл будет будет проверяться и при необходимости форматироваться. Это позволяет быть уверенным в корректности файлов которые попадают в ваш репозиторий.
## Заключение
Нам осталось сохранить все изменения. Перед этим создадим файл *.gitignore* куда запишем *node\_modules*, нам не нужно чтобы папка с зависимостями попала в наш репозиторий. Также мы можем удалить файл index.ts, он нам в дальнейшем не понадобится.
```
git add .
git commit -m "Added husky and lint-staged"
git push
```
Весь результат работы вы сможете видеть в [репозитории](https://github.com/Alexandrshy/react-ant). Актуальное состояние проекта — это ветка мастер, и для каждой статьи я буду создавать отдельную ветку.
На этом мы остановимся, всем спасибо за внимание, увидимся в следующих частях.
### Ссылки
[npm документация](https://docs.npmjs.com/)
[ESLint официальный сайт](https://eslint.org/)
[Prettier-eslint](https://github.com/prettier/prettier-eslint)
[Prettier-eslint-cli](https://github.com/prettier/prettier-eslint-cli)
[Prettier расширение для VSCode](https://github.com/prettier/prettier-vscode)
[Husky](https://github.com/typicode/husky)
[Lint-staged](https://github.com/okonet/lint-staged) | https://habr.com/ru/post/476162/ | null | ru | null |
# Собственный поисковик по раздачам The Pirate Bay
В последнее время на хабре [стало популярно](http://habrahabr.ru/post/274449/) делать [собственные поисковики](http://habrahabr.ru/post/273777/) по RuTracker. Мне это показалось прекрасным поводом для того, чтобы отойти от скучной enterprise разработки и попробовать что-нибудь новое.
Итак, задача: реализовать на локалхосте поисковик по базе The Pirate Bay и попутно попробовать, что же такое frontend разработка и с чем её едят. Задача осложняется тем, что TPB не публикует своих дампов, в отличие от RuTracker, и для получения дампов требуется распарсить их сайт. В результате гугления и осмысления задачи я решил в качестве поисковика использовать [Elasticsearch](https://www.elastic.co/products/elasticsearch), для которого написать client-side only фронтенд на [AngularJS](https://angularjs.org/). Для получения данных я решил написать собственный парсер сайта TPB и отдельный загружатель дампа в индекс, оба на Go. Пикантность выбору придавал тот факт, что ни к Elasticsearch, ни к AngularJS я до этого ни разу не прикасался и именно их опробывание было моей настоящей целью.
### Парсер
Краткий осмотр сайта TPB показал, что каждый торрент имеет свою страницу по адресу "/torrent/{id}". Где id во-первых численные, во-вторых увеличиваются, в-третьих последний id можно посмотреть на странице "/recent" и потом перепробовать все id меньше последнего. Практика показала, что id увеличиваются не монотонно и не для каждого id есть корректная страница с торрентом, что потребовало дополнительной проверки и пропуска id.
Так как парсер подразумевает работу с сетью в несколько потоков, выбор Go был очевиден. Для разбора HTML я использовал модуль [goquery](http://github.com/PuerkitoBio/goquery).
Устройство парсера весьма просто: вначале запрашивается "/recent" и из неё получается максимальный id:
**Получаем последний id**
```
func getRecentId(topUrl string) int {
var url bytes.Buffer
url.WriteString(topUrl)
url.WriteString("/recent")
log.Info("Processing recent torrents page at: %s", url.String())
doc, err := goquery.NewDocument(url.String())
if err != nil {
log.Critical("Can't download recent torrents page from TPB: %v", err)
return 0
}
topTorrent := doc.Find("#searchResult .detName a").First()
t, pT := topTorrent.Attr("title")
u, pU := topTorrent.Attr("href")
if pT && pU {
rx, _ := regexp.Compile(`\/torrent\/(\d+)\/.*`)
if rx.MatchString(u) {
id, err := strconv.Atoi(rx.FindStringSubmatch(u)[1])
if err != nil {
log.Critical("Can't retrieve latest torrent id")
return 0
}
log.Info("The most recent torrent is %s and it's id is %d", t, id)
return id
}
}
return 0
}
```
Затем мы просто бежим по всем значениям id от максимального до нулевого и скармливаем полученные цифры в канал:
**Скучный цикл и немного синхронизации.**
```
func (d *Downloader) run() {
d.wg.Add(streams)
for w := 0; w <= streams; w++ {
go d.processPage()
}
for w := d.initialId; w >= 0; w-- {
d.pageId <- w
}
close(d.pageId)
log.Info("Processing complete, waiting for goroutines to finish")
d.wg.Wait()
d.output.Done()
}
```
Как видно из кода, с другой стороны канала запущено некоторое количество горутин, принимающих id торрента, скачивающих соответствующую страницу и обрабатывающую её:
**Обработчик страницы торрента**
```
func (d *Downloader) processPage() {
for id := range d.pageId {
var url bytes.Buffer
url.WriteString(d.topUrl)
url.WriteString("/torrent/")
url.WriteString(strconv.Itoa(id))
log.Info("Parsing torrent page at: %s", url.String())
doc, err := goquery.NewDocument(url.String())
if err != nil {
log.Warning("Can't download torrent page %s from TPB: %v", url, err)
continue
}
torrentData := doc.Find("#detailsframe")
if torrentData.Length() < 1 {
log.Warning("Erroneous torrent %d: \"%s\"", id, url.String())
continue
}
torrent := TorrentEntry{Id: id}
torrent.processTitle(torrentData)
torrent.processFirstColumn(torrentData)
torrent.processSecondColumn(torrentData)
torrent.processHash(torrentData)
torrent.processMagnet(torrentData)
torrent.processInfo(torrentData)
d.output.Put(&torrent)
log.Info("Processed torrent %d: \"%s\"", id, torrent.Title)
}
d.wg.Done()
}
```
После обработки результат отправляется в OutputModule, который уже сохраняет его в том или ином формате. Я написал два модуля вывода, в csv и в «почти» json.
Формат csv:
`id торрента, название, размер, количество файлов, категория, подкатегория, автор закачки, хэш, дата создания, магнет ссылка`
Json friendly формат не совсем Json: каждая строка представляет собой отдельный json объект с теми же полями, что и в csv, плюс описание торрента.
Полный дамп содержит 3828894 торрентов и занял почти 30 часов на загрузку.
### Индекс
Перед тем как загрузить данные в Elasticsearch, его надо настроить.
Так как я бы хотел получить полнотекстовый поиск по названия и описаниям торрентов, которые написаны на нескольких языках, то в первую очередь создадим Unicode friendly анализатор:
**Unicode анализатор с нормализацией и прочими преобразованиями.**
```
{
"index": {
"analysis": {
"analyzer": {
"customHTMLSnowball": {
"type": "custom",
"char_filter": [
"html_strip"
],
"tokenizer": "icu_tokenizer",
"filter": [
"icu_normalizer",
"icu_folding",
"lowercase",
"stop",
"snowball"
]
}
}
}
}
}
```
```
curl -XPUT http://127.0.0.1:9200/tpb -d @tpb-settings.json
```
Перед созданием анализатора необходимо поставить [ICU plugin](https://www.elastic.co/guide/en/elasticsearch/guide/current/icu-plugin.html), а после создания анализатора нужно связать его с полями в описании торрента:
**Описание типа торрента**
```
{
"properties" : {
"Id" : {
"type" : "long",
"index" : "no"
},
"Title" : {
"type" : "string",
"index" : "analyzed",
"analyzer" : "customHTMLSnowball"
},
"Size" : {
"type" : "long",
"index" : "no"
},
"Files" : {
"type" : "long",
"index" : "no"
},
"Category" : {
"type" : "string",
"index" : "not_analyzed"
},
"Subcategory" : {
"type" : "string",
"index" : "not_analyzed"
},
"By" : {
"type" : "string",
"index" : "no"
},
"Hash" : {
"type" : "string",
"index" : "not_analyzed"
},
"Uploaded" : {
"type" : "date",
"index" : "no"
},
"Magnet" : {
"type" : "string",
"index" : "no"
},
"Info" : {
"type" : "string",
"index" : "analyzed",
"analyzer" : "customHTMLSnowball"
}
}
}
```
```
curl -XPUT http://127.0.0.1:9200/tpb/_mappings/torrent -d @tpb-mapping.json
```
И теперь самое главное — загрузка данных. Загрузчик я тоже написал на Go, чтобы посмотреть, как работать с Elasticsearch из Go.
Сам загрузчик ещё проще парсера: читаем файл построчно, каждую строчку переводим из json в структуру, отправляем структуру в Elastisearch. Правильнее было бы сделать bulk indexing, но мне, честно говоря, было лень. Кстати, самой сложной частью написания загрузчика был поиск для скриншота достаточно длинного куска лога без порнухи.
**Загрузчик в Elasticsearch**
```
func (i *Indexer) Run() {
for i.scaner.Scan() {
var t TorrentEntry
err := json.Unmarshal(i.scaner.Bytes(), &t)
if err != nil {
log.Warning("Failed to parse entry %s", i.scaner.Text())
continue
}
_, err = i.es.Index().Index(i.index).Type("torrent").BodyJson(t).Do()
if err != nil {
log.Warning("Failed to index torrent entry %s with id %d", t.Title, t.Id)
continue
}
log.Info("Indexed %s", t.Title)
}
i.file.Close()
}
```
Сам индекс занял те же самые ~6GB и строился порядка 2х часов.
### Frontend
Самая интересная часть для меня. Я хотел бы видеть все торренты в базе и фильтровать их по категориям/подкатегориям и по названию/описанию торрента. Таким образом, слева фильтры, справа торренты.
За основу для вёрстки я взял [Bootstrap](http://getbootstrap.com/). Для большинства это видимо боян, но мне в новинку.
Итак, по левую руку у меня фильтр по заголовкам и содержимому:
**Фильтр по заголовкам**
```
Title
Look in torrent info too.
Search
```
Под ним фильтры по категориям и субкатегориям:
**Фильтр по категориям**
```
### Categories:
{{cat.key}} {{cat.doc\_count}}
### Sub categories:
{{cat.key}} {{cat.doc\_count}}
```
Список категорий наполняется автоматически при загрузке приложения. Использование TermsAggregation запроса позволяет получить сразу и список категорий и количество торрентов в этих категориях. Говоря более строго — список уникальных значений поля Category и число документов для каждого такого значения.
**Загрузка категорий**
```
client.search({
index: 'tpb',
type: 'torrent',
body: ejs.Request().agg(ejs.TermsAggregation('categories').field('Category'))
}).then(function (resp) {
$scope.categories = resp.aggregations.categories.buckets;
$scope.errorCategories = null;
}).catch(function (err) {
$scope.categories = null;
$scope.errorCategories = err;
// if the err is a NoConnections error, then the client was not able to
// connect to elasticsearch. In that case, create a more detailed error
// message
if (err instanceof esFactory.errors.NoConnections) {
$scope.errorCategories = new Error('Unable to connect to elasticsearch.');
}
});
```
При клике на одну или несколько категорий, они выбираются и загружается список их подкатегорий:
**Обработка подкатегорий**
```
$scope.categoryClick = function (category) {
/* Mark button */
category.active = !category.active;
/* Reload sub categories list */
$scope.filterCategories = [];
$scope.categories.forEach(function (item) {
if (item.active) {
$scope.filterCategories.push(item.key);
}
});
if ($scope.filterCategories.length > 0) {
$scope.loading = true;
client.search({
index: 'tpb',
type: 'torrent',
body: ejs.Request().agg(ejs.FilterAggregation('SubCategoryFilter').filter(ejs.TermsFilter('Category', $scope.filterCategories)).agg(ejs.TermsAggregation('categories').field('Subcategory').size(50)))
}).then(function (resp) {
$scope.SubCategories = resp.aggregations.SubCategoryFilter.categories.buckets;
$scope.errorSubCategories = null;
//Restore selection
$scope.SubCategories.forEach(function (item) {
if ($scope.selectedSubCategories[item.key]) {
item.active = true;
}
});
}
).catch(function (err) {
$scope.SubCategories = null;
$scope.errorSubCategories = err;
// if the err is a NoConnections error, then the client was not able to
// connect to elasticsearch. In that case, create a more detailed error
// message
if (err instanceof esFactory.errors.NoConnections) {
$scope.errorSubCategories = new Error('Unable to connect to elasticsearch.');
}
});
} else {
$scope.selectedSubCategories = {};
$scope.filterSubCategories = [];
}
$scope.searchClick();
};
```
Подкатегории тоже можно выбирать. При смене выбора категорий/подкатегорий или заполнении формы поиска формируется Elasticsearch query, учитывающий всё выбранное и отправляется в Elasticsearch.
**Формируем запрос к Elasticsearch в зависимости от выбранного слева.**
```
$scope.buildQuery = function () {
var match = null;
if ($scope.query) {
if ($scope.useInfo) {
match = ejs.MultiMatchQuery(['Title', 'Info'], $scope.query);
} else {
match = ejs.MatchQuery('Title', $scope.query);
}
} else {
match = ejs.MatchAllQuery();
}
var filter = null;
if ($scope.filterSubCategories.length > 0) {
filter = ejs.TermsFilter('Subcategory', $scope.filterSubCategories);
}
if ($scope.filterCategories.length > 0) {
var categoriesFilter = ejs.TermsFilter('Category', $scope.filterCategories);
if (filter !== null) {
filter = ejs.AndFilter([categoriesFilter, filter]);
} else {
filter = categoriesFilter;
}
}
var request = ejs.Request();
if (filter !== null) {
request = request.query(ejs.FilteredQuery(match, filter));
} else {
request = request.query(match);
}
request = request.from($scope.pageNo*10);
return request;
};
```
Результаты отображаются справа:
**Шаблон результатов**
```
###
[{{doc.\_source.Title}}]({{doc._source.Magnet}})
{{doc.\_source.Category}} / {{doc.\_source.Subcategory}}
#{{doc.\_source.Id}} **{{doc.\_source.Title}}**
Size
{{doc.\_source.Size}}
Files
{{doc.\_source.Files}}
Hash
{{doc.\_source.Hash}}
Uploaded at {{doc.\_source.Uploaded}} by {{doc.\_source.By}}
```
Вот и всё. Теперь у меня есть собственный поисковик по The Pirate Bay, и я узнал, что можно сделать современный сайт за пару часов.
* [tpb-parser](https://github.com/akashihi/tpb-parser) — Исходный код парсера The Pirate Bay
* [estorrent](https://github.com/akashihi/estorrent) — Исходный код фронтенда и индексатора
* [Дамп TPB для тех, кто хочет сделать на его основе что-то новое (архив ~1.2GB)](https://mega.nz/#!EUsyWKxa!cdnF2_tDSKSE6LnefEu9GWltLSyZ5_42Nvhq6sz9I28)
* [Образ виртуальной машины с Elasticsearch и веб приложением (~6GB)](https://mega.nz/#!RBd2jDDZ!l_tS7UfeLKxyh5zz1L6jZ8FuhwBcH4qcmXZwU1gcK8c) | https://habr.com/ru/post/275339/ | null | ru | null |
# Быстрая сортировка массива байт в Java
Для текущих задач потребовалось сортировать большие массивы байт, как знаковых (signed), так и беззнаковых (unsigned). Размер массива в моем случае был около 10 мегабайт, это не так уж и много, то есть, можно использовать сортировку в памяти.
Поначалу стал использовать java.util.Arrays.sort(byte[])… К сожалению, это решение оказалось неприемлемым, так как:
— Arrays.sort позволяет сортировать только signed значения… весьма странно что разработчики JDK этим ограничились;
— Arrays.sort использует универсальный метод (подтюненный qsort), но для ряда задач, как например для текущей, это не оптимально.
В результате обратил внимание на так называемую сортировку подсчетом, которая в данном случае будет оптимальной. Реализация также получилась весьма простой.
Пояснение по поводу метода сортировки:
1. Инициализируем модель, которая представляет собой массив int[256]. Каждый i-й элемент модели является Ni (количество элементов исходного массива, равных i).
2. Заполняем результирующий массив, при этом последовательно записывая в него каждый i-й элемент модели Ni раз.
Все, этого достаточно, произведена очень быстрая сортировка в один проход!
Причем этот метод работает как для знаковой, так и для беззнаковой сортировки, разница лишь в том, что для беззнаковой заполнение результирующего массива ведется элементами в диапазоне от 0 до 255, а для знаковой — в диапазоне от -128 до 127.
Вот код класса (комменты удалил, чтобы занимало меньше места, для понимания принципа этого кода достаточно):
> `1. public class ByteArraySorter {
> 2. private static final int BYTE\_MODEL\_SIZE = 256;
> 3. private static final int BYTE\_MASK = 0xFF;
> 4. private static final int BYTE\_SIGNED\_MIN\_VALUE = -128;
> 5. private static final int BYTE\_SIGNED\_MAX\_VALUE = 127;
> 6. private static final int BYTE\_UNSIGNED\_MIN\_VALUE = 0;
> 7. private static final int BYTE\_UNSIGNED\_MAX\_VALUE = 255;
> 8.
> 9. public static void sort(byte[] buffer) {
> 10. sort(buffer, BYTE\_SIGNED\_MIN\_VALUE, BYTE\_SIGNED\_MAX\_VALUE);
> 11. }
> 12.
> 13. public static void sortUnsigned(byte[] buffer) {
> 14. sort(buffer, BYTE\_UNSIGNED\_MIN\_VALUE, BYTE\_UNSIGNED\_MAX\_VALUE);
> 15. }
> 16.
> 17. private static void sort(byte[] buffer, int fromValue, int toValue) {
> 18. if (buffer == null) { return; }
> 19.
> 20. int length = buffer.length;
> 21. if (length == 0) { return; }
> 22.
> 23. int[] model = new int[BYTE\_MODEL\_SIZE];
> 24.
> 25. for (int i = 0; i < length; i++) {
> 26. model[buffer[i] & BYTE\_MASK]++;
> 27. }
> 28.
> 29. int index = 0;
> 30.
> 31. for (int i = fromValue; i <= toValue; i++) {
> 32. int toIndex = index + model[i & BYTE\_MASK];
> 33.
> 34. while (index < toIndex) {
> 35. buffer[index] = (byte)i;
> 36. index++;
> 37. }
> 38. }
> 39. }
> 40. }
> \* This source code was highlighted with Source Code Highlighter.`
Результаты измерений для массива 10 мегабайт:
Arrays.sort(byte[]):
— массив, заполненный случайными значениями: 0.703 сек
— массив, заполненный уже отсортированными значениями: 0.231 сек
— массив, заполненный только нолями: 0.060 сек
ByteArraySort.sort(byte[]):
— массив, заполненный случайными значениями: 0.032 сек
— массив, заполненный уже отсортированными значениями: 0. 032 сек
— массив, заполненный только нолями: 0.047 сек
Каждый тест запускался 100 раз, взято минимальное значение (среднее отличается от минимального лишь на несколько миллисекунд, так что погрешностью в данном случае можно пренебречь).
Выгода сортировки подсчетом видна однозначно.
Примечание 1. Данный тип сортировки неэффективен для небольших массивов, то есть, если нужно отсортировать, скажем, менее чем 1000 элементов (значение 1000 получено экспериментально, но если у кого есть время и желание можно рассчитать математически, более точно), то лучше использовать другие виды сортировки. Если же массив содержит более 1000 элементов, то конкурентов у сортировки подсчетом практически нет.
Примечание 2. Данный алгоритм использует дополнительную память для модели, а именно 256 \* 4 = 1024 байт. Хоть это и совсем немного, но все равно потенциально есть возможность получать OutOfMemoryError, это желательно учитывать.
Если кто предложит более оптимальный вариант, скажет что можно улучшить, или укажет на возможные недостатки, буду очень благодарен. | https://habr.com/ru/post/66334/ | null | ru | null |
# Тестирование по спецификации
Недавно я писал про [различные виды тестирования](http://habrahabr.ru/blogs/testing/81226/) и про то, что интеграционное тестирование удобно производить с помощью спецификаций. В этой статье я покажу как именно происходит такое тестирование.
Спецификация — это текстовый файл с описанием того, что нужно протестировать в тестовых данных. В ней указывается какие результаты должна получить программа. Тестовый код находит реальные, вычисленные на живом коде результаты. А тестовый движок производит сверку спецификации и вычисленных результатов.
Такой подход позволяет декларативно создавать тесты. Спецификации легко читаются и дополняются при изменении требований. Тестовый код получается компактным. Его легко поддерживать и расширять.
В статье описаны принципы работы движка для тестирования спецификаций и приведены примеры использования. Сам движок прилагается к статье. Можно его считать небольшой библиотекой для интеграционного тестирования.
Код библиотеки
==============
Исходный код — [stalker98.narod.ru/TestBySpecification.rar](http://stalker98.narod.ru/TestBySpecification.rar)
Код подробно прокомментирован, так что если по прочтении статьи некоторые моменты останутся непонятными, детали можно посмотреть в реализации. По большому счету библиотека состоит всего из 4х классов, что немного. Движок тестирования находится в Utils.Common.Tests.
Для тестирования я использую тестовый фреймворк 2008 студии, но можно перенести на NUnit. Для этого надо исправить вызов тестов в Test.Domain.Documents.DocumentTester.cs и Test.Domain.Polygons.PolygonTester.cs.
Предметная область для примеров
===============================
Пусть стоит задача написать конвертер документов из одного формата в другой. Конвертирование хитрое, с множеством математических расчетов. Наиболее сложная часть преобразования — обработка геометрических фигур, описанных в документах. Заказчик передал набор типовых документов, которые ему требуется перевести в другой формат.
До завершения разработки еще далеко. Уже написанный код покрыт unit-тестами, каждый из которых тестирует свой модуль в изоляции от остальной программы. Но настает момент, когда требуется убедится, что написанный код будет работать на реальных данных. Классы программы в этом случае должны использоваться вместе, без изоляции друг от друга. Нужно провести интеграционное тестирование.
Подход к тестированию такой — для каждого присланного заказчиком типового документа создадим спецификацию, где запишем существенные результаты, которые получит наша программа при конвертировании. Из присланных документов выберем различные фигуры и также напишем для них свои спецификации. В спецификациях фигур запишем те результаты, к которым должна прийти наша программа, при обработке той или иной фигуры.
Файл спецификации
=================
Спецификация — это текстовый файл, описывающий, что нужно протестировать в тестовых данных. Файл состоит из:* Комментариев в начале файла. Комментарии могут состоять из любых символов кроме $.
* Проверяемых свойств. Имя каждого свойства начинается с символа $. Конец значения свойства определяется либо началом следующего свойства, либо концом файла.
Пример (файл спецификации Параллелограмм.spec):
| |
| --- |
| `4 3
+------+
/ /
+------+
1 2
$Vertices = (0;0) (3;0) (4;1) (1;1)
$VerticeCount = 4
$IsRhombus = false
$HasSelfIntersections = false` |
Тестовый код
============
Чтобы проверить соответствие свойств из спецификации и реальных (вычисляемых) значений свойств, нужно знать как находить эти реальные значения свойств. Для этого создается наследник класса Specification и в нем записываются get аксессоры для свойств, с теми же именами, что и в спецификации:
`public class PolygonSpecification: Specification
{
///
/// Число вершин в фигуре
///
private int VerticeCount
{
get { return Polygon.Vertices.Count( ); }
}
///
/// Является ли фигура ромбом
///
private bool IsRhombus
{
get { return Polygon.IsRhombus; }
}
///
/// Имеет ли фигура самопересечения
///
private bool HasSelfIntersections
{
get { return Polygon.SelfIntersections.Any( ); }
}
// ... про чтение тестовых данных чуть позже
}`
Тип свойства должен соответствовать имени. Например, свойства которые начинаются на Is, Has или Are, библиотека считает булевыми флагами. А свойства, заканчивающиеся на Count, целыми числами. О механизме сопоставления имени свойства его типу будет рассказано ниже.
Как можно видеть, тестовый код сведен к минимуму.
Вызов тестов
============
`[TestClass( )]
public class PolygonTester: Engine<PolygonSpecification>
{
///
/// Тестирование всех спецификаций типа PolygonSpecification
///
[TestMethod( )]
public void Polygon\_AllSpecifications( )
{
Assert.IsTrue( TestSpecifications( ), FailedSpecInfo );
}
///
/// Для отладки одной спецификации
///
[TestMethod( )]
public void Polygon\_DebugSpecification( )
{
Assert.IsTrue( TestSpecification( "Параллелограмм" ), FailedSpecInfo );
}
}`
Запуск тестирования в студии Ctrl + R, A:
Тестовый вывод
==============
При тестировании ведется лог операций (он же тестовый вывод). В лог пишутся какие спецификации и свойства были протестированы, каков результат тестирования, сколько времени заняло тестирование. Если какое-то свойство не прошло тестирование, то это указывается отдельно. Тестовый вывод можно посмотрев щелкнув по тесту в Test Results окне.
Я написал еще 5 спецификаций для различных фигур. При тестировании оказалось, что свойство IsRhombus (булев флаг — является ли фигура ромбом) в спецификациях не соответствует значению, которое находится в программе. Очевидно допущена ошибка в методе, определяющем является ли фигура ромбом. Лог выглядит при этом так:
| |
| --- |
| `Тестирование спецификаций типа PolygonTester
-----------------------------------------------/ Квадрат
00:00:00.000 [успех] HasSelfIntersections
00:00:00.000 [успех] IsRhombus
00:00:00.000 [успех] VerticeCount
-----------------------------------------------/ Параллелограмм
00:00:00.000 [успех] HasSelfIntersections
00:00:00.000 [ошибка] IsRhombus
00:00:00.000 [успех] VerticeCount
-----------------------------------------------/ Перекрещенный
00:00:00.000 [успех] HasSelfIntersections
00:00:00.000 [ошибка] IsRhombus
-----------------------------------------------/ Ромб
00:00:00.000 [успех] HasSelfIntersections
00:00:00.000 [успех] IsRhombus
-----------------------------------------------/ Трапеция
00:00:00.000 [успех] HasSelfIntersections
00:00:00.000 [ошибка] IsRhombus
00:00:00.000 [успех] VerticeCount
-----------------------------------------------/ Треугольник
00:00:00.000 [успех] HasSelfIntersections
00:00:00.000 [успех] IsRhombus
00:00:00.000 [успех] VerticeCount
===============================================
Спецификаций прошло тест: 3/6
Свойств проверено: 16
Затрачено времени: 00:00:00.0029297
-----------------------------------------------
Не прошли тест спецификации по свойствам:
Параллелограмм [1]:
IsRhombus: Specified = False, Actual = True
Перекрещенный [1]:
IsRhombus: Specified = False, Actual = True
Трапеция [1]:
IsRhombus: Specified = False, Actual = True` |
Для примера я взял несложные проверки, поэтому везде во времени вычислений стоит 00:00:00.000. В реальных проектах время будет более существенным.
Механизм определения свойств
============================
Внимательному читателю на данный момент должны быть непонятны два вопроса — откуда берутся тестовые данные и что делать в случае, если нужно протестировать что-то кроме равенства двух bool или int. На оба вопроса ответ лежит в механизме определения свойств.
Каждое свойство относится к одному определенному типу. Причем под типом здесь подразумевается нечто больше, чем просто .NET тип. Это скорее .NET тип плюс поведение при тестировании. Поведение описывается специальным объектом — дескриптором свойства PropertyDescriptor. Дескриптор определяет соглашение, принятое для имен свойств, преобразование из строки в значение свойства и обратно, а также критерий, который определяет прошло ли свойство тестирование или нет.
Приведу в пример библиотечный дескриптор булевых флагов:
`protected PropertyDescriptor<bool> FlagProperty = new PropertyDescriptor<bool>
{
NamePattern = @"(Is|Has|Are)\w+",
Convert = ( value ) => bool.Parse( value ),
Verify = ( specified, actual ) => specified == actual,
};`
В дескрипторе указано регулярное выражение **NamePattern**, задающее соглашение для именования свойств, к которым применяется дескриптор. В данном случае это все свойства с именами, которые начинаются на Is, Has или Are. **Convert** задает функцию преобразования из строки в значение свойства. **Verify** определяет критерий прохождения теста. В данном случае это простая проверка на равенство. То есть если булево значение в спецификации равно вычисленному значению, то считается что свойство прошло тест. Если Verify опустить, то свойство будет считываться, но не будет тестироваться. Существует еще **Translate**, который переводит значение свойства в строку. Если его не указать, то при выводе в лог будет использоваться ToString().
Кроме дескриптора булевых флагов, в библиотеке предопределен дескриптор целочисленных счетчиков (свойства, которые заканчиваются на Count). Он очень похож на разобранный выше дескриптор, так что не буду утомлять читателя его разбором.
Расширение спецификации новым типом
===================================
До этого момента я показывал примеры на спецификациях фигур. Но у нас еще есть спецификации документов. Представим себе следующую ситуацию — на предварительном показе нашей системы оказалось, что программа некорректно производит разбор документов. Вместо кириллицы отображаются квадратики. Чтобы такие ошибки впредь не появлялись, напишем тест. Дополним спецификацию документа, где была обнаружена ошибка, строчкой с перечислением имен секций:
| |
| --- |
| `$SectionNames = Ромб, Параллелограмм, Треугольник` |
В тестовом коде добавляем одноименное свойство:
`///
/// Имена секций документа
///
private IEnumerable<string> SectionNames
{
get { return Document.Sections.Select( s => s.Name ); }
}`
Мы могли бы запустить тестирование, но оно вылетит с ошибкой. Библиотека не знает как обрабатывать данный тип свойств. Ни один из известных библиотеке дескрипторов не подходит — имя свойства не соответствует ни флагу ни счетчику. Нужно создать новый дескриптор. Объявим его в тестовом коде — этого будет достаточно, чтобы библиотека его нашла:
`///
/// Описатель свойства имен секций
///
protected PropertyDescriptor<IEnumerable<string>> SectionNamesProperty = new PropertyDescriptor<IEnumerable<string>>
{
NamePattern = @"SectionNames",
Convert = ( text ) => text.Split( ',' ).Select( n => n.Trim( ) ),
Verify = ( specified, actual ) =>
specified.Count( ) == actual.Count( ) &&
specified.Intersect( actual ).Count( ) == actual.Count( ),
Translate = ( value ) => string.Format( "[{0}]: {1}",
value.Count( ),
string.Join( ", ", value.ToArray( ) ) ),
};`
Приведенный выше дескриптор применим для свойства с именем «SectionNames». Convert разделяет по запятым строку, считанную из спецификации, и убирает крайние пробелы. Verify определяет, что свойство проходит проверку, когда две коллекции строк эквивалентны — каждый элемент из первой коллекции присутствует во второй коллекции и наоборот. Translate нужен для того, чтобы в случае провала проверки, в логе появилась осмысленная надпись, а не имя анонимного типа. Translate создает строку, в которой указано количество элементов в коллекции и через запятую перечислены их значения.
Дескриптор типизирован, так что при его заполнении IntelliScense будет подсказывать типы аргументов, а компилятор проверит корректность операций.
Если в дальнейшем понадобиться добавить свойство с таким же поведением, то в дескрипторе NamePattern можно изменить на @"\w+Names". И тогда все свойства, оканчивающиеся на Names, будут использовать данный дескриптор.
Чтение тестовых данных
======================
Тестовые данные могут находится где угодно — библиотека не накладывает каких либо ограничений. Однако на практике оказалось удобным пользоваться двумя местами хранения тестовых данных — в самой спецификации, либо в отдельном файле. В обоих случаях файлы хранятся в DLL тестового проекта как Embedded Resource. Это позволяет:* Включать интеграционные тесты вместе со всеми данными в систему контроля версий.
* Всегда иметь под рукой спецификации и тестовые данные, когда работаешь в студии.
Проиллюстрирую оба подхода.
### 1) Тестовые данные зашиты в спецификацию
Удобно для тестирования объектов, для инициализации которых не нужно много данных. В классе спецификации объявляется дескриптор, в котором не указан метод Verify. Значение свойства при этом берется из словаря считанных свойств спецификации SpecifiedProperties:
`///
/// Описатель для свойства, перечисляющего вершины полигона
///
PropertyDescriptor<IEnumerable<Vector>> VerticesProperty = new PropertyDescriptor<IEnumerable<Vector>>
{
NamePattern = "Vertices",
Convert = ( text ) => Polygon.ParseVertices( text ),
};
///
/// Тестируемый полигон
///
public Polygon Polygon
{
get { return new Polygon( (IEnumerable<Vector>) SpecifiedProperties[ "Vertices" ] ); }
}`
### 2) Тестовые файлы во внешнем файле
Подходит для случая, когда данных много, или когда тестовые данные — документ. Удобно принять соглашение, по которому имена файлов спецификации и тестовых данных совпадают. При этом тестовые данные лежат в соседнем, относительно спецификаций, каталоге. Тогда чтение будет осуществляться следующим образом:
`///
/// Тестируемый документ
///
public Document Document
{
get
{
var assembly = Assembly.GetExecutingAssembly( );
var resourceName = string.Format(
"{0}.Documents.Data.{1}.txt",
assembly.GetName( ).Name, Name );
var stream = assembly.GetManifestResourceStream( resourceName );
var text = new StreamReader( stream ).ReadToEnd( );
return Document.CreateFromText( text );
}
}`
Принятые соглашения
===================
Движок при тестировании опирается на следующие соглашения:* Для каждого типа спецификаций создается отдельная папка в тестовом проекте.
* В этой папке создается наследник от класса Specification.
* Файлы спецификации складываются в подпапку Specs как Embedded Resource.
* Расширение у файлов спецификации должно быть .spec
* Спецификации ищутся в той же сборке, откуда запущено тестирование. Но если потребуется, сборку можно указать явно в Engine.Assembly.
Удобно рядом с тестовым кодом положить код, запускающий тестирование, и легенду — какие свойства можно проверить в спецификации.
Для случая хранения тестовых данных в отдельных файлах, структура будет следующей (данные, как и спецификации, хранятся в сборке как Embedded Resource):
В спецификациях:* Имена свойств должны совпадать с вычисляемыми свойствами в тестовом коде.
* Каждому считанному свойству должен соответствовать ровно один дескриптор.
* Тестовый код не должен иметь предположения в каком порядке тестируются свойства. Тесты не должны влиять друг на друга.
Если какое-то соглашение нарушено (например, для свойства из спецификации не обнаружено одноименное свойство в тестовом коде), во время выполнения в движке возникнет соответствующее исключение.
Заключение
==========
Я применял приведенный подход к интеграционному тестированию в своем последнем проекте и остался доволен результатами. Тесты, основанные на спецификациях, проще читать и поддерживать в сравнении с аналогичными тестами, реализованными как unit-тесты.
Фактически спецификации представляют из себя файлы, написанные на Mini DSL (Domain Specific Language). Библиотека является движком этого языка и определят API взаимодействия с тестируемым кодом. На языке общего назначения (C#) тестирование по спецификации также можно написать, но от этого пострадает читаемость и увеличатся издержки по поддержке тестов.
Думаю в будущем добавлю к библиотеке возможность указывать сколько времени имеет право вычисляться то или иное свойство. Тогда можно будет ограничить отводимое на тестирование время и проверять при этом SLA (System Level Agreements) соглашения. | https://habr.com/ru/post/81848/ | null | ru | null |
# Архитектура Android приложений
Наше путешествие от стандартных Activity и AsyncTask'ов к современной MVP архитектуре с применением RxJava.
-----------------------------------------------------------------------------------------------------------
*Код проекта должен быть разделён на независимые модули, работающие друг с другом как хорошо смазанный механизм — фото [Честера Альвареза](https://unsplash.com/chesteralvarez).*
Экосистема средств разработки под Android развивается очень быстро. Каждую неделю кто-то создаёт новые инструменты, обновляет существующие библиотеки, пишет новые статьи, или выступает с докладами. Если вы уедете в отпуск на месяц, то к моменту вашего возвращения уже будет опубликована свежая версия Support Library и/или Google Play Services.
Я занимаюсь разработкой Android-приложений в компании [ribot](http://ribot.co.uk/us/) в течение последних трёх лет, и всё это время и архитектура наших приложений, и используемые нами технологии, постоянно развивались и улучшались. Эта статья проведёт вас путём, пройденным нами, показав вынесенные нами уроки, совершенные нами ошибки, и рассуждения, которые привели ко всем этим архитектурным изменениям.
### Старые добрые времена
В далёком 2012-м структура наших проектов выглядела очень просто. У нас не было никаких библиотек для работы с сетью, и `AsyncTask` всё ещё был нашим другом. Приведённая ниже диаграмма показывает примерную архитектуру тех решений:
Код был разделён на два уровня: уровень данных (data layer), который отвечал за получение/сохранение данных, получаемых как через REST API, так и через различные локальные хранилища, и уровень представления (view layer), отвечающий за обработку и отображение данных.
`APIProvider` предоставляет методы, позволяющие активити и фрагментам взаимодействовать с REST API. Эти методы используют `URLConnection` и `AsyncTask`, чтобы выполнить запрос в фоновом потоке, а потом доставляют результаты в активити через функции обратного вызова. Аналогично работает и `CacheProvider`: есть методы, которые достают данные из `SharedPreferences` или SQLite, и есть функции обратного вызова, которые возвращают результаты.
#### Проблемы
Главная проблема такого подхода состоит в том, что уровень представления имеет слишком много ответственности. Давайте представим простой сценарий, в котором приложение должно загрузить список постов из блога, закешировать их в SQLite, а потом отобразить в `ListView`. `Activity` должна сделать следующее:
1. Вызвать метод `APIProvider#loadPosts(Callback)`.
2. Подождать вызова метода `onSuccess()` в переданном `Callback`'е, и потом вызвать `CacheProvider#savePosts(Callback)`.
3. Подождать вызова метода `onSuccess()` в переданном `Callback`'е, и потом отобразить данные в `ListView`.
4. Отдельно обработать две возможные ошибки, которые могут возникнуть как в `APIProvider`, так и в `CacheProvider`.
И это ещё простой пример. В реальной жизни может случиться так, что API вернёт данные не в том виде, в котором их ожидает наш уровень представления, а значит `Activity` должна будет как-то трансформировать и/или отфильтровать данные прежде, чем сможет с ними работать. Или, например, `loadPosts()` будет принимать аргумент, который нужно откуда-то получить (например, адрес электронной почты, который мы запросим через Play Services SDK). Наверняка SDK будет возвращать адрес асинхронно, через функцию обратного вызова, а значит у нас теперь есть три уровня вложенности функций обратного вызова. Если мы продолжим наворачивать всё больше и больше сложности, то в итоге получим то, что называется callback hell.
Просуммируем:
* Активити и фрагменты становятся слишком здоровенными и трудно поддерживаемыми
* Слишком много уровней вложенности приводят к тому, что код становится уродливым и недоступным для понимания, что приводит к усложнению добавления нового функционала или внесения изменений.
* Юнит-тестирование затрудняется (если не становится вообще невозможным), так как много логики находится в активити или фрагментах, которые не очень-то располагают к юнит-тестированию.
### Новая архитектура с применением RxJava
Мы использовали описанный выше подход на протяжении двух лет. В течение этого времени мы внесли несколько изменений, смягчивших боль и страдания от описанных проблем. Например, мы добавили несколько вспомогательных классов, и вынесли в них часть логики, чтобы разгрузить активити и фрагменты, а также мы начали использовать [Volley](http://developer.android.com/training/volley/index.html) в `APIProvider`. Несмотря на эти изменения, код всё так же был трудно тестируемым, и callback-hell периодически прорывался то тут, то там.
Ситуация начала меняться в 2014-м году, когда мы прочли несколько статей по [RxJava](http://reactivex.io/). Мы попробовали её на нескольких пробных проектах, и осознали, что решение проблемы вложенных функций обратного вызова, похоже, найдено. Если вы не знакомы с реактивным программированием, то рекомендуем прочесть [вот это](https://gist.github.com/staltz/868e7e9bc2a7b8c1f754) введение. Если коротко, RxJava позволяет вам управлять вашими данными через асинхронные потоки (прим. переводчика: в данном случае имеются в виду потоки как streams, не путать с threads — потоками выполнения), и предоставляет множество [операторов](http://reactivex.io/documentation/operators.html), которые можно применять к потокам, чтобы трансформировать, фильтровать, или же комбинировать данные так, как вам нужно.
Приняв во внимание все шишки, которые мы набили за два прошедших года, мы начали продумывать архитектуру нового приложения, и пришли к следующему:
Код всё так же разделён на два уровня: уровень данных содержит `DataManager` и набор классов-помощников, уровень представления состоит из классов Android SDK, таких как `Activity`, `Fragment`, `ViewGroup`, и так далее.
Классы-помощники (третья колонка в диаграмме) имеют очень ограниченные области ответственности, и реализуют их в последовательной манере. Например, большинство проектов имеют классы для доступа к REST API, чтения данных из бд или взаимодействия с SDK от сторонних производителей. У разных приложений будет разный набор классов-помощников, но наиболее часто используемыми будут следующие:
* `PreferencesHelper`: работает с данными в `SharedPreferences`.
* `DatabaseHelper`: работает с SQLite.
* Сервисы [Retrofit](https://github.com/square/retrofit), выполняющие обращения к REST API. Мы начали использовать Retrofit вместо Volley, потому что он поддерживает работу с RxJava. Да и API у него поприятнее.
Многие публичные методы классов-помощников возвращают RxJava `Observables`.
`DataManager` является центральной частью новой архитектуры. Он широко использует операторы RxJava для того, чтобы комбинировать, фильтровать и трансформировать данные, полученные от помощников. Задача `DataManager` состоит в том, чтобы освободить активити и фрагменты от работы по «причёсыванию» данных — он будет производить все нужные трансформации внутри себя и отдавать наружу данные, готовые к отображению.
Приведённый ниже код показывает, как может выглядеть какой-нибудь метод из `DataManager`. Работает он следующим образом:
1. Загружает список постов через Retrofit.
2. Кеширует данные в локальной базе данных через `DatabaseHelper`.
3. Фильтрует посты, отбирая те, что были опубликованы сегодня, так как уровень представления должен отобразить лишь их.
```
public Observable loadTodayPosts() {
return mRetrofitService.loadPosts()
.concatMap(new Func1, Observable>() {
@Override
public Observable call(List apiPosts) {
return mDatabaseHelper.savePosts(apiPosts);
}
})
.filter(new Func1() {
@Override
public Boolean call(Post post) {
return isToday(post.date);
}
});
}
```
Компоненты уровня представления будут просто вызывать этот метод и подписываться на возвращенный им `Observable`. Как только подписка завершится, посты, возвращённые полученным `Observable` могут быть добавлены в `Adapter`, чтобы отобразить их в `RecyclerView` или чём-то подобном.
Последний элемент этой архитектуры это **event bus**. Event bus позволяет нам запускать сообщения о неких событиях, происходящих на уровне данных, а компоненты, находящиеся на уровне представления, могут подписываться на эти сообщения. Например, метод `signOut()` в `DataManager` может запустить сообщение, оповещающее о том, что соответствующий `Observable` завершил свою работу, и тогда активити, подписанные на это событие, могут перерисовать свой интерфейс, чтобы показать, что пользователь вышел из системы.
#### Чем этот подход лучше?
* `Observables` и операторы из RxJava избавляют нас от вложенных функций обратного вызова.
* `DataManager` берёт на себя работу, которая ранее выполнялась на уровне представления, разгружая таким образом активити и фрагменты.
* Перемещение части кода в `DataManager` и классы-помощники делает юнит-тестирование активити и фрагментов более простым.
* Ясное разделение ответственности и выделение `DataManager` как единственной точки взаимодействия с уровнем данных делает всю архитектуру более дружественной к тестированию. Классы-помощники, или `DataManager`, могут быть легко подменены на специальные заглушки.
#### А какие проблемы остались?
* В больших и сложных проектах `DataManager` может стать слишком раздутым, и поддержка его существенно затруднится.
* Хоть мы и сделали компоненты уровня представления (такие, как активити и фрагменты) более легковесными, они всё ещё содержат заметное количество логики, крутящейся около управления подписками RxJava, анализа ошибок, и прочего.
### Пробуем Model View Presenter
В течение прошлого года в Android-сообществе начали набирать популярность отдельные архитектурные шаблоны, так как [MVP](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93presenter), или [MVVM](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93viewmodel). После исследования этих шаблонов в [тестовом проекте](https://github.com/ivacf/archi), а также [отдельной статье](https://medium.com/ribot-labs/approaching-android-with-mvvm-8ceec02d5442#.x98dqfu6m), мы обнаружили, что MVP может привнести значимые изменения в архитектуру наших проектов. Так как мы уже разделили код на два уровня (данных и представления), введение MVP выглядело натурально. Нам просто нужно было добавить новый уровень presenter'ов, и перенести в него часть кода из представлений.
Уровень данных остаётся неизменным, но теперь он называется **моделью**, чтобы соответствовать имени соответствующего уровня из MVP.
**Presenter**'ы отвечают за загрузку данных из модели и вызов соответствующих методов на уровне представления, когда данные загружены. Presenter'ы подписываются на `Observables`, возвращаемые `DataManager`. Следовательно, они должны работать с такими сущностями как [подписки](http://reactivex.io/RxJava/javadoc/rx/Subscription.html) и [планировщики](http://reactivex.io/documentation/scheduler.html). Более того, они могут анализировать возникающие ошибки, или применять дополнительные операторы к потокам данных, если необходимо. Например, если нам нужно отфильтровать некоторые данные, и этот фильтр скорее всего нигде больше использоваться не будет, есть смысл вынести этот фильтр на уровень presenter'а, а не `DataManager`.
Ниже представлен один из методов, которые могут находиться на уровне presenter'а. Тут происходит подписка на `Observable`, возвращаемый методом `dataManager.loadTodayPosts()`, который мы определили в предыдущем разделе.
```
public void loadTodayPosts() {
mMvpView.showProgressIndicator(true);
mSubscription = mDataManager.loadTodayPosts().toList()
.observeOn(AndroidSchedulers.mainThread())
.subscribeOn(Schedulers.io())
.subscribe(new Subscriber>() {
@Override
public void onCompleted() {
mMvpView.showProgressIndicator(false);
}
@Override
public void onError(Throwable e) {
mMvpView.showProgressIndicator(false);
mMvpView.showError();
}
@Override
public void onNext(List postsList) {
mMvpView.showPosts(postsList);
}
});
}
```
`mMvpView` — это компонент уровня представления, с которым работает presenter. Обычно это будет `Activity`, `Fragment` или `ViewGroup`.
Как и в предыдущей архитектуре, уровень представления содержит стандартные компоненты из Android SDK. Разница в том, что теперь эти компоненты не подписываются напрямую на `Observables`. Вместо этого они имплементируют интерфейс `MvpView`, и предоставляют список внятных и понятных методов, таких как `showError()` или `showProgressIndicator()`. Компоненты уровня представления отвечают также за обработку взаимодействия с пользователем (например, события нажатия), и вызов соответствующих методов в presenter'е. Например, если у нас есть кнопка, которая загружает список постов, наша `Activity` должна будет вызвать в `OnClickListener`'е метод `presenter.loadTodayPosts()`.
> Если вы хотите взглянуть на работающий пример, то можно заглянуть в [наш репозиторий на Github](https://github.com/ribot/android-boilerplate). Ну а если захотелось большего, то можете посмотреть наши [рекомендации по построению архитектуры](https://github.com/ribot/android-guidelines/blob/master/architecture_guidelines/android_architecture.md).
#### Чем этот подход лучше?
* Активити и фрагменты становятся ещё более легковесными, так как их работа сводится теперь к отрисовке/обновлению пользовательского интерфейса и обработке событий взаимодействия с пользователем. Тем самым, их становится ещё проще поддерживать.
* Писать юнит-тесты для presenter'ов очень просто — нужно просто замокировать уровень представления. Раньше этот код был частью уровня представления, и провести его юнит-тестирование не представлялось возможным. Архитектура становится ещё более тестируемой.
* Если `DataManager` становится слишком раздутым, мы всегда можем перенести часть кода в presenter'ы.
#### А какие проблемы остались?
* В случае большого количества кода `DataManager` всё так же может стать слишком раздутым. Пока что это не произошло, но мы не зарекаемся от подобного развития событий.
---
Важно упомянуть, что описанный мною подход не является идеалом. Вообще было бы наивно полагать, что есть где-то та самая уникальная и единственная архитектура, которая возьмёт да и решит все ваши проблемы раз и навсегда. Экосистема Android'а будет продолжать развиваться с высокой скоростью, а мы должны будем держаться в курсе событий, исследуя, читая и экспериментируя. Зачем? Чтобы продолжать делать отличные Android-приложения.
Я надеюсь, вам понравилась моя статья, и вы нашли её полезной. Если так, не забудьте нажать на кнопку Recommend (прим. переводчика: перейдите на оригинальную статью, и нажмите на кнопку-сердечко в конце статьи). Также, я хотел бы выслушать ваши мысли по поводу нашего текущего подхода. | https://habr.com/ru/post/278815/ | null | ru | null |
# Как собрать WhatsApp за сутки. Часть 1
Здравствуйте, дорогие читатели Хабрахабра!
В этой серии статей я расскажу, как быстро и почти безболезненно поднять свой собственный WhatsApp под iOS. Статью делю на две части для вашего удобства:
1. Создание проекта, простой UI, привязка к сервису мгновенных сообщений
2. Делаем красивый UI, добавляем видео и аудио звонки, передачу фото и документов
К сожалению, пособие о том, как набрать 400 000 000 пользователей и продать сервис за 19 Инстаграмов, затерялось где-то на книжной полке. Постараюсь его найти, если кому интересно.
Заинтересовавшихся прошу под кат.
#### Создание проекта
Открываем Xcode и создаем новый проект.
Берем Single View Application за основу.
Вводим все данные для приложения и жмем «Next». Я выбрал наименее претенциозные регалии.
И проект готов.
Но, что это такое? Какая ужасная сортировка файлов по группам! Давайте это поправим.
Так-то лучше! Вы можете использовать свой способ сортировки файлов, но в этом руководстве я буду придерживаться модели выше. Кстати говоря, комбинация клавиш для создания новой группы — это Command + Alt + N.
#### Простой UI
Тем временем, я позволил себе создать новый класс NKLoginViewController и привязать его к UIViewController объекту в Interface Builder. Этот View Controller будет первым, что увидит пользователь. Это и логично — никакого чата без регистрации!
Продолжая развлекаться, я прикрутил текстовые поля, как Outlet, и Action кнопки «Войти» к нашему NKLoginViewController. Считаю это хорошим тоном, прикручивать IB объекты в .m файлах, дабы они были недоступны извне. Более того, мне нравится, когда код поделен на «Прагмы».
Создаем еще один контроллер (как представление в IB, так и новый класс) — список чатов. Используем стандартный код UITableViewController — нам никакого сверхъестественного функционала тут не нужно, пока что.
Слегка изменим код NKChatListTableViewController.m, чтобы в таблице хоть что-то отображалось:
**Жми меня!**
```
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
return 20;
}
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"cell" forIndexPath:indexPath];
cell.textLabel.text = @"Vasiliy Pupkin";
return cell;
}
```
Теперь подумаем над навигацией. Все приложение у нас будет встроено в один UINavigationController и контроллеры мы будем «пушить» и «попать» в зависимости от ситуации. Встроим же приложение в UINavigationController! Let the magic time begin!
Добавляем названия контроллеров и Segue от Login View Controller до Chat List Table View Controller. Назовем ее «SegueToChatList». Вот так выглядит наше приложение сейчас.
Слегка поработаем над кодом Login View Controller. Дадим пользователю возможность убирать клавиатуру. Для этого мы сделаем контроллер делегатом текстовых полей.
А сам код контроллера поправим следующим образом:
**NKLoginViewController.h**
```
#import
// Добавим нужный протокол к интерфейсу
@interface NKLoginViewController : UIViewController
@end
```
**NKLoginViewController.m**
```
#import "NKLoginViewController.h"
@interface NKLoginViewController ()
@property (weak, nonatomic) IBOutlet UITextField *emailTextField;
@property (weak, nonatomic) IBOutlet UITextField *passwordTextField;
- (IBAction)loginTouched:(UIButton *)sender;
@end
@implementation NKLoginViewController
#pragma mark - UITextFieldDelegate -
// Сделаем так, чтобы по нажатию "Done" клавиатура пряталась
- (BOOL)textFieldShouldReturn:(UITextField *)textField
{
[textField resignFirstResponder];
return YES;
}
#pragma mark - Button methods -
// Пока что просто переместимся на следующий экран по нажатию кнопки "Войти".
- (IBAction)loginTouched:(UIButton *)sender
{
[self performSegueWithIdentifier:@"SegueToChatList" sender:self];
}
```
На время перенесем все элементы на контроллере логина вверх — это ведь простой UI. О том, как интерактивно перемещать элементы интерфейса вверх при появлении клавиатуры, я расскажу в следующей части.
Наше приложение уже можно потыкать!
Создаем третий — и последний — контроллер. Попадать в него мы будем при помощи нажатия на ячейку предыдущего контроллера. Сам контроллер состоит из UITableView, источником данных которого назначен контроллер, текстового поля и кнопки «Отправить». Полагаю, этот экран интуитивно понятен.
Код NKChatViewController.m ниже:
**Жми меня!**
```
#import "NKChatViewController.h"
@interface NKChatViewController ()
@property (weak, nonatomic) IBOutlet UITableView *tableView;
@property (weak, nonatomic) IBOutlet UITextField *messageTextField;
- (IBAction)sendTouched:(UIButton *)sender;
@end
@implementation NKChatViewController
#pragma mark - View Controller life cycle -
- (void)viewDidAppear:(BOOL)animated
{
[super viewDidAppear:animated];
// Показываем клавиатуру, как только попадаем на контроллер
[_messageTextField becomeFirstResponder];
}
#pragma mark - UITableViewDataSource -
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
return 20;
}
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"cell"];
cell.textLabel.text = @"Вася Пупкен";
cell.detailTextLabel.text = @"Привет, как дела?";
return cell;
}
#pragma mark - Button methods -
- (IBAction)sendTouched:(UIButton *)sender
{
}
@end
```
Простенький UI для нашего мессенджера готов. Приступаем к самому интересному — начинке приложения!
#### Привязка к сервису мгновенных сообщений
В качестве сервиса мгновенных сообщений у нас будет выступать C2Call. Конечно, никто не мешает вам написать свою серверную часть, но это может занять чуть больше 24х часов.
Все, что вам нужно сделать — это зарегистрировать на c2call.com и купить учетку за $100. К сожалению, в бесплатной версии не работает регистрация через low-language API. Возможно, что-то изменится на момент прочтения вами этой статьи. Однако вместо помесячной оплаты C2Call сняли с меня $100 и, похоже, забыли про меня. Больше денег не списывали. Я не призываю вас ни покупать продукт, ни пытать удачу с месячной подпиской. Полагаю, мне просто повезло.
После регистрации, покупки учетки и регистрации приложения на сервисе — это довольно тривиальная задача — качаем SDK. В архиве пара-тройка примеров, как собирать приложения. Нам понадобятся следующие два объекта:
Переносим их в наш проект.
Добавляем следующие фреймворки и библиотеки в проект:
**Ужасающий список фреймворков и библиотек**AVFoundation.framework
Accounts.framework
AdSupport.framework
AddressBook.framework
AddressBookUI.framework
AssetsLibrary.framework
AudioToolbox.framework
CFNetwork.framework
CoreAudio.framework
CoreData.framework
CoreFoundation.framework
CoreLocation.framework
CoreMedia.framework
CoreTelephony.framework
CoreText.framework
CoreVideo.framework
MapKit.framework
MediaPlayer.framework
MessageUI.framework
MobileCoreServices.framework
OpenGLES.framework
QuartzCore.framework
QuickLook.framework
Security.framework
StoreKit.framework
SystemConfiguration.framework
iAd.framework
libsqlite3.dylib
libz.dylib
И прописываем следующее в Build Settings:
HEADER\_SEARCH\_PATHS = /usr/include/libxml2
OTHER\_LDFLAGS = -lxml2 -lstdc++
ARCHS = armv7
VALID\_ARCHS = armv7
Теперь немного поменяем App Delegate:
**NKAppDelegate.h**
```
#import
#import
@interface NKAppDelegate : C2CallAppDelegate
@property (strong, nonatomic) UIWindow \*window;
@end
```
**NKAppDelegate.m**
```
@implementation NKAppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
self.affiliateid = @"6B9DF5671444320162B";
self.secret = @"2fd9cd18aa4d957a4030c0455101646d";
return [super application:application didFinishLaunchingWithOptions:launchOptions];
}
@end
```
Мы засабклассили элемент от C2Call, да рассказали ему о наших данных. Ваши Affiliate ID и Secret вы можете посмотреть в админке сервиса.
Закончили с настройкой фреймворка, пора его использовать.
Создадим подкласс NSObject под названием NKChat, в котором мы инкапсулируем всю логику чата. Думаю, будет правильным дать вам примерный листинг кода NKChat.m, а после объяснить его.
**NKChat.m**
```
#import "NKChat.h"
#import
@implementation NKChat
#pragma mark - Singleton pattern -
// 1
+ (instancetype)sharedManager
{
static NKChat \*sharedChat = nil;
static dispatch\_once\_t onceToken;
dispatch\_once(&onceToken, ^{
sharedChat = [self new];
});
return sharedChat;
}
#pragma mark - Accessors -
// 2
- (NSArray \*)chatHistory
{
return [self fetchChatHistory];
}
#pragma mark - General methods -
// 3
- (void)login:(NSString \*)email password:(NSString \*)password success:(void(^)())successBlock failure:(void(^)())failureBlock
{
NSDictionary \*dictionary = @{@"EMail":email,
@"Password":password};
[[C2CallPhone currentPhone] registerUser:dictionary
withCompletionHandler:^(BOOL success, NSString \*result) { if (success) {
[[C2CallPhone currentPhone] startC2CallPhone];
successBlock();
} else {
failureBlock();
}
}];
}
// 4
- (void)logout
{
[(C2CallAppDelegate \*)[UIApplication sharedApplication].delegate logoutUser];
}
// 5
- (void)sendMessage:(NSString \*)message toUser:(NSString \*)userId
{
[[C2CallPhone currentPhone] submitMessage:message toUser:userId];
}
// 6
- (NSArray \*)fetchChatHistory
{
// Получаем все Managed Object истории чата
NSFetchRequest \*request = [[SCDataManager instance] fetchRequestForChatHistory:YES];
NSFetchedResultsController \*controller = [[SCDataManager instance] fetchedResultsControllerWithFetchRequest:request sectionNameKeyPath:nil cacheName:nil];
NSError \*error;
[controller performFetch:&error];
// Собираем результирующий массив
NSMutableArray \*result = [NSMutableArray array];
for (NSManagedObject \*chat in controller.fetchedObjects) {
// Получаем словарь чата
NSArray \*chatKeys = @[@"contact", @"lastTimestamp", @"missedEvents"];
NSMutableDictionary \*inChat = [[chat dictionaryWithValuesForKeys:chatKeys] mutableCopy];
// Проверяем на дубликаты
NSMutableDictionary \*dublicate = nil;
for (NSMutableDictionary \*dict in result) {
if ([dict[@"contact"] isEqualToString:inChat[@"contact"]]) {
dublicate = dict;
break;
}
}
// Получаем все сообщения
NSMutableArray \*messages = (dublicate) ? dublicate[@"messages"] : [NSMutableArray array];
for (NSManagedObject \*chatEvent in [chat valueForKey:@"chatHistory"]) {
NSArray \*chatEventKeys = [[[chatEvent entity] attributesByName] allKeys];
NSMutableDictionary \*inChatEvent = [[chatEvent dictionaryWithValuesForKeys:chatEventKeys] mutableCopy];
// NSLog(@"%@",inChatEvent);
inChatEvent[@"ManagedObject"] = chatEvent;
[messages addObject:inChatEvent];
}
[messages sortUsingDescriptors:@[[NSSortDescriptor sortDescriptorWithKey:@"timevalue" ascending:YES]]];
if (dublicate) {
dublicate[@"messages"] = messages;
[dublicate[@"ManagedObjects"] addObject:chat];
dublicate[@"missedEvents"] = @([dublicate[@"missedEvents"] intValue] + [inChat[@"missedEvents"] intValue]);
if (!dublicate[@"name"])
dublicate[@"name"] = inChat[@"name"];
} else {
inChat[@"messages"] = messages;
inChat[@"ManagedObjects"] = [NSMutableArray arrayWithObject:chat];
}
// Добавляем словарь в результат
if (!dublicate)
[result addObject:inChat];
}
// Сортируем результат
[result sortUsingDescriptors:@[[NSSortDescriptor sortDescriptorWithKey:@"lastTimestamp" ascending:NO]]];
// Возвращаем результирующий массив
return [result copy];
}
@end
```
Пойдем по-порядку:
1. Стандартный шаблон — синглтон. Ничего необычного для вас здесь быть не должно. У нас один объект, который отвечает за чат — больше не надо.
2. Метод-аксессор, который возвращает массив истории чата в нужной нам форме.
3. Метод для регистрации и логина. Фишка C2Call в том, что, когда вы входите с одними данными в первый раз, вы регистрируетесь. Когда вы входите с теми же данными второй раз, вы просто входите. Этот метод как-раз и недоступен бесплатным подписчикам, к сожалению. Вы можете обойти этот метод добавив нативное окно регистрации от C2Call, дабы сэкономить.
4. Метод для логаута. Дешево и сердито.
5. Метод для посылки сообщения — тоже довольно прост.
6. Ужасный и монструозный метод-скатерть, который возвращает в нужном формате историю чата. Здесь собраны все камни, о которые можно столкнуться, используя C2Call. Во-первых, данные хранятся в Core Data. Во-вторых, имена контактов постоянно разные — то id придет, то имя и фамилия. В-третьих, забудьте пока что про этот метод. Он работает и для этого туториала сойдет :)
Ну, когда все готово для работы, пора использовать магию кода!
Добавьте в NKAppDelegate.m инициализацию NKChat, если еще не сделали этого.
**NKAppDelegate.m**
```
#import "NKAppDelegate.h"
@implementation NKAppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
self.affiliateid = @"6B9DF5671444320162B";
self.secret = @"2fd9cd18aa4d957a4030c0455101646d";
[NKChat sharedManager];
return [super application:application didFinishLaunchingWithOptions:launchOptions];
}
@end
```
Теперь слегка изменим метод loginTouched у класса NKLoginViewController. Не забудьте сделать импорт NKChat!
**Жми меня!**
```
- (IBAction)loginTouched:(UIButton *)sender
{
sender.enabled = NO;
[[NKChat sharedManager] login:_emailTextField.text
password:_passwordTextField.text
success:^{
[self performSegueWithIdentifier:@"SegueToChatList" sender:self];
sender.enabled = YES;
}
failure:^{
sender.enabled = YES;
}];
}
```
Здесь мы выключили кнопку, пока грузится ответ с сервера, отправили запрос на сервер, переходим в новый контроллер в случае успеха, включаем кнопку, вне зависимости от результата.
В этой части туториала мы будем работать с двумя учетными записями: nikita@borodutch.com и luke@borodutch.com. Мы просто захардкодим возможность отправлять сообщения этим двум контактам, временно.
Слегка изменим NKChatListTableViewController.m таким образом, чтобы можно было отправлять сообщения только этим двум контактам.
**Жми меня!**
```
#import "NKChatListTableViewController.h"
@interface NKChatListTableViewController ()
@end
@implementation NKChatListTableViewController
#pragma mark - UITableViewDataSource -
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
return 2;
}
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"cell" forIndexPath:indexPath];
cell.textLabel.text = (indexPath.row) ? @"nikita@borodutch.com" : @"luke@borodutch.com";
return cell;
}
@end
```
Результат манипуляций:
Добавим метод передачи информации в следующий контроллер в NKChatListTableViewController.m.
**Жми меня!**
```
- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(UITableViewCell *)sender
{
UIViewController *dest = segue.destinationViewController;
dest.title = sender.textLabel.text;
}
```
Нам осталось только получать нужную историю чата и отправлять сообщения нужным контактам! Дело в шляпе, сударь.
Как в старые добрые времена, приведу листинг NKChatViewController.m вместе с объяснениями чуть ниже.
**Жми меня!**
```
#import "NKChatViewController.h"
#import
#import "NKChat.h"
@interface NKChatViewController ()
@property (weak, nonatomic) IBOutlet UITableView \*tableView;
@property (weak, nonatomic) IBOutlet UITextField \*messageTextField;
- (IBAction)sendTouched:(UIButton \*)sender;
@end
@implementation NKChatViewController
{
NSArray \*tableData;
}
#pragma mark - View Controller life cycle -
- (void)viewDidLoad
{
[super viewDidLoad];
// 1
tableData = [self getTableData];
}
- (void)viewDidAppear:(BOOL)animated
{
[super viewDidAppear:animated];
// Показываем клавиатуру, как только попадаем на контроллер
[\_messageTextField becomeFirstResponder];
// 2
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(receivedMessage) name:@"kC2CallPhoneReceivedMessage" object:nil];
}
#pragma mark - UITableViewDataSource -
- (NSInteger)tableView:(UITableView \*)tableView numberOfRowsInSection:(NSInteger)section
{
// 3
return tableData.count;
}
- (UITableViewCell \*)tableView:(UITableView \*)tableView cellForRowAtIndexPath:(NSIndexPath \*)indexPath
{
// 4
UITableViewCell \*cell = [tableView dequeueReusableCellWithIdentifier:@"cell"];
cell.textLabel.text = ([tableData[indexPath.row][@"eventType"] isEqualToString:@"MessageIn"]) ? self.title : @"Я";
cell.detailTextLabel.text = tableData[indexPath.row][@"text"];
return cell;
}
#pragma mark - Button methods -
- (IBAction)sendTouched:(UIButton \*)sender
{
// 5
[[NKChat sharedManager] sendMessage:\_messageTextField.text
toUser:@"c45645f71465dcff18e"];
[self addMessage:\_messageTextField.text];
\_messageTextField.text = @"";
}
#pragma mark - General Methods -
- (void)addMessage:(NSString \*)message
{
// 6
NSMutableArray \*mTableData = [tableData mutableCopy];
[mTableData addObject:@{@"text":message,
@"eventType":@"MessageOut"}];
tableData = mTableData;
[\_tableView reloadData];
}
- (void)receivedMessage
{
// 7
tableData = [self getTableData];
[\_tableView reloadData];
}
- (NSArray \*)getTableData
{
// 8
for (NSDictionary \*chat in [NKChat sharedManager].chatHistory)
if ([chat[@"contact"] isEqualToString:self.title])
return chat[@"messages"];
return nil;
}
@end
```
По-порядку:
1. Как только контроллер загрузился, мы заполняем его нужными данными
2. kC2CallPhoneReceivedMessage — это дефиниция названия нотификации о том, что пришло новое сообщение; подписываемся на это событие
3. Нам нужно столько ячеек, сколько всего сообщений есть в истории этого чата
4. Каждой ячейке даем нужное имя контакта и сообщение
5. Отправляем сообщение при помощи метода из NKChat; добавляем сообщение в локальные данные контроллера, потому что сообщению нужно время для того, чтобы оно добавилось в историю C2Call; очищаем поле отправки
6. Метод добавления сообщения в локальные данные контроллера. Полагаю, интуитивно понятен
7. При получении сообщения нужно перезагрузить историю в контроллере и заставить таблицу обновить свои данные
8. Просто проходимся по всей истории и возвращаем историю нужного нам контакта
Вот, что у нас получилось (большая гифка):
#### Заключение
Огромное спасибо, что дошли до конца первой части этого руководства. В скором времени, как появится пара свободных деньков, напишу вторую часть. Исходный код первой части [тут](https://github.com/backmeupplz/C2Call-Tutorial-Part-1).
Во второй части мы решим несколько щепетильных вопросов по UI, обойдем пару багов C2Call (например, тот, что виден на последней гифке с получением сообщений), добавим функционала приложению и влепим пару-тройку котиков.
Если у вас есть какие-либо вопросы по туториалу, смело задавайте их в комментариях — на все отвечу.
В случае обнаружения вами опечаток или неточностей в статье, прошу обращаться в мой хабрацентр.
До скорой встречи. | https://habr.com/ru/post/225079/ | null | ru | null |
# Подключаем нагрудный датчик пульса по Bluetooth на Swift
С чего все началось?
--------------------
Около года назад я приобрел данный девайс для контроля частоты сердечных сокращений (далее - ЧСС) во время тренировок. Датчик отлично подсоединяется к телефону, умным часам по Bluetooth, но обычно, фитнесс-приложения, анализирующие подобного рода данные требуют либо подписки, либо нагружены излишне сложными аналитиками, которые мне, как рядовому пользователю не очень интересны. Поэтому у меня родилась идея написать свое приложение для контроля ЧСС во время тренировок для IOS на Swift.
Немного теории о технологии Bluetooth LE
----------------------------------------
Bluetooth Low Energy - очень популярный и распространённый протокол обмена данными, который мы используем повсеместно и который становится все популярнее с каждым днем. У меня даже чайник на кухне управляется дистанционно через BLE. Low energy, кстати, гораздо сниженное энергопотребление в отличие от "голого" Bluetooth, настолько сниженное, что устройство готово общаться по данному протоколу на одной батарейке несколько месяцев, а то и лет.
Конечно, цитировать и переписывать спецификацию [протокола](https://www.bluetooth.com/specifications/specs/core-specification/) BLE 5.2 нет никакого смысла, поэтому ограничимся основными понятиями.
Центральное и периферийное устройство
-------------------------------------
В зависимости от использования и назначения, устройство Bluetooth может быть:
* Центральным (главным) - получает данные от периферийного устройства (наш телефон)
* Периферийным - устройство, которое отправляет данные на центральное устройство (датчик ЧСС)
Рекламные пакеты данных протокола
---------------------------------
Рекламные или оповещательные данные отправляются с периферийного устройства в виде пакетов, которые содержат в себе основную информацию об устройстве: его название, а также его функциональные возможности. Задача центрального устройства, получить их, прочитать, а после выделить из списка периферии необходимый для подключения девайс.
Объем рекламных пакетов не очень большой и вместить всю информацию об устройстве не способен. Чтобы получить доступ ко всем возможностям и характеристикам устройства, необходимо выполнить подключение, после чего считать его данные, которые, в свою очередь, могут быть предоставлены в виде:
* Сервиса (услуг) - набор данных, описывающих функции устройства. В нашем случае мы увидим службу получения ЧСС.
* Характеристик - дополнительных описаний сервисов устройства. Например характеристика изменения сердечного ритма в секунду, а также положения датчика на теле.
Переходя к абстракциям, сервисом является некий шкаф, в котором много ящиков - характеристик. Причем каждый сервис уникален и представлен идентификатором UUID, который может быть 16-битным или 128-битным, в зависимости от типов сервисов.
Перейдем к написанию кода
-------------------------
Создадим проект в Xcode с одноимённым названием, после чего добавим несколько необходимых Label в Main.storyboard и перетянем outlets этих labels во View Controller, закрепим их с помощью constraints, а также скроем их для первоначального изображения в методе viewDidLoad, как я сделал это на изображении:
Я создал outlets для текстовых значений "121" и "грудь", другие же текстовые значения просто закрепил на view, так как изменений в них делать мы не планируем.
> Отладку и демонстрацию работы необходимо совершать на реальном устройстве, так как симулятор не поддерживает возможность работы по протоколу Bluetooth.
>
>
В файле Info.plist проекта необходимо добавить свойство: Bluetooth Always Usage Description и прикрепить к нему описание, чтобы уведомить пользователя об использовании данных по Bluetooth при первом запуске приложения. Если данное свойство не добавить в список, то приложение "упадет" с одноименной ошибкой. Не забывайте про это!
Подключаем библиотеку Bluetooth
-------------------------------
Тут все просто, для подключения библиотеки воспользуемся следующей строчкой:
```
import CoreBluetooth
```
Вспомним, что по протоколу у нас существуют так называемые центральные и периферийные устройства, логично предположить, что основной функционал работы данного протокола будет исполнен методами делегатов централи и периферии.
Для начала создадим переменную центрального (главного) устройства в проекте рядом с объявлением других переменных:
```
var centralManager: CBCentralManager!
```
Теперь, чтобы получить доступ к методам необходимо назначить ViewController делегатом, но предварительно подпишем его под протокол CBCentralManagerDelegate. Сделать это предлагаю в extension ViewController, так будет рациональнее.
```
extension ViewController: CBCentralManagerDelegate {}
```
Xcode на такое пользовательское действие отреагирует ошибкой: "Type 'ViewController' does not conform to protocol 'CBCentralManagerDelegate'", оповещая, что данный протокол требует обязательную реализацию метода: "func centralManagerDidUpdateState(\_ central: CBCentralManager)". Нажмем "fix", добавив этот метод в проект. Данный метод нужен для автоматической проверки состояния центрального менеджера, которого мы создали ранее.
Чтобы отобразить все состояния центрального менеджера, в теле метода "func centralManagerDidUpdateState(\_ central: CBCentralManager)" напишем:
```
func centralManagerDidUpdateState(_ central: CBCentralManager) {
switch central.state {
}
```
Xcode автоматически предложит вставить все возможные состояния данного условия, соглашаемся с ним. А в каждом из состояний напишем функцию print("это состояние"):
```
extension ViewController: CBCentralManagerDelegate {
func centralManagerDidUpdateState(_ central: CBCentralManager) {
switch central.state {
case .unknown:
print ("central.state is unknown")
case .resetting:
print ("central.state is resetting")
case .unsupported:
print ("central.state is unsupported")
case .unauthorized:
print ("central.state is unauthorized")
case .poweredOff:
print ("central.state is poweredOff")
case .poweredOn:
print ("central.state is poweredOn")
@unknown default:
break
}
}
}
```
Теперь нам осталось проинициализировать переменную "centralManager" и задать ей делегирование. Сделаем это в методе "viewDidLoad", а в качестве параметра очереди напишем "nil", определяя всю работу про Bluetooth в главной очереди.
```
override func viewDidLoad() {
super.viewDidLoad()
centralManager = CBCentralManager(delegate: self, queue: nil)
heartRateLabel.isHidden = true
bodyLocationLabel.isHidden = true
}
```
Собираем проект, запускаем на устройстве с включенным Bluetooth, видим системный запрос за его использование, соглашаемся и получаем в консоль заветное сообщение "**central.state is poweredOn**", которое сигнализирует нам о том, что центральный менеджер готов к работе. Если выключить Bluetooth на телефоне, то в консоли появится логичное "**central.state is poweredOff**".
Поиск Bluetooth устройств
-------------------------
Центральный менеджер ждет дальнейших указаний, и сейчас он их получит. Для этого в методе "centralManagerDidUpdateState" в случае ".poweredOn" после метода "print" пишем:
```
centralManager.scanForPeripherals(withServices: nil)
```
Менеджер начнет сканировать все доступные вокруг устройства, а чтобы мы смогли увидеть их в консоли приложения, необходимо реализовать метод делегата в extension ViewController ниже метода "centralManagerDidUpdateState" следующим образом:
```
func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
print(peripheral)
}
```
Запускаем приложение... И теперь в консоли мы можем увидеть множество всех доступных для подключения устройств. Замечательно! Одним из них и является необходимый для подключения пульсометр. Но чтобы упростить поиск пульсометра, можно воспользоваться некоторой хитростью, которую я сейчас покажу.
Идентификатор служб UUID
------------------------
Я ранее упомянул наличие данного идентификатора в протоколе Bluetooth как уникальную характеристику для различных устройств, поэтому могу сказать вам, что пульсометры обладают таким уникальным UUID для своей непосредственной службы измерения ЧСС. Список всех UUID можно также найти в [спецификации](https://www.bluetooth.com/specifications/assigned-numbers/), из которой я нашел нужный: "0x180D". Добавим новую константу в проект над объявленными ранее outlets:
```
let heartRateUUID = CBUUID(string: "0x180D")
```
Также обновим метод "centralManager.scanForPeripherals(withServices: nil)" добавив в него вышенаписанный идентификатор пульсометра:
```
case .poweredOn:
print ("central.state is poweredOn")
centralManager.scanForPeripherals(withServices: [heartRateUUID] )
```
Теперь центральный менеджер находится в поиске устройств с данным UUID, и после некоторого времени в консоли появиться заветное устройство:
Теперь необходимо создать переменную в проекте, с которой мы сможем связать данное устройство, для этого рядом с "var centralManager: CBCentralManager!" напишем:
```
var heartRatePeripheral: CBPeripheral!
```
А в методе "didDiscover peripheral" свяжем найденное устройство с вышеобъявленной переменной и прекратим поиск новых устройств с помощью метода:
```
func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
print(peripheral)
heartRatePeripheral = peripheral
centralManager.stopScan()
}
```
Подключаемся к пульсометру
--------------------------
Для этого напишем под строкой "centralManager.stopScan()":
```
centralManager.connect(heartRatePeripheral, options: nil)
```
Нам уже удалось подключиться к пульсометру, но чтобы это действительно увидеть, необходимо реализовать еще один метод делегата "didConnect peripheral" ниже метода "didDiscover peripheral", который автоматически вызывается при подключении нового устройства:
```
func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
print("Соединение установлено")
}
```
Собираем проект, запускаем на устройстве и видим в консоле заветное "Соединение установлено". Хороший результат, теперь двигаемся дальше.
Получаем список сервисов с пульсометра
--------------------------------------
После того, как соединение установлено, необходимо сделать запрос об услугах (сервисах), которые данный пульсометр готов предоставить. Для этого после установки соединения вызовем метод "heartRatePeripheral.discoverServices()" в методе "didConnect", который примет следующий вид:
```
func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
print("Соединение установлено")
heartRatePeripheral.discoverServices(nil)
}
```
Запрос на получение сервисов сделан, а чтобы их увидеть и начать с ними работать, необходимо расширить класс протоколом "CBPeripheralDelegate" в самом низу нашего проекта и вызвать метод "peripheral(\_:didDiscoverServices:)" следующим образом:
```
extension ViewController: CBPeripheralDelegate {
func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
guard let services = peripheral.services else { return }
for service in services {
print(service)
}
}
}
```
Метод получает сервисы, сообщает об этом центральному менеджеру и выводит их в консоль. В данный момент консоль будет пуста, так как необходимо делегировать данный протокол периферийному устройству "heartRatePeripheral". Сделаем это после инициализации периферийного устройства в следующем методе:
```
func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
print(peripheral)
heartRatePeripheral = peripheral
heartRatePeripheral.delegate = self
centralManager.stopScan()
centralManager.connect(heartRatePeripheral, options: nil)
}
```
Отлично, делегат обьявлен, метод получения сервисов написан, запустим программу на телефоне и получим в консоль список служб пульсометра:
Не все сервисы нам интересны и оставить необходимо лишь первый. Для этого можно провести так называемую фильтрацию с помощью идентификатора UUID в методе "heartRatePeripheral.discoverServices()"
```
heartRatePeripheral.discoverServices([heartRateUUID])
```
Вот теперь список служб отобразится в виде "", из которой мы сможем извлечь нужные нам характеристики - ящики (№ шкафа мы уже получили).
Достаем характеристики из шкафа
-------------------------------
Шкаф-сервис нам известен, осталось посмотреть, что он предлагает и получить это. Сделаем запрос на получение характеристик, для этого в теле метода "didDiscoverServices - peripheral" реализуем метод - поиск:
```
extension ViewController: CBPeripheralDelegate {
func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
guard let services = peripheral.services else { return }
for service in services {
peripheral.discoverCharacteristics(nil, for: service)
}
}
}
```
Теперь доступный сервис будет посылать свои характеристики, а увидеть мы их сможем в самостоятельном методе делегата "CBPeripheralDelegate" под названием "didDiscoverCharacteristicsFor". Реализуем его и выведем в консоль все доступные характеристики:
```
func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
guard let characteristics = service.characteristics else { return }
for characteristic in characteristics {
print(characteristic)
}
}
```
Запускаем программу, видим, что характеристики получены, а консоль заполнилась следующими строками:
Видно, что у данной службы две характеристики, имеющие два уникальных идентификатора. Из спецификации на Bluetooth узнаем, что UUID = 2A37 отвечает за измерение ЧСС, а UUID = 2A38 за положение датчика на теле. Положение датчика на теле не самая интересная характеристика в данной теме, но будет полезно считать и ее.
Для удобства добавим в проект два уникальных идентификатора данных характеристик следующим образом:
```
let heartRateUUID = CBUUID(string: "0x180D")
let heartRateCharacteristicCBUUID = CBUUID(string: "2A37")
let bodyLocationCharacteristicCBUUID = CBUUID(string: "2A38")
```
Характеристики отличаются друг от друга типами свойств. Например, характеристика ЧСС имеет свойство ".notify" т.е. она уведомляет об изменении значения ЧСС, а характеристика положения на теле имеет свойство ".read", т.е. может быть считана напрямую. Данное пояснение необходимо, чтобы правильно получить значения из них.
Положение пульсометра на теле
-----------------------------
Характеристика выведена консоль, теперь нужно лишь реализовать метода считывая значений из нее. Для этого напишем запрос на чтение значений "peripheral.readValue(for: characteristic)"
```
func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
guard let characteristics = service.characteristics else { return }
for characteristic in characteristics {
peripheral.readValue(for: characteristic)
}
}
```
Запрос написан, как вы догадываетесь, нужно реализовать еще один метод "peripheral(\_:didUpdateValueFor:error:)" делегата "CBPeripheralDelegate", который будет в асинхронном режиме получать ответ с данного запроса, причем в данном методе напишем конструкцию "switch - case", чтобы была возможность разделить характеристики по уникальному идентификатору:
```
func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic,
error: Error?) {
switch characteristic.uuid {
case bodySensorLocationCharacteristicCBUUID:
print(characteristic.value ?? "no value")
default:
print("Unhandled Characteristic UUID: \(characteristic.uuid)")
}
}
```
В консоли после выполнения данной программы появится строка "1 bytes". Это нужный результат, потому что мы пытались вывести объект типа "data".
Чтобы "распасить" данный байт, необходимо снова прибегнуть к спецификации, из которой мы сможем понять, как данный байт заполнен. Ускоряя результат, реализуем ниже функцию получения строки положения на теле датчика ЧСС из этого байта:
```
private func bodyLocation(from characteristic: CBCharacteristic) -> String {
guard let characteristicData = characteristic.value,
let byte = characteristicData.first else { return "Error" }
switch byte {
case 0: return "Другое"
case 1: return "Грудь"
case 2: return "Запястье"
case 3: return "Палец"
case 4: return "Ладонь"
case 5: return "Мочка уха"
case 6: return "Нога"
default:
return "Резерв"
}
}
```
И теперь вызовем данную функцию в методе "didUpdateValueFor characteristic", одновременно выводя результат на экран телефона (не забудем показать скрытый label для положения датчика):
```
func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic,
error: Error?) {
switch characteristic.uuid {
case bodyLocationCharacteristicCBUUID:
let bodySensorLocation = bodyLocation(from: characteristic)
bodyLocationLabel.text = bodySensorLocation
bodyLocationLabel.isHidden = false
default:
print("Unhandled Characteristic UUID: \(characteristic.uuid)")
}
}
```
Ура! Характеристика успешно получена, прочитана и выведена на экран!
Не совсем ясно, где еще можно носить данный пульсометр, поэтому существует данная характеристика :)
---
Получение ЧСС и вывод на экран пользователя
-------------------------------------------
Осталось совсем немного, и теперь нужно получить значения из характеристики ЧСС. Как мы помним, у нее тип значения ".notify", поэтому нам нужно как бы "подписаться на нее", чтобы она присылала обновленные значения ЧСС. Для этого нужно выполнить метод "peripheral.setNotifyValue(**true**, for: characteristic)" в функции "didDiscoverCharacteristicsFor service:
```
func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
guard let characteristics = service.characteristics else { return }
for characteristic in characteristics {
peripheral.readValue(for: characteristic)
peripheral.setNotifyValue(true, for: characteristic)
}
}
```
Если запустить приложение, то в консоли появятся стоки:
> **Unhandled Characteristic UUID: 2A37**
>
> **Unhandled Characteristic UUID: 2A37**
>
> **Unhandled Characteristic UUID: 2A37**
>
>
Именно в этой характеристики и лежат данные о ЧСС. Теперь необходимо провернуть такую же развертку этих данных, обращаясь к спецификации. В некоторых моделях данные могут быть представлены либо 1 либо 2 байтами. Чтобы не получить конфуз, реализуем метод для "парсинга" этих данных в нужном порядке в протоколе "CBPeripheralDelegate".
```
private func heartRate(from characteristic: CBCharacteristic) -> Int {
guard let characteristicData = characteristic.value else { return -1 }
let byteArray = [UInt8](characteristicData)
let firstBitValue = byteArray[0] & 0x01
if firstBitValue == 0 {
return Int(byteArray[1])
} else {
return (Int(byteArray[1]) << 8) + Int(byteArray[2])
}
}
```
И, наконец, добавим еще один case в методе "peripheral(\_:didUpdateValueFor:error:)", в котором получим ЧСС, а также обновим и покажем label пользовательского интерфейса:
```
func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic,
error: Error?) {
switch characteristic.uuid {
case bodyLocationCharacteristicCBUUID:
let bodySensorLocation = bodyLocation(from: characteristic)
bodyLocationLabel.text = bodySensorLocation
bodyLocationLabel.isHidden = false
case heartRateCharacteristicCBUUID:
let bpm = heartRate(from: characteristic)
heartRateLabel.text = String(bpm)
heartRateLabel.isHidden = false
default:
print("Unhandled Characteristic UUID: \(characteristic.uuid)")
}
}
```
Поздравляю!
Теперь данные с пульсометра выводятся на экран телефона. Я даже слегка нервничаю :)
---
Итоги
-----
В целом гайд по использованию Bluetooth для подключения датчика ЧСС вышел немного большим и местами сложным, надеюсь, что основной смысл мне удалось донести. Конечно, есть еще несколько нереализованных методов, которые можно было бы добавить (например, метод переподключения при обрыве соединения), но я посчитал этого набора достаточным, чтобы в меру оценить лаконичность и удобность библиотеки на swift CoreBluetooth.
> Всем успехов и спасибо!
>
> | https://habr.com/ru/post/550378/ | null | ru | null |
# HTML-CSS фреймворк «NTH»
Выкладываю фреймворк, написанный для себя.
Причина создания: надоело каждый раз при верстке нового сайта заниматься одним и тем же — переделывать мой любимый [Tripoli](http://devkick.com/lab/tripoli/) (исправляя его баги, добавлять свойства разметки); добавлять JS-фреймворк [jQuery](http://www.jquery.com/), создавать типичную HTML-структуру. Решил объединить часто используемые мной элементы в единое универсальное целое.
Делал для себя, то есть — аккуратно и хорошо.
#### Файловая структура
```
[css] папка с файлами стилей
|- ie6.css файл стилей для Internet Explorer 6
|- ie7.css файл стилей для Internet Explorer 7
|- print.css файл стилей для печатных устройств
|- reset.css файл, сбрасывающий стили браузеров
[img] папка для декоративных изображений
|- blank.gif однопиксельный прозрачный GIF
[js] папка для ява-скриптов
|- jquery.js JS-фреймворк jQuery
|- script.js файл скриптов
[pict] папка для информативных изображений
iepngfix.htc устранение проблем IE6 с PNG
index.html html-макет
style.css ОСНОВНОЙ файл стилей
```
##### Примечания и пояснения
* Основной CSS-файл вынесен в корень (адаптация под работу с WordPress).
* Добавлены отдельные файлы стилей для Internet Explorer версий 6 и 7.
* Все изображения, используемые в верстке для декорирования, размещены в папке [img] (следует добавлять их на страницу в виде фонов блоков, но не тегами `img`).
* Все изображения, используемые для отображения значимой информации, размещены в папке [pict] (добавлять их на страницу следует с помощью тега `img`).
#### HTML
HTML сверстан безтаблично, семантически и [валидно](http://validator.w3.org/check?uri=http%3A%2F%2Fnicothin.ru%2Fnth-framework%2Findex.html&charset=(detect+automatically)&doctype=Inline&group=0&user-agent=W3C_Validator%2F1.591) (XHTML 1.0 Transitional).
Это фиксированный по ширине двухколоночный макет, у которого левая узкая колонка (`.sidebar`) в HTML-потоке следует за основной частью (`.content`).
[Смотреть макет](http://nicothin.ru/nth-framework/).
Файл `index.html` имеет следующую структуру:
```
#all-site
#header
.site-logo
.site-description
#navigation
#wrapper
.content
.content-block
.sidebar
.sidebar-block .search
.sidebar-block .login
.sidebar-block .contact
.sidebar-block .advert
#footer
```
Теги `div` снабжены комментариями с классами (идентификаторами) закрывающегося `div`.
Как видно, блок `.sidebar` имеет несколько типичных вложенных блоков.
#### CSS
Основан на фреймворке Tripoli. Файлов стилей несколько, все они подверглись доработке.
##### Особенности и отличия от Tripoli
* Добавлены стили оформления HTML-макета фиксированной ширины (980px — общая, 690px — контентный блок, 219px — сайдбар), выровненный горизонтально по центру окна браузера.
* Основные блоки разделены серым бордюром.
* Свойства, прописанные для основной типографики распространяются на `#wrapper` — то есть и на `.content` и на `.sidebar` (в оригинале Tripoli свойства применялись только к контентному блоку).
* Устранена проблема с `input[type='password']` (в Tripoli не прописаны некоторые свойства, в результате, `input` с этим параметром отличался от остальных; в IE проблема осталась).
* Нумерованные и ненумерованные списки теперь чуть прижаты к предшествующим параграфам (`p+ul` и `p+ol`).
* Добавлены сервисные классы `.hide`, `.right`, `.left`, `.more`. (Класс `.more`, если задан для параграфа, прижимает параграф к предыдущему элементу в потоке, к ссылке, находящейся внутри `p.more` добавляется символ “→”)
* Для тегов `sup` и `sub` назначен рубленый шрифт.
* Для тега `big` назначен увеличенный шрифт.
* Исправлена проблема с многоуровневыми списками нумерованного, ненумерованного и смешанного типов.
* Добавлено изменение цвета в ячейках `thead`, изменение цвета фона строки таблицы при наведении (не работает в IE, проблема решена с помощью JS).
* В оформлении цитат использованы «елочки» (французские кавычки), мультиязычная поддержка кавычек убрана.
* Для IE (6 и 7) принудительно скрыты маркеры списков в сайдбаре.
* Для IE7 увеличены внутренние отступы `textarea` и `input`, изменены внутренние отступы кнопок.
* Убрано свойство ссылок `position: relative; padding: 0.3em 0 .1em 0;`.
* Множественные добавления и исправления в стилях для печати.
Структура style.css (основной файл стилей):
```
/* Название, данные о файле*/
/* Памятка верстальщику */
/* данные о цветах, используемых в макете */
/* BLOCKS */
[Описание блочной структуры]
/* TYPOGRAPHY */
[типографические правила]
/* SIDEBAR ONLY */
[типографические правила для .sidebar]
/* SERVICE */
[сервисные правила]
/* DESIGN ELEMENTS */
[элементы оформления добавочных блоков]
```
#### JavaScript
NTH-фреймворк имеет «на борту» jQuery 1.2.6.
##### Особенности
* Добавлено выделение `tr` при наведении (для IE6; для нормальных браузеров дублировано через CSS).
* Добавлено изменение параметра `value` для тега `input` поисковой формы при получении фокуса.
#### Лицензия
NTH-фреймворк распространяется по лицензии Creative Commons Attribution-ShareAlike (by-sa)
Этот тип лицензии позволяет перерабатывать, исправлять и развивать произведение даже в коммерческих целях до тех пор, пока указывается авторство и все производные произведения лицензируются на аналогичных условиях.
#### Скачать NTH-фреймворк
[Скачать с моего блога](http://nicothin.ru/files/nth_framework_10.zip).
#### Послесловие
Не исключены баги (и просто проблемы) верстки. Буду рад, если Вы обратите на них внимание. Собственно, создавая этот топик, я очень надеюсь, что коллеги укажут на проблемы и ошибки, возможные дополнения.
UPD: пост перенесен в блог «Web-разработка» | https://habr.com/ru/post/39279/ | null | ru | null |
# Включение Samba-сервера на базе Ubuntu в домен AD
В нашей предыдущей работе было рассмотрено, что такое Active Directory и Samba и в чем состоят преимущества их совместной работы. Также был рассмотрен процесс сборки Samba из исходников и включение ее в домен, и все это — из командной строки. Следует признать, что сборка чего-либо из исходников не является распространенной практикой в современных дистрибутивах Линукс. Гораздо чаще для установки программного обеспечения используются репозитории. Это позволяет сделать процесс установки более дружелюбным и простым для пользователя. Также могут автоматически вовлекаться дополнительные пакеты, необходимые для работы устанавливаемого ПО, что опять же серьезно облегчает жизнь и избавляет от необходимости изучать списки необходимых предустановленных пакетов. В настоящее время наблюдается тенденция к повсеместному использованию графических интерфейсов. Можно долго обсуждать доводы «за» и «против», но факт остается фактом: все большее количество пользователей и даже системных администраторов предпочитает для значительного числа задач использовать GUI. В рамках этой статьи мы постараемся рассмотреть процесс установки и включения в домен Samba при помощи командной строки и репозиториев, а также включение Samba в домен при помощи графического интерфейса утилиты SADMS.
По статистике, Openstat Ubuntu является 4-й в списке самых популярных ОС для веб-серверов, и её популярность быстро растёт. В нашем случае это дистрибутив Ubuntu Server 12.04 LTS. Найти дистрибутив можно на официальном [сайте Ubuntu](http://www.ubuntu.com/download/server).
##### 1.Включение Samba-сервера на базе Ubuntu в домен AD при помощи командной строки
Для начала рассмотрим включение сервера на базе Ubuntu в домен AD средствами командной строки. Процесс подробно описан в документации на [сайте Ubuntu](http://help.ubuntu.ru/wiki/ввод_в_домен_windows).
##### 2.Установка обновлений и необходимых пакетов.
Нам понадобятся Kerberos, Samba и Winbind. Прежде чем их устанавливать, рекомендуется обновить систему:
```
sudo apt-get update
sudo apt-get upgrade
```
После успешной установки обновлений ставим Kerberos, Samba и Winbind:
```
sudo apt-get install install krb5-user samba winbind
```
В этой команде,
**krb5-user**— пакет для протокола Kerberos, который используется для аутентификации в Windows;
**samba**— позволяет стать членом домена;
**winbind**— позволяет использовать учетную запись пользователя из ActiveDirectory.
При использовании графического интерфейса можно использовать менеджер пакетов Synaptic. Стоит заметить, что по умолчанию в Ubuntu Server 12.04 LTS графического интерфейса нет, его при необходимости можно установить отдельно:
```
sudo apt-get install ubuntu-desktop
```
После этого необходимо сконфигурировать все компоненты для работы с доменом. Тестовый домен называется LAB.LOCAL, контроллер домена — lab-dc1.lab.local, c IP 192.168.7.2, имя сервера — testubuntu.
##### 3.Настройка DNS
В первую очередь необходимо настроить DNS на хосте под управлением Ubuntu (сервером DNS будет контролер домена), а также прописать правильный домен поиска. Для этого необходимо отредактировать файл /etc/resolv.conf, чтобы он содержал следующую информацию:
```
domain lab.local
search lab.local
nameserver 192.168.7.2
```
Для их применения изменений необходимо перезапустить сетевую службу:
```
/etc/init.d/networking restart
```
Также следует убедиться, что имя сервера в файле */etc/hostname* задано верно:
```
testubuntu
```
Необходимо еще отредактировать файл /etc/hosts таким образом, чтобы в нём была запись с полным доменным именем компьютера и обязательно с коротким именем хоста, ссылающаяся на один из внутренних IP:
```
# Имена этого компьютера
127.0.0.1 localhost
127.0.1.1 testubuntu.lab.local testubuntu
```
##### 4.Настройка синхронизации времени.
Следующий шаг — настройка синхронизации по времени с контролером домена. Очень важно не забыть про этот момент, так как если расхождение по времени составит более пяти минут, мы не сможем получить тикет от Kerberos.
Если в сети существует сервер точного времени, то можно воспользоваться им или любым публичным:
```
ntpdate ntp.mobatime.ru
```
Автоматическая же синхронизация настраивается с помощью ntpd, этот демон будет периодически выполнять синхронизацию. Для начала его необходимо установить:
```
sudo ap*t-get* install ntp
```
Теперь необходимо внести правки в файл `/etc/ntp.conf`, добавив в него информацию о сервере времени:
```
# You do need to talk to an NTP server or two (or three).
server lab-dc1.lab.local
```
После чего нужно перезапустить демон `ntpd`:
```
sudo /etc/init.d/ntp restart
```
##### 5.Настройка Kerberos.
Следующий этап — настройка авторизации через протокол Kerberos. Нужно будет отредактировать файл `/etc/krb5.conf`. Ниже приведен результат правок:
```
[libdefaults]
default_realm = LAB.LOCAL
kdc_timesync = 1
ccache_type = 4
forwardable = true
proxiable = true
v4_instance_resolve = false
v4_name_convert = {
host = {
rcmd = host
ftp = ftp
}
plain = {
something = something-else }
}
fcc-mit-ticketflags = true
```
```
[realms]
LAB.LOCAL = {
kdc = lab-dc1
admin_server = lab-dc1
default_domain = LAB.LOCAL
}
```
```
[domain_realm]
.lab.local = LAB.LOCAL
lab.local = LAB.LOCAL
[login]
krb4_convert = false
krb4_get_tickets = false
```
На данном этапе можно проверить, что мы можем авторизоваться в домене. Для этого используем следующую команду:
```
kinit user@LAB.LOCAL
```
Вместо `user`, естественно, стоит вписать имя существующего пользователя домена. Имя домена необходимо писать заглавными буквами!
Если выполнение команды не привело к возникновению ошибок — значит, всё верно, и домен отдаёт вам тикет Kerberos. Убедиться в том, что тикет получен, можно, выполнив команду:
```
klist
```
Удалить все тикеты можно командой
```
kdestroy
```
Итак, будем считать, что авторизация прошла успешно; пора настроить непосредственно вход в домен.
Еще один файл, который нас интересует — `/etc/samba/smb.con`f. В нем нам нужна секция `[global]`. Ниже — пример части файла конфигурации Samba с комментариями по поводу значения важных параметров:
```
[global]
```
```
# Эти две опции нужно писать именно в заглавном регистре, причём `workgroup` без
# последней секции после точки, а `realm` - полное имя домена
workgroup = LAB
realm = LAB.LOCAL
```
```
# Эти две опции отвечают как раз за авторизацию через AD
security = ADS
encrypt passwords = true
# Просто важные
dns proxy = no
socket options = TCP_NODELAY
```
```
# Если вы не хотите, чтобы самба пыталась при случае вылезти в лидеры в домене или рабочей группе,
# или даже стать доменконтроллером, то всегда прописывайте эти пять опций именно в таком виде
domain master = no
local master = no
preferred master = no
os level = 0
domain logons = no
```
```
# Отключить поддержку принтеров
load printers = no
show add printer wizard = no
printcap name = /dev/null
disable spoolss = yes
```
Отредактировав `smb.conf`, выполните команду
```
testparm
```
Она проверит конфигурацию на ошибки и выдаст суммарную сводку о нём:
```
# testparm
Load smb config files from /etc/samba/smb.conf
Loaded services file OK.
Server role: ROLE_DOMAIN_MEMBER
Press enter to see a dump of your service definitions
```
Как видно, были заданы правильные параметры для того, чтобы компьютер стал членом домена. Теперь пора попытаться непосредственно войти в домен. Для этого используется следующая команда:
```
net ads join -U admin -D LAB
```
И в случае успеха вывод команды должен быть примерно таким:
```
# net ads join -U *admin* -D LAB
Enter admin's password:
Using short domain name — LAB
Joined 'testubuntu' to realm 'lab.local'
```
##### 6.Параметры, используемые командой net
1. `U username%password` — обязательный параметр, вместо admin необходимо подставить имя пользователя с правами администратора домена и указать пароль.
2. `D DOMAIN: DOMAIN` — собственно сам домен; его можно и не указывать, но лучше всё же это делать всегда — так спокойнее.
3. `S win_domain_controller: win_domain_controller` можно не указывать, но бывают случаи, когда автоматически сервер не находит контроллер домена.
4. `createcomputer=«OU/OU/…»`: в AD часто используется OU (Organizational Unit), есть в корне домена OU = Office, в нем OU = Cabinet; чтобы сразу добавить в нужный, можно указать так:
```
sudo net ads join -U username createcomputer=«Office/Cabinet».
```
Если больше никаких сообщений нет, значит, всё прошло успешно.
Попробуйте использовать ping по имени с другого члена домена, чтобы убедиться, что в домене всё отработало как следует.
Можно также использовать команду
```
net ads testjoin
```
Если проблем не возникло, то вывод команды будет следующим:
```
#net ads testjoin
Join is OK
```
Но иногда после сообщения о присоединении к домену выдаётся такая ошибка:
```
DNS update failed!
```
Прежде чем выяснять, почему же не обновляется DNS, перезагрузите компьютер после введения в домен! Вполне возможно, что это решит проблему.
Если это не помогло, рекомендуется ещё раз проверить настройки DNS: с большой долей вероятности причина будет в них. После этого нужно удалить компьютер из домена и попытаться повторить процесс заново.
Если всё прошло без ошибок, то компьютер успешно включен в домен. Можно зайти на домен-контроллер и убедиться в этом.
Если вам необходимо как-либо работать с пользователями домена, например, настраивать SMB-шары с разграничением доступа, то кроме самой Samba вам понадобится ещё и Winbind — специальный демон, служащий для связи локальной системы управления пользователями и группами Linux с сервером Active Directory.
Проще говоря, Winbind нужен, если вы хотите видеть пользователей домена на своём компьютере с Ubuntu.
Winbind позволяет спроецировать всех пользователей и все группы AD в вашу Linux-систему, присвоив им ID из заданного диапазона. Таким образом, вы сможете назначать пользователей домена владельцами папок и файлов на вашем компьютере и выполнять любые другие операции, завязанные на пользователей и группы.
Для настройки Winbind используется всё тот же файл `/etc/samba/smb.conf`. Добавьте в секцию `[global]` следующие строки:
```
# Опции сопоставления доменных пользователей и виртуальных пользователей в системе через Winbind.
# Диапазоны идентификаторов для виртуальных пользователей и групп.
idmap uid = 10000 - 40000
idmap gid = 10000 - 40000
# Эти опции не стоит выключать.
winbind enum groups = yes
winbind enum users = yes
# Использовать домен по умолчанию для имён пользователей. Без этой опции имена пользователей и групп
# будут использоваться с доменом, т.е. вместо user - DOMAIN\user.
# Возможно именно это вам и нужно, однако обычно проще этот параметр включить.
winbind use default domain = yes
# Если вы хотите разрещить использовать командную строку для пользователей домена, то
# добавьте следующую строку, иначе в качестве shell'а будет вызываться /bin/false
template shell = /bin/bash
# Для автоматического обновления билета Kerberos модулем pam_winbind.so нужно добавить строчку
winbind refresh tickets = yes
```
Теперь перезапустите демон Winbind и Samba в следующем порядке:
```
sudo /etc/init.d/winbind stop
sudo smbd restart
sudo /etc/init.d/winbind start
```
После перезапуска проверьте, что Winbind установил доверительные отношения с AD командой
```
# wbinfo -t
```
а также, что Winbind увидел пользователей и группы из AD, командами
```
wbinfo -u
wbinfo -g
```
Эти две команды должны выдать список пользователей и групп из домена соответственно.
Итак, Winbind работает, однако в систему он ещё не интегрирован.
Чтобы ваша Ubuntu прозрачно работала с пользователями домена (в частности, чтобы вы могли назначать пользователей домена владельцами папок и файлов), необходимо указать Ubuntu использовать Winbind как дополнительный источник информации о пользователях и группах.
Для этого измените две строчки в файле `/etc/nsswitch.conf`:
```
passwd: compat
group: compat
```
добавив к ним в конец winbind:
```
passwd: compat winbind
group: compat winbind
```
Теперь проверьте, что Ubuntu запрашивает у Winbind информацию о пользователях и группах, выполнив
```
getent passwd
getent group
```
Первая команда должна вам вернуть всё содержимое вашего файла `/etc/passwd`, то есть ваших локальных пользователей плюс пользователей домена с ID из заданного вами в `smb.conf` диапазона. Вторая должна сделать тоже самое для групп.
##### Включение Samba-сервера на базе Ubuntu в домен AD при помощи графического интерфейса и SADMS.
Возможно, скажем в домашних условиях или в спешке, вам захочется произвести все эти манипуляции в графическом режиме. Для этих целей существует пакет SADMS, о котором есть информация на [сайте Ubuntu](http://help.ubuntu.com/community/ActiveDirectoryWinbind-SADMS). А [на сайте](http://sadms.sourceforge.net/) можно узнать все об этом пакете и скачать его. Посмотрим на интерфайс пакета:
Рис. 1. Общий вид главной вкладки.
Здесь отображаются статусы winbind, smb и nmb, и присутствует индикация подключения компьютера к домену.
Рис. 2. Запуск smb и nmb.
Рис. 3. Вкладка «Данные».
Здесь мы должны указать данные, которые будут использоваться для подключения к домену. По умолчанию поля заполнены разработчиками, для примера. Разработчики пакета — французы, так что пусть вас не смущают примеры вроде «administrateur» вместо привычного «Administrator».
Рис. 4. Автоматический захват части параметров.
Щелкаем по «Определить» — и часть параметров подхватывается автоматически. Остальные придется заполнять вручную. Все эти параметры использовались при настройке из командной строки.
Рис. 5. Заполнение остальных полей.
Заполняем поля. Здесь обратите особое внимание: Netbios имя домена должно быть прописано БОЛЬШИМИ буквами, иначе получим ошибку Kerberos, как вышло в данном случае. Если все заполнено правильно, щелкаем по «Установить» — и SADMS включает машину в домен.
Рис. 6. Машина включена в домен успешно.
Рис. 7. Меню «Проверки».
Из меню «Проверки» мы можем выполнить тесты на выполнение различных операций. Также можно провести все тесты из командной строки, как это описывалось ранее.
Рис. 8. Пример вывода теста на членство в домене.
Рис. 9. Результаты теста сети.
Рис. 10. Проверка наличия машины на контролере домена.
Сервер находится в списке доменных машин вместе с другими нашими серверами.
Итак, мы рассмотрели установку Samba и включение ее в домен — с использованием как командной строки, так и графического интерфейса. Использование графического интерфейса позволяет серьезно ускорить и упростить настройку, но вместе с тем не позволяет понять всю механику процесса, а также может серьезно затруднить процесс поиска ошибки. С другой стороны, CLI (Command Line Interface), хоть и предоставляет абсолютный контроль над всем, гораздо менее дружелюбен к пользователю и подразумевает у него наличие некоторых навыков работы. Какой способ использовать — решать вам. | https://habr.com/ru/post/171057/ | null | ru | null |
# Увидеть незримое
Пару лет назад на Хабре проскакивало две статьи, в которых упоминался интересный алгоритм. Статьи, правда, были написаны нечитабильно. В стилистике «новости»([1](http://habrahabr.ru/post/145135/), [2](http://habrahabr.ru/company/nordavind/blog/184610/)), но ссылка на сайт присутствовала, подробно можно было разобраться на [месте](http://people.csail.mit.edu/mrub/vidmag/) (алгоритм за авторством MIT). А там была магия. Абсолютно волшебный алгоритм, позволяющий увидеть незримое. Оба автора на Хабре этого не заметили и сфокусировались на том, что алгоритм позволял увидеть пульс. Пропустив самое главное.
Алгоритм позволял усиливать движения, невидные глазу, показать вещи, которые никто никогда не видел живьём. Видео чуть выше – [презентация](http://people.csail.mit.edu/nwadhwa/phase-video/) c сайта MIT второй части алгоритма. Микросаккады, которые приведены начиная с 29ой секунды, раньше наблюдались только как отражения установленных на зрачках зеркалах. А тут они видны глазами.
Пару недель назад я опять натолкнулся на те статьи. Мне сразу стало любопытно: а что народ сделал за эти два года готового? Но… Пустота. Это определило развлечение на следующие полторы недели. Хочу сделать такой же алгоритм и разобраться, что с ним можно сделать и почему его до сих пор нет в каждом смартфоне, как минимум для измерения пульса.
В статье будет много матана, видео, картинок, немного кода и ответы на поставленные вопросы.
NB!
---
*Обратите внимание, статья 2014 года. А сейчас 2021. С тех пор произошло пару революций в ComputerVision. Делает ли это приведенные тут методы неправильными? Нет. Но, скорее всего это не то что вы хотите использовать в качестве основы от которой идти дальше. Сейчас есть много нейросетевых подходов, которые позволяют чуть точнее решать описанные тут задачи. Если хотите оставаться в курсе событий — советую читать мой канал ([vk](https://vk.com/cvml_team), [telegram](https://t.me/CVML_team)) про более новые методы/подходы.*
Начнём с математики (я не буду придерживаться какой-то одной определённой статьи, а буду мешать из разных частей разных статей, для более гладкого повествования). У исследовательской группы есть две основных работы по алгоритмической части:
1) [Eulerian Video Magnification for Revealing Subtle Changes in the World](http://people.csail.mit.edu/mrub/papers/vidmag.pdf);
2) [Phase-Based Video Motion Processing](http://people.csail.mit.edu/billf/publications/Phase-Based_Video.pdf).
В первой работе реализуется амплитудный подход, более грубый и быстрый. Его я и брал за основу. Во второй работе кроме амплитуды используется фаза сигнала. Это позволяет получить значительно более реалистичное и чёткое изображение. Видео выше прилагалось именно к этой работе. Минус – более сложный алгоритм и обработка, заведомо вылетающая из реального времени без применения видеокарты.
#### Начнём?
Что такое усиление движения? Усиление движения, это когда мы предсказываем в какую сторону сигнал смешается и сдвигаем его в эту сторону дальше.
Пусть у нас есть одномерный приёмник. На этом приёмнике мы видим сигнал I(x,t)=f(x). На картинке от нарисован чёрным (для некоторого момента t).В следующий момент времени сигнал I(x,t+1)= f(x+Δ) (синий). Усилить этот сигнал, это значит получить сигнал I’(x,t+1)= f(x+(1+α)Δ). Тут α – коэффициент усиления. Разложив его в ряд Тейлора его можно выразить как:
Пусть:
Что такое B? Грубо говоря это I(x,t+1)- I(x,t). Нарисуем:
Конечно, это неточно, но в качестве грубого приближения сойдёт (голубой график показыает форму такого «приближенонго» сигнала). Если мы домножим B на (1+α) это и будет «усиление» сигнала. Получаем (красный график):
В реальных кадрах может присутствовать несколько движений, каждое из которых будет идти с разной скоростью. Приведённый выше способ — линейный прогноз, без доработки он обломится. Но, есть классический подход для решения этой проблемы, который и использовался в работе — разложить движения по частотным характеристикам (как пространственным, так и временным).
На первом этапе происходит разложение изображения по пространственным частотам. Этот этап, кроме того, реализует получение дифференциала ∂f(x)/ ∂x. В [первой](http://people.csail.mit.edu/mrub/papers/vidmag.pdf) работе не рассказано, как они его реализуют. Во [второй](http://people.csail.mit.edu/mrub/papers/phasevid-siggraph13.pdf) работе, при использовании фазового подхода, амплитуда и фаза считалась фильтрами Габбора разного порядка:
Примерно так я и поступил, взяв фильтр:
И нормировав его значение, чтобы
Тут l — расстояния пикселя от центра фильтра. Конечно, я немного схалтурил, взяв такой фильтр только для одного значения окна σ. Это позволило значительно ускорить вычисления. При этом получается чуть более размазанная картинка, но я решил не стремиться за высокой точностью.
Вернёмся к формулам. Пусть мы хотим усилить сигнал, дающий характерный отклик на частоте ω в нашей временной последовательности кадров. Мы уже подобрали характерный пространственный фильтр с окном σ. Это даёт нам примерный дифференциал в каждой точке. Как понятно из формул — остаётся только временная функция, дающая отклик на наше движение и коэффициент усиления. Умножаем на синус той частоты, которую хотим усилить (это и будет функция, дающая временной отклик). Получаем:
Конечно, куда проще, чем в оригинальной статье, зато чуть-чуть меньше проблем со скоростью.
#### Код и результат
Исходники к первой статье выложены в открытом доступе на Матлабе:. Казалось бы, зачем изобретать велосипед и писать самому? Но был целый ряд причин, во многом завязанных на Матлаб:
1. Если потом придёт в голову сделать что-то разумное и применимое, код на Матлабе куда сложнее использовать, чем C#+OpenCV, портирующийся за пару часов в с++.
2. Оригинальный код ориентировался на работу с сохранёнными видео, имеющее постоянный битрейт. Чтобы можно было работать с камерами, подключёнными к компьютеру, обладающими переменным битрейтом нужно менять логику.
3. Оригинальный код реализовывал самый простой из их алгоритмов, без всяких плюшек. Реализовать чуть более сложную версию с плюшками – уже пол работы. К тому же, не смотря на то, что алгоритм был оригинальным, параметры на его вводе были не те, что в статьях.
4. Оригинальный код периодически приводил к мёртвому зависанию компа (даже без синего экрана). Может только у меня, но ведь некомфортно.
5. В оригинальном коде был только консольный режим. Делать всё визуальным в Матлабе, который я знаю значительно хуже VS, было бы значительно дольше, чем всё переписать.
[Исходники](https://github.com/ZlodeiBaal/MotionMagnification) я выложил на github.com и достаточно подробно прокомментировал. Программа реализует захват видео с камеры и его анализ в реальном времени. Оптимизации получилось немного с запасом, но можно добиться подвисаний, расширяя параметры. Что обрезано во имя оптимизации:1. Использование кадра с уменьшенным размером. Значительно ускоряет работу. На форму не стал выводить управление размером кадра, но если откроете код, то строчка: "\_capture.QueryFrame().Convert().PyrDown().PyrDown();" это оно
2. Использование только одного пространственного фильтра. Для ситуации, когда известно желаемое движение потери некритичны. Управление параметром фильтра с формы (длинна волны фильтра Габора).
3. Использование только одной частоты, подчёркивающей временной ряд. Конечно, можно было делать свёртку с заранее рассчитанным окном со спектром почти без потери производительности, но этот способ тоже неплохо работает. С формы управляется либо ползунком, либо вводом предельных значений.
Маленькая ремарка. Все результаты получены на обычной веб-камере в домашних условиях. При использовании камеры с хорошими параметрами + штатива + правильного освещения + подавления 50ГЦ помехи качество значительно улучшится. Моей целью не было получение красивой картинки или улучшенного алгоритма. Цель – добиться результата в домашних условиях. Ну, как бонус, хотелось бы ещё сделать запись пульса когда я играю в Starctaft 2… Любопытно же, насколько e-sport таки спорт.
В итоге логика работы получается:
Всё просто до безобразия. Например суммирование прирощения с кадром реализовано вообще так:
```
for (int x = 0; x < Ic[ccp].I.Width; x++)
for (int y = 0; y < Ic[ccp].I.Height; y++)
{
FF2.Data[y, x, 0] = Alpha * FF2.Data[y, x, 0] / counter;
ImToDisp.Data[y, x, 0] = (byte)Math.Max(0, Math.Min((FF2.Data[y, x, 0] + ImToDisp.Data[y, x, 0]), 255));
}
```
(Да, я знаю, что при наличии OpenCV это не оптимальный способ).
Где-то 90% кода это не ядро, я обвес вокруг него. Но реализация ядра даёт уже неплохой результат. Видно как раздувается грудная клетка на пару десятков сантиметров при дыхании, видно как набухает вена, как качается голова в такт пульса.
Вот тут подробно объясняется, почему качается голова от пульса. По сути это отдача от вброса крови сердцем:
#### Немножко про красоту
Конечно, в MIT любят красивые результаты. И, поэтому, стараются сделать их как можно красивее. В результате у смотрящего создаётся впечатление, что эта частность это и есть целое. К сожалению нет. Разбухающую вену можно увидеть только при правильно поставленном освещении (тень должна рисовать узор кожи). Изменение цвета лица — только на хорошей камере без автокоррекции, с правильно поставленным светом и человеком, у которого имеются явные сложности с сердцем (в видео это грузный мужчина и недоношенный ребёнок). Например в примере с негром, у которого с сердцем всё хорошо, вы видите не колебание яркости кожи, а усиление изменения тени из-за микродвижений (тень аккуратно лежит сверху вниз).
#### Количественных характеристики
Но всё же. В видео явно видны дыхание и пульс. Давайте попробуем их получить. Самое простое, что приходит в голову — просуммированная разница между соседними кадрами. Так как при дыхании колеблется почти всё тело — эта характеристика должна быть заметна.
Полученный график прогоним через Фурье-преобразование, посчитав спектр (на графике набрана статистика где-то за 5 минут суммированием спектра, рассчитанного по 16-секундным отрезкам).
Виден явный пик на частотах 0.6-1.3, не свойственный шуму. Так как дыхание не синусоидальный процесс, а процесс, имеющий два явных всплеска (при вдохе-выдохе), то частота разностной картинки должна равняться двойной частоте дыхания. Частота дыхания у меня была где-то 10 вдохов за 30 секунд (0.3 HZ). Её удвоение — 0.6HZ. Что приблизительно равно выявленному максимуму спектрограммы. Но, понятно, о точном значении говорить не приходится. Кроме дыхания вытягивается множество мелкой моторики тела, которая значительно портит картину.
Имеется интересный пик на 2.625HZ. Судя по всему это пробивается наводка электросети на матрицу. По матрице ползут полосы, которые успешно дают максимум на этой частоте.
Между прочим, двойная частота пульса должна лежать примерно в том же диапазоне, а значит этот метод не должен на ней сработать. И действительно:
В таком спектре найти пульс нельзя.
В одной из работ MIT приведён другой способ для измерения частоты пульса: вычислять [оптический поток](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D1%83%D0%BA%D0%B0%D1%81%D0%B0_%E2%80%94_%D0%9A%D0%B0%D0%BD%D0%B0%D0%B4%D0%B5) на лице и определять его по частоте этого потока. Так я и сделал (на графике тоже спектры):
Лучше видно на графике на котором я откладывал количество максимумов спектра:
Почему максимум на частоте пульса \*3 я не знаю как объяснить, но этот максимум точно есть и завязан на пульс:)
Хотелось бы отметить только, что для получения пульса таким способом нужно сидеть прямо и не двигаться. При игре в Старкрафт это невозможно, частота не снимается. Эх… А такая задумка! Придётся добывать пульсометр, ведь интересно теперь стало!
#### Итак, результат
В результате я достаточно чётко сформировал своё мнение о границах алгоритма, мне стало понятно, какие у него ограничения:
**Почему он не стал популярным для измерения пульса?** Качества для Web-камер компьютера хватает на границе, а то и не хватает. У android явно не хватит производительности. Остаются спецсредства для профессионального измерения. Но они будут очень дорогими и не стабильными к внешним условиям (засветка, мерцающий свет, темнота, тряска), а качество будет ниже, чем у проверенных средств съёмки пульса.
**Почему алгоритм не используется для оценки колебаний домов, мостов, кранов?** Опять же. Спецсредства дешевле и дают большую точность.
**А где же его можно использовать и можно ли вообще?** Думаю, что можно. Везде где нужна наглядность. Научные видеосъёмки, образовательные программы. Тренинг психиаторов, психологов, ~~пикаперов~~ (видны мельчайшие движения человека, усиливается мимика). Для анализа переговоров. Конечно, при этом использовать нужно не простую версию алгоритма, а ту версию, которая у них в последней работе и основана на фазовом подходе. При этом в реальном времени всё это сложно будет увидеть, производительности не будет хватать, разве что на видюхе всё распаралелить. Зато можно посмотреть постфактум.
#### Ничего не ново под луной
Когда читаешь работы товарищей и смотришь видео закрадывается подозрение. Где-то я всё это видел. Вот смотришь и думаешь, думаешь. А потом они показывают видео того, как с помощью этого же алгоритма берут и стабилизируют движение Луны, убирая шумы атмосферы. И тут как вспышка: «Да это же алгоритм подавления шумов, только с положительной обратной связью!!». И вместо того, чтобы подавлять паразитные движения, он их усиливает. Если взять α<0, тогда связь опять отрицательная и движения уходят!
Конечно, в алгоритмах подавления движения и тряски чуть другая математика и чуть другой подход. Но ведь по сути ровно тот же спектральный анализ пространственно-временной трубки.
Хотя говорить, что тут свиснули алгоритм глупо. В MIT реально заметили одну маленькую интересную особенность, развили её и получили целую теорию с такими красивыми и магическими картинками.
#### И напоследок: программист, будь аккуратен!
Алгоритм, судя по пометкам на сайте, патентуется. Использование разрешено в образовательных целях. Конечно, в России не существует патентования алгоритмов. Но будьте аккуратны, если сделаете что-то на его базе. Вне пределов России это может стать нелегально.
#### Подвал
[Сайт про исследования MIT на тему усиления движения](http://people.csail.mit.edu/mrub/vidmag/);
[Мои исходники](https://github.com/ZlodeiBaal/MotionMagnification).
*З.Ю. А подскажите пульсометр, который бы мог данные на комп скидывать и, желательно, какой-нить интерфейс под Android имел?* | https://habr.com/ru/post/232515/ | null | ru | null |
# 64-битный код в 2015 году: что нового в диагностике возможных проблем?
64-битные ошибки достаточно тяжело обнаружить, так как они сродни бомбе замедленного действия: могут дать о себе знать далеко не сразу. Статический анализатор [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) облегчает задачу поиска и исправления подобных ошибок. Однако в этом направлении были сделаны ещё несколько шагов: недавно были более внимательно пересмотрены 64-битные диагностики, вследствие чего их распределение по уровням важности изменилось. Речь в данной статье пойдёт об этих изменениях, а также о том, как это повлияло на работу с инструментом и на поиск ошибок. Примеры 64-битных ошибок из реальных приложений прилагаются.
О чём статья?
-------------
Для начала хотелось бы внести конкретики по содержанию. В статье раскрываются следующие темы:1. Изменения в анализаторе PVS-Studio, затрагивающие поиск 64-битных ошибок;
2. Обзор 64-битных ошибок первого уровня, найденных анализатором PVS-Studio, и краткие комментарии к ним;
3. Сравнение эффективности в поиске наиболее важных ошибок средствами PVS-Studio и Microsoft Visual Studio 2013.
Первый пункт говорит сам за себя: в нём будут рассмотрены основные изменения PVS-Studio, касающиеся анализа 64-битных ошибок, а также то, как они отразятся на работе с инструментом.
Второй, основной раздел, посвящён найденным 64-битным ошибкам в реальных проектах. Помимо фрагментов кода из проектов также будут приведены комментарии к ним, так что, возможно, вам удастся почерпнуть что-то новое для себя.
В третьем разделе осуществляется сравнение в эффективности поиска этих ошибок статическим анализатором PVS-Studio и средствами среды Microsoft Visual Studio 2013. Причём, в случае Visual Studio, для поиска ошибок использовались как компилятор, так и статический анализатор.
Не стоит забывать, что здесь выписаны только некоторые ошибки. В реальном проекте их наверняка будет куда больше и они будут более разнообразными. В конце статьи предложны ссылки, которые более полно познакомят вас с миром 64-битных ошибок.
Изменения в PVS-Studio, связанные с 64-битными ошибками
-------------------------------------------------------
Не так давно мы внимательно просмотрели 64-битные диагностики и более аккуратно распределили их по уровням важности.
Теперь распределение 64-битных ошибок выглядит так:
**Уровень 1.** Критические ошибки, которые причиняют вред в любом приложении. Примером может служить хранение указателя в 32-битной переменной типа int. Если вы разрабатываете 64-битное приложение, вы обязательно должны изучить и исправить предупреждения первого уровня.
**Уровень 2.** Ошибки, которые как правило проявляют себя только в приложениях, обрабатывающие большие массивы данных. Пример — использование для индексации огромного массива переменной типа 'int'.
**Уровень 3.** Всё остальное. Как правило, эти предупреждения не актуальны. Однако, для некоторых приложений, та или иная диагностика может оказаться крайне полезной.
Таким образом, установив фильтрацию по 64-битным ошибкам первого уровня, вы получите список сообщений, указывающих на участки кода, которые с большей вероятностью являются ошибочными. Не стоит недооценивать эти предупреждения, так как последствия 64-битных ошибок могут быть самыми разными, но явно неприятными и часто неожиданными. Именно про них и пойдёт речь.
Насколько тяжело было бы обнаружить подобные ошибки без такого инструмента, как PVS-Studio, думаю, поймёте по мере прочтения статьи.
Анализ 64-битных ошибок
-----------------------
Необходимо внимательно следить за правильным использованием типов данных. С этого, пожалуй, и начнём.
```
LRESULT CSaveDlg::OnGraphNotify(WPARAM wParam, LPARAM lParam)
{
LONG evCode, evParam1, evParam2;
while (pME && SUCCEEDED(pME->GetEvent(&evCode,
(LONG_PTR*)&evParam1,
(LONG_PTR*)&evParam2, 0)))
{
....
}
return 0;
}
```
Предупреждения анализатора:* [V114](http://www.viva64.com/ru/d/0050/) Dangerous explicit type pointer conversion: (LONG\_PTR \*) & evParam1 test.cpp 8
* [V114](http://www.viva64.com/ru/d/0050/) Dangerous explicit type pointer conversion: (LONG\_PTR \*) & evParam2 test.cpp 8
Для того, чтобы понять суть ошибки, необходимо взглянуть на типы переменных 'evParam1', 'evParam2', а также на объявление метода 'GetEvent':
```
virtual HRESULT STDMETHODCALLTYPE GetEvent(
/* [out] */ __RPC__out long *lEventCode,
/* [out] */ __RPC__out LONG_PTR *lParam1,
/* [out] */ __RPC__out LONG_PTR *lParam2,
/* [in] */ long msTimeout) = 0;
```
Как видно из сообщения анализатора, выполняется опасное явное приведение типа. Дело в том, что тип 'LONG\_PTR' является '[memsize-типом](http://www.viva64.com/ru/t/0030/)', имеющим размер 32 бита на Win32 (модель данных [ILP32](http://www.viva64.com/ru/t/0018/)) и 64 бита на архитектуре Win64 (модель данных [LLP64](http://www.viva64.com/ru/t/0026/)). В то же время тип 'LONG' имеет размеры 32 бита на обеих архитектурах. Так как на 64-битной архитектуре вышеупомянутые типы имеют разный размер, возможна некорректная работа с объектами, на которые ссылаются эти указатели.
Продолжим тему опасных приведений типов. Взглянем на следующий код:
```
BOOL WINAPI TrackPopupMenu(
_In_ HMENU hMenu,
_In_ UINT uFlags,
_In_ int x,
_In_ int y,
_In_ int nReserved,
_In_ HWND hWnd,
_In_opt_ const RECT *prcRect
);
struct JABBER_LIST_ITEM
{
....
};
INT_PTR CJabberDlgGcJoin::DlgProc(....)
{
....
int res = TrackPopupMenu(
hMenu, TPM_RETURNCMD, rc.left, rc.bottom, 0, m_hwnd, NULL);
....
if (res) {
JABBER_LIST_ITEM *item = (JABBER_LIST_ITEM *)res;
....
}
....
}
```
Предупреждение анализатора: [V204](http://www.viva64.com/ru/d/0156/) Explicit conversion from 32-bit integer type to pointer type: (JABBER\_LIST\_ITEM \*) res test.cpp 57
Для начала неплохо было бы взглянуть на использовавшуюся в данном коде функцию 'TrackPopupMenu'. Она возвращает идентификатор выбранного пользователем элемента меню, или нулевое значение в случае ошибки или если выбора не было. Тип 'BOOL' для этих целей явно выбран неудачно, но что делать.
Результат выполнения данной функции, как это видно из кода, заносится в переменную 'res'. В случае, если какой-то элемент пользователем всё же был выбран (res!=0), то данная переменная приводится к типу указателя на структуру. Интересный подход, но так как в статье мы ведём беседу про 64-битные ошибки, давайте подумаем, как этот код будет исполняться на 32 и 64-битных архитектурах, и в чём может быть проблема?
Загвоздка в том, что на 32-битной архитектуре такие преобразования допустимы и осуществимы, так как типы 'pointer' и 'BOOL' имеют одинаковый размер. Но грабли дадут о себе знать на 64-битной архитектуре. В Win64 приложениях вышеупомянутые типы имеют разный размер (64 и 32 бита соответственно). Потенциальная ошибка состоит в том, что могут быть потеряны значения старших бит в указателе.
Продолжаем обзор. Фрагмент кода:
```
static int hash_void_ptr(void *ptr)
{
int hash;
int i;
hash = 0;
for (i = 0; i < (int)sizeof(ptr) * 8 / TABLE_BITS; i++)
{
hash ^= (unsigned long)ptr >> i * 8;
hash += i * 17;
hash &= TABLE_MASK;
}
return hash;
}
```
Предупреждение анализатора: [V205](http://www.viva64.com/ru/d/0157/) Explicit conversion of pointer type to 32-bit integer type: (unsigned long) ptr test.cpp 76
Разберемся, в чём же заключается проблема приведения переменной типа 'void\*' к типу 'unsigned long' в этой функции. Как уже говорилось, данные типы имеют различный размер в модели данных LLP64, где тип 'void\*' занимает 64 бита, а 'unsigned long' — 32 бита. В результате этого будут отсечены (потеряны) старшие биты, содержавшиеся в переменной 'ptr'. Значение же переменной 'i' по мере прохождения итераций увеличивается, как следствие этого — побитовый сдвиг вправо по мере прохождения итераций будет затрагивать всё большее количество бит. Так как размер переменной 'ptr' был усечён, с некоторой итерации все содержащиеся в ней биты будут заполняться 0. Как итог всего вышеописанного — на Win64-приложениях 'hash' будет составляться некорректно. За счёт заполнения 'hash' нулями, возможно возникновение [коллизий](http://www.viva64.com/go.php?url=1607), то есть получение одинаковых хешей для различных входных данных (в данном случае — указателей). В результате это может привести к неэффективной работе программы. Если бы выполнялось приведение к 'memsize-типу', усечения не произошло бы, и тогда сдвиг (а следовательно — составление хеша) осуществлялся бы корректно.
Посмотрим на следующий код:
```
class CValueList : public CListCtrl
{
....
public:
BOOL SortItems(_In_ PFNLVCOMPARE pfnCompare,
_In_ DWORD_PTR dwData);
....
};
void CLastValuesView::OnListViewColumnClick(....)
{
....
m_wndListCtrl.SortItems(CompareItems, (DWORD)this);
....
}
```
Предупреждение анализатора: [V220](http://www.viva64.com/ru/d/0172/) Suspicious sequence of types castings: memsize -> 32-bit integer -> memsize. The value being cast: 'this'. test.cpp 87
Диагностика V220 сигнализирует о двойном опасном преобразовании данных. В начале переменная 'memsize-типа' превращается в 32-битное значение, а затем сразу расширяется обратно до 'memsize-типа'. Фактически, это означает что будут «отрезаны» значения старших бит. Почти всегда это ошибка.
Продолжим раскрывать тему опасных преобразований:
```
#define YAHOO_LOGINID "yahoo_id"
DWORD_PTR __cdecl CYahooProto::GetCaps(int type, HANDLE /*hContact*/)
{
int ret = 0;
switch (type)
{
....
case PFLAG_UNIQUEIDSETTING:
ret = (DWORD_PTR)YAHOO_LOGINID;
break;
....
}
return ret;
}
```
Предупреждение анализатора: [V221](http://www.viva64.com/ru/d/0361/) Suspicious sequence of types castings: pointer -> memsize -> 32-bit integer. The value being cast: '«yahoo\_id»'. test.cpp 99
Заметил тенденцию, что с каждым примером преобразований становится больше и больше. Тут их целых 3. И 2 из них являются опасными, по тем же причинам, что и все, описанные выше. Так как 'YAHOO\_LOGINID' является строковым литералом, его тип — 'const char\*', имеющий в 64-битной архитектуре тот же размер, что и тип 'DWORD\_PTR', так что явное преобразование корректно. Но вот дальше начинаются нехорошие вещи. Тип 'DWORD\_PTR' неявно приводится к целочисленному 32-битному. Но это не всё. Так как возвращаемый функцией результат имеет тип 'DWORD\_PTR', будет выполнено ещё одно неявное преобразование, на этот раз обратно к 'memsize-типу'. Очевидно, что в таком случае использование возвращённого значения ведётся на свой страх и риск.
Хочу отметить, что компилятор Visual Studio 2013 выдал предупреждение следующего вида:
warning C4244: '=': conversion from 'DWORD\_PTR' to 'int', possible loss of data
Здесь будет возможен актуальный вопрос: почему предупреждение, выданное Visual Studio 2013, приведено только в этом примере? Вопрос справедливый, но наберитесь терпения, об этом будет написано ниже.
А пока продолжим рассматривать ошибки. Рассмотрим следующий код, содержащий иерархию классов:
```
class CWnd : public CCmdTarget
{
....
virtual void WinHelp(DWORD_PTR dwData, UINT nCmd = HELP_CONTEXT);
....
};
class CFrameWnd : public CWnd
{
....
};
class CFrameWndEx : public CFrameWnd
{
....
virtual void WinHelp(DWORD dwData, UINT nCmd = HELP_CONTEXT);
....
};
```
Предупреждение анализатора: [V301](http://www.viva64.com/ru/d/0080/) Unexpected function overloading behavior. See first argument of function 'WinHelpA' in derived class 'CFrameWndEx' and base class 'CWnd'. test.cpp 122
Пример интересен тем, что взят из [отчёта](http://www.viva64.com/ru/b/0163/) при проверке библиотек Visual C++ 2012. Как видите, даже разработчики Visual C++ допускают 64-битные ошибки.
Достаточно подробно об этой ошибке написано в [соответствующей статье](http://www.viva64.com/ru/l/0012/). Здесь же я хотел объяснить суть вкратце. На 32-битной архитектуре данный код будет корректно отрабатываться, так как типы 'DWORD' и 'DWORD\_PTR' имеют одинаковый размер, в классе-наследнике данная функция будет переопределена, и код будет выполняться корректно. Но подводный камень никуда не делся и даст знать о себе на 64-битной архитектуре. Так как в этом случае типы 'DWORD' и 'DWORD\_PTR' будут иметь разные размеры, полиморфизм будет разрушен. Мы будем иметь на руках 2 разные функции, что идёт вразрез с тем, что подразумевалось.
И последний пример:
```
void CSymEngine::GetMemInfo(CMemInfo& rMemInfo)
{
MEMORYSTATUS ms;
GlobalMemoryStatus(&ms);
_ultot_s(ms.dwMemoryLoad, rMemInfo.m_szMemoryLoad,
countof(rMemInfo.m_szMemoryLoad), 10);
....
}
```
Предупреждение анализатора: [V303](http://www.viva64.com/ru/d/0082/) The function 'GlobalMemoryStatus' is deprecated in the Win64 system. It is safer to use the 'GlobalMemoryStatusEx' function. test.cpp 130
В принципе, особых пояснений не требуется, всё понятно из сообщения анализатора. Необходимо использовать функцию 'GlobalMemoryStatusEx', так как функция 'GlobalMemoryStatus' может работать некорректно на 64-битной архитектуре. Подробнее об этом написано на портале MSDN в [описании соответствующей функции](http://www.viva64.com/go.php?url=1592).
**Примечание.**
Обратите внимание на то, что все приведённые ошибки могут встретиться в самом обыкновенном прикладном программном обеспечении. Чтобы они возникли, программе вовсе не обязательно работать с большим объемом памяти. И именно поэтому диагностики, выявляющие эти ошибки, относятся к первому уровню.
Что нам скажет Visual Studio 2013?
----------------------------------
### Предупреждения компилятора
Прежде чем рассказывать про результаты проверки статического анализатора среды Visual Studio 2013, хотелось бы остановиться на предупреждениях компилятора. Внимательные читатели наверняка заметили, что в тексте было приведено только 1 такое предупреждение. В чём же дело, спросите вы? А дело в том, что больше никаких предупреждений, как-то связанных с 64-битными ошибками, попросту не было. И это при 3-м уровне выдачи предупреждений.
Но стоит скомпилировать этот пример при всех включённых предупреждениях (EnableAllWarnings), как получаем…
Причём, совершенно неожиданно, предупреждения ведут в заголовочные файлы (например, winnt.h). Если не полениться и найти в этой куче предупреждений те, которые относятся к проекту, то всё же можно извлечь что-то интересное, например:
warning C4312: 'type cast': conversion from 'int' to 'JABBER\_LIST\_ITEM \*' of greater size
warning C4311: 'type cast': pointer truncation from 'void \*' to 'unsigned long'
warning C4311: 'type cast': pointer truncation from 'CLastValuesView \*const ' to 'DWORD'
warning C4263: 'void CFrameWndEx::WinHelpA(DWORD,UINT)': member function does not override any base class virtual member function
В общем компилятор выдал 10 предупреждений в файле с этими примерами. Только 3 предупреждения из этого списка явно указывают на 64-битные ошибки (предупреждения компилятора С4311 и С4312). Среди этих предупреждений есть и такие, которые указывают на сужающее преобразование типов (С4244) или же на то, что виртуальная функция не будет переопределена (С4263). Эти предупреждения также косвенно указывают на 64-битные ошибки.
В итоге, исключив так или иначе повторяющие друг друга предупреждения, получим 5 предупреждений, касающихся рассматриваемых нами 64-битных ошибок.
Как видим, компилятору Visual Studio не удалось обнаружить все 64-битные ошибки. Напоминаю, что анализатор PVS-Studio в том же файле нашёл 9 ошибок первого уровня.
«А как же статический анализатор, встроенный в Visual Studio 2013?» — спросите вы. Может быть он справился лучше и нашёл больше ошибок? Давайте посмотрим.
### Статический анализатор, входящий в состав Visual Studio 2013
Результатом проверки этих примеров статическим анализатором, встроенным в среду Visual Studio 2013 стали 3 предупреждения:* C6255 Unprotected use of alloca
\_alloca indicates failure by raising a stack overflow exception. Consider using \_malloca instead.
64BitsErrors — test.cpp (Line 58);
* C6384 Pointer size division
Dividing sizeof a pointer by another value.
64BitsErrors — test.cpp (Line 72);
* C28159 Consider using another function instead
Consider using 'GlobalMemoryStatusEx' instead of 'GlobalMemoryStatus'. Reason: Deprecated. See MSDN for details
64BitsErrors — test.cpp (Line 128);
Но мы ведь смотрим 64-битные ошибки, верно? Сколько ошибок из этого списка относится к 64-битным? Только последняя (использование функции, которая может возвращать некорректные результаты).
Выходит, что статический анализатор Visual Studio 2013 нашёл 1 64-битную ошибку против 9, найденных анализатором PVS-Studio. Впечатляет, не правда ли? Представьте, какова будет разница в больших проектах.
А теперь ещё раз хочу напомнить, что по функциональности в плане обнаружения ошибок статические анализаторы кода, встроенные в среды Visual Studio 2013 и Visual Studio 2015 одинаковы (о чём подробнее написано в [соответствующей заметке](http://www.viva64.com/ru/b/0319/)).
Что в итоге?
------------
Нагляднее всего будет отразить результаты проверки примеров кода в виде таблицы.
Как видно из таблицы, с помощью PVS-Studio было обнаружено 9 64-битных ошибок, а общими средствами Microsoft Visual Studio 2013 — 6. Возможно, вы скажите, что не такая уж большая разница. Не соглашусь. Давайте прикинем, почему:* Мы говорили только о наиболее критичных 64-битных ошибках. Даже 3 пропущенные ошибки, это уже много. А если брать более редкие ошибки, для которых анализатор PVS-Studio выдаёт предупреждения 2-ого и 3-его уровня, то он может найти гораздо больше, чем Visual Studio. Некоторое представление об этом может дать [эта статья](http://www.viva64.com/ru/a/0066/). Статья немного устарела, сейчас разрыв будет ещё больше.
* Призывать на помощь компилятор с включённым 4-м уровнем предупреждений не всегда возможно. Но как на четвёртом, так и на третьем уровне предупреждений мы получим всего лишь 2 предупреждения (средствами анализатора и компилятора), связанные с 64-битными ошибками. Не слишком впечатляющий результат.
* Если выставить флаг "/Wall", получаем кучу предупреждений, не имеющих отношения к проекту. На практике воспользоваться "/Wall" будет затруднительно. Можно отдельно включить некоторые предупреждения, но всё равно будет очень много лишнего шума.
Как видно из вышенаписанного, для того, чтобы обнаружить 64-битные ошибки, найденные средствами Microsoft Visual Studio 2013, нужно проделать ещё определённый объём работы. А теперь представьте, насколько он увеличится, будь это реальный, действительно большой проект.
Что с PVS-Studio? Запускаем диагностику, выставляем фильтрацию по 64-битным ошибкам и нужным предупреждениям несколькими кликами мыши, получаем результат.
Заключение
----------
Надеюсь, что мне удалось показать, что перенос приложений на 64-битную архитектуру связан с рядом сложностей. Ошибки, подобные тем, что были описаны в этой статье, достаточно легко допустить, но при этом крайне тяжело найти. Добавим к этому тот факт, что не все подобные ошибки обнаруживаются средствами Microsoft Visual Studio 2013, да и для поиска тех нужно проделать определённый объём работ. В то же время статический анализатор [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) справился с поставленной задачей, показав достойный результат. При этом сам процесс поиска и фильтрации ошибок проще и удобнее. Согласитесь, что в действительно больших проектах без подобного инструмента пришлось бы туго, так что в подобных случаях хороший статический анализатор попросту необходим.
Разрабатываете 64-битное приложение? [Скачайте](http://www.viva64.com/ru/pvs-studio-download/) триал PVS-Studio, проверьте свой проект и посмотрите, сколько 64-битных сообщений первого уровня у вас будет. Если несколько всё же обнаружатся — пожалуйста, исправьте их, и сделайте этот мир чуточку лучше.
Дополнительные материалы
------------------------
Как и обещал, привожу перечень дополнительных материалов по теме 64-битных ошибок:* Терминология. [64-битная ошибка](http://www.viva64.com/ru/t/0002/);
* Андрей Карпов. [Коллекция примеров 64-битных ошибок в реальных программах](http://www.viva64.com/ru/a/0065/).
* Андрей Карпов. [C++11 и 64-битные ошибки](http://www.viva64.com/ru/b/0253/).
* Андрей Карпов, Евгений Рыжков. [Уроки разработки 64-битных приложений на языке Си/Си++](http://www.viva64.com/ru/l/).
Эта статья на английском
------------------------
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Sergey Vasiliev. [64-Bit Code in 2015: New in the Diagnostics of Possible Issues](http://www.viva64.com/en/b/0325/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/258491/ | null | ru | null |
# Передача типа map в функцию
Недавно проскакивала [статья](https://habrahabr.ru/post/325468/) о том, как устроены разные простые типы и слайсы в памяти. Из этой статьи мы узнали, почему переданный «по значению» слайс в функцию является передачей слайса по ссылке только до того момента, пока слайс внутри функции не потребует реаллокацию в памяти при увеличении своего capacity. Если внутри функции capacity этого слайса изменяется, и он был передан «по значению», а не в виде указателя, то слайс начинает ссылаться на совсем другой массив, совсем не тот, который будет дальше использоваться в вызывающей функции.
Такая особенность слайса может порождать «случайные» ошибки логики работы программы на этапе выполнения, если программист не учел это.
У меня возник вопрос, а нет ли похожей ситуации с типом **map**? Ведь у него тоже есть capacity, и он тоже может менять аллокацию в памяти при росте числа пар значений.
И я провел небольшой эксперимент, написав такой код:
```
package main
import (
"fmt"
)
type myMap map[string]string
func main() {
mymap := make(myMap, 1)
mymap["firstKey"] = "firstValue"
fmt.Printf("Init method nop: Address = %p Len = %d\n", &mymap, len(mymap))
mymap.grow()
fmt.Printf("Growed method nop: Address = %p Len = %d\n", &mymap, len(mymap))
mymap = make(myMap, 1)
mymap["firstKey"] = "firstValue"
fmt.Printf("Init method p: Address = %p Len = %d\n", &mymap, len(mymap))
(&mymap).growp()
fmt.Printf("Growed method p: Address = %p Len = %d\n", &mymap, len(mymap))
mymap = make(myMap, 1)
mymap["firstKey"] = "firstValue"
fmt.Printf("Init func nop: Address = %p Len = %d\n", &mymap, len(mymap))
fgrow(mymap)
fmt.Printf("Growed func nop: Address = %p Len = %d\n", &mymap, len(mymap))
mymap = make(myMap, 1)
mymap["firstKey"] = "firstValue"
fmt.Printf("Init func p: Address = %p Len = %d\n", &mymap, len(mymap))
fgrowp(&mymap)
fmt.Printf("Growed func p: Address = %p Len = %d\n", &mymap, len(mymap))
}
func (m myMap) grow() {
for i := 1; i < 1000000; i++ {
m[fmt.Sprintf("nopAddKey%d", i)] = fmt.Sprintf("%d", i)
}
}
func (m *myMap) growp() {
for i := 1; i < 1000000; i++ {
(*m)[fmt.Sprintf("pAddKey%d", i)] = fmt.Sprintf("%d", i)
}
}
func fgrow(m myMap) {
for i := 1; i < 1000000; i++ {
m[fmt.Sprintf("nopAddKey%d", i)] = fmt.Sprintf("%d", i)
}
}
func fgrowp(m *myMap) {
for i := 1; i < 1000000; i++ {
(*m)[fmt.Sprintf("pAddKey%d", i)] = fmt.Sprintf("%d", i)
}
}
```
Здесь я определил два метода и две функции роста мапы, по значению и по указателю. Результатом выполнения я получил такой результат:
> Init method nop: Address = 0xc042054018 Len = 1
>
> Growed method nop: Address = 0xc042054018 Len = 1000000
>
> Init method p: Address = 0xc042054018 Len = 1
>
> Growed method p: Address = 0xc042054018 Len = 1000000
>
> Init func nop: Address = 0xc042054018 Len = 1
>
> Growed func nop: Address = 0xc042054018 Len = 1000000
>
> Init func p: Address = 0xc042054018 Len = 1
>
> Growed func p: Address = 0xc042054018 Len = 1000000
Итак, мы видим, что мапы вызывающей функции меняются и для случая, когда они были переданы по значению, и для случая передачи через указатель. | https://habr.com/ru/post/329254/ | null | ru | null |
# Развертываем инфраструктуру для разработки в облаке InfoboxCloud. Часть 1: Запускаем Gitlab
В этой серии статей мы рассмотрим процесс размещения инфраструктуры для разработки в облаке InfoboxCloud. Для удобного развертывания стека приложений будем использовать Docker.
В первой статье развернем **Gitlab**, включающий в себя:
* **веб-интерфейс** для системы управления исходными текстами git, максимально похожий на GitHub
* удобный **просмотр активностей** пользователей
* **браузер файлов**
* **Wiki**
* возможности проведения **Code Review**
* **баг-трекер**
* возможность создания **сниппетов кода**
* возможность вставки **web hooks**
* **билд-сервер**
и многое другое.
Вы можете создать неограниченное количество бесплатных репозиториев, настраивать политики доступа и безопасности. Если перед Gitlab вы [развернете VPN](https://infoboxcloud.ru/community/blog/iaas/225.html), вы можете не предоставлять публичный ip серверу с Gitlab и работать с ним, подключаясь к внутренней сети облака по VPN из вашей корпоративной сети.
#### **Подготовка окружения**
1. Создайте сервер с CentOS 7 для установки Docker в [InfoboxCloud](http://infoboxcloud.ru). Для работы Docker сейчас необходима именно виртуальная машина, поэтому при создании сервера обязательно установите галочку [«Разрешить управление ядром ОС»](https://infoboxcloud.ru/community/blog/iaas/220.html).
**Как правильно создать сервер в InfoboxCloud для Docker**Если у вас еще нет доступа в InfoboxCloud – [закажите его](http://infoboxcloud.ru).
После регистрации вы получите данные для доступа к панели управления на email. Войдите в панель управления по адресу: <https://panel.infobox.ru>
В разделе «Облачная инфраструктура» вашей подписки нажмите «Новый сервер» (при необходимости подписка меняется в правом верхнем углу в выпадающем меню).
Задайте необходимые параметры сервера. Обязательно выделите серверу 1 публичный IP–адрес и установите галочку **«Разрешить управление ядром ОС»**, как показано на скриншоте ниже.
В списке доступных операционных систем выберите CentOS 7 и завершите создание сервера.
После этого данные для доступа к серверу придут к вам на электронную почту.
После создания сервера с CentOS 7 подключитесь к нему [по SSH](https://infoboxcloud.ru/community/blog/linuxvps/304.html).
Мы подготовили скрипт, который позволит вам установить Docker и полезные утилиты для работы с Docker на такой сервер. Необходимые настройки будут выполнены автоматически.
Выполните команду для установки Docker и Compose:
```
bash <(curl -s http://repository.sandbox.infoboxcloud.ru/scripts/docker/centos7/install.sh)
```
Docker и compose будут установлены.
Можно создать образ с установленным docker в [панели управления](https://panel.infobox.ru), нажав на сервер и далее «Создать образ». После этого из образа с Docker можно будет создавать новые сервера и не выполнять этот шаг повторно.
#### **Системные требования к облачному серверу**
**Для комфортной работы Gitlab рекомендуется 2 ядра CPU и 2Gb Ram от 100 до 500 пользователей.**
Если нужно максимально сэкономить при тестировании — можно серверу с Gitlab выдать 1 ядро CPU 1 ггц, но памяти должно быть не менее 2 гб.
Если нужно работать с большим количеством пользователей:
**CPU**
* 4 ядра CPU – до 2,000 пользователей
* 8 ядер CPU – до 5,000 пользователей
* 16 ядер CPU – до 10,000 пользователей
* 24 ядра CPU – до 15,000 пользователей
**RAM**
* 4GB RAM – до 1,000 пользователей
* 8GB RAM — до 2,000 пользователей
* 16GB RAM — до 4,000 пользователей
* 32GB RAM — до 8,000 пользователей
* 64GB RAM — 16,000 пользователей
Если нужно большее количество пользователей — можно запустить Gitlab [на нескольких серверах](https://about.gitlab.com/high-availability/).
#### **Устанавливаем Gitlab**
Мы уже подготовили файлы для быстрого развертывания Gitlab последней версии. Gitlab будет развернут в Docker-контейнер. Перед этим мы обновим официальный образ с Gitlab: получим все обновления на ОС включая последнюю версию Gitlab (официальный образ обновляется с задержкой, у нас последняя стабильная версия будет раньше).
Установите git командой:
```
yum install -y git
```
Перейдите в директорию пользователя.
```
cd ~
```
Скачайте необходимые файлы для развертывания gitlab.
```
git clone https://github.com/trukhinyuri/gitlab-docker.git
```
Теперь перейдите в директорию с файлами для развертывания.
```
cd ~/gitlab-docker
```
В директории присутствуют следующие файлы и директории:
* **Dockerfile**: описывает действия, которые будут произведены над официальным образом gitlab;
* **docker-compose.yml** описывает как нужно развертывать полученный образ, какие порты пробрасывать, какие папки контейнера монтировать куда на хост;
* папка **config**: в этой папке gitlab будет хранить конфигурационные файлы
* папка **data**: в этой папке gitlab будет хранить файлы данных
* папка **logs**: в этой папке gitlab будет хранить логи логи
В Dockerfile содержится:
```
FROM gitlab/gitlab-ce:latest
MAINTAINER Yuri Trukhin
ENV REFRESHED\_AT 2015.09.27.004
ENV GITLAB\_SHELL\_SSH\_PORT 8005
RUN apt-get update
RUN apt-get -y upgrade
EXPOSE 80
EXPOSE 443
EXPOSE 22
```
Давайте рассмотрим назначение команд подробнее:
* **FROM** указывает из какого образа какой версии будем строить контейнер. В данном случае используем официальный образ Gitlab Community Edition последней версии.
* **ENV** устанавливает переменные окружения. **ENV REFRESHED\_AT 2015.09.27.004** — дата сборки образа. Если необходимо обновить контейнер — меняем дату, перестраиваем образ (как это делать ниже) и разворачиваем его. **ENV GITLAB\_SHELL\_SSH\_PORT 8005** указывает Gitlab, что на хосте SSH будет располагаться на порту 8005 и нужно работать с этим портом (и учитывать это в веб-интерфейсе).
* **RUN** запускает команды внутри контейнера. Обновляем ОС.
* **EXPOSE** показывает какие порты нужно сделать доступными для проброса на хост.
В **docker-compose.yml** содержится:
```
gitlab:
build: .
ports:
- "8004:443"
- "8003:80"
- "8005:22"
volumes:
- ./config:/etc/gitlab
- ./logs:/var/log/gitlab
- ./data:/var/opt/gitlab
restart: always
```
Первой строкой указываем название контейнера, который получится в результате. **build** указывает путь где располагается Dockerfile для сборки образа. В секции **ports** указываем какие порты хоста пробросить на какие порты контейнера. В секции **volumes** указываем какие папки хоста пробросить в контейнер в соответствующие папки. Политика **restart: always** означает, что контейнер будет запускаться автоматически и при загрузке системы и при падении процессов в нем.
Все это мы уже подготовили и вам достаточно сначала собрать образ командой:
```
docker-compose build
```
Затем развернуть контейнер командой:
```
docker-compose up -d
```
Если перед Gitlab вам необходимо поставить балансировщик — пример создания связанных контейнеров с балансировщиком можно увидеть [в этой статье](https://infoboxcloud.ru/community/blog/iaas/320.html). Рекомендуется включить шифрование трафика на стороне балансировщика NGINX для безопасного входа в Gitlab.
*Если вы не знаете, как отредактировать файл — [подробности в этой статье](https://infoboxcloud.ru/community/blog/linuxvps/310.html) в разделе «Как отредактировать текстовый файл». Если вам интересно разобраться с Docker Compose – [подробности тут](https://infoboxcloud.ru/community/blog/iaas/306.html).*
Теперь вы можете войти в gitlab по адресу:
```
http://ip–адрес вашего сервера
```
Gitlab был успешно установлен.
Данные для входа по-умолчанию:
* **логин**: root
* **пароль**: 5iveL!fe
При первом входе будет предложено установить новый пароль для входа.
После смены пароля и входа в Gitlab вы увидите стартовую страницу.
#### **Первоначальная настройка**
Направьте A–запись домена, с которым будет использоваться gitlab, на выделенный ip–адрес хоста в облаке. Выделенный адрес можно посмотреть в [панели управления](https://panel.infobox.ru) в разделе «Облачная инфраструктура».
Основные параметры gitlab следует указать на хосте в файле **~/gitlab/config/gitlab.rb**.
Если строчки с параметрами, которые мы будем указывать, закомментированы (перед параметром установлена #) — # следует убрать. Это нужно сделать только для тех параметров, которые устанавливаем.
Для начала сделайте резервную копию файла конфигурации. Это рекомендуется делать при каждом изменении параметров:
```
cp gitlab.rb gitlab.rb.old
```
##### **Конфигурация параметров в gitlab.rb**
###### **external\_url**
В параметре укажите домен, направленный на сервер, по которому будет доступен Gitlab.
###### **time\_zone**
В этом параметре указывается часовой пояс.
```
gitlab_rails['time_zone'] = 'Europe/Moscow'
```
##### **Настройки почты в gitlab.rb**
В данном разделе указаны работающие параметры в **gitlab.rb** для домена, привязанного к [Яндекс Почте](https://pdd.yandex.ru). Настройки для Gmail и Mailgun [указаны тут](https://gitlab.com/gitlab-org/omnibus-gitlab/blob/master/doc/settings/smtp.md).
Вставьте эти параметры в файл **gitlab.rb**, заменив **git.alm@plugndo.com** на адрес вашей яндекс для домена. Замените **здесь ваш пароль от почты** на ваш пароль от почты. Вместо plugndo.com вставьте имя вашего почтового домена. Остальные настройки оставьте неизменными.
```
gitlab_rails['smtp_enable'] = true
gitlab_rails['smtp_address'] = "smtp.yandex.ru"
gitlab_rails['smtp_port'] = 587
gitlab_rails['smtp_user_name'] = "git.alm@plugndo.com"
gitlab_rails['smtp_password'] = "здесь ваш пароль от почты"
gitlab_rails['smtp_domain'] = "plugndo.com"
gitlab_rails['smtp_authentication'] = "login"
gitlab_rails['smtp_enable_starttls_auto'] = true
#gitlab_rails['smtp_openssl_verify_mode'] = 'peer'
gitlab_rails['gitlab_email_from'] = 'git.alm@plugndo.com'
gitlab_rails['gitlab_email_reply_to'] = 'git.alm@plugndo.com'
```
После сохранения изменений перезагрузите контейнер с gitlab командой:
```
docker restart CONTAINER_ID
```
, где вместо **CONTAINER\_ID** укажите уникальный номер вашего контейнера с gitlab. Его можно посмотреть с помощью команды:
```
docker ps
```
Для проверки корректности настройки почты создайте пользователя в Gitlab, если все сделано правильно — пользователь получит на email ссылку для установки пароля.
#### **Заключение**
После применения инструкций статьи вы получили актуальную версию Gitlab на собственном облачном сервере. Можно приступать к настройке системы для ваших проектов. Благодаря тройной репликации в распределенной отказоустойчивой системе хранения данных в [InfoboxCloud](http://infoboxcloud.ru) вы можете не беспокоиться за сохранность ваших данных.
##### **Как получить пробную версию InfoboxCloud бесплатно?**
[Пришлите нам](mailto:trukhinyuri@infoboxcloud.ru) ваш адрес электронной почты и ФИО на [trukhinyuri@infoboxcloud.com](http://trukhinyuri@infoboxcloud.com), в ответ получите данные для доступа к панели управления. Вы можете тестировать новый регион облака в течение 14 дней, далее можно перейти на полную версию облака.
Если вы нашли ошибку в статье или у вас есть вопросы/замечания, напишите нам в ЛС или [на почту](mailto:trukhinyuri@infoboxcloud.ru). Если вы не можете оставлять комментарии на Хабре, напишите в [Сообществе InfoboxCloud](https://infoboxcloud.ru/community/blog/iaas/329.html).
Продуктивной разработки! | https://habr.com/ru/post/267813/ | null | ru | null |
# Пишем техническую документацию: руководство для непрофессионала
Осенью 2016 года нам с коллегой поручили улучшить документацию и контент в моей бывшей компании. Мы потратили год на все виды документации: справочник по API, руководства, учебные пособия, сообщения в блогах. До этого я 5 лет писала доки, но официально не обучалась этому. Но и неопытной меня нельзя назвать: кроме документирования API для проектов и стартапа, я ещё преподавала Python Flask на семинарах во время учёбы на последних курсах в университете. Но сейчас выпала возможность сосредоточиться только на любимом деле: помогать специалистам всех уровней через техническую документацию.
В этом году я многому научилась в сообществе Write The Docs, у других провайдеров API, а также методом проб и ошибок. В прошлом году я поделилась опытом в докладе «Что мне хотелось бы знать о написании документации» на конференции [API Strategy and Practice](https://events.linuxfoundation.org/events/apistrat-2018/) в Портленде. Эта статья — обзор полученных знаний.
Как люди на самом деле читают документацию?
===========================================
*«Нация содрогается от большого фрагмента слитного текста», фото [The Onion](https://www.theonion.com/nation-shudders-at-large-block-of-uninterrupted-text-1819571366)*
Знаете это чувство, как на картинке? Так бывает. Может и не физически, но, скорее всего, люди содрогаются умственно. Меня постоянно мучала мысль, что люди не будут читать мои тексты, если я не оформлю их легко усваиваемым способом. Чёрт возьми, такое может произойти даже с этой статьёй.
В [исследовании направления взгляда](https://www.nngroup.com/articles/f-shaped-pattern-reading-web-content-discovered/) Neilson Norman Group в 2006 году 232 пользователя просмотрели тысячи веб-страниц. Оказалось, что пользователи обычно смотрят на страницы по F-шаблону:
1. «Сначала читают в **горизонтальном направлении**, как правило, в верхней части области с контентом. Это верхний элемент фигуры F».
2. «Затем немного перемещаются вниз по странице — и совершают **второе горизонтальное** движение, которое обычно охватывает более короткую область, чем предыдущее. Этот дополнительный элемент образует средний элемент фигуры F».
3. «Наконец, пользователи сканируют левую сторону контента **по вертикали**. Иногда это медленное и систематическое сканирование, которое отображается в виде сплошной полосы на теплокарте. Иногда движение более быстрое, образующее пятна на теплокарте. Это последний вертикальный элемент в фигуре F».
*Теплокарты Nielsen Norman Group*
Исследование обнаружило некоторые альтернативные паттерны сканирования, такие как шаблон слоёного торта, пятнистая карта, шаблон разметки, шаблон обхода и целеустремлённый шаблон. Настоятельно рекомендую ознакомиться с [докладом](https://www.nngroup.com/articles/f-shaped-pattern-reading-web-content-discovered/).
Важно отметить, что F-шаблон [мешает пользователям](https://www.nngroup.com/articles/f-shaped-pattern-reading-web-content/), но хорошее позиционирование контента помогает предотвратить F-сканирование.
Каковы конкретные последствия для документации?
===============================================
* В первых двух абзацах следует указать **самую важную информацию**
* **Критически важны** первые 3−5 слов
* Заголовки, абзацы и маркированные списки с информативными словами
* Изменения шрифта (размер, ссылки, выделения жирным и т. д.) могут быть необходимы, чтобы удержать внимание читателя
Так как структурировать контент на странице?
============================================
* Предотвратите сканирование: убедитесь в выделении информации, которая нужна читателю
* Одна мысль на абзац. Если их несколько, разбейте абзац
* Пользователи пропускают всё, что похоже на баннеры, поэтому будьте осторожны с иллюстрациями
* Не расширяйте слишком сильно колонку с текстом: оптимально 65−90 символов
Некоторые из этих советов я узнала из [лекции](https://www.youtube.com/watch?v=sQP_hUNCrcE) Кевина Берка «Как писать документацию для пользователей, которые её не читают». Кевин поддерживал документацию Twilio с 2011 по 2014 годы.
Кроме того, у абзацев есть своя специфика. Подобно слитному тексту *The Onion*, когда вы читаете много абзацев, можно пропустить суть. Тогда зачем использовать их так часто? Давайте проведём эксперимент из документации Keen IO:
**Быстро прочитайте это:**
У наборов событий может быть практически любое название, но есть несколько правил: в названии должно быть не более 64 знаков. Оно должно содержать только символы ASCII. Оно не может быть значением null.
**Теперь быстро прочитайте это:**
У наборов событий может быть практически любое название, но есть несколько правил:
* В названии должно быть не более 64 знаков
* Оно должно содержать только символы ASCII
* Оно не может быть значением null
В обоих примерах **абсолютно** одинаковый текст. Это не бином Ньютона: второй помогает лучше и быстрее усвоить информацию. Если абзац содержит список любого типа, превратите его в маркированный список.
Позже мы подробнее обсудим вёрстку документации и навигацию по ней.
Примеры кода
============
Что такое документация API без кода, верно? Примеры кода есть во многих наших документах, и пользователи *действительно* их читают. Но проблема в том, что они не всегда обращают внимание на окружающий текст.
Контекст в примере кода важен для успеха разработчика. Разработчики любят быстро копировать и вставлять. Вот пример с Keen IO API:
```
var client = new Keen({
projectId: "your_project_id",
writeKey: "your_write_key"
});
var ticketPurchase = {
price: 50.00,
user: {
id: "020939382",
age: 28
},
artist: {
id: "19039",
name: "Tycho"
}
}
client.addEvent("ticket_purchases", ticketPurchase);
```
Разработчик быстро копирует и вставляет этот код. И…
Во-первых, как они вообще запускают файл? Вероятно, как `node file_name.js`, но этого нет в коде. Можно было бы указать в комментарии вверху.
Хорошо, они запустили его и… `ReferenceError: Keen is not defined`. :-( Клиент Keen не инициировался, в верхней части нет оператора import или require, и он работает только после установки библиотеки npm.
Пользователь всё починил и запустил ещё раз… Угадайте?! Ещё одна ошибка! `your_project_id` и `your_write_key` отсутствуют.
Всё это можно было бы сделать более очевидным.
Вот пример из документации Twilio, которая предоставляет хороший контекст для конечного пользователя:
*Скриншот из документации библиотеки [Twilio Node Helper](https://www.twilio.com/docs/libraries/node)*
Это сразу проясняет, как установить библиотеку, внедрить её в свой код и что нужно заменить в образце кода перед его запуском.
Копипаст багов
==============
Поскольку у нас в документации много примеров кода, успешный копипаст — довольно важное свойство. Вот два примера того, где это не соблюдается:
```
# Скопируйте и вставьте следующую команду
$ gem install rails
```
Кажется довольно безобидным, верно? Подумайте ещё раз, что происходит, когда вы копируете и вставляете это в командную строку? Вы, скорее всего, получите:
```
bash: command not found: $
```
Распространённая ошибка. Либо вы хотите, чтобы команда выглядела как в командной строке, либо вы случайно её скопируете. Я бы рекомендовала отказаться от `$`. Ещё можно найти способ запретить копипаст этого символа, чтобы ошибка не раздражала пользователей.
Более свежий пример: вы проверяли, насколько легко выделить код, который пользователь хочет скопировать?
Келси Хайтауэр изо всех сил пытался скопировать образец кода из StackOverflow на презентации Google Cloud Next.
> In a LIVE DEMO, watch [@kelseyhightower](https://twitter.com/kelseyhightower?ref_src=twsrc%5Etfw) build a weather application from zero. Starting from the database up to the end point: <https://t.co/XAKsOYSHZq> [pic.twitter.com/1iuHGlVRnR](https://t.co/1iuHGlVRnR)
>
> — Google Cloud Platform (@GCPcloud) [July 26, 2018](https://twitter.com/GCPcloud/status/1022591825096335360?ref_src=twsrc%5Etfw)
*«Хорошие программисты копируют, великие программисты вставляют»*
Он сделал это намеренно? Мы никогда этого не узнаем. Тем не менее, это иллюстрация, как программисты пытаются выделить большие блоки текста на некоторых сайтах документации. Убедитесь, что пользовательский интерфейс сайта позволяет легко копировать большие блоки. Можно даже разбить эти блоки, чтобы объяснить фрагменты по отдельности. Так они станут доступнее для копирования и понимания.
«Вот и всё!»
============
> "That's all!" [pic.twitter.com/zKtabSPJ1z](https://t.co/zKtabSPJ1z)
>
> — Tracy Chou (@triketora) [July 26, 2017](https://twitter.com/triketora/status/890179098680668160?ref_src=twsrc%5Etfw)
«Вот и всё!» Фраза кажется довольно безобидной вне контекста, но представьте, как воспринимаются определённые слова вроде «легко», «просто», «тривиально» и «несложно», когда у вас проблемы — не здорово! Когда человек застрял, пытаясь заставить API работать, такая фраза подвергает сомнению его интеллект и заставляет задать вопрос: «Значит, я глупый?» Это деморализует.
### Чрезмерное упрощение
Упрощение встречается повсеместно. Оно наиболее распространено среди новичков в написании документации. Зачастую авторы документации — одновременно и разработчики системы, поэтому некоторые вещи им кажутся «лёгкими». Но ведь они разработали эту функцию, написали для неё код, проверили много, много раз, а потом написали документацию. Когда вы делаете что-то десятки раз, то ясное дело, что это будет «легко» для вас. Но как насчёт того, кто никогда раньше не видел UI или функцию?
### Сопереживание
Выбор слов *действительно* имеет значение. Эмпатия — это способность понимать и разделять чувства других. Когда мы проявляем эмпатию, то помогаем не только новичкам, но и более продвинутым пользователям. Это помогает увеличить потенциальное количество пользователей, вариантов использования, клиентов и даже доход компании.
Но когда документацию пишет эксперт-разработчик проекта, проявить эмпатию сложнее. Вот несколько полезных советов, которые помогли мне в прошлом:
* Попросите менее опытных участников проекта честно прокомментировать документацию
* Поощряйте менее опытных участников проекта вносить свой вклад или указывать на пункты документации, которые они не понимают
* Создайте окружение, где поощряются вопросы, в том числе такие, какие могут показаться «очевидными» для опытных участников проекта — это поможет заметить «слепые зоны»
* В процессах код-ревью и CI используйте линтеры, чтобы гарантировать эмпатию и дружественность языка для **всех** пользователей
* Наконец, попросите прокомментировать документацию реальных пользователей, покажите им текст и спросите, всё ли понятно
Сообщения об ошибках как вид документации
=========================================
Обычно пользователи чаще видят сообщения об ошибках, чем документацию. Как говорит Кейт Восс, «сообщения об ошибках на самом деле представляют собой возможность». Я считаю, что многие разработчики документации упускают эту возможность. Здесь есть место для обучения, установления доверительных отношений и ожиданий пользователей. Прежде всего, вы поможете людям помочь самим себе.
[Кейт на сайте Write The Docs](http://www.writethedocs.org/videos/na/2017/error-messages-being-humble-human-and-helpful-will-make-users-happy-kate-voss/) рассказывает много полезного о написании сообщений об ошибках. Многое я узнала во время прошлой работы над сообщениями об ошибках API, а также будучи на другой стороне баррикад, получая сообщения об ошибках других API в качестве разработчика.
Кейт говорит, что хорошие сообщения об ошибках построены на трёх принципах:
* Скромность
* Гуманность
* Полезность
### Скромность
Сразу нужно извиниться, даже если это не ваша вина. Это я практикую также в службе поддержки.
Пример:
> Извините, не удалось подключиться к \_\_\_. Пожалуйста, проверьте сетевые настройки, подключитесь к доступной сети и повторите попытку.
### Гуманность
Используйте понятные человеку термины, избегайте фраз типа «исключение выброшено целевым объектом вызова». При написании кода, для которого вызывается много сообщений об ошибках, легко сбиться с понятной лексики.
Пример (ошибка кода состояния 401 у Twilio):
```
{
“code”: 20003,
“detail”: “Your AccountSid or AuthToken was incorrect.”,
“message”: “Authenticate”,
“more_info”: “https://www.twilio.com/docs/errors/20003",
“status”: 401
}
```
### Полезность
Если вы запомните что-то из этих советов, запомните о полезности. Поделитесь с пользователем информацией, как устранить проблему.
Пример:
> Извините, изображение, которое вы пытались загрузить, слишком большое. Попробуйте снова с изображения меньше, чем 4000px по высоте и 4000px по ширине.
### Как писать сообщения об ошибках
Как и в любой другой документации, сначала укажите важную информацию. Это можно сделать, указав сначала объект, затем действие. Пользователь ищет результат, а не как туда добраться. Это полезно, когда пользователи быстро сканируют сообщения об ошибках.
Плохой пример:
> Нажмите кнопку «назад», чтобы вернуться на предыдущую страницу.
Хороший пример:
> Чтобы вернуться на предыдущую страницу, используйте кнопку «назад».
### Сообщения об ошибках в документации
Я считаю *очень* полезным, когда общие сообщения об ошибках API упоминаются в документации. Так автор документации может разъяснить сообщение об ошибке, не увеличивая документацию, в то же время помогая пользователю понять, почему возникает ошибка.
Twilio публикует полный каталог ошибок и предупреждений с возможными причинами и решениями. Используя этот метод, вы можете сделать фактические сообщения об ошибках короче, но по-прежнему полезными.
В случае ошибки 20003 (ошибка кода состояния 401, упомянутая ранее), есть много возможных причин, которые чётко изложены в каталоге.
*Источник: <https://www.twilio.com/docs/api/errors>*
Stripe делает нечто подобное с детальным описанием различных кодов ошибок.
*Источник: <https://www.twilio.com/docs/api/errors>*
Вы даже можете найти свои сообщения об ошибках в вопросах StackOverflow. Ответьте на них скромно, по-человечески и с пользой. Из-за SEO пользователи часто попадают с вашими сообщениями об ошибках на StackOverflow, а не в реальную документацию.
> Подсказка: если кто-то не ответил скромно, по-человечески и с пользой, то с достаточной «репутацией» можно редактировать ответы StackOverflow.
Выбор слов
==========
У многих слов есть устоявшиеся ментальные модели. Например, такие слова, как «библиотеки», SDK, «обёртки» и «клиенты» уже перегружены и проходят мимо внимания читателя.
В своей лекции [«Даже для этой лекции трудно подобрать название»](http://www.writethedocs.org/videos/na/2017/even-naming-this-talk-is-hard-ruthie-bendor/) на Write The Docs Рути Бендор говорит, почему выбор правильных слов может быть таким трудным.
Мы часто плохо выбираем слова, хотя при написании текста делаем это постоянно. Как и многие названия SDK, каждое слово вызывает у читателя широкий спектр чувств, идей и определений. Вы можете не понимать этого — и часто мы делаем неправильные предположения.
В такой ситуации как никогда справедлива известная поговорка: «Есть только две трудные задачи в области информатики: инвалидация кеша и придумывание названий». Цитату часто приписывают Филу Карлтону, но сегодня ходит много вариантов этой поговорки. Иногда в конце добавляют «… и ошибка на единицу». Рути считает это демонстрацией, что программное обеспечение в наши дни во многом основано на чужом коде или работе.
### Почему же сохраняются плохие названия объектов (или документация)?
Как и с чрезмерным упрощением, мы часто не понимаем, что название плохое. Это то, что Рути называет **сбоем эмпатии**. Это как сказать, что проблема неудачных слов меня не касается, поэтому её не существует.
> Подсказка для США: во избежание случайного расизма используйте слова «запрещённый список» и «разрешённый список» вместо «чёрный» и «белый».
>
> (Источники: [Андре Штальц](https://twitter.com/andrestaltz/status/1030200563802230786) и [rails/rails/issues/33677](https://github.com/rails/rails/issues/33677))
Мне это ещё напоминает то, что Рути называет **ошибкой мышления новичка**. Это как сказать «Мне это совершенно ясно. Не понимаю, как кто-то не может этого понять».
Наконец, Рути упоминает **ошибку локализации**. Например, слово Bing по-китайски означает «больной».
Согласно [исследованию GitHub Open Source Survey за 2017 год](http://opensourcesurvey.org/2017/):
> Почти 25% разработчиков читают и пишут по-английски не «очень хорошо». При общении в проекте используйте понятный и доступный язык для людей из неанглоязычных стран.
Вы это учитываете, когда используете американизмы и идиомы в документации? Многие из них могут быть непонятны для пользователей.
> Подсказка: я твёрдо верю, что один из величайших «трюков» для решения этих проблем — разнообразие команды, работающей над документацией.
Есть ещё случаи, когда мы признаём ошибку, но не можем или не хотим её исправлять, потому что мы…
* Привязаны к ней
* Не находим времени
* Не видим важности
* У нас нет агентства, чтобы её исправить
Вы можете сказать или услышать: «Но это моё детище!», «Кто убрал мою конфетку?» «Если мы переименуем, всё сломается», «Не верю, что изменение этого названия повлияет на что-то важное».
Нельзя бояться рефакторинга и переписывания, когда речь идёт о документации. Как же её улучшить, если не соглашаться с тем, что изначально сделан не лучший выбор?
### Как правильно подобрать слова?
Для начала рекомендую задать вопрос: какие слова используют ваши пользователи? В разных программистских кругах в ходу разные термины, не пытайтесь использовать другие. Это полезно не только для читателей, но также для поиска и SEO.
В конце концов, всё неизбежно сводится к субъективной оценке. Однако есть несколько принципов, которые стоит учесть. Рути говорит, что плохие названия — это те, что могут:
* смутить
* огорчить
* ввести в заблуждение
* запутать
* оскорбить
С другой стороны, хорошие названия:
* способствуют внезапному прояснению («вот оно что!»)
* вводят в контекст
* объясняют
* освещают
* оказывают поддержку
Рекомендую учитывать эти качества при вычитке документации, чтобы составить полезные и честные отзывы о ней.
Подбирать верные слова трудно. Волшебной формулы не существует. Все пользователи отличаются, как и варианты использования продукта; что работает для одних, может не работать для других. Если бы это было легко, у всех была бы намного лучшая документация. Как говорит Рути разработчикам: «Написание программ — это упражнение в придумывании названий. Смиритесь с этим». И если вы пишете документацию для чужой программы, «сообщите разработчику, если его названия не попадают в цель». | https://habr.com/ru/post/421549/ | null | ru | null |
# Как понять и подружиться с транзакциями и JPA
Наверное, все знают о транзакциях в реляционных базах данных, все слышали про ACID. Но тем не менее есть разница между знать и прочувствовать, сам с этим столкнулся, когда пришлось переквалифицироваться в бэкэнд разработчика. Думаю, в тот момент подобная статья здорово бы мне помогла, надеюсь она окажется полезна и вам.
При разработке энтерпрайз приложений зачастую с базами данных взаимодействуют посредством ORM технологии, в мире джавы наиболее известна технология JPA (Java Persistence API) и её реализации — Hibernate и EclipseLink. JPA позволяет взаимодействовать с базой данных в терминах объектов предметной области, предоставляет кэш, репликацию кэша при наличии кластера в middle tier-е.
Как это обычно происходит:
1. На бэкэнд приходит REST запрос обновить документ, в теле запроса — новое состояние.
2. Начинаем транзакцию.
3. Бэкэнд запрашивает существующее состояние документа у EntityManager-а, который может вычитать его из базы, а может достать из кэша.
4. Далее мы берём объект прибывший в теле запроса смотрим на него, сравниваем с состоянием объекта представляющего запись в базе данных.
5. На основе этого сравнения вносим необходимые изменения.
6. Коммитим транзакцию.
7. Возвращаем ответ клиенту.
Где здесь порылась собака? Смотрите, мы взяли данные, скорее всего из кэша, возможно уже протухшие, возможно сервер прямо сейчас обрабатывает конкурентный запрос на изменение того же документа, и данные протухают ровно в момент когда мы делаем все эти сравнения. На основе этих данных сомнительной достоверности и тела REST запроса мы принимаем решения о внесении изменений в базу и коммитим их. Тут встаёт вопрос, что за лажу мы только что записали в базу данных?
Здесь нам и помогут транзакции. Ключ к их пониманию — это при каких условиях транзакция не пройдёт, или, иначе говоря, когда случится её откат. А откат транзакции случится если вносимые изменения нарушат констрейнты базы данных. Наиболее важные из них:
* Нарушение констрейнтов уникальности.
* Нарушение ссылочной целостности.
И так, если наша транзакция прошла, то «лажа», которую мы закоммитили чуть выше, удовлетворяет констрейнтам. Осталось настроить констрейнты так, чтобы удовлетворяющие им данные представляли собой валидные бизнес-сущности.
Вот максимально примитивный и искусственный пример:
```
@Entity
public class Document {
@Id
private String name;
@Lob
private String content;
// getters and setters пропущены
}
```
```
@ApplicationScoped
@Transactional // транзакции начнаются перед вызовом безнес-метода и завершаются по его окончанию
public class DocumentService {
@PersistenceContext
private EntityManager entityManager;
public void createDocument(String name, String content) {
// скорее всего никакого запроса к базе данных здесь не будет,
// с большой долей вероятности мы получим закэшированный объект
Document documentEntity = entityManager.find(Document.class, name);
if (documentEntity != null) {
throw new WebApplicationException(Response.Status.CONFLICT); // конфликт имен!
}
// возможно прямо сейчас другой тред конкурентно создает документ с таким же именем
documentEntity = new Document();
documentEntity.setName(name);
documentEntity.setContent(content);
entityManager.persist(documentEntity);
}
}
```
Здесь в случае кункурентного создания документа с тем же именем или если данные полученные из каша оказались устаревшими, в момент коммита случится ConstraintViolationException и бэкэнд вернет клиенту 500 ошибку. Пользователь повторит операцию чуть позже и получит вразумительное сообщение об ошибке или таки создаст документ.
На самом деле, 500 ошибки не очень желательны, фокус в том, что они почти никогда не будут случаться, ну а если специфика использования вашего приложения такова, что они случаются слишком часто, вот тогда стоит подумать о чём-нибудь более изощренном.
Попробуем что-нибудь посложнее. Допустим мы хотим иметь возможность защитить документ от удаления. Заводим новую таблицу:
```
@Entity
public class DocumentLock {
@Id
@GeneratedValue
private Long id;
@OneToOne
private Document document;
@Basic
private String lockedBy;
// getters, setters
}
```
И добавляем в класс Document:
```
@OneToOne(mappedBy = "document")
private DocumentLock lock;
```
Теперь чтобы защитить документ от удаления достаточно создать DocumentLock ссылающийся на документ. Логика удаляющая документ:
```
public void deleteDocument(String name) {
Document documentEntity = entityManager.find(Document.class, name);
if (documentEntity == null) {
throw new NotFoundException();
}
DocumentLock lock = documentEntity.getLock();
if (lock != null) {
throw new WebApplicationException(
"Document is locked by " + lock.getLockedBy(),
Response.Status.BAD_REQUEST);
}
entityManager.remove(documentEntity);
}
```
Смотрите, мы проверили, что лока нет, но использовали для это закэшированные данные возможно уже устаревшие, а возможно устаревающие прямо во время проверки. В этом случае наш код удаляя документ попытается нарушить ссылочную целостность данных и значит наша транзакция не пройдёт. Пара замечаний:
1. Убедитесь, что каскадное удаление отключено, в случае каскадных удалений, удаление документа приведет к удалению всех записей, которые на него ссылаются. Т.е. наличие записи о бизнес-локе ничему не помешает.
2. На самом деле код выше позволяет повесить несколько локов на один документ, т.е. требуется настроить ещё констрейнт уникальности.
3. Пример сугубо синтетический, скорее всего имеет смысл поместить данные о владельце бизнес-лока прямо в документ, а не заводить отдельную таблицу. И затем использовать явный пессимистичный лок для проверки отсутствия этого бизнес-лока при удалении документа.
В реальных задачах ссылочная целостность здорово помогает при хранении иерархически организованных данных: штат организации, структура каталогов и файлов. В этом случае, например, если мы удаляем начальника и конкурентно в параллельной транзакции назначаем ему подчиненного, ссылочная целостность гарантирует, что успешно завершится только одна из этих операций и структура организации останется валидной (у каждого сотрудника кроме директора есть начальник). При этом на момент начала обеих операций каждая из них выглядела осуществимой.
Подводя итоги: даже используя устаревшие и сомнительные данные (что вполне может иметь место при работе с БД посредством JPA) при принятии решения о внесении изменений в базу данных, и даже если конкурентно вносятся конфликтующие изменения, механизм транзакций не позволит нам сделать ничего, что нарушит ссылочную целостность либо не будет соответствовать наложенным констрейнтам, все действия объединённые данной транзакцией и приводящие к данному плачевному итогу будут отменены в соответствии с принципом атомарности. Просто имейте это ввиду моделируя данные и аккуратно расставляйте констрейнты. | https://habr.com/ru/post/325470/ | null | ru | null |
# Учебный проект на Python: алгоритм Дейкстры, OpenCV и UI ( часть 1)
Лабиринты — это распространенная головоломка для людей, но они представляют из себя интересную задачу для программирования, которую мы можем решить, используя методы кратчайшего пути, такие как алгоритм Дейкстры.
### Вспоминаем алгоритм Дейкстры
Алгоритм Дейкстры — один из наиболее популярных алгоритмов теории графов. Он используется для поиска кратчайшего пути между узлами на ориентированном графе. Мы начнем с исходного узла и известных длин ребер между узлами.
Сначала мы присваиваем значение расстояния от источника всем узлам. Узел s получает значение 0, потому что это источник; остальные получают значения ∞ для начала.
Наш интересующий узел — это необработанный узел с наименьшим значением (показан серым), то есть s. Сначала мы «ослабляем» каждую смежную вершину до нашего интересующего узла, обновляя их значения до минимума их текущего значения или значения узла интереса плюс длину соединительного ребра…
Узел s теперь завершен (черный), а его соседи a и b приняли новые значения. Новый интересующий узел — b, поэтому мы повторяем процесс «ослабления» соседних узлов b и финализации значения кратчайшего пути для b.
Пройдя через каждый узел, мы в итоге получим график, показывающий кратчайшую длину пути от источника до каждого узла.
*Наша финальная диаграмма после запуска алгоритма Дейкстры. Числа в каждом узле представляют кратчайшее возможное расстояние от исходного узла.*
### Концептуализация изображений лабиринта
Мы можем представить себе изображение как матрицу пикселей. Каждый пиксель (для простоты) имеет значение RGB 0,0,0 (черный) или 255,255,255 (белый). Наша цель — создать кратчайший путь, который начинается на белом и не переходит на чёрные границы. Чтобы представить эту цель, мы можем рассматривать каждый пиксель как узел и рисовать ребра между соседними пикселями с длиной ребер, основанной на разнице значений RGB. Мы будем использовать формулу евклидова квадратного расстояния и добавим 0,1, чтобы гарантировать отсутствие длины пути 0 — (требование для алгоритма Дейкстры):
Эта формула делает расстояние пересечения через границу лабиринта чрезмерно большим. Как мы видим, кратчайший путь от источника к месту назначения будет четко проходить вокруг барьера, а не через него.
### Реализация
Мы можем использовать OpenCV, популярную библиотеку компьютерного зрения для Python, чтобы извлечь значения пикселей и показать наши изображения лабиринта. Давайте также определим координаты нашего начального и конечного местоположений, добавив точки в наш лабиринт
```
import cv2
import matplotlib.pyplot as plt
import numpy as np
img = cv2.imread('maze.png') # read an image from a file using
cv2.circle(img,(5,220), 3, (255,0,0), -1) # add a circle at (5, 220)
cv2.circle(img, (25,5), 3, (0,0,255), -1) # add a circle at (5,5)
plt.figure(figsize=(7,7))
plt.imshow(img) # show the image
plt.show()
```
Мы создаем класс Vertex, который поможет нам отслеживать координаты. Мы также хотим отслеживать родительский узел, чтобы мы могли восстановить весь путь, как только найдем значения расстояния.
```
class Vertex:
def __init__(self,x_coord,y_coord):
self.x=x_coord
self.y=y_coord
self.d=float('inf') #current distance from source node
self.parent_x=None
self.parent_y=None
self.processed=False
self.index_in_queue=None
```
Нам нужно создать матрицу вершин, представляющую двухмерное расположение пикселей на изображении. Это будет основой для алгоритма Дейкстры. Мы также поддерживаем очередь с минимальной кучей приоритетов для отслеживания необработанных узлов.
```
def find_shortest_path(img,src,dst):
pq=[] #min-heap priority queue
imagerows,imagecols=img.shape[0],img.shape[1]
matrix = np.full((imagerows, imagecols), None)
#access matrix elements by matrix[row][col]
#fill matrix with vertices
for r in range(imagerows):
for c in range(imagecols):
matrix[r][c]=Vertex(c,r)
matrix[r][c].index_in_queue=len(pq)
pq.append(matrix[r][c])
#set source distance value to 0
matrix[source_y][source_x].d=0
#maintain min-heap invariant (minimum d Vertex at list index 0)
pq = bubble_up(pq, matrix[source_y][source_x].index_in_queue)
```
Нам нужно несколько вспомогательных функций, чтобы помочь найти ребра и длину ребер между вершинами:
```
#Implement euclidean squared distance formula
def get_distance(img,u,v):
return 0.1 + (float(img[v][0])-float(img[u][0]))**2+(float(img[v][1])-float(img[u][1]))**2+(float(img[v][2])-float(img[u][2]))**2
#Return neighbor directly above, below, right, and left
def get_neighbors(mat,r,c):
shape=mat.shape
neighbors=[]
#ensure neighbors are within image boundaries
if r > 0 and not mat[r-1][c].processed:
neighbors.append(mat[r-1][c])
if r < shape[0] - 1 and not mat[r+1][c].processed:
neighbors.append(mat[r+1][c])
if c > 0 and not mat[r][c-1].processed:
neighbors.append(mat[r][c-1])
if c < shape[1] - 1 and not mat[r][c+1].processed:
neighbors.append(mat[r][c+1])
return neighbors
```
Теперь мы можем реализовать алгоритм Дейкстры и присвоить значения расстояния (d) всем вершинам пикселей в изображении лабиринта:
```
while len(pq) > 0:
u=pq[0] #smallest-value unprocessed node
#remove node of interest from the queue
pq[0]=pq[-1]
pq[0].index_in_queue=0
pq.pop()
pq=bubble_down(pq,0) #min-heap function, see source code
u.processed=True
neighbors = get_neighbors(matrix,u.y,u.x)
for v in neighbors:
dist=get_distance(img,(u.y,u.x),(v.y,v.x))
if u.d + dist < v.d:
v.d = u.d+dist
v.parent_x=u.x #keep track of the shortest path
v.parent_y=u.y
idx=v.index_in_queue
pq=bubble_down(pq,idx)
pq=bubble_up(pq,idx)
```
Теперь мы можем вызвать функцию кратчайшего пути и нарисовать решение в нашем лабиринте:
```
img = cv2.imread('maze.png') # read an image from a file using opencv (cv2) library
p = find_shortest_path(img, (25,5), (5,220))
drawPath(img,p)
plt.figure(figsize=(7,7))
plt.imshow(img) # show the image on the screen
plt.show()
```
Давайте попробуем другие лабиринты со всего Интернета.
Полный исходный код доступен на GitHub [здесь](https://github.com/maxwellreynolds/Maze).
Продолжение: [Учебный проект на Python: интерфейс в 40 строк кода (часть 2)](https://habr.com/ru/company/skillfactory/blog/509340/)
Узнайте подробности, как получить востребованную профессию с нуля или Level Up по навыкам и зарплате, пройдя платные онлайн-курсы SkillFactory:
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=ML&utm_term=regular&utm_content=02072002) (12 недель)
* [Обучение профессии Data Science с нуля](https://skillfactory.ru/data-scientist?utm_source=infopartners&utm_medium=habr&utm_campaign=DST&utm_term=regular&utm_content=02072002) (12 месяцев)
* [Профессия аналитика с любым стартовым уровнем](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=SDA&utm_term=regular&utm_content=02072002) (9 месяцев)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=PWS&utm_term=regular&utm_content=02072002) (9 месяцев)
### Читать еще
* [Тренды в Data Scienсe 2020](https://habr.com/ru/company/skillfactory/blog/508450/)
* [Data Science умерла. Да здравствует Business Science](https://habr.com/ru/company/skillfactory/blog/508556/)
* [Крутые Data Scientist не тратят время на статистику](https://habr.com/ru/company/skillfactory/blog/507052/)
* [Как стать Data Scientist без онлайн-курсов](https://habr.com/ru/company/skillfactory/blog/507024/)
* [Шпаргалка по сортировке для Data Science](https://habr.com/ru/company/skillfactory/blog/506888/)
* [Data Science для гуманитариев: что такое «data»](https://habr.com/ru/company/skillfactory/blog/506798/)
* [Data Scienсe на стероидах: знакомство с Decision Intelligence](https://habr.com/ru/company/skillfactory/blog/506790/) | https://habr.com/ru/post/509304/ | null | ru | null |
# Моделирование пуассоновского процесса
#### Введение
Одним из важнейших процессов, наблюдаемых в природе, является пуассоновский точечный процесс. Поэтому важно понять, как такие процессы можно моделировать. Методы моделирования различаются в зависимости от типа пуассоновского точечного процесса, т. е. пространства, в котором протекает процесс и однородности или неоднородности процесса. Мы не будем заинтересованы развитием пуассоновского точечного потока или с важными приложениями его в различных областях. Чтобы этот материал показался интересным, читателю настоятельно рекомендуется прочитать соответствующие разделы в Феллере (1965) и Синларе (1975) для основной теории и некоторые разделы в Триведи (1982) для приложений в ИТ.
На первом шаге мы определим пуассоновский процесс на [0;+∞). Процесс полностью определяется семейством случайных событий, которые происходят в определённые случайные моменты времени 0 < T1 < T2 <… Эти события могут относиться ко множеству вещей, таких как ограбление банков, рождению пяти близнецов, и аварии с участием такси Монреаля. Если N(t1,t2) — это количество событий, происшедших за временной интервал (t1,t2), то часто выполнены два следующих условия:
* Для непересекающихся интервалов (t1,t2) и (t3,t4) случайные величины N(t1,t2) и N(t3,t4) независимы
* N(t1,t2) распределено также как и N(0,t2-t1), т. е. распределение числа событий за определённое время зависит только от длины этого интервала.
Удивительным фактом является то, что эти два условия влекут за собой, что все случайные величины N(t1,t2) распределены по закону Пуассона и что существует такая неотрицательная константа λ, что N(t,t+a) распределено по закону Po(λa) для любых неотрицательных t и a>0. См., например, Феллер (1965). Таким образом, пуассоновское распределение происходит вполне естественно.
Предыдущее понятие может быть обобщено на Rd. Пусть A — некоторое подмножество Rd, а N — случайная величина, принимающая только целые значения. Пусть X1,...XN — набор случайных векторов, принимающих значение в A. Тогда мы говорим, что Xi задают равномерный или однородный пуассоновский процесс на А, если
* Для любого конечного набора попарно неперескающихся подмножеств множества A Аi конечного объёма события N(A1),...,N(Ak независимы
* Для любого борелевского подмножества B множества A распределение N(B) зависит только от объёма множества B
*Примечание переводчика: Лучше было бы употребить слово «мера», но тем, кто не увлекается математикой, тогда пришлось бы объяснять с десяток страниц, а то и больше.*
Опять же эти предположения влекут за собой, что все N(B) распределены по закону P(λVol(B)) для некоторого неотрицательного λ, котороый мы назовём интенсивностью, или параметром интенсивности однородного пуассоновского процесса на А. Примеры таких процессов в многомерном Евклидовом пространстве включают в себя бактерии на чашке Петри и места убийств в Хьюстоне.
#### Моделирование однородных пуассоновских процессов
Если нам необходимо смоделировать равномерный пуассоновский процесс на множестве A, принадлежащем Rd, то нам необходимо сгенерировать некоторое число случайных векторов Xi из A. По теореме 1.1 это можно сделать следующим образом:
`Сгенерировать пуассоновскую случайную величину N с параметром λVol(A)`
`Сгенерировать независимые случайные вектора X1,..,XN, равномерно распределённые на А`
`RETURN Х1,...,ХN`
Чтобы сгенерировать величину N, бесполезно использовать алгоритм со средней сложностью О(1), поскольку в конце алгоритма, мы потратим, как минимум Ω(n) операций. Поэтому, если используется этот алгоритм, настоятельно рекомендуется генерировать пуассоновскую случайную величину очень простым алгоритмом (со средним временем, растущим как О(λ) ). Для определённых множеств А, можно использовать другие методы, которые не требуют явной генерации пуассоновской случайной величины. Существует три случая, которые мы используем, чтобы это проиллюстрировать.
1. A=[0;+∞)
2. A — окружность
3. A — прямоугольник
Чтобы это сделать, нам понадобится интересная связь между Пуассоновским процессом и экспоненциальным распределением.
Теорема 1.2 предлагает следующий метод моделирования равномерного пуассоновского процесса на A=[0;+∞)
`T = 0 (вспомогательная переменная для обновления "времени")`
`k = 0 (инициализировать счётчик событий)`
`REPEAT`
`Сгенерировать экспоненциальную случайную величину Е`
`k = k + 1`
`T = T + E/λ`
`T[k] = T`
`UNTIL Ложь (это бесконечный цикл; по желанию можно добавить критерий остановки)`
Этот алгоритм просто реализовать, поскольку нет нужды генерировать пуассоновские случайные величины. Для других простых множеств A, существуют тривиальные обобщения теоремы 1.2. Например, когда A=[0,t]x[0,1], где t может равняться бесконечности, 0 < T1 < T2 <… — равномерный пуассоновский процесс с интенсивностью λ и U1,U2,… — последовательность независимых одинаково распределённых равномерно на [0,1] случайных величин, то (T1,U1),(T2,U2),… определяют пуассоновский процесс с интенсивностью λ на А.
##### Пример 1.1.
Равномерный пуассоновский процесс на единичной окружности
Если A — окружность с единичным радиусом, то разные свойства равномерного пуассоновского процесса можно использовать, чтобы получить несколько методов генерации (которые обобщаются на d-мерные сферы). Пусть λ — желаемая интенсивность.
Во-первых, мы просто могли бы сгенерировать случайную пуассоновскую величину N с параметром λπ, а затем вернуть последовательность N независимых одинаково распределённых равномерно на единично окружности векторов. Если мы применим метод порядковых статистик, предлагаемый теоремой 1.2, то пуассоновская случайная величина получается неявно. Например, перейдя в полярные координаты (R,φ) заметим, что для равномерного пуассоновского процесса R и φ независимы, и случайная величина R имеет плотность 2r, r меняется от 0 до 1, а φ равномерно распределена на [0;2π]. Таким образом, мы можем поступить следующим образом: Сгенерировать равномерный пуассоновский процесс 0 < φ1 < φ2 <… < φN с параметром интенсивности λ/(2π) на [0;2π] экспоненциальным методом и вернуть (φ1,R1),...,(φN,RN), где Ri — независимые одинаково распределённые случайные величины с плотностью 2r на [0;1], которые можно сгенерировать, взяв максимум из двух независимых равномерно распределённых на [0;1] случайных величин. Особой причины применять эспоненциальный метод к углам нет. Таким же образом мы могли подобрать и радиусы. К сожалению, порядковые радиусы не формируют одномерный равномерный пуассоновский процесс на [0;1]. Однако, тем не менее они образуют неоднородный пуассоновский процесс, и генерация таких процессов будет рассмотрена в следующем разделе.
#### Неоднородные пуассоновские процессы
Бывают такие ситуации, когда события происходят в «случайные моменты времени», но некоторые моменты более возможны, чем другие. Это случай прибытий в центры интенсивной терапии, предложений работ в компьютерных центрах и травмы игроков НХЛ. Для этих случаев очень хорошей моделью является модель неоднородного пуассоновского процесса, определённого здесь ради удобства на [0;+∞). Это самый важный случай, поскольку время чаще всего является «бегущей переменной».
Неоднородный пуассоновский процесс на [0;+∞) определяется неотрицательно определённой функцией интенсивности Λ(t), которую можно рассматривать как некоторого рода плотность с тем отличием, что её интеграл по [0;+∞) не обязательно равен 1(обычно, он расходится). Процесс определяется следующим свойством: для любой конечной коллекции непересекающихся интервалов A1,A2,...,Ak количество событий, происходящих в этих интервалах (N1,...,Nk) — независимые пуассоновские случайные величины с параметрами 
Теперь рассмотрим, как такие процессы можно смоделировать. При моделировании мы понимаем, что моменты времени, когда события происходят, 0 < T1 < T2 <… должны быть заданы в возрастающем порядке. Большая работа по моделированию неоднородных пуассоновских процессов была проделана Льюисом и Шедлером (1979). Весь этот раздел — переработанная версия их труда. Интересно наблюдать, что общие принципы генерации непрерывных случайных величин могут быть расширены: мы увидим, что существуют аналоги методом инверсии, отклонения и композиции.
Роль функции распределения займёт проинтегрированная функция интенсивности 
Мы начнём с того, что заметим, что если Tn = T, то Tn+1-Tn имеет функцию распределения 
если функция Λ(t) неограниченно возрастает с ростом t. Это следует из того факта, что 
Иными словами, нам необходимо обратить Λ. Формально имеем (см. также Синлар (1975) или Бретли, Фокс и Шраге (1983)) алгоритм, основанный на обращении интеграла функции интенсивности (метод инверсии)
`T = 0 (вспомогательная переменная)`
`k = 0 (счётчик)`
`REPEAT`
`Сгенерировать экспоненциальную случайную величину E`
`k = k+1`
`T = T + InvΛ(E+Λ(T)), (InvΛ - обратная функция к Λ)`
`T[k] = T`
`UNTIL False`
##### Пример 1.2. Однородный пуассоновский процесс
Для особого случая λ(t)=λ, Λ(t)=λt несложно видеть, что InvΛ(E+Λ(T))=T+E/λ, в результате чего мы снова получаем экспоненциальный метод.
##### Пример 1.3.
Для моделирования утреннего потока автомобилей перед часом пик, мы иногда можем взять λ(t)=t, тогда Λ(t)=t^2/2 и получим шаг 
Если функцию интенсивности можно представить в виде суммы функций интенсивности, т. е. ,
0 < Ti1 < Ti2 <… Tin — независимые реализации отдельных неоднородных пуассоновских процессов, то объединённая упорядоченная последовательность образует реализацию неоднородного пуассоновского процесса с функкцией интенсивности λ(t). Это относится к методу композиции, но разница теперь состоит в том, что нам нужны реализации всех компонентов процесса. Декомпозицию можно использовать, когда существует естественное разложение, продиктованное аналитической формой λ(t). Поскольку основная операция в слиянии процессов — взять минимальное значение из n процессов, для больших n преимущество может предоставить хранение моментов времени в куче из n элементов.
В итоге получим метод композиции:
`Сгенерировать T[1,1],...,T[n,1] для n пуассоновских процессов и хранить эти значения вместе с индексами соответствующих процессов в таблице`
`T = 0 (текущее время)`
`k = 0`
`REPEAT`
`Найти минимальный элемент T[i,j] в таблице и удалить его`
`k = k + 1`
`T[k] = T[i,j]`
`Сгенерировать T[i,j+1] и вставить в таблицу`
`UNTIL False`
Третий общий принцип — это принцип утоньшения (Льюис и Шедлер, 1979). Аналогично тому, что происходит в методе отклонения, предполагаем, что существует лёгкая доминирующая функция интенсивности λ(t) <= μ(t) для любого t.
Тогда идея состоит в том, чтобы сгенерировать однородный Пуассоновский процесс на части положительной полуплоскости между 0 и μ(t), затем рассмотреть однородный пуассоновский процесс под λ и, наконец, вернуть x-компоненты событий в этом процессе. Это требует следующей теоремы.
Теперь рассмотрим метод утоньшения Льюиса и Шедлера:
`T = 0`
`k = 0`
`REPEAT`
`Сгенерировать Z, первое событие в неоднородном пуассоновском процессе с функцией интенсивности μ, который происходит после момента времени T. Присвоить T = Z`
`Сгенерировать равномерно распределённую на [0;1] случайную величину U`
`IF U <= λ(Z)/μ(Z)`
`THEN k = k + 1, X[k] = T`
`UNTIL False`
Утверждается, что последовательность Xk так сгенерированная образует неоднородный пуассоновский процесс с функцией интенсивности λ. Заметим, что мы взяли неоднородный процесс 0 < Y1 < Y2 <… с функцией интенсивности μ и убрали некоторые точки. Насколько мы знаем, (Yi,Uiμ(Yi) — однородный пуассоновский процесс с единичной интенсивностью на кривой, если Ui независимые одинаково распределённые равномерно на [0;1] случайные величины в силу теоремы 1.3. Таким образом, подпоследовательность на кривой λ определяет однородный пуассоновский процесс с единичной интенсивностью на этой кривой (часть 3. теоремы 1.3). Наконец, взятие x-координат только этой подпоследовательности даёт нам неоднородный пуассоновский процесс с функцией интенсивности λ.
Неоднородный пуассоноский процесс с функцией интенсивности μ обычно моделируют методом инверсии.
##### Пример 1.4. Функция с циклической интенсивностью
Следующий пример также принадлежит Льюису и Шедлеру (1979). Рассмотрим функцию с циклической интенсивностью λ(t)= λ(1+cos(t)) с очевидным выбором доминирующей функции μ=2λ.
Тогда алгоритм моделирования примет вид:
`T = 0`
`k = 0`
`REPEAT`
`Сгенерировать экспоненциальную случайную величину E c параметром 1`
`T = T + E/(2λ)`
`Сгенерировать равномерную на [0;1] случайную величину U`
`IF U <= (1+cos(T))/2`
`THEN k = k + 1, X[k] = T`
`UNTIL False`
Нет нужды говорить о том, что можно использовать здесь теорему о двух милиционерах, чтобы избежать вычисления косинуса в большинстве случаев.
Заключительное слово об эффективности алгоритма, когда моделируется неоднородный пуассоновский процесс на множестве [0,t]. Среднее число событий, которое необходимо от доминирующего процесса, равно  в то время, как среднее число возвращённых случайных величин равно 
Отношение средних величин может быть рассмотрено как объективная мера эффективности, сравнимая в духе константы отклонения в стандартном методе отклонения. Заметим, что мы не можем использовать среднюю величину отношения, поскольку она, в общем случае, была бы равна бесконечности в силу положительной вероятности того, что ни одна величина не возвратится. | https://habr.com/ru/post/210432/ | null | ru | null |
# Большая история аргументов функций в Python
Ну, на самом деле, история аргументов в Python не такая уж и большая.
Я всегда удивлялся тому, что для работы с аргументами Python-функций достаточно лишь разобраться с `*args` и `**kwargs`. И удивлялся я не зря. Как оказалось, аргументы — это далеко не так просто. В этом материале я хочу дать общий обзор всего того, что связано с аргументами функций в Python. Надеюсь, что в итоге у меня, и правда, получится показать общую картину работы с аргументами, и что эта статья не станет очередной публикацией, в которой читателю не удастся найти ничего нового. А теперь — к делу.
[](https://habr.com/ru/company/ruvds/blog/515678/)
Большинству читателей этой статьи, полагаю, понятна сущность аргументов функций. Для начинающих поясню, что это — объекты, отправляемые функции инициатором её вызова. При передаче аргументов функции выполняется множество действий, зависящих от того, объекты какого типа отправляют функции (изменяемые или неизменяемые объекты). Инициатор вызова функции — это сущность, которая вызывает функцию и передаёт ей аргументы. Говоря о вызове функций, стоит поразмыслить над некоторыми вещами, которые мы сейчас обсудим.
В аргументы, имена которых заданы при объявлении функции, записываются объекты, передаваемые функциям при вызове. При этом, если соответствующим локальным переменным функций, их параметрам, что-то присваивают, эта операция не влияет на передаваемые функциям неизменяемые объекты. Например:
```
def foo(a):
a = a+5
print(a) # Выводит 15
a = 10
foo(a)
print(a) # Выводит 10
```
Как видно, вызов функции никак не повлиял на переменную `a`. Именно это происходит в том случае, если функции передаётся неизменяемый объект.
А если же функциям передают изменяемые объекты, то можно столкнуться с поведением системы, которое отличается от вышеописанного.
```
def foo(lst):
lst = lst + ['new entry']
print(lst) # Выводит ['Book', 'Pen', 'new entry']
lst = ['Book', 'Pen']
print(lst) # Выводит ['Book', 'Pen']
foo(lst)
print(lst) # Выводит ['Book', 'Pen']
```
Заметили ли вы тут что-то новое? Если вы ответите «Нет», то будете правы. Но если как-то повлиять на элементы изменяемого объекта, переданного функции, мы станем свидетелями кое-чего другого.
```
def foo(lst):
lst[1] = 'new entry'
print(lst) # Выводит ['Book', 'new entry']
lst = ['Book', 'Pen']
print(lst) # Выводит ['Book', 'Pen']
foo(lst)
print(lst) # Выводит ['Book', 'new entry']
```
Как видите, объект из параметра `lst` был изменён после вызова функции. Произошло это из-за того, что мы работаем со ссылкой на объект, хранящейся в параметре `lst`. В результате изменение содержимого этого объекта выходит за пределы функции. Избежать этого можно, просто выполняя глубокие копии подобных объектов и записывая их в локальные переменные функции.
```
def foo(lst):
lst = lst[:]
lst[1] = 'new entry'
print(lst) # Выводит ['Book', 'new entry']
lst = ['Book', 'Pen']
print(lst) # Выводит ['Book', 'Pen']
foo(lst)
print(lst) # Выводит ['Book', 'Pen']
```
Это вас ещё не удивило? Если нет — тогда хотелось бы мне сделать так, чтобы вы, пропустив то, что вам известно, сразу же перешли к новому для вас материалу. А если да — то, помяните мои слова, вы, ближе знакомясь с аргументами, узнаете ещё много интересного.
Итак, вот что следует знать об аргументах функций:
1. Порядок передачи функциям позиционных аргументов.
2. Порядок передачи функциям именованных аргументов.
3. Назначение значений аргументов, применяемых по умолчанию.
4. Организация обработки наборов аргументов переменной длины.
5. Распаковка аргументов.
6. Использование аргументов, которые можно передавать только по имени (keyword-only).
Разберём каждый из этих пунктов.
1. Порядок передачи функциям позиционных аргументов
---------------------------------------------------
Позиционные аргументы обрабатываются слева направо. То есть оказывается, что позиция аргумента, переданного функции, находится в прямом соответствии с позицией параметра, использованного в заголовке функции при её объявлении.
```
def foo(d, e, f):
print(d, e, f)
a, b, c = 1, 2, 3
foo(a, b, c) # Выводит 1, 2, 3
foo(b, a, c) # Выводит 2, 1, 3
foo(c, b, a) # Выводит 3, 2, 1
```
Переменные `a`, `b` и `c` имеют, соответственно, значения 1, 2 и 3. Эти переменные играют роль аргументов, с которыми вызывается функция `foo`. Они, при первом вызове функции, соответствуют параметрам `d`, `e` и `f`. Этот механизм применим практически во всех из вышеперечисленных выше 6 пунктов, касающихся того, что нужно знать об аргументах функций в Python. Место размещения позиционного аргумента, передаваемого функции при вызове, играет главную роль при назначении значений параметрам функции.
2. Порядок передачи функциям именованных аргументов
---------------------------------------------------
Именованные аргументы передают функциям с указанием имён этих аргументов, соответствующих тем именам, которые им назначены при объявлении функции.
```
def foo(arg1=0, arg2=0, arg3=0):
print(arg1, arg2, arg3)
a, b, c = 1, 2, 3
foo(a,b,c) # Выводит 1 2 3
foo(arg1=a, arg2=b, arg3=c) # Выводит 1 2 3
foo(arg3=c, arg2=b, arg1=a) # Выводит 1 2 3
foo(arg2=b, arg1=a, arg3=c) # Выводит 1 2 3
```
Как видите, функция `foo` принимает 3 аргумента. Эти аргументы имеют имена `arg1`, `arg2` и `arg3`. Обратите внимание на то, как мы, при вызове функции, меняем позиции аргументов. Именованные аргументы обрабатываются не так, как позиционные, хотя система продолжает читать их слева направо. Python, при назначении соответствующих значений параметрам функций, учитывает имена аргументов, а не их позиции. В результате оказывается, что функция выводит одно и то же независимо от позиций переданных ей аргументов. Это — всегда `1 2 3`.
Обратите внимание на то, что здесь продолжают действовать механизмы, описанные в пункте №1.
3. Назначение значений аргументов, применяемых по умолчанию
-----------------------------------------------------------
Именованным аргументам можно назначать значения, применяемые по умолчанию. При использовании этого механизма в функции определённые аргументы становятся необязательными. Объявление подобных функций выглядит как то, что мы рассматривали в пункте №2. Единственное различие заключается в том, как именно вызываются эти функции.
```
def foo(arg1=0, arg2=0, arg3=0):
print(arg1, arg2, arg3)
a, b, c = 1, 2, 3
foo(arg1=a) # Выводит 1 0 0
foo(arg1=a, arg2=b ) # Выводит 1 2 0
foo(arg1=a, arg2=b, arg3=c) # Выводит 1 2 3
```
Обратите внимание на то, что в этом примере мы не передаём функции все аргументы, описанные при её объявлении. В этих случаях соответствующим параметрам назначаются значения, заданные по умолчанию. Продолжим этот пример:
```
foo(arg2=b) # Выводит 0 2 0
foo(arg2=b, arg3=c ) # Выводит 0 2 3
foo(arg3=c) # Выводит 0 0 3
foo(arg3=c, arg1=a ) # Выводит 1 0 3
```
Это — простые и понятные примеры использования вышеописанных механизмов вызова функций с передачей ей именованных аргументов. А теперь давайте усложним наши эксперименты, объединив то, о чём мы до сих пор говорили в пунктах №1, №2 и №3:
```
foo(a, arg2=b) # Выводит 1 2 0
foo(a, arg2=b, arg3=c) # Выводит 1 2 3
foo(a, b, arg3=c) # Выводит 1 2 3
foo(a) # Выводит 1 0 0
foo(a,b) # Выводит 1 2 0
```
Тут при вызове функции использованы и позиционные и именованные аргументы. При использовании позиционных аргументов порядок их указания играет, как и прежде, важнейшую роль в правильной передаче функции входных данных.
Здесь мне хотелось бы обратить ваше внимание на одну примечательную деталь. Она заключается в том, что позиционные аргументы нельзя указывать после именованных аргументов. Вот пример, который позволит вам лучше понять эту идею:
```
foo(arg1=a, b)
>>>
foo(arg1=a, b)
^
SyntaxError: positional argument follows keyword argument
foo(a, arg2=b, c)
>>>
foo(a, arg2=b, c)
^
SyntaxError: positional argument follows keyword argument
```
Вы можете воспринимать это как правило. Позиционные аргументы не должны следовать за именованными аргументами при вызове функции.
4. Организация обработки наборов аргументов переменной длины
------------------------------------------------------------
Здесь речь пойдёт о конструкциях `*args` и `**kwargs`. Когда эти конструкции используются при объявлении функции, мы ожидаем, что при вызове функции наборы аргументов произвольной длины будут представлены в виде параметров `args` и `kwargs`. При применении конструкции `*args` в параметр `args` попадают позиционные аргументы, представляемые в виде кортежа. При применении `**kwargs` в `kwargs` попадают именованные аргументы, представленные в виде словаря.
```
def foo(*args):
print(args)
a, b, c = 1, 2, 3
foo(a, b, c) # Выводит (1, 2, 3)
foo(a, b) # Выводит (1, 2)
foo(a) # Выводит (1)
foo(b, c) # Выводит (2, 3)
```
Этот код доказывает то, что в параметре `args` хранится кортеж, содержащий то, что передано функции при её вызове.
```
def foo(**kwargs):
print(kwargs)
foo(a=1, b=2, c=3) # Выводит {'a': 1, 'b': 2, 'c': 3}
foo(a=1, b=2) # Выводит {'a': 1, 'b': 2}
foo(a=1) # Выводит {'a': 1}
foo(b=2, c=3) # Выводит {'b': 2, 'c': 3}
```
В вышеприведённом коде показано то, что в параметре `kwargs` хранится словарь, состоящий из пар ключ-значение и представляющий именованные аргументы, переданные функции при вызове.
Но надо отметить, что функции, рассчитанной на приём позиционных аргументов, нельзя передавать именованные аргументы (и наоборот).
```
def foo(*args):
print(args)
foo(a=1, b=2, c=3)
>>>
foo(a=1, b=2, c=3)
TypeError: foo() got an unexpected keyword argument 'a'
#########################################################
def foo(**kwargs):
print(kwargs)
a, b, c = 1, 2, 3
foo(a, b, c)
>>>
TypeError: foo() takes 0 positional arguments but 3 were given
```
А теперь давайте соберём вместе всё то, что мы разобрали в пунктах №1, №2, №3 и №4, и со всем этим поэкспериментируем, исследовав разные комбинации аргументов, которые можно передавать функциям при их вызове.
```
def foo(*args,**kwargs):
print(args, kwargs)
foo(a=1,)
# () {'a': 1}
foo(a=1, b=2, c=3)
# () {'a': 1, 'b': 2, 'c': 3}
foo(1, 2, a=1, b=2)
# (1, 2) {'a': 1, 'b': 2}
foo(1, 2)
# (1, 2) {}
```
Как видите, в нашем распоряжении оказывается кортеж `args` и словарь `kwargs`.
А вот — ещё одно правило. Оно заключается в том, что конструкцию `*args` нельзя использовать после конструкции `**kwargs`.
```
def foo(**kwargs, *args):
print(kwargs, args)
>>>
def foo(**kwargs, *args):
^
SyntaxError: invalid syntax
```
То же самое правило распространяется и на порядок указания аргументов при вызове функций. Позиционные аргументы не должны следовать за именованными.
```
foo(a=1, 1)
>>>
foo(a=1, 1)
^
SyntaxError: positional argument follows keyword argument
foo(1, a=1, 2)
>>>
foo(1, a=1, 2)
^
SyntaxError: positional argument follows keyword argument
```
При объявлении функций можно комбинировать позиционные аргументы, `*args` и `*kwagrs` следующим образом:
```
def foo(var, *args,**kwargs):
print(var, args, kwargs)
foo(1, a=1,) # Вызов 1
# 1 () {'a': 1}
foo(1, a=1, b=2, c=3) # Вызов 2
# 1 () {'a': 1, 'b': 2, 'c': 3}
foo(1, 2, a=1, b=2) # Вызов 3
# 1 (2,) {'a': 1, 'b': 2}
foo(1, 2, 3, a=1, b=2) # Вызов 4
# 1 (2, 3) {'a': 1, 'b': 2}
foo(1, 2) # Вызов 5
# 1 (2,) {}
```
При объявлении функции `foo` мы исходили из того, что у неё должен быть один обязательный позиционный аргумент. За ним следует набор позиционных аргументов переменной длины, а за этим набором идёт набор именованных аргументов переменной длины. Зная это, мы легко сможем «расшифровать» каждый из вышеприведённых вызовов функции.
В `Вызове 1` функции переданы аргументы `1` и `a=1`. Это, соответственно, позиционный и именованный аргументы. `Вызов 2` — это разновидность `Вызова 1`. Здесь длина набора позиционных аргументов равна нулю.
В `Вызове 3` мы передаём функции `1`, `2` и `a=1,b=2`. Это значит, что она теперь принимает два позиционных аргумента и два именованных аргумента. В соответствии с объявлением функции оказывается, что `1` воспринимается как обязательный позиционный аргумент, `2` идёт в набор позиционных аргументов переменной длины, а `a=1` и `b=2` попадают в набор именованных аргументов переменной длины.
Для того чтобы правильно вызвать эту функцию, мы должны передать ей, как минимум, один позиционный аргумент. В противном случае мы столкнёмся с ошибкой.
```
def foo(var, *args,**kwargs):
print(var, args, kwargs)
foo(a=1)
>>>
foo(a=1)
TypeError: foo() missing 1 required positional argument: 'var'
```
Ещё одной разновидностью подобной функции может стать функция, в объявлении которой указано, что она принимает один обязательный позиционный аргумент и один именованный аргумент, за которыми следуют наборы позиционных и именованных аргументов переменной длины.
```
def foo(var, kvar=0, *args,**kwargs):
print(var, kvar, args, kwargs)
foo(1, a=1,) # Вызов 1
# 1 0 () {'a': 1}
foo(1, 2, a=1, b=2, c=3) # Вызов 2
# 1 0 () {'a': 1, 'b': 2, 'c': 3}
foo(1, 2, 3, a=1, b=2) # Вызов 3
# 1 2 () {'a': 1, 'b': 2}
foo(1, 2, 3, 4, a=1, b=2) # Вызов 4
# 1 2 (3,) {'a': 1, 'b': 2}
foo(1, kvar=2) # Вызов 5
# 1 2 () {}
```
Вызовы этой функции можно «расшифровать» так же, как это делалось при анализе предыдущей функции.
При вызове этой функции ей надо передавать, как минимум, один позиционный аргумент. Иначе мы столкнёмся с ошибкой:
```
foo()
>>>
foo()
TypeError: foo() missing 1 required positional argument: 'var'
foo(1)
# 1 0 () {}
```
Обратите внимание на то, что вызов `foo(1)` работает нормально. Дело тут в том, что в том случае, если функцию вызывают, не указывая значение для именованного аргумента, значение ему назначается автоматически.
А вот ещё некоторые ошибки, с которыми можно столкнуться при неправильном вызове этой функции:
```
foo(kvar=1) # Вызов 1
>>>
TypeError: foo() missing 1 required positional argument: 'var'
foo(kvar=1, 1, a=1) # Вызов 2
>>>
SyntaxError: positional argument follows keyword argument
foo(1, kvar=2, 3, a=2) # Вызов 3
>>>
SyntaxError: positional argument follows keyword argument
```
Обратите особое внимание на ошибку, возникающую при выполнении `Вызова 3`.
5. Распаковка аргументов
------------------------
В предыдущих разделах мы говорили о том, как собирать в кортежи и словари наборы аргументов, передаваемых функциям. А здесь мы обсудим обратную операцию. А именно, разберём механизм, позволяющий распаковывать аргументы, подаваемые на вход функции.
```
args = (1, 2, 3, 4)
print(*args) # Выводит 1 2 3 4
print(args) # Выводит (1, 2, 3, 4)
kwargs = { 'a':1, 'b':2}
print(kwargs) # Выводит {'a': 1, 'b': 2}
print(*kwargs) # Выводит a b
```
Распаковывать переменные можно с помощью синтаксических конструкций `*` и `**`. Вот как выглядит их использование при передаче в функции кортежей, списков и словарей.
```
def foo(a, b=0, *args, **kwargs):
print(a, b, args, kwargs)
tup = (1, 2, 3, 4)
lst = [1, 2, 3, 4]
d = {'e':1, 'f':2, 'g':'3'}
foo(*tup) # foo(1, 2, 3, 4)
# 1 2 (3, 4) {}
foo(*lst) # foo(1, 2, 3, 4)
# 1 2 (3, 4) {}
foo(1, *tup) # foo(1, 1, 2, 3, 4)
# 1 1 (2, 3, 4) {}
foo(1, 5, *tup) # foo(1, 5, 1, 2, 3, 4)
# 1 5 (1, 2, 3, 4) {}
foo(1, *tup, **d) # foo(1, 1, 2, 3, 4 ,e=1 ,f=2, g=3)
# 1 1 (2, 3, 4) {'e': 1, 'f': 2, 'g': '3'}
foo(*tup, **d) # foo(1, 1, 2, 3, 4 ,e=1 ,f=2, g=3)
# 1 2 (3, 4) {'e': 1, 'f': 2, 'g': '3'}
d['b'] = 45
foo(2, **d) # foo(1, e=1 ,f=2, g=3, b=45)
# 2 45 () {'e': 1, 'f': 2, 'g': '3'}
```
Разберите каждый из приведённых здесь вызовов функций, выполненный с использованием распаковки аргументов, и обратите внимание на то, как соответствующие вызовы выглядели бы без использования `*` и `**`. Постарайтесь понять то, что происходит при выполнении этих вызовов, и то, как именно распаковываются различные структуры данных.
Экспериментируя с распаковкой аргументов, можно столкнуться с новой ошибкой:
```
foo(1, *tup, b=5)
>>>
TypeError: foo() got multiple values for argument 'b'
foo(1, b=5, *tup)
>>>
TypeError: foo() got multiple values for argument 'b'
```
Эта ошибка возникает из-за конфликта именованного аргумента, `b=5`, и позиционного аргумента. Как мы выяснили в разделе №2, при передаче именованных аргументов их порядок значения не имеет. В результате в обоих случаях возникает одна и та же ошибка.
6. Использование аргументов, которые можно передавать только по имени (keyword-only)
------------------------------------------------------------------------------------
В некоторых случаях нужно сделать так, чтобы функция принимала бы обязательные именованные аргументы. Если при объявлении функции описывают аргументы, которые можно передавать только по имени, то такие аргументы должны передаваться ей при любом её вызове.
```
def foo(a, *args, b):
print(a, args, b)
tup = (1, 2, 3, 4)
foo(*tup, b=35)
# 1 (2, 3, 4) 35
foo(1, *tup, b=35)
# 1 (1, 2, 3, 4) 35
foo(1, 5, *tup, b=35)
# 1 (5, 1, 2, 3, 4) 35
foo(1, *tup, b=35)
# 1 (1, 2, 3, 4) 35
foo(1, b=35)
# 1 () 35
foo(1, 2, b=35)
# 1 (2,) 35
foo(1)
# TypeError: foo() missing 1 required keyword-only argument: 'b'
foo(1, 2, 3)
# TypeError: foo() missing 1 required keyword-only argument: 'b'
```
Как видите, ожидается, что функции обязательно будет передан именованный аргумент `b`, который, в объявлении функции, указан после `*args`. При этом в объявлении функции можно использовать просто символ `*`, после которого, через запятую, идут идентификаторы именованных аргументов, которые можно передавать функции только по имени. Такая функция не будет рассчитана на приём набора позиционных аргументов переменной длины.
```
def foo(a, *, b, c):
print(a, b, c)
tup = (1, 2, 3, 4)
foo(1, b=35, c=55)
# 1 35 55
foo(c= 55, b=35, a=1)
# 1 35 55
foo(1, 2, 3)
# TypeError: foo() takes 1 positional argument but 3 were given
foo(*tup, b=35)
# TypeError: foo() takes 1 positional argument but 4 positional arguments (and 1 keyword-only argument) were given
foo(1, b=35)
# TypeError: foo() takes 1 positional argument but 4 positional arguments (and 1 keyword-only argument) were given
```
Функция, объявленная в предыдущем примере, принимает один позиционный аргумент и два именованных аргумента, которые можно передавать только по имени. Это приводит к тому, что для правильного вызова функции ей необходимо передавать оба именованных аргумента. После `*` можно описывать и именованные аргументы, которым заданы значения, применяемые по умолчанию. Это даёт нам определённую свободу при вызове подобных функций.
```
def foo(a, *, b=0, c, d=0):
print(a, b, c, d)
foo(1, c=55)
# 1 0 55 0
foo(1, c=55, b=35)
# 1 35 55 0
foo(1)
# TypeError: foo() missing 1 required keyword-only argument: 'c'
```
Обратите внимание на то, что функцию можно нормально вызывать, не передавая ей аргументы `b` и `d`, так как для них заданы значения, применяемые по умолчанию.
Итоги
-----
Пожалуй, у нас, и правда, получилась очень длинная история об аргументах. Надеюсь, читатели этого материала узнали что-то новое для себя. И, кстати, историю об аргументах функций в Python можно продолжать. Возможно, мы ещё о них поговорим.
**Узнали ли вы из этого материала что-то новое об аргументах функций в Python?**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=arguments-in-python) | https://habr.com/ru/post/515678/ | null | ru | null |
# Дифференциальный криптоанализ для чайников
> Шифр FEAL обладает таким же уровнем стойкости что и DES. Более того, увеличенная длина ключа (64 бита по сравнению с 56 битами в DES) затрудняет возможность перебора. Шифр FEAL обладает хорошим распределением шифротекстов, близким к случайному. И это тоже говорит в пользу FEAL по сравнению с DES.
Это краткое содержание спецификации алгоритма шифрования FEAL, опубликованного в 1987 году.
Ничто не вечно под луной. В данном топике я расскажу как при наличии всего 40 пар открытых-закрытых текстов получить полный ключ FEAL4 за несколько минут.
#### Дифференциальный криптоанализ
Для начала разберемся что же скрывается под ласкающим русское ухо названием «Дифференциальный криптоанализ».
Дифференциальный криптоанализ — атака с подобранным открытым текстом. Это означает, что для применения ДК вы должны иметь возможность зашифровать абсолютно любые тексты в абсолютно любом количестве.
Целью атакующего, применяющего ДК, является получение некоторой информации о ключе, которая может как полностью скомпрометировать ключ (что бывает очень редко), так и просто дать некоторое преимущество при подборе ключа.
Работает это все следующим образом. Для двух заранее подобранных шифротекстов P1 и P2 злоумышленник вычисляется «дифференциал» ΔP=P1⊕P2. И с помощью ΔP пытается определить каким должен быть «дифференциал» шифротекстов ΔС=C1⊕C2. Зачастую невозможно предугадать со 100% точностью какое именно будет иметь значение ΔС. Единственное, что может злоумышленник, это определить с какой частотой шифр возвращает различные значения ΔС, для заданного заранее ΔP. Это знание позволяет атакующему вскрыть часть ключа или ключ целиком.
В качестве примера разберем трехраундовый блочный шифр, изображенный на рисунке ниже.
Данный шифр имеет 64 битный размер блока и 128 битный ключ.
На каждом раунде входной блок делится на 8 байт, каждый из которых проходит через функцию подстановки **Sbox**. После этого данные перемешиваются с 64 битным подключом Subkey. Функция перемешивания представляет собой обычный XOR.
Предположим, что злоумышленник решил проверить дифференциал 0x80. Для этого он генерирует произвольный байт X1, и вычисляет X2=X1⊕80.
Далее атакующий прогоняет X1 и X2 через функцию Sbox и получает значения Y1 и Y2. Для каждой такой пары X1 и X2, дифференциал которых равен 80, атакующий в состоянии получить дифференциал ΔY. Анализируя полученные значения, атакующий выбирает такое значение ΔY, которое имеет большую вероятность возникновения.
Возвращаясь к нашему примеру, предположим, что из всех 256 пар X1 и X2, в 192 случаях Y1⊕Y2=02. Таким образом, вероятность того, что при заданном ΔX=80, значение ΔY=02, составляет 192/256=3/4. Это в свою очередь означает, что при заданном ΔX=80, с вероятность P1=3/4 на вход второго раунда попадут два значения U1 и U2, такие что ΔU=02.
Обратите внимание, что ключ никоим образом не влияет на значение дифференциалов. Так как при шифровании разных текстов ключ не изменяется и перемешивание с ключевой последовательностью осуществляется с помощью XOR, то при вычислении ΔU байты ключа взаимно исключаются.
Для раскрытия свойств второго раунда, злоумышленник генерирует новые 256 пар входных байт X1 и X2, таких, что X1⊕X2=02. Произведя вычисление функции Sbox для каждой пары X1 и X2, атакующий замечает, что в 64 случаях из 256 ΔY=88. Т.е. вероятность того, что ΔY=88, для заданного ΔX=02, составляет P2=64/256=1/4.
Таким образом, произведя нехитрый подсчет вероятностей, атакующий понимает, что для указанного шифра для каждой пары байт X1 и X2, таких что ΔX=80, с вероятность P= P1\*P2=3/4\*1/4=3/16, дифференциал внутреннего состояния шифра перед последним раундом составляет ΔY=88.
Обладая этим знанием атакующий генерирует несколько пар текстов таких, что ΔP=808080808080 и приступает к побайтовому подбору подключа третьего раунда.
Покажем каким образом осуществляется вскрытие первого байта подключа.
Для каждого из 256 возможных вариантов первого байта Subkey[0] и для каждой пары шифротекстов {C1, C2}, злоумышленник вычисляет U1=Sbox(C1⊕Subkey[0]) и U2=Sbox(C2⊕Subkey[0]).
Если Subkey[0] угадан правильно, то приблизительно 3 из каждых 16 пар U1 и U2 при вычислении ΔU будут равны 88.
Подобрав таким образом наиболее вероятный первый байт подключа Subkey, атакующий может перейти ко второму байту и действуя аналогичным образом вскрыть весь ключ третьего раунда.
После того, как ключ последнего раунда будет раскрыт, злоумышленник может приступить к атаке на предпоследний раунд и действуя подобным образом в конечном итоге получит информацию о всех раундовых ключах шифра.
#### Описание шифра FEAL
Теперь рассмотрим криптоалгоритм с которым мы попытаемся совершить описанные выше действия.
Итак, FEAL4 это блочный шифр, с размером блока и длиной ключа равными 64 бита.
Существует несколько равноценных описаний алгоритма FEAL4, мы воспользуемся наиболее удобным для демонстрации дифференциального криптоанализа.
Шифр состоит из 4-х раундов и использует шесть 32-битных подключей, генерируемых из основного ключа(в дальнейшем будем считать, что каждый подключ генерируется независимо, «увеличив» таким образом порог стойкость с 264 до 2192).
На начальном этапе открытый текст разбивается на два блока, по 32 бита каждый. Левый и правый блоки складываются по модулю два с 32-битными подключами K[4] и K[5] соответственно. Затем левая часть остается без изменений, а правая образуется сложением по модулю два с левым блоком.
После этого выполняется 4 раунда шифрования на каждом из которых правый блок суммируется по модулю два с подключом раунда K[i], а затем полученный результат прогоняется через функцию перестановки F. Результат перестановки складывается с левой частью текста. После этих операций левый и правый блок меняют местами и полученный результат подается на вход следующего раунда.
Последний раунд немного отличается от всех остальных. Левые и правые блоки не меняются местами, как в предыдущих раундах.
Вместо этого, правый блок складывается по модулю два с левым блоком и полученный результат возвращается в качестве правой части шифротекста. Левая же часть после 4 раунда остается неизменной и составляет первые 32 бита полученного шифротекста.
Оригинальная схема шифра, описанная создателями несколько отличалась от приведенной выше. Вместо шести 32-битных, в оригинальном описании используются двенадцать 16-битных подключа. Однако, оба варианта идентичны и при желании 32-битные ключи можно легко представить в виде 16-битных ключей из оригинального описания.
Единственным белым пятном в описании шифра осталась функция F. На рисунке ее можно представить следующим образом:
На входе функция F получает 4 байта X1, X2, X3, X4. Далее входные байты перемешиваются и проходят через функции G0 или G1. 4 байта полученных после вычисления функций Gx образуют 32-битную выходную последовательность функции F.
Функции G0 и G1 выполняют преобразование 16-битной входной последовательности в 8-битный результат.
Функцию G0 можно выразить следующим образом:, где << — циклический сдвиг влево.
В то время как функция G1 имеет следующее определение: .
Расшифровка алгоритма происходит по такому же самом принципу. Собственно, шифротекст разбивается на левый и правый блок и все операции шифрования выполняются в обратном порядке.
Т.е. сперва выполняется расшифровка последнего раунда, затем предпоследнего и так далее.
**реализация FEAL4 на C#**
```
class FEAL4
{
private byte G0(byte a, byte b)
{
return (byte)((((a + b) % 256) << 2) | (((a + b) % 256) >> 6));
}
private byte G1(byte a, byte b)
{
return (byte)((((a + b+1) % 256) << 2) | (((a + b+1) % 256) >> 6));
}
public byte[] F(byte[] x)
{
byte[] y = new byte[4];
y[1] = G1((byte)(x[0] ^ x[1]), (byte)(x[2] ^ x[3]));
y[0] = G0(x[0], y[1]);
y[2] = G0(y[1], (byte)(x[2] ^ x[3]));
y[3] = G1(y[2], x[3]);
return y;
}
private void AddKeyPart(byte[] P, byte[] K)
{
for (int i = 0; i < 4; i++)
{
P[i] = (byte)(P[i] ^ K[i]);
}
}
private byte[] XOR(byte[] a, byte[] b)
{
byte[] c=new byte[a.Length];
for (int i = 0; i < c.Length; i++)
{
c[i] = (byte)(a[i] ^ b[i]);
}
return c;
}
public byte[] Encrypt(byte[] P, byte[][] K)
{
byte[] LeftPart = new byte[4];
byte[] RightPart = new byte[4];
Array.Copy(P, 0, LeftPart, 0, 4);
Array.Copy(P, 4, RightPart, 0, 4);
AddKeyPart(LeftPart, K[4]);
AddKeyPart(RightPart, K[5]);
byte[] Round2Left = XOR(LeftPart, RightPart);
byte[] Round2Right = XOR(LeftPart, F(XOR(Round2Left, K[0])));
byte[] Round3Left = Round2Right;
byte[] Round3Right = XOR(Round2Left,F(XOR(Round2Right,K[1])));
byte[] Round4Left = Round3Right;
byte[] Round4Right = XOR(Round3Left, F(XOR(Round3Right, K[2])));
byte[] CipherTextLeft = XOR(Round4Left,F(XOR(Round4Right,K[3])));
byte[] CipherTextRight = XOR(Round4Right, CipherTextLeft);
byte[] CipherText = new byte[8];
Array.Copy(CipherTextLeft, 0, CipherText, 0, 4);
Array.Copy(CipherTextRight, 0, CipherText, 4, 4);
return CipherText;
}
public byte[] Decrypt(byte[] P, byte[][] K)
{
byte[] LeftPart = new byte[4];
byte[] RightPart = new byte[4];
Array.Copy(P, 0, LeftPart, 0, 4);
Array.Copy(P, 4, RightPart, 0, 4);
byte[] Round4Right = XOR(LeftPart, RightPart);
byte[] Round4Left = XOR(LeftPart, F(XOR(Round4Right, K[3])));
byte[] Round3Right = Round4Left;
byte[] Round3Left = XOR(Round4Right, F(XOR(Round3Right, K[2])));
byte[] Round2Right = Round3Left;
byte[] Round2Left = XOR(Round3Right, F(XOR(Round2Right, K[1])));
byte[] Round1Right = Round2Left;
byte[] Round1Left = XOR(Round2Right, F(XOR(Round1Right, K[0])));
byte[] TextLeft = Round1Left;
byte[] TextRight = XOR(Round1Left,Round1Right);
AddKeyPart(TextLeft, K[4]);
AddKeyPart(TextRight, K[5]);
byte[] Text = new byte[8];
Array.Copy(TextLeft, 0, Text, 0, 4);
Array.Copy(TextRight, 0, Text, 4, 4);
return Text;
}
}
```
#### Дифференциальный криптоанализ шифра FEAL4
Как и в приведенном выше примере начнем криптоанализ шифра с исследования функции подстановки F. Именно здесь скрыт самый значительный изъян всего шифра FEAL. Дело в том, что функция F обладает одним катастрофическим с точки зрения безопасности свойством. Любые два значения X1 и X2, такие что их дифференциал X1⊕X2=0x80800000, преобразуются в Y1 и Y2. При этом дифференциал Y1⊕Y2=0x02000000 в 100% случаев.
Для того, чтобы понять почему так происходит взглянем на преобразование дифференциалов, которое происходит при вычислении функции F.
Легко заметить, что ненулевое значение поступает на вход функции G, только в позиции первого байта. Соответственно на выходе получаем .
Нетрудно понять, что это свойство делает шифр абсолютно уязвимым перед дифференциальным криптоанализом. 100% вероятность возникновения определенного дифференциала ΔY позволяет свести количество необходимых для атаки пар открытый-закрытый текст к минимуму.
Рассмотрим какие шаги следует предпринять злоумышленнику для вскрытия ключа последнего раунда K[3].
Атакующий генерирует несколько пар открытых текстов P1 и P2, таких что ΔP=0x8080000080800000. Зная, описанное выше свойство функции F, атакующий в состоянии рассчитать дифференциалы практически на каждом раунде шифрования.
Отследить поведение дифференциалов вы можете на следующей картинке:
Как видите дифференциалы просчитываются вплоть до последнего раунда. Но и без этого у атакующего уже достаточно информации, чтобы вскрыть последний раундовый ключ.
На иллюстрации ниже изображены два последних раунда шифра FEAL4.
Обладая парой шифротекстов C1 и C2 атакующий может вычислить ΔC, получив таким образом значения L' и R'.
На основании этого он может вычислить Z'=L'⊕02.
C другой стороны для каждой пары шифротекстов C1 и C2, злоумышленник может вычислить Y1 и Y2.
Зная Y1 и Y2 атакующий начинает перебор ключа K[3]. Для каждого возможного ключа Kpos вычисляется Z1=F(Y1⊕Kpos) и Z2=F(Y2⊕Kpos). Сложив по модулю два значения Z1⊕Z2 атакующий сравнивает получившееся значение с предвычисленным заранее Z'. Если Z'=Z1⊕Z2, значит Kpos вероятнее всего и является искомым подключом K[3].
Для того, чтобы снизить вероятность ошибки полученный ключ Kpos необходимо проверить с несколькими парами шифротекстов(я в своей реализации использовал 10 пар).
Нетрудно посчитать, что атака, описанная выше, требует 232 вычислений функции F. Это конечно не 264, заявленные создателями шифра, но все равно цифра не очень приятная особенно если мы хотим вычислить все 4 раундовых ключа, а мы несомненно этого хотим.
К счастью атаку можно упростить и свести количество вычислений ко вполне комфортным 217.
Для этого введем определение функции , где a — набор байт, и z — нулевой байт.
Для каждого A=(z, a0, a1, z) злоумышленник вычисляет Q0=F(M(Y0)⊕A) и Q1=F(M(Y1)⊕A).
Нетрудно убедиться, что если A=M(K[3]), тогда второй и третий байт значения Q0⊕Q1 совпадут со вторым и третьим байтом значения Z'. Таким образом мы получаем информацию о двух байтах потенциального ключа Kpos.
После этого для всех значений b0 и b1, атакующий вычисляет последовательность Kpos=(b0, b0⊕a0, b1⊕a1, b1) и проверяет полученную последовательность описанным выше способом.
После вскрытия подключа K[3], злоумышленник способен восстановить значения в которых находился шифр после третьего раунда и это даст ему возможность атаковать аналогичным образом подключ K[2]. Здесь, правда, необходимо заметить, что для атаки на ключ K[2] необходимо будет использовать другой исходный дифференциал, т.к. дифференциал ΔP=0x8080000080800000 на втором раунде всегда ведет к значению Z'=0x02000000, при любом используемом ключе. И это не позволит угадать ключ второго раунда.
В качестве дифференциалов для вскрытия каждого из подключей можно использовать следующие значения:
Round 4: 0x8080000080800000
Round 3: 0x0000000080800000
Round 2: 0x0000000002000000
Round 1: 0x0200000080000000
После вскрытия всех четырех ключей каждого из раундов легко вычислить ключи K[5] и K[4] для этого достаточно прогнать любой шифротекст через 4 раунда расшифровки и получившееся значение сложить по модулю два с известным открытым текстом.
Если интересно скачать исходники атаки вы можете [здесь](http://ge.tt/1KdeXAQ1).
#### Полезные ссылки
* [Tutorial on Linear and Differential Cryptanalysis](http://www.engr.mun.ca/~howard/PAPERS/ldc_tutorial.pdf)
* [Differential Cryptanalysis of FEAL](http://www.theamazingking.com/crypto-feal.php) | https://habr.com/ru/post/215527/ | null | ru | null |
# Vim-airline — новая строка статуса для Vim
Известно что строку статуса в Vim можно легко кастомизировать в соответствии с вашими пожеланиями: вывести информацию о текущем файле, позиции курсора, текущей vcs-ветке. Есть также отдельные плагины, которые полностью заменяют строку статуса, самым используемым из которых является vim-powerline. В данной статье я хочу познакомить вас с одним из таких плагинов, vim-airline, который я с недавнего времени использую вместо vim-powerline.
Vim-airline — легкий плагин, заменяющий строку статуса в Vim с широкими возможностями для кастомизации. Получил свое название по причине того, что первую его версию автор написал, летя в самолете. Установка плагина не несет никаких проблем — установить можно как обычным копированием, так и через любой из пакетных менеджеров: vundle, pathogen, neobundle. Airline интегрирован с множеством наиболее популярных плагинов: vim-bufferline, fugitive, unite, ctrlp, minibufexpl, gundo, undotree, nerdtree, tagbar, syntastic, lawrencium.
Преимущества по сравнению с вышеупомянутым vim-powerline:
* лучшая производительность при загрузке
* больше возможностей кастомизации
* меньше проблем со шрифтами
* простота создания собственной темы, для примера одна из стандартных: [dark](https://github.com/bling/vim-airline/blob/master/autoload/airline/themes/dark.vim)
##### Кастомизация
Задать тему:
```
let g:airline_theme='dark'
```
Изменить тему во время работы:
```
:AirlineTheme dark
```
Включить/выключить интеграцию со сторонними плагинами:
```
let g:airline_enable_fugitive=1
let g:airline_enable_syntastic=1
let g:airline_enable_bufferline=1
```
Замена символов:
```
let g:airline_left_sep = ''
let g:airline_right_sep = ''
let g:airline_linecolumn_prefix = '¶ '
let g:airline_fugitive_prefix = '⎇ '
let g:airline_paste_symbol = 'ρ'
```
Замена отдельных секций:
```
let g:airline_section_c = '%t'
```
(a,b,c — секции слева, x,y,z — справа)
##### Дополнительные ссылки
1. vim-airline
[github.com/bling/vim-airline](https://github.com/bling/vim-airline)
2. vim-powerline
[github.com/Lokaltog/vim-powerline](https://github.com/Lokaltog/vim-powerline) | https://habr.com/ru/post/187588/ | null | ru | null |
# Mozilla Firefox. Проблемы адаптивной вёрстки (баг, который чуть не рассорил компанию)
Рекомендуется к прочтению верстальщикам, а так же их руководителям. Не является руководством к какому-либо действию.
Сегодня 13 февраля 17-ого. История началась 3 дня назад. Собственно проблема появилась следующая. Есть каруселька (это тип слайдера), верстальщику компании «R&K» пришёл запрос, о том что каруселька не адаптивная, т.е. не сжимается как положено, при сжатии окна браузера по ширине. Баг выявлен в Firefox v50.1.0 32-bit, Win7 32-bit. При этом, на следующий день, появился странный телефонный звонок от заказчика, с сообщением о том, что всё работает, и благодарность за быстрое реагирование. Т.к. вёрстку вообще никто не смотрел, то люди почесали в недоумении репы и разошлись. Через два дня снова позвонил заказчик, и уже яростно/истошно/дико/люто начал орать, что вёрстка снова не адаптивная, и не ужимается в окно браузера при сжатии браузера. Вот тут-то люди призадумались и начали крутить вёрстку.
```
index.html
```
```
style.css
* {margin: 0; padding: 0; font-size: 0; } /* сброс стилей */
div {
margin: 20px auto; /* центрирование для тестов */
border: 1px solid royalblue; /* видимость блока для тестов */
/*display: inline-block; оригинальное значение div, для теста не нужно */
max-width: 450px; /* 300, 400, 450, 600, ширину перебирайте сами */
white-space: nowrap; /* что бы изображения были в линию */
/*overflow: hidden; оригинальное значение overflow, для теста не нужно */
}
input {
/*display: none; оригинальное значение display, для теста не нужно */
}
img {
width: 100%; /* адаптивное сжатие изображения */
}
```
Само собой все лишнее выпилено для тестов. Что бы ясно был виден смысл проблемы. Итак, обнаруженная проблема «адаптивной верстки» следующая:
Верстаем, верстаем, например то что выше, запускаем опять же в вышеприведённом браузере Firefox. Видим следующую картину, всё как и ожидается, например вот так.
Сжимаем окно, естественно «адаптивная вёрстка» жмёт и изображение, получаем вот это.
Всё в порядке? А не тут то было… Идём пить чаёк, курим, приходим обратно, открываем яндекс, читаем новости (почту, Хабр, рутуб и т.д.), открываем поглядеть нашу верстку, и изумлённо получаем вот это.
Теперь поймите правильно людей. Люди — это люди. Всё учесть невозможно. В мире багнутого ПО учесть всё — тем более невозможно. Сложилась следующая ситуация. Клиент открыл страничку в одной вкладке, сжал браузер, и получил то, что хотел. На следующий день он открыл страничку со второй вкладкой, и верстку расколбасило. При этом, верстальщик ровно так же не замечая вкладок — открывал по-разному и получал разные результаты. На количество вкладок никто не обратил внимания. Дошло до того, что начали приподымать чистую вёнду, смотреть там, начали рыть багрепорты на форумах мозиллы, начали искать странное поведение селекторов width/max-width и предпринимать ну очень фееричные и странные действия, про которые стыдно писать, но на количество вкладок снова и опять никто не обратил внимания. Более того, часа три никто не смог воссоздать баг, потому что открывали тестовую страничку на чистом браузере без вкладок. Были просто поражены тем, что баг исчез сам собой, но конечно же, стоило открыть страничку со вкладками, причем с определенными — баг выполз. Сутки люди имели наилютейший баттхерт, которого я в жизни не видел, сдобренный истошными воплями клиента. Разумеется, у людей начали немножко сдавать нервы, и дело чуть не дошло до откровенного мордобоя. Далее повесть рассказывать смысла нет, но догадаться во что выливаются подобные ситуации можно самостоятельно.
Пожалуйста, в мире багнутого ПО будьте внимательней и терпеливей. Это относится ко всем без исключения. Как к исполнителям, так и к руководителям. С заказчиков брать кроме денег, конечно же нечего, и им простительно.
**P.S.:** К верстальщикам не имею никакого отношения. Верстал 10 лет назад, слава богу быстро слез с этого непотребного дела. Получил себе эту проблему по телефонному звонку от знакомого, который всю голову изломал, решая оную задачку. Баг успешно воссоздан, верстка выше — моя. Верстка тестовая, никак не продакшн, ни в одном глазу. Специально позвонил еще одному знакомому верстальщику, слышит про этот баг впервые. | https://habr.com/ru/post/321966/ | null | ru | null |
# UE4 для Unity-разработчиков
Привет, Хабр! Меня зовут Александр, и сегодня мы сравним Unity и Unreal Engine 4.
Думаю, многие разработчики пробовали движок Unity и видели сделанные на нём игры, проекты, какие-то демки. Его главный конкурент — движок Unreal Engine. Он берёт своё начало в проектах компании Epic Games, таких как шутер Unreal Tournament. Давайте рассмотрим, как начать работу с движком Unreal после Unity и какие препятствия могут подстерегать нас на пути.
Бывает, что 3D-движки сравнивают весьма поверхностно, либо акцентируют внимание только на одной из фич, например, на графике. Мы же холиварить не будем и рассмотрим оба движка в качестве равноправных инструментов. Наша цель — сопоставить две технологии и помочь вам разобраться в движке Unreal Engine 4. Сравним базовые системы движков на конкретных примерах кода демо-проекта [UShooter](http://github.com/asd-firelight/UShooter) (Unreal + Unity Shooter), специально сделанного для этих целей. Проект использует версию Unity 5.5.0 и Unreal Engine 4.14.3.
Система компонентов (Unity)
---------------------------
Когда мы запускаем проект на Unreal, то видим, что персонаж в сцене — лишь один объект. В окне World Outliner нет привычных нодов модели (вложенных объектов, мешей), костей скелета и т. д. Это следствие различий систем компонентов Unity и Unreal.
В Unity сцена состоит из объектов типа **Game Object**. Это пустой универсальный объект, к которому добавляются компоненты, реализованные скриптами поведения **(MonoBehaviour)** и встроенными компонентами движка. Иногда их оставляют пустыми, в качестве объекта-маркера, на месте которого будет создан, например, игровой персонаж или эффект.
Все эти объекты мы видим в окне **Hierarchy** в редакторе движка. Они имеют встроенный компонент `Transform`, с помощью которого мы можем управлять положением объекта в пространстве 3D-сцены. Например, скрипт движения объекта меняет координаты в функции `Update`, и объект двигается. Для добавления подобного скрипта на **Game Object** достаточно двух кликов. Создав объект — персонажа или предмет, — мы его настраиваем, добавляем скрипты и сохраняем в **prefab** (файл, хранящий **Game Object** и его дочерние объекты). Впоследствии мы можем менять сам prefab, и эти изменения отразятся на всех подобных объектах.
Вот как выглядит класс `RocketProjectile`, представляющий собой ракету в проекте UShooter.
**Фрагмент RocketProjectile.cs**
```
public class RocketProjectile: MonoBehaviour
{
public float Damage = 10.0f;
public float FlySpeed = 10.0f;
void Update()
{
gameObject.transform.position += gameObject.transform.forward * FlySpeed * Time.deltaTime;
}
void OnCollisionEnter(Collision collision)
{
// Обработка столкновения
}
}
```
Мы задаём параметры снаряда в редакторе, при желании меняем скорость перемещения (свойство `FlySpeed`) и урон (`Damage`). Обработка столкновений происходит в функции `OnCollisionEnter`. Unity сам её вызывает, так как на объекте есть компонент **Rigid Body**.
Система компонентов (UE4)
-------------------------
В Unreal Engine 4 игровые объекты представляются Actor’ами и их компонентами. `AActor` («актер») — это основной класс объекта, который помещается в сцене. Мы можем его создать в игровой сцене (как из редактора, так и кодом), менять его свойства и т. д. Также есть класс, от которого унаследованы все сущности движка: `UObject`.
Компоненты добавляются к Actor’у, игровому объекту. Это может быть оружие, персонаж, что угодно. Но эти компоненты условно скрыты от нас в аналоге **Prefab**’а — `Blueprint Class`.
В объекте Actor, в отличие от Unity, существует понятие `Root Component`. Это корневой компонент объекта, к которому крепятся остальные компоненты. В Unity достаточно мышкой перетащить объект, чтобы поменять у него иерархию вложенности. В Unreal это делается через привязку компонентов друг к другу ("attachment").
В Unity существуют функции `Start`, `Update` и `LateUpdate` для обновления или начала работы скриптов **MonoBehaviour**. Их аналоги в Unreal — функции `BeginPlay` и `Tick` у Actor'а. У компонентов Actor’а (`UActorComponent`) для этого существуют функции `InitializeComponent` и `ComponentTick`, поэтому нельзя «в один клик» сделать из компонента Actor, и наоборот. Также, в отличие от Unity, Transform есть не у всех компонентов, а только у `USceneComponent` и унаследованных от него.
В Unity мы можем практически в любом месте кода написать `GameObject.Instantiate` и получим созданный из **Prefab**’а объект. В Unreal же мы «просим» объект мира (`UWorld`) создать экземпляр объекта. Создание объекта называется в анриале спауном, от слова spawn. Для этого используется функция `World->SpawnActor`.
Персонажи и их Controller’ы
---------------------------
В Unreal для персонажей существуют специальные классы `APawn` и `ACharacter`, они унаследованы от класса `AActor`.
`APawn` — класс персонажа, которым может управлять игрок или AI. В Unreal для управления персонажами есть система контроллеров. Мы создаём `Player Controller` или `AI Controller`. Они получают команду управления от игрока или внутреннюю логику, если это AI, и передают команды движения самому классу персонажа, `APawn` или `ACharacter`.
`ACharacter` создан на основе `APawn` и имеет расширенные механизмы перемещения, встроенный компонент скелетного меша, базовую логику перемещения персонажа и его представление для сетевой игры. Для оптимизации можно создать персонажа на основе `APawn` и реализовать только необходимый проекту функционал.
Описание игрового класса (Actor’а)
----------------------------------
Теперь, немного узнав о компонентах Unreal, мы можем взглянуть на класс ракеты в Unreal-версии **UShooter**.
**Фрагмент RocketProjectile.h**
```
UCLASS()
class USHOOTER_API ARocketProjectile : public AActor
{
GENERATED_BODY()
public:
// Sets default values for this actor's properties
ARocketProjectile();
// Called when the game starts or when spawned
virtual void BeginPlay() override;
// Called every frame
virtual void Tick( float DeltaSeconds ) override;
// Rocket fly speed
UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Rocket")
float FlySpeed;
// Rocket damage
UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Rocket")
float Damage;
// Impact (collsion) handling
UFUNCTION()
void OnImpact(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit);
private:
/** Collision sphere */
UPROPERTY(VisibleDefaultsOnly, Category = "Projectile")
USphereComponent* CollisionComp;
};
```
Взаимодействие редактора и скриптов, которое в Unity не требует специального кода, работает в Unreal через генерацию кода. Этот специальный код Unreal генерирует при сборке. Чтобы редактор мог показать свойства нашего объекта, мы делаем специальные обёртки: `UCLASS`, `GENERATED_BODY` и `UPROPERTY`. Также мы декорируем свойства и описываем, как редактор должен с ними работать. Например, ***EditDefaultsOnly*** означает, что мы можем изменить свойства только дефолтного объекта, blueprint class’а (**prefab**’а, если провести аналогию с Unity). Свойства могут быть сгруппированы в разные категории. Это позволяет быстрее найти интересующие нас свойства объекта.
Функция `OnImpact` — аналог `OnCollisionEnter` в Unity. Но для работы с ней требуется подписаться на события компонента `USphereComponent` в конструкторе или даже во время игры. Это не работает автоматически, как в Unity, зато здесь есть возможность оптимизации. Если нам больше не нужно реагировать на столкновения, мы можем отписаться от события.
Блупринты (Blueprint)
---------------------
Типичное действие после создания C++ класса в Unreal — создание на его основе `Blueprint Class`’а. Это расширение объекта, которое нам предоставляет Unreal. Система Blueprint’ов в Unreal используется для визуального программирования. Мы можем создавать визуальные схемы, соединять события с какими-то реакциями на них. Через блупринты движок упрощает взаимодействие программистов и дизайнеров. Мы можем написать на С++ часть игровой логики и предоставить доступ к ней дизайнерам.
При этом Unreal позволяет отделить, если требуется, C++ исходники проекта от его бинарников и контента. Дизайнеры или аутсорсеры могут работать с собранными dll-библиотеками и никогда не узнают, что происходит внутри C++ части проекта. Это дополнительная степень свободы, предоставляемая движком.
Unreal хорош тем, что в нём практически всё связано с Blueprint’ами. Мы можем расширять ими С++ классы, создавать из них Blueprint-наследников и т. д. Эта система тесно связана со всеми компонентами движка, от его внутренней логики до визуальных компонентов, collision, анимации и т. д.
В Unity есть схожие системы визуального программирования, например [Antares Universe](https://www.assetstore.unity3d.com/en/#!/content/1566). Они не входят в состав движка и созданы поверх него, поэтому в любой момент что-то может сломаться (например, при обновлении версии движка). Система визуального скриптования в Unity не предусмотрена. На мой взгляд, это серьёзный недостаток по сравнению с Unreal. Ведь благодаря таким системам даже далекие от программирования люди могут составить схему взаимодействия объектов или связать какую-то последовательность действий. К слову, в Unreal все шаблоны проектов имеют две версии: как на основе C++ кода, так и целиком на Blueprint’ах. Таким образом, создать простой проект без использования кода, целиком на блупринтах — вполне реально.
Демка шутера (UShooter)
-----------------------
В Unity мы пишем демку с нуля, а в Unreal опираемся на шаблоны. В шаблоне выберем управление и вид камеры, и Unreal сгенерирует проект с указанными настройками. Это хорошая основа, от которой вы можете отталкиваться для ускорения разработки и создания прототипа проекта.
Поверх шаблона Side Scroller мы добавляем собственный интерфейс (HUD), бочки, несколько видов оружия и звуки. Дадим игроку ракетницу и railgun, пусть героически стреляет по взрывающимся бочкам.
Система ввода (Unity)
---------------------
Управлять персонажем будем с помощью системы ввода. В Unity мы обычно настраиваем ввод через **Input Manager**, создаём виртуальные именованные оси. Например, «идти вперёд» или «стрелять». Даём им имена и потом получаем значение какой-либо оси или состояние виртуальной кнопки. Обычно скрипты, которые занимаются управлением объектами, получают состояние осей в функции `Update`. В каждом кадре опрашивается состояние оси и целого ряда кнопок управления.
Система ввода (UE4)
-------------------
В Unreal тоже есть виртуальные оси, но там есть разделение на собственно оси (значения, полученные от джойстика, и т.п.) и кнопки действия. В отличие от Unity, мы привязываем оси и кнопки к функциям класса, который реализует управление персонажем. Связь создаётся через компонент `UInputComponent`. Такой компонент ввода есть у класса персонажа `ACharacter`.
Вызовом `BindAxis("MoveRight", this, &AUShooterCharacter::MoveRight)` в **Input Component** мы привязываем нажатие кнопки MoveRight к вызову одноимённой функции движения. Не требуется каждый кадр заниматься опросом кнопки.
Также в Unreal не ограничено количество альтернативных кнопок. В Unity в Input Manager есть только основная кнопка и альтернативная. Чем больше устройств ввода в вашей игре, тем острее может быть эта проблема.
Работа с 3D-моделями
--------------------
Как уже говорилось, в Unreal мы не видим в сцене структуру скелета персонажа. Дело в том, что компоненты скелета не являются Actor’ами или чем-то подобным. Это внутренние свойства скелета и анимации. Как тогда привязать к персонажу оружие или скрыть одну из его частей? Может, мы хотим надеть на него модную кепку или привязать оружие к руке.
В Unity мы выделим модель оружия в редакторе, перетащим в нужную кость, можем даже повесить на него отдельный скрипт управления. В Unreal мы будем пользоваться сокетами (Socket) — точками крепления на игровых объектах. Сокеты — это часть скелета в моделях со скелетной анимацией (в Unity такие модели называются **Skinned Mesh**, в Unreal’е — **Skeletal Mesh**). Также сокеты можно добавлять в статические меши (**Static Mesh**).
Выбираем кость, к которой крепится сокет, и задаём имя сокета, например **`S_Weapon`**, если к точке крепится оружие. После создания сокета можно создать («заспаунить») объект в позиции этого сокета или привязать его к сокету через механизм привязки (функции `AttachTo`). Система немного запутанная, в отличие от Unity, зато более универсальная. Мы можем один раз настроить названия точек, тем самым отделив игровую логику от настроек моделей. Причём если у нас имеется несколько моделей с одним скелетом, то сокеты надо будет добавить только в скелет. В демке шутера сокеты используются при создании снарядов и эффектов выстрела.
Система анимации (Unity)
------------------------
У нас есть персонаж, мы знаем, как работать с вводом, теперь нужно проигрывать анимацию. В Unity для этого есть **Animation Controller**, в нём мы описываем определённые состояния персонажа. Например, бежать, прыгать или умереть. Каждому блоку соответствует свой анимационный клип, и мы настраиваем такой граф переходов:
Хотя эта схема называется **Animation Controller**, внутренней логики у неё нет. Это просто схема переключения анимации в зависимости от состояния. Чтобы она работала, мы заранее объявляем в этом контроллере названия переменных, соответствующих состоянию персонажа. Скрипт, управляющий анимацией, зачастую сам передаёт эти состояния контроллеру каждый кадр.
В переходах между состояниями (на схеме показаны стрелочками) мы настраиваем условия переходов. Можно настроить смешивание (crossfade) анимации, т. e. время, в течение которого одна анимация затухнет, а другая продолжится, для их плавного совмещения.
Система анимации (UE4)
----------------------
В Unreal всё сделано Blueprint’ами, анимация не исключение. Создаём `Animation Blueprint`, который будет управлять анимацией. Он тоже представляет собой граф состояний. Так выглядит машина состояний, она управляет финальной анимацией персонажа в зависимости от движения или состояния смерти.
Тут мы видим уже знакомые нам состояния **Idle/Run, Jump, Dead**. Но один узел совмещает в себе **Idle** и **Run**. Внутри него находится так называемый **Blend Space 1D**, он используется для плавного перехода анимации в зависимости от значения одной или нескольких переменных. С помощью **Blend Space** можно привязать скорость персонажа к переходу между анимацией **Idle** и **Run**. Кроме того, получится настроить несколько точек перехода. Например, от нуля до метра в секунду персонаж идёт медленно — это будет движение, интерполированное между анимацией **Idle** и **Walk**. А после некоторого порогового значения включается бег (**Run**). И всё это будет в одном узле Animation Blueprint’а, который обращается к **Blend State**.
Стрелочками показаны переходы между состояниями, но, в отличие от Unity, мы можем создать Blueprint, реализующий внутреннюю логику работы этих переходов. В **Animation Blueprint** есть доступ к персонажу, на котором он используется, поэтому Blueprint сам обращается к его параметрам (скорость движения и т. п.). Это можно рассматривать как дополнительную оптимизацию, так как позволяет не рассчитывать параметры, которые не используются для текущего состояния персонажа.
В Unreal существует множество инструментов для анимации. **Montage** представляет собой подсистему и редактор, который позволяет совмещать анимационные клипы и их фрагменты.
Тут представлено совмещение машины состояний движения с анимацией атаки, которую мы проигрываем через инструмент **Montage**.
В нижней части рисунка — фрагмент схемы **Animation Blueprint**, который отвечает за реакцию на выстрел из оружия. Команда **Montage Play** включает анимацию выстрела, затем **Delay** ждёт, пока она закончится, и анимация выключается командой **Montage Stop**. Так сделано, потому что в машине состояний анимации мы не можем задать однократное проигрывание анимационного клипа. Если анимация зациклена и соответствует какому-то состоянию персонажа, мы можем управлять анимацией через машину состояний. А если требуется проиграть один клип анимации по событию, то можем сделать через **Montage**.
Проблема вложенных Prefab’ов
----------------------------
Большая проблема в Unity — вложенные **prefab**’ы. На случай, если проблема вам не знакома, рассмотрим пример.
Предположим, объект «стол с ноутбуком» сохранили в prefab table1, а затем понадобился второй подобный объект, но уже с зелёным цветом экрана ноутбука. Создаём новый prefab — table2, перетаскиваем в него старый ноутбук, меняем цвет экрана на зелёный, сохраняем. В результате table2, второй prefab, становится совершенно новым объектом, у него нет никаких ссылок на оригинал. Если мы поменяем исходный префаб, это никак не отразится на втором префабе. Простейший случай, но даже он не поддерживается движком.
В Unreal, благодаря наследованию **Blueprint**’ов, такой проблемы нет: изменение исходного объекта отразится на всех дочерних объектах. Это пригодится не только для игровых объектов, персонажей, какой-то логики или даже статических объектов на сцене, но и для системы интерфейсов.
С другой стороны, можно попытаться победить эту проблему в Unity, используя ассеты в Asset Store. В Unity есть плагины, расширения движка, которые так и называются — [Nested Prefabs](https://www.assetstore.unity3d.com/en/#!/content/72007). Существует несколько подобных систем, но они немного костыльные, сделаны поверх движка, поддержки нет. Они пытаются сохранить в себе внутреннее состояние объекта. Когда запускается игровая сцена, они пробуют восстановить внутренние структуры, их поля, свойства и т. д., удаляют устаревшие объекты в сцене и заменяют их экземплярами из префабов. В результате мы получаем не только удобство вложенных префабов, но и ненужные тормоза, лишнее копирование данных и создание объектов. А если что-то в движке поменяется, то эти системы могут и вовсе отвалиться по неизвестным причинам.
Системы UI
----------
В Unity нельзя сохранить в **prefab** элементы окон или какие-то виджеты. Можем попытаться, но возникнет та же самая проблема префабов: движок забудет о старых объектах. Поэтому зачастую в Unity мы создаём элементы управления, добавляем скрипты и потом их копируем, не создавая prefab. Если приходится добавлять в такие «виджеты» что-то новое, требуемые изменения нужно повторять вручную.
В Unreal мы можем сохранить элементы интерфейса в виджеты (Widget Blueprint), быстро сделать на основе одних элементов управления новые. Cделали кнопку и надпись, пусть это будет наш status bar widget. На основе стандартных и новых виджетов получается быстро и удобно строить окна интерфейса. К слову, виджеты также расширяются за счет Blueprint’ов, можно описать логику их работы на визуальных схемах.
В Unreal система редактирования интерфейсов и всех виджетов открывается в отдельной вкладке редактора. В Unity интерфейс редактируется через специальный объект **Canvas**, расположенный прямо в 3D-сцене и зачастую даже мешающий её редактировать.
Преимущества и недостатки
-------------------------
Для новичка значительно проще движок Unity, у него устоявшееся сообщество, множество готовых решений. Можно расширять редактор скриптами, добавлять новые меню, расширять инспектор свойств и т. п.
В Unreal тоже можно написать для редактора свои окна и инструменты, однако это чуть сложнее, так как надо делать плагин, и это тема для отдельной статьи. Это посложнее, чем в Unity, здесь нельзя написать маленький скрипт, чтобы появилась полезная кнопка, расширяющая функционал редактора.
Из плюсов Unreal стоит отметить визуальное программирование, наследование blueprint’ов, виджеты UI, систему анимации с множеством возможностей и многое другое. Кроме того, в Unreal Engine 4 существует целый набор классов и компонентов, рассчитанных на создание игр: [Gameplay Framework](https://docs.unrealengine.com/latest/INT/Gameplay/Framework/). Gameplay Framework является частью движка, на нём созданы все шаблоны проектов. Классы Gameplay Framework открывают множество возможностей — от описания игровых режимов (**Game Mode**) и состояния игрока (**Player State**) до сохранения игры (**Save Game**) и управления персонажами (**Player Controller**). Особенная фича движка — продвинутая сетевая подсистема, выделенный (dedicated) сервер и возможность запуска сетевой игры в редакторе.
Заключение
----------
Мы сравнили движки Unity 5 и Unreal Engine 4 на конкретных примерах и проблемах, с которыми вы можете столкнуться, начав работу с движком Unreal. Часть сложностей, присущих Unity, решена в Unreal Engine 4. Конечно, невозможно в одном докладе сделать всесторонний обзор этих технологий в полной мере. Однако мы надеемся, что данный материал поможет вам в изучении движка. | https://habr.com/ru/post/327520/ | null | ru | null |
# Микросервисная архитектура, Spring Cloud и Docker
Привет, Хабр. В этой статье я кратко расскажу о деталях реализации микросервисной архитектуры с использованием инструментов, которые предоставляет Spring Cloud на примере простого концепт-пруф приложения.
Код доступен для ознакомления [на гитхабе](http://github.com/sqshq/PiggyMetrics). Образы опубликованы на докерхабе, весь зоопарк стартует одной командой.
За основу я взял старый забытый проект, бэкенд которого представлял из себя монолит. Приложение позволяет организовать личные финансы: вносить регулярные доходы и расходы, следить за накоплениями, считать статистику и прогнозы.
Функциональные сервисы
======================
Попробуем декомпозировать монолит на несколько основных микросервисов, каждый из которых будет отвечать за определенную бизнес-задачу.
### Account service
Реализует логику и валидацию по сохранению доходов, расходов, накоплений и настроек аккаунта.
| Метод | Путь | Описание | Пользователь авторизован | Доступно из UI |
| --- | --- | --- | --- | --- |
| GET | /accounts/{account} | Получить данные указанного аккаунта | | |
| GET | /accounts/current | Получить данные текущего аккаунта | × | × |
| GET | /accounts/demo | Получить данные демо аккаунта | | × |
| PUT | /accounts/current | Сохранить данные текущего аккаунта | × | × |
| POST | /accounts/ | Зарегистрировать новый аккаунт | | × |
### Statistics service
Производит расчет основных статистических параметров аккаунта, приводит их значения к базовой валюте и периоду, сохраняет данные в виде, удобном для последующего анализа. Полученный временной ряд будет использован для отображения пользователю статистики и показателей за прошедшее время и экстраполяции для простейших прогнозов на будущее.
| Метод | Путь | Описание | Пользователь авторизован | Доступно из UI |
| --- | --- | --- | --- | --- |
| GET | /statistics/{account} | Получить статистику указанного аккаунта | | |
| GET | /statistics/current | Получить статистику текущего аккаунта | × | × |
| GET | /statistics/demo | Получить статистику демо аккаунта | | × |
| PUT | /statistics/{account} | Создать/обновить дата-поинт для
указанного аккаунта | | |
### Notification service
Хранит настройки уведомлений (частоты напоминаний, периодичность бекапов). По расписанию производит рассылку e-mail сообщений, предварительно собирая и агрегируя нужные данные у первых двух сервисов, если требуется.
| Метод | Путь | Описание | Пользователь авторизован | Доступно из UI |
| --- | --- | --- | --- | --- |
| GET | /notifications/settings/current | Получить настройки нотификаций
для текущего аккаунта | × | × |
| PUT | /notifications/settings/current | Сохранить настройки нотификаций
для текущего аккаунта | × | × |
#### Примечания
* Все микросервисы имеют свою собственную БД, соответственно любой доступ к данным можно получить только через API приложения.
* В этом проекте для простоты я использовал только MongoDB как основную БД для каждого из сервисов. На практике может оказаться полезным подход, называемый [Polyglot persistence](http://martinfowler.com/bliki/PolyglotPersistence.html) — выбор хранилища, наиболее подходящего для задач конкретного сервиса.
* Коммуникация между сервисами также существенно упрощена: используются только синхронные rest-запросы. Общепринятой практикой является комбинирование различных способов взаимодействия. Например, синхронные GET-запросы для получения информации и асинхронные запросы с использованием сервера очередей — для create/update операций. Что, кстати, переносит нас в мир [eventual consistency](http://martinfowler.com/articles/microservice-trade-offs.html#consistency) — один из важных аспектов распределенных систем, с которым приходится жить.
Инфраструктурные сервисы
========================
Для обеспечения совместной работы описанных выше сервисов будем использовать набор основных паттернов и практик Микросервисной архитектуры. Многие из них реализованы в [Spring Cloud](http://projects.spring.io/spring-cloud/) (в частности, посредством интеграции с продуктами [Netflix OSS](https://github.com/Netflix)) — на деле это зависимости, расширяющие возможности Spring Boot в ту или иную сторону. Ниже кратко рассмотрен каждый из компонентов.
Config Server
-------------
[Spring Cloud Config](http://cloud.spring.io/spring-cloud-config/spring-cloud-config.html) — это горизонтально масштабируемое хранилище конфигураций для распределенной системы. В качестве источника данных на данный момент поддерживаются Git, Subversion и простые файлы, хранящиеся локально. По умолчанию Spring Cloud Config отдает файлы, соответствующие имени запрашивающего Spring приложения (но можно забирать проперти под конкретный Spring profile и из определенной ветки системы контроля версий).
На практике наибольший интерес представляет загрузка конфигураций из систем котроля версий, но здесь для простоты будем использовать локальные файлы. Поместим дирректорию `shared` в класспасе приложения, в которой будут хранится конфигурационные файлы для всех приложений в кластере. Например, если Notification service запросит конфигурацию, Config server ответит ему содержимым файла `shared/notification-service.yml`, смердженным с `shared/application.yml` (который является общим для всех).
На стороне клиентского приложения теперь не требуются никаких конфигурационных файлов, кроме `bootstrap.yml` с именем приложения и адресом Config server:
```
spring:
application:
name: notification-service
cloud:
config:
uri: http://config:8888
fail-fast: true
```
Spring Cloud Config позволяет изменять конфигурацию динамически. Например, бин [EmailService](https://github.com/sqshq/PiggyMetrics/blob/master/notification-service/src/main/java/com/piggymetrics/notification/service/EmailServiceImpl.java), помеченный аннотацией `@RefreshScope`, может начать рассылать измененный текст e-mail сообщения без пересборки.
Для этого следует внести правки в конфигурационный файл Config server, а затем выполнить следующий запрос к `Notification service`:
```
`curl -H "Authorization: Bearer #token#" -XPOST http://127.0.0.1:8000/notifications/refresh`
```
Этот процесс [можно автоматизировать](http://cloud.spring.io/spring-cloud-config/spring-cloud-config.html#_push_notifications_and_spring_cloud_bus), если использовать загрузку конфигураций из систем контроля версий, настроив вебхук из Github, Gitlub или Bitbucket.
Примечания
* К сожалению, есть существенные ограничения на динамическое обновление конфигурации. `@RefreshScope` не работает для `@Configuration` классов и методов, отмеченных аннотацией `@Scheduled`
* Свойство `fail-fast`, упомянутое в `bootstrap.yml` означает, что приложение остановит загрузку сразу же, если нет соединения с Config Server. Это пригодится нам при одновременном старте всей инфраструктуры.
* Продвинутые настройки безопасности выходят за рамки этого концепт-пруф приложения. Spring Security предоставляет широкие возможности для реализации механизмов обеспечения безопасности. Использование JCE keystore для шифрования паролей микросервисов и информации в конфигурационных файлах подробно [описаны в документации](http://cloud.spring.io/spring-cloud-config/spring-cloud-config.html#_security).
Auth Server
-----------
Обязанности по авторизации полностью вынесены в отдельное приложение, которое выдает OAuth2 токены для доступа к ресурсам бэкенда. Auth server используется как для авторизации пользователей, так и для защищенного общения сервис-сервис внутри периметра.
На самом деле, здесь описан только один из возможных подходов. Spring Cloud и Spring Security позволяют достаточно гибко настраивать конфигурацию под ваши нужды (например, имеет смысл проводить авторизацию на стороне API Gateway, а внутрь инфраструктуры передавать запрос с уже заполненными данными пользователя).
В этом проекте я использую `Password credential` grant type для авторизации пользователей и `Client credentials` grant type — для авторизации между сервисами.
Spring Cloud Security предоставляет удобные аннотации и автоконфигурацию, что позволяет достаточно просто реализовать описанный функционал как со стороны клиента, так и со стороны авторизационного сервера.
Со стороны клиента это ничем не отличается от традиционной авторизации с помощью сессий. Из запроса можно получить объект `Principal`, проверить роли и другие параметры с использованием аннотации `@PreAuthorize`.
Кроме того, каждое OAuth2-приложение имеет `scope`: для бэкенд-сервисов — `server`, для браузера — `ui`. Так мы можем ограничить доступ к некоторым эндпоинтам извне:
```
@PreAuthorize("#oauth2.hasScope('server')")
@RequestMapping(value = "accounts/{name}", method = RequestMethod.GET)
public List getStatisticsByAccountName(@PathVariable String name) {
return statisticsService.findByAccountName(name);
}
```
API Gateway
-----------
Все три основных сервиса, которые мы обсудили выше, предоставляют для внешнего пользователя некоторый API. В промышленных системах, построенных на Микросервисной архитектуре, число компонентов растет быстро — [поговаривают](http://highscalability.com/amazon-architecture), что в Амазоне в рендеринг страницы вовлечены порядка 150 сервисов.
Гипотетически, клиентское приложение могло бы запрашивать каждый из сервисов самостоятельно. Но такой подход сразу натыкается на массу ограничений — необходимость знать адрес каждого эндпоинта, делать запрос за каждым куском информации отдельно и самостоятельно мерджить результат. Кроме того, не все приложения не бэкенде могут поддерживать дружественные вебу протоколы, и прочее прочее.
Для решения такого рода проблем применяют API Gateway — единую точку входа. Ее используют для приема внешних запросов и маршрутизации в нужные сервисы внутренней инфраструктуры, отдачи статического контента, аутентификации, стресс тестирования, канареечного развертывания, миграции сервисов, динамического управления трафиком. У Netflix если [блог-пост](http://techblog.netflix.com/2013/01/optimizing-netflix-api.html) об оптимизации своего API за счет асинхронной аггрегации контента из разных микросервисов.
Netflix заопенсорсила свою имплементацию API Gateway — [Zuul](http://techblog.netflix.com/2013/06/announcing-zuul-edge-service-in-cloud.html). Spring Cloud нативно интегрирован с ним и включается добавлением одной зависимости и аннотациии `@EnableZuulProxy` в Spring Boot приложение. В этом проекте Zuul используется для самых элементарных задач — отдачи статики (веб-приложение) и роутинга запросов.
Пример префиксной маршрутизации для Notification service:
```
zuul:
routes:
notification-service:
path: /notifications/**
serviceId: notification-service
stripPrefix: false
```
Теперь каждый запрос, uri которого начинается на `/notifications`, будет направлен в соответствующий сервис.
Service discovery
-----------------
Еще один широко известный паттерн для распределенных систем. Service discovery позволяет автоматически определять сетевые адреса для доступных инстансов приложений, которые могут динамически изменяться по причинам масштабирования, падений и обновлений.
Ключевым звеном здесь является Registry service. В этом проекте я использую Netflix Eureka (но есть еще Consul, Zookeeper, Etcd и другие). Eureka — пример client-side discovery паттерна, что означает клиент должен запросить адреса доступных инстансов и осуществлять балансировку между ними самостоятельно.
Чтобы превратить Spring Boot приложение в Registry server, достаточно добавить зависимость на `spring-cloud-starter-eureka-server` и аннотацию `@EnableEurekaServer`. На стороне клиентов — зависимость `spring-cloud-starter-eureka`, аннотацию `@EnableDiscoveryClient` и имя приложения (serviceId) в `bootstrap.yml`:
```
spring:
application:
name: notification-service
```
Теперь инстанс приложения при старте будет регистрироваться в Eureka, предоставляя мета-данные (такие как хост, порт и прочее). Eureka будет принимать хартбит-сообщения, и если их нет в течении сконфигурированного времени — инстанс будет удален из реестра. Кроме того, Eureka предоставляет дашборд, на котором видны зарегистрированные приложения с количеством инстансов и другая техническая информация: `http://localhost:8761`
Клиентский балансировщик, Предохранитель и Http-клиент
------------------------------------------------------
Следующий набор инструментов тоже разработан в Netflix и нативно интегрирован в Spring Cloud. Все они работают совместно и используются в микросервисах, которым нужно общаться с внешним миром или внутренней инфраструктурой.
### Ribbon
Ribbon — это client-side балансировщик. По сравнению с традиционным, здесь запросы проходят напрямую по нужному адресу, что исключает лишний узел при вызове. Из коробки он интегрирован с механизмом Service Discovery, который предоставляет динамический список доступных инстансов для балансировки между ними.
### Hystrix
Hystrix — это имплементация паттерна [Circuit Breaker](http://martinfowler.com/bliki/CircuitBreaker.html) — предохранителя, который дает контроль над задержками и ошибками при вызовах по сети. Основная идея состоит в том, чтобы остановить каскадный отказ в распределенной системе, состоящей из большого числа компонентов. Это позволяет отдавать ошибку как можно быстрее, не задерживаясь при запросе к зависшему сервису, давая ему восстановиться.
Помимо контроля за размыканием цепи, Hystrix позволяет определить fallback-метод, который будет вызван при неуспешном вызове. Тем самым можно отдавать дефолтный ответ, сообщение об ошибке, и др.
На каждый запрос Hystrix генерирует набор метрик (таких как скорость выполнения, результат), что позволяет анализировать общее состоянее системы. Ниже будет рассмотрен мониторинг на основе данных метрик.
### Feign
Feign — простой и гибкий http-клиент, который нативно интегрирован с Ribbon и Hystrix. Проще говоря, имея в класспасе зависимость `spring-cloud-starter-feign` и активировав клиент аннотацией `@EnableFeignClients`, вы получаете полный набор из балансировщика, предохранителя и клиента, готовый к бою с разумной дефолтной конфигурацией.
Вот пример из Account Service:
```
@FeignClient(name = "statistics-service")
public interface StatisticsServiceClient {
@RequestMapping(method = RequestMethod.PUT, value = "/statistics/{accountName}", consumes = MediaType.APPLICATION_JSON_UTF8_VALUE)
void updateStatistics(@PathVariable("accountName") String accountName, Account account);
}
```
* Все что нужно — объявить интерфейс
* Как обычно, мы просто указываем имя сервиса (благодаря механизму Service Discovery), но конечно можно обращаться и к произвольному url
* `@RequestMapping` вместе с содержимым можно оставлять единой для `@FeignClient` и `@Controller` в Spring MVC
Панель мониторинга
------------------
Метрики, которые генерит Hystrix, можно отдавать наружу, включив в класспас зависимость `spring-boot-starter-actuator`. Помимо прочих [интересных вещей](https://docs.spring.io/spring-boot/docs/current/reference/html/production-ready-endpoints.html), будет выставлен специальный эндпоинт — `/hystrix.stream`. Этот стрим можно визуализировать с помощью Hystrix dashboard, о котором мы подробно поговорим ниже. Для включения Hystrix Dashboard понадобится зависимость `spring-cloud-starter-hystrix-dashboard` и аннотация `@EnableHystrixDashboard`. Hystrix Dashboard можно натравить на стрим любого микросервиса для наблюдения живой картины происходящего в этом конкретном сервисе.
Однако в нашем случае сервисов несколько, и было бы здорово видеть все их метрики в одном месте. Для этого существует специальное решение. Каждый из наших сервисов будет пушить свои стримы в AMQP брокер (RabbitMQ), откуда аггрегатор стримов, Turbine, будет преобразовывать их, выставляя единый эндпоинт для Hystrix Dashboard.
Рассмотрим поведение системы под нагрузкой: Account service вызывает Statistics Service, и тот отвечает с варьируемой имитационной задержкой. Пороговое значение времени запроса установлено в 1 секунду.
| | | | |
| --- | --- | --- | --- |
| `задержка 0 мс` | `задержка 500 мс` | `задержка 800 мс` | `задержка 1100 мс` |
| Система работает без ошибок. Пропускная способность порядка 22 з/с. Небольшое число активных потоков в Statistics service. Среднее время получения ответа —
50 мс. | Число активных потоков увеличивается. Фиолетовая цифра показывает число отклоненных запросов, соответственно порядка 30-40% ошибок, но цепь все еще замкнута. | Полуоткрытое состояние: процент ошибок более 50%, предохранитель размыкает цепь. После определенного таймаута, цепь замыкается, но снова ненадолго. | 100% запросов с ошибками. Цепь разомкнута постоянно, попытки пропустить запрос спустя таймаут ничего не меняют — каждый отдельный запрос слишком медленный. |
Анализ логов
============
В инфраструктуре, состоящей из большого количества движущихся частей (каждая из которых может иметь по нескольку экземпляров), очень важно использовать систему централизированного сбора, обработки и анализа логов. Elasticsearch, Logstash и Kibana составляют стeк, с помощью которого можно эффективно решать такую задачу.
Готовая к запуску Docker-конфигурация ELK с Куратором и шаблонами для шипперов [доступна на гитхабе](https://github.com/sqshq/ELK-docker). Именно такая конфигурация, с небольшой кастомизацией и масштабированием, успешно работает в продакшене на моем текущем проекте для анализа логов, сетевой активности и мониторинга производительности серверов.
[](https://github.com/sqshq/ELK-docker)
*Картинка с официального сайта Elastic, просто для примера*
Автоматизация инфраструктуры
============================
Развертывание микросервисной системы с большим количеством движущихся частей и взаимосвязанностью — задача очевидно более комплексная, нежели деплой монолитного приложения. Без автоматизированной инфраструктуры вся история превратится в бесконечную боль и трату времени. Это тема для совершенно отдельного разговора, я лишь покажу простейший Сontinuous delivery воркфлоу, реализованный в этом проекте на бесплатных версиях сервисов:
Последний этап — это образно, продакшена для проекта не предполагается.
К корне репозитория находится [.travis.yml](https://github.com/sqshq/PiggyMetrics/blob/master/.travis.yml) файл с указаниями для CI сервера — что делать после удачной сборки. В данной конфигурации на каждый успешный пуш в Github, Travis CI соберет докер-образы, пометит их тегом и запушит в Docker Hub. Теперь получается, что у нас всегда есть готовые к деплою контейнеры, помеченные тегом `latest`, а также контейнеры со старыми версиями, версиями из любых веток.
Запуск
------
Если вы дочитали до этого места, возможно вам будет интересно запустить все это своими руками. Хочу отметить, что инфраструктура состоит из 8 Spring Boot приложений, 4 инстансов MongoDB и одного RabbitMQ. Убедитесь, что в системе доступны 3-4 Гб памяти. Всегда можно запустить ограничиться самым необходимым функционалом — отказаться от Statistics service, Notification Service и Monitoring.
#### Прежде чем начать
* Установите Docker и Docker Compose
* Экспортируйте переменные окружения: `CONFIG_SERVICE_PASSWORD`, `NOTIFICATION_SERVICE_PASSWORD`, `STATISTICS_SERVICE_PASSWORD`, `ACCOUNT_SERVICE_PASSWORD`, `MONGODB_PASSWORD`
#### Production mode
В этом режиме все предварительно собранные образы загружаются из центрального репозитория (в данном случае Docker Hub), порты проброшены наружу докера только для API Gateway, Service Discovery, Monitoring и RabbitMQ management. Все что вам понадобится — это docker-compose файл и команда `docker-compose up -d`.
**docker-compose.yml**
```
version: '2'
services:
rabbitmq:
image: rabbitmq:3-management
restart: always
ports:
- 15672:15672
logging:
options:
max-size: "10m"
max-file: "10"
config:
environment:
CONFIG_SERVICE_PASSWORD: $CONFIG_SERVICE_PASSWORD
image: sqshq/piggymetrics-config
restart: always
logging:
options:
max-size: "10m"
max-file: "10"
registry:
environment:
CONFIG_SERVICE_PASSWORD: $CONFIG_SERVICE_PASSWORD
image: sqshq/piggymetrics-registry
restart: always
ports:
- 8761:8761
logging:
options:
max-size: "10m"
max-file: "10"
gateway:
environment:
CONFIG_SERVICE_PASSWORD: $CONFIG_SERVICE_PASSWORD
image: sqshq/piggymetrics-gateway
restart: always
ports:
- 80:4000
logging:
options:
max-size: "10m"
max-file: "10"
auth-service:
environment:
CONFIG_SERVICE_PASSWORD: $CONFIG_SERVICE_PASSWORD
NOTIFICATION_SERVICE_PASSWORD: $NOTIFICATION_SERVICE_PASSWORD
STATISTICS_SERVICE_PASSWORD: $STATISTICS_SERVICE_PASSWORD
ACCOUNT_SERVICE_PASSWORD: $ACCOUNT_SERVICE_PASSWORD
MONGODB_PASSWORD: $MONGODB_PASSWORD
image: sqshq/piggymetrics-auth-service
restart: always
logging:
options:
max-size: "10m"
max-file: "10"
auth-mongodb:
environment:
MONGODB_PASSWORD: $MONGODB_PASSWORD
image: sqshq/piggymetrics-mongodb
restart: always
logging:
options:
max-size: "10m"
max-file: "10"
account-service:
environment:
CONFIG_SERVICE_PASSWORD: $CONFIG_SERVICE_PASSWORD
ACCOUNT_SERVICE_PASSWORD: $ACCOUNT_SERVICE_PASSWORD
MONGODB_PASSWORD: $MONGODB_PASSWORD
image: sqshq/piggymetrics-account-service
restart: always
logging:
options:
max-size: "10m"
max-file: "10"
account-mongodb:
environment:
INIT_DUMP: account-service-dump.js
MONGODB_PASSWORD: $MONGODB_PASSWORD
image: sqshq/piggymetrics-mongodb
restart: always
logging:
options:
max-size: "10m"
max-file: "10"
statistics-service:
environment:
CONFIG_SERVICE_PASSWORD: $CONFIG_SERVICE_PASSWORD
MONGODB_PASSWORD: $MONGODB_PASSWORD
STATISTICS_SERVICE_PASSWORD: $STATISTICS_SERVICE_PASSWORD
image: sqshq/piggymetrics-statistics-service
restart: always
logging:
options:
max-size: "10m"
max-file: "10"
statistics-mongodb:
environment:
MONGODB_PASSWORD: $MONGODB_PASSWORD
image: sqshq/piggymetrics-mongodb
restart: always
logging:
options:
max-size: "10m"
max-file: "10"
notification-service:
environment:
CONFIG_SERVICE_PASSWORD: $CONFIG_SERVICE_PASSWORD
MONGODB_PASSWORD: $MONGODB_PASSWORD
NOTIFICATION_SERVICE_PASSWORD: $NOTIFICATION_SERVICE_PASSWORD
image: sqshq/piggymetrics-notification-service
restart: always
logging:
options:
max-size: "10m"
max-file: "10"
notification-mongodb:
image: sqshq/piggymetrics-mongodb
restart: always
environment:
MONGODB_PASSWORD: $MONGODB_PASSWORD
logging:
options:
max-size: "10m"
max-file: "10"
monitoring:
environment:
CONFIG_SERVICE_PASSWORD: $CONFIG_SERVICE_PASSWORD
image: sqshq/piggymetrics-monitoring
restart: always
ports:
- 9000:8080
- 8989:8989
logging:
options:
max-size: "10m"
max-file: "10"
```
#### Development mode
В режиме разработки предполагается строить образы, а не забирать их из репозитория. Все контейнеры выставлены наружу для удобного дебага. Эта конфигурация наследуется от приведенной выше, перезаписывая и расширяя указанные моменты. Запускается командой `docker-compose -f docker-compose.yml -f docker-compose.dev.yml up -d`
**docker-compose.dev.yml**
```
version: '2'
services:
rabbitmq:
ports:
- 5672:5672
config:
build: config
ports:
- 8888:8888
registry:
build: registry
gateway:
build: gateway
auth-service:
build: auth-service
ports:
- 5000:5000
auth-mongodb:
build: mongodb
ports:
- 25000:27017
account-service:
build: account-service
ports:
- 6000:6000
account-mongodb:
build: mongodb
ports:
- 26000:27017
statistics-service:
build: statistics-service
ports:
- 7000:7000
statistics-mongodb:
build: mongodb
ports:
- 27000:27017
notification-service:
build: notification-service
ports:
- 8000:8000
notification-mongodb:
build: mongodb
ports:
- 28000:27017
monitoring:
build: monitoring
```
#### Примечания
Всем Spring Boot приложениям в этом проекте для старта необходим доступный Config Server. Благодаря опции `fail-fast` в `bootstrap.yml` каждого приложения и опции restart: always в докере, контейнеры можно запускать одновременно (они будут автоматически продолжать попытки старта, пока не поднимется Config Server).
Механизм Service Discovery так же требует некоторого времени для начала полноценной работы. Сервис не доступен для вызова, пока он сам, Eureka и клиент не имеют одну и ту же мета-информацию у себя локально — на это требуется 3 хартбита. По умолчанию период времени между хартбитами составляет 30 секунд.
Ссылки по теме
--------------
* [Статьи о микросервисах](http://martinfowler.com/articles/microservices.html) Мартина Фаулера
* [Building Microservices](http://shop.oreilly.com/product/0636920033158.do) Сэма Ньюмана — книга, в деталях охватывающая все основные понятия Микросервисной архитектуры
* Целая [брошюра](https://www.nginx.com/microservices-soa/) с описанием отличий Микросервисов и SOA
* Серия [статей о Микросервисах](https://www.nginx.com/blog/introduction-to-microservices/) в блоге NGINX от Криса Ричардсона, основателя CloudFoundry
* Очень крутой и подробный доклад Кирилла Толкачёва [tolkkv](https://habr.com/en/users/tolkkv/) и Александра Тарасова [aatarasoff](https://habr.com/en/users/aatarasoff/) из Альфа-Лаборатории, в [двух](https://vk.com/videos-46597293?section=all&z=video-46597293_171607640%2Fclub46597293%2Calbum-46597293%2Fpl_-46597293) [частях](https://vk.com/videos-46597293?section=all&z=video-46597293_171607646%2Fclub46597293%2Calbum-46597293%2Fpl_-46597293). О микросервисах, Spring Boot, Spring Cloud, инструментах Netflix OSS, Apache Thrift и многом другом. | https://habr.com/ru/post/280786/ | null | ru | null |
# Kata вызов Wordle JLDD
Kata — это кодовые головоломки, которые помогут вам отточить свои навыки.
-------------------------------------------------------------------------
Мне нравится создавать и решать кодовые ката. Код Ката — это головоломки по программированию, которые помогут вам отточить свои навыки программирования.
Я написал статью под названием «Learn to Kata and Kata to Learn» для книги «[97 вещей, которые должен знать каждый Java-программист](https://www.oreilly.com/library/view/97-things-every/9781491952689/)», и ссылка на статью доступна бесплатно здесь, в [публикации на Medium](https://medium.com/97-things/learn-to-kata-and-kata-to-learn-73c98a69e44c)*.*
Удивительный мир Wordle
-----------------------
Wordle — это очень популярная онлайн игра головоломка, в которой у вас есть шесть шансов угадать слово из пяти букв.
Каждое предположение приводит к изучению того, какие символы соответствуют символам в слове. Вам даются подсказки с помощью цветов, которые сообщают, правильно ли вы вставили букву в правильное положение, если буква находится в слове, но в неправильном положении, или если буква не соответствует какой-либо букве в слове.
Вы можете узнать больше об увлечении Wordle в этой статье.
> [**Wordle explained: Everything you need to know to master the viral word game**](https://www.cnet.com/how-to/wordle-explained-everything-you-need-to-know-about-the-viral-word-game/)
>
> Wordle — это вирусная словесная игра, недавно приобретенная New York Times за несколько миллионов. Но…
>
> [www.cnet.com](https://www.cnet.com/how-to/wordle-explained-everything-you-need-to-know-about-the-viral-word-game/)
>
>
JLDD = Jet Lag Driven Development
----------------------------------
В прежние времена, когда технические конференции и путешествия по миру были обычным явлением, несколько Java чемпионов([Хосе Помар](https://medium.com/u/18673d5e2e01?source=post_page-----b6fb1c89d8eb-----------------------------------), [Нихил Нанивадекар](https://medium.com/u/4285d8a2ca86?source=post_page-----b6fb1c89d8eb-----------------------------------), и я) делились задачами по кодированию в Твиттере, пока мы были на конференциях (обычно JavaOne/Oracle CodeOne).
У всех нас была разная степень смены часовых поясов во время конференций, поэтому мы решили использовать хэштег JLDD (разработка, управляемая сменой часовых поясов), когда публиковали задачи по программированию.
Чаще всего задачи программирования были направлены на решение проблем с Java-коллекциями или потоками. Обычно я размещал решения, используя [Eclipse Collections](https://www.eclipse.org/collections/).
На протяжении всей пандемии мы время от времени делились друг с другом проблемами JLDD в Твиттере, несмотря на то что джетлаг уже давно прекратился. Несколько недель назад я поделился Haiku Kata, используя Java Text Blocks и Eclipse Collections.
> [**Haiku на Java с использованием текстовых блоков**](https://medium.com/javarevisited/haiku-for-java-using-text-blocks-6b7862ccd067)
>
> Творческое письмо в сочетании с текстовыми блоками Java и коллекциями Eclipse
>
> [medium.com](https://medium.com/javarevisited/haiku-for-java-using-text-blocks-6b7862ccd067)
>
>
[Хосе Помар](https://medium.com/u/18673d5e2e01?source=post_page-----b6fb1c89d8eb-----------------------------------) затем сделал все возможное и закодировал задачу JLDD в прямом эфире в 25-минутном видео JEP Cafe # 9. Он проделывает потрясающую работу, объясняя решения Eclipse Collections и Java 17. Отличная работа!
Wordle Ката
-----------
[Хосе Помар](https://medium.com/u/18673d5e2e01?source=post_page-----b6fb1c89d8eb-----------------------------------) на этой неделе мне прислали вызов Wordle Kata JLDD в виде теста, для которого мне нужно было написать код, проходящий этот тест. Мне нравится этот тип ката, который следует классическому стилю TDD с использованием подхода «сначала тест». Выше приведен тестовый код для kata с использованием простых утверждений JUnit 5.
Несколько скрытых слов и соответствующих догадок, которые приводят к некоторому результатуПравила, основанные на этом тесте, довольно просты.
1. Если буква в строке предположения не соответствует букве в скрытом слове, замените символ в выводе на «.»
2. Если буква в строке предположения совпадает с буквой в скрытом слове и буква находится в той же позиции, то замените символ на заглавную букву.
3. Если буква в строке предположения совпадает с буквой в скрытом слове, но буква находится в другой позиции, то замените символ строчной буквой.
4. Если буква совпадает, но появляется в угаданной строке больше раз, чем в скрытом слове, то замените дополнительные символы в выводе на «.».
Мое первое решение с использованием Eclipse Collections
-------------------------------------------------------
Решение, которое я придумал, выглядело следующим образом и прошло все тесты.
Код для угадывания Wordle с использованием коллекций EclipseКод принимает предположение, сравнивает каждую букву со скрытым словом и, если есть прямое совпадение, печатает заглавную букву, в противном случае печатает строчную букву, если есть косвенное совпадение или «.» если нет совпадения или буква является дополнительным совпадающим символом.
Метод `collectWithIndex` типа `CharAdapter` преобразует строку `guessChars` в один символ за раз. Сначала я думал, что никакие `char` значения не будут упакованы как объекты `Character`, но оказалось, что я ошибался.
Метод `collectWithIndex` принимает `CharIntToObjectFunction`, что означает, что значения `char` для каждого выходного символа будут упакованы как объекты `Character`.
Это также означает, что у нас нет чисто примитивной версии `collectWithIndex` в Eclipse Collections, как в случае с `collectChar`. Я думаю, что это, вероятно, приемлемо в большинстве случаев и не должно быть слишком дорогостоящим для этого конкретного сценария использования.
Я не думаю, что добавление чисто примитивной версии с именем `collectCharWithIndex` имело бы смысл.
Однако существует более серьезная проблема, чем упаковка `char` значений в виде `Character` объектов перед созданием выходных данных `String`. Я обнаружил, что отсутствует тестовый пример и дополнительное правило, которое мы должны добавить в ката.
Правило: отдавайте предпочтение прямым совпадениям, а не косвенным.
-------------------------------------------------------------------
Я добавил следующий тестовый пример, который приводит к сбою моего первого решения.
Слово, имеющее прямое совпадение по одной букве, но косвенное совпадение предшествует прямому совпадению.Позвольте мне увеличить масштаб, чтобы вы могли видеть тестовый пример более четко.
Вывод для слова «ббабб» с догадкой «ааааа» должен быть «..А..»В этом случае буква «а» будет иметь прямое совпадение в третьей позиции, но косвенные совпадения в догадке следует игнорировать в пользу прямого совпадения в третьей позиции.
Мое обновленное решение
-----------------------
Для тех, кто меня знает, вы должны знать, что я несколько одержим [обеспечением хорошей симметрии](https://medium.com/oracledevs/finding-symmetry-27944c74b6d4?source=friends_link&sk=064af64192d05112ad00482795405d16) в API Eclipse Collection.
В этом конкретном сценарии использования было бы идеально, если бы существовал эквивалент `selectWithIndex` и `rejectWithIndex`, имеющихся для примитивных типов коллекций в Eclipse Collections. Этот конкретный вариант использования может заставить меня согласиться и добавить недостающие методы.
Однако существует альтернативный метод, который я могу использовать для реализации эквивалента этих двух методов. Это метод `injectIntoWithIndex`.
Вот мое обновленное решение, использующее `injectIntoWithIndex` для создания `CharBag` с оставшимися символами, которые не имеют прямых совпадений.
Решение для угадывания Wordle, которое обрабатывает все правилаЕсли вы хотите понять, как метод `injectIntoWithIndex` работает, вы можете прочитать следующий блог про injectInto ([EC by Example: InjectInto](https://donraab.medium.com/ec-by-example-injectinto-923a35c3b0cd)). Метод injectInto можно использовать для реализации большинства шаблонов итерации, что также относится к `injectIntoWithIndex`. Это одновременно магические и мощные методы.
Обновление: альтернативное решение с использованием zipChar
-----------------------------------------------------------
Иногда, когда вы работаете над одним и тем же кодом в течение 18 лет, вы кое-что забываете. К счастью, друг будет время от времени напоминать вам о вещах, которые вы, возможно, забыли. Это случилось на этой неделе, когда [Vladimir Zakharov](https://medium.com/u/7db07b72520d?source=post_page-----b6fb1c89d8eb-----------------------------------) поделился другим решением для Wordle JLDD Kata в Твиттере, используя метод с именем `zipChar`.
Решение Влада довольно крутое, и это определенно не тот подход, о котором я бы подумал. Я забыл, что `zip` в Eclipse Collections была доступна примитивная версия. Каждый примитивный тип `OrderedIterable` в Eclipse Collections поддерживает `zip` одного и того же типа. Итак, у a `CharAdapter` есть метод `zipChar`.
Вскоре я вспомнил, что был блог, который я написал более четырех лет назад о примитиве `zip`.
Как только я увидел решение Влада, я понял, что могу написать альтернативу своему собственному решению, используя `zipChar` для замены `injectIntoIndex` и `collectWithIndex`.
Wordle Kata с использованием zipChar с reject и collectCharДва решения, которые используют `zipChar`, существенно различаются по алгоритму, который они используют для вычисления окончательного результата строки предположения.
Исходник моего финального решения с Eclipse Collections
-------------------------------------------------------
Я создал свое окончательное решение задачи Wordle Kata JLDD с использованием коллекций Eclipse. Я с нетерпением жду возможности увидеть решение на чистой Java 17 от [Хосе Помар](https://medium.com/u/18673d5e2e01?source=post_page-----b6fb1c89d8eb-----------------------------------).
. Я всегда узнаю от Хосе что-то новое и интересное о Java, чего раньше не знал.
```
import org.eclipse.collections.api.bag.primitive.MutableCharBag;
import org.eclipse.collections.impl.factory.Strings;
import org.eclipse.collections.impl.factory.primitive.CharBags;
import org.eclipse.collections.impl.string.immutable.CharAdapter;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class WordleTest
{
@Test
public void wordleTest()
{
Assertions.assertEquals(".....", new Wordle("aaaaa").guess("bbbbb"));
Assertions.assertEquals("A....", new Wordle("aaaaa").guess("abbbb"));
Assertions.assertEquals(".A...", new Wordle("aaaaa").guess("babbb"));
Assertions.assertEquals("..A..", new Wordle("aaaaa").guess("bbabb"));
Assertions.assertEquals("...A.", new Wordle("aaaaa").guess("bbbab"));
Assertions.assertEquals("....A", new Wordle("aaaaa").guess("bbbba"));
Assertions.assertEquals(".a...", new Wordle("abbbb").guess("caccc"));
Assertions.assertEquals("..a..", new Wordle("abbbb").guess("ccacc"));
Assertions.assertEquals("...a.", new Wordle("abbbb").guess("cccac"));
Assertions.assertEquals("....a", new Wordle("abbbb").guess("cccca"));
Assertions.assertEquals("A....", new Wordle("abbbb").guess("accca"));
Assertions.assertEquals("A....", new Wordle("abbbb").guess("accaa"));
Assertions.assertEquals("A..a.", new Wordle("aabbb").guess("accaa"));
Assertions.assertEquals("AA...", new Wordle("aabbb").guess("aacaa"));
Assertions.assertEquals("...aa", new Wordle("aabbb").guess("cccaa"));
Assertions.assertEquals("..A..", new Wordle("bbabb").guess("aaaaa"));
Assertions.assertEquals("AAAAA", new Wordle("aaaaa").guess("aaaaa"));
Assertions.assertEquals("BRAVO", new Wordle("bravo").guess("bravo"));
}
record Wordle(String string)
{
Wordle(String string)
{
this.string = string.toLowerCase();
}
public String guess(String guess)
{
CharAdapter guessChars = Strings.asChars(guess.toLowerCase());
CharAdapter hiddenChars = Strings.asChars(this.string);
MutableCharBag remaining = hiddenChars
.injectIntoWithIndex(
CharBags.mutable.empty(),
(bag, each, i) -> guessChars.get(i) != each ? bag.with(each) : bag);
return guessChars.collectWithIndex((each, i) -> hiddenChars.get(i) == each ?
Character.toUpperCase(each) : this.replaceDifferentPositionOrNoMatch(remaining, each))
.makeString("");
}
private char replaceDifferentPositionOrNoMatch(MutableCharBag remaining, char each)
{
return remaining.remove(each) ? each : '.';
}
}
}
```
Заключительные соображения
--------------------------
Надеюсь, вам понравился этот блог о моих решениях задачи JLDD Kata с использованием коллекций Eclipse. Я, конечно, был бы рад видеть другие решения этих задач, чтобы мы все могли изучить новые и разные решения задач программирования. Эти решения могут быть на Java с использованием ваших любимых библиотек или даже на другом языке программирования.
Спасибо, что нашли время прочитать! | https://habr.com/ru/post/653191/ | null | ru | null |
# Пять главных итогов Helm Summit 2019 в Амстердаме
***Прим. перев.**: Повышенный интерес к «пакетному менеджеру Kubernetes» — Helm, — что наблюдается в последнее время, легко объяснить. В активной стадии — причём уже не только разработки, но и релизов — находится долгожданное крупное обновление Helm v3, о котором мы [уже писали](https://habr.com/ru/company/flant/blog/453734/). Его последняя бета-версия — [третья по счёту](https://github.com/helm/helm/releases/tag/v3.0.0-beta.3) — вышла в начале сентября. А совсем недавно прошло довольно крупное (для столь специализированного Open Source- проекта) мероприятие, впечатлениями с которого и делятся его посетители из компании CloudARK, предлагающей iPaaS (integration platform as a service) для Kubernetes.*
*Оригинальное фото [взято](https://www.flickr.com/photos/143247548@N03/48746251223/in/album-72157710876124641/) из Flickr-аккаунта CNCF*
На прошлой неделе в Амстердаме прошел [Helm Summit](https://events.linuxfoundation.org/events/helm-summit-2019/program/schedule/). На нем собрались около 150 энтузиастов, представляющих различных пользователей и поставщиков услуг по Kubernetes. Вот пять ключевых моментов с этого мероприятия.
1. В Helm 3.0 — лучшая безопасность, поддержка CRD и некоторые ломающие привычный подход изменения
--------------------------------------------------------------------------------------------------
В саммите принимали участие некоторые из ключевых членов основной команды разработчиков Helm. Из их выступлений и общения в кулуарах стало понятно, что Helm 3.0 станет важной вехой для проекта. Многие из вас, вероятно, уже слышали, что в третьей версии не будет Tiller — серверного компонента Helm. *(**Прим. перев.**: Подробнее об этом можно почитать в [этой статье](https://habr.com/ru/company/flant/blog/453734/).)* В Helm 3.0 появятся и другие важные нововведения — например, более пристальный контроль безопасности и лучшая поддержка Custom Resource Definitions (CRDs). Вот три ключевых аспекта, которые особенно запомнились:
* В области безопасности набор предварительно настроенных разрешений для пользователей по умолчанию будет минимальным. В отличие от Tiller'а, автоматом получавшего права администратора на весь кластер, в Helm 3.0 придется вручную наделять привилегиями пользовательские *(User)* и служебные *(Service)* учетные записи, предназначенные для работы с Helm. Такая перемена гарантирует осознанное принятие решений администраторами о безопасности своих кластеров.
* Второе важное изменение — это расширенная поддержка CRD. В нынешней версии Helm установка CRD осуществляется через хук (hook) `crd-install`, определенный как аннотация. Однако не все разработчики CRD и операторов его используют. Это делает чарты Helm уязвимыми перед ошибками установки, поскольку для правильной установки чартов необходимо, чтобы CRD ставились перед манифестами Custom Resource. В Helm 3.0 поддержка CRD выйдет на новый уровень. В каталоге `chаrts` появится подкаталог `crd`. Пользователю будет достаточно сложить все YAML-файлы CRD в эту директорию. Helm обработает ее перед установкой остальных частей чарта. Подобный порядок действий будет гарантировать установку CRD перед установкой манифестов Custom Resource.
* Серьезные изменения затронут работу с CLI. Например, сейчас в процессе установки чарта генерируется случайное имя релиза, если оно не указано в качестве входного параметра. В Helm 3.0 ситуация будет обратная: параметр с именем станет обязательным. Чтобы сохранить случайное именование релизов, потребуется указывать специальный флаг при вводе команды.
2. Консолидация cloud native-артефактов
---------------------------------------
Несколько сессий были посвящены проблемам хранения Helm-чартов. Эти сессии вел [Josh Dolitsky](https://helmsummit2019.sched.com/event/S8t8/from-chartmuseum-to-harbor-josh-dolitsky-blood-orange?iframe=yes&w=100%&sidebar=yes&bg=no#) — автор [ChartMuseum](https://chartmuseum.com/). Он представил проблему, существующие решения и рассказал об общих веяниях в этом пространстве. Основной вывод состоит в том, что работа с различными артефактами, с которыми приходится иметь дело в подходе cloud-native (образами Docker, чартами Helm, патч-файлами Kustomize), должна вестись единообразно.
Обеспечить хранение всех этих артефактов в едином реестре призван проект [ORAS](https://github.com/deislabs/oras) — OCI Registry as Storage. Для пользователей Kubernetes это определенно шаг в правильном направлении, поскольку он позволит консолидировать различные артефакты в одном реестре, попутно обеспечив поддержку таких вещей, как разделение реестра, контроль доступа и т.п.
3. Helm и операторы
-------------------
Несколько докладчиков затронули в своих выступлениях тему пользовательских контроллеров и операторов. В [выступлении CloudARK](https://helmsummit2019.sched.com/event/S8st/operators-and-helm-it-takes-two-to-tango-devdatta-kulkarni-cloudark?iframe=no&w=100%&sidebar=yes&bg=no) основное внимание было уделено лучшим практикам при создании Helm-чартов для операторов. [Команда Red Hat](https://helmsummit2019.sched.com/event/S8sn/at-the-helm-without-a-steering-wheel-your-chart-as-a-kubernetes-operator-daniel-messer-red-hat?iframe=yes&w=100%&sidebar=yes&bg=no) рассказала об операторах и [Operator Hub](https://operatorhub.io/).
Представители [Workday](https://helmsummit2019.sched.com/event/S8tW/automated-helm-deployment-using-custom-controllers-and-operators-pauline-lallinec-workday?iframe=yes&w=100%&sidebar=yes&bg=no), [Weaveworks](https://helmsummit2019.sched.com/event/S8ti/gitops-continuous-delivery-with-helm-operator-kingdon-barrett-university-of-notre-dame-stefan-prodan-weaveworks?iframe=yes&w=100%&sidebar=yes&bg=no) и [University of Notre Dame](https://helmsummit2019.sched.com/event/S8ti/gitops-continuous-delivery-with-helm-operator-kingdon-barrett-university-of-notre-dame-stefan-prodan-weaveworks?iframe=yes&w=100%&sidebar=yes&bg=no) в своих выступлениях обсудили «родной для Kubernetes» подход к непрерывному согласованию релизов на основе Helm-чартов в кластере с помощью процесса, называемого GitOps. *(**Прим. перев.**: Подробнее о GitOps читайте [здесь](https://habr.com/ru/company/flant/blog/458878/).)*
Ключевым выводом всех этих выступлений стало то, что Helm и операторы хорошо дополняют друг друга. В то время как первый (Helm) фокусируется на шаблонизации и простоте управления артефактами, вторые (операторы) концентрируются на управлении задачами Day-2 *(т.е. на стадии жизненного цикла системы, когда та начинает приносить плоды ее создателям — **прим. перев.**)* для стороннего программного обеспечения, такого как реляционные/нереляционные базы данных, работающие в кластере Kubernetes.
4. Проблемы управления Helm-чартами
-----------------------------------
Когда речь заходит о крупных корпоративных приложениях, одного Helm-чарта недостаточно. Требуются несколько чартов. [Презентация GitLab](https://helmsummit2019.sched.com/event/S8sw/gitlab-as-cloud-native-complex-suite-made-simple-with-helm-jason-plum-gitlab?iframe=yes&w=100%&sidebar=yes&bg=no) стала настоящим открытием в этом смысле. У них множество чартов, при этом средний размер чарта также достаточно велик (несколько тысяч строк). Управление всеми этими чартами само по себе является непростой задачей.
Было два интересных выступления, посвященных различным аспектам этой проблемы. В одном [команда IBM](https://helmsummit2019.sched.com/event/S8se/more-charts-more-problems-lets-talk-bringing-sanity-shikha-srivastava-kirti-apte-ibm?iframe=yes&w=100%&sidebar=yes&bg=no) представила свой внутренний инструмент, упрощающий поиск Helm-чартов по различным критериям. Они сосредоточились на решении проблемы DevOps-инженеров, вынужденных отбирать и устанавливать чарты в своих кластерах. В другом — [команда Replicated](https://helmsummit2019.sched.com/event/S8tZ/day-2-operations-of-helm-charts-dex-horthy-replicated-inc?iframe=yes&w=100%&sidebar=yes&bg=no) рассказала о попытке решить проблему управления правками Helm-чартов без создания копий или форков. Суть их подхода в том, чтобы отделить базовый Helm-чарт, а пользовательские Helm-чарты создавать, позаимствовав идею kustomize с патч-файлами. В будущем мы можем стать свидетелями бурной деятельности в этом направлении по мере того, как различные провайдеры будут концентрироваться на различных аспектах Helm-чартов, влияющих на управление ими. Например, мы в CloudARK [фокусируемся](https://github.com/cloud-ark/kubeplus) на Helm-чартах операторов, которые получают специальные аннотации `platform-as-code` для облегчения обнаружения и повышения простоты использования Custom Resources.
5. Гостеприимное сообщество
---------------------------
Разработчики Helm'а и ключевые члены сообщества оказались весьма приветливыми людьми. Они были открыты и доступны для любых обсуждений и вопросов, таких как сроки выхода, мысли о Helm'е и kustomize'е, совместное проведение мероприятий с KubeCon и т.п.
Также они рассказали о процессе участия в разработке Helm'а. Он не показался слишком сложным. Проект Helm пока еще не принял процесс KEP (Kubernetes Enhancement Proposal). Впрочем, это может измениться после того, как завершится стадия его инкубации.
CloudARK на саммите Helm
------------------------
[Наше выступление](https://static.sched.com/hosted_files/helmsummit2019/ac/Operators-and-Helm-It-takes-two-to-tango.pdf) на саммите было посвящено принципам и лучшим практикам создания Helm-чартов для операторов. Мы предлагаем iPaaS, который позволяет DevOps-командам собирать свои собственные стеки платформы Kubernetes без какой-либо привязки с провайдеру Kubernetes или проприетарным интерфейсам. Необходимые CRD/операторы упаковываются в виде Helm-чартов с особым акцентом на совместимость Custom Resources от различных операторов.
Выступление базировалось на уроках, полученных в процессе самостоятельной разработки нескольких операторов и анализе более чем ста общедоступных операторов с целью получить настраиваемый платформенный слой Kubernetes Native, готовый для корпоративного использования.
Амстердам
---------
Место проведения конференции может похвастаться живописным видом на один из многочисленных каналов Амстердама.
Заключение
----------
Helm стоит на пороге превращения в CNCF-проект высшего уровня. За последние несколько лет он стал более зрелым, обрел крепкое сообщество и высокую популярность. Если вы еще не используете его — попробуйте. Он предлагает один из простейших способов шаблонизации и управления артефактами Kubernetes. У тех же, кто его уже активно использует, Helm 3.0 должен развеять многие опасения, связанные с безопасностью, и обеспечить явную поддержку расширяемости Kubernetes с помощью CRD.
P.S. от переводчика
-------------------
Другие впечатления о прошедшем Helm Summit и его докладам можно найти в Twitter по тегу [#HelmSummit](https://twitter.com/search?q=%23HelmSummit&src=hashtag_click&f=live).
Читайте также в нашем блоге:
* «[KubeCon Europe 2019: Как мы впервые посетили главное событие по Kubernetes](https://habr.com/ru/company/flant/blog/454184/)»;
* «[Знакомство с Helm 3](https://habr.com/ru/company/flant/blog/453734/)»;
* «[Пакетный менеджер для Kubernetes — Helm: прошлое, настоящее, будущее](https://habr.com/ru/company/flant/blog/417079/)»;
* «[Трезвый взгляд на Helm 2: „Вот такой, какой есть...“](https://habr.com/ru/company/flant/blog/438814/)»;
* «[Практическое знакомство с пакетным менеджером для Kubernetes — Helm](https://habr.com/ru/company/flant/blog/420437/)». | https://habr.com/ru/post/468259/ | null | ru | null |
# Квантовая запутанность для чайников
В обсуждениях [недавней темы](http://habrahabr.ru/post/179443/) я заметил несколько сообщений, от людей, которые думают, что «физики договорились» о существовании суперпозиции. Что это просто удобная математическая/физическая модель, не имеющая под собой реальных экспериментов, доказывающих нахождение квантов в суперпозиции. Что кванты, на самом деле находятся всегда в конкретных позициях, а проведение эксперимента, лишь обнаруживает эти позиции. Некоторое время это было спором и у физиков, пока в 1964 году Джон Стюарт Белл не сформулировал свою известную теорему Белла(неравенства Белла), которая в последствии была улучшена другими учеными и неоднократно проверена экспериментально. Для желающих ознакомиться непосредственно с его теоремой, я советую пропустить эту статью, и сразу перейти к прочтению книг, ссылки на которые даны ниже, и в комментариях. Для понимания ее основ не требуются глубокие познания физики и математики. Для тех же, кому даже [статья в Википедии](http://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%80%D0%B0%D0%B4%D0%BE%D0%BA%D1%81_%D0%AD%D0%B9%D0%BD%D1%88%D1%82%D0%B5%D0%B9%D0%BD%D0%B0_%E2%80%94_%D0%9F%D0%BE%D0%B4%D0%BE%D0%BB%D1%8C%D1%81%D0%BA%D0%BE%D0%B3%D0%BE_%E2%80%94_%D0%A0%D0%BE%D0%B7%D0%B5%D0%BD%D0%B0) кажется сложной для понимания, я приведу довольно упрощенную аналогию.
Для простоты, скажем, у кванта есть некоторые 3 характеристики: A, B и C, которые могут принимать значения 1 или 0. Возьмем два запутанных кванта, таких, что:
1) Если при измерении у первого кванта одной из характеристик мы получаем 1, то у другого кванта, эта же характеристика при измерении будет равна 0.
2) Если мы выбираем для сравнения характеристику случайным образом, то в половине случаев мы получаем одинаковые значения, а в половине — разные. (!)
Сперва кажется что выполнить эти два условия очень легко, написав простенькую программу мы можем смоделировать эту ситуацию. НО! Давайте просто проверим это статистически, программно, кто как хочет и может, пусть проведет свое собственное исследование: Поставит такой эксперимент: Создаст N заранее определенных пар троек значений: (1,0,1)-(0,1,0); (1,1,0)-(0,0,1)… итп, далее построит модель, которая будет удовлетворять обоим вышеуказанным пунктам.
Окажется, что это не только непросто сделать, но и в принципе невозможно. Если мы с такими исходными данными будем измерять одинаковые параметры, мы будем получать противоположные значения. Что понятно и согласуется с пунктом 1. Но вот если, мы будем измерять случайные параметры, то *противоположные значения у нас будут появляться в более чем 50% случаев*. Что противоречит пункту 2.
**Небольшой кусок кода на С#, с попыткой написать такую модель**
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication14
{
class Program
{
static void Main(string[] args)
{
int confirm = 0, notconfirm = 0;
Random rnd = new Random();
List> p = new List>();
for (int i = 0; i < 500000; i++)
{
var t = new Tuple(rnd.Next(2) == 1 ? true : false, rnd.Next(2) == 1 ? true : false, rnd.Next(2)==1?true:false);
p.Add(t);
}
for (int i = 0; i < 500000; i++)
{
var t = p[i];
bool first, second;
switch (rnd.Next(3))
{
case 0: first = t.Item1;
break;
case 1: first = t.Item2;
break;
case 2: first = t.Item3;
break;
default:
first = false;
throw new Exception("first error");
}
switch (rnd.Next(3))
{
case 0: second = !t.Item1;
break;
case 1: second = !t.Item2;
break;
case 2: second = !t.Item3;
break;
default:
second = true;
throw new Exception("second error");
}
if (first != second)
confirm++;
else
notconfirm++;
}
Console.WriteLine((double)confirm / (double)(confirm+notconfirm));
Console.ReadKey();
}
}
}
```
А именно, в нашем эксперименте, вероятность обнаружения противоположных значений будет лежать в диапазоне [5/9; 2/3] (0.555;0.667). В самой лучшей модели мы не сможем добиться получения разных результатов в менее чем 55,5% случаев. В то время как в реальности можно поставить подобный эксперимент с квантами, в котором она останется равной 1/2.
Объясняется это очень просто: При наличии «заранее определенных квантов» мы всегда имеем «перевес» его значений в одну сторону. Там либо две единицы, и один ноль, либо два нуля и единица, либо вообще все 3 значения равны или единице или нулю.
Именно этот мысленный эксперимент показал мне, что в мире квантов нет места детерминированным параметрам. Заставил изучить тему подробнее и найти в ней очень много необычного интересного и захватывающего.
P.S. Очень хорошо данный эксперимент был описан в книге Ричарда Фейнмана (надеюсь сообщество подскажет в какой именно, я немного запутался)
P.P.S. Ан-нет, это Брайан Грин «Ткань космоса. Пространство, время и текстура реальности». Вот как раз [этот момент](http://www.physic-in-web.ru/study-115-17.html). Может быть так кому-то станет понятнее.
**Upd1**
Пояснение с математической стороны:
Например 1 квант имеет такие характеристики (1,1,0), а спутанный с ним (0,0,1). Мы, случайно выбираем и измеряем характеристику первого кванта и случайно выбираем и измеряем характеристику второго кванта. При большом числе экспериментов у нас будут результаты всех возможных комбинаций: A1A2,A1B2,A1C2,B1A2,B1B2,B1C2,C1A2,C1B2,C1C2 (9 штук) примерно с одинаковой вероятностью появления каждой.
Теперь, если мы выпишем с нашей пары квантов все комбинации мы получим:
10,10,11,10,10,11,00,00,01. 5 пар разные значения. 4 пары одинаковые. Таким образом мы для подобных квантов будем иметь перевес 5:4 в пользу разных пар.
Для запутанных пар (0,0,0)-(1,1,1) — мы всегда будем получать разные пары.
Имеем 8 вариантов распределения трех двоичных параметров: 000,001,010,100,011,101,110,111.
2/8 из них с тремя одинаковыми значениями, значит запутанная пара всегда будет с противоположными значениями (p=1).
6/8 из них с двумя одинаковыми и одним противоположным значением. 9 различных комбинаций с такими запутанными тройками. Из них 5 — это разные значения, 4-одинаковые. (p=5/9)
Итого, общая вероятность пар с разными значениями: 5/9\*6/8+1\*2/8=2/3 > 1/2
**Upd2**
Хочу выразить отдельное спасибо пользователю [Shkaff](http://geektimes.ru/users/shkaff/), за указание ошибок в первоначальном варианте статьи, и за полезные ссылки в его [комментарии](http://habrahabr.ru/post/181692/#comment_6313686). Статью пришлось немного изменить, но я постарался сохранить первоначальную идею. | https://habr.com/ru/post/181692/ | null | ru | null |
# Добавляем modbus в Embox RTOS и используем на STM32 и не только
Нас часто спрашивают, чем [Embox](http://embox.github.io/) отличается от других ОС для микроконтроллеров, например, FreeRTOS? Сравнивать проекты между собой, конечно, правильно. Но параметры, по которым порой предлагают сравнение, лично меня повергают в легкое недоумение. Например, сколько нужно памяти для работы Embox? А какое время переключения между задачами? А в Embox поддерживается modbus? В данной статье на примере вопроса про modbus мы хотим показать, что отличием Embox является другой подход к процессу разработки.
Давайте разработаем устройство, в составе которого будет работать в том числе modbus server. Наше устройство будет простым. Ведь оно предназначено только для демонстрации modbus, Данное устройство будет позволять управлять светодиодами по протоколу Modbus. Для связи с устройством будем использовать ethernet соединение.
[Modbus](https://en.wikipedia.org/wiki/Modbus) открытый коммуникационный протокол. Широко применяется в промышленности для организации связи между электронными устройствами. Может использоваться для передачи данных через последовательные линии связи RS-485, RS-422, RS-232 и сети TCP/IP (Modbus TCP).
Протокол modbus достаточно простой чтобы реализовать его самостоятельно. Но поскольку любая новая реализация функциональности может содержать ошибки, давайте используем что-нибудь готовое.
Одной из самых популярных реализаций протокола modbus является открытый проект [libmodbus](https://libmodbus.org/). Его и будем использовать. Это позволит сократить время разработки и уменьшить количество ошибок. При этом мы сможем сосредоточиться на реализации бизнес логики, а не на изучении протокола.
Наш проект будем вести в отдельном [репозитории](https://github.com/embox/embox_project_modbus_iocontrol). При желании все можно скачать и воспроизвести самостоятельно.
Разработка прототипа на Linux
-----------------------------
Начнем с разработки прототипа на хосте. Для того чтобы можно было использовать libmodbus в качестве библиотеки его нужно скачать, сконфигурировать и собрать.
Для этих целей я набросал Makefile
```
libmodbus-$(LIBMODBUS_VER).tar.gz:
wget http://libmodbus.org/releases/libmodbus-$(LIBMODBUS_VER).tar.gz
$(BUILD_BASE)/libmodbus/lib/pkgconfig/libmodbus.pc : libmodbus-$(LIBMODBUS_VER).tar.gz
tar -xf libmodbus-$(LIBMODBUS_VER).tar.gz
cd libmodbus-$(LIBMODBUS_VER); \
./configure --prefix=$(BUILD_BASE)/libmodbus --enable-static --disable-shared; \
make install; cd ..;
```
Собственно из параметров конфигурации мы используем только prefix чтобы собрать библиотеку локально. А поскольку мы хотим использовать библиотеку не только на хосте, соберем ее статическую версию.
Теперь нам нужен modbus сервер. В проекте libmodbus есть примеры, давайте на основе какого-нибудь простого сервера сделаем свою реализацию.
```
ctx = modbus_new_tcp(ip, port);
header_len = modbus_get_header_length(ctx);
query = malloc(MODBUS_TCP_MAX_ADU_LENGTH);
modbus_set_debug(ctx, TRUE);
mb_mapping = mb_mapping_wrapper_new();
if (mb_mapping == NULL) {
fprintf(stderr, "Failed to allocate the mapping: %s\n",
modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
listen_socket = modbus_tcp_listen(ctx, 1);
for (;;) {
client_socket = modbus_tcp_accept(ctx, &listen_socket);
if (-1 == client_socket) {
break;
}
for (;;) {
int query_len;
query_len = modbus_receive(ctx, query);
if (-1 == query_len) {
/* Connection closed by the client or error */
break;
}
if (query[header_len - 1] != MODBUS_TCP_SLAVE) {
continue;
}
mb_mapping_getstates(mb_mapping);
if (-1 == modbus_reply(ctx, query, query_len, mb_mapping)) {
break;
}
leddrv_updatestates(mb_mapping->tab_bits);
}
close(client_socket);
}
printf("exiting: %s\n", modbus_strerror(errno));
close(listen_socket);
mb_mapping_wrapper_free(mb_mapping);
free(query);
modbus_free(ctx);
```
Здесь все стандартно. Пара мест, которые представляют интерес, это функции mb\_mapping\_getstates и leddrv\_updatestates. Это как раз функционал, который и реализует наше устройство.
```
static modbus_mapping_t *mb_mapping_wrapper_new(void) {
modbus_mapping_t *mb_mapping;
mb_mapping = modbus_mapping_new(LEDDRV_LED_N, 0, 0, 0);
return mb_mapping;
}
static void mb_mapping_wrapper_free(modbus_mapping_t *mb_mapping) {
modbus_mapping_free(mb_mapping);
}
static void mb_mapping_getstates(modbus_mapping_t *mb_mapping) {
int i;
leddrv_getstates(mb_mapping->tab_bits);
for (i = 0; i < mb_mapping->nb_bits; i++) {
mb_mapping->tab_bits[i] = mb_mapping->tab_bits[i] ? ON : OFF;
}
}
```
Таким образом, нам нужны leddrv\_updatestates, которая задает состояние светодиодов, и leddrv\_getstates, которая получает состояние светодиодов.
```
static unsigned char leddrv_leds_state[LEDDRV_LED_N];
int leddrv_init(void) {
static int inited = 0;
if (inited) {
return 0;
}
inited = 1;
leddrv_ll_init();
leddrv_load_state(leddrv_leds_state);
leddrv_ll_update(leddrv_leds_state);
return 0;
}
...
int leddrv_getstates(unsigned char leds_state[LEDDRV_LED_N]) {
memcpy(leds_state, leddrv_leds_state, sizeof(leddrv_leds_state));
return 0;
}
int leddrv_updatestates(unsigned char new_leds_state[LEDDRV_LED_N]) {
memcpy(leddrv_leds_state, new_leds_state, sizeof(leddrv_leds_state));
leddrv_ll_update(leddrv_leds_state);
return 0;
}
```
Так как мы хотим чтобы наше ПО работало и на плате и на хосте, нам понадобятся разные реализации функций установки и получения состояния светодиодов. Давайте для хоста хранить состояние в обычном файле. Это позволит получать состояние светодиодов в других процессах.
Например, если мы захотим проверить состояния через вебсайт мы запустим вебсайт и укажем в качестве источника данных этот файл.
```
void leddrv_ll_update(unsigned char leds_state[LEDDRV_LED_N]) {
int i;
int idx;
char buff[LEDDRV_LED_N * 2];
for (i = 0; i < LEDDRV_LED_N; i++) {
char state = !!leds_state[i];
fprintf(stderr, "led(%03d)=%d\n", i, state);
buff[i * 2] = state + '0';
buff[i * 2 + 1] = ',';
}
idx = open(LED_FILE_NAME, O_RDWR);
if (idx < 0) {
return;
}
write(idx, buff, (LEDDRV_LED_N * 2) - 1);
close(idx);
}
...
void leddrv_load_state(unsigned char leds_state[LEDDRV_LED_N]) {
int i;
int idx;
char buff[LEDDRV_LED_N * 2];
idx = open(LED_FILE_NAME, O_RDWR);
if (idx < 0) {
return;
}
read(idx, buff, (LEDDRV_LED_N * 2));
close(idx);
for (i = 0; i < LEDDRV_LED_N; i++) {
leds_state[i] = buff[i * 2] - '0';
}
}
```
Нам нужно указать файл где будет сохранено начальное состояние светодиодов. Формат файла простой. Через запятую перечисляются состояние светодиодов, 1 — светодиод включен, а 0 -выключен. В нашем устройстве 80 светодиодов, точнее 40 пар светодиодов. Давайте предположим, что по умолчанию четные светодиоды будут выключены а нечетные включены. Содержимое файла
```
0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1
```
Запускаем сервер
```
./led-server
led(000)=0
led(001)=1
...
led(078)=0
led(079)=1
```
Теперь нам нужен клиент для управления нашим устройством. Его тоже очень просто разрабатываем на базе примера из libmodbus
```
ctx = modbus_new_tcp(ip, port);
if (ctx == NULL) {
fprintf(stderr, "Unable to allocate libmodbus context\n");
return -1;
}
modbus_set_debug(ctx, TRUE);
modbus_set_error_recovery(ctx,
MODBUS_ERROR_RECOVERY_LINK |
MODBUS_ERROR_RECOVERY_PROTOCOL);
if (modbus_connect(ctx) == -1) {
fprintf(stderr, "Connection failed: %s\n",
modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
if (1 == modbus_write_bit(ctx, bit_n, bit_value)) {
printf("OK\n");
} else {
printf("FAILED\n");
}
/* Close the connection */
modbus_close(ctx);
modbus_free(ctx);
```
Запускаем клиент. Установим 78 светодиод, который по умолчанию выключен
```
./led-client set 78
Connecting to 127.0.0.1:1502
[00][01][00][00][00][06][FF][05][00][4E][FF][00]
Waiting for a confirmation...
<00><01><00><00><00><06><05><00><4E><00>
OK
```
На сервере увидим:
```
...
led(076)=0
led(077)=1
led(078)=1
led(079)=1
Waiting for an indication...
ERROR Connection reset by peer: read
```
То есть светодиод установлен. Давайте выключим его.
```
./led-client clr 78
Connecting to 127.0.0.1:1502
[00][01][00][00][00][06][FF][05][00][4E][00][00]
Waiting for a confirmation...
<00><01><00><00><00><06><05><00><4E><00><00>
OK
```
На сервере увидим сообщение об изменении:
```
...
led(076)=0
led(077)=1
led(078)=0
led(079)=1
Waiting for an indication...
ERROR Connection reset by peer: read
```
Запустим http сервер. О разработке веб-сайтов мы рассказывали в [статье](https://habr.com/ru/company/embox/blog/541662/). К тому же веб-сайт нам нужен только для более удобной демонстрации работы modbus. Поэтому не буду сильно вдаваться в подробности. Сразу приведу cgi скрипт:
```
#!/bin/bash
echo -ne "HTTP/1.1 200 OK\r\n"
echo -ne "Content-Type: application/json\r\n"
echo -ne "Connection: close\r\n"
echo -ne "\r\n"
if [ $REQUEST_METHOD = "GET" ]; then
echo "Query: $QUERY_STRING" >&2
case "$QUERY_STRING" in
"c=led_driver&a1=serialize_states")
echo [ $(cat ../emulate/conf/leds.txt) ]
;;
"c=led_driver&a1=serialize_errors")
echo [ $(printf "0, %.0s" {1..79}) 1 ]
;;
"c=led_names&a1=serialize")
echo '[ "one", "two", "WWWWWWWWWWWWWWWW", "W W W W W W W W " ]'
;;
esac
elif [ $REQUEST_METHOD = "POST" ]; then
read -n $CONTENT_LENGTH POST_DATA
echo "Posted: $POST_DATA" >&2
fi
```
И напомню что запустить можно с помощью любого http сервера с поддержкой CGI. Мы используем встроенный в python сервер. Запускаем следующей командой:
```
python3 -m http.server --cgi -d .
```
Откроем наш сайт в браузере:
Установим 78 светодиод с помощью клиента:
```
./led-client -a 127.0.0.1 set 78
Connecting to 127.0.0.1:1502
[00][01][00][00][00][06][FF][05][00][4E][FF][00]
Waiting for a confirmation...
<00><01><00><00><00><06><05><00><4E><00>
OK
```
сбросим 79 светодиод:
```
./led-client -a 127.0.0.1 clr 79
Connecting to 127.0.0.1:1502
[00][01][00][00][00][06][FF][05][00][4F][00][00]
Waiting for a confirmation...
<00><01><00><00><00><06><05><00><4F><00><00>
OK
```
На сайте увидим разницу:
Собственно все, на Linux наша библиотека прекрасно работает.
Адаптация к Embox и запуск на эмуляторе
---------------------------------------
### Библиотека libmodbus
Теперь нам нужно перенести код в Embox. начнем с самого проекта libmodbus.
Все просто. Нам нужно описание модуля (Mybuild):
```
package third_party.lib
@Build(script="$(EXTERNAL_MAKE)")
@BuildArtifactPath(cppflags="-I$(ROOT_DIR)/build/extbld/third_party/lib/libmodbus/install/include/modbus")
module libmodbus {
@AddPrefix("^BUILD/extbld/^MOD_PATH/install/lib")
source "libmodbus.a"
@NoRuntime depends embox.compat.posix.util.nanosleep
}
```
Мы с помощью аннотации *[Build](https://habr.com/ru/users/build/)(script="$(EXTERNAL\_MAKE)")* указываем что используем Makefile для работы с внешними проектами.
С помощью аннотации *[Build](https://habr.com/ru/users/build/)ArtifactPath* добавляем пути для поиска заголовочных файлов к тем модулям, которые будут зависеть от этой библиотеки.
И говорим что нам нужна библиотека *source «libmodbus.a»*
```
PKG_NAME := libmodbus
PKG_VER := 3.1.6
PKG_SOURCES := http://libmodbus.org/releases/$(PKG_NAME)-$(PKG_VER).tar.gz
PKG_MD5 := 15c84c1f7fb49502b3efaaa668cfd25e
PKG_PATCHES := accept4_disable.patch
include $(EXTBLD_LIB)
libmodbus_cflags = -UHAVE_ACCEPT4
$(CONFIGURE) :
export EMBOX_GCC_LINK=full; \
cd $(PKG_SOURCE_DIR) && ( \
CC=$(EMBOX_GCC) ./configure --host=$(AUTOCONF_TARGET_TRIPLET) \
prefix=$(PKG_INSTALL_DIR) \
CFLAGS=$(libmodbus_cflags) \
)
touch $@
$(BUILD) :
cd $(PKG_SOURCE_DIR) && ( \
$(MAKE) install MAKEFLAGS='$(EMBOX_IMPORTED_MAKEFLAGS)'; \
)
touch $@
```
Makefile для сборки тоже простой и очевидный. Единственное, отмечу что используем внутренний компилятор (*$(EMBOX\_GCC)* ) Embox и в качестве платформы (*--host*) передаем ту, которая задана в Embox (*$(AUTOCONF\_TARGET\_TRIPLET)*).
### Подключаем проект к Embox
Напомню, что для удобства разработки мы создали отдельный репозиторий. Для того чтобы подключить его к Embox достаточно указать Embox где лежит внешний проект.
Делается это с помощью команды
```
make ext_conf EXT_PROJECT_PATH=
```
в корне Embox. Например,
```
make ext_conf EXT_PROJECT_PATH=~/git/embox_project_modbus_iocontrol
```
### modbus-server
Исходный код modbus сервера не требует изменений. То есть мы используем тот же код, который разработали на хосте. Нам нужно добавить Mybuild:
```
package iocontrol.modbus.cmd
@AutoCmd
@Build(script="true")
@BuildDepends(third_party.lib.libmodbus)
@Cmd(name="modbus_server")
module modbus_server {
source "modbus_server.c"
@NoRuntime depends third_party.lib.libmodbus
}
```
В котором с помощью аннотаций мы укажем что это у нас команда, а также что она зависит от библиотеки libmodbus.
Нам также понадобятся библиотеки эмуляции. Не буду приводить Mybuild для них, они тривиальны, лишь отмечу, что исходники также используются без изменений.
Нам также нужно собрать нашу систему вместе с modbus сервером.
Добавляем наши модули в mods.conf:
```
include iocontrol.modbus.http_admin
include iocontrol.modbus.cmd.flash_settings
include iocontrol.modbus.cmd.led_names
include third_party.lib.libmodbus
include iocontrol.modbus.cmd.modbus_server
include iocontrol.modbus.cmd.led_driver
include embox.service.cgi_cmd_wrapper(cmds_check=true, allowed_cmds="led_driver led_names flash_settings")
include iocontrol.modbus.lib.libleddrv_ll_stub
```
А наш файл leds.txt со статусами светодиодов кладем в корневую файловую систему. Но так как нам нужен изменяемый файл, давайте добавим RAM disk и скопируем наш файл на этот диск. Содержимое system\_start.inc:
```
"export PWD=/",
"export HOME=/",
"netmanager",
"service telnetd",
"service httpd http_admin",
"ntpdate 0.europe.pool.ntp.org",
"mkdir -v /conf",
"mount -t ramfs /dev/static_ramdisk /conf",
"cp leds.txt /conf/leds.txt",
"led_driver init",
"service modbus_server",
"tish",
```
Этого достаточно запустим Embox на qemu:
```
./scripts/qemu/auto_qemu
```
modbus и httpd сервера запускаются автоматически при старте. Установим такие же значения с помощью modbus клиента, только указав адрес нашего QEMU (10.0.2.16):
```
./led-client -a 10.0.2.16 set 78
Connecting to 10.0.2.16:1502
[00][01][00][00][00][06][FF][05][00][4E][FF][00]
Waiting for a confirmation...
<00><01><00><00><00><06><05><00><4E><00>
OK
```
и соответственно
```
./led-client -a 10.0.2.16 clr 79
Connecting to 10.0.2.16:1502
[00][01][00][00][00][06][FF][05][00][4F][00][00]
Waiting for a confirmation...
<00><01><00><00><00><06><05><00><4F><00><00>
```
Откроем браузер:
Как и ожидалось все тоже самое. Мы можем управлять устройством через modbus протокол уже на Embox.
Запуск на микроконтроллере
--------------------------
Для запуска на микроконтроллере будем использовать STM32F4-discovery. На вышеприведенных скриншотах страниц браузера, видно что используется 80 ног вывода, объединенные в пары, и еще можно заметить что у этих пар есть другие свойства, например можно задать имя, или пара может подсвечиваться. На самом деле, код был взят из реального проекта и из него для упрощения были убраны лишние части. 80 выходных пинов было получено с помощью дополнительных микросхем сдвиговых регистров.
Но на плате STM32F4-discovery всего 4 светодиода. Было бы удобно задавать количество светодиодов, чтобы не модифицировать исходный код В Embox есть механизм позволяющий параметризировать модули. Нужно в описании модуля (Mybuild) добавить опцию
```
package iocontrol.modbus.lib
static module libleddrv {
option number leds_quantity = 80
...
}
```
И можно будет использовать в коде
```
#ifdef __EMBOX__
#include
#include
#define LEDDRV\_LED\_N OPTION\_MODULE\_GET(iocontrol\_\_modbus\_\_lib\_\_libleddrv,NUMBER,leds\_quantity)
#else
#define LEDDRV\_LED\_N 80
#endif
```
При этом менять этот параметр можно будет указав его в файле mods.conf
```
include iocontrol.modbus.lib.libleddrv(leds_quantity=4)
```
если параметр не указывается, то используется тот который задан в модуле по умолчанию, то есть 80.
Нам нужно еще управлять реальными линиями вывода. Код следующий:
```
struct leddrv_pin_desc {
int gpio; /**< port */
int pin; /**< pin mask */
};
static const struct leddrv_pin_desc leds[] = {
#include
};
void leddrv\_ll\_init(void) {
int i;
for (i = 0; i < LEDDRV\_LED\_N; i++) {
gpio\_setup\_mode(leds[i].gpio, leds[i].pin, GPIO\_MODE\_OUTPUT);
}
}
void leddrv\_ll\_update(unsigned char leds\_state[LEDDRV\_LED\_N]) {
int i;
for (i = 0; i < LEDDRV\_LED\_N; i++) {
gpio\_set(leds[i].gpio, leds[i].pin,
leds\_state[i] ? GPIO\_PIN\_HIGH : GPIO\_PIN\_LOW);
}
}
```
В файле mods.conf нам нужна конфигурация для нашей платы. К ней добавляем наши модули:
```
include iocontrol.modbus.http_admin
include iocontrol.modbus.cmd.flash_settings
include iocontrol.modbus.cmd.led_names
include third_party.lib.libmodbus
include iocontrol.modbus.cmd.modbus_server
include iocontrol.modbus.cmd.led_driver
include embox.service.cgi_cmd_wrapper(cmds_check=true, allowed_cmds="led_driver led_names flash_settings")
include iocontrol.modbus.lib.libleddrv(leds_quantity=4)
include iocontrol.modbus.lib.libleddrv_ll_stm32_f4_demo
```
По сути дела, те же модули как и для ARM QEMU, за исключением конечно драйвера.
Собираем, прошиваем, запускаем. И с помощью того же modbus клиента управляем светодиодами. Нужно только поставить правильный адрес, и не забыть что у нас всего 4 светодиода на плате.
Работу на плате stm32f4-discovery можно увидеть на этом коротком видео:
Выводы
------
На этом простом примере мы постарались показать, в чем же основное отличие Embox от других ОС для микроконтроллеров. В том числе которые имеют POSIX совместимость. Ведь мы по сути дела, взяли готовый модуль, разработали бизнес логику на Linux используя при этом несколько приложений. И запустили все это на нашей целевой платформе. Тем самым существенно упростив и ускорив саму разработку.
Да, конечно, приложение демонстрационное и не сложное. Сам протокол modbus так же можно было бы реализовать самостоятельно. Но в этом случае нам нужно было бы разбираться в протоколе modbus. А наш подход позволяет сосредоточится каждому специалисту на своей части. Ну и конечно, большинство проблем решаются на хосте, что гораздо более удобно чем разрабатывать напрямую на плате. | https://habr.com/ru/post/547582/ | null | ru | null |
# Beta-тестирование плагина PVS-Studio для JetBrains CLion
Традиционно сложилось, что основной средой разработки для работы с анализатором PVS-Studio была среда Visual Studio от Microsoft. Наш анализатор начинал свой путь на Windows, поэтому выбор Visual Studio был вполне оправданным и очевидным. Тем не менее, более чем за 10 лет развития PVS-Studio анализатор стал доступен для нескольких других языков и платформ, поэтому вполне естественно, что в нашей поддержке всё больше людей спрашивают о возможности интеграции PVS-Studio с их любимой IDE.
Год назад, 18 июня 2020 года, состоялся первый релиз плагина PVS-Studio для среды разработки JetBrains Rider. Этот релиз был приурочен к одновременному выходу анализатора PVS-Studio для C# на платформах Linux и macOS.
Сегодня же мы рады объявить о начале публичного beta-тестирования плагина для другой IDE от JetBrains — CLion. Мы верим, что данное нововведение значительно улучшит опыт работы с нашим продуктом для Linux и кроссплатформенных С++ пользователей. По результатам прохождения beta-тестов мы надеемся выпустить первую версию плагина CLion в предстоящем релизе PVS-Studio 7.14, в последних числах июля — начале августа.
Как принять участие в beta тесте PVS-Studio for CLion
-----------------------------------------------------
Для полноценного тестирования плагина необходимо инсталлировать саму бета-версию плагина и бета-версию ядра C++ анализатора. Плагин можно установить несколькими способами: из официального репозитория, из репозитория на нашем сайте или с помощью Windows установщика PVS-Studio — далее мы расскажем, как это сделать.
После установки плагина и анализатора вы можете зарегистрироваться на beta-тест PVS-Studio for CLion на нашей [странице раннего доступа](https://pvs-studio.com/ru/pvs-studio-eap/), вам на почту придёт пробный ключ для анализатора.
Подробную документацию по установке и работе с плагинами PVS-Studio для CLion и Rider можно найти [здесь](https://pvs-studio.com/ru/docs/manual/0052/), а мы дальше приведём краткую инструкцию по установке и первому запуску PVS-Studio в CLion.
Цель любого beta-теста — сбор отзывов пользователей о новом продукте, удобстве его использования и, конечно, неизбежных багах, которые всегда присутствуют в ранних версиях. Данный beta-тест не исключение. Если вы столкнулись с одной из таких ошибок или просто хотите поделиться своими впечатлениями о новом плагине PVS-Studio, обязательно напишите нам в ответ на письмо, пришедшее после регистрации на beta-тесте или свяжитесь с нами с помощью нашей [формы обратной связи](https://pvs-studio.com/ru/about-feedback/?is_question_form_open=true).
Установка из официального репозитория
-------------------------------------
Для этого нужно запустить CLion и далее File->Settings->Plugins, выбрать вкладку Marketplace, а в строке поиска ввести 'PVS-Studio'. Далее установить плагин PVS-Studio for CLion.
Установка плагина из репозитория PVS-Studio
-------------------------------------------
Этот пункт аналогичный предыдущему, но сначала надо настроить CLion для нового репозитория. Для этого перейдите в File->Settings->Plugins, нажмите на "шестерёнку" в правой части окна и в выпадающем меню выберите Manage Plugin Repositories.
В открывшимся окне добавьте путь <http://files.viva64.com/java/pvsstudio-clion-plugins/updatePlugins.xml>. И нажмите ОК.
Далее устанавливаем плагин аналогично предыдущему пункту.
Установка с помощью Windows инсталлятора
----------------------------------------
Если вы используете операционную систему Windows, вы можете установить плагин и ядро анализатора из дистрибутива. Для этого скачайте и запустите инсталлятор [отсюда](https://pvs-studio.com/ru/pvs-studio/download-beta/) (в таблице в колонке Windows скачайте ".exe" файл установщика).
Установка beta-версии анализатора С++
-------------------------------------
Для корректной работы PVS-Studio в CLion помимо непосредственно самого плагина требуется установить ядро C++ анализатора. Для этого можно перейти по [адресу](https://pvs-studio.com/ru/pvs-studio/download-beta/) и скачать дистрибутив для вашей платформы. Если вы установили дистрибутив для Windows, то этот пункт можно пропустить.
Если вы используете операционные системы Linux или macOS, вы также можете воспользоваться следующими командами для установки:
### Для debian-based систем:
```
wget -q -O - https://files.viva64.com/beta/etc/pubkey.txt | \
sudo apt-key add -
sudo wget -O /etc/apt/sources.list.d/viva64-beta.list \
https://files.viva64.com/beta/etc/viva64.list
sudo apt-get update
sudo apt-get install pvs-studio
```
### Для yum-based систем:
```
wget -O /etc/yum.repos.d/viva64-beta.repo \
https://files.viva64.com/beta/etc/viva64.repo
yum update
yum install pvs-studio
```
### Для zypper-based систем:
```
wget -q -O /tmp/viva64-beta.key https://files.viva64.com/beta/etc/pubkey.txt
sudo rpm --import /tmp/viva64-beta.key
sudo zypper ar -f https://files.viva64.com/beta/rpm viva64-beta
sudo zypper update
sudo zypper install pvs-studio
```
### Для macOS:
```
brew install viva64/pvs-studio/pvs-studio-beta
```
Регистрация продукта
--------------------
После регистрации в beta-тесте и получения регистрационного ключа для активации лицензии нужно перейти в окно Tools->PVS-Studio->Settings. В открывшемся окне перейти на вкладку Registration.
В полях User Name и Serial Number нужно ввести соответствующие данные лицензии. Ещё раз напоминаем, что получить регистрационный ключ можно здесь: [страница раннего доступа](https://pvs-studio.com/ru/pvs-studio-eap/).
Первое знакомство с плагином
----------------------------
После установки и настройки плагин будет примерно выглядеть, как показано на рисунке ниже.
Плагин позволяет анализировать CMake проекты, загруженные в CLion, и отдельные выбранные файлы.
Для запуска анализа выберите Tools->PVS-Studio->Check Project.
Для анализа выбранных файлов Tools -> PVS-Studio -> Check Current File.
Результаты анализа можно увидеть в окне PVS-Studio:
В окне можно увидеть таблицу, которая состоит из столбцов c кодом предупреждения, описанием проблемы, позицией и т.д.
При нажатии правой кнопкой мыши на строке с сообщением анализатора в таблице окна PVS-Studio откроется контекстное меню, содержащее дополнительные команды для выбранных сообщений анализатора.
Команда 'Mark selected messages as False Alarms / Remove false alarm masks' позволяет разметить сообщение анализатора как ложное срабатывание, добавив в код, на который выдано предупреждение, комментарий специального вида.
Команда 'Exclude from analysis' позволяет добавить путь или часть пути к файлу, в котором найдено предупреждение анализатора, в список исключённых из анализа директорий. Все файлы, пути до которых попадут под данный фильтр, будут исключены из анализа.
При двойном клике левой кнопкой мыши на строке будет открыт файл на строке, где было найдено предупреждение анализатора.
Настройки плагина
-----------------
Для того чтобы открыть окно настроек плагина, зайдите в Tools->PVS-Studio->Settings. Панель настроек плагина состоит из нескольких вкладок. Рассмотрим каждую из них подробнее.
Settings — настройки ядра анализатора PVS-Studio. При наведении курсора мыши на название настройки появляется подсказка с описанием того, для чего эта настройка предназначена.
Warnings — список типов всех предупреждений, поддерживаемых анализатором. Если убрать галочку у предупреждения, то все предупреждения данного типа в таблице вывода результатов работы анализатора будут отфильтрованы:
Excludes — содержит маски для имен файлов и путей, которые будут исключены из анализа.
Как начать использовать анализатор на проекте с большим объёмом legacy кода
---------------------------------------------------------------------------
Очень часто начать регулярно использовать статический анализ мешают многочисленные срабатывания на legacy коде. Такой код обычно уже хорошо оттестирован и стабильно работает, поэтому править в нём все срабатывания анализатора может оказаться нецелесообразно. Тем более, если размер кодовой базы достаточно велик, такая правка может потребовать большого времени. При этом такие сообщения на существующий код мешают смотреть сообщения на код новый, ещё находящийся в разработке.
Чтобы решить данную проблему и начать сразу регулярно использовать статический анализ, PVS-Studio предлагает возможность "отключить" сообщения на старом коде. Чтобы подавить сообщения анализатора на старом коде можно воспользоваться командой главного меню 'Tools -> PVS-Studio -> Suppress All Messages' или кнопкой 'Suppress All Messages' на панели окна PVS-Studio. Механизм подавления работает с помощью специальных suppress файлов, в которые добавляются подавленные сообщения анализатора после выполнения команды 'Suppress All Messages'. При последующем запуске анализа все сообщения, добавленные в такие suppress файлы, не попадут в отчёт анализатора. Система подавления через suppress файлы достаточно гибкая и способна "отслеживать" подавленные сообщения даже при модификации и сдвигах участков кода, в которых выдаётся подавленное сообщение.
В CLion подавленные сообщения добавляются в suppress\_base.json, который записывается в директорию .PVS-Studio в корневой директории открытого в CLion проекта. Чтобы вернуть все сообщения в вывод анализатора, необходимо удалить этот файл и перезапустить анализ.
Смотрите также статью "[Как внедрить статический анализатор кода в legacy проект и не демотивировать команду](https://pvs-studio.com/ru/blog/posts/0743/)".
Сохранение и загрузка результатов анализа
-----------------------------------------
Для сохранения или загрузки результатов работы анализатора можно воспользоваться командами главного меню, доступными через 'Tools -> PVS-Studio':
Команда 'Open Report' открывает .json файл отчёта и загружает его содержимое в таблицу окна 'PVS-Studio'.
Подменю 'Recent Reports' показывает список из нескольких последних открытых файлов отчётов. При нажатии на элемент в списке будет открыт соответствующий отчёт (если отчёт ещё существует по такому пути) и его содержимое будет загружено в таблицу окна 'PVS-Studio'.
Команда 'Save Report' сохраняет все сообщения из таблицы (даже отфильтрованные) в .json файл отчёта. Если текущий результат анализа ещё ни разу не сохранялся, то будет предложено задать имя и место для сохранения отчёта.
Аналогично команда 'Save Report As' сохраняет все предупреждения из таблицы (даже отфильтрованные) в .json файл отчёта, всегда предлагая выбрать место сохранения отчёта на диске.
Инкрементальный анализ
----------------------
Обычно мы рекомендуем регулярно запускать полный анализ, например раз в сутки, ночью. Однако для наибольшего эффекта от использования анализатора можно в дополнение к ночному анализу осуществлять проверку нового кода сразу после его написания. Для этого можно использовать инкрементальный анализ, который работает следующим образом. После того как в проект были внесены изменения, разработчик запускает сборку и после успешного завершения компиляции будет запущен анализ только изменённых файлов. Изменёнными файлами считаются те файлы, которые изменились с момента предыдущего анализа.
Режим инкрементального анализа можно включить или отключить. Для этого надо выбрать опцию Tools->PVS-Studio->Analysis after Build (Modified files only) и далее Enabled или Disabled.
Заключение
----------
С поддержкой новой IDE JetBrains CLion мы надеемся сделать использование анализатора более удобным для наших C++ пользователей на всех поддерживаемых платформах (Windows, Linux, macOS). И хотя остаётся ещё много сред разработки, в которых нет прямой интеграции PVS-Studio (однако во многих из них можно использовать анализатор с помощью стандартных средств просмотра предупреждений компилятора), мы планируем в будущем наращивать количество IDE, которые мы поддерживаем напрямую.
Исходя из интереса наших пользователей наиболее вероятным следующим кандидатом для такой поддержки будет Visual Studio Code. Пишите нам если вам интересна прямая интеграция нашего анализатора в "вашу" IDE, и, возможно, она тоже появится в наших планах.
Ну и напоследок ещё раз напомню, что вы [можете зарегистрироваться](https://pvs-studio.com/ru/pvs-studio-eap/) для участия в beta-тесте и [написать нам](https://pvs-studio.com/ru/about-feedback/?is_question_form_open=true) через форму обратной связи о найденных проблемах и пожеланиях.
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: [Beta-Testing of PVS-Studio Plugin for JetBrains CLion](https://habr.com/en/company/pvs-studio/blog/565470/). | https://habr.com/ru/post/565474/ | null | ru | null |
# Программируем Windows 7: Taskbar. Часть 3 – OverlayIcon
На этот раз мы поговорим о другой особенности панели задачи Windows 7 – OverlayIcon. Эта возможность исключительно полезна для приложений, которые обладают каким-то состоянием с точки зрения пользователя.
К таким приложениям можно отнести программы для обмена мгновенными сообщениями (IM). Например, Windows Live Messanger активно использует эту возможность. Например, если мы откроем WLM и будем изменять состояние, то можно увидеть как оно отображается на панели задач.
Такая функциональность может быть полезна для множества приложений. К счастью реализовать ее не так сложно. Как и в предыдущих примерах мы воспользуемся библиотекой [.NET Interop Sample Library](http://code.msdn.microsoft.com/Windows7Taskbar/Release/ProjectReleases.aspx?ReleaseId=2246).
Чтобы добавить иконку состояния к основному значку приложения, необходимо добавить файл ресурсов в проект и разместить там нужные иконки. Также, мы можем получить объекты Icon из другого места, если это необходимо.
Теперь все, что необходимо сделать – это воспользоваться методами расширения, позволяющими задавать иконки для нашего приложения. Для этих целей определен метод SetTaskbarOverlayIcon. Мы должны передать ему в параметрах нашу форму, иконку и описание. Т.о., установка новой иконки из кода будет выглядеть следующим образом.
`WindowsFormsExtensions.SetTaskbarOverlayIcon(this, Icons.Error, "Error");`
Также мы можем удалить этот значок. Для этого необходимо передать значение null вместо самой иконки.
`WindowsFormsExtensions.SetTaskbarOverlayIcon(this, null, String.Empty);`
Давайте создадим для примера небольшое приложение, в котором можем переключать состояние. Выглядеть оно будет следующим образом.
При нажатии на каждую из кнопок переключается состояние, которое отображается в панели задач.
Демонстрационное приложение:
[Taskbar-Icons.zip](http://blogs.gotdotnet.ru/personal/sergun/content/binary/WindowsLiveWriter/Windows7Taskbar.3OverlayIcon_C7CC/Taskbar-Icons.zip) | https://habr.com/ru/post/60223/ | null | ru | null |
# Создание простой MVC-системы на PHP 5
Предисловие
-----------
В этом руководстве Вы узнаете, как построить простую систему по архитектуре MVC (Model-View-Controller, Модель-Отображение-Контроллер) на PHP 5.1 с использованием возможностей библиотеки SPL (Standard PHP Library, Стандартная Библиотека PHP).
Введение
--------
Добро пожаловать в первое полноценное руководство для PHP 5 на [PHPit](http://www.phpit.net/). Вам понадобится PHP 5.1 с установленной библиотекой SPL, так как мы воспользуемся некоторыми из самых последних возможностей PHP 5.
В этом руководстве я собираюсь показать, как построить простую MVC-систему (архитектура MVC является наиболее распространённым шаблоном проектирования для больших web-приложений). Я проведу Вас через все шаги от начала и до конца создания полноценной MVC-системы.
Одна точка входа
----------------
Одной из важных вещей в MVC является одна точка входа в приложение вместо кучи PHP-файлов, делающих примерно следующее:
> php<br/
> include ('global.php');
>
>
>
> // Здесь код страницы
>
>
>
> ?>
>
>
>
>
У нас будет один файл, обрабатывающий все запросы. Это значит, что нам не придётся мучиться с подключением global.php каждый раз, когда нам нужно создать новую страницу. Эта «одна точка входа» будет называться index.php и на данный момент будет такой:
> php<br/
>
>
>
>
> // Тут чего-нибудь делаем
>
>
>
>
>
> ?>
>
>
>
>
Как Вы можете заметить, этот скрипт пока ещё ничего не делает, но погодите минутку.
Чтобы направить все запросы на главную страницу, мы воспользуемся mod\_rewrite и установим в .htaccess директиву RewriteRule. Вставим следующий код в файл .htaccess и сохраним его в той же директории, что и index.php:
>
> ```
>
> RewriteEngine on
>
> RewriteCond %{REQUEST_FILENAME} !-f
> RewriteCond %{REQUEST_FILENAME} !-d
>
> RewriteRule ^(.*)$ index.php?route=$1 [L,QSA]
>
> ```
>
Сперва мы проверяем, существует ли запрашиваемый файл, используя директиву RewriteCond, и, если нет, то перенаправляем запрос на index.php. Такая проверка на существование файла необходима, так как иначе index.php будет пытаться обрабатывать все запросы к сайту, включая запросы на изображения. А это нам как раз и не надо.
Если у Вас нет возможности использовать .htaccess или mod\_rewrite, то Вам придётся вручную адресовать все запросы к index.php. Другими словами, все ссылки должны будут иметь вид «index.php?route=[здесь-идёт-запрос]». Например, «index.php?route=chat/index».
Теперь, когда все запросы идут через одну точку входа, мы можем начать написание скрипта index.php. Первая вещь, которую мы должны сделать, это инициализация системы. Создадим директорию includes, а в ней файл startup.php (он будет у нас файлом инициализации). Вставим следующий код в index.php:
> php<br/
>
>
> error\_reporting (E\_ALL);
>
>
>
> if (version\_compare(phpversion(), '5.1.0', '<') == true) { die ('PHP5.1 Only'); }
>
>
>
>
>
> // Константы:
>
>
>
> define ('DIRSEP', DIRECTORY\_SEPARATOR);
>
>
>
>
>
> // Узнаём путь до файлов сайта
>
>
>
> $site\_path = realpath(dirname(\_\_FILE\_\_) . DIRSEP . '..' . DIRSEP) . DIRSEP;
>
>
>
> define ('site\_path', $site\_path);
>
>
>
>
>
> В этом примере мы объявляем некоторую константу, узнаём, где лежат файлы системы, а также проверяем, что версия PHP, ну, хотя бы, 5.1.
>
>
>
> Следующая вещь, которую необходимо сделать, это объект Registry (журнал, реестр) для хранения глобальных значений. Он будет передаваться в отдельные объекты системы и использоваться для доступа к глобальным значениям, причём без необходимости обозначать переменные как «global» или обращаться к массиву $GLOBALS. Почитайте статью [«Использование глобальных значений в PHP»](http://www.phpit.net/article/using-globals-php/) для более подробной информации об объекте реестра.
>
>
>
> Добавьте следующий код в файл startup.php после того кода, что приведён в предыдущем примере:
>
>
>
>
> > $registry = new Registry;
> >
> >
>
>
>
>
>
> Если сейчас попробовать запустить систему, то можно увидеть следующую ошибку:
>
>
>
>
> > `Fatal error: Class 'Registry' not found in g:\Projects\PHPit\content\simple mvc php5\demo\includes\startup.php on line 12`
>
>
>
>
>
> Это, конечно, не большой сюрприз для нас, ведь мы ещё не написали сам класс Registry. Файл с классом можно было бы просто подключить, используя функцию include() (*Прим. пер.: кстати говоря, include() не такая уж и функция, а всё-таки выражение языка, управляющая структура, если смотреть по [ману](http://ru2.php.net/manual/ru/function.include.php)*), но давайте воспользуемся одной из новых возможностей PHP 5: \_\_autoload().
>
>
>
> Волшебная функция \_\_autoload() используется для динамической загрузки классов. Когда PHP обнаруживает несуществующий класс, он сначала вызывает функцию \_\_autoload() и только затем выдаёт ошибку. Мы можем воспользоваться такой возможностью для загрузки классов «на лету».
>
>
>
> Вставьте этот код **перед** кодом из предыдущего примера:
>
>
>
>
> > // Загрузка классов «на лету»
> >
> >
> >
> > function \_\_autoload($class\_name) {
> >
> >
> >
> > $filename = strtolower($class\_name) . '.php';
> >
> >
> >
> > $file = site\_path . 'classes' . DIRSEP . $filename;
> >
> >
> >
> >
> >
> > if (file\_exists($file) == false) {
> >
> >
> >
> > return false;
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > include ($file);
> >
> >
> >
> > }
> >
> >
>
>
>
>
>
> Наша функция \_\_autoload() берёт имя класса, переданное ей как аргумент, и проверяет, существует ли файл с похожим именем в директории с классами. Если файла нет, то функция просто вернёт false и выскочит фатальная ошибка. Но если файл существует, он будет загружен. Т.е. объявится необходимый класс, и никакой ошибки не будет.
>
>
>
> Мы ещё не создали сам класс Registry, поэтому ошибка всё ещё будет появляться. Давайте же займёмся этим.
>
>
>
>
>
> Создание класса Registry
> ------------------------
>
>
>
> Класс Registry используется для передачи глобальных значений между отдельными объектами. Это на самом деле довольно простой класс, в котором нужно реализовать несколько маленьких методов.
>
>
>
> Для начала создадим директорию classes и в ней файл registry.php. Вставим следующий код в registry.php:
>
>
>
>
> > php<br/
> >
> >
> >
> >
> > Class Registry {
> >
> >
> >
> > private $vars = array();
> >
> >
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > ?>
> >
> >
> >
> >
>
>
>
>
>
> Теперь у нас есть «скелет» класса Registry и нужно нагрузить его методами. Напишем 2 метода: set(), чтобы устанавливать значения и get(), чтобы значения получать. Также можно написать метод remove() для удаления значений. Добавим эти методы в класс Registry:
>
>
>
>
> > function set($key, $var) {
> >
> >
> >
> > if (isset($this->vars[$key]) == true) {
> >
> >
> >
> > throw new Exception('Unable to set var `' . $key . '`. Already set.');
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > $this->vars[$key] = $var;
> >
> >
> >
> > return true;
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > function get($key) {
> >
> >
> >
> > if (isset($this->vars[$key]) == false) {
> >
> >
> >
> > return null;
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > return $this->vars[$key];
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > function remove($var) {
> >
> >
> >
> > unset($this->vars[$key]);
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > ?>
> >
> >
> >
> >
>
>
>
>
>
> Эти методы простые, они устанавливают, получают и удаляют элементы из массива $vars, который является атрибутом класса. В методе set() мы заодно проверяем, не существует ли уже значение с указанным ключом, и, если существует, то мы генерируем исключение. Это нужно, чтобы избежать случайной перезаписи значений.
>
>
>
> Теперь у нас есть полноценный класс Registry, но мы не будем останавливаться на этом. Воспользуемся одной из возможностей библиотеки SPL: ArrayAccess. SPL (сокращённо от Standard PHP Library, Стандартная Библиотека PHP) — это коллекция интерфейсов и классов, предназначенных для решения стандартных проблем. Один из интерфейсов SPL, ArrayAccess, может быть использован, чтобы предоставить доступ к объекту, как к обычному массиву. Посмотрим на такой пример:
>
>
>
>
> > php<br/
> >
> >
> >
> >
> > $registry = new Registry;
> >
> >
> >
> >
> >
> > // Устанавливаем некоторое значение
> >
> >
> >
> > $registry->set ('name', 'Dennis Pallett');
> >
> >
> >
> >
> >
> > // Получаем значение, используя get()
> >
> >
> >
> > echo $registry->get ('name');
> >
> >
> >
> >
> >
> > // Получаем значение, используя доступ как к массиву
> >
> >
> >
> > echo $registry['name']
> >
> >
> >
> >
> >
> > ?>
> >
> >
> >
> >
>
>
>
>
>
> Фокус в том, что $registry становится как бы массивом, хотя на самом деле это объект. Конечно, ArrayAccess не даёт никаких особых преимуществ, но он позволяет сократить объём кода, так как не придётся каждый раз писать «->get()». Чтобы воспользоваться этим интерфейсом, нужно исправить первую строчку класса («Class Registry») таким образом:
>
>
>
>
> > Class Registry Implements ArrayAccess {
> >
> >
> >
> >
>
>
>
>
>
> Ключевое слово «Implements» говорит интерпретатору, что этим классом мы реализуем интерфейс, чем на самом деле ArrayAccess и является.
>
>
>
> Класс, реализующий интерфейс ArrayAccess, должен иметь следующие методы:
>
>
>
>
> > function offsetExists($offset) {
> >
> >
> >
> > return isset($this->vars[$offset]);
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > function offsetGet($offset) {
> >
> >
> >
> > return $this->get($offset);
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > function offsetSet($offset, $value) {
> >
> >
> >
> > $this->set($offset, $value);
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > function offsetUnset($offset) {
> >
> >
> >
> > unset($this->vars[$offset]);
> >
> >
> >
> > }
> >
> >
> >
> >
>
>
>
>
>
> Эти методы должны быть понятны сами по себе. Дополнительную информацию можно найти в документации [SPL](http://www.php.net/~helly/php/ext/spl/).
>
>
>
> Теперь, реализовав интерфейс ArrayAccess, мы можем обращаться к объекту, как к обычному массиву. Это наглядно продемонстрировано, как в предыдущем примере, так и в этом:
>
>
>
>
> > php<br/
> >
> >
> >
> >
> > $registry = new Registry;
> >
> >
> >
> >
> >
> > // Устанавливаем некоторое значение
> >
> >
> >
> > $registry['name'] = 'Dennis Pallett';
> >
> >
> >
> >
> >
> > // Получаем значение, используя get()
> >
> >
> >
> > echo $registry->get ('name');
> >
> >
> >
> >
> >
> > // Получаем значение, используя доступ как к массиву
> >
> >
> >
> > echo $registry['name']
> >
> >
> >
> >
> >
> > ?>
> >
> >
> >
> >
>
>
>
>
>
> Класс Registry теперь завершён, и, если попробовать запустить систему, всё должно заработать (хотя ещё ничего не будет выводиться). Мы закончили с файлом инициализации и можно приступать к следующему шагу написания нашей MVC-системы: реализация доступа к базе данных, что в архитектуре MVC называется «Model» («Модель»).
>
>
>
>
>
>
>
> Модель
> ------
>
>
>
> «M» или модель – часть MVC-системы, которая отвечает за запросы к базе данных (или другому внешнему источнику) и предоставление информации контроллеру. Можно было бы загружать необходимую модель в зависимости от запроса, но я предпочитаю немного стереть границы между моделью и контроллером именно в этом месте, т.е. контроллер работает с БД непосредственно через библиотеку взаимодействия с БД, нежели чем через отдельную модель. Может быть, Вам захочется сделать это по-другому, тут дело вкуса.
>
>
>
> Нам нужно написать код, необходимый для установки соединения с БД и поместить его в index.php. Существует множество замечательных библиотек для работы с БД (включая мою собственную, [AutoCRUD](http://phpscripts.pallettgroup.com/autocrud)), но в PHP 5 уже есть такая библиотека – PDO. Поэтому нет нужды использовать какую-либо другую.
>
>
>
> Вставим следующий код в файл index.php (после подключения файла инициализации):
>
>
>
>
> > # Соединяемся с БД
> >
> >
> >
> > $db = new PDO('mysql:host=localhost;dbname=demo', '[user]', '[password]');
> >
> >
> >
> > $registry->set ('db', $db);
> >
> >
> >
> >
>
>
>
>
>
> В этом примере мы сначала создаём новый экземпляр библиотеки PDO и соединяемся с нашей БД MySQL. Потом делаем переменную $db доступной глобально при помощи нашего класса Registry.
>
>
>
> Модельная компонента нашей системы готова, поэтому давайте перейдём к написанию контроллера.
>
>
>
> Написание контроллера подразумевает также и написание класса Router, ответственного за загрузку нужного контроллера в зависимости от запроса (вспомните, в index.php через URL передаётся переменная $route).
>
>
>
>
>
>
>
> Класс Router
> ------------
>
>
>
> Класс Router будет разбирать запрос, а потом загружать требуемый контроллер. Создадим «скелет» класса:
>
>
>
>
> > php<br/
> >
> >
> >
> >
> > Class Router {
> >
> >
> >
> > private $registry;
> >
> >
> >
> > private $path;
> >
> >
> >
> > private $args = array();
> >
> >
> >
> >
> >
> > function \_\_construct($registry) {
> >
> >
> >
> > $this->registry = $registry;
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > ?>
> >
> >
> >
> >
>
>
>
>
>
> Затем добавим следующие строки в index.php:
>
>
>
>
> > # Загружаем router
> >
> >
> >
> > $router = new Router($registry);
> >
> >
> >
> > $registry->set ('router', $router);
> >
> >
> >
> >
>
>
>
>
>
> Мы добавили класс Router в нашу MVC-систему, но он пока что ничего не делает, поэтому давай добавим в него методы, необходимые для работы.
>
>
>
> Первая вещь, которую мы напишем, это метод setPath() для установки директории, где будут лежать все наши контроллеры. Метод выглядит следующим образом и должен быть добавлен в класс Router:
>
>
>
>
> > function setPath($path) {
> >
> >
> >
> > $path = trim($path, '/\\');
> >
> >
> >
> > $path .= DIRSEP;
> >
> >
> >
> >
> >
> > if (is\_dir($path) == false) {
> >
> >
> >
> > throw new Exception ('Invalid controller path: `' . $path . '`');
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > $this->path = $path;
> >
> >
> >
> > }
> >
> >
> >
> >
>
>
>
>
>
> Потом добавим следующие строки в index.php:
>
>
>
>
> > $router->setPath (site\_path . 'controllers');
> >
> >
> >
> >
>
>
>
>
>
> Теперь, когда мы установили путь до наших контроллеров, напишем сам метод, ответственный за загрузку контроллера. Этот метод будет называться delegate(), он и будет анализировать запрос. Первый кусочек этого метода такой:
>
>
>
>
> > function delegate() {
> >
> >
> >
> > // Анализируем путь
> >
> >
> >
> > $this->getController($file, $controller, $action, $args);
> >
> >
> >
> >
>
>
>
>
>
> Как Вы можете видеть, он использует ещё один метод, getController(), чтобы получить название контроллера и несколько других переменных. Этот метод выглядит так:
>
>
>
>
> > private function getController(&$file, &$controller, &$action, &$args) {
> >
> >
> >
> > $route = (empty($\_GET['route'])) ? '' : $\_GET['route'];
> >
> >
> >
> >
> >
> > if (empty($route)) { $route = 'index'; }
> >
> >
> >
> >
> >
> > // Получаем раздельные части
> >
> >
> >
> > $route = trim($route, '/\\');
> >
> >
> >
> > $parts = explode('/', $route);
> >
> >
> >
> >
> >
> > // Находим правильный контроллер
> >
> >
> >
> > $cmd\_path = $this->path;
> >
> >
> >
> > foreach ($parts as $part) {
> >
> >
> >
> > $fullpath = $cmd\_path . $part;
> >
> >
> >
> >
> >
> > // Есть ли папка с таким путём?
> >
> >
> >
> > if (is\_dir($fullpath)) {
> >
> >
> >
> > $cmd\_path .= $part . DIRSEP;
> >
> >
> >
> > array\_shift($parts);
> >
> >
> >
> > continue;
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > // Находим файл
> >
> >
> >
> > if (is\_file($fullpath . '.php')) {
> >
> >
> >
> > $controller = $part;
> >
> >
> >
> > array\_shift($parts);
> >
> >
> >
> > break;
> >
> >
> >
> > }
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > if (empty($controller)) { $controller = 'index'; };
> >
> >
> >
> >
> >
> > // Получаем действие
> >
> >
> >
> > $action = array\_shift($parts);
> >
> >
> >
> > if (empty($action)) { $action = 'index'; }
> >
> >
> >
> >
> >
> > $file = $cmd\_path . $controller . '.php';
> >
> >
> >
> > $args = $parts;
> >
> >
> >
> > }
> >
> >
> >
> >
>
>
>
>
>
> Пробежимся по этому методу. Сначала он берёт значение переменной $route из запроса, потом разбивает его на части с помощь функции explode(). Например, запрос «members/view» преобразуется в такой массив: array(‘members’, ‘view’).
>
>
>
> Потом при помощи цикла foreach он проходит по каждой части и проверяет, является ли эта часть директорией. Если является, то он приписывает её к пути до файла и проверяет следующую часть. Это позволяет поместить контроллеры в поддиректориях и, таким образом, получить иерархию контроллеров. Если же текущая часть запроса не является директорией, но является файлом, она сохраняется в переменную $controller, и мы выходим из цикла, так как нашёлся контроллер, который нам нужен.
>
>
>
> После цикла мы проверяем переменную с именем контроллера. Если она пустая, то используем контроллер «index», который будет у нас контроллером по умолчанию. Потом метод определяет действие, которое необходимо выполнить. Контроллер – это класс, который состоит из нескольких методов. Действие же указывает на конкретный метод. Если действие не указано, будем использовать «index» — действие по умолчанию.
>
>
>
> И, наконец, получаем полный путь до файла контроллера, объединяя три переменные: путь, имя контроллера и расширение «php».
>
>
>
> Теперь, когда мы проанализировали запрос, пора вызывать метод delegate() для загрузки контроллера и выполнения действия. Полностью метод delegate() выглядит так:
>
>
>
>
> > function delegate() {
> >
> >
> >
> > // Анализируем путь
> >
> >
> >
> > $this->getController($file, $controller, $action, $args);
> >
> >
> >
> >
> >
> > // Файл доступен?
> >
> >
> >
> > if (is\_readable($file) == false) {
> >
> >
> >
> > die ('404 Not Found');
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > // Подключаем файл
> >
> >
> >
> > include ($file);
> >
> >
> >
> >
> >
> > // Создаём экземпляр контроллера
> >
> >
> >
> > $class = 'Controller\_' . $controller;
> >
> >
> >
> > $controller = new $class($this->registry);
> >
> >
> >
> >
> >
> > // Действие доступно?
> >
> >
> >
> > if (is\_callable(array($controller, $action)) == false) {
> >
> >
> >
> > die ('404 Not Found');
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > // Выполняем действие
> >
> >
> >
> > $controller->$action();
> >
> >
> >
> > }
> >
> >
> >
> >
>
>
>
>
>
> Проанализировав запрос при помощи метода getController(), мы проверяем, существует ли в действительности файл, и, если нет, то возвращаем простое сообщение об ошибке.
>
>
>
> После этого мы подключаем файл с контроллером и создаём экземпляр его класса, называться который должен «Controller\_[имя]». Чуть позже мы поговорим о контроллерах более подробно.
>
>
>
> Потом мы проверяем, есть ли указанное действие (т.е. метод) и возможно ли к нему обратиться (используем для этого функцию [is\_callable()](http://php.net/is_callable)). Наконец, мы выполняем непосредственно само действие, на чём роль класса Router и завершается.
>
>
>
> Написав полностью метод delegate(), добавим следующую строчку в файл index.php:
>
>
>
>
> > $router->delegate();
> >
> >
> >
> >
>
>
>
>
>
> Если попробовать сейчас запустить систему, то мы увидим следующую ошибку (разумеется, если директории controllers ещё нет):
>
>
>
>
> > `Fatal error: Uncaught exception 'Exception' with message 'Invalid controller path: `g:\Projects\PHPit\content\simple mvc php5\demo\controllers\`' in g:\Projects\PHPit\content\simple mvc php5\demo\classes\router.php:18 Stack trace: #0 g:\Projects\PHPit\content\simple mvc php5\demo\index.php(13): Router->setPath('g:\Projects\PHP...') #1 {main} thrown in g:\Projects\PHPit\content\simple mvc php5\demo\classes\router.php on line 18`
>
>
>
>
>
> Или же мы увидим ошибку «404 Not Found», так как ещё нет ни одного контроллера. Но этим-то мы сейчас и займёмся.
>
>
>
>
>
>
>
> Контроллер
> ----------
>
>
>
> Контроллеры в нашей MVC-системе будут достаточно простыми и потребуют совсем немного времени. Во-первых, удостоверимся, что директория controllers существует. Создадим файл controller\_base.php в директории classes и вставим в него следующий код:
>
>
>
>
> > php<br/
> >
> >
> >
> >
> > Abstract Class Controller\_Base {
> >
> >
> >
> > protected $registry;
> >
> >
> >
> >
> >
> > function \_\_construct($registry) {
> >
> >
> >
> > $this->registry = $registry;
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > abstract function index();
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > ?>
> >
> >
> >
> >
>
>
>
>
>
> Этот абстрактный класс будет родительским классом для всех наших контроллеров. Он будет делать всего лишь две вещи: сохранять локальную копию класса Registry и при помощи абстрактного метода index() заставлять все дочерние контроллеры реализовывать этот метод.
>
>
>
> Напишем наш первый контроллер. Создадим файл index.php в директории controllers и вставим в него такой код:
>
>
>
>
> > php<br/
> >
> >
> >
> >
> > Class Controller\_Index Extends Controller\_Base {
> >
> >
> >
> >
> >
> > function index() {
> >
> >
> >
> > echo 'Hello from my MVC system';
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > ?>
> >
> >
> >
> >
>
>
>
>
>
> Только что мы создали наш первый контроллер и, если попробовать запустить систему, то можно увидеть следующее:
>
> 
>
>
>
> [(Полный размер, 1024x357, 115 КБ)](http://www.phpit.net/demo/simple%20mvc%20php5/1.jpg)
>
>
>
>
>
> Это означает, что класс Router выполнил свою работу и запустил требуемое действие из требуемого контроллера. Давайте напишем ещё один контроллер, который будет соответствовать запросу «members/view». Создадим файл members.php в директории контроллеров и вставим в него такой код:
>
>
>
>
> > php<br/
> >
> >
> >
> >
> > Class Controller\_Members Extends Controller\_Base {
> >
> >
> >
> >
> >
> > function index() {
> >
> >
> >
> > echo 'Default index of the `members` controllers';
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > function view() {
> >
> >
> >
> > echo 'You are viewing the members/view request';
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > ?>
> >
> >
> >
> >
>
>
>
>
>
> Теперь зайдём в нашу MVC-систему по запросу «members/view» или же «index.php?route=members/view». Мы должны увидеть такой результат:
>
>
>
> 
>
>
>
> [(Полный размер, 1024x320, 117 КБ)](http://www.phpit.net/demo/simple%20mvc%20php5/2.jpg)
>
>
>
>
>
> Только лишь написанием нового контроллера и добавлением в него метода, мы смогли создать новую страницу, и ничего не пришлось менять в самой системе. Кроме того, нашим контроллерам не нужно подключать файл global.php или делать что-нибудь в таком роде.
>
>
>
> Теперь, когда у нас есть контроллеры, осталась лишь одна вещь: «V» или «View» («Отображение»).
>
>
>
>
>
>
>
> Отображение
> -----------
>
>
>
> Как и в случае с моделями, есть несколько различных вариантов создания компоненты View в MVC-системе. Мы могли бы научить класс Router автоматически загружать ещё один файл, названный как-нибудь так: «view\_{имя}.php». Но чтобы сделать руководство более понятным, напишем класс Template, который будет заниматься выводом шаблонов.
>
>
>
> Сначала создадим файл template.php в директории classes и вставим в него следующий код:
>
>
>
>
> > php<br/
> >
> >
> >
> >
> > Class Template {
> >
> >
> >
> > private $registry;
> >
> >
> >
> > private $vars = array();
> >
> >
> >
> >
> >
> > function \_\_construct($registry) {
> >
> >
> >
> > $this->registry = $registry;
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > ?>
> >
> >
> >
> >
>
>
>
>
>
> Теперь у нас есть основная структура нашего класс Template. Следующим шагом добавим такой код в файл index.php прямо перед строками, связанными с классом Router:
>
>
>
>
> > # Создаём объект шаблонов
> >
> >
> >
> > $template = new Template($registry);
> >
> >
> >
> > $registry->set ('template', $template);
> >
> >
> >
> >
>
>
>
>
>
> Так как нам понадобится использовать значения из моделей и контроллеров, то напишем метод set() для установки переменных, доступных в шаблонах. Посмотрим на пример:
>
>
>
>
> > function set($varname, $value, $overwrite=false) {
> >
> >
> >
> > if (isset($this->vars[$varname]) == true AND $overwrite == false) {
> >
> >
> >
> > trigger\_error ('Unable to set var `' . $varname . '`. Already set, and overwrite not allowed.', E\_USER\_NOTICE);
> >
> >
> >
> > return false;
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > $this->vars[$varname] = $value;
> >
> >
> >
> > return true;
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > function remove($varname) {
> >
> >
> >
> > unset($this->vars[$varname]);
> >
> >
> >
> > return true;
> >
> >
> >
> > }
> >
> >
> >
> >
> >
> > Методы set() и remove() достаточно простые и используются, соответственно, для установки и удаления переменных.
> >
> >
> >
> > Займёмся написанием метода show(), который будет отображать шаблоны. Простейший путь – это создать отдельную директорию templates, где хранить все файлы шаблонов, и использовать include() для вывода шаблона. Разумеется, Ваш собственный метод show() может быть совершенно другим и загружать шаблоны из базы данных или делать что-нибудь ещё. Посмотрим на кусо
>
> | https://habr.com/ru/post/31270/ | null | ru | null |
# Строим свою вкладку на ленте (Ribbon) AutoCad средствами .Net (C#)
В данной публикации мы рассмотрим пример программного построения собственной вкладки на ленте, а также несколько проблемных вопросов, связанных с лентой.
В последнее время стало очень популярным нововведение под названием лента (Ribbon). Autodesk не стал отставать от жизни и, начиная с 2009 автокада, тоже начал использовать ленту.
Мы рассмотрим пример создания вкладки на ленте для 2010 автокада и рассмотрим несколько сопутствующих «проблемных» вопросов. Почему для него? Да потому что в 2009 лента была еще «сырая» (но там тоже можно так сделать), и потому что для последующих автокадов (2011-2013) код будет анологичен.
Вариантов добавить свою вкладку на ленту несколько:
* создать файл АПИ (cui) со своей лентой и подгружать его. На мой взгляд самый плохой и проблемный вариант. ИМХО
* создать вкладку на ленте программно — этот вариант и рассмотрим
* создать вкладку используя технологию WPF — я не стал разбираться
**Примечание**: Я не буду углубляться в каждую мелочь и «красиво» все описывать — пример не сложный. Да и я так красиво излагать не умею.
Пример рассматривается с учетом, что вы знаете как писать (хотя бы самые простые) плагины для автокада средствами .net. Для работы я использую Microsoft Visual Studio 2010.
Итак, приступим:
1. Открываем VS2010 и создаем новый проект:
2. Далее к нашему проекту подключаем ссылки:
* Проект —> Добавить ссылку —> вкладка «Обзор» —> из папки с автокадом 2010 выбираем файлы: **acdbmgd.dll**, **acmgd.dll**, **AdWindows.dll**. Не забываем в свойствах этих файлов поставить значение **false** для параметра **Копировать локально**;
* Проект —> Добавить ссылку —> вкладка «NET» —> добавляем ссылки на следующие библиотеки: **PresentationCore**, **PresentationFramework**, **WindowsBase**.
3. Теперь рассмотрим из чего состоит лента на примере этой картинки:
Тут в принципе и описывать нечего.
4. Добавляем в наш проект две иконки размерами 16х16 и 32х32 в формате .png. Так, как я ленивый, то использовал одинаковую картинку первую попавшеюся на просторах интернет.
Главное для этих файлов поставить значение **Resource** для параметра **Действие при построение**:
5. Переходим к коду. Открываем файл Class1.cs (или можете свой создать), удаляем класс Class1 и создаем свой собственный класс, унаследованный от **IExtensionApplication**. Назовем его **ExampleRibbon**.
Далее я хотел как-то пошагово описать все действия, но решил, что удобней и понятней будет сразу привести весь код с пояснениями:
**Весь основной код проекта**
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
// Acad
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.Windows;
using acadApp = Autodesk.AutoCAD.ApplicationServices.Application;
namespace ACadRibbon
{
public class ExampleRibbon : IExtensionApplication
{
// Инициализация нашего плагина
public void Initialize()
{
/* ленту грузим с помощью обработчика событий:
* Этот вариант нужно использовать, если ваш плагин
* стоит в автозагрузке, т.к. он (плагин) инициализируется
* до построения ленты
*/
//Autodesk.Windows.ComponentManager.ItemInitialized += new EventHandler(ComponentManager_ItemInitialized);
// Т.к. мы грузим плагин через NETLOAD, то строим вкладку в ленте сразу
BuildRibbonTab();
}
// Происходит при закрытии автокада
public void Terminate()
{
// Тут в принципе ничего не требуется делать
}
/* Обработчик события
* Следит за событиями изменения окна автокада.
* Используем его для того, чтобы "поймать" момент построения ленты,
* учитывая, что наш плагин уже инициализировался
*/
void ComponentManager_ItemInitialized(object sender, Autodesk.Windows.RibbonItemEventArgs e)
{
// Проверяем, что лента загружена
if (Autodesk.Windows.ComponentManager.Ribbon != null)
{
// Строим нашу вкладку
BuildRibbonTab();
//и раз уж лента запустилась, то отключаем обработчик событий
Autodesk.Windows.ComponentManager.ItemInitialized -=
new EventHandlerRibbonItemEventArgs>(ComponentManager_ItemInitialized);
}
}
// Построение вкладки
void BuildRibbonTab()
{
// Если лента еще не загружена
if (!isLoaded())
{
// Строим вкладку
CreateRibbonTab();
// Подключаем обработчик событий изменения системных переменных
acadApp.SystemVariableChanged += new SystemVariableChangedEventHandler(acadApp_SystemVariableChanged);
}
}
// Проверка "загруженности" ленты
bool isLoaded()
{
bool _loaded = false;
RibbonControl ribCntrl = Autodesk.Windows.ComponentManager.Ribbon;
// Делаем итерацию по вкладкам ленты
foreach (RibbonTab tab in ribCntrl.Tabs)
{
// И если у вкладки совпадает идентификатор и заголовок, то значит вкладка загружена
if (tab.Id.Equals("RibbonExample_ID") & tab.Title.Equals("RibbonExample"))
{ _loaded = true; break; }
else _loaded = false;
}
return _loaded;
}
/* Удаление своей вкладки с ленты
* В данном примере не используем
*/
void RemoveRibbonTab()
{
try
{
RibbonControl ribCntrl = Autodesk.Windows.ComponentManager.Ribbon;
// Делаем итерацию по вкладкам ленты
foreach (RibbonTab tab in ribCntrl.Tabs)
{
if (tab.Id.Equals("RibbonExample_ID") & tab.Title.Equals("RibbonExample"))
{
// И если у вкладки совпадает идентификатор и заголовок, то удаляем эту вкладку
ribCntrl.Tabs.Remove(tab);
// Отключаем обработчик событий
acadApp.SystemVariableChanged -= new SystemVariableChangedEventHandler(acadApp_SystemVariableChanged);
// Останавливаем итерацию
break;
}
}
}
catch (Autodesk.AutoCAD.Runtime.Exception ex)
{
Autodesk.AutoCAD.ApplicationServices.Application.
DocumentManager.MdiActiveDocument.Editor.WriteMessage(ex.Message);
}
}
/* Обработка события изменения системной переменной
* Будем следить за системной переменной WSCURRENT (текущее рабочее пространство),
* чтобы наша вкладка не "терялась" при изменение рабочего пространства
*/
void acadApp_SystemVariableChanged(object sender, SystemVariableChangedEventArgs e)
{
if (e.Name.Equals("WSCURRENT")) BuildRibbonTab();
}
// Создание нашей вкладки
void CreateRibbonTab()
{
try
{
// Получаем доступ к ленте
RibbonControl ribCntrl = Autodesk.Windows.ComponentManager.Ribbon;
// добавляем свою вкладку
RibbonTab ribTab = new RibbonTab();
ribTab.Title = "RibbonExample"; // Заголовок вкладки
ribTab.Id = "RibbonExample_ID"; // Идентификатор вкладки
ribCntrl.Tabs.Add(ribTab); // Добавляем вкладку в ленту
// добавляем содержимое в свою вкладку (одну панель)
addExampleContent(ribTab);
// Делаем вкладку активной (не желательно, ибо неудобно)
//ribTab.IsActive = true;
// Обновляем ленту (если делаете вкладку активной, то необязательно)
ribCntrl.UpdateLayout();
}
catch (System.Exception ex)
{
Autodesk.AutoCAD.ApplicationServices.Application.
DocumentManager.MdiActiveDocument.Editor.WriteMessage(ex.Message);
}
}
// Строим новую панель в нашей вкладке
void addExampleContent(RibbonTab ribTab)
{
try
{
// создаем panel source
RibbonPanelSource ribSourcePanel = new RibbonPanelSource();
ribSourcePanel.Title = "RibbonExample";
// теперь саму панель
RibbonPanel ribPanel = new RibbonPanel();
ribPanel.Source = ribSourcePanel;
ribTab.Panels.Add(ribPanel);
// создаем пустую tooltip (всплывающая подсказка)
RibbonToolTip tt;
// создаем split button
RibbonSplitButton risSplitBtn = new RibbonSplitButton();
/* Для RibbonSplitButton ОБЯЗАТЕЛЬНО надо указать
* свойство Text, а иначе при поиске команд в автокаде
* будет вылетать ошибка.
*/
risSplitBtn.Text = "RibbonSplitButton";
// Ориентация кнопки
risSplitBtn.Orientation = System.Windows.Controls.Orientation.Vertical;
// Размер кнопки
risSplitBtn.Size = RibbonItemSize.Large;
// Показывать изображение
risSplitBtn.ShowImage = true;
// Показывать текст
risSplitBtn.ShowText = true;
// Стиль кнопки
risSplitBtn.ListButtonStyle = Autodesk.Private.Windows.RibbonListButtonStyle.SplitButton;
risSplitBtn.ResizeStyle = RibbonItemResizeStyles.NoResize;
risSplitBtn.ListStyle = RibbonSplitButtonListStyle.List;
/* Далее создаем две кнопки и добавляем их
* не в панель, а в RibbonSplitButton
*/
#region Кнопка-пример №1
// Создаем новый экземпляр подсказки
tt = new RibbonToolTip();
// Отключаем вызов справки (в данном примере её нету)
tt.IsHelpEnabled = false;
// Создаем кнопку
RibbonButton ribBtn = new RibbonButton();
/* В свойство CommandParameter (параметры команды)
* и в свойство Command (отображает команду) подсказки
* пишем вызываемую команду
*/
ribBtn.CommandParameter = tt.Command = "_Line";
// Имя кнопки
ribBtn.Name = "ExampleButton1";
// Заголовок кнопки и подсказки
ribBtn.Text = tt.Title = "Кнопка-пример №1";
// Создаем новый (собственный) обработчик команд (см.ниже)
ribBtn.CommandHandler = new RibbonCommandHandler();
// Ориентация кнопки
ribBtn.Orientation = System.Windows.Controls.Orientation.Horizontal;
// Размер кнопки
ribBtn.Size = RibbonItemSize.Large;
/* Т.к. используем размер кнопки Large, то добавляем
* большое изображение с помощью специальной функции (см.ниже)
*/
ribBtn.LargeImage = LoadImage("icon_32");
// Показывать картинку
ribBtn.ShowImage = true;
// Показывать текст
ribBtn.ShowText = true;
// Заполняем содержимое всплывающей подсказки
tt.Content = "Я кнопочка №1. Нажми меня и я нарисую отрезок";
// Подключаем подсказку к кнопке
ribBtn.ToolTip = tt;
// Добавляем кнопку в RibbonSplitButton
risSplitBtn.Items.Add(ribBtn);
#endregion
// Делаем текущей первую кнопку
risSplitBtn.Current = ribBtn;
// Далее создаем вторую кнопку по аналогии с первой
#region Кнопка-пример №2
tt = new RibbonToolTip();
tt.IsHelpEnabled = false;
ribBtn = new RibbonButton();
ribBtn.CommandParameter = tt.Command = "_Pline";
ribBtn.Name = "ExampleButton2";
ribBtn.Text = tt.Title = "Кнопка-пример №2";
ribBtn.CommandHandler = new RibbonCommandHandler();
ribBtn.Orientation = System.Windows.Controls.Orientation.Horizontal;
ribBtn.Size = RibbonItemSize.Large;
ribBtn.LargeImage = LoadImage("icon_32");
ribBtn.ShowImage = true;
ribBtn.ShowText = true;
tt.Content = "Я кнопочка №2. Нажми меня и я нарисую полилинию";
ribBtn.ToolTip = tt;
risSplitBtn.Items.Add(ribBtn);
#endregion
// Добавляем RibbonSplitButton в нашу панель
ribSourcePanel.Items.Add(risSplitBtn);
// Создаем новую строку
RibbonRowPanel ribRowPanel = new RibbonRowPanel();
// Создаем третью кнопку по аналогии с предыдущими.
// Отличие только в размере кнопки (и картинки)
#region Кнопка-пример №3
tt = new RibbonToolTip();
tt.IsHelpEnabled = false;
ribBtn = new RibbonButton();
ribBtn.CommandParameter = tt.Command = "_Circle";
ribBtn.Name = "ExampleButton3";
ribBtn.Text = tt.Title = "Кнопка-пример №3";
ribBtn.CommandHandler = new RibbonCommandHandler();
ribBtn.Orientation = System.Windows.Controls.Orientation.Vertical;
ribBtn.Size = RibbonItemSize.Standard;
ribBtn.Image = LoadImage("icon_16");
ribBtn.ShowImage = true;
ribBtn.ShowText = false;
tt.Content = "Я кнопочка №3. Нажми меня и я нарисую кружочек";
ribBtn.ToolTip = tt;
ribRowPanel.Items.Add(ribBtn);
#endregion
// Добавляем строку в нашу панель
ribSourcePanel.Items.Add(ribRowPanel);
}
catch (System.Exception ex)
{
Autodesk.AutoCAD.ApplicationServices.Application.
DocumentManager.MdiActiveDocument.Editor.WriteMessage(ex.Message);
}
}
// Получение картинки из ресурсов
// Данная функция найдена на просторах интернет
System.Windows.Media.Imaging.BitmapImage LoadImage(string ImageName)
{
return new System.Windows.Media.Imaging.BitmapImage(
new Uri("pack://application:,,,/ACadRibbon;component/" + ImageName + ".png"));
}
/* Собственный обраотчик команд
* Это один из вариантов вызова команды по нажатию кнопки
*/
class RibbonCommandHandler : System.Windows.Input.ICommand
{
public bool CanExecute(object parameter)
{
return true;
}
public event EventHandler CanExecuteChanged;
public void Execute(object parameter)
{
Document doc = acadApp.DocumentManager.MdiActiveDocument;
if (parameter is RibbonButton)
{
// Просто берем команду, записанную в CommandParameter кнопки
// и выпоняем её используя функцию SendStringToExecute
RibbonButton button = parameter as RibbonButton;
acadApp.DocumentManager.MdiActiveDocument.SendStringToExecute(
button.CommandParameter + " ", true, false, true);
}
}
}
}
}
```
6. Все — код готов. Компилируем его (Построение —> Построить решение), открываем автокад 2010, выполняем команду **NETLOAD** и выбираем наш плагин ...\ACadRibbon\ACadRibbon\bin\Debug\ACadRibbon.dll.
И сразу же после загрузки мы увидим, что у нас добавилась новая вкладка на ленте:
Данный вариант активно используется в моем плагине [ModPlus](http://modplus.org/) и пока не вызвал нареканий.
Надеюсь, пример окажется полезным! | https://habr.com/ru/post/263373/ | null | ru | null |
# (Более) точное измерение динамического диапазона сенсора камеры
### Вступление
Всем привет! В этом посте поговорим о том, как (более) точно измерять динамический диапазон сенсора камеры и что с этими замерами можно сделать.
Разумеется, я не являюсь специалистом по компьютерному зрению, программистом или статистиком, поэтому не стесняйтесь поправлять меня в комментариях, если я допускаю в этом посте ошибки. Здесь мой интерес был в основном направлен на повседневные и прикладные задачи, такие как фотография, но я считаю, что результат может быть полезен также и специалистам по компьютерному зрению.
Существующая проблема
---------------------
Динамический диапазон современных сенсоров изображения ограничен, мы не можем захватывать детали сразу в очень ярких светах и очень тёмных тенях без ухудшения качества изображения из-за шума. Вообще, шум, на мой взгляд, сегодня является самым ограничивающим фактором качества изображения. Чем темнее сцена, тем больше в тенях шума, который с затемнением всё больше и больше увеличивается по амплитуде и всё больше "съедает" детали, прежде всего у малоконтрастных объектов.
Зачем измерять динамический диапазон
------------------------------------
Вообще, точные измерения динамического диапазона могут использоваться как фотографами (причём не только любителями, но и профессионалами), так и специалистами по компьютерному зрению с целью оценки какого-либо оборудования.
Во-первых, измерения помогут ответить на вопрос, какую камеру или сенсор выбрать для будущих задач или стоит ли совершать апгрейд - насколько преимущество будет заметно. Во-вторых, благодаря измерениям можно проанализировать существующую камеру или сенсор с целью поиска оптимальной стратегии экспонирования и постобработки, а также использовать данные для дальнейших исследований.
Как сейчас измеряется динамический диапазон сенсоров
----------------------------------------------------
*В этой главе я использую метод и данные Билла Клэффа (Bill Claff) с сайта* [*Photons to Photos*](https://www.photonstophotos.net/)*.*
[Текущий метод измерения динамического диапазона](https://www.photonstophotos.net/GeneralTopics/Sensors_&_Raw/Sensor_Analysis_Primer/Engineering_and_Photographic_Dynamic_Range.htm) начинается с построения графика соотношения сигнала к шуму для нужного ISO при разных значениях экспозиции, как показано на иллюстрации ниже:
Вообще, существуют инженерный и так называемый фотографический динамический диапазон. Вот что мистер Клэфф пишет относительно первого:
> The low endpoint for Engineering Dynamic Range is determined by where the SNR curve crosses the value of 1.
>
> Here is an extreme close-up of that area of the Photon Transfer Curve:
>
>
> The ISO 100 line crosses 0 (the log2(1)) at 1.63 EV.
>
> So Engineering Dynamic Range is 14.00 EV - 1.63 EV = 12.37 EV.
>
> Or, if we use the White Level (from [White Level](https://www.photonstophotos.net/GeneralTopics/Sensors_&_Raw/Sensor_Analysis_Primer/White_Level.htm)), (14.00 EV - 0.11 EV) - 1.63 EV = 12.26 EV.
>
>
Для сравнения, вот определение так называемого фотографического динамического диапазона:
> My definition of Photographic Dynamic Range is a low endpoint with an SNR of 20 when adjusted for the appropriate Circle Of Confusion (COC) for the sensor.
>
> For the D300 the SNR values on this curve is for a 5.5 micron square photosite.
>
> To correct for a COC of .022mm we are looking for a log2 SNR value of 2.49.
>
> Here is an close-up of the area of the curve:
>
>
> Note that the ISO 100 crosses 2.49 at 5.00 EV.
>
> So Photographic Dynamic Range at ISO 100 is 14.00 EV - 5.00 EV = 9.00 EV.
>
> Or, if we use the White Level (from [White Level](https://www.photonstophotos.net/GeneralTopics/Sensors_&_Raw/Sensor_Analysis_Primer/White_Level.htm)), (14.00 EV - 0.11 EV) - 5.00 EV = 8.89 EV.
>
>
Графики, полученные после таких измерений, можно найти здесь - [Photographic Dynamic Range versus ISO Setting](https://www.photonstophotos.net/Charts/PDR.htm)
Например, так выглядят данные для Pentax K-1:
Однако выбирать стратегию экспонирования лишь по этому графику - не лучшая идея, ведь некоторые камеры являются так называемыми ISO-less, то есть поднятие ISO в камере до захвата снимка не приведёт к улучшению шумных деталей в тенях, а лишь уничтожит детали в светах.
Поэтому также нужен другой график - вот такой - [улучшение теней против значения ISO](https://www.photonstophotos.net/Charts/PDR_Shadow.htm):
Действительно, выбранная камера оказалась ISO-less, то есть повышение ISO выше 100 не приведёт к улучшению деталей в тенях.
Для наглядности, вот два кадра с той же камеры [от DPReview](https://www.dpreview.com/reviews/image-comparison/fullscreen?attr134_0=pentax_k1&attr134_1=pentax_k1&attr134_2=pentax_k1&attr134_3=pentax_k1&attr136_0=6&attr136_1=1&attr136_2=3&attr136_3=2&attr403_0=1&attr403_1=1&attr403_2=1&attr403_3=1&normalization=full&widget=487&x=0.151173145&y=0.5005349) - один на ISO 3200 с осветлением на стоп, другой на ISO 100 с остветлением на 6 стопов:
Но это работает не для всех камер. Например, вот Canon 6D, тут поднятие ISO действительно улучшает тени:
Нельзя сказать, что только из-за этого камера обязательно лучше или хуже, но это влияет на выбор оптимальной стратегии экспонирования при съёмке.
Недостаток такого метода измерений
----------------------------------
Проблема в таком классическом подходе появляется тогда, когда в камере используется шумодав. Да, это по прежнему сырые файлы, просто он может быть использован ещё до демозаика. Как видно на графике ниже, динамический диапазон резко взлетает на ISO 640:
Это совсем не значит, что качество изображения стало действительно лучше. Наоборот, шумодав мог уничтожить некоторые мелкие детали.
На графике улучшения теней всё ещё нагляднее - преимущество достигает почти 2 стопов:
На самом деле, как вы понимаете, в реальности всё будет не так классно. В этом и проблема классического способа замеров - алгоритмы DSP, такие как шумоподавление и восстановление деталей, можно лишь обнаружить (что и значат перевёрнутые треугольники на графике), но нельзя оценить их реальное влияние на качество изображения.
Более совершенный метод измерения динамического диапазона
---------------------------------------------------------
Вы наверняка знаете библиотеку [libraw](https://www.libraw.org/) и, возможно, даже пользуетесь ей. Разработчик этой библиотеки Алексей Тутубалин [предложил](https://blog.lexa.ru/2017/08/25/novyy_staryy_podhod_k_dinamicheskomu_diapazonu_na_primere_kamery_canon_eos_5d_iv.html) свой вариант измерения динамического диапазона ещё в 2017 году. Он задался вопросом того, сколько реального разрешения остаётся на снимке вследствие воздействия шума - для этого Алексей использовал малоконтрастную повёрнутую мишень для тестирования разрешения. Повёрнута она была, чтобы усложнить работу DSP внутри камеры, если такие алгоритмы в ней имеются. Выглядело это вот так:
После серий снимков и анализа результатов в полуавтоматическом режиме был получен вот такой интересный график:
На мой взгляд, данные получились невероятно полезными и наглядными, но мне хотелось повторить результат, используя полностью автоматические замеры и метрики, при этом чтобы разработанный метод был доступен каждому в домашних условиях.
Предлагаемое решение
--------------------
Я считаю, что разрешение нельзя тестировать с помощью специальных мишеней из-за возможных попыток читерства со стороны камеры. При этом мишень должна иметь разрешение, то есть детализацию, выше разрешения сенсора. Получается, нам нужна мишень с большим количеством мелких деталей, которые невозможно подделать - а тогда это просто шум. Но мы не можем взять обычный шум, ведь он будет уменьшаться по мере удаления камеры от мишени, поэтому нам нужен специальный, scale-invariant розовый шум.
Imatest продают такие мишени за $330:
Я же просто распечатал такой квадратик на обычном принтере на листочке A4.
К сожалению, у меня нет отдельной камеры, поэтому тестирование проводилось на обычном телефоне с сенсором SONY IMX686. Я использовал приложение [FreeDCam](https://github.com/KillerInk/FreeDcam), которым управлял через компьютер с помощью [scrcpy](https://github.com/Genymobile/scrcpy), чтобы не двигать телефон между кадрами (в случае с реальной камерой её надо было бы поставить на штатив и так же дистанционно управлять с компьютера). После этого я сделал серии снимков получившейся мишени на разных ISO с разной экспозицией, от 1 до 12 стопов ниже насыщения сенсора (внимательные читатели заметят, что на самом деле линии на графике ниже обрываются раньше 12 стопов на ISO 3200 и 6400 - во FreeDCam просто нет настолько коротких значений выдержки). Полученные кадры были сконвертированы в линейный 16-битный TIFF без демозаика, но с балансом белого, который был применён через усиление каналов, а затем проанализированы относительно референсного кадра - 10 усреднённых кадров мишени, снятых на стоп ниже насыщения сенсора - аналог кадра на ISO 5 с идеальной экспозицией.
Получился вот такой график соотношения сигнал/шум:
В отличие от графика мистера Клэффа, этот график если не полностью, то хотя бы частично устойчив к DSP - прошу обратить внимание на нижние значения на ISO 3200 и 6400 - это, вероятно, шумодав. Хотя график не полностью избавлен от его влияния, улучшения относительно верхних значений не случилось, а значит полученные данные имеют более высокое качество, чем те, которые были бы получены стандартным способом. На самом деле, я тестировал конкретно свой телефон не с розовым шумом, поэтому реальный розовый шум (который можно сгенерировать, например, используя функции [отсюда](https://github.com/VileBile/colorednoise_2d)), вероятно, только улучшит результат.
Вместо построения графиков классическим способом, я решил пойти дальше и построить график как у Алексея Тутубалина, только, опять же, используя данные, полученные в полностью автоматическом режиме и, как я надеюсь, с большей точностью. Для этого я написал и использовал вот такую функцию numpy:
```
def find_real_resolution(image_resolution, ground_truth, noisy_image):
stock_contrast = np.max(ground_truth) / np.min(ground_truth)
noise = np.mean(np.abs(noisy_image - ground_truth))
real_contrast = (np.max(ground_truth) - noise) / (np.min(ground_truth) + noise)
contrast_change_coefficient = stock_contrast / real_contrast
real_resolution = image_resolution / contrast_change_coefficient
return real_resolution
```
Подробнее о ней`image_resolution` - разрешение всего кадра (так как в данном случае тестировалась лишь его обрезанная часть 100x100 пикселей), `ground_truth` - референсное изображение, `noisy_image` - тестируемое изображение из серии. Как вы понимаете, все кадры в сериях надо просто прогнать через эту функцию. Но что же она делает?
Давайте ещё раз посмотрим на мишень для тестирования разрешения:
В худшем случае шум уменьшит значение белого фона и увеличит значение чёрных линий, что приведёт к понижению контраста, а тогда и к падению разрешения для данной мишени. Поэтому я просто сначала нахожу "средний шум" каждого кадра (строка 2 внутри функции), после чего вычитаю его из точки белого референсного изображения и прибавляю к точке чёрного того же изображения (строка 3). Затем сравниваю (строка 4) исходную (строка 1) и новую (строка 3) контрастность, после чего просто делю (строка 5) всё разрешение кадра на данный коэффициент и получаю реальное разрешение.
Получился вот такой график:
*Значения ниже 0 приведены лишь для наглядности.*
Как и было сказано ранее, такой график можно использовать для сравнения двух сенсоров, чтобы понять, например, какой из них выбрать для определённых условий освещения. Или же можно исследовать график только этого сенсора для определения оптимальной стратегии экспонирования, а также разработки наилучших алгоритмов постобработки, например, того же шумоподавления.
Дальнейшее исследование
-----------------------
В качестве дальнейшей работы я бы хотел отметить следующие возможности:
* Разделение фильтра Байера на каналы до анализа. Если пиксели автофокуса у камеры только, например, синие, интересно сравнить их с теми, у которых автофокуса нет (то есть, например, с одним из зелёных каналов)
* Использование этого метода для несырых, обработанных изображений. Это будет полезно, если нужно не только визуально оценить работу алгоритмов шумоподавления при постобработке, но и узнать, сколько реальных деталей они оставляют. Это также может помочь при разработке каких-либо новых алгоритмов, связанных с восстановлением деталей и уменьшением шума, даже нейросетевых
* Модификация метода с целью использования на видео - можно показывать новое изображение розового шума покадрово на высокогерцовом мониторе. Однако программа, проводящая анализ такого видео, должна знать, в какой момент какой кадр был показан - очевидно, для этого можно выводить какую-либо вспомогательную информацию (например, номер кадра, возможно, закодированный в QR-код) сбоку от основной мишени. Но в итоге такая система будет устойчива даже в временны́м методам шумоподавления, которые как раз используются на видео
* Использование более точных вычислений, возможно, опирающихся на статистический анализ, для подсчёта реального разрешения
* Использование различных метрик оценки качества изображения для представления результатов. Вот, например, SSIM:
На этом всё, спасибо, что прочитали! | https://habr.com/ru/post/709634/ | null | ru | null |
# SOLID == ООП?
Наверное я не ошибусь, если скажу, что чаще всего на собеседованиях спрашивают о SOLID принципах. Технологии, языки и фреймворки разные, но принципы написания кода в целом похожи: SOLID, KISS, DRY, YAGNI, GRASP и подобные стоит знать всем.
В современной индустрии уже много десятков лет доминирует парадигма ООП и у многих разработчиков складывается впечатление, что она лучшая или и того хуже — единственная. На эту тему есть прекрасное видео [Why Isn't Functional Programming the Norm?](https://www.youtube.com/watch?v=QyJZzq0v7Z4) про развитие языков/парадигм и корни их популярности.
SOLID изначально были описаны Робертом Мартином для ООП и многими воспринимаются как относящиеся только к ООП, даже [википедия](https://en.wikipedia.org/wiki/SOLID) говорит нам об этом, давайте же рассмотрим так ли эти принципы привязаны к ООП?
#### Single Responsibility
Давайте пользоваться пониманием SOLID от [Uncle Bob](http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod):
> This principle was described in the work of Tom DeMarco and Meilir Page-Jones. They called it cohesion. They defined cohesion as the functional relatedness of the elements of a module. In this chapter we’ll shift that meaning a bit, and relate cohesion to the forces that cause a module, or a class, to change.
Каждый модуль должен иметь одну причину для изменений (а вовсе не делать одну вещь, как многие отвечают) и как объяснял сам автор в одном из видео — это означает, что изменения должны исходить от одной группы/роли людей, например модуль должен меняться только по запросам бизнес-аналитика, дизайнера, DBA специалиста, бухгалтера или юриста.
Обратите внимание, этот принцип относится к модулю, видом которого в ООП является класс. Модули есть практически во всех языках, выходит этот принцип не ограничен ООП.
#### Open Closed
> SOFTWARE ENTITIES (CLASSES, MODULES, FUNCTIONS, ETC.) SHOULD BE OPEN FOR EXTENSION, BUT CLOSED FOR MODIFICATION
>
> Bertrand Meyer
Этот принцип обычно почему-то вызывает наибольшие проблемы у людей, но суть его довольно проста — проектируя модуль следует использовать абстракции, заменяя реализацию которых можно изменять поведение модуля (расширять его) без необходимости менять его код.
При этом функция это одна из лучших абстракций (исходя из принципа сегрегации интерфейсов, о котором позже). Использование функций для обеспечения этого принципа настолько удобно, что подход уже прочно перекочевал из функциональных языков во все основные ООП языки. Для примера можно взять функции `map`, `filter`, `reduce`, которые позволяют менять свой функционал прямой передачей кода в виде функции. Более того, весь этот функционал можно получить используя только одну функцию `foldLeft` без изменения ее кода!
```
def map(xs: Seq[Int], f: Int => Int) =
xs.foldLeft(Seq.empty) { (acc, x) => acc :+ f(x) }
def filter(xs: Seq[Int], f: Int => Boolean) =
xs.foldLeft(Seq.empty) { (acc, x) => if (f(x)) acc :+ x else acc }
def reduce(xs: Seq[Int], init: Int, f: (Int, Int) => Int) =
xs.foldLeft(init) { (acc, x) => f(acc, x) }
```
Выходит, что этот принцип тоже не ограничен ООП, более того — некоторые подходы приходиться заимствовать из других парадигм.
#### Liskov Substitution
Обратимся к самой [Барбаре](https://en.wikipedia.org/wiki/Barbara_Liskov):
> If for each object `o1` of type `S` there is an object `o2` of type `T` such that for all programs `P` defined in terms of `T`, the behavior of `P` is unchanged when `o1` is substituted for `o2` then `S` is a subtype of `T`.
Немного заумно, но в целом этот принцип требует, что бы объекты "подтипа" можно было подставить в любую программу вместо объектов родительского типа и поведение программы не должно поменяться. Обычно имеется в виду не полная идентичность поведения, а то, что ничего не сломается.
Как видите тут речь хоть и идет об "объектах", но ни слова о классах нет, "объект" тут это просто значение типа. Многие говорят о том, что этот принцип регламентирует наследование в ООП и они правы! Но принцип шире и может быть даже использован с другими видами полиморфизма, вот пример (немного утрированный конечно), который без всякого наследования нарушает этот принцип:
```
static T increment(T number) {
if (number instanceof Integer) return (T) (Object) (((Integer) number) + 1);
if (number instanceof Double) return (T) (Object) (((Double) number) + 1);
throw new IllegalArgumentException("Unexpected value "+ number);
}
```
Тут мы объявляем, что функция принимает тип `T`, не ограничивая его, что делает все типы его "подтипом" (т.е. компилятор позволяет передать в функцию объект любого типа), при этом функция ведет себя не так, как объявлена — работает не для всех типов.
Вообще люди, привыкли считать, что "полиморфизм" это один из принципов ООП, а значит [про наследование](https://habr.com/ru/post/37576), но это не так. Полиморфизм это способность кода работать с разными типами данных, потенциально неизвестными на момент написания кода, в данном случае это параметрический полиморфизм (собственно ошибочное его использование), в ООП используется полиморфизм включения, а существует еще и специальный (ad hoc) полиморфизм. И во всех случаях этот принцип может быть полезен.
#### Interface Segregation
Этот принцип говорит о том, что интерфейсы следует делать настолько минимальными, насколько это возможно, разделяя большие интерфейсы на мелкие по способам использования.
С одной стороны этот принцип говорит об интерфейсах, как о наборе функций, "протоколе" который обязуются выполнять реализации и казалось бы уж этот принцип точно про ООП! Но существуют другие схожие механизмы обеспечения полиморфизма, например классы типов (type classes), которые описывают протокол взаимодействия с типом отдельно от него.
Например вместо интерфейса `Comparable` в `Java` есть type class `Ord` в `haskell` (пусть слово `class` не вводит вас в заблуждение — `haskell` чисто функциональный язык):
```
// упрощенно
class Ord a where
compare :: a -> a -> Ordering
```
Это "протокол", сообщающий, что существуют типы, для которые есть функция сравнения `compare` (практически как интерфейс `Comparable`). Для таких классов типов принцип сегрегации прекрасно применим.
#### Dependency Inversion
> Depend on abstractions, not on concretions.
Этот принцип часто путают с Dependency Injection, но этот принцип о другом — он требует использования абстракций где это возможно, причем абстракций любого рода:
```
int first(ArrayList xs) // ArrayList это деталь реализации ->
int first(Collection xs) // Collection это абстракция ->
T first(Collection xs) // но и тип элемента коллекции это только деталь реализации
```
В этом функциональные языки пошли гораздо дальше чем ООП: они смогли абстрагироваться даже от эффектов (например асинхронности):
```
def sum[F[_]: Monad](xs: Seq[F[Int]]): F[Int] =
if (xs.isEmpty) 0.pure
else for (head <- xs.head; tail <- all(xs.tail)) yield head + tail
sum[Id](Seq(1, 2, 3)) -> 6
sum[Future](Seq(queryService1(), queryService2())) -> Future(6)
```
эта функция будет работать как с обычным списком чисел, так и со списком асинхронных запросов, которые должны вернуть числа.
---
Конечно про SOLID написано множество статей, так что моя цель тут не объяснять снова их смысл. Надеюсь мне удалось показать, что принципы SOLID более общие, чем ООП в сегодняшнем нашем его понимании. Не забывайте оглядываться по сторонам, докапываться до смысла и узнавать новое! | https://habr.com/ru/post/509430/ | null | ru | null |
# Прожектор угроз: Файловый вирус Neshta
***Салют, хабровчане! В преддверии старта курса [«Реверс-инжиниринг 2.0»](https://otus.pw/INUh/) хотим поделиться с вами еще одним интересным переводом.***
---
### Краткий обзор
Neshta — довольно старый файловый вирус, который до сих пор широко распространен. Изначально он был обнаружен в 2003 году и ранее ассоциировался с вредоносным ПО BlackPOS. Он добавляет вредоносный код в зараженные файлы. В основном эта угроза попадает в среду посредством непреднамеренной загрузки или с помощью других вредоносных программ. Он заражает исполняемые файлы Windows и может атаковать сетевые ресурсы и съемные носители.
В 2018 году Neshta преимущественно ориентировалась на обрабатывающую промышленность, но также атаковала финансовый, потребительский и энергетический секторы. В целях устойчивости в системе Neshta переименовывает себя в svchost.com, а затем изменяет реестр, чтобы он запускался каждый раз при запуске .exe файла. Известно, что эта угроза собирает системную информацию и использует POST запросы для эксфильтрации данных на сервера, контролируемые злоумышленниками. Двоичные файлы Neshta, использованные в нашем анализе, не продемонстрировали поведение или функциональность эксфильтрации данных.
### Технический анализ
В этом разделе описываются симптомы заражения Neshta. Мы взяли образцы вируса закачанные на VirusTotal в 2007, 2008 и 2019.
Мы проанализировали файлы со следующими SHA-256 хэшами:
* 29fd307edb4cfa4400a586d38116a90ce91233a3fc277de1cab7890e681c409a
* 980bac6c9afe8efc9c6fe459a5f77213b0d8524eb00de82437288eb96138b9a2
* 539452719c057f59238e123c80a0a10a0b577c4d8af7a5447903955e6cf7aa3d
* a4d0865565180988c3d9dbf5ce35b7c17bac6458ef234cfed82b4664116851f2
* 46200c11811058e6d1173a2279213d0b7ccde611590e427b3b28c0f684192d00
* c965f9503353ecd6971466d32c1ad2083a5475ce64aadc0b99ac13e2d2c31b75
### Статический анализ файла
Код Neshta скомпилирован с помощью Borland Delphi 4.0. Размер файла обычно составляет 41,472 байта.
Как и любой бинарный файл Delphi, Neshta имеет четыре записываемых (DATA, BSS, .idata и .tls) и три разделяемых секции (.rdata, .reloc и .rsrc):
*Рисунок 1. Особенности хедеров секций.*
Кроме того, код Neshta демонстрирует любопытные строки — см. рисунок 2 ниже:
> “Delphi-the best. F\*\*\* off all the rest. Neshta 1.0 Made in Belarus. Прывiтанне усiм ~цiкавым~ беларус\_кiм дзяучатам. Аляксандр Рыгоравiч, вам таксама :) Восень- кепская пара… Алiварыя — лепшае пiва! Best regards 2 Tommy Salo. [Nov-2005] yours [Dziadulja Apanas]”
>
> *(«Delphi — лучший. Остальные идут на\*\*\*. Neshta 1.0 Сделано в Беларуси. Привет всем ~ интересным ~ белорус\_ким девчонкам. Аляксандр Григорьевич, вам тоже :) Осень — плохая пара… Аливария — лучшее пиво! С наилучшими пожеланиями для Томми Сало. [Ноябрь-2005] ваш [Дедуля Апанас])»*
*Рисунок 2: Интересные строки в теле вируса*
### Заражение файлов
Основной особенностью Neshta является файловый заражатель, который ищет .exe файлы на локальных дисках. Neshta нацелен на «.exe» файлы, исключая лишь те, которые содержат в своем коротком пути любую из следующих строк:
* %Temp%
* %SystemRoot% (usually C:\Windows)
* \PROGRA~1\
Сводка процесса заражения описана ниже и на рисунке 3.
Neshta:
1. Считывает 41,472 (0xA200) байта с начала целевого исходного файла.
2. Создает два раздела и выделяет память с атрибутом PAGE\_READWRITE в начале и конце исходного файла.
3. Помещает свой вредоносный заголовок и код в начале исходного файла. Записанные данные составляют 41,472 байта.
4. Записывает закодированный исходный заголовок и код в файл, размер которого составляет 41,472 байта.
Эти действия позволяют запускать вредоносный код сразу после запуска зараженного файла:
*Рисунок 3: Заражение файла*
При запуске зараженного файла исходная программа помещается в ``%Temp%\3582-490\`` и запускается с помощью WinExec API.
### Устойчивость
Neshta помещает себя в `C:\Windows\svchost.com` и устанавливает себя в реестр, используя следующие параметры:
Ключ реестра: *HKLM\SOFTWARE\Classes\exefile\shell\open\command*
Значение реестра: *(Default)*
Значение: `%SystemRoot%\svchost.com "%1" %*`
Это изменение реестра предписывает системе запускать Neshta при каждом запуске .exe-файла. "%1" %\* указывает на запущенный файл .exe. Кроме того, Neshta создает именованный мьютекс для проверки существования другого работающего экземпляра:
`MutexPolesskayaGlush*.*<0x90>svchost.com<0x90>exefile\shell\open\command‹À "%1" %*œ‘@`
Еще один внедряемый файл — «directx.sys», который отправляется в %SystemRoot%. Это текстовый файл (а не драйвер ядра), который содержит путь к последнему зараженному файлу для запуска. Он обновляется каждый раз, когда исполняется зараженный файл.
### BlackBerry Cylance останавливает Neshta
BlackBerry Cylance использует агентов на основе искусственного интеллекта, обученных обнаружению угроз на миллионах как безопасных, так и небезопасных файлов. Наши автоматизированные агенты безопасности блокируют Neshta, основываясь на множестве атрибутов файлов и вредоносном поведении, вместо того, чтобы полагаться на конкретную подпись файла. BlackBerry Cylance, которая предлагает [прогнозное преимущество](https://threatvector.cylance.com/en_us/home/cylance-vs-future-threats-the-predictive-advantage.html) перед угрозами нулевого дня, обучена и эффективна против новых и известных кибератак. Для получения более подробной информации посетите [https://www.cylance.com](https://www.cylance.com/).
Приложение
----------
#### Показатели компрометации (IOCs)
* Хэши
o 29fd307edb4cfa4400a586d38116a90ce91233a3fc277de1cab7890e681c409a
o 980bac6c9afe8efc9c6fe459a5f77213b0d8524eb00de82437288eb96138b9a2
o 539452719c057f59238e123c80a0a10a0b577c4d8af7a5447903955e6cf7aa3d
o a4d0865565180988c3d9dbf5ce35b7c17bac6458ef234cfed82b4664116851f2
o 46200c11811058e6d1173a2279213d0b7ccde611590e427b3b28c0f684192d00
o c965f9503353ecd6971466d32c1ad2083a5475ce64aadc0b99ac13e2d2c31b75
* Имена файлов
o %SystemRoot%\svchost.com
o %SystemRoot%\directx.sys
o %Temp%\tmp5023.tmp
* C2s/IPs
* Мьютексы
o MutexPolesskayaGlush\*.\*<0x90>svchost.com<0x90>exefile\shell\open\command‹À "%1" %\*œ‘@
* Интересные строки
o Delphi-the best. F\*\*k off all the rest. Neshta 1.0 Made in Belarus. Прывiтанне усiм ~цiкавым~ беларус\_кiм дзяучатам. Аляксандр Рыгоравiч, вам таксама :) Восень- кепская пара… Алiварыя — лепшае пiва! Best regards 2 Tommy Salo. [Nov-2005] yours [Dziadulja Apanas]
| | |
| --- | --- |
| sha256 | 29fd307edb4cfa4400a586d38116a90ce91233a3fc277de1cab7890e681c409a |
| тип | pe32 executable (gui) intel 80386, for ms windows |
| размер | 41472 |
| timestamp | 1992:06:20 07:22:17+09:00 |
| itw | svchost[.]com |
---
[Узнать подробнее о курсе.](https://otus.pw/INUh/)
--- | https://habr.com/ru/post/498440/ | null | ru | null |
# Удобный доступ к файлам на удаленных хостах
На Хабре достаточно много разработчиков работают с файлами на удаленных хостах. На локальной машине запускается IDE, отладчик, все необходимое, а сами файлы находятся на сервере, где они регулярно бакапятся, автобилдятся, тестируются и так далее. Очень удобный рабочий вариант. Да я сам его использую.
Единственная проблема, доставляющая неудобство — файлы все же находятся на другом компе, и доступ к ним не такой простой и прозрачный как к «своим».
Под катом — как сделать такой доступ максимально удобным. **Чтобы он запускался автоматом когда надо, а самое главное — чтобы не запускался, когда не надо!**
Из всех вариантов удаленного доступа к файлам: SSHFS, NFS и виндошара — SMB (не к ночи будь помянут), я выбрал SSHFS по следующим причинам:
— Максимальная простота настройки
— Работает практически везде, не требует установки на сервер хитрых компонент
— Максимальная безопасность: клиента, сервера и передаваемых данных.
Установка на Ubuntu максимально проста:
`$ sudo apt-get install sshfs`
При этом автоматически установится в качестве зависимостей fuse-utils и libfuse2.
Так же должна создаться группа fuse и в modconf.d пропишется загрузка модуля fuse — впрочем это зависит от вашего дистрибутива, возможно это придется проверить и подправить руками.
Для пользователей Windows есть самурайская разработка [Dokan SSHFS](http://dokan-dev.net/en/download/). Качаем Dokan lib, потом dokan sshfs. Эта штука работает, но говорю сразу — я с ней практически не работал, может при длительной эксплуатации и вылезут какие-то проблемы.
Теперь все это можно легко замаунтить консольным вызовом:
`$ sshfs username@server.ru:/home/user mount-point/`
Но это не самый удобный вариант использования — надо каждый раз в консоли маунтить папку, конечно, можно все это прописать в /ets/fstab, но у нас есть вариант получше — [Automount FUSE](http://afuse.sourceforge.net/). Ставить опять можно из репозитариев:
`$ sudo apt-get install afuse`
После чего достаточно его запустить с нужными парамтерами:
`afuse -o mount_template="sshfs %r:/ %m" -o unmount_template="fusermount -u -z %m" ~/sshfs/`
После чего все обращения к файлам и папкам в папке ~/sshfs/ будут вызывать монтирование соответствующей папки в ~/sshfs/. После чего обращение пойдет дальше на удаленный хост. Самое главное для нас — все происходит абсолютно прозрачно при первом обращении к нужной папке из **любой программы**.
Например: `ls ~/sshfs/tmpvar@foobarhost.com` вначале малость потормозит, потом покажет содержимое корневой папки / сервера foobarhost.com. Конечно, не всегда удобно писать полный адрес и параметры доступа к серверу tmpvar@foobarhost.com:22, поэтому мы их перенесем в настройки доступа ssh.
```
cat ~/.ssh/config
Host file-storage
Hostname filestorage.server.ru
Port 2222 # на сервере может быть использован нестандартный порт
HostKeyAlias fs
User admin
```
Теперь мы можем обращаться к нашему серверу по короткому имени fs как в ssh, так и в sshfs:
> ssh fs # заходим на сервер — никаких лишних настроек не надо
> ls ~/sshfs/fs # смотрим корневую папку сервера.
Если вы монтите папку первый раз, то у вас появится окошко ввода пароля для доступа к указанному серверу. После того как соединение установлено, окно больше не будет вас докучать. Как вы уже поняли — можно легко сказать окну не вылезать — сделав авторизацию на сервер по ключу.
**Итак**, что же мы получили?
А получили мы классную вещь — прозрачное SSHFS-монтирование папок по требованию. Это обозначает, что:
— монтирование осуществляется **автоматически когда нужно**. Например, утром я включаю свой ноут и открываю Eclipse c текущим проектом. Как только он запустится, он тут же открывает старые файлы с сервера, при этом монтится папка и происходит вся скрытая механика. Но меня, как пользователя, это уже не интересует — я запускаю прогу и работаю в ней.
— но есть вещи гораздо интереснее: **монтирование не запускается когда не надо!** Например, вы сидите в интернет-кафе или на даче на gprs-модеме. Вот скажите, вам сильно надо чтобы при запуске ноута подключались все папки с рабочего сервера? В итоге загрузка длилась полчаса и выдавала гору ошибок? Вот это и есть главное преимущество перед прописыванием настроект в /etc/fstab — когда не надо, система вам не мешает. :)
Но человек быстро привыкает ко всему хорошему. Я перся с этой системы ровно 2 недели — а потом начал банально забывать запускать afuse :). В итоге пришлось сделать небольшой скриптец, который это будет делать за меня:
```
$ cat ~/bin/afuse.sh
#!/bin/sh
if [ ! -z `ls -d /tmp/afuse-* 2>/dev/null` ]; then
echo 'Afuse is already running';
else
/usr/bin/afuse -o mount_template="sshfs %r:/ %m" -o unmount_template="fusermount -u -z %m" ~/sshfs/
fi
```
и добавил его в автозапуск в GNOME.
Вот теперь система стала идеальной :) | https://habr.com/ru/post/52310/ | null | ru | null |
# DisTalk. Если ты не умеешь читать, это не значит то, что ты не можешь общаться
Всем привет! Сегодня я расскажу о приложении DisTalk Pro. Я должен извиниться за паузу в моих постах, ~~опять спасал мир~~ подбивал итоги четверти, выиграл серебряную медаль [кубка России](https://vk.com/wall20124065_3548) по бочча в тройках, [выступил на форуме Обнаженные сердца](https://www.youtube.com/watch?v=zeWIlwrmI-E). Но обещание есть обещание, и на этой неделе я выложил новую версию программы DisTalk в [Google Play](https://play.google.com/store/apps/details?id=ru.aacidov.distalkpro) и на [GitHub](https://github.com/aacidov/DisTalkPro-android).
Для тех кто не понимает, о чем я говорю, советую почитать [эту статью](https://habrahabr.ru/company/aacidov/blog/308514/).
*DisTalk Pro*
### Глава 0. Что собственно делаем?
Есть такой довольно популярный и ~~дешевый~~ девайс GoTalk. Принцип его работы прост. В матрицу вставляются карточки. На карточки с помощью кнопки Record педагог записывает аудиофрагменты. И потом при нажатии на карточку GoTalk играет эту фразу. Эти устройства широко известны в инвасообществе и используются очень давно (я помню свой третьий класс и кнопку «В туалет»)
*GoTalk*
Я после своего хорошего опыта с DisQwerty и DisType решил сделать приложение DisTalk с тем же функционалом (только вместо записи речи, использовать tts). И…
### Глава 1. Не делайте так!
Задача очень простая. Сделать приложение, которое создает папку DisTalk в корне устройства. Пользователь кладет туда картинки, гружу это в GridView, при нажатии на картинку произношу название файла. Еще чтоб было повеселей сделал переключение по папкам. Чтобы учитель ребенка мог сделать разные наборы… Я сделал такое приложение, загрузил в play market. И сейчас я расскажу о том, как не надо писать приложения. (Но как надо я не знаю и не претендую на звание гуру)
### Ошибки и советы юного и на костылях
**Читайте документацию и тестируйте на разных версиях android.**
Как мы ~~все~~ знаем, с обновлением Android до версии Lolipop мало просто написать в манифесте, то что хочешь писать в storage. Надо еще вызвать запрос на доступ в fs.
*Кстати, в [доках](https://developer.android.com/training/basics/data-storage/files.html?hl=ru) об этом ничего нет. [Stackoverflow](http://stackoverflow.com/questions/33653303/mkdirs-return-false-with-write-external-permission) наше всё!*
По этой причине я не мог понять почему у половины людей всё работает, а у половины багрепорты случаются. В DisType Pro я использую проверку и всё работает:
```
private void verifyStoragePermissions(Activity activity) {
// Check if we have write permission
int permission = ActivityCompat.checkSelfPermission(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE);
if (permission != PackageManager.PERMISSION_GRANTED) {
// We don't have permission so prompt the user
ActivityCompat.requestPermissions(activity, new String[] { Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_EXTERNAL_STORAGE}, 0);
}
}
```
**Уважайте пользователя.**
Следующая моя ошибка в том, что я очень плохо построил интерфейс. При первом запуске пользователь видел просто белый экран. Никакого намека на то, что нужно подключить планшет к компу, загрузить картинки и вообще. Я наивно надеялся на то, что люди почитают инструкцию в описании приложения на гугл плей. Но нет.
В новой версии я сделал:
* Стартовый набор картинок, которые загружаются сразу после первого запуска (ну раздул я apk до 1 мб, ~~надеюсь~~ никто не умер) копируются в папку DisTalk и юзер видит не просто белых экран, а уже готовое к работе приложение
* Функции добавления, удаления, редактирования картинок из галереи и создания папок прямо из приложения. Теперь не обязательно иметь компьютер
* Добавил подпись к каждому элементу gridview. Теперь пользователь может использовать не только подписанные pecs пиктограммы, а простые фотки
* Добавил Yandex AppMetrica (нет, это не реклама) для отслеживания ошибок в приложении (ну еще слежу кто что сказал (: ). Юзеры не охотно шлют багрепорты, а это полезно!
**Не забывайте ключ.**
Хорошо, Вань, написал новое приложение — молодец, но почему было не обновить старое?
Потому что я потерял keystore и забыл пароль от него. Так делать не надо. Сохраняйте этот файл в надежное место. Новый jks я отправил себе на почту. Храню его!
**Снимайте видеогайды про продукты**
*Ролик о том как пользоваться новым DisTalk'ом*
### Глава 2. Что дальше?
**Нужна помощь:**
* Придумать как усложнить выход из приложения. Специалисты жалуются, что люди с аутизмом привыкли играть на планшете, и постоянно выходят из программы
* Придумать как склонять слова в потоке речи. Чтобы не получалось «я хотеть яблоко», а «я хочу яблоко»
* Сделать банк карточек
* Добавить функцию записи аудио на кнопки. Специалисты говорят, что иногда нужно записать кнопку с интонацией.
* iOS, windows
* Donate because open source
— [Мой сайт.](http://aacidov.ru) | https://habr.com/ru/post/314262/ | null | ru | null |
# Flutter: PlatformView + QR code reader
Из бесплатных доступных библиотек для работы с qr кодами в Android самой лучшей (на мой личный взгляд) является zxing-android-embedded. Часто, UI который предоставляет эта библиотека не достаточно или нужен какой-то иной. **В этой статье пойдет речь о том, как**«**кастомизировать**»**UI библиотеки zxing-android-embedded для распознавания QR кодов при использовать её Flutter проекте.**
Представленная статья и код вместе с ней, всего лишь минимальный достаточный пример для демонстрации возможностей «кастомизации» [zxing-android](https://github.com/journeyapps/zxing-android-embedded) для работы с ней во flutter. Статья затрагивает только Android реализацию не касаясь IOS.
Мы будем использовать три основных компонента для взаимодействия с этой библиотекой из flutter окружения. Для этого нам потребуется:
* PlatformViewLink
* MethodChannel
* EventChannel
### PlatformViewLink:
Даёт возможность «прокинуть» нативный android экран(View) в ваше fluttter приложение. Это удобно в тех случаях когда есть готовое, проверенное решение под нативную платформу, а времени переделывать под flutter не хватает и легче показать android activity напрямую в вашем flutter приложении. По такому принципу работают google maps во flutter приложениях. В нашем случае через PlatformViewLink мы будем показывать нативный экран со стримом фотокамеры.
### MethodChannel:
Даёт возможность вызывать нативные методы платформы(android или ios и т.д.) из flutter среды в и получать результат . Надо заметить что все вызовы методов асинхронны. В данном проекте MethodChannel будет использоваться чтобы включать и выключать подсветку фотокамеры.
### EventChannel:
Почти то же самое что и MethodChannel, с тем лишь отличием, что мы можем подписаться на поток событий, генерируемых в нативной среде. Самый часты кейс это например «слушать» gps координаты от нативной платформы. В данном примере EventChannel будет использоваться для отправки распознанного QR кода из android окружения в наше flutter приложение. Конечно, для получения результата мы могли бы использовать MethodChannel, например самостоятельно запрашивая данные скажем каждые 10 секунд. Но такой подход выглядит не очень правильным в условиях, когда у нас есть возможность получить результат именно тогда когда он готов.
Создадим пустой flutter проект. В консоли терминала вышей любимой ОС выполним команду:
Откроем **main.dart**. Добавим в качестве home элемента **MaterialApp**виджета, QrCodePage - виджет, который обернёт основной экран в **Scaffold**и добавит AppBar для него:
```
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
primarySwatch: Colors.blue,
),
home: QrCodePage(),
);
}
}
class QrCodePage extends StatelessWidget {
QrCodePage({Key? key}) : super(key: key);
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text("QR code App"),
),
body: PlatformView(),
);
}
}
```
**PlatformView**- основной **StatefulWidge** виджет. Он будет обёрткой над **PlatformViewLink**и будет непосредственно транслировать видео с камеры:
```
class _PlatformViewState extends State {
final MethodChannel platformMethodChannel = MethodChannel('flashlight');
bool isFlashOn = false;
bool permissionIsGranted = false;
String result = '';
void \_handleQRcodeResult() {
const EventChannel \_stream = EventChannel('qrcodeResultStream');
\_stream.receiveBroadcastStream().listen((onData) {
print('EventChannel onData = $onData');
result = onData;
setState(() {});
});
}
Future \_onFlash() async {
try {
dynamic result = await platformMethodChannel.invokeMethod('onFlash');
setState(() {
isFlashOn = true;
});
} on PlatformException catch (e) {
debugPrint('PlatformException ${e.message}');
}
}
Future \_offFlash() async {
try {
dynamic result = await platformMethodChannel.invokeMethod('offFlash');
setState(() {
isFlashOn = false;
});
} on PlatformException catch (e) {
debugPrint('PlatformException ${e.message}');
}
}
@override
void initState() {
super.initState();
\_handleQRcodeResult();
\_checkPermissions();
}
\_requestAppPermissions() {
showDialog(
context: context,
builder: (BuildContext context) => AlertDialog(
title: const Text('Permission required'),
content: const Text('Allow camera permissions'),
actions: [
TextButton(
onPressed: () {
\_checkPermissions();
Navigator.pop(context, 'OK');
},
child: const Text('OK'),
),
],
));
}
\_checkPermissions() async {
var status = await Permission.camera.status;
if (!status.isGranted) {
final PermissionStatus permissionStatus = await Permission.camera.request();
if (!permissionStatus.isGranted) {
\_requestAppPermissions();
}
}
}
@override
Widget build(BuildContext context) {
final String viewType = '';
final Map creationParams = {};
return result.isEmpty
? Stack(
alignment: Alignment.center,
children: [
PlatformViewLink(
viewType: viewType,
surfaceFactory: (BuildContext context, PlatformViewController controller) {
return Container(
child: AndroidViewSurface(
controller: controller as AndroidViewController,
gestureRecognizers: const >{},
hitTestBehavior: PlatformViewHitTestBehavior.opaque,
),
);
},
onCreatePlatformView: (PlatformViewCreationParams params) {
return PlatformViewsService.initSurfaceAndroidView(
id: params.id,
viewType: viewType,
layoutDirection: TextDirection.ltr,
creationParams: creationParams,
creationParamsCodec: StandardMessageCodec(),
)
..addOnPlatformViewCreatedListener(params.onPlatformViewCreated)
..create();
},
),
Align(
alignment: Alignment.topCenter,
child: ElevatedButton(
onPressed: () {
if (!isFlashOn) {
\_onFlash();
} else {
\_offFlash();
}
},
child: isFlashOn ? Text('off flashlight') : Text('on flashlight'))),
Align(
alignment: Alignment.center,
child: Container(
height: 200,
width: 200,
decoration: BoxDecoration(
color: Colors.transparent,
border: Border.all(
color: Colors.blueAccent,
width: 5,
)),
),
)
],
)
: Container(
child: Center(child: Text('QR code result:\n$result')),
);
}
}
```
Пару комментариев к коду ваше:
* Запрашиваем разрешения на работу с камерой:
* В поле класса, создаём **platformMethodChannel -**через этот экземпляр будем вызывать нативные методы (которые мы создадим чуть позже) в android окружении. Аргумент в конструкторе ‘flashlight’ это своего рода уникальный ID, который должен быть идентичный во flutter и нативной среде:
* Метод **\_handleQRcodeResult()** - будет получать результат отсканированного qr кода:
* Методы**\_onFlash()** и **\_offFlash*()****вызывают соответствующий метод на стороне Android фреймворка.*
* В некоторых случаях необходимо передать параметры в нативную среду. Для этого удобно использовать **creationParams**. Но в нашем примере параметров для передачи у нас не будет:
* В качестве **ViewGroup**используем **Stack**для того чтоб расположить дополнительные UI элементы. В моём примере это рамка в центр экрана(**Container** с прозрачным фоном и **BoxDecoration**) и **ElevatedButton** над ней для включения подсветки.
Взглянем на Android реализацию:
-------------------------------
В **build.gradle** модуля app (android/app/build.gradle) подключим библиотеку. В раздел dependencies добавим:
В MainActivity, в методе **configureFlutterEngine, EventChannel**
```
class MainActivity : FlutterFragmentActivity(), LifecycleOwner, ResultCallback {
var myEvents: EventChannel.EventSink? = null
override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
super.configureFlutterEngine(flutterEngine)
EventChannel(flutterEngine.dartExecutor.binaryMessenger, "qrcodeResultStream")
.setStreamHandler(object : EventChannel.StreamHandler {
override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
myEvents = events
}
override fun onCancel(arguments: Any?) {
myEvents = null
}
})
flutterEngine
.platformViewsController
.registry
.registerViewFactory("", NativeViewFactory())
}
override fun result(result: String) {
myEvents?.success(result)
}
override fun getMyFlutterEngine(): FlutterEngine? = flutterEngine
}
```
**EventChannel.StreamHandler** возвращает нам объект **EventChannel.EventSink**вызывая на котором **.success(result)** — мы передаём событие во flutter фреймворк. В нашем случае это будет строка с QR кодом.
В методе выше мы регистрируем фабрику которая может возвращать разные View в зависимости от переданных аргументов, но мы не будем усложнять пример и возвращаем наш единственное **NativeView**:
Взглянем на интерфейс **ResultCallback**, который имплементирует **MainActivity**:
Метод **result*(*result: String*)*** *нужен для передачи результата (распознанного qr кода) в***MainActivity**.
метод **getMyFlutterEngine()** - вернёт нам FlutterEngine в нашем **NativeView**.
Основной код будет в **NativeView**:
```
class NativeView(context: Context, id: Int, creationParams: Map?) : PlatformView {
private val textView: TextView
private val CHANNEL = "flashlight"
private val rootView: View
private var barcodeView: DecoratedBarcodeView? = null
override fun getView(): View {
return rootView
}
override fun dispose() {}
init {
(context as LifecycleOwner).lifecycle.addObserver(object : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON\_RESUME)
fun connectListener() {
barcodeView?.resume()
}
@OnLifecycleEvent(Lifecycle.Event.ON\_PAUSE)
fun disconnectListener() {
barcodeView?.pause()
}
})
rootView = LayoutInflater.from(context.applicationContext).inflate(R.layout.layout, null)
barcodeView = rootView.findViewById(R.id.barcode\_scanner)
val formats: Collection = Arrays.asList(BarcodeFormat.QR\_CODE, BarcodeFormat.CODE\_39)
barcodeView?.barcodeView?.decoderFactory = DefaultDecoderFactory(formats)
barcodeView?.setStatusText("")
barcodeView?.viewFinder?.visibility = View.INVISIBLE
barcodeView?.initializeFromIntent(Intent())
barcodeView?.decodeContinuous(object : BarcodeCallback {
override fun possibleResultPoints(resultPoints: MutableList?) {
super.possibleResultPoints(resultPoints)
}
override fun barcodeResult(result: BarcodeResult?) {
(context as ResultCallback).result(result?.result?.text ?: "no result")
barcodeView?.setStatusText(result?.text)
}
})
barcodeView?.resume()
textView = TextView(context)
textView.textSize = 36f
textView.setBackgroundColor(Color.rgb(255, 255, 255))
textView.text = "Rendered on a native Android view (id: $id) ${creationParams?.entries}"
val flutterEngine = (context as ResultCallback).getMyFlutterEngine()
MethodChannel(flutterEngine?.dartExecutor?.binaryMessenger, CHANNEL)
.setMethodCallHandler { call, result ->
when (call.method) {
"onFlash" -> {
barcodeView?.setTorchOn()
result.success("setTorchOn")
}
"offFlash" -> {
barcodeView?.setTorchOff()
result.success("setTorchOff")
}
else -> {
result.notImplemented()
}
}
}
}
}
```
В **init** блоке подписываемся на жизненный цикл activiti и в соответствующих методах вызываем **resume** / **pause**у **barcodeView**. Важно**:** что без реализации этих методов вы вместо видеопотока с камеры будет увидите черный экран:
**NativeView** наследуется от интерфейса **PlatformView** это обязывает нас реализовать два метода:
В **getView** мы должны вернуть **View** которая является главным экраном. Нужно создать **layout.xml** с следующего содержания:
Из него с помощью **LayoutInflater** мы создаём **view** и возвращаем ссылку на него в методе **getView*()****:*
Поскольку наш layout содержит **DecoratedBarcodeView** мы можем найти его(получить ссылку на него) с помощью **findViewById** и настроить как на нужно:
Тут мы устанавливаем поддерживаемый формат qr кодов, дефолтную строку результата «сеттим» как пустую, убираем стандартную рамку в центре экрана. Отдельно стоит остановиться на этом куске кода:
Когда библиотека распознаёт qr код, результат этого она передаёт в callback -**barcodeResult*(*result: BarcodeResult?*)****. В нем имея ссылку на***MainActivity**через общий контекст, вызываем метод **result**нашего **ResultCallback**и через него передаём строку с результатом. И уже в самом **MainActivity**используя **EventChannel**передаём дальше — во Flutter окружение.
Код выше является обработчиком событий отправляемых из flutter среды. У **MethodChannel** принимает **MethodCallHandler** используя который мы узнаём какой метод сейчас вызывается и реагируем на него. В данном коде мы включаем или выключаем подсветку камеры.
Короткое видео с примером этого приложения:
[Исходный код приложения](https://gitlab.com/postflow/flutter_qr_code_plugin)
[**zxing-android-embedded**](https://github.com/journeyapps/zxing-android-embedded) | https://habr.com/ru/post/592129/ | null | ru | null |
# Волшебное введение в алгоритмы классификации
*Перевод [статьи](http://blog.yhat.com/posts/harry-potter-classification.html) Брайна Беренда.*
Когда вы впервые приступаете к изучению теории анализа и обработки данных, то одними из первых вы изучаете алгоритмы классификации. Их суть проста: берётся информация о конкретном результате наблюдений (data point), на основании которой этот результат относится к определённой группе или классу.
Хороший пример — спам-фильтр электронной почты. Он должен помечать входящие письма (то есть результаты наблюдений) как «спам» или «не спам», ориентируясь на информацию о письмах (отправитель, количество слов, начинающихся с прописных букв, и так далее).
Это пример хороший, но скучный. Спам-классификацию приводят в качестве примера на лекциях, презентациях и конференциях, так что вы наверняка уже не раз слышали о нём. Но что если поговорить о другом, более интересном алгоритме классификации? Каком-то более странном? Более… волшебном?
Всё верно! Сегодня мы поговорим о Распределяющей шляпе (Sorting Hat) из мира Гарри Поттера. Возьмём какие-то данные из сети, проанализируем и создадим классификатор, который будет сортировать персонажей по разным факультетам. Должно получиться забавно!
**Примечание:**
Наш классификатор будет не слишком сложным. Так что его нужно рассматривать как «первичный подход» к решению проблемы, демонстрирующий некоторые базовые методики извлечения текста из сети и его анализа. Кроме того, учитывая относительно небольшой размер выборки, мы не будем использовать классические обучающие методики вроде [перекрёстной проверки](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B5%D0%BA%D1%80%D1%91%D1%81%D1%82%D0%BD%D0%B0%D1%8F_%D0%BF%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%BA%D0%B0). Мы просто соберём определенные данные, построим простой классификатор на основе правил и оценим результат.
**Второе примечание:**
Идея этого поста навеяна прекрасной презентацией Брайана Ланга на конференции [PyData Chicago 2016](https://pydata.org/chicago2016/). Видеозапись [здесь](https://www.youtube.com/watch?v=y8J6ggsLSfw), слайды [здесь](https://www.slideshare.net/brianjlange/its-not-magic-explaining-classification-algorithms-pydata-chicago-2016-edition).
Шаг первый: извлекаем данные из сети
------------------------------------
На случай, если последние 20 лет вы провели в пещере: Распределяющая шляпа — это волшебная шляпа, которая помещает поступающих студентов по четырём факультетам Хогвартса: Гриффиндор, Слизерин, Хаффлпафф и Рэйвенклоу. У каждого факультета свои характеристики. Когда шляпу надевают на голову студента, она считывает его разум и определяет, какой факультет подходит ему лучше всего. Согласно этому определению, Распределяющая шляпа — это многоклассовый классификатор (multiclass classifier) (сортирует более чем по двум группам), в отличие от бинарного классификатора (сортирует строго по двум группам), которым является спам-фильтр.
Чтобы распределить студентов по факультетам, нам нужно знать о них определенную информацию. К счастью, достаточно данных есть на [harrypotter.wikia.com](http://blog.yhat.com/posts/harrypotter.wikia.com). На этом сайте лежат статьи почти по всем аспектам вселенной Гарри Поттера, включая описания студентов и факультетов. Приятный бонус: компания [Fandom](http://www.wikia.com/about), заведующая сайтом, предоставляет простой в использовании [API](http://api.wikia.com/wiki/Quick_Start) и массу прекрасной [документации](http://api.wikia.com/wiki/Documentation). Ура!
Начнём с импортирования `pandas` и `requests`. Первые будут использоваться для упорядочивания данных, а последние — для запросов к API на получение данных.
Также нам нужно грамотно пройтись по всем студентам Хогвартса и записать факультеты, по которым они раскиданы Распределяющей шляпой (это будут «реальные данные», с которыми мы будем сравнивать результаты нашей сортировки). На сайте статьи разбиты по категориям, вроде «Студенты Хогвартса» и «Фильмы». API позволяет создавать списки статей в рамках конкретной категории.
Возьмём для примера Рэйвенклоу. Закинем все данные в переменную `info` и затем положим их во фрейм данных (Data Frame) Pandas.
```
# Импортирует модули
import pandas as pd
import requests
# Получает статьи из категории Рэйвенклоу
category = 'Ravenclaws'
url = 'http://harrypotter.wikia.com/api/v1/Articles/List?expand=1&limit=1000&category=' + category
requested_url = requests.get(url)
json_results = requested_url.json()
info = json_results['items']
ravenclaw_df = pd.DataFrame(info)
print('Number of articles: {}'.format(len(info)))
print('')
ravenclaw_df.head()
```
Количество статей: 158
*Вы можете проследить полное выполнение анализа с помощью [Rodeo](https://www.yhat.com/products/rodeo)!*
**Примечание:**
Если воспользуетесь нашим Python IDE, Rodeo, то просто скопируйте и вставьте вышеприведённый код в Editor или Terminal. Результат вы увидите в окне History или Terminal. Бонус: можно просто перетаскивать окна мышью, меняя их расположение и размер.
На основе этих данных мы узнаем:
* Первым пунктом в списке идёт «Ravenclaw individual infobox». Поскольку это не студент, нам нужно отфильтровать результаты по колонке «Тип».
* К сожалению, в `ravenclaw_df` не указаны содержания статей… только описания. Чтобы получить содержания, придётся воспользоваться другим видом запроса к API и запрашивать данные на основе ID статей.
* Также мы можем написать цикл, пройтись по всем факультетам и получить один фрейм со всеми необходимыми данными.
```
# Задаём переменные
houses = ['Gryffindor', 'Hufflepuff', 'Ravenclaw', 'Slytherin']
mydf = pd.DataFrame()
# Получаем ID статей, URL статей и факультеты
for house in houses:
url = "http://harrypotter.wikia.com/api/v1/Articles/List?expand=1&limit=1000&category=" + house + 's'
requested_url = requests.get(url)
json_results = requested_url.json()
info = json_results['items']
house_df = pd.DataFrame(info)
house_df = house_df[house_df['type'] == 'article']
house_df.reset_index(drop=True, inplace=True)
house_df.drop(['abstract', 'comments', 'ns', 'original_dimensions', 'revision', 'thumbnail', 'type'], axis=1, inplace=True)
house_df['house'] = pd.Series([house]*len(house_df))
mydf = pd.concat([mydf, house_df])
mydf.reset_index(drop=True, inplace=True)
# Выводим результаты
print('Number of student articles: {}'.format(len(mydf)))
print('')
print(mydf.head())
print('')
print(mydf.tail())
```
Количество статей о студентах: 748
Получение содержаний статей
---------------------------
Имея ID статей, мы можем начать запрашивать содержания. Но некоторые из статей просто ОГРОМНЫ, они содержат невероятное количество подробностей. Вы только взгляните на статьи про [Гарри Поттера](http://harrypotter.wikia.com/wiki/Harry_Potter) и [Волан-де-Морта](http://harrypotter.wikia.com/wiki/Tom_Riddle)!
В статьях про всех ключевых персонажей есть раздел «Личность и черты характера». Логично было бы извлекать отсюда информацию, которую Распределяющая шляпа будет использовать при принятии решений. Но такой раздел есть не во всех статьях, так что если ориентироваться только на него, то количество персонажей сильно уменьшится.
Нижеприведённый код извлекает из каждой статьи раздел «Личность и черты характера» и вычисляет его длину (количество знаков). Затем на основе ID объединяет эти данные с нашим начальным фреймом данных mydf (на это уходит немного времени).
```
# Циклически проходим по статьям и извлекаем разделы " Личность и черты характера " по каждому студенту
# Если в статье про какого-то студента такого раздела нет, то оставляем пустую строку
# Это займёт несколько минут
text_dict = {}
for iden in mydf['id']:
url = 'http://harrypotter.wikia.com/api/v1/Articles/AsSimpleJson?id=' + str(iden)
requested_url = requests.get(url)
json_results = requested_url.json()
sections = json_results['sections']
contents = [sections[i]['content'] for i, x in enumerate(sections) if sections[i]['title'] == 'Personality and traits']
if contents:
paragraphs = contents[0]
texts = [paragraphs[i]['text'] for i, x in enumerate(paragraphs)]
all_text = ' '.join(texts)
else:
all_text = ''
text_dict[iden] = all_text
# Помещаем данные в DataFrame и вычисляем длину раздела "Личность и черты характера"
text_df = pd.DataFrame.from_dict(text_dict, orient='index')
text_df.reset_index(inplace=True)
text_df.columns = ['id', 'text']
text_df['text_len'] = text_df['text'].map(lambda x: len(x))
# Снова объединяем текст с информацией о студентах
mydf_all = pd.merge(mydf, text_df, on='id')
mydf_all.sort_values('text_len', ascending=False, inplace=True)
# Создаём новый DataFrame только с теми студентами, про которых есть разделы "Личность и черты характера"
mydf_relevant = mydf_all[mydf_all['text_len'] > 0]
print('Number of useable articles: {}'.format(len(mydf_relevant)))
print('')
mydf_relevant.head()
```
Количество подходящих статей: 94
Шаг второй: Получение характеристик факультетов с помощью NLTK
--------------------------------------------------------------
Теперь мы знаем количество студентов, надо распределить их по факультетам. Для этого составим список характеристик каждого факультета. Начнём собирать из с [harrypotter.wikia.com](http://harrypotter.wikia.com/wiki/Main_Page).
```
trait_dict = {}
trait_dict['Gryffindor'] = ['bravery', 'nerve', 'chivalry', 'daring', 'courage']
trait_dict['Slytherin'] = ['resourcefulness', 'cunning', 'ambition', 'determination', 'self-preservation', 'fraternity',
'cleverness']
trait_dict['Ravenclaw'] = ['intelligence', 'wit', 'wisdom', 'creativity', 'originality', 'individuality', 'acceptance']
trait_dict['Hufflepuff'] = ['dedication', 'diligence', 'fairness', 'patience', 'kindness', 'tolerance', 'persistence',
'loyalty']
```
Обратите внимание, что все слова — существительные. Это хорошо. Нам нужна консистентность при описании черт характера. Некоторые из них были представлены не в виде существительных, так что приведём их к общему порядку:
* «ambitious» (прилагательное) — можно легко заменить на 'ambition'
* «hard work», «fair play» и «unafraid of toil» — эти фразы тоже можно легко заменить на однословные существительные:
* «hard work» --> 'diligence'
* «fair play» --> 'fairness'
* «unafraid of toil» --> 'persistence'
Получив список характеристик для каждого факультета, можем просто сканировать колонку «Текст» и подсчитать, сколько раз использовались соответствующие слова в описаниях персонажей. Звучит несложно, верно?
К сожалению, это ещё не всё. Вот фраза из раздела «[Личность и черты характера](http://harrypotter.wikia.com/wiki/Neville_Longbottom#Personality_and_traits)» про Невила Лонгботтома:
> Когда он был моложе, Невил был неуклюж, забывчив, застенчив, и многие считали, что он плохо подходит для факультета Гриффиндор, потому что он казался **робким**.
>
>
>
> Благодаря поддержке друзей, которым он был очень **предан**; вдохновению профессора Римуса Люпина предстать перед лицом своих страхов на третьем году обучения; и тому, что мучители его родителей разгуливают на свободе, Невил стал **храбрее**, увереннее в себе, и **самоотверженным** в борьбе против Волан-де-Морта и его Пожирателей Смерти.
>
>
>
> (When he was younger, Neville was clumsy, forgetful, shy, and many considered him ill-suited for Gryffindor house because he seemed **timid**.
>
>
>
> With the support of his friends, to whom he was very **loyal**, the encouragement of Professor Remus Lupin to face his fears in his third year, and the motivation of knowing his parents’ torturers were on the loose, Neville became **braver**, more self-assured, and **dedicated** to the fight against Lord Voldemort and his Death Eaters.)
Выделенные слова должны засчитываться в пользу каких-то факультетов, но они не будут засчитаны, потому что являются прилагательными. Также не будут учтены слова вроде «bravely» и «braveness». Чтобы наш алгоритм классификации работал правильно, нужно идентифицировать синонимы, антонимы и другие словоформы.
Синонимы
--------
Исследовать синонимы можно с помощью функции `synsets` из [WordNet](https://wordnet.princeton.edu/), лексической базы данных английского языка, включённой в модуль [nltk](http://www.nltk.org/) (NLTK — Natural Language Toolkit). “Synset” — это «synonym set», коллекция синонимов, или «лемм». Функция `synsets` возвращает наборы синонимов, которые ассоциированы с конкретными словами.
Озадачены? Давайте запустим код, а затем разберём его:
```
from nltk.corpus import wordnet as wn
# Наборы синонимов из разных слов
foo1 = wn.synsets('bravery')
print("Synonym sets associated with the word 'bravery': {}".format(foo1))
foo2 = wn.synsets('fairness')
print('')
print("Synonym sets associated with the word 'fairness': {}".format(foo2))
foo3 = wn.synsets('wit')
print('')
print("Synonym sets associated with the word 'wit': {}".format(foo3))
foo4 = wn.synsets('cunning')
print('')
print("Synonym sets associated with the word 'cunning': {}".format(foo4))
foo4 = wn.synsets('cunning', pos=wn.NOUN)
print('')
print("Synonym sets associated with the *noun* 'cunning': {}".format(foo4))
print('')
# Выводим синонимы ("леммы"), ассоциированные с каждым synset
foo_list = [foo1, foo2, foo3, foo4]
for foo in foo_list:
for synset in foo:
print((synset.name(), synset.lemma_names()))
```
Synonym sets associated with the word 'bravery': [Synset('courage.n.01'), Synset('fearlessness.n.01')]
Synonym sets associated with the word 'fairness': [Synset('fairness.n.01'), Synset('fairness.n.02'), Synset('paleness.n.02'), Synset('comeliness.n.01')]
Synonym sets associated with the word 'wit': [Synset('wit.n.01'), Synset('brain.n.02'), Synset('wag.n.01')]
Synonym sets associated with the word 'cunning': [Synset('craft.n.05'), Synset('cunning.n.02'), Synset('cunning.s.01'), Synset('crafty.s.01'), Synset('clever.s.03')]
Synonym sets associated with the noun 'cunning': [Synset('craft.n.05'), Synset('cunning.n.02')]
('courage.n.01', ['courage', 'courageousness', 'bravery', 'braveness']) ('fearlessness.n.01', ['fearlessness', 'bravery']) ('fairness.n.01', ['fairness', 'equity']) ('fairness.n.02', ['fairness', 'fair-mindedness', 'candor', 'candour']) ('paleness.n.02', ['paleness', 'blondness', 'fairness']) ('comeliness.n.01', ['comeliness', 'fairness', 'loveliness', 'beauteousness']) ('wit.n.01', ['wit', 'humor', 'humour', 'witticism', 'wittiness']) ('brain.n.02', ['brain', 'brainpower', 'learning\_ability', 'mental\_capacity', 'mentality', 'wit']) ('wag.n.01', ['wag', 'wit', 'card']) ('craft.n.05', ['craft', 'craftiness', 'cunning', 'foxiness', 'guile', 'slyness', 'wiliness']) ('cunning.n.02', ['cunning'])
Так, мы получили много выходных данных. Рассмотрим некоторые моменты и потенциальные проблемы:
* `wn.synsets('bravery')` связано с двумя наборами синонимов: один для `courage.n.01` и один для `fearlessness.n.01`. Давайте посмотрим, что это означает:
* Первая часть ('courage' и 'fearlessness') это слово, вокруг которого выстроен весь конкретный набор синонимов. Назовём его «центральным» словом. То есть все синонимы в данном наборе («леммы») аналогичны по смыслу центральному слову.
* Вторая часть ('n') означает «существительное» («noun»). К примеру, набор, ассоциированный со словом «cunning», включает в себя `crafty.s.01` и `clever.s.03` (прилагательные). Они появились тут потому, что слово «cunning» может быть и существительным, и прилагательным. Чтобы оставить только существительные, можно задать `wn.synsets('cunning', pos=wn.NOUN)`.
* Третья часть ('01') ссылается на конкретный смысл центрального слова. Например, 'fairness' может означать как «соответствие правилам и стандартам», так и «вынесение суждений без дискриминации или нечестности».
Как вы могли заметить, функция `synset` может предоставлять нежелательные наборы синонимов. Например, со словом 'fairness' также ассоциированы наборы `paleness.n.02` («иметь от природы светлую кожу») и `comeliness.n.01` («хорошо выглядеть и быть привлекательным»). Эти черты явно не ассоциируются с Хаффлпаффом (хотя [Невил Лонгботтом](https://www.pinterest.com/cherokee7743/matthew-lewis/) и вырос красавчиком), так что придётся вручную исключать такие наборы из нашего анализа.
**Перевод: получить синонимы труднее, чем кажется**
Антонимы и словоформы
---------------------
После того, как мы собрали все синонимы, нужно позаботиться об антонимах и разных словоформах (например, применительно к «bravery» — «brave», «bravely» и «braver»). Немало тяжёлой работы можно выполнить в nltk, но всё же придётся вручную набивать деепричастия и прилагательные в сравнительной / превосходной степени.
```
# Выводим разные леммы (синонимы), антонимы и производные словоформы для наборов синонимов к "bravery"
foo1 = wn.synsets('bravery')
for synset in foo1:
for lemma in synset.lemmas():
print("Synset: {}; Lemma: {}; Antonyms: {}; Word Forms: {}".format(synset.name(), lemma.name(), lemma.antonyms(),
lemma.derivationally_related_forms()))
print("")
```
Synset: courage.n.01; Lemma: courage; Antonyms: [Lemma('cowardice.n.01.cowardice')]; Word Forms: [Lemma('brave.a.01.courageous')]
Synset: courage.n.01; Lemma: courageousness; Antonyms: []; Word Forms: [Lemma('brave.a.01.courageous')]
Synset: courage.n.01; Lemma: bravery; Antonyms: []; Word Forms: []
Synset: courage.n.01; Lemma: braveness; Antonyms: []; Word Forms: [Lemma('brave.a.01.brave'), Lemma('audacious.s.01.brave')]
Synset: fearlessness.n.01; Lemma: fearlessness; Antonyms: [Lemma('fear.n.01.fear')]; Word Forms: [Lemma('audacious.s.01.fearless'), Lemma('unafraid.a.01.fearless')]
Synset: fearlessness.n.01; Lemma: bravery; Antonyms: []; Word Forms: []
Собираем всё вместе
-------------------
Следующий код создаёт список синонимов, антонимов и словоформ для каждой характеристики факультетов. Для полноты анализа некоторые из слов могут быть записаны неправильно.
```
# Вручную выбираем наборы, которые нам подходят
relevant_synsets = {}
relevant_synsets['Ravenclaw'] = [wn.synset('intelligence.n.01'), wn.synset('wit.n.01'), wn.synset('brain.n.02'),
wn.synset('wisdom.n.01'), wn.synset('wisdom.n.02'), wn.synset('wisdom.n.03'),
wn.synset('wisdom.n.04'), wn.synset('creativity.n.01'), wn.synset('originality.n.01'),
wn.synset('originality.n.02'), wn.synset('individuality.n.01'), wn.synset('credence.n.01'),
wn.synset('acceptance.n.03')]
relevant_synsets['Hufflepuff'] = [wn.synset('dedication.n.01'), wn.synset('commitment.n.04'), wn.synset('commitment.n.02'),
wn.synset('diligence.n.01'), wn.synset('diligence.n.02'), wn.synset('application.n.06'),
wn.synset('fairness.n.01'), wn.synset('fairness.n.01'), wn.synset('patience.n.01'),
wn.synset('kindness.n.01'), wn.synset('forgivingness.n.01'), wn.synset('kindness.n.03'),
wn.synset('tolerance.n.03'), wn.synset('tolerance.n.04'), wn.synset('doggedness.n.01'),
wn.synset('loyalty.n.01'), wn.synset('loyalty.n.02')]
relevant_synsets['Gryffindor'] = [wn.synset('courage.n.01'), wn.synset('fearlessness.n.01'), wn.synset('heart.n.03'),
wn.synset('boldness.n.02'), wn.synset('chivalry.n.01'), wn.synset('boldness.n.01')]
relevant_synsets['Slytherin'] = [wn.synset('resourcefulness.n.01'), wn.synset('resource.n.03'), wn.synset('craft.n.05'),
wn.synset('cunning.n.02'), wn.synset('ambition.n.01'), wn.synset('ambition.n.02'),
wn.synset('determination.n.02'), wn.synset('determination.n.04'),
wn.synset('self-preservation.n.01'), wn.synset('brotherhood.n.02'),
wn.synset('inventiveness.n.01'), wn.synset('brightness.n.02'), wn.synset('ingenuity.n.02')]
# Функция, получающая разные словоформы из леммы
def get_forms(lemma):
drfs = lemma.derivationally_related_forms()
output_list = []
if drfs:
for drf in drfs:
drf_pos = str(drf).split(".")[1]
if drf_pos in ['n', 's', 'a']:
output_list.append(drf.name().lower())
if drf_pos in ['s', 'a']:
# Наречия + "-ness" существительные + сравнительные & превосходные прилагательные
if len(drf.name()) == 3:
last_letter = drf.name()[-1:]
output_list.append(drf.name().lower() + last_letter + 'er')
output_list.append(drf.name().lower() + last_letter + 'est')
output_list.append(drf.name().lower()+'ness')
output_list.append(drf.name().lower()+'ly')
elif drf.name()[-4:] in ['able', 'ible']:
output_list.append(drf.name().lower()+'r')
output_list.append(drf.name().lower()+'st')
output_list.append(drf.name().lower()+'ness')
output_list.append(drf.name()[:-1].lower()+'y')
elif drf.name()[-1:] == 'e':
output_list.append(drf.name().lower()+'r')
output_list.append(drf.name().lower()+'st')
output_list.append(drf.name().lower()+'ness')
output_list.append(drf.name().lower()+'ly')
elif drf.name()[-2:] == 'ic':
output_list.append(drf.name().lower()+'er')
output_list.append(drf.name().lower()+'est')
output_list.append(drf.name().lower()+'ness')
output_list.append(drf.name().lower()+'ally')
elif drf.name()[-1:] == 'y':
output_list.append(drf.name()[:-1].lower()+'ier')
output_list.append(drf.name()[:-1].lower()+'iest')
output_list.append(drf.name()[:-1].lower()+'iness')
output_list.append(drf.name()[:-1].lower()+'ily')
else:
output_list.append(drf.name().lower()+'er')
output_list.append(drf.name().lower()+'est')
output_list.append(drf.name().lower()+'ness')
output_list.append(drf.name().lower()+'ly')
return output_list
else:
return output_list
# Создаём копию словаря черт характера
# Если этого не сделать, то мы сразу же обновим словарь, по которому проходим циклически, что приведёт к бесконечному циклу
import copy
new_trait_dict = copy.deepcopy(trait_dict)
antonym_dict = {}
# Добавляем синонимы и словоформы в (новый) словарь черт характера; также добавляем антонимы (и их словоформы) в словарь антонимов
for house, traits in trait_dict.items():
antonym_dict[house] = []
for trait in traits:
synsets = wn.synsets(trait, pos=wn.NOUN)
for synset in synsets:
if synset in relevant_synsets[house]:
for lemma in synset.lemmas():
new_trait_dict[house].append(lemma.name().lower())
if get_forms(lemma):
new_trait_dict[house].extend(get_forms(lemma))
if lemma.antonyms():
for ant in lemma.antonyms():
antonym_dict[house].append(ant.name().lower())
if get_forms(ant):
antonym_dict[house].extend(get_forms(ant))
new_trait_dict[house] = sorted(list(set(new_trait_dict[house])))
antonym_dict[house] = sorted(list(set(antonym_dict[house])))
# Выводим некоторые результаты
print("Gryffindor traits: {}".format(new_trait_dict['Gryffindor']))
print("")
print("Gryffindor anti-traits: {}".format(antonym_dict['Gryffindor']))
print("")
```
Характеристики Гриффиндора: ['bold', 'bolder', 'boldest', 'boldly', 'boldness', 'brass', 'brassier', 'brassiest', 'brassily', 'brassiness', 'brassy', 'brave', 'bravely', 'braveness', 'braver', 'bravery', 'bravest', 'cheek', 'cheekier', 'cheekiest', 'cheekily', 'cheekiness', 'cheeky', 'chivalry', 'courage', 'courageous', 'courageouser', 'courageousest', 'courageously', 'courageousness', 'daring', 'face', 'fearless', 'fearlesser', 'fearlessest', 'fearlessly', 'fearlessness', 'gallantry', 'hardihood', 'hardiness', 'heart', 'mettle', 'nerve', 'nervier', 'nerviest', 'nervily', 'nerviness', 'nervy', 'politesse', 'spunk', 'spunkier', 'spunkiest', 'spunkily', 'spunkiness', 'spunky']
Антихарактеристики Гриффиндора: ['cowardice', 'fear', 'timid', 'timider', 'timidest', 'timidity', 'timidly', 'timidness']
```
# Проверяем, что словарь черт характера и словарь антонимов не содержат повторов внутри факультетов
from itertools import combinations
def test_overlap(dict):
results = []
house_combos = combinations(list(dict.keys()), 2)
for combo in house_combos:
results.append(set(dict[combo[0]]).isdisjoint(dict[combo[1]]))
return results
# Выводим результаты теста; должно получиться "False"
print("Any words overlap in trait dictionary? {}".format(sum(test_overlap(new_trait_dict)) != 6))
print("Any words overlap in antonym dictionary? {}".format(sum(test_overlap(antonym_dict)) != 6))
```
Есть какие-то повторы в словаре черт характера? False
Повторы в словаре антонимов? False
Шаг третий: Распределяем студентов по факультетам
-------------------------------------------------
Пришло время распределить студентов по факультетам! Наш алгоритм классификации будет работать следующим образом:
* Проходит по каждому слову раздела «Личность и черты характера» по каждому студенту.
* Если какое-то слово есть в списке **черт**, характерных для конкретного факультета, то к баллам этого факультета добавляется 1.
* Если какое-то слово есть в списке **античерт**, характерных для конкретного факультета, то из баллов этого факультета вычитается 1.
* Студент приписывается к факультету, который наберёт больше всего баллов.
* Если будет ничья, то просто напишет “Tie!”.
Допустим, в разделе «Личность и черты характера» есть лишь предложение «Алиса была храброй». Тогда Алиса получит 1 балл для Гриффиндора и 0 баллов для остальных факультетов. Соответственно, Алиса попадёт в Гриффиндор.
```
# Импортируем "word_tokenize", разбивающий предложение на слова и пунктуацию
from nltk import word_tokenize
# Функция, распределяющая студентов
def sort_student(text):
text_list = word_tokenize(text)
text_list = [word.lower() for word in text_list]
score_dict = {}
houses = ['Gryffindor', 'Hufflepuff', 'Ravenclaw', 'Slytherin']
for house in houses:
score_dict[house] = (sum([True for word in text_list if word in new_trait_dict[house]]) -
sum([True for word in text_list if word in antonym_dict[house]]))
sorted_house = max(score_dict, key=score_dict.get)
sorted_house_score = score_dict[sorted_house]
if sum([True for i in score_dict.values() if i==sorted_house_score]) == 1:
return sorted_house
else:
return "Tie!"
# Тестируем функцию
print(sort_student('Alice was brave'))
print(sort_student('Alice was British'))
```
Gryffindor Tie!
Похоже, функция работает. Применим её к нашим данным и посмотрим, что получится!
```
# Отключаем предупреждение
pd.options.mode.chained_assignment = None
mydf_relevant['new_house'] = mydf_relevant['text'].map(lambda x: sort_student(x))
mydf_relevant.head(20)
```
```
print("Match rate: {}".format(sum(mydf_relevant['house'] == mydf_relevant['new_house']) / len(mydf_relevant)))
print("Percentage of ties: {}".format(sum(mydf_relevant['new_house'] == 'Tie!') / len(mydf_relevant)))
```
Совпадение: 0.2553191489361702
Доля ничьих: 0.32978723404255317
Хм. Мы ожидали других результатов. Давайте выясним, почему Волан-де-Морт попал в Хаффлпафф.
```
# Текст о Волан-де-Морте
tom_riddle = word_tokenize(mydf_relevant['text'].values[0])
tom_riddle = [word.lower() for word in tom_riddle]
# Вместо вычисления баллов выведем список слов в тексте, совпадающих со словами из словарей черт характера и антонимов
words_dict = {}
anti_dict = {}
houses = ['Gryffindor', 'Hufflepuff', 'Ravenclaw', 'Slytherin']
for house in houses:
words_dict[house] = [word for word in tom_riddle if word in new_trait_dict[house]]
anti_dict[house] = [word for word in tom_riddle if word in antonym_dict[house]]
print(words_dict)
print("")
print(anti_dict)
```
{'Slytherin': ['ambition'], 'Ravenclaw': ['intelligent', 'intelligent', 'mental', 'individual', 'mental', 'intelligent'], 'Hufflepuff': ['kind', 'loyalty', 'true', 'true', 'true', 'loyalty'], 'Gryffindor': ['brave', 'face', 'bold', 'face', 'bravery', 'brave', 'courageous', 'bravery']}
{'Slytherin': [], 'Ravenclaw': ['common'], 'Hufflepuff': [], 'Gryffindor': ['fear', 'fear', 'fear', 'fear', 'fear', 'fear', 'cowardice', 'fear', 'fear']}
Как видите, Слизерин набрал (1-0) = 1 баллов, Рэйвенклоу — (6-1) = 5, Хаффлпафф — (6-0) = 6, Гриффиндор — (8-9) = -1.
Интересно отметить, что в разделе «Личность и черты характера» Волан-де-Морта, самом длинном среди всех студентов, со словарями совпало лишь 31 слово. Это означает, что по другим студентам, вероятно, было гораздо больше совпадений. То есть мы принимаем решение о классификации на основании слишком небольшого количества данных, что и объясняет высокую долю ошибок и большое количество ничьих.
Выводы
------
Созданный нами классификатор работает не слишком хорошо (немногим точнее, чем простое угадывание), но не забывайте, что наш подход был упрощённым. Современные спам-фильтры очень сложны и не классифицируют лишь на основании наличия конкретных слово. Так что наш алгоритм можно улучшить так, чтобы он учитывал больше информации. Вот небольшой список идей:
* Сравнить с факультетами, в которые попадали другие члены семьи этого студента.
* Использовать другие разделы статей, например, «Ранние годы» или введение.
* Вместо маленького списка черт характера и их синонимов создать список наиболее частых слов в разделе «Личность и черты характера» применительно для каждого факультета, и классифицировать на основании этих данных.
* Использовать более сложные методики анализа текстов, вроде [анализа тональности текста](https://ru.wikipedia.org/wiki/%D0%90%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7_%D1%82%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D0%B8_%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%B0).
Однако в процессе работы мы много узнали об API и nltk, так что результат можно считать хорошим. Эти инструменты дают нам прочную основу для будущих начинаний, так что мы можем выходить и покорять Python, как Невил сокрушил Нагайну.
 | https://habr.com/ru/post/331352/ | null | ru | null |
# Сборка проектов с dapp. Часть 1: Java
Эта статья — начало цикла о сборке **dapp**'ом приложений на различных языках, платформах, технологических стеках. Предыдущие статьи про dapp *(см. ссылки в конце материала)* были больше обзорными, описывали возможности dapp. Теперь же пора поговорить более предметно и поделиться конкретным опытом работы с проектами. В связи с недавним релизом [dapp 0.26.2](https://github.com/flant/werf/releases/tag/0.26.2) я заодно покажу, как описывать сборку в YAML-файле.
**Обновлено 13 августа 2019 г.:** в настоящее время проект dapp переименован в **[werf](https://werf.io)**, его код переписан на Go, а документация значительно улучшена.
Описывать сборку буду на примере приложения из репозитория dockersamples — [atsea-sample-shop-app](https://github.com/dockersamples/atsea-sample-shop-app). Это прототип небольшого магазина, построенный на React (фронт) и Java Spring Boot (бэкенд). В качестве БД используется PostgreSQL. Для большей похожести на рабочий проект добавлены реверсивный прокси на nginx и шлюз платежей в виде простого скрипта.
В статье опишу сборку только приложения — образы с nginx, PostgresSQL и шлюзом можно найти в нашем форке в [ветке dappfile](https://github.com/flant/dockersamples-atsea-sample-shop-app/tree/dappfile).
Сборка приложения «как есть»
----------------------------
После клонирования репозитория готовый Dockerfile для Java- и React-приложений можно найти по пути `/app/Dockerfile`. В этом файле определено два образа-стэйджа (в dapp это артефакт) и один финальный образ. В стэйджах собирается Java-приложение в jar и React-приложение в директорию /static.
```
FROM node:latest AS storefront
WORKDIR /usr/src/atsea/app/react-app
COPY react-app .
RUN npm install
RUN npm run build
FROM maven:latest AS appserver
WORKDIR /usr/src/atsea
COPY pom.xml .
RUN mvn -B -f pom.xml -s /usr/share/maven/ref/settings-docker.xml dependency:resolve
COPY . .
RUN mvn -B -s /usr/share/maven/ref/settings-docker.xml package -DskipTests
FROM java:8-jdk-alpine
RUN adduser -Dh /home/gordon gordon
WORKDIR /static
COPY --from=storefront /usr/src/atsea/app/react-app/build/ .
WORKDIR /app
COPY --from=appserver /usr/src/atsea/target/AtSea-0.0.1-SNAPSHOT.jar .
ENTRYPOINT ["java", "-jar", "/app/AtSea-0.0.1-SNAPSHOT.jar"]
CMD ["--spring.profiles.active=postgres"]
```
Для начала переделаю этот файл «как есть» в «классический» Dappfile, а затем — в `dappfile.yml`.
**Dappfile** получается более многословным за счёт Ruby-блоков:
```
dimg_group do
artifact do # артефакт для сборки Java-приложения
docker.from 'maven:latest'
git do
add '/app' do
to '/usr/src/atsea'
end
end
shell do
install do
run 'cd /usr/src/atsea'
run 'mvn -B -f pom.xml -s /usr/share/maven/ref/settings-docker.xml dependency:resolve'
run 'mvn -B -s /usr/share/maven/ref/settings-docker.xml package -DskipTests'
end
end
export '/usr/src/atsea/target/AtSea-0.0.1-SNAPSHOT.jar' do
to '/app/AtSea-0.0.1-SNAPSHOT.jar'
after :install
end
end
artifact do # артефакт для сборки React-приложения
docker.from 'node:latest'
git do
add '/app/react-app' do
to '/usr/src/atsea/app/react-app'
end
end
shell do
install do
run 'cd /usr/src/atsea/app/react-app'
run 'npm install'
run 'npm run build'
end
end
export '/usr/src/atsea/app/react-app/build' do
to '/static'
after :install
end
end
dimg 'app' do
docker.from 'java:8-jdk-alpine'
shell do
before_install do
run 'mkdir /app'
run 'adduser -Dh /home/gordon gordon'
end
end
docker do
entrypoint "java", "-jar", "/app/AtSea-0.0.1-SNAPSHOT.jar"
cmd "--spring.profiles.active=postgres"
end
end
end
```
«Классический» Dappfile — это вариант с export в artifact, который был доступен в dapp до февральских релизов. Он отличается от директивы `COPY --from` в Dockerfile тем, что именно в артефакте указывается, что и куда нужно скопировать, а не в описании финального образа. Так проще описывать примерно одинаковые образы, в которые нужно скопировать один результат сборки чего-либо. Теперь же, с версии 0.26.2, dapp **поддерживает механизм import**, который даже предпочтительней использовать *(пример его использования см. ниже)*.
И ещё один комментарий к файлу. При сборке через `docker build` в Docker Engine отправляется контекст. Обычно это директория, где лежит Dockerfile и исходные тексты приложения. В случае с dapp контекст — это Git-репозиторий, по истории которого dapp вычисляет изменения, произошедшие с последней сборки, и меняет в финальном образе только то, что изменилось. То есть аналог директивы `COPY` без `--from` в Dockerfile — это директива `git`, в которой описывается, какие директории или файлы из репозитория нужно скопировать в финальный образ, куда положить, какого владельца назначить. Также здесь описывается, от каких изменений зависит пересборка, но об этом чуть позже. Пока что давайте посмотрим, как выглядит та же сборка **в новом синтаксисе YAML**:
```
artifact: appserver
from: maven:latest
git:
- add: '/app'
to: '/usr/src/atsea'
shell:
install:
- cd /usr/src/atsea
- mvn -B -f pom.xml -s /usr/share/maven/ref/settings-docker.xml dependency:resolve
- mvn -B -s /usr/share/maven/ref/settings-docker.xml package -DskipTests
---
artifact: storefront
from: node:latest
git:
- add: /app/react-app
to: /usr/src/atsea/app/react-app
shell:
install:
- cd /usr/src/atsea/app/react-app
- npm install
- npm run build
---
dimg: app
from: java:8-jdk-alpine
shell:
beforeInstall:
- mkdir /app
- adduser -Dh /home/gordon gordon
import:
- artifact: appserver
add: '/usr/src/atsea/target/AtSea-0.0.1-SNAPSHOT.jar'
to: '/app/AtSea-0.0.1-SNAPSHOT.jar'
after: install
- artifact: storefront
add: /usr/src/atsea/app/react-app/build
to: /static
after: install
docker:
ENTRYPOINT: ["java", "-jar", "/app/AtSea-0.0.1-SNAPSHOT.jar"]
CMD: ["--spring.profiles.active=postgres"]
```
Всё довольно похоже на «классический» Dappfile, но есть несколько отличий. Во-первых, разрабатывая YAML-синтаксис, мы решили отказаться от наследования и вложенности. Как показала практика, наследование было слишком сложной фичей и время от времени приводило к непониманию. Линейный файл — такой, как Dockerfile — гораздо понятнее: он больше похож на скрипт, а уж скрипты понимают все.
Во-вторых, для копирования результатов артефактов теперь используется import в том dimg, куда нужно поместить файлы. Добавилось небольшое улучшение: если не указать to, то путь назначения будет таким же, как указано в add.
На что обратить внимание при написании Dappfile? Распространённой практикой в проектах с Dockerfile является раскладывание разных Dockerfile по директориям и поэтому пути в директивах `COPY` указываются относительно этих директорий. Dappfile же один на проект и пути в директиве `git` указываются относительно корня репозитория. Второй момент — директива `WORKDIR`. В Dappfile директивы из семейства `docker` выполняются на последнем шаге, поэтому для перехода в нужную директорию на стадиях используется вызов `cd`.
Улучшенная сборка
-----------------
**Сборку Java-приложения** можно разбить как минимум на два шага: скачать зависимости и собрать приложение. Первый шаг зависит от изменений в `pom.xml`, второй — от изменений в java-файлах, описателях, ресурсах— в общем можно сказать, что изменение в директории src должно приводить к пересборке jar’а. Dapp предлагает **4 стадии**: `before_install` (где нет исходников) и `install`, `before_setup`, `setup` (где исходники уже доступны по путям, указанным в директивах `git`).
Скачивание зависимостей можно сделать более агрессивным, указав для maven цель `dependency:go-offline` вместо `dependency:resolve`. Это может быть оправданным решением, т.к. `pom.xml` меняется не очень часто, а `dependency:resolve` не скачивает всё и на этапе сборки приложения будут обращения в Maven-репозиторий (central или в ваш nexus/artifactory/…).
Итого, шаг скачивания зависимостей можно вынести в стадию `install`, которая останется в кэше до момента изменений в `pom.xml`, а сборку приложения — вынести в стадию `setup`, прописав зависимости от изменений в директории `src`.
```
artifact: appserver
from: maven:latest
git:
- add: /app
to: /usr/src/atsea
stageDependencies:
install: ['pom.xml']
setup: ['src']
shell:
install:
- cd /usr/src/atsea
- mvn -B -f pom.xml -s /usr/share/maven/ref/settings-docker.xml dependency:go-offline
setup:
- cd /usr/src/atsea
- mvn -B -s /usr/share/maven/ref/settings-docker.xml package -DskipTests
```
**Сборка React-приложения** также может быть разбита на два шага: скачивание зависимостей на стадии `install` и сборка приложения на стадии `setup`. Зависимости описываются в `/app/react-app/package.json`.
```
artifact: storefront
from: node:latest
git:
- add: /app/react-app
to: /usr/src/atsea/app/react-app
stageDependencies:
install: ['package.json']
setup: ['src', 'public']
shell:
install:
- cd /usr/src/atsea/app/react-app
- npm install
setup:
- cd /usr/src/atsea/app/react-app
- npm run build
```
Обращаю внимание, что пути в `stageDependencies` указываются относительно пути, указанного в `add`.
Коммиты и кэш
-------------
Теперь посмотрим, как работают `stageDependencies`. Для этого нужно сделать коммит с изменением в java-файле и запустить сборку `dapp dimg build`. В логе будет видно, что собирается только стадия `setup`:
```
Setup group
Git artifacts: apply patches (before setup) ... [OK] 1.7 sec
signature: dimgstage-atsea-sample-shop-app:e543a0f90ba39f198b9ae70a6268acfe05c6b3a6e25ca69b1b4bd7414a6c1067
Setup [BUILDING]
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building atsea 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
...
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 39.283 s
[INFO] Finished at: 2018-02-05T13:18:47Z
[INFO] Final Memory: 42M/355M
[INFO] ------------------------------------------------------------------------
Setup [OK] 46.71 sec
signature: dimgstage-atsea-sample-shop-app:264aeb0287bbe501798a0bb19e7330917f3ec62b3a08e79a6c57804995e93137
commands:
cd /usr/src/atsea
mvn -B -s /usr/share/maven/ref/settings-docker.xml package -DskipTests
building artifact `appserver` [OK] 49.12 sec
```
Если изменить `pom.xml`, сделать коммит и запустить сборку, то будет пересобрана стадия `install` со скачиванием зависимостей и затем стадия `setup`.
Зависимости
-----------
Разделение сборки на два шага для Java-приложения закэшировало зависимости и теперь образ стадии `install` выполняет роль хранилища зависимостей. Однако dapp предоставляет возможность подмонтировать директорию для такого рода хранилищ. Монтировать можно из временной директории `tmp_dir`, время жизни которой — одна сборка, можно из `build_dir` — это постоянная директория, уникальная для каждого проекта. В [документации](https://werf.io/documentation/configuration/stapel_image/mount_directive.html) приведены директивы для Dappfile, а в случае нашего приложения покажу, как добавить монтирование поддиректории из `build_dir` в `dappfile.yml`:
```
artifact: appserver
from: maven:latest
> mount:
> - from: build_dir
> to: /usr/share/maven/ref/repository
git:
...
shell:
install:
...
```
Если не указать флаг `--build-dir`, то dapp в качестве `build_dir` создаёт директорию `~/.dapp/builds/<имя проекта dapp>`. В `build_dir` после сборки появляется директория `mount`, в которой будет дерево монтируемых директорий. Имя проекта вычисляется как имя директории, в которой содержится Git-репозиторий. Если собираются проекты из одноимённых директорий, то имя проекта можно указать флагом `--name`, либо явно указывать разные директории с помощью флага `--build-dir`. В нашем случае имя dapp будет вычислено из директории, где хранится Git-репозиторий проекта и потому будет создан `~/.dapp/builds/atsea-sample-shop-app/mount/usr/share/maven/ref/repository/`.
Запуск через compose
--------------------
Ранее об этом не упоминалось, но можно использовать dapp для сборки, а запускать проект для проверки с помощью docker-compose. Для запуска понадобится сделать теги для образов и поправить `docker-compose.yml`, чтобы использовались образы, собранные dapp'ом.
Самый простой способ протегировать образы — запустить команду `dapp dimg tag` без флагов (**Обновлено 13 августа 2019 г.:** в werf тэгирование реализовано немного иначе, [см. документацию](https://werf.io/documentation/reference/plugging_into_cicd/overview.html)). Команда выведет на экран имена образов с тегом `latest`. Теперь нужно поправить `docker-compose.yml`: убрать директивы `build` и добавить директивы `image` с именами образов из вывода `dapp dimg tag`.
Например:
```
payment_gateway:
image: atsea-sample-shop-app/payment-gateway
```
Теперь проект можно запустить командой `docker-compose up` (если build по какой-либо причине остались, то поможет флаг `--no-build`):
Сайт доступен по адресу localhost:8080:
P.S.
----
В следующей части статьи мы расскажем о сборке приложения на… PHP или Node.js — по итогам голосования ниже.
Читайте также в нашем блоге:
* «[**Сборка проектов с dapp. Часть 2: JavaScript (frontend)**](https://habr.com/company/flant/blog/359204/)»;
* «[werf — наш инструмент для CI/CD в Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/460351/)» *(Дмитрий Столяров; 27 мая 2019 на DevOpsConf)*;
* «[Сборка и дeплой приложений в Kubernetes с помощью dapp и GitLab CI](https://habrahabr.ru/company/flant/blog/345580/)»;
* «[Практика с dapp. Часть 1: Сборка простых приложений](https://habrahabr.ru/company/flant/blog/336212/)»;
* «[Практика с dapp. Часть 2. Деплой Docker-образов в Kubernetes с помощью Helm](https://habrahabr.ru/company/flant/blog/336170/)»;
* «[Собираем Docker-образы для CI/CD быстро и удобно вместе с dapp (обзор и видео доклада)](https://habrahabr.ru/company/flant/blog/324274/)»;
* «[Официально представляем dapp — DevOps-утилиту для сопровождения CI/CD](https://habrahabr.ru/company/flant/blog/333682/)». | https://habr.com/ru/post/348436/ | null | ru | null |
# Обратная разработка первоапрельской «Змейки» от Google
Возможно, кто-то из вас заметил, что Google на 1 апреля добавила в приложение Google Maps для Android и iOS интерактивную игру «Змейка».
Специалисты Check Point обычно заняты исследованием последних киберугроз, но здесь очень увлеклись этой игрой, правда, сильно расстраивались из-за проигрышей… поэтому возникла логичная мысль: почему бы её не взломать!
Таким образом, наши самые озорные сотрудники начали думать над обратной разработкой приложения с помощью удалённой отладки. В общем, у них получилось, и вскоре мы успешно выполнили задачу никогда не проигрывать — и даже добавили простой ИИ, который сам играет в игру.
В этой заметке подробно опишем хак.
Сначала мы открыли приложение на виртуальном устройстве через Genymotion и запустили «Змейку», которая находится в меню в правом верхнем углу.
Похоже, что игра отображается в WebView, поэтому мы запустили удалённую отладку в инструментах разработчика Chrome:
Затем перешли на сайт и нашли на вкладке с исходниками файл v18.js, а в нём несколько интересных функций.
Во-первых, функция **fa()** инициирует поле размером 20×20:
```
this.height = this.width = 20;
```
Наша главная цель — найти и изменить функцию, которая определяет, когда змейка врезается в стену или в себя, чтобы отключить возможность проигрыша. Переменные *width* и *height* представляют размеры игрового поля, поэтому мы поискали *width* и *height* внутри исходного кода и нашли функцию **F(a, b)**:
Похоже, **F(a, b)** проверяет, находятся ли координаты тела змеи в пределах поля. Один из вариантов — полностью удалить условия в функции, чтобы она всегда возвращала истину, тем самым переводя нас в «режим Бога», где мы можем проходить сквозь стены, не умирая.
Для этого мы нажали кнопку *Inspect* в удалённой консоли и изменили функцию **F(a, b)** на следующую:
Теперь мы можем проходить сквозь стены:
[](https://research.checkpoint.com/wp-content/uploads/2019/04/fig11.png)
*Рис. 1. Режим Бога*
Это всё очень хорошо, но нам по-прежнему придётся играть, самостоятельно подбирая людей, чтобы зарабатывать очки. Следующий хак решит эту проблему.
В стеке вызовов много вызовов функции **wa(a)**. Если изучить эту функцию, то мы увидим, что она рекурсивна и отвечает за запрос кадров анимации. **wa(a)** вызывает функции **xa(a, b)** и **ya(a)**, которые отображают игровые фигуры (поезд, люди) и поле, соответственно.
Рассмотрим функцию **xa(a, b)**:
Она принимает два аргумента: 'a' и 'b'. Первый является частью глобальной переменной Q, которая содержит интересную информацию о нашей игре, включая массив, который представляет собой игровое поле (рис. 2), где мы видим поезд (М), людей и объекты (K). Функция также вычисляет счёт и сохраняет его в c.i, что также эквивалентно Q.b.
[](https://research.checkpoint.com/wp-content/uploads/2019/04/fig12.png)
*Рис. 2. Массив игрового поля*
Данный массив соответствует такому полю:
*Рис. 3. Игровое поле*
**xa(a)** также обращается к функции **sa(a)** на рис. 4, которая генерирует случайные координаты при каждом создании нового человека. Если вызывать функцию более одного раза, то можно создать сколько угодно людей (рис. 5).
*Рис. 4. Вызов функции **sa(a)***
Как здесь:
*Рис. 5. Вызов функции с созданием любого количества людей на карте*
Обратите внимание, что даже если вызывать **sa(a)** более одного раза и забирать человека, счёт не меняется. При подборе пассажира вызывается функция **ka(a, b)** на рис. 6. Таким образом, её нужно изменить, чтобы при каждом вызове она добавляла 10 очков и обновляла счёт на экране.
*Рис. 6. Обновлённая функция*
Координаты каждой части поезда указаны в Q.b.o.b, где первый элемент представляет собой первый вагончик в поезде.
*Рис. 7. Массив вагончиков*
Это понадобится для создания простого ИИ. Начнём с его логики:
*Рис. 8. Логика ИИ*
Змейка представляет собой машину состояний (конечный автомат):
1. На X=19 идём **вниз**, пока не доберёмся до Y=19.
2. На X=19 и Y=19 идём **влево** до X=0.
3. Переходим к машине состояний для зигзагов:
1. **Вверх** на одну клетку и **направо** до X=18.
2. **Вверх** на одну клетку и **налево** до X=0.
3. Назад к шагу А.
4. На Y=0 идём **направо** до X=19.
5. Возвращаемся к шагу 1.
Полный код опубликован [на GitHub](https://github.com/romanzaikin/Google_Maps_Snake_Hack).
Видео: | https://habr.com/ru/post/446920/ | null | ru | null |
# Рецепты PostgreSQL: преобразование из HTML и URL в PDF и PS
Для приготовления преобразования из HTML и URL в PDF и PS нам понадобится сам [postgres](https://github.com/RekGRpth/postgres), генератор [htmldoc](https://github.com/RekGRpth/htmldoc) и расширение [pg\_htmldoc](https://github.com/RekGRpth/pg_htmldoc). (Я дал ссылки на свои форки, т.к. делал некоторые изменения, которые пока не удалось пропихнуть в оригинальный репозитории. Можно также воспользоваться [готовым образом](https://hub.docker.com/r/rekgrpth/postgres).)
Для начала устанавливаем расширения командой
```
CREATE EXTENSION pg_htmldoc
```
Для преобразования из HTML и URL в PDF и PS используем команды
```
SELECT file2pdf('file.html', 'file.pdf'); -- преобразуем FILE в PDF и сохраняем результат в файл
SELECT file2ps('file.html', 'file.pdf'); -- преобразуем FILE в PS и сохраняем результат в файл
SELECT file2pdf(ARRAY['file1.html', 'file2.html'], 'file.pdf'); -- преобразуем несколько FILE в PDF и сохраняем результат в файл
SELECT file2ps(ARRAY['file1.html', 'file2.html'], 'file.pdf'); -- преобразуем несколько FILE в PS и сохраняем результат в файл
SELECT html2pdf('Здравствуй, мир!', 'file.pdf'); -- преобразуем HTML в PDF и сохраняем результат в файл
SELECT html2ps('Здравствуй, мир!', 'file.pdf'); -- преобразуем HTML в PS и сохраняем результат в файл
SELECT html2pdf(ARRAY['Здравствуй, мир!', 'До свидания, мир!'], 'file.pdf'); -- преобразуем несколько HTML в PDF и сохраняем результат в файл
SELECT html2ps(ARRAY['Здравствуй, мир!', 'До свидания, мир!'], 'file.pdf'); -- преобразуем несколько HTML в PS и сохраняем результат в файл
SELECT url2pdf('https://google.com', 'file.pdf'); -- преобразуем URL в PDF и сохраняем результат в файл
SELECT url2ps('https://google.com', 'file.pdf'); -- преобразуем URL в PS и сохраняем результат в файл
SELECT url2pdf(ARRAY['https://google.com', 'https://google.ru'], 'file.pdf'); -- преобразуем несколько URL в PDF и сохраняем результат в файл
SELECT url2ps(ARRAY['https://google.com', 'https://google.ru'], 'file.pdf'); -- преобразуем несколько URL в PS и сохраняем результат в файл
```
Также, результат генерации можно отправлять на почту с помощью [pg\_curl](https://habr.com/ru/post/456736/) так
```
CREATE OR REPLACE FUNCTION send(url TEXT, username TEXT, password TEXT, subject TEXT, "from" TEXT, "to" TEXT[], data TEXT, type TEXT) RETURNS TEXT LANGUAGE SQL AS $BODY$
WITH s AS (SELECT
pg_curl_easy_reset(), -- обнуляем (на всякий случай)
pg_curl_easy_setopt('CURLOPT_URL', url), -- задаём адрес запроса
pg_curl_easy_setopt('CURLOPT_USERNAME', username), -- задаём логин
pg_curl_easy_setopt('CURLOPT_PASSWORD', password), -- задаём пароль
pg_curl_recipient_append("to"), -- задаём получателей
pg_curl_header_append('Subject', subject), -- задаём тему
pg_curl_header_append('From', "from"), -- задаём отправителя
pg_curl_header_append('To', "to"), -- задаём получателей
pg_curl_mime_data(data, type:=type), -- задаём тело
pg_curl_mime_data(file2pdf('file.html'), file:='=?utf-8?B?'||encode('Из FILE в PDF.pdf', 'base64')||'?=', type:='application/pdf', code:='base64'), -- задаём вложение из FILE в PDF
pg_curl_mime_data(file2ps('file.html'), file:='=?utf-8?B?'||encode('Из FILE в PS.ps', 'base64')||'?=', type:='application/ps', code:='base64'), -- задаём вложение из FILE в PS
pg_curl_mime_data(file2pdf(ARRAY['file1.html', 'file2.html']), file:='=?utf-8?B?'||encode('Из нескольких FILE в PDF.pdf', 'base64')||'?=', type:='application/pdf', code:='base64'), -- задаём вложение из нескольких FILE в PDF
pg_curl_mime_data(file2ps(ARRAY['file1.html', 'file2.html']), file:='=?utf-8?B?'||encode('Из нескольких FILE в PS.ps', 'base64')||'?=', type:='application/ps', code:='base64'), -- задаём вложение из нескольких FILE в PS
pg_curl_mime_data(html2pdf('Здравствуй, мир!'), file:='=?utf-8?B?'||encode('Из HTML в PDF.pdf', 'base64')||'?=', type:='application/pdf', code:='base64'), -- задаём вложение из HTML в PDF
pg_curl_mime_data(html2ps('Здравствуй, мир!'), file:='=?utf-8?B?'||encode('Из HTML в PS.ps', 'base64')||'?=', type:='application/ps', code:='base64'), -- задаём вложение из HTML в PS
pg_curl_mime_data(html2pdf(ARRAY['Здравствуй, мир!', 'До свидания, мир!']), file:='=?utf-8?B?'||encode('Из нескольких HTML в PDF.pdf', 'base64')||'?=', type:='application/pdf', code:='base64'), -- задаём вложение из нескольких HTML в PDF
pg_curl_mime_data(html2ps(ARRAY['Здравствуй, мир!', 'До свидания, мир!']), file:='=?utf-8?B?'||encode('Из нескольких HTML в PS.ps', 'base64')||'?=', type:='application/ps', code:='base64'), -- задаём вложение из нескольких HTML в PS
pg_curl_mime_data(url2pdf('https://google.com'), file:='=?utf-8?B?'||encode('Из URL в PDF.pdf', 'base64')||'?=', type:='application/pdf', code:='base64'), -- задаём вложение из URL в PDF
pg_curl_mime_data(url2ps('https://google.com'), file:='=?utf-8?B?'||encode('Из URL в PS.ps', 'base64')||'?=', type:='application/ps', code:='base64'), -- задаём вложение из URL в PS
pg_curl_mime_data(url2pdf(ARRAY['https://google.com', 'https://google.ru']), file:='=?utf-8?B?'||encode('Из нескольких URL в PDF.pdf', 'base64')||'?=', type:='application/pdf', code:='base64'), -- задаём вложение из нескольких URL в PDF
pg_curl_mime_data(url2ps(ARRAY['https://google.com', 'https://google.ru']), file:='=?utf-8?B?'||encode('Из нескольких URL в PS.ps', 'base64')||'?=', type:='application/ps', code:='base64'), -- задаём вложение из нескольких URL в PS
pg_curl_header_append('Connection', 'close'), -- отключаемся после выполнения
pg_curl_easy_perform(), -- выполняем
pg_curl_easy_getinfo_char('CURLINFO_HEADERS') -- получаем результат
) SELECT pg_curl_easy_getinfo_char FROM s; -- возвращаем результат
$BODY$;
```
И всё это можно выполнять асинхронно в фоне с помощью [планировщика](https://habr.com/ru/post/456722/). | https://habr.com/ru/post/458986/ | null | ru | null |
# STM32 + EmBlocks — мигаем светодиодами
Как и просили в комментариях к [предыдущей статье](http://habrahabr.ru/post/191468/) о EmBlocks, сегодня я покажу от начала и до конца как создать в EmBlocks простой проект для мигания парой светодиодов.
В качестве отладочной платы мы будем использовать кроху на [STM32F103C8](http://ravenium.ru/stm32-vs-arduino/ "STM32F103C8").
Вот наш стенд:
Подключаем аноды светодиодов к пинам PB5 и PB6, катоды через резсторы в 390 Ом к земле.
Итак, если еще не скачали [EmBlocks](http://ravenium.ru/emblocks-ide/#download "download EmBlocks"), сделайте это. Распакуйте в любой удобный каталог и запускайте.
Создаем проект, выбрав в меню «File->New->Project...»
В категории Projects выбираем «STmicro-Arm».
Называем проект и выбираем папку, в которой он будет создан. В дальнейшем новые проекты будут автоматически сохраняться там же, если не выберете другую.
В окне выбора компилера ничего не трогаем и двигаем дальше.
В окне выбора процессора из первого списка выбираем «STM32F10x\_md» т.к. STM32F103C8 принадлежит к семейству F1 и содержит 64к FLASH, что относит его к medium density девайсам.
Если будете использовать ColinkEx, то выбираем в следующем окне конкретное название процессора, это нужно для прошивки утилитой CoFlash.
Если будете пользоваться ST-Link, то можно не трогать.
Галка «Create hex file» отвечает за создание .hex на выходе вместо .elf файла. ColinkEx принимает и те и другие, а вот ST-Link Utility только .hex
Жмем Finish. Мастер предложит выбрать отладчик и настроить его. Причем дважды — для цели Debug, а затем для Release… Если будете использовать другой, нажмите отмену и выберите другой отладчик. О других отладчиках расскажу как-нибудь в другой раз.
По-умолчанию предлагается ST-Link, нас это устраивает, поэтому просто жмем **Ok** дважды для каждой цели (Debug, Release)
Все, болванка проекта готова. Если теперь нажать F7, проект скомпилируется и готов к прошивке с напоминанием, которое уже учтено в настройках Release цели.
Разберем структуру проекта:
---------------------------
[](https://habrastorage.org/storage3/0a4/e7b/919/0a4e7b91912dae99da361e83bf7b85aa.png)
Все файлы проекта автоматически раскладываются по папкам **Sources**, **Headers** и **ASM Sources** для **.с**,**.h** и **.S** файлов соответственно.
В папке **Sources** у нас есть подпапка cmsis\_boot с файлом библиотеки CMSIS.
В подпапке **stm\_lib\src** у нас уже лежит пара файлов, которые нужны практически в любом проекте:
`stm32f10x_gpio.c
stm32f10x_rcc.c`
Это части *StdPeriph Library* для работы с GPIO и системой тактирования.
В подпапке **Src** лежит файл main.c — заготовка для нашей программы.
В папке **Headers** заголовки, разложенные по точно таким же папкам.
В дальнейшем нужные части StdPeriph Library мы будем добавлять в подпапки **stm\_lib\inc** и **stm\_lib\src** и включать в проект, щелкнув правой кнопкой по названию и выбрав «Add files...» или «Add files recursively...». Но сегодня нам это не понадобится.
За запуск микроконтроллера отвечает файл startup\_stm32f10x\_md.S, в папке **ASM Sources\cmsis\_boot\startup**.
Скрипт линкера лежит в папке **Others** и называется gcc\_arm.ld
Cо структурой проекта мы бегло познакомились, пора писать код, ради которого и затевали дело.
Окрываем файл **Sources\Src\main.c** и заменяем текст в нем на такой:
```
#include
#include
#include
#include
#define RCC\_GPIO RCC\_APB2Periph\_GPIOB
#define LED\_PORT GPIOB
#define LED1\_PIN GPIO\_Pin\_5
#define LED2\_PIN GPIO\_Pin\_6
void Delay(volatile uint32\_t nCount) {
for (; nCount != 0; nCount--);
}
int main(void) {
/\* SystemInit() уже отработала в startup\_stm32f10x\_md\_vl.S \*/
GPIO\_InitTypeDef GPIO\_InitStructure;
RCC\_APB2PeriphClockCmd(RCC\_GPIO, ENABLE);
GPIO\_InitStructure.GPIO\_Pin = LED1\_PIN | LED2\_PIN;
GPIO\_InitStructure.GPIO\_Mode = GPIO\_Mode\_Out\_PP;
GPIO\_InitStructure.GPIO\_Speed = GPIO\_Speed\_50MHz;
GPIO\_Init( LED\_PORT , &GPIO\_InitStructure);
LED\_PORT->ODR ^= LED2\_PIN;
while (1) {
LED\_PORT->ODR ^= LED2\_PIN;
LED\_PORT->ODR ^= LED1\_PIN;
Delay(0x7FFFF);
}
return 0;
}
```
Мы определили макросы RCC\_GPIO, LED\_PORT, LED\_PIN1 и LED\_PIN2, изменив которые, мы можем подключить светодиоды к пинам другого порта.
В функции main() заполняем структуру GPIO\_InitStructure, настраивая пины PB5 и PB6 на работу в режиме PushPull с максимальной частотой 50MHz.
Затем инвертируем состояние LED\_PIN2, чтобы светодиоды перемигивались и в цикле переключаем их с небольшой задержкой.
Жмем **F7**, убеждаемся, что проект собрался без ошибок
[](https://habrastorage.org/getpro/habr/post_images/188/6c1/e08/1886c1e087511aeeaa1a009032efef38.png)
Подключаем отладчик ST-Link/v2 к плате и подаем на нее питание например через USB, сняв перемычку P2, чтобы ПК не пытался определить плату как USB девайс, а просто подал питание. Жмем **F6**, чтобы прошить с помощью ST-Link/V2 или выбираем «Tools->Flash w ST-Link/V2» ждем несколько секунд и если все сделали правильно, то светодиоды начнут моргать попеременно, чего мы и добивались:
Довольно просто, неправда ли?
Весь процесс занимает примерно минуту. Если у вас все же не получилось, [скачайте проект](http://ravenium.ru/wp-content/uploads/2013/08/tstBlink.rar "tstBlink Project") и сравните с тем, что получилось у вас.
Для другой платы изменится только выбор процессора из списка, если он отличается и макроопределения светодиодов, если он подключены к другому порту.
Например, для STM32VLDiscovery:
```
#define RCC_GPIO RCC_APB2Periph_GPIOC
#define LED_PORT GPIOC
#define LED1_PIN GPIO_Pin_8
#define LED2_PIN GPIO_Pin_9
``` | https://habr.com/ru/post/191624/ | null | ru | null |
# JavaScript не нужно ничем заменять — другие языки тоже столкнутся с теми же проблемами
> «Существует только два вида языков: те, на которые жалуются и те, которыми никто не пользуется», — Бьёрн Страуструп, создатель C++
Очень часто слышатся заявления о том, что JavaScript нужно заменить каким-то другим языком. Причиной всегда становится то, что у JavaScript накопилось слишком много странностей, которые давно нужно было исправить.
Но поскольку их не исправили, то это очевидно означает, что JavaScript — отстойный язык, который просто никак не исправишь. И что его нужно заменить, и желательно любимым языком очередного жалобщика.
Но действительно ли это так?
Как мы оказались в такой ситуации?
==================================
Не стоит ждать, что я назову JavaScript идеальным языком. У него есть странные причуды. [Он был спроектирован за десять дней](https://en.wikipedia.org/wiki/JavaScript#Beginnings_at_Netscape), а затем его изменили так, чтобы он напоминал Java. К сожалению, это наследие, с которым мы вынуждены жить.
Но ни один язык не идеален, а JavaScript значительно улучшился после ES6 и продолжает своё развитие. Он эволюционировал из «игрушечного языка», используемого только для анимирования элементов веб-страниц, в серьёзный язык программирования, применяемый сегодня для выполнения больших и сложных веб-приложений.
JavaScript сегодня в буквальном смысле повсюду и является [самым используемым языком программирования в мире](https://insights.stackoverflow.com/survey/2019#most-popular-technologies).
Так почему же некоторые разработчики всё равно требуют его заменить?
Познай свой язык
================
Больша́я часть критики JavaScript возникла вследствие невежества, незнания языка и нежелания по-настоящему его изучить.
Ключевое слово `this`, прототипное наследование и нехватка иммутабельности — вот три основных источника путаницы в JavaScript. Я понимаю вас, если вы привыкли к языку, ведущему себя иначе. Мне понятно ваше смятение, а иногда и раздражение.
Но всё это не является непреодолимыми препятствиями. В изучении того, как на самом деле работает JavaScript нет ничего космически сложного, если у вас действительно будет желание учиться.
Вполне можно понять, почему разработчики стремятся к тому, чтобы другой язык заменил JavaScript, раз и навсегда устранив все его проблемы, но это нереалистично и не станет реальным решением.
Не ломайте веб
==============
[Главный принцип проектирования](https://www.w3.org/TR/html-design-principles/#support-existing-content) для JavaScript, а также для HTML и CSS, заключается в том, что новые возможности *никогда* не должны «ломать» уже существующие веб-сайты.
По сути, это превращает JavaScript в язык программирования, в котором возможно *только добавление*: возможности могут добавляться только в том случае, если они не повредят существующим веб-сайтам, но уже имеющиеся возможности *никогда* не должны меняться или удаляться.
Этот принцип гарантирует, что уже готовые веб-сайты никогда не поломаются, даже если они создавались десятки лет назад, и комитет TC39 [прилагает серьёзные усилия](https://developers.google.com/web/updates/2018/03/smooshgate) для того, чтобы этот принцип не нарушался.
Это хорошая черта, но она накладывает на JavaScript бремя: возможности могут только *добавляться* в него, но никогда не *меняться*.
Поэтому несмотря на то, что сбивающие с толку аспекты JavaScript, например, ключевое слово `this`, теоретически можно исправить, это может нанести урон существующим веб-сайтам, которые идеально работали до внесения изменений. И это просто неприемлемо, потому что нарушает принцип «не ломайте веб».
Другой язык — не решение
========================
Теоретически, на замену JavaScript можно реализовать новый язык. Предполагаю, что это станет техническим и логистическим кошмаром, который продлится целую вечность, но в целом это вполне реализуемо.
Но этот новый язык *тоже* должен будет придерживаться принципа «не ломайте веб», что по сути также превратит его в *только дополняемый* язык. Думаю, вы уже можете предвидеть, как энтузиазм относительного этого языка постепенно угаснет, и вскоре мы снова услышим те же стоны о необходимости его замены.
Ограничения, накладываемые на JavaScript этим принципом, ограничивают возможные пути его эволюции, и будут относиться к *любому* языку, который стремится его придерживаться. Именно это превратило JavaScript в то, чем он является сегодня, и язык, который бы заменил его, никоим образом не смог бы избежать той же судьбы.
На самом деле беспрецедентная обратная совместимость JavaScript, сохраняемая два с лишним десятка лет, является огромным достижением. Она сыграла серьёзную роль в эволюции того веба, который мы имеем сейчас, и JavaScript следует за это благодарить, а не ненавидеть.
С чистого листа?
================
Надеюсь, теперь вы осознаёте, насколько мала вероятность того, что другой язык полностью заменит JavaScript. Но если вы всё равно не хотите подробно изучать JavaScript, то для вас есть надежда в лице [WebAssembly](https://webassembly.org/) и дюжины других [языков, которые компилируются в JavaScript](https://github.com/jashkenas/coffeescript/wiki/list-of-languages-that-compile-to-js).
Меня не перестаёт впечатлять [TypeScript](https://www.typescriptlang.org/), добавивший к JavaScript статическую типизацию, и [PureScript](http://www.purescript.org/), который по сути является Haskell в браузере, позволяющим писать полностью работоспособный код в парадигме функционального программирования.
Но, как это всегда бывает, дополнительный этап компиляции добавляет сложности и вопрос заключается в том, стоит ли оно того. На данный момент я бы порекомендовал вам изучать TypeScript, потому что он является надмножеством JavaScript, и следовательно, они очень схожи. Кроме того, он активно разрабатывается и имеет большое сообщество.
Также вам понадобится время на его изучение. Время, которое можно потратить на тщательное изучение JavaScript. В нём нет ничего особо трудного, и после того, как вы изучите его причуды, увидите, что это невероятно мощный и гибкий язык.
Он неидеален, но, повторюсь, как и любой другой язык.
Выбор за вами. | https://habr.com/ru/post/477694/ | null | ru | null |
# Получение данных из СУБД Oracle средствами С/C++ под SuSE Linux
Привет хабрачеловек!
Столкнулся на днях с необходимостью получить данные из СУБД Oracle средствами С/C++ под SuSE Linux
До этого неоднократно выполнял подобные вещи из других языков (Perl, PHP, sh), но вот из C еще ни разу.
Из всех доступных средств, которые позволяют подключиться к Oracle, я остановился на методе прекомпиляции proc, бинарник которой входит в базовую комплектацию Oracle клиента.
Система на которой будет происходить буйство красок:
vmotp# cat /etc/SuSE-release
SUSE Linux Enterprise Server 11 (i586)
VERSION = 11
PATCHLEVEL = 0
+
oracle.client VER:10.2.0.1.0
Сама БД находится на другой машине. Версия сервера: 9.0.2 (знаю, что старая, но она служит исключительно как историческая реплика и простая база для временных таблиц)
Для начала сделаем пример на подобие «Hello World», который будет выводить на экран результат запроса
`SELECT 12345,'TEST STRING' FROM dual;`
Делаем файл **test\_ora.pc** со следующим содержанием
`#include
#include
#include
#include
#include
#include
#define ORA\_PARAM "**~~ORACLE\_LOGIN/ORACLE\_PASS@ORACLE\_SID~~**" /\*Меняем зачеркнутое на свои настройки подключения к БД \*/
EXEC SQL BEGIN DECLARE SECTION; /\* Далее до строки END DECLARE SECTION идет описание переменных, которые будут использованы для чтения строк из Oracle\*/
static int ora\_i; /\*Переменная для чтения INT значения \*/
static VARCHAR ora\_str[20]; /\*Переменная для чтения CHAR значения \*/
static VARCHAR connect\_str[100]; /\*Переменная для параметров подключения \*/
EXEC SQL END DECLARE SECTION;
EXEC SQL INCLUDE SQLCA; /\*Включаем SQLCA что бы получать ошибки (насколько я понял) \*/
int main( int argc, char\* argv[] )
{
char str[21]; /\*Объявляем переменную для переформатирования CHAR данных из БД\*/
memset(str,0,sizeof(str)); /\*Очищаем переменную для подключения\*/
connect\_str.len = sprintf(connect\_str.arr,ORA\_PARAM); /\*Заносим в нее параметры подключения\*/
EXEC SQL CONNECT :connect\_str; /\*Подключаемся\*/
EXEC SQL WHENEVER SQLERROR CONTINUE;
EXEC SQL SELECT 12345,'TEST STRING' INTO :ora\_i,:ora\_str FROM dual; /\*Выполняем запрос, счиывая значения в подготовленные переменные\*/
sprintf( str, "%\*.\*s", ora\_str.len, ora\_str.len, ora\_str.arr ); /\*Переводим считанную переменную CHAR в формат пригодный для использования в C \*/
printf("\ni=[%d], str=[%s]\n", ora\_i, str ); /\*Выводим результат на экран\*/
return 0;
} /\* end of main() \*/`
Теперь необходимо «скормить» наш файл утилите proc, по умолчанию она находится по пути **$ORACLE\_HOME/bin/**
`/opt/oracle/product/11gR1/db/bin/proc CODE=ANSI_C include=/opt/oracle/product/11gR1/db/lib include=/usr/lib/gcc/i586-suse-linux/4.3/include/ ireclen=4800 oreclen=4800 select_error=no release_cursor=no hold_cursor=yes ltype=none cpp_suffix=c USERID=**~~ORACLE\_LOGIN/ORACLE\_PASS@ORACLE\_SID~~** SQLCHECK=SEMANTICS iname=test_ora.pc;`
`cc test_ora.c -L/opt/oracle/product/11gR1/db/lib /opt/oracle/product/11gR1/db/lib/libclntsh.so /opt/oracle/product/11gR1/db/lib/libsqlplus.a -o test_ora;`
Запускаем получившийся файл и видим, что фокус удался:
`vmotp$ ./test_ora
i=[12345], str=[TEST STRING]
vmotp$`
PS. Данную статью публикую по просьбе моего друга. У которого еще нет логина на хабр, если у кого-то остались инвайты, поделитесь, пожалуйста ( lanarion (at) gmail.com ). | https://habr.com/ru/post/90556/ | null | ru | null |
# Опыт разработки плагина для Yasca
В этой статье я хочу поделиться опытом использования одной полезной [утилиты](http://www.scovetta.com/yasca.html), позволяющей автоматизировать сборку и анализ качества кода. Речь пойдет о Yasca — свободно распространяемом ПО, представляющем собой небольшой PHP движок и набор утилит для выполнения анализа Java, С++ или PHP кода, включающего в себя PMD, JLint и RATS. Сама интеграция выполнения этих утилит осуществляется путем разработки небольших плагинов, на языке PHP. О процессе разработки такого плагина и пойдет речь далее.
Для начала, нам нужно добиться функционирования самой Yasca. Сделать это — довольно просто. Идем на [страницу закачки](http://sourceforge.net/projects/yasca/files/Yasca%202.x/Yasca%202.1/) и скачиваем собственно [yasca](http://sourceforge.net/projects/yasca/files/Yasca%202.x/Yasca%202.1/yasca-2.1.zip/download) и какой-нибудь из [кодечекеров](http://sourceforge.net/projects/yasca/files/Yasca%202.x/Yasca%202.1/yasca-2.1-pmd.zip/download). создаем локальный каталог (например c:/yasca) и просто распаковываем в него все архивы по очереди. Сразу же после этого, инструмент готов к работе. Набираем в командной строке (или сохраняем в cmd-файл) команду (заменив многоточие на путь к каталогу с каким нибудь Java или C++ проектом):
```
yasca.exe -o ./Report ...
```
Проработав некоторое время, Yasca формирует отчет Report.html, содержащий замечания по стилю кодирования нашего проекта. Строки отчета содержат ссылки на исходный код и единственное, что неудобно, это то, что при переходе по ссылке, мы попадаем в начало файла, а искать нужную строку по номеру может быть слегка утомительно. Именно это я и предлагаю исправить. Пусть ссылки позиционируют нас сразу на нужную строку исходного кода.
Понятно, что мы не сможем провернуть такой фокус непосредственно с исходными текстами, но мы можем построить на их основе временные html-файлы, сформировав в каждой строке закладку, в качестве имени которой, используем номер строки. Заодно, слева, мы проставим номера строк, чтобы было удобнее ориентироваться. Звучит страшновато, но на самом деле, делается довольно просто. Сам плагин (его нужно будет, назвав Mirror.php, поместить в папку plugins) будет выглядеть следующим образом:
```
php
/**
* @extends Plugin
* @package Yasca
*/
class Plugin_Mirror extends Plugin {
public $valid_file_types = array("java", "c", "cpp", "h", "cs", "sql");
function rmdir_recurse($path) {
$path= rtrim($path, '/').'/';
$handle = opendir($path);
for (;false !== ($file = readdir($handle));)
if($file != "." and $file != ".." ) {
$fullpath= $path.$file;
if( is_dir($fullpath) ) {
$this-rmdir_recurse($fullpath);
rmdir($fullpath);
}
else
unlink($fullpath);
}
closedir($handle);
}
function execute() {
$yasca =& Yasca::getInstance();
static $once = true;
if ($once) {
$this->rmdir_recurse('./Mirror');
}
$once = false;
if (!check_in_filetype($this->filename, $this->valid_file_types)) {
return;
}
$filename = preg_replace('/\w:/', './Mirror', $this->filename) . ".html";
$dir_name = preg_replace('/[\\\\\\/][^\\\\\\/]+$/', '', $filename);
if (!file_exists($dir_name)) {
if (!mkdir($dir_name, 0777, true)) return;
}
if (file_exists($filename)) {
unlink($filename);
}
if (!$handle = fopen($filename, 'w+', true) ) return;
fwrite($handle,"
```
\n");
$line = 1;
foreach ($this->file_contents as $file_line) {
$str = $line;
while (strlen($str)<5) {
$str = " " . $str;
}
fwrite($handle,"$str: $file_line
\n");
$line++;
}
fwrite($handle,"
```
");
fclose($handle);
}
}
?>
``` | https://habr.com/ru/post/158229/ | null | ru | null |
# Полигоны Another World: IBM PC
Перевод [четвёртой статьи из серии от Fabien Sanglard](http://fabiensanglard.net/another_world_polygons_PC_DOS/index.html), в этот раз про [порт Another World на IBM PC](https://suvitruf.ru/2020/03/11/7684/another_world_polygons_pc_dos/).
В течение трёх десятилетий IBM спокойно доминировала на рынке мэйнфреймов. Когда в 1979 году продажи микрокомпьютеров достигли 150 миллионов долларов, «Колосс Армонка» решил выпустить собственный. На фоне конкурентов, таких как Hewlett-Packard (HP), Texas Instruments (TI), Tandy и Data General, IBM сделала всё по-другому, чтобы выделиться.
Серия статей
------------
1. [Полигоны Another World](https://habr.com/ru/post/482872/).
2. [Полигоны Another World: Amiga 500](https://habr.com/ru/post/483140/).
3. [Полигоны Another World: Atari ST](https://habr.com/ru/post/484656/).
4. Полигоны Another World: IBM PC.
5. [Полигоны Another World: Sega Genesis](https://habr.com/ru/post/503410/).
IBM PC
------
Вместо того, чтобы идти по вертикали, как это было в прошлом, с большинством компонентов и программного обеспечения, разработанных собственными силами, IBM построила свой микрокомпьютер горизонтально. Они приобрели такие элементы, как CPU, у Intel и поставили с операционной системой PC DOS 1.0 от Microsoft.
Они пошли ещё дальше, предоставив технические характеристики и схемы машины. Для потребителей, которые раньше боролись с производителями за технические детали, это был совершенно новый мир.
> Техническое справочное руководство IBM PC за 36 долларов США включало в себя полную принципиальную схему, откомментированный исходный код ПЗУ BIOS и другую информацию по проектированию и программированию для всего оборудования IBM, связанного с ПК, а также инструкции по разработке периферийных устройств сторонних производителей.
>
> **— Wikipedia (IBM\_Personal\_Computer#History)**
>
>
Первый персональный компьютер от IBM был выпущен 12 августа 1981 года с появлением 5150. Он работал на Intel 8088 (4,77 МГц) с 16 КиБ ОЗУ и графической картой MDA, которая могла отображать только текст. Это был потрясающий успех, было продано 40 000 единиц в день анонса. Некоторое время IBM оставалась единственным поставщиком так называемого «ПК».
Когда популярность компьютеров IBM перешагнула порог, открытость, которая способствовала успеху, стала помехой. В марте 1983 года Compaq представила «совместимый с IBM ПК» под названием «Compaq Portable». Вскоре после этого рынок ПК был наводнён клонами ПК. IBM попыталась внедрить новый стандарт, используя защищённую авторским правом шину MCA. Когда эти усилия потерпели неудачу, IBM фактически потеряла контроль над рынком.
Архитектура
-----------
ПК от IBM были построены вокруг концепции «большого ядра» с чудовищным процессором, большим количеством оперативной памяти и всем, что клиент хотел купить в виде дополнительной карты. В 1991 году это дополнение включало графическую карту, которая может быть любой, от TGA, EGA, до последней VGA. То же самое касается аудио части с не менее чем четырьмя типами несовместимых выходов (Beeper, AdLib, SoundBlaster и Disney Sound Source).
Чтобы выпустить программное обеспечение для «IBM PC или Compatible», разработчики могли отображать только список «минимальных требований» и «рекомендуемой конфигурации» на игровой упаковке. Поддерживаемые процессор, оперативная память, графический адаптер и звуковые карты были перечислены там.
«Типичный» ПК 1991 года был бы чем-то на базе процессоре Intel 386 с частотой 16 МГц с 2 МиБ ОЗУ и аудиокартой AdLib. Как и в Atari ST, был контроллер DMA, который нельзя было использовать для Blit, поскольку он был предназначен для передачи данных с дискет/HDD.
Видео системы
-------------
С выпуска первого ПК в 1981 и по 1991 год было выпущено пять основных графических стандартов. MDA и CGA в основном вымерли, но все ещё существовала большая база старых TGA/EGA, которые ещё не были обновлены до VGA.
```
Акроним Полное наименование Год выпуска
--------------------------------------------------------------
MDA Monochrome Display Adapter 1981
CGA Color Graphics Adapter 1981
TGA Tandy Graphics Adapter 1984
EGA Enhanced Graphics Adapter 1985
VGA Video Graphics Array 1987
```
Старшие поколения TGA/EGA использовали ужасную цветовую систему с 2-мя битами на канал (6 бит на цвет).
| | |
| --- | --- |
| | |
Последнее поколение VGA использовало гораздо более впечатляющую систему с 6 битами на канал (18 бит на пиксель).
| | |
| --- | --- |
| | |
Конфигурирование этих карт было ужасом по связке 300 регистров, которые все взаимодействовали друг с другом. К счастью, в BIOS компьютера была предусмотрена процедура настройки всего. В то время, в зависимости от графической карты, было доступно 19 режимов.
```
Режим Тип Разрешение Цвета RAM/VRAM маппинг VRAM (KiB)
-------------------------------------------------------------------------------
0h,1h MDA 360 x 400 16 B8000 16
2h,3h MDA 720 x 400 16 B8000 16
4h,5h CGA 320 x 200 4 B8000 16
6h CGA 640 x 200 2 B8000 16
7h MDA 720 x 400 2 B0000 16
8h TGA 160 x 200 B0000 64
9h TGA 320 x 200 16 B0000 64
Ah TGA 640 x 200 16 B0000 64
Bh --- --------- -- ----- --
Ch --- --------- -- ----- --
Dh EGA 320 x 200 16 A0000 128
Eh EGA 640 x 200 16 A0000 128
Fh EGA 640 x 350 2 A0000 128
10h EGA 640 x 350 16 A0000 128
11h VGA 640 x 480 2 A0000 256
12h VGA 640 x 480 16 A0000 256
13h VGA 320 x 200 256 A0000 256
```
Обратите внимание на три режима 320x200, по крайней мере, с 16 цветами, которые соответствуют требованиям VM Another World. Как мы увидим, это не совсем то, что в конечном итоге использовалось.
Графический адаптер Tandy
-------------------------
Удивительно, но графический режим, обозначенный как TGA, был представлен не корпорацией Tandy, а IBM. Когда крупная железячная компания выпустила свой «PCjr» 1984 года, нацеленный на рынок Apple II/Commodore 64, они воспользовались возможностью улучшить свою устаревшую CGA. Позднее в том же году корпорация Tandy выпустила «Tandy 1000» по более низкой цене с более лёгкой расширяемостью и более широкой совместимостью с ПК. Если вначале Tandy «охватила» графическую подсистему IBM, лучшие продажи позволили им «улучшить»[[1]](#tandy_graphics_adapter_incompatibilities) и в конечном итоге «затмить» имя PCjr.
Каждая версия MDA/CGA/EGA/VGA имела обратную совместимость, но TGA имеет три эксклюзивных режима: 8h, 9h и Ah. Самым интересным для «Another World», конечно же, является режим 9h 320х200 с 16 цветами. Этот режим был доступен только со специальным расширением VRAM (8x16КиБ) на 128 КиБ, так как это «режимы с высокой пропускной способностью»[[2]](#Tandy_1000TL).
Графический слой режима 9h очень похож на Atari ST, который мы рассмотрели в [прошлой статье](https://habr.com/ru/post/484656/).
Фреймбуферы размещаются в оперативной памяти, поскольку на этих машинах не было VRAM. Пиксели располагаются линейно в виде полубайтовых нибблов, кодирующих 4-битные индексы цвета[[3]](#IBM_PCjr_Technical_Reference).
Усовершенствованный графический адаптер
---------------------------------------
EGA и VGA очень похожи. Они могут быть настроены на 320x200 в режиме 16 цветов через режим 9h. Здесь есть VRAM, к которой напрямую обращается центральный процессор.
Кадровый буфер организован так же, как на Amiga, которую мы изучали в [первой статье](https://habr.com/ru/post/482872/), за исключением того, что каждая битовая плоскость находится в выделенном блоке памяти. Есть четыре блока. В режиме 9h бит из каждого из четырёх блоков объединяется в ниббл, получая тем самым 4-битный индекс цвета.
Карты VGA имеют намного больше VRAM (256 КиБ как 4x64 КиБ), чем карты EGA (128 КиБ как 4x32 КиБ), что не имеет значения для Another World. VGA имеет более глубокие цвета (6 бит/канал против 2 бит/канал), что очень важно.
Обманчиво мощный
----------------
С точки зрения вычислительной мощности ПК намного превосходил Amiga и Atari ST, которые мы рассмотрели ранее. Проблемой для игр было очень медленное видео.
Система памяти никогда не была предназначена для анимации. Она была разработана с учётом электронных таблиц и обработки текста. Перемещение всех этих пикселей по шине занимало много времени. Более того, работа с битпланом была обременительной, особенно без сопроцессора, такого как Amiga Blitter. Возьмём для примера простую процедуру очистки экрана в режиме 9h.
```
char far * VGA = ( byte far *) 0xA0000000L ;
#define SC_MAPMASK 0x02
#define SC_INDEX 0x03c4
#define SC_DATA 0x03c5
void selectBank(uint_8 bank) {
outp(SC_INDEX , SC_MAPMASK );
outp(SC_DATA , 1 << bank );
}
void ClearScreen() {
for(int y =0 ; y < 200 ; y ++) {
for(int x =0; x < 160 ; x ++) {
selectBank(x % 4);
VGA[x + y * 200] = 0;
}
}
}
```
Даже на лучшем ПК 1991 года этот пример кода не мог пройти 5fps[[4]](#Game_Engine_Black_Book_Wolfenstein_3D_clearScreen). Это патологический пример, поскольку экран очищается слева направо. Однако даже при вертикальной очистке, чтобы избежать переключения блоков памяти, этот код всё равно будет работать только со скоростью 10 кадров в секунду[[5]](#Game_Engine_Black_Book_Wolfenstein_3D_p_127).
```
void ClearScreen() {
for(int x =0; x < 160 ; x ++) {
selectBank (x % 4);
for(int y =0 ; y < 200 ; y ++) {
VGA[x + y * 200] = 0;
}
}
}
```
При разработке игр старались максимально избегать переключения блоков. Именно по этой причине Wolfenstein 3D рисовал всё, от стен до спрайтов, включая HUD, по вертикали, и даже тогда только 72% экрана обновлялось в каждом кадре, достигая 11 кадров в секунду на 386SX 16 МГц.
Another World на PC
-------------------
Учитывая ограничения TGA/EGA/VGA, перенос Another World на ПК выглядел непростой задачей. Мало того, что вам приходилось сталкиваться с фрагментацией, вы также должны были создать движок, невероятно быстрый для удовлетворения требований.
Эта проблема встала перед Даниэлем Морэ, который заключил контракт с Delphine Software.
> Эрик Шайи хотел, чтобы на всех портах частота кадров соответствовала версиям Atari и Amiga. Даже на слабом ПК с процессором 286 игра должна была работать со скоростью 24 кадра в секунду.
>
> **— Даниэль Морэ**
>
>
Решение проблем с фрагментацией
-------------------------------
Чтобы разобраться с фрагментацией графической и звуковой систем, Даниэль написал слой абстракции, основанный на указателях функций.
> Было бы намного проще написать порт PC DOS на C. Но Эрик написал версию Atari ST и Amiga на 68000 asm. Я принял это как вызов и поставил себе целью сделать то же самое. В конце концов, виртуальная машина была на 100% написана на x86 asm.
>
> **— Даниэль Морэ**
>
>
В 1991 году не было PnP. Чтобы настроить игру, пользователи должны были запустить текстовый инструмент CONFIG.EXE, чтобы детализировать свою периферию.
| | |
| --- | --- |
| | |
Параметры сохраняются в файле CONFIG.DAT. Когда запускается ANOTHER.EXE, он читает файл и назначает указатели функций в зависимости от графической и звуковой карт.
Работа с TGA
------------
При работе с графической картой TGA особого выбора не было. Режим 9h обеспечивает 320x200 с 16 6-битными цветами. Автоматическое преобразование палитр из 4-битных цветов в 2-битные с помощью LSR привело к алиасингу. Решением было преобразовать все палитры вручную.
Визуально результат «особенный». Имейте в виду, что проблема здесь заключается не в количестве цветов (TGA имеет 16), а в глубине цвета.
Результат может быть не всем по душе, но я не думаю, что можно было бы сделать гораздо больше с 6-битными цветами. Расположение данных похоже на Atari ST, что было рассмотрено ранее, и далее TGA обсуждаться не будет.
Работает с EGA
--------------
На графической карте EGA лучшим режимом был режим Dh. Используются те же палитры, что и для TGA, поскольку цвета EGA также кодируются в 6-битном формате. Остальное работает как VGA.
Работа с VGA
------------
С графической картой VGA всё куда интересней. На первый взгляд казалось, что режим 13h дал бы лучшие визуальные эффекты за счёт 4 бит на пиксель. Но Даниэль обнаружил, что VGA-карта не работает как EGA в режиме Dh. Загрузка палитры не ожидала 6-битного цвета, но 18-битного, как в режиме 13h. Это позволило также работать в режиме Dh, не теряя места, но с теми же визуальными эффектами, что и на Amiga.
По этой причине игра также поставляется с палитрами Amiga (вместе с палитрами TGA/EGA).
TL;DR: TGA/EGA/VGA
------------------
Игра поставлялась с двумя наборами палитр. Первый с 6 битами на цвет для TGA/EGA и набор с Amiga для VGA. В TGA используется режим 9h. В EGA/VGA игра работает в режиме Dh.
DRAWN и FILL
------------
Отрисовка полигонов выполняется как на Atari ST, полностью программно. Простой алгоритм Брезенхэма генерирует горизонтальные линии начальных и конечных координат пространства экрана. В результате возникла проблема заполнения этих строк достаточно быстро.
> К счастью, в Париже был этот невероятный компьютерный книжный магазин под названием «Le monde en tique» с набором книг по программированию, которых вы не могли найти больше нигде во Франции. Я нашёл объяснение одной особенности EGA/VGA, и это очень помогло.
>
> **— Даниэль Морэ**
>
>
Хитрость заключалась в использовании факта, что полигоны были одного цвета, стоило лишь поиграть с выбором блока памяти. Вместо записи в один блок за другим, маска блока может быть настроена для одновременной записи во все блоки.
Производительность зависит от выравнивания, но в лучшем случае этот трюк позволяет писать 4 байта вместо одного. Это приводило к установке восьми последовательных горизонтальных пикселей при записи одного байта.
> Я не помню точных чисен, но отрисовка полигонов была ОХРЕНЕННО БЫСТРОЙ. С этим 8-кратным ускорением частота кадров оказалась намного выше цели в 24 кадра в секунду, которую мы для себя поставили.
>
> **— Даниэль Морэ**
>
>
COPY
----
Последней частью головоломки было найти способ достаточно быстро выполнить опкод COPY FB. Поскольку фреймбуфер был записан в VRAM благодаря уловке с выбором групп памяти, единственным способом копирования, очевидно, было возвращение кадрового буфера из VRAM в RAM для хранения и записывать его обратно в VRAM по требованию.
Уловка для решения этой проблемы была задокументирована Майклом Абрашем в его статье «Mode X Marks the Latch»[[6]](#Mode_X_Marks_the_Latch). Дизайнеры EGA/VGA не были полными садистами. Чтобы справиться с гранулярностью битовых плоскостей, каждый блок имеет однобайтовый переключатель. «Запоминание» последнего прочитанного байта значительно упрощает построение битов.
Хитрость здесь в том, чтобы переставить переключатели, чтобы они использовались для чтения и записи четырёх байтов за раз.
Выбрав сохранение BKGD в VRAM вместе с двойными буферами, код операции COPY FB был реализован с 4-кратным ускорением.
Удивительные сложности со звуком
--------------------------------
В этой серии статей аудио часть не обсуждалась, так как это была «решённая проблема» на большинстве платформ. Очевидно, с портом ПК DOS это предположение не подтвердилось.
> Часть с EGA/VGA не была действительно сложной для написания, потому что это было в основном написание кода для заполнения строк одним цветом или копирование целых кадровых буферов из VRAM в VRAM. Как только вы узнаете, как работает EGA/VGA, это становится довольно легко реализовать.
>
>
>
> Трудности возникли при работе с аудио. Музыка для Amiga была написана с помощью инструмента «Sound Tracker» с аудиосэмплами, воспроизводимыми на четырёх каналах. На Amiga и ST это было просто, потому что в этих машинах было всё необходимое. Но на ПК это была совсем другая история. У этих машин был «buzzer» по умолчанию, а у счастливчиков был AdLib, способный воспроизводить FM. Ни один из них не имел возможности PCM, как, например, Sound Blaster и Gravis UltraSound.
>
>
>
> Чтобы решить эту проблему, мне пришлось изменить таймер IRQ (от 80 или 100 Гц до 8000 Гц, уже точно не помню). Это означало, что основная программа прерывалась 8000 раз в секунду, чтобы сделать что-то ещё. Это «что-то ещё» должно было быть как можно короче, иначе ПК зависнет. Цель состояла в том, чтобы заставить PC Buzzer или AdLib вибрировать на желаемой частоте для имитации PCM сэмплов.
>
> Результат был далёк от оригинала. В любом случае это было лучше, чем вообще никакого звука.
>
> **— Даниэль Морэ**
>
>
**На заметку:** в версии для ПК издатель Interplay жаловался на продолжительность игры (которая может быть закончена всего за 20 минут опытными игроками). Чтобы увеличить продолжительность, были добавлены новые уровни (уровней стало на 3 больше – 15)[[7]](#Another_World_Out_of_this_World_Versions_of_a_Classic).
Итог
----
Даниэль создал великолепный порт для Delphine Software. Работая в том же разрешении, что и на Atari ST и Amiga (320x200 и 16 цветов), ему даже удалось снизить минимальную конфигурацию до Intel 286 с 10MHz ЦП и 640 КиБ ОЗУ на ЛЮБОЙ графической карте: TGA, EGA или VGA[[8]](#Mobygames_Another_World_DOS_Box).
Ссылки
------
1. [Tandy Graphics Adapter Incompatibilities](https://en.wikipedia.org/wiki/Tandy_Graphics_Adapter#Incompatibilities).
2. [TGA has 3 rows of 8 64kx4 DRAM. The four is the 128k upgrade](http://www.oldskool.org/guides/tvdog/1000TL.html).
3. [IBM PCjr Technical Reference](https://archive.org/details/IBMPCJrTechnicalReference_201705/page/n83).
4. [Game Engine Black Book: Wolfenstein 3D clearScreen](http://fabiensanglard.net/gebb/index.html).
5. [Game Engine Black Book: Wolfenstein 3D p 127](http://fabiensanglard.net/gebb/index.html).
6. [Mode X Marks the Latch](https://www.phatcode.net/res/224/files/html/ch48/48-01.html)
7. [Another World, a.k.a. Out of this World — Versions of a Classic](http://nerdlypleasures.blogspot.com/2013/01/another-world-aka-out-of-this-world.html).
8. [Mobygames, Another World DOS Box](https://www.mobygames.com/game/dos/out-of-this-world/cover-art/gameCoverId,783/). | https://habr.com/ru/post/492298/ | null | ru | null |
# Производительность сети малой латентности InfiniBand на виртуальном кластере HPC HUB
Моделирование сложных физических процессов в наши дни рассматривается как важная технологическая возможность многими современными компаниями. Широко используемым сейчас подходом для создания вычислителей, способных рассчитывать сложные модели, является создание кластерных систем, где вычислительный узел представляет собой сервер общего назначения, подключенный к сети малой латентности и управляемый своей собственной ОС (как правило, из семейства GNU/Linux).
Введение виртуализационного слоя в системное ПО вычислительных кластеров, позволяет в течение нескольких минут создавать “виртуальный кластер”. Такие виртуальные кластера в рамках одной OpenStack инфраструктуры являются абсолютно независимыми. Пользовательские программы внутри них могут изменяться так, как нужно пользователю без каких-либо согласований с кем-либо, а логические устройства, на которых находятся пользовательские данные, недоступны другим виртуальным кластерам.
Поддержка сети малой латентности виртуализационными решениями представляет собой отдельную сложную проблему. Для прикладных программ в большинстве случаев современная виртуализация на основе KVM приводит к минимальным потерям вычислительной мощности (<1%). Однако специализированные тесты сетей малой латентности показывают накладные расходы от виртуализации не более 20% на операциях синхронизации.
Значение сетей малой латентности для HPC
-----------------------------------------
Современные задачи моделирования физических процессов требуют больших объемов памяти и вычислительных мощностей для того, чтобы расчеты могли быть выполнены на практике за реалистичное время. Такие большие объемы оперативной памяти и такие большие количества вычислительных ядер совместить в одной системе под управлением одной классической ОС с использованием современных технологий сложно и дорого.
Гораздо более дешевым и широко используемым сейчас альтернативным подходом является создание кластерных систем, где вычислительный узел представляет собой компьютер общего назначения, управляемый своей собственной ОС. При этом вычислительные узлы кластера синхронизируются и совместно управляются специальным ПО, обеспечивающим запуск, сопровождение и остановку так называемых «параллельных приложений». Последние представляют собой независимые процессы в ОС узлов, синхронизирующихся друг с другом за счет взаимодействия в сети. Далее мы будем называть такие сети «вычислительными сетями», вычислительные узлы — «кластерными узлами» или просто «узлами», управляющее ПО — «кластерным ПО».
Современные концепции программирования используют два основных метода распараллеливания: по данным и по процессам. Для моделирования естественных явлений чаще всего используется распараллеливание по данным, а именно:
* в начале шага вычислений части данных раздаются разным вычислителям и они производят некоторые действия над этими частями
* затем вычислители обмениваются информацией согласно различных численных схем (как правило довольно жестко запрограммированных) для того, чтобы иметь исходные данные для следующего шага
С точки зрения практики программирования вычислителем может являться все что угодно, что имеет хотя бы один процессор, некий объем памяти и доступ к вычислительной сети для обменов с другими вычислителями. По сути вычислитель — это абонент вычислительной сети с какими-то (пусть и относительно небольшими) вычислительными мощностями. Вычислителем может быть и тред в рамках процесса, и процесс в рамках ОС, и виртуальная машина с одним или несколькими виртуальными процессорами, и аппаратный узел с какой-то урезанной специализированной ОС, и т.д.
Самым массовым стандартом API для создания современных параллельных приложений является MPI, существующий в нескольких реализациях. Также широко распространен стандарт Intel OpenMP API, предназначенный для создания параллельных приложений в рамках одной ОС на многопроцессорном узле. Поскольку современные кластерные узлы содержат многоядерные процессоры с большим объемом памяти, то возможно большое количество вариантов определения «вычислителя» в рамках парадигмы распараллеливания по данным и реализации этой парадигмы на базе подхода параллельных приложений. Самыми распространенными являются два подхода:
1. одно процессорное ядро — один вычислитель
2. один многопроцессорный узел — один вычислитель
Для реализации первого подхода достаточно использовать MPI, для которого он собственно и создавался. В рамках второго подхода часто используется связка MPI + OpenMP, где MPI используется для коммуникации между узлами, а OpenMP для распараллеливания внутри узла.
Естественно, что в ситуации, когда параллельные приложения работают на нескольких узлах, суммарная производительность зависит не только от процессоров и памяти, но и от производительности сети. Также понятно, что обмены по сети будут медленнее, чем обмены внутри многопроцессорных систем. Т.е. кластерные системы по сравнению с эквивалентными многопроцессорными системами (SMP) практически всегда работают медленнее. Для того, чтобы минимизировать деградацию скоростей обменов по сравнению с SMP машинами используются специальные вычислительные сети малой латентности.
Ключевые характеристики вычислительных сетей
---------------------------------------------
Ключевыми характеристиками специализированных вычислительных сетей являются латентность и ширина канала (скорость обмена при больших объемах данных). Скорость передачи больших объемов данных важна для различных задач, например, когда узлам надо передавать друг другу результаты, полученные на текущем шаге расчета, чтобы собрать начальные данные для следующего шага. Латентность играет ключевую роль при передаче сообщений малого размера, например, синхронизационных сообщений, необходимых для того, чтобы узлы знали о состоянии других узлов, данные с которых им нужны. Синхронизационные сообщения как правило очень малы (типичный размер несколько десятков байт), но именно они используются для предотвращения логических гонок и тупиков (race condition, deadlock). Высокая скорость синхронизационных сообщений собственно отличает вычислительный кластер от его ближайшего родственника — вычислительной фермы, где сеть между узлами не обеспечивает свойства малой латентности.
Intel Infiniband является одним из самых массовых стандартов сетей малой латентности сегодня. Именно оборудование этого типа часто используется в качестве вычислительной сети для современных кластерных систем. Существует несколько поколений Infiniband сетей. Наиболее распространен сейчас стандарт Infiniband FDR (2011 год). По прежнему актуальным остается стандарт QDR (2008 год). Поставщиками оборудования сейчас активно продвигается следующий стандарт Infiniband EDR (2014 год). Порты Infiniband как правило состоят из агрегированных групп базовых двунаправленных шин. Наиболее распространены порты 4х.
**Характеристики сети Infiniband последних поколений**
| | | | |
| --- | --- | --- | --- |
| | QDRx4 | FDRx4 | EDRx4 |
| Полная пропускная способность, ГБит/c | 32 | 56 | 100 |
| Латентность порт-порт, мкс | 1.3 | 0.7 | 0.7 |
Как известно, виртуализация вносит некоторые свои специфические задержки при работе гостевых систем с устройствами. Не исключение в данном случае и сети малой латентности. Но из-за того, что малая латентность (задержка) является их самым важным свойством, то взаимодействие с виртуализациоными средами для таких сетей критически важно. При этом их пропускная способность, как правило, остается такой же, как и без виртуализации в широком диапазоне параметров соединений. Важным шагом в развитии Infiniband, сделанным относительно недавно (2011 год), является использование технологии SR-IOV. Эта технология позволяет физический сетевой адаптер Infiniband превратить в набор виртуальных устройств — виртуальных функций VF. Такие устройства, выглядят как независимые Infiniband адаптеры и, например, могут быть отданы в монопольное управление различным виртуальным машинам или каким-то высоконагруженным службам. Естественно, что адаптеры IB VF работают по другим алгоритмам, и их характеристики отличаются от оригинальных адаптеров IB без включенной поддержки SR-IOV.
Групповые операции обменов между узлами
----------------------------------------
Как уже упомянуто выше, самым популярным инструментальным HPC средством на текущий момент остается библиотека MPI. Существуют несколько основных вариантов реализации MPI API:
* [MPICH](https://www.mpich.org/)
* [MVAPICH](http://mvapich.cse.ohio-state.edu/)
* [OpenMPI](https://www.open-mpi.org/)
* [Intel MPI](https://software.intel.com/en-us/intel-mpi-library/documentation/)
Библиотеки MPI содержат основные функции, необходимые для реализации параллельных вычислений. Критически важными для HPC приложений являются функции передачи сообщений между процессами, в особенности групповые функции синхронизации и передачи сообщений. Стоит отметить, что чаще всего под группой понимаются все процессы параллельного приложения. В сети легко найти подробные описания MPI API:
* <https://computing.llnl.gov/tutorials/mpi/>
* <https://parallel.ru/docs/mpi2/mpi2-report.html>.
Основы алгоритмов, использованных для реализации MPI, хорошо описаны в [1], также много статей на эту тему можно найти по [ссылке](https://www.open-mpi.org/papers/). Оценки эффективности данных алгоритмов являются предметом большого количества работ [2, 3, 4, 5]. Чаще всего оценки строятся с помощью методов асимптотического анализа теории алгоритмов и оперируют понятиями  время установления соединения,  скорость передачи единицы информации,  количество передаваемых единиц информации,  количество задействованных процессоров.
Естественно, что для современных многопроцессорных систем, объединенных сетью малой латентности, параметры  и  надо брать различными для процессоров, взаимодействующих внутри одного узла и находящихся на разных узлах, на одном многоядерном кристалле и на разных. Тем не менее, хорошим начальным оценочным приближением для  и  в случае задач, использующих несколько узлов вычислительного кластера, являются значения латентности и пропускной способности вычислительной сети.
Как легко понять, именно групповые операции синхронизации являются наиболее требовательными к свойству «малой латентности» сети и масштабируемости этого свойства. Для наших тестов мы, как и другие авторы [6], использовали следующие 3 операции:
**broadcast**
Самая простая из групповых операций — broadcast (широковещательная рассылка). Один процесс посылает одно и то же сообщение всем остальным (M обозначает буфер с данными. Взято из [1]).
В вычислительных программах broadcast часто применяется для распространения каких-то условий, параметров в начале счета и между итерациями. Broadcast часто является элементом реализации других, более сложных коллективных операций. Например, broadcast используют в некоторых реализациях функции barrier. Существуют несколько вариантов алгоритмов для реализации broadcast. Оптимальное время работы broadcast на неблокирующем коммутаторе полнодуплексных каналов без аппаратного ускорения составляет:
**all-reduce**
Операция all-reduce проводит указанную в параметрах ассоциативную операцию над данными, лежащими в памяти группы вычислителей, а затем сообщает результат всем вычислителям группы. (Знак  означает указанную ассоциативную операцию. Взято из [1]).
С точки зрения структуры сетевых обменов all-reduce аналогична функции all-to-all broadcast. Эта операция применяется для суммирования или перемножения, поисков максимума или минимумов среди операндов, расположенных на разных вычислителях. Иногда эта функция используется в роли barrier. Оптимальное время работы all-reduce на неблокирующем коммутаторе полнодуплексных каналов без аппаратного ускорения составляет:
**all-to-all**
Операцию all-to-all еще иногда называют «personalized all-to-all» или «total exchange». Во время этой операции каждый вычислитель пересылает сообщение каждому другому вычислителю. Все сообщения могут быть уникальными (Взято из [1]).
Эта операция интенсивно используется различными алгоритмами, такими как преобразование Фурье, матричными преобразованиями, сортировки, параллельными операциями над базами данных. Это одна из самых «тяжелых» коллективных операций. Для данной коллективной операции оптимальный алгоритм зависит от соотношений значений ключевых переменных , ,  и размера передаваемых сообщений . При использовании алгоритма гиперкуба, который не оптимален по объему пересылок и применяется для сообщений малого размера, оценка времени составляет:
Используются и другие подходы к тестированию HPC сред. Например, с помощью интегральных тестов, имитирующих вычисления широко распространенных задач. Одним из самых популярных наборов интегральных тестов является [NAS parallel benchmarks](http://www.nas.nasa.gov/publications/npb.html). Этот тест также применялся и для тестирования виртуальных HPC сред [7].
Методика тестирования
----------------------
Для тестов производительности, изложенных в этой работе, использовались сервера с процессорами Intel Xeon 64 Гб RAM и IB адаптерами ConnectX-3. На виртуальных и физических узлах был установлен OpenMPI, соединение узел-узел тестировалось с помощью утилит perftest и OSU benchmarks.
**Более подробно**Сервера семейства Intel H2000JF (материнская плата S2600JF) с процессорами Intel Xeon E5-2680v2 2.8 GHz (10 ядер, HyperThreading выключен), 64 Гб оперативной памяти стандарта DDR3, IB адаптерами Mellanox Technologies MT27500 семейства ConnectX-3 (firmware ConnectX3-rel-2\_36\_5000), соединенных через свитч Mellanox SwitchX (36 портов SX6036 FDR).
OS CentOS Linux release 7.2.1511 (CentOS 7.2), ядро 3.10.0-327.18.2.el7.x86\_64, qemu/KVM кастомизированный на базе 2.3.0 (в дистрибутиве CentOS 7 используется версия 1.5.3 ), драйвера Mellanox OFED 3.3-1.0.4, qemu-kvm поддерживал NUMA режим.
Гостевая OS CentOS Linux release 7.1.1503 (CentOS 7.1), ядро 3.10.0-229.el7.x86\_64, драйвера Mellanox ConnectX-3. Каждая виртуальная машина была единственной на своем физическом сервере и занимала на нем все процессоры и 48 Гб оперативной памяти, overcommit по процессорным ядрам был выключен.
Адаптеры IB были переключены в режим поддержки SR-IOV, и было создано 2 VF на адаптер. Одна из VF экспортировалась в KVM. Соответственно, в гостевой OS был виден лишь один адаптер Infiniband, а в хостовой два: mlx4\_0 и mlx4\_1 (VF).
На виртуальных и физических узлах был установлен OpenMPI версии 1.10.3rc4 (входит в состав пакетов Mellanox OFED 3.3-1.0.4). Соединение узел-узел тестировалось с помощью утилит perftest 0.19.g437c173.33100.
Групповые тесты производились с помощью OSU benchmarks версии 5.3.1, собранных с помощью gcc 4.8.5 и указанного выше OpenMPI. Каждый результат OSU benchmarks является усреднением 100 или 1000 измерений, в зависимости от ряда условий.
На физических узлах демоном tuned установлен профиль latency-performance. На виртуальных узлах он был выключен.
Тесты запускались на двух узлах (40 ядер). Измерения проводились сериями по 10-20 измерений. В качестве результата бралось среднее арифметическое трех самых меньших значений.
Результаты
-----------
Приведенные в таблице параметры сетей являются идеальными, и в реальной ситуации они недостижимы. Например, латентность между двумя узлами с адаптерами Infiniband FDR (режим datagram), измеренная с помощью *ib\_send\_lat*, составляет для малых сообщений 0.83 мкс, а полезная пропускная способность (без учета служебной информации) между двумя узлами, измеренная с помощью *ib\_send\_bw*, составляет 6116.40 МБ/с (~51.3 Гбит/с). Пенальти по латентности и пропускной способности в реальных системах обусловлена следующими факторами:
1. дополнительной латентностью коммутатора
2. задержками, обусловленными ОС узлов
3. потери пропускной способности на обеспечение передачи служебной информации протоколов
Запуск осуществлялся на сервере командой:
```
ib_send_bw -F -a -d mlx4_0
```
на клиенте:
```
ib_send_bw -F -a -d mlx4_0
```
Так *ib\_send\_lat* между парой гостевых ОС, расположенных на разных физических серверах, показывает латентность 1.10 мкс (рост задержки на 0.27 мкс, отношение латентностей нативного и виртуализированного IB составляет 0.75), а *ib\_send\_bw* показывает пропускную способность в 6053.6 МБ/с (~50.8 Гбит/с, 0.99 от полезной ширины канала без виртуализации). Данные результаты находятся в хорошем соответствии с результатами тестов других авторов, например [6].
Стоит заметить, что в хостовой ОС тест работал не с SR-IOV VF, а с самим адаптером. Результаты представлены тремя графиками:
1. все размеры сообщений
2. только сообщения до 256 байтов включительно
3. отношение времен исполнения теста для нативного Infiniband и для VF
Тест **broadcast** запускался и в хостовой и в гостевой ОС как:
```
/usr/mpi/gcc/openmpi-1.10.3rc4/bin/mpirun --hostfile mh -N 20 -bind-to core -mca pml ob1 -mca btl_openib_if_include mlx4_0:1 /usr/local/libexec/osu-micro-benchmarks/mpi/collective/osu_bcast
```
Худшее отношение времен — 0.55, для большинства тестов отношение не хуже 0.8.
Тест **all-reduce** запускался и в хостовой и в гостевой OS как:
```
/usr/mpi/gcc/openmpi-1.10.3rc4/bin/mpirun --hostfile mh -N 20 -bind-to core -mca pml ob1 -mca btl_openib_if_include mlx4_0:1 /usr/local/libexec/osu-micro-benchmarks/mpi/collective/osu_allreduce
```
Худшее отношение времен — 0.7, для большинства тестов отношение не хуже 0.8.
Тест **all-to-all** запускался и в хостовой и в гостевой OS как:
```
/usr/mpi/gcc/openmpi-1.10.3rc4/bin/mpirun --hostfile mh -N 20 -bind-to core -mca pml ob1 -mca btl_openib_if_include mlx4_0:1 /usr/local/libexec/osu-micro-benchmarks/mpi/collective/osu_alltoall
```
Худшее отношение времен — 0.87, для большинства тестов отношение не хуже 0.88.
Обсуждение
-----------
Зубчатая форма представленных в тестах графиков с одной стороны обусловлена результатом не очень большой выборки тестов, но с другой стороны как раз является желанным эффектом метода отбора наименьших измеренных значений, используемого при профилировании программ. Обоснованием этого метода есть рассуждение, что фрагмент кода не может исполниться быстрее своей максимальной скорости, а все процессы, которые могут происходить в системе одновременно с исполнением тестового кода, либо не влияют на его скорость, либо замедляют его. Наличие кажущихся противоречивыми результатов, когда виртуализированный тест исполняется немного быстрее (2-5% ускорения), чем невиртуализированный следует отнести к особенностям драйверов и прошивки IB адаптеров, которые, во-первых, имеют свои оптимизационные схемы, а во-вторых, все же немного по-разному работают в обоих случаях (размеры буферов данных, особенности обработки прерываний и т.д.).
Особенности современных технологий виртуализации вносят дополнительные источники задержек по сравнению с ситуацией, где виртуализационного слоя нет. К существенными для HPC можно отнести три вида таких задержек:
* Замедление скорости работы сети малой латентности. В нашем конкретном случае — замедление Infiniband в режиме виртуальной функции SR-IOV. Это задержка является центральной темой данной работы и разобрана выше.
* Внешние по отношению к виртуализационной оболочке программы и службы будут эпизодически требовать процессорного времени, будут сбрасывать кэши счетных приложений. Это довольно сложным образом будет вносить разнообразную рассинхронизацию и задержки в счетные приложения, работающие под виртуализационной оболочкой. Такие систематические помехи могут быть крайне неприятны для всякого рода «экстремальных» программ, либо для неправильно оптимизированных. Разумеется стоит понимать, что без виртуализационной прослойки счетные программы будут работать быстрее. Однако в большинстве практически важных случаев пенальти по производительности из-за наличия управляющего кода вне виртуализационной оболочки на современных многоядерных узлах не превышает нескольких процентов, а чаще всего оно <1%. К тому же существует ряд подходов, позволяющих выделить и зафиксировать процессорные ядра, которые будут заниматься нагрузками вне виртуализационной оболочки, исключив их из виртуализированной среды. В результате воздействие на процессорные ядра и их кэши внутри виртуализационных оболочек можно минимизировать.
* При работе с виртуальным APIC возникают многочисленные выходы в гипервизор, что весьма накладно по задержке (десятки микросекунд). Эта проблема стала актуальной в последнее время в связи с ростом запросов на многоядерные виртуальные машины, и ей уделяется внимание на различных конференциях и в специализированных публикациях, например [8,9]. Такие задержки происходят при доставке прерываний, в том числе и от SR-IOV устройств (в нашем случае Infiniband) в госте, и при пробуждении ядра процессора из спящего состояния (IPI), например, при получении сообщения
Самым радикальными методами уменьшения виртуализационных пенальти для обработки прерываний, на взгляд авторов, является либо использование процессоров Intel с поддержкой vAPIC, либо использования контейнерной виртуализации (например LXC) для счетных узлов. На существенность задержки, возникающей при обработке прерываний в KVM, также косвенно указывается в [7], где авторы устанавливают связь между ростом количества прерываний и существенным уменьшением производительности виртуализированной версии теста.
Оценить данные задержки, кроме самой первой, с помощью простых формул, подобных приведенным в [1], сложно по нескольким причинам:
* Первая и основная из них та, что данные задержки проявляются асинхронно с алгоритмом счетной задачи, которая работает в виртуализированной среде
* Вторая причина заключается в том, что данные задержки зависят от «истории» вычислительного узла в целом, включая и алгоритм счетной задачи и ПО виртуализации — состояния кэшей, памяти, контроллеров
Также важно понимать, что при пересылках большого количества пакетов по сети малой латентности, в частности, при фрагментации больших сообщений, скорость генерации прерываний будет расти по сложному закону, что может привести к появлению нетривиальных зависимостей скорости передачи сообщений от их длины и опять же, истории стэка ПО виртуализации.
Создателями традиционных кластерных вычислительных систем прикладываются огромные усилия, чтобы устранить помехи для вычислительных задач:
* выключение всех ненужных служб ОС
* минимизация всех сетевых обменов
* минимизация любых других источников прерываний для узлов
В случае сочетания виртуализации и облачного ПО мы находимся только в начале этого пути оптимизации под высокопроизводительные вычисления.
Выводы
-------
Сравнительные тесты набора из трех часто используемых операций MPI (broadcast, all-reduce, personalized all-to-all) показали, что виртуализационная среда на базе qemu/KVM и с использованием технологии SR-IOV демонстрирует увеличенное время тестов в среднем на 20% (в самом худшем случае на 80% при broadcast пакетов размерами 16 и 32Кб). Данное падение производительности хотя и заметно, однако не критично для большинства параллельных приложений, связанных с механикой сплошных сред, молекулярной динамикой, обработкой сигналов и т.д. Удобство использования виртуализованной среды, возможность быстрого расширения вычислительного поля и его настройки кратно компенсирует затраты на возможное увеличение счетного времени.
Для задач, требующих быстрого случайного доступа одного узла в память другого, такая задержка может быть критичной. Скорее всего она не позволит эффективно использовать виртуализированные кластера для решения подобных задач.
На практике деградация производительности вычислительных программ зачастую оказывается гораздо меньше указанных величин (max 20%). Это происходит потому, что большинство времени хорошо написанные и широко используемые программы все же считают и обрабатывают данные внутри вычислителя, а не совершают операции синхронизации или пересылки данных. Ведь авторы параллельного кода всегда стремятся выбрать такие алгоритмы и приемы реализации, которые минимизируют потребность в синхронизации и пересылках между вычислителями.
Литература
-----------
**Более подробно**1. A. Grama, A. Gupta, G. Karypis, V. Kumar. Introduction to Parallel Computing, Second Edition. Addison-Wesley, 2003
2. R. Thakur, W. Gropp. Improving the Performance of Mpi Collective Communication on Switched Networks, 2003
3. R. Thakur, R. Rabenseifner, W. Gropp. Optimization of Collective Communication Operations in MPICH. Int'l Journal of High Performance Computing Applications,-- 2005 — Vol 19(1) — pp. 49-66.
4. J. Pješivac-Grbović, T. Angskun, G. Bosilca, G. E. Fagg, E. Gabriel, J. J. Dongarra. Performance analysis of MPI collective operations. Cluster Computing — 2007 — Vol. 10 — p.127.
5. B. S. Parsons. Accelerating MPI collective communications through hierarchical algorithms with flexible inter-node communication and imbalance awareness. Ph. D. Thesis on Computer science, Purdue University, USA, 2015
6. J. Jose, M. Li, X. Lu, K. C. Kandalla, M. D. Arnold, D. K. Panda. SR-IOV Support for Virtualization on InfiniBand Clusters: Early Experience. International Symposium on Cluster, May 2011
7. A. Kudryavtsev, V. Koshelev, A. Avetisyan. Modern HPC cluster virtualization using KVM and Palacios. High Performance Computing (HiPC) Conference, 2012
8. D. Matlack. KVM Message Passing Performance. KVM forum, 2015
9. R. van Riel. KVM vs. Message Passing Throughput, Reducing Context Switching Overhead. Red Hat KVM Forum 2013
Материал подготовлен Андреем Николаевым, Денисом Луневым, Анной Субботиной, Вильгельмом Битнером. | https://habr.com/ru/post/319940/ | null | ru | null |
# Настройка Azure Application Insights для диагностики ПО с микросервисной архитектурой
**Application Insights** — клёвая штука, позволяющяя проводить диагностику, профилирование и анализ использования развернутых систем (в т.ч. в продакшен режиме), и при этом не требующая от разработчика вообще никаких усилий. Конечно, всё это становится возможным ценой мучительной первоначальной настройки.
В рекламных видео конечно никакой особой настройки нет, но жизнь — она сложнее, особенно если ваше ПО микросервисное. Почему? А всё очень просто.
Что в первую очередь должна делать система диагностики в микросервисной архитектуре?
Правильно, коррелировать диагностику от различных микросервисов в рамках одной операции.
Тыркнул пользователь в UI кнопочку — надо увидеть диагностику от всех N микросервисов, которые так или иначе обрабатывали этот тырк. Случился где-нибудь exception — надо увидеть не только в каком микросервисе он произошёл, но и в рамках какой операции это случилось.
Только вот Application Insights с точки зрения конкретного микросервиса — это в первую очередь SDK. И SDK таких есть несколько — есть для JS, есть для .NET Core, .NET (со своими особенностями настройки для MVC, WebAPI, WCF), есть для Java и [т.д.](https://docs.microsoft.com/en-us/azure/application-insights/)
Какие-то из этих SDK — opensource, какие-то — внутренняя разработка MS. И чтобы всё завелось — их надо подружить.
В этом и состоит основная сложность.
Не скажу, что я достиг 100% просветления в этом вопросе.
Но по крайней мере, я уже собрал несколько граблей и у меня есть рабочий семпл с UI на ASP.NET MVC (не Core) + JS и двумя микросервисами (Asp.Net WebApi, WCF)
Кому интересно — прошу под кат.
Немного про Application Insights
--------------------------------
Если в двух словах — то работает он так:
1. С помощью SDK ручками или автоматично генерируются объекты из [дата модели](https://docs.microsoft.com/en-us/azure/application-insights/application-insights-data-model) Application Insights по событиям в ПО
2. Сгенерированные объекты засылаются в Azure через REST API
3. В Azure есть инструменты (очень богатые) для анализа сгенерированной инфы
Как дата модель Application Insights маппится на микросервисную архитектуру?
----------------------------------------------------------------------------
Как видно из картинки, каждый пинок в микросервис\UI\API порождает Request на той стороне, куда пнули и Dependency на той стороне, где пинали.
В процессе работы могут рождаться также трассировочные события, сообщения об ошибках, кастомные евенты, а также такие специализированные объекты как pageView
Как Application Insights коррелирует между собой объекты
--------------------------------------------------------
На картинке синими стрелочками отмечены связи между объктами. Как видно,
1. Все объекты связаны с определенной операцией (это не отдельная сущность датамодели AI, они просто имеют одинаковое свойство. Операция инициализируется при первом request не в рамках операции)
2. Трассировочные сообщения/сообщения об ошибках/кастомные события/депенды микросервиса связаны дополнительно к объекту request (также через свойство)
3. Объекты Request связаны дополнительно с объектом Dependency (если только это не самый первый Request) также через свойство.
Подробности можно почитать в [официальной документации](https://docs.microsoft.com/en-us/azure/application-insights/) по Application Insights
Что дальше?
-----------
А дальше будет описание двух сценариев взаимодействия между микросервисами с подробным описанием способа реализации.
Сценарий 1 — AJAX, MVC, WebApi
------------------------------
Или то же самое, но словами:
1. Для отображения странички требуется в MVC контроллере получить данные от WebAPI микросервиса (через HttpClient)
2. После отображения странички она сама с помощью jQuery лезет на сервер в MVC контроллер и получает ещё данные, которые в свою очередь также берутся от WebAPI микросервиса.
### Что мы хотим получить
Хотим иметь возможность
1. Увидеть факт просмотра страницы
2. Увидеть, что для генерации страницы сервер ходил в микросервис
3. Увидеть, что сама страница выполняла ajax запрос на сервер
4. Увидеть, что сервер для удовлетворения этого запроса также ходил в микросервис
5. В случае возникновения где-нибудь ошибки — хотим сразу увидеть контекст в рамках которого она произошла
В идеале, мы должны всю информацию увидеть на одном экране как последовательность действий
Конечно, все эти цели в конечном счёте мы достигнем.
Чтобы не томить —
### Сначала результат:
Переход от страницы к диагностической информации по операции
Сама диагностическая информация
А теперь с ошибкой в микросервисе:
### Детали реализации
#### В Web API микросервисе:
* Устанавливаем NuGets *Microsoft.ApplicationInsights*, *Microsoft.ApplicationInsights.Web*, *Microsoft.AspNet.WebApi.Tracing*
* С пакетами выше приезжает TraceListener для ApplicationInsights, прописывается в web.config сам.
* В WebApiConfig указываем *config.EnableSystemDiagnosticsTracing()*
* Реализуем *IExceptionFilter*, регистрирующий все непойманные ошибки в ApplicationInsights, прописываем его в FilterConfig.cs
**Код**
```
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
public class WebApiAITrackingAttribute : FilterAttribute, IExceptionFilter
{
public void OnException(ExceptionContext filterContext)
{
if (filterContext != null
&& filterContext.HttpContext != null && filterContext.Exception != null)
{
ApplicationInsightsSettings.TelemetryClient.TrackException(filterContext.Exception);
}
}
}
```
TelemetryClient — объект из SDK ApplicationInsights. Его не рекомендуется создавать каждый раз, поэтому он тут singleton через ApplicationInsightsSettings
#### В ASP.Net MVC UI:
* Устанавливаем NuGet'ы *Microsoft.ApplicationInsights*, *Microsoft.ApplicationInsights.Web*
* Реализуем *IExceptionFilter*, регистрирующий все непойманные ошибки в ApplicationInsights, прописываем его в FilterConfig.cs (такой же как и для Web API микросервиса)
* Реализуем *HttpClientHandler* для работы с HttpClient, создающий Dependency.
Тут чуть поподробнее: вообще, [документация декларирует](https://docs.microsoft.com/en-us/azure/application-insights/application-insights-correlation#telemetry-correlation-in-net), что System.Net.HttpClient начиная хз с какой версии умеет сам создавать Dependency.
И это даже действительно так. Но только делает он это не напрямую (он напрямую с AI SDK не работает), а слегка через одно место, поэтому этот Dependency не всегда привязывается правильно к Request. Поэтому когда мне надоело ловить глюки с этим — я написал свой HttpClientHandler
**Код**
```
public class DependencyTrackingHandler : HttpClientHandler
{
public DependencyTrackingHandler()
{
}
private static int _dependencyCounter = 0;
protected override async Task SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
using (var op = ApplicationInsightsSettings.TelemetryClient.StartOperation(request.Method.Method + " " + request.RequestUri.AbsolutePath))
{
op.Telemetry.Target = request.RequestUri.Authority;
op.Telemetry.Type = request.Method.Method;
op.Telemetry.Data = request.Method.Method + " " + request.RequestUri.ToString();
op.Telemetry.Id += "." + Interlocked.Increment(ref \_dependencyCounter).ToString();
request.Headers.Add("Request-Id", op.Telemetry.Id);
var result = base.SendAsync(request, cancellationToken).Result;
op.Telemetry.ResultCode = result.StatusCode.ToString();
op.Telemetry.Success = result.IsSuccessStatusCode;
return result;
}
}
}
```
Как видно, смысл этого хендлера — обернуть вызов HttpClient'а в DependencyTelemetry, а также (и это очень важно), установить правильный *Request\_Id* хедер.
Про хедеры также чуть поподробнее. Через них инфраструктура AI передает информацию о id операции, а также информацию о id dependency при вызовах через HttpClient.
Хедеры для этих целей используются такие: "Request-Id", "x-ms-request-id", "x-ms-request-root-id". Для того чтобы корреляция правильно инициализировалась достаточно первого или (второго И третьего).
Подробнее про корреляции и хедеры можно почитать в [документации](https://docs.microsoft.com/en-us/azure/application-insights/application-insights-correlation) (хотя она довольно сумбурна)
* Вспоминаем, что тут мы имеем дело с двумя SDK — для JS и для .NET, поэтому где-нибудь в вьюхах MVC ищем код, инициализирующий appInsight на стороне браузера, а затем
* Прописываем туда *InstrumentationKey*
**Код**
```
var appInsights=window.appInsights||function(config)
{
function r(config){ t[config] = function(){ var i = arguments; t.queue.push(function(){ t[config].apply(t, i)})} }
var t = { config:config},u=document,e=window,o='script',s=u.createElement(o),i,f;for(s.src=config.url||'//az416426.vo.msecnd.net/scripts/a/ai.0.js',u.getElementsByTagName(o)[0].parentNode.appendChild(s),t.cookie=u.cookie,t.queue=[],i=['Event','Exception','Metric','PageView','Trace','Ajax'];i.length;)r('track'+i.pop());return r('setAuthenticatedUserContext'),r('clearAuthenticatedUserContext'),config.disableExceptionTracking||(i='onerror',r('_'+i),f=e[i],e[i]=function(config, r, u, e, o) { var s = f && f(config, r, u, e, o); return s !== !0 && t['_' + i](config, r, u, e, o),s}),t
}({
instrumentationKey: "@Microsoft.ApplicationInsights.Extensibility.TelemetryConfiguration.Active.InstrumentationKey"
});
```
* Синхронизируем глобальную операцию между сервером и браузером (чтобы у нас в одной глобальной операции отображалась и серверная диагностика и диагностика с браузера)
**Код**
```
window.appInsights.queue.push(function () {
var serverId ="@Context.GetRequestTelemetry().Context.Operation.Id";
appInsights.context.operation.id = serverId;
});
```
```
Большое спасибо за этот WA **Sergey Kanzhelev** и его блогу [http://apmtips.com](http://apmtips.com)
```
Сценарий 2 — AJAX, WCF, WebApi
------------------------------
Или то же самое, но словами:
* Для отображения странички не требуется данных от микросервиса
* После отображения странички она сама с помощью jQuery лезет в WCF микросервис и получает ещё данные, которые в свою очеред также берутся от WebAPI микросервиса.
Цели те же, как и в предыдущем сценарии
### Сначала результат:
С ошибкой в микросервисе:
### Детали реализации
В Web API микросервисе — ничего нового относительно предыдущего сценария
#### В ASP.Net MVC UI:
* Где-нибудь в вьюхах MVC ищем код, инициализирующий appInsight на стороне браузера, а затем перепределяем функцию *appInsights.\_ajaxMonitor.sendHandler*
**Код**
```
window.appInsights.queue.push(function () {
appInsights._ajaxMonitor.sendHandler = function (e, n) {
e.ajaxData.requestSentTime = Date.now();
if (!this.appInsights.config.disableCorrelationHeaders) {
var i = this.appInsights.context.operation.id;
e.setRequestHeader("x-ms-request-root-id", i);
e.setRequestHeader("x-ms-request-id", e.ajaxData.id);
}
e.ajaxData.xhrMonitoringState.sendDone = !0;
};
});
```
С этим чуть поподробнее. Как известно, запросы через XmlHttpRequest на хосты, отличные от текущего, подвержены дополнительной секьюрити, т.н. [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS)
Выражается это в том, что в http API могут прилетать т.н. preflight запросы перед основным для апрува хедеров, метода и хоста основного запроса.
Так вот, почему-то Application Insights SDK для JS видимо очень боится отправить эти preflight запросы и поэтому [никогда не пересылает](https://github.com/Microsoft/ApplicationInsights-JS/blob/c5cbccf42e709f497c7c9a8b74663dd38d8ed55d/JavaScript/JavaScriptSDK/ajax/ajax.ts#L156) корреляционные хедеры на хосты, отличные от текущего (с учётом порта).
На команду Application Insights SDK для JS уже заведён [FR](https://github.com/Microsoft/ApplicationInsights-JS/issues/479) по этому поводу.
В коде выше в качестве WA просто убирается проверка на соответствие хостов и таким образом, хедеры отсылаются в любом случае.
#### В WcfApi:
* Устанавливаем NuGet'ы *Microsoft.ApplicationInsights*, *Microsoft.ApplicationInsights.Web*, *Microsoft.ApplicationInsights.Wcf* (из <https://www.myget.org/F/applicationinsights-sdk-labs/>)
* Удаляем из ApplicationInsights.config
* Помечаем атрибутом [*ServiceTelemetry*] класс сервиса
* Не забываем установить Method = "\*" в атрибуте WebInvoke для методов интерфейса сервиса (т.к. в него будут прилетать preflight запросы с методом OPTIONS)
* Реализуем ответ на preflight запрос в методах сервиса
**Код**
```
private bool CheckCorsPreFlight()
{
var cors = false;
if (WebOperationContext.Current != null)
{
var request = WebOperationContext.Current.IncomingRequest;
var response = WebOperationContext.Current.OutgoingResponse;
if (request.Method == "OPTIONS")
{
response.Headers.Add("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
response.Headers.Add("Access-Control-Allow-Headers", "Content-Type, X-Requested-With, x-ms-request-root-id, x-ms-request-id");
response.Headers.Add("Access-Control-Allow-Credentials", "true");
cors = true;
}
var origin = request.Headers.GetValues("Origin");
if (origin.Length > 0)
response.Headers.Add("Access-Control-Allow-Origin", origin[0]);
else
response.Headers.Add("Access-Control-Allow-Origin", "*");
}
return cors;
}
```
В качестве бонуса — запросы для Application Insights Analytics
--------------------------------------------------------------
### Получение id глобальной операции по факту просмотра страницы
```
pageViews
| order by timestamp desc
| project timestamp, operation_Id, name
```
### Получение id глобальной операции по факту возникновения ошибки
```
exceptions
| order by timestamp desc
| project timestamp, operation_Id, problemId, assembly
```
Также для этих целей удобно использовать новый интерфейс Failures
### Получение диагностических данных по глобальной операции
```
requests
| union dependencies
| union pageViews
| union exceptions
| where operation_Id == ""
| order by timestamp desc
| project timestamp, itemType, data = iif(itemType == "exception", problemId, name)
```
**Всем спасибо**
[Тестовый проект на github](https://github.com/AndreyPoturaev/appinsightdd)
Что почитать:
[Мега блог amptips.com](http://apmtips.com/)
[Официальная документация](https://docs.microsoft.com/en-us/azure/application-insights/)
Буду благодарен за любую конструктивную критику! | https://habr.com/ru/post/346148/ | null | ru | null |
# Передача видео с глубоководного робота
Хочу поделиться с сообществом опытом разработки программного обеспечения для просмотра и записи видео-сигнала передаваемого с глубоководного робота Moby Dick. Разработка проводилась по заказу лаборатории подводной робототехники [The Whale](http://www.rov-underwater.ru/). Проект был призван обеспечить:
— работу с любыми IP-камерами поддерживающими протокол RTSP;
— просмотр и запись видео от нескольких IP-камер;
— просмотр и запись стерео-видео от двух выделенных IP-камер;
— запись видео с экрана;
— комфортный просмотр видео при кратковременном падении скорости передачи данных.
Глубоководный робот Moby Dick проекта 1-0-1 десантированый с борта трансрейдера [ВКС России](https://ru.wikipedia.org/wiki/%D0%92%D0%BE%D0%B7%D0%B4%D1%83%D1%88%D0%BD%D0%BE-%D0%BA%D0%BE%D1%81%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5_%D1%81%D0%B8%D0%BB%D1%8B_%D0%A0%D0%BE%D1%81%D1%81%D0%B8%D0%B9%D1%81%D0%BA%D0%BE%D0%B9_%D0%A4%D0%B5%D0%B4%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8) [«Лунная радуга»](https://ru.wikipedia.org/wiki/%D0%9B%D1%83%D0%BD%D0%BD%D0%B0%D1%8F_%D1%80%D0%B0%D0%B4%D1%83%D0%B3%D0%B0_(%D1%80%D0%BE%D0%BC%D0%B0%D0%BD)) исследует океан [Европы](https://ru.wikipedia.org/wiki/%D0%95%D0%B2%D1%80%D0%BE%D0%BF%D0%B0_(%D1%81%D0%BF%D1%83%D1%82%D0%BD%D0%B8%D0%BA)) (в представлении художника, коллаж)
Если вас не пугают мегатонны кода добро пожаловать под кат.
#### Moby Dick
Moby Dick — [телеуправляемый подводный аппарат](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BB%D0%B5%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D1%8F%D0%B5%D0%BC%D1%8B%D0%B9_%D0%BD%D0%B5%D0%BE%D0%B1%D0%B8%D1%82%D0%B0%D0%B5%D0%BC%D1%8B%D0%B9_%D0%BF%D0%BE%D0%B4%D0%B2%D0%BE%D0%B4%D0%BD%D1%8B%D0%B9_%D0%B0%D0%BF%D0%BF%D0%B0%D1%80%D0%B0%D1%82) (англ. Underwater Remotely Operated Vehicle (Underwater ROV или UROV)) разработанный в лаборатории подводной робототехники [The Whale](http://www.rov-underwater.ru/). Основной целью при проектировании и создании Moby Dick было создание небольшого робота, способного погружаться на максимальные (в перспективе) глубины мирового океана (в составе подъемно-спускового механизма), выдавать видео высокого разрешения (Full HD), брать пробы, образцы, проводить спасательные работы.
Глубоководный робот Moby Dick спереди (видны две передние камеры в верхней части под баллонами)
Глубоководный робот Moby Dick сзади (видна задняя камера в нижней части под креплением кабеля)
Как правило на Moby Dick устанавливают три цифровые видеокамеры, причем две из них устанавливаются на вращающимся подвесе с вращением на 360° по всем трем осям. Вращение на 360° по всем трем осям позволяет осматривать двигатели аппарата и общую обстановку вокруг и внутри рамы, а также быстро осматривать длинномерные объекты (трубопроводы, суда и т.д.) при положении видеокамеры перпендикулярно движению робота. Эта особенность так же позволяет получать стереоскопическое изображение морского дна, появляется возможность оценивать расстояние до объектов и их размер непосредственно с экрана монитора.
Всего на Moby Dick можно установить до 9 цифровых камер получив обзор всей сферы. Правда в максимальной комплектации приходится довольствоваться Full HD только для одной камеры — остальные придется подключать как 720p из-за ограничения скорости передачи данных по кабелю.
Следует отметить, что это единственный подводный робот с возможностью передачи стерео-видео в нашей стране. Аналогичные по своим возможностям роботы имеются за рубежом, но по сравнению с Moby Dick они сильно большие по размерам.
#### Получение и запись видео
Для получения и записи видео была выбрана библиотека [FFMPEG](https://ffmpeg.zeranoe.com/). Для изоляции разработчика от специфического API FFMPEG используется DLL-посредник (собран в старой доброй Microsoft Visual C++ 2008 Express Edition). Рассмотрим наиболее интересные части его кода.
Для получения отметок времени высокой точности используется код
```
static bool timer_supported;
static LARGE_INTEGER timer_f;
static bool timer_init(void)
{
return timer_supported = QueryPerformanceFrequency(&timer_f);
}
static LARGE_INTEGER timer_t;
static bool timer_get(void)
{
return QueryPerformanceCounter(&timer_t);
}
static LONGLONG get_microseconds_hi(void)
{
return timer_get()? timer_t.QuadPart * 1000000 / timer_f.QuadPart : 0;
}
static LONGLONG get_microseconds_lo(void)
{
return GetTickCount() * 1000i64;
}
static LONGLONG (*get_microseconds)(void) = get_microseconds_lo;
```
Задержки высокой точности выставляются стандартной функцией Sleep. При включении / выключении отметок времени и задержек высокой точности выполняются необходимые подготовительные процедуры
```
static TIMECAPS tc;
...
//при инициализации DLL
memset(&tc, 0, sizeof(tc));
...
//если нужно использовать отметки времени и задержки высокой точности
if (flag)
{
get_microseconds = timer_init()? get_microseconds_hi : get_microseconds_lo;
//если установка точности не производилась и структура tc получена, то...
if (!tc.wPeriodMin && timeGetDevCaps(&tc, sizeof(tc)) == MMSYSERR_NOERROR)
{
timeBeginPeriod(tc.wPeriodMin); //устанавливаем самую высокую точность
//теперь Sleep будет работать с высокой точностью
}
}
//если точность не нужна
else
{
if (tc.wPeriodMin) //если установка точности производилась
{
timeEndPeriod(tc.wPeriodMin); //возвращаем все как было
memset(&tc, 0, sizeof(tc));
}
}
```
Каждая камера представлена классом ctx\_t.
```
class ctx_t:
public mt_obj //класс поддерживающий блокировку
{
public:
AVFormatContext *format_ctx; //контекст формата
int stream; //номер видео-потока
AVCodecContext *codec_ctx; //контекст декодера видео-потока
AVFrame *frame[2]; //буфер из двух кадров
int frame_idx; //номер формируемого кадра (готовый кадр имеет номер !frame_idx если frames_count > 0)
//BGR-представление кадра и контекст масштабирования...
//используются приложением вызывающим DLL-посредник для чтения сформированного кадра
AVFrame *x_bgr_frame;
SwsContext *x_bgr_ctx;
AVFormatContext *ofcx; //контекст формата для записи
AVStream *ost; //видео-поток для записи
int rec_started; //признак старта записи (старт только с ключевого кадра)
mt_obj rec_cs; //блокировка для записи
int64_t pts[2]; //отметка времени кадра
int continue_on_error; //продолжать работу при возникновении ошибок
int disable_decode; //отключить декодер
void (*cb_fn)(int cb_param); //обработчик вызываемый после формирования кадра
int cb_param; //параметр передаваемый обработчику
ms_rec_ctx_t *owner; //объект отвечающий за стерео-запись
int out_stream; //номер видео-потока (задается)
int frames_count; //количество сформированных кадров
DWORD base_ms; //время вызова функции FFMPEG
DWORD timeout_ms; //предельное время выполнения функции FFMPEG
HANDLE thread_h; //поток
int terminated; //признак уничтожения потока
};
```
Для контроля времени выполнения функций FFMPEG используется функция обратного вызова
```
static int interrupt_cb(void *_ctx)
{
ctx_t *ctx = (ctx_t *)_ctx;
//если время выполнения функции FFMPEG больше предельного, то прерываем ее работу
if (GetTickCount() - ctx->base_ms > ctx->timeout_ms) return 1;
return 0;
}
```
Благодаря этой функции мы можем контролировать время выполнения функций FFMPEG таких как avformat\_open\_input / avformat\_find\_stream\_info / av\_read\_frame / avformat\_close\_input
```
format_ctx = avformat_alloc_context();
if (!format_ctx)
{...}
format_ctx->interrupt_callback.callback = interrupt_cb;
format_ctx->interrupt_callback.opaque = this;
AVDictionary *opts = 0;
if (tcp_flag) av_dict_set(&opts, "rtsp_transport", "tcp", 0); //только TCP-транспорт
base_ms = GetTickCount(); //устанавливаем время вызова функции FFMPEG
if (avformat_open_input(&format_ctx, src, 0, &opts) != 0) //вызов функции FFMPEG (с контролем времени)
{...}
```
С функцией обратного вызова avformat\_open\_input будет выполнятся не дольше чем заданное время timeout\_ms. Без функции обратного вызова выполнение программы было бы приостановлено до установления связи с IP-камерой. Обратите внимание на то, что в качестве транспорта выбран TCP. При использовании UDP большая часть приходящих кадров оказывалась повреждена (линия связи имеет значительную длину и передача идет с помехами от работающих агрегатов робота).
Каждую камеру обслуживает отдельный поток следующего вида
```
AVPacket packet;
int finished;
while (!ctx->terminated)
{
ctx->base_ms = GetTickCount();
if (av_read_frame(ctx->format_ctx, &packet) != 0)
{
//продолжать работу при возникновении ошибок если задан соответствующий флаг
if (ctx->continue_on_error)
{}
else
{
ctx->terminated = 1;
ExitThread(0);
}
}
else if (packet.stream_index == ctx->stream)
{
int64_t original_pts = packet.pts;
if (ctx->disable_decode) //если декодер отключен записываем пакет (если запись включена)
{
ctx->rec_cs.lock(); //блокировка для записи
if (ctx->owner) lock(ctx->owner); //блокировка объекта отвечающего за стерео-запись
if (ctx->ofcx)
{
//старт записи только с ключевого кадра
if (!ctx->rec_started && (packet.flags & AV_PKT_FLAG_KEY))
{
ctx->rec_started = 1;
}
if (ctx->rec_started)
{
//отметка времени показа
int64_t pts = packet.pts;
//разность отметок времени декодирования и показа
int64_t delta = packet.dts - packet.pts;
if (ctx->owner) //если есть объект отвечающий за стерео-запись, то...
{
LONGLONG start;
//получаем время начала стерео-записи
get_start(ctx->owner, &start);
//получаем текущую отметку времени
LONGLONG dt = (get_microseconds() - start) / 1000;
//формируем отметку времени показа в частотах оригинала
pts = dt * ctx->format_ctx->streams[ctx->stream]->time_base.den / 1000;
}
packet.stream_index = ctx->out_stream; //устанавливаем номер потока
//устанавливаем отметку времени показа в частотах формируемой записи
packet.pts = av_rescale_q(pts, ctx->format_ctx->streams[ctx->stream]->time_base, ctx->ost->time_base);
//устанавливаем отметку времени декодирования в частотах формируемой...
//записи используя смещение по отношению к времени показа
packet.dts = av_rescale_q(packet.dts == AV_NOPTS_VALUE? AV_NOPTS_VALUE : (pts + delta), ctx->format_ctx->streams[ctx->stream]->time_base, ctx->ost->time_base);
//на всякий случай устанавливаем продолжительность
packet.duration = av_rescale_q(packet.duration, ctx->format_ctx->streams[ctx->stream]->time_base, ctx->ost->time_base);
//на всякий случай еще немного магии
packet.pos = -1;
//ставим пакет на запись - очередность записи пакетов определяется...
//FFMPEG по типу пакета
av_interleaved_write_frame( ctx->ofcx, &packet );
//на всякий случай восстанавливаем номер потока
packet.stream_index = ctx->stream;
}
}
if (ctx->owner) unlock(ctx->owner);
ctx->rec_cs.unlock();
}
//если декодер включен, то в начале декодируем пакет и только потом...
else if (avcodec_decode_video2(ctx->codec_ctx, ctx->frame[ctx->frame_idx], &finished, &packet) > 0)
{
//записываем его (если запись включена) так же как мы делали выше
ctx->rec_cs.lock();
if (ctx->owner) lock(ctx->owner);
if (ctx->ofcx)
{
if (!ctx->rec_started && (packet.flags & AV_PKT_FLAG_KEY))
{
ctx->rec_started = 1;
}
if (ctx->rec_started)
{
int64_t pts = packet.pts;
int64_t delta = packet.dts - packet.pts;
if (ctx->owner)
{
LONGLONG start;
get_start(ctx->owner, &start);
LONGLONG dt = (get_microseconds() - start) / 1000;
pts = dt * ctx->format_ctx->streams[ctx->stream]->time_base.den / 1000;
}
packet.stream_index = ctx->out_stream;
packet.pts = av_rescale_q(pts, ctx->format_ctx->streams[ctx->stream]->time_base, ctx->ost->time_base);
packet.dts = av_rescale_q(packet.dts == AV_NOPTS_VALUE? AV_NOPTS_VALUE : (pts + delta), ctx->format_ctx->streams[ctx->stream]->time_base, ctx->ost->time_base);
packet.duration = av_rescale_q(packet.duration, ctx->format_ctx->streams[ctx->stream]->time_base, ctx->ost->time_base);
packet.pos = -1;
av_interleaved_write_frame( ctx->ofcx, &packet );
packet.stream_index = ctx->stream;
}
}
if (ctx->owner) unlock(ctx->owner);
ctx->rec_cs.unlock();
if (finished) //если кадр готов
{
ctx->lock(); //блокируем камеру
ctx->pts[ctx->frame_idx] = original_pts; //устанавливаем отметку времени кадра
ctx->frame_idx = !ctx->frame_idx; //меняем номер формируемого кадра
//если задан обработчик вызываемый после формирования кадра, то вызываем его
if (ctx->cb_fn) ctx->cb_fn(ctx->cb_param);
ctx->unlock();
if (ctx->frames_count + 1 < 0) ctx->frames_count = 1;
else ctx->frames_count++;
}
}
}
av_free_packet(&packet);
}
```
Обратите внимание на возможность:
-продолжать работу при возникновении ошибок если задан соответствующий флаг (если ошибка не была связана с прекращением передачи данных со стороны IP-камеры, поток пропустит поврежденные пакеты и продолжит работу);
-работать без декодирования (на время сворачивания окна можно отключать декодирование разгружая процессор).
Относительно нагрузки на процессор. Основная нагрузка на процессор идет при декодировании потока. Нагрузка от одного потока 1280 x 720, 24 fps, 2727 kbps для аппаратной конфигурации Intel Core2 Duo E8300 2.83 ГГц составляет порядка 17%. Для сравнения родной ffplay нагружает процессор на такую же величину. Запись видео с камеры практически не нагружает процессор так как идет без перекодирования.
Стерео-видео от двух выделенных IP-камер записывается в один файл (каждой камере соответствует свой номер потока).
Для того что бы в случае нештатного прерывания процесса кодирования запись не была повреждена (не выдавалось сообщение moov atom not found) при инициализации контекста формата для записи выбираем формат который нечувствителен к нештатному прерыванию процесса кодирования
```
AVOutputFormat *ofmt = av_guess_format( "VOB", NULL, NULL ); //выбираем VOB
ofcx = avformat_alloc_context();
if (!ofcx)
{...}
ofcx->oformat = ofmt;
```
Сформированный кадр может быть прочитан при помощи следующей функции
```
//неблокирующий вызов
int ffmpeg_get_bmp_NB_(int _ctx, void *bmp_bits, int w, int h, int br, int co, int sa, void *pts)
{
ctx_t *ctx = (ctx_t *)_ctx;
if (!ctx || !ctx->frames_count) return 0; //если нет камеры или нет кадров - выходим
//если нет BGR-представления кадра или запрошенные размеры не совпадают с текущими, то...
if (!ctx->x_bgr_frame || ctx->x_bgr_frame->width != w || ctx->x_bgr_frame->height != h)
{
//освобождаем контекст масштабирования и BGR-представление кадра
sws_freeContext(x_bgr_ctx);
av_free(x_bgr_frame);
x_bgr_frame = 0;
x_bgr_ctx = 0;
//создаем BGR-представление кадра
ctx->x_bgr_frame = av_frame_alloc();
if (!ctx->x_bgr_frame)
{
sws_freeContext(x_bgr_ctx);
av_free(x_bgr_frame);
x_bgr_frame = 0;
x_bgr_ctx = 0;
return 0;
}
ctx->x_bgr_frame->width = w;
ctx->x_bgr_frame->height = h;
if
(
avpicture_fill((AVPicture *)ctx->x_bgr_frame, 0, PIX_FMT_RGB32, w, h) < 0
)
{
sws_freeContext(x_bgr_ctx);
av_free(x_bgr_frame);
x_bgr_frame = 0;
x_bgr_ctx = 0;
return 0;
}
//создаем контекст масштабирования
ctx->x_bgr_ctx = sws_getContext(ctx->codec_ctx->width, ctx->codec_ctx->height, ctx->codec_ctx->pix_fmt, w, h, PIX_FMT_RGB32, SWS_BICUBIC, 0, 0, 0);
if (!ctx->x_bgr_ctx)
{
sws_freeContext(x_bgr_ctx);
av_free(x_bgr_frame);
x_bgr_frame = 0;
x_bgr_ctx = 0;
return 0;
}
}
//настраиваем BGR-представление кадра на переданный указатель на содержимое кадра
ctx->x_bgr_frame->data[0] = (uint8_t *)bmp_bits;
ctx->x_bgr_frame->data[0] += ctx->x_bgr_frame->linesize[0] * (h - 1);
ctx->x_bgr_frame->linesize[0] = -ctx->x_bgr_frame->linesize[0];
//меняем яркость, контраст, насыщенность
int *table;
int *inv_table;
int brightness, contrast, saturation, srcRange, dstRange;
sws_getColorspaceDetails(ctx->x_bgr_ctx, &inv_table, &srcRange, &table, &dstRange, &brightness, &contrast, &saturation);
brightness = ((br<<16) + 50) / 100;
contrast = (((co+100)<<16) + 50) / 100;
saturation = (((sa+100)<<16) + 50) / 100;
sws_setColorspaceDetails(ctx->x_bgr_ctx, inv_table, srcRange, table, dstRange, brightness, contrast, saturation);
//масштабируем
sws_scale(ctx->x_bgr_ctx, ctx->frame[!ctx->frame_idx]->data, ctx->frame[!ctx->frame_idx]->linesize, 0, ctx->codec_ctx->height, ctx->x_bgr_frame->data, ctx->x_bgr_frame->linesize);
//возвращаем настройки BGR-представления кадра к оригинальным
ctx->x_bgr_frame->linesize[0] = -ctx->x_bgr_frame->linesize[0];
//отметка времени кадра
*(int64_t *)pts = ctx->pts[!ctx->frame_idx] * 1000 / ctx->format_ctx->streams[ctx->stream]->time_base.den;
return 1;
}
//блокирующий вызов
int ffmpeg_get_bmp(int _ctx, void *bmp_bits, int w, int h, int br, int co, int sa, void *pts)
{
ctx_t *ctx = (ctx_t *)_ctx;
if (!ctx || !ctx->frames_count) return 0;
ctx->lock();
int res = ffmpeg_get_bmp_NB_(_ctx, bmp_bits, w, h, br, co, sa, pts);
ctx->unlock();
return res;
}
```
#### Отображение видео
Программа выполнена в виде множества окон просмотра каждое из которых ассоциировано с определенной камерой (приложение собиралось в теплом ламповом Borland C++ Builder 6.0 Enterprise Suite).
Внешний вид программы во время работы (обратите внимание на то, что одна камера — внешняя — висит на кабеле сзади робота; о том КТО попал в кадр читайте далее)
Полевые испытания (запись идет с экрана, интерфейс управления роботом отображаемый поверх окон просмотра является внешним приложением)
Для удобства пользования видимость, позиция, глубина расположения, размер, яркость, контраст, насыщенность и прозрачность каждого окна могут меняться и запоминаются. В окна просмотра поверх кадров полученных от камеры может выводится различная служебная информация: название камеры, размер окна, FPS отображения и записи, состояние буфера вывода, нагрузка процессора, индикаторы записи (с камеры, с экрана, стерео), область видимости для левого и правого глаза (очки) и т.п.
Вывод очередного кадра на экран происходит в обработчике сообщения WM\_PAINT окна просмотра. Сообщения WM\_PAINT посылаются окну просмотра достаточно замысловатым способом. В начале рассмотрим необходимый для работы служебный функционал. Для получения средней задержки между кадрами используется объект следующего класса
```
class t_buf_t
{
public:
int n; //размер циклического буфера
__int64 *t; //циклический буфер отметок времени
int idx; //текущий индекс для записи в циклический буфер
int ttl; //общее количество записанных отметок времени (если буфер не заполнен)
t_buf_t(void): n(0), t(0), idx(0), ttl(0) {}
virtual ~t_buf_t(void) {delete [] t;}
void reset_size(int n)
{
delete [] t;
this->n = n;
t = new __int64[n];
idx = 0;
ttl = 0;
}
void set_t(__int64 t) //запись отметки времени в циклический буфер
{
this->t[idx] = t;
idx++;
if (idx == n) idx = 0;
if (ttl < n) ttl++;
}
__int64 get_dt(void) //расчет средней задержки между кадрами
{
if (ttl != n) return 0;
int idx_2 = idx - 1;
if (idx_2 < 0) idx_2 = n - 1;
return (t[idx_2] - t[idx]) / n;
}
};
```
Объект этого класса хранит циклический буфер содержащий отметки времени кадров. Для расчета средней задержки между кадрами отметка времени первого кадра циклического буфера вычитается из отметки времени последнего кадра циклического буфера и полученная разница делится на размер циклического буфера.
Для хранения кадров так же используются циклические буферы — отдельные для хранения содержимого кадров, идентификаторов кадров и отметок качества кадров. Каждый из этих буферов состоит из двух частей. Первую часть будем называть буфером ввода — в него записываются кадры читаемые из потока. Вторую часть будем называть буфером вывода — из него читаются кадры выводимые на экран. Для доступа к частям используются базовые индексы (смещение в общем буфере). Переключение между частями производится перестановкой базовых индексов.
```
char **form_bmp_bits; //общий буфер для хранения содержимого кадров
HBITMAP *form_bmp_h; //общий буфер для хранения идентификаторов кадров
bool *frame_good; //общий буфер для хранения отметок качества кадров
int frame_buffer_size; //размер буфера (ввода или вывода)
int frame_buffer_size_2; //удвоенный размер буфера (ввода или вывода)
int in_frames_count_ttl; //общее количество полученных кадров (если буфер не заполнен)
int in_frame_idx; //текущий индекс для записи кадров в буфер ввода
int out_frame_idx; //текущий индекс для чтения кадра из буфера вывода
int in_frames_count; //количество кадров в буфере ввода
int out_frames_count; //количество кадров в буфере вывода
int in_base_idx; //базовый индекс буфера ввода (смещение в общем буфере)
int out_base_idx; //базовый индекс буфера вывода (смещение в общем буфере)
int buffer_w, buffer_h; //размер кадра
t_buf_t in_t_buf; //объект используемый для расчета средней задержки между кадрами
__int64 out_dt; //средняя задержка между кадрами
__int64 pts; //отметка времени последнего сформированного кадра
__int64 dpts; //разница отметок времени двух последних сформированных кадров
//события используемые для вывода кадров при размере буфера равном одному кадру
HANDLE h_a;
HANDLE h_b;
//количество отметок времени используемое для расчета средней задержки между кадрами
int n_param;
//поправка к средней задержке между кадрами для предотвращения опустошения/переполнения буфера
int active_dt_param;
void reset_frame_buffer(void)
{
in_frames_count_ttl = frame_buffer_size == 1? 1 : 0;
in_frame_idx = 0;
out_frame_idx = 0;
in_frames_count = frame_buffer_size == 1? 1 : 0;
out_frames_count = frame_buffer_size == 1? 1 : 0;
in_base_idx = 0;
out_base_idx = frame_buffer_size == 1? 0 : frame_buffer_size;
//инициализация объекта используемого для расчета средней задержки между кадрами
in_t_buf.reset_size(n_param);
out_dt = 20; //начальная задержка между кадрами 20 мс
}
void create_frame_buffer(void)
{
reset_frame_buffer();
frame_buffer_size_2 = frame_buffer_size == 1? 1 : frame_buffer_size * 2;
buffer_w = ClientWidth;
buffer_h = ClientHeight;
//общий буфер состоит из двух буферов (ввода и вывода) с увеличенными в два раза размерами
int n = frame_buffer_size == 1? 1 : frame_buffer_size * 4;
form_bmp_bits = new char *[n];
form_bmp_h = new HBITMAP[n];
frame_good = new bool[n];
for (int i = 0; i < n; i++)
{
BITMAPINFOHEADER form_bmi_hdr;
form_bmi_hdr.biSize = sizeof(BITMAPINFOHEADER);
form_bmi_hdr.biWidth = buffer_w;
form_bmi_hdr.biHeight = buffer_h;
form_bmi_hdr.biPlanes = 1;
form_bmi_hdr.biBitCount = 32;
form_bmi_hdr.biCompression = BI_RGB;
form_bmi_hdr.biSizeImage = form_bmi_hdr.biWidth * form_bmi_hdr.biHeight * 4;
form_bmi_hdr.biXPelsPerMeter = 0;
form_bmi_hdr.biYPelsPerMeter = 0;
form_bmi_hdr.biClrUsed = 0;
form_bmi_hdr.biClrImportant = 0;
form_bmp_h[i] = CreateDIBSection(0, (BITMAPINFO *)&form_bmi_hdr, DIB_RGB_COLORS, (void **)&form_bmp_bits[i], 0, 0);
frame_good[i] = false;
}
}
void destroy_frame_buffer(void)
{
int n = frame_buffer_size == 1? 1 : frame_buffer_size * 4;
for (int i = 0; i < n; i++)
DeleteObject(form_bmp_h[i]);
delete [] form_bmp_bits;
delete [] form_bmp_h;
delete [] frame_good;
}
```
Увеличение размера буферов (ввода и вывода) в два раза по сравнению с заданным делает возможным дрейф средней задержки между кадрами как в положительную так и в отрицательную сторону.
Теперь перейдем непосредственно к процессу вывода. При формировании кадра DLL-посредник вызывает обработчик читающий кадр в буфер ввода
```
//вспомогательная функция читающая кадр в буфер ввода
bool u_obj_t::get_frame(const bool _NB_, void *pts)
{
bool res;
if (_NB_)
{
res = ffmpeg_get_bmp_NB_(form->ctx, form->form_bmp_bits[form->in_frame_idx + form->in_base_idx], form->buffer_w, form->buffer_h, form->br, form->co, form->sa, pts);
}
else
{
res = ffmpeg_get_bmp(form->ctx, form->form_bmp_bits[form->in_frame_idx + form->in_base_idx], form->buffer_w, form->buffer_h, form->br, form->co, form->sa, pts);
}
return res;
}
//вспомогательная функция вызываемая обработчиком
void u_obj_t::exec(const bool _NB_)
{
__int64 pts;
//если буфер инициализирован и кадр прочитан, то...
if (form->form_bmp_h[form->in_frame_idx + form->in_base_idx] && get_frame(_NB_, &pts))
{
if (pts != form->pts) //если это реально новый кадр (отметки времени разные), то...
{
form->frame_good[form->in_frame_idx + form->in_base_idx] = true;
//вычисляем разницу отметок времени двух последних сформированных кадров...
//и запоминаем отметку времени последнего сформированного кадра
form->dpts = pts - form->pts;
form->pts = pts;
//записываем отметку времени в объект используемый для расчета средней задержки между кадрами
form->in_t_buf.set_t(ffmpeg_get_microseconds() / 1000);
//вычисляем среднюю задержку между кадрами
form->out_dt = form->in_t_buf.get_dt();
//ограничиваем задержку на уровне 250 мс
if (form->out_dt > 250) form->out_dt = 250;
//увеличиваем текущий индекс для записи кадров в буфер ввода
form->in_frame_idx++;
//если буфер ввода заполнен - не меняем текущий индекс для записи кадров в буфер ввода
if (form->in_frame_idx == form->frame_buffer_size_2) form->in_frame_idx--;
//увеличиваем количество кадров в буфере ввода
form->in_frames_count++;
//пока буфер ввода не заполнен увеличиваем общее количество полученных кадров
if (form->in_frames_count_ttl != form->frame_buffer_size) form->in_frames_count_ttl++;
}
}
else //кадр не был прочитан
{
form->frame_good[form->in_frame_idx + form->in_base_idx] = false;
}
}
//обработчик
void cb_fn(int cb_param)
{
Tmain_form *form = (Tmain_form *)cb_param;
form->u_obj->lock(); //блокируем объект отвечающий за чтение кадров
form->u_obj->exec(true); //читаем кадр
form->u_obj->unlock(); //деблокируем объект отвечающий за чтение кадров
if (form->frame_buffer_size == 1) //при размере буфера равном одному кадру
{
ResetEvent(form->h_b); //сбрасываем событие A
SetEvent(form->h_a); //устанавливаем событие A
ResetEvent(form->h_a); //сбрасываем событие B
SetEvent(form->h_b); //устанавливаем событие B
}
}
```
Параллельно работает поток посылающий сообщения WM\_PAINT окну просмотра с вычисляемым в процессе работы интервалом
```
//вспомогательная функция вызываемая функцией потока
void __fastcall repaint_thread_t::repaint(void)
{
form->Repaint(); //здесь будет послано сообщение WM_PAINT окну просмотра
if (form->frame_buffer_size == 1) //при размере буфера равном одному кадру больше ничего не требуется
{}
else //иначе...
{
//увеличиваем текущий индекс для чтения кадра из буфера вывода
form->out_frame_idx++;
//если буфер вывода пуст или буфер ввода заполнен, то пробуем переключить буфера
if (form->out_frame_idx >= form->out_frames_count || form->in_frames_count >= form->frame_buffer_size_2)
{
form->u_obj->lock();
if (form->in_frames_count) //если в буфере ввода есть кадры, то...
{
//реально переключаем буфера
//количество кадров которое окажется в буфере вывода
int n = form->in_frames_count >= form->frame_buffer_size_2? form->frame_buffer_size_2 : form->in_frames_count;
form->out_frame_idx = 0;
form->out_frames_count = n;
form->out_base_idx = form->out_base_idx? 0 : form->frame_buffer_size_2;
form->in_frame_idx = 0;
form->in_frames_count = 0;
form->in_base_idx = form->in_base_idx? 0 : form->frame_buffer_size_2;
}
else //иначе придется подождать пока в буфере ввода появиться хотя бы один кадр
{
form->out_frame_idx--;
}
form->u_obj->unlock();
}
}
}
//функция потока
void __fastcall repaint_thread_t::Execute(void)
{
while (!Terminated)
{
if (form->frame_buffer_size == 1) //если размер буфера равен одному кадру, то...
{
WaitForSingleObject(form->h_a, 250); //ожидаем событие A в течение 250 мс
Synchronize(repaint); //вызываем функцию которая пошлет сообщение WM_PAINT окну просмотра
WaitForSingleObject(form->h_b, 250); //ожидаем событие B в течение 250 мс
/*таким образом при размере буфера равном одному кадру данный код будет работать
исключительно от событий без использования задержек что позволит оптимально использовать
ресурсы процессора при минимальной задержке от момента получения кадра до его вывода на экран*/
}
else //иначе выводим кадр и делаем после него задержку для чего...
{
//в начале рассчитаем поправку к средней задержке между кадрами...
//для предотвращения опустошения/переполнения буфера
form->active_dt_param =
(
/*из размера буфера вычтем количество кадров которые у нас сейчас есть...
первая часть этих кадров находится в буфере вывода (остаток который мы еще не вывели)
вторая часть этих кадров находится в буфере ввода (их мы будем выводить когда переключим буфера)*/
form->frame_buffer_size -
(form->out_frames_count - form->out_frame_idx + form->in_frames_count)
/*мы получили количество кадров которого нам не хватает для того что бы у нас в запасе было
количество кадров равное размеру буфера
вспомним что буфер имеет удвоенный размер и количество кадров фактически находящихся в нем может
быть меньше (вплоть до нуля) или больше (вплоть до удвоенного размера)
поэтому нам надо управлять кадрами хранимыми в запасе стремясь к тому что бы их количество было
равно размеру буфера (ни больше ни меньше)
для этого мы будем сводить к нулю полученную разность при помощи поправки к средней задержке
между кадрами:
поправка будет положительная для положительной разности
(нам нужно больше времени что бы получить больше кадров что бы наполнить ими буфер который начал
опустошаться)
поправка будет отрицательной для отрицательной разности
(нам нужно быстрее выводить кадры что бы сбросить их избыток из буфера который начал переполняться)
для этого полученную разность умножим на среднюю задержку между кадрами и разделим на размер буфера
тем самым мы получим задержку необходимую для стабилизации размера буфера - это время которое нужно
добавить к средней задержке между кадрами для того чтобы получить/пропустить рассчитанное нами
количество кадров за период в течение которого мы получаем количество кадров равное размеру буфера
(мы могли бы выбрать любой другой период в течение которого мы хотели бы привести количество кадров
находящихся у нас в запасе к размеру буфера однако этот период ничем не хуже)... уфф :)*/
) * form->out_dt / form->frame_buffer_size;
LONGLONG t = ffmpeg_get_microseconds() / 1000;
Synchronize(repaint); //вызываем функцию которая пошлет сообщение WM_PAINT окну просмотра
LONGLONG dt = ffmpeg_get_microseconds() / 1000 - t;
//вычисляем фактическую задержку между кадрами:
//к средней задержке между кадрами прибавляем поправку и вычитаем время затраченное на рисование
int delay = form->out_dt + form->active_dt_param - dt;
if (delay > 0) Sleep(delay);
}
}
}
```
Постоянная коррекция задержки между кадрами позволяет эффективно сглаживать неравномерность их поступления тем самым повысив комфортность просмотра видео при кратковременном падении скорости передачи данных.
Процедуры непосредственно отвечающие за рисование выглядят следующим образом
```
mem_c = new TCanvas; //канва для вывода элементов интерфейса поверх кадра естественными средствами
...
//функция заполняющая канву цветом фона
void Tmain_form::draw_bg_img(TCanvas *c, int w, int h)
{
c->Brush->Style = bsSolid;
c->Brush->Color = clBlack;
c->FillRect(TRect(0, 0, w, h));
}
//пример функции выводящей сообщение через канву
void Tmain_form::draw_no_signal_img(TCanvas *c, int w, int h)
{
AnsiString s = "NO SIGNAL";
c->Brush->Style = bsClear;
c->Font->Color = clWhite;
c->Font->Size = 24;
c->Font->Style = TFontStyles()<< fsBold;
c->TextOutA(w / 2 - c->TextWidth(s) / 2, h / 2 - c->TextHeight(s) / 2, s);
}
...
//обработчик сообщения WM_PAINT
void __fastcall Tmain_form::WMPaint(TWMPaint& Message)
{
if (form_bmp_h[out_frame_idx + out_base_idx]) //если буфер инициализирован
{
PAINTSTRUCT ps;
HDC paint_hdc = BeginPaint(Handle, &ps);
HDC hdc_1 = CreateCompatibleDC(paint_hdc); //создаем контекст 1
HDC hdc_2 = CreateCompatibleDC(paint_hdc); //создаем контекст 2
mem_c->Handle = hdc_1; //настраиваем канву на контекст 1
HBITMAP h_1 = CreateCompatibleBitmap(paint_hdc, buffer_w, buffer_h); //создаем BMP
HBITMAP old_h_1 = (HBITMAP)SelectObject(hdc_1, h_1); //ассоциируем контекст 1 с BMP
//все что мы будем выводить через канву (а значит через контекст 1) будет попадать в BMP
//ассоциируем контекст 2 с кадром
HBITMAP old_h_2 = (HBITMAP)SelectObject(hdc_2, form_bmp_h[out_frame_idx + out_base_idx]);
//копируем кадр в BMP
BitBlt(hdc_1, 0, 0, buffer_w, buffer_h, hdc_2, 0, 0, SRCCOPY);
//если включен режим тестирования стерео и форма на которой мы рисуем ассоциирована с левой или...
//правой камерой (то есть транслирующей изображение для левого или правого глаза), то...
if (start_form->stereo_test && (start_form->left_form == this || start_form->right_form == this))
{
//рисуем через канву тестовое изображение (для левого или правого глаза соответственно)
mem_c->CopyMode = cmSrcCopy;
mem_c->StretchDraw(TRect(0, 0, buffer_w, buffer_h), start_form->left_form == this? start_form->left_img : start_form->right_img);
}
else
{
//если с камерой что-то не так выводим через канву сообщение NO SIGNAL
if (!ffmpeg_get_status(ctx))
{
draw_bg_img(mem_c, buffer_w, buffer_h);
draw_no_signal_img(mem_c, buffer_w, buffer_h);
}
//если в буфере вывода еще нет кадров выводим через канву сообщение ...BUFFERING...
else if (!out_frames_count) {
draw_bg_img(mem_c, buffer_w, buffer_h);
draw_buffering_img(mem_c, buffer_w, buffer_h);
}
//если с кадром что-то не так выводим через канву сообщение NO SIGNAL
else if (!frame_good[out_frame_idx + out_base_idx])
{
draw_bg_img(mem_c, buffer_w, buffer_h);
draw_no_signal_img(mem_c, buffer_w, buffer_h);
}
}
//если включен режим показа области видимости рисуем через канву соответствующее изображение (очки)
if (area_type) draw_area_img(mem_c, buffer_w, buffer_h);
//если включен режим показа информации (размер окна, FPS, задержка, нагрузка процессора и т.п.)...
//выводим через канву соответствующую информацию
if (show_ui) draw_info_img(mem_c, buffer_w, buffer_h);
//копируем изображение из оперативной памяти (BMP) на экран
BitBlt(paint_hdc, 0, 0, buffer_w, buffer_h, hdc_1, 0, 0, SRCCOPY);
//удаляем временные объекты
SelectObject(hdc_1, old_h_1);
SelectObject(hdc_2, old_h_2);
DeleteObject(h_1);
DeleteDC(hdc_1);
DeleteDC(hdc_2);
EndPaint(Handle, &ps);
}
}
```
Обратите внимание на некоторую избыточность кода — мы рисуем в оперативной памяти в том числе копируя в нее сам кадр который также является объектом расположенным в оперативной памяти (!), в конце рисования изображение копируется из оперативной памяти (BMP) на экран. Почему так? Дело в том, что если рисовать непосредственно на кадре (эй, он ведь тоже расположен в оперативной памяти, давайте рисовать сразу на нем) и в конце рисования так же копировать изображение из него на экран, то при определенных частотах вывода кадров может возникнуть совершенно необъяснимый и неуместный в данном случае эффект мерцания…
Относительно нагрузки на процессор. Вывод кадров на экран практически не нагружает процессор. Основная нагрузка на процессор как и раньше идет при декодировании потока.
#### Просмотр стерео-видео
Просмотр стерео-видео от двух выделенных IP-камер организован следующим образом: любая камера может быть назначена левой или правой (то есть транслирующей изображение для левого или правого глаза). После этого положение и размер окон настраиваются в ручную или с помощью одного из предопределенных профилей таким образом что бы обеспечить удобный просмотр на выбранных вами технических средствах. При необходимости может быть включен режим показа области видимости для левого и правого глаза (очки).
Внешний вид программы во время работы в режиме показа области видимости для левого и правого глаза (очки)
Полевые испытания (существо на видео — это форма жизни которая называется налим и он судя по всему сидит в засаде)
Простой просмотр стерео-видео был организован следующим образом:
-в VR шлем помещался смартфон на базе ОС Android;
-на смартфон устанавливалось приложение [iDisplay](http://getidisplay.com/) (платно);
-на ПК с программой устанавливался модуль iDisplay (бесплатно);
-смартфон подключался к ПК при помощи USB (требуется ADB драйвер) или Wi-Fi и становился «дополнительным дисплеем» (обратите внимание на кавычки — вскоре вы поймете почему);
-окна просмотра программы перетаскивались на этот «дополнительный дисплей» и настраивались под экран и VR шлем.
Данный способ организации просмотра стерео-видео обладает следующими неоспоримыми преимуществами:
-сравнительно низкая цена решения (VR шлем под смартфон можно приобрести по цене от 0 USD :), приложение iDisplay для смартфона обойдется вам в 5 USD);
-простота настройки — подключил и работай.
Теперь о недостатках:
-«дополнительный дисплей» — это ничуть не дисплей в нормальном понимании этого слова — то есть это не подключение устройства как дисплея — нет, смартфон остается смартфоном, а ПК остается ПК и как бы разработчики iDisplay не лезли из кожи вон, но на тестах была видна одна и та же картина: для аппаратной конфигурации Intel Core2 Duo E8300 2.83 ГГц iDisplay забирает 50% ресурсов процессора (ровно одно ядро; например, для процессора Intel Core2 Quad Q9400 2.66 ГГц у которого четыре ядра нагрузка будет равна 25%) обеспечивая транспорт картинки, что конечно же очень печально; кроме того в некоторых трудновоспроизводимых случаях наблюдалось очень кратковременное (но заметное глазом) замирание картинки с периодом порядка одной секунды — iDisplay явно что-то мудрит с буферизацией или просто не успевает доставить кадры (пропускает те которые не были переданы за некий интервал сразу перескакивая к текущему); плюс ко всему некоторые комбинации настроек iDisplay могут дать задержку между реальным изменением картинки и отображением этих изменений на «дополнительном дисплее»;
-картинка не может соперничать с профессиональными VR решениями, но и не настолько плоха что бы не рассматривать этот вариант.
#### Запись видео с экрана
Запись видео с экрана реализована достаточно просто: программа создает поток который с заданной частотой делает снимок экрана и передает его DLL-посреднику для записи. Код потока выглядит следующим образом
```
void scr_rec_thread_t::main(void) //функция потока
{
LONGLONG t = ffmpeg_get_microseconds() / 1000;
HBITMAP old_h = (HBITMAP)SelectObject(scr_bmp_hdc, scr_bmp_h);
if (!BitBlt //захватываем картинку
(
scr_bmp_hdc, //HDC hdcDest
0, //int nXDest
0, //int nYDest
scr_w, //int nWidth
scr_h, //int nHeight
scr_hdc, //HDC hdcSrc
scr_x, //int nXSrc
scr_y, //int nYSrc
CAPTUREBLT | SRCCOPY //DWORD dwRop
))
{}
SelectObject(scr_bmp_hdc, old_h);
ffmpeg_rec_bmp(scr_rec_ctx, scr_bmp_bits); //записываем картинку
/*задержка между картинками рассчитывается по заданному FPS однако для предотвращения
перегрузки процессора значение задержки ограничивается снизу заданной минимальной задержкой
между кадрами*/
LONGLONG dt = ffmpeg_get_microseconds() / 1000 - t;
int ms_per_frame = 1000 / scr_rec_max_fps;
if (dt < ms_per_frame)
{
dt = ms_per_frame - dt;
if (dt < scr_rec_min_delay) dt = scr_rec_min_delay;
}
else
{
dt = scr_rec_min_delay;
}
Sleep(dt);
//раз в секунду рассчитываем FPS записи с экрана
frames_count++;
if (ffmpeg_get_microseconds() / 1000 - start > 1000)
{
start = ffmpeg_get_microseconds() / 1000;
fps = frames_count;
frames_count = 0;
}
}
scr_rec_thread_t *scr_rec_thread; //объект-поток
//положение и размеры картинки
int scr_x;
int scr_y;
int scr_w;
int scr_h;
HDC scr_hdc; //контекст экрана
HDC scr_bmp_hdc; //контекст BMP
char *scr_bmp_bits; //содержимое захваченной картинки
HBITMAP scr_bmp_h; //идентификатор BMP
//инициализируем запись с экрана
void scr_rec_init(void)
{
//создаем объект в DLL-посреднике отвечающий за запись
scr_rec_ctx = ffmpeg_alloc_rec_ctx();
//получаем положение и размеры картинки
scr_x = GetSystemMetrics(SM_XVIRTUALSCREEN);
scr_y = GetSystemMetrics(SM_YVIRTUALSCREEN);
scr_w = GetSystemMetrics(SM_CXVIRTUALSCREEN);
scr_h = GetSystemMetrics(SM_CYVIRTUALSCREEN);
//создаем контекст экрана и BMP
scr_hdc = GetDC(0);
scr_bmp_hdc = CreateCompatibleDC(scr_hdc);
//создаем BMP
BITMAPINFOHEADER scr_bmi_hdr;
scr_bmi_hdr.biSize = sizeof(BITMAPINFOHEADER);
scr_bmi_hdr.biWidth = scr_w;
scr_bmi_hdr.biHeight = scr_h;
scr_bmi_hdr.biPlanes = 1;
scr_bmi_hdr.biBitCount = 32;
scr_bmi_hdr.biCompression = BI_RGB;
scr_bmi_hdr.biSizeImage = scr_bmi_hdr.biWidth * scr_bmi_hdr.biHeight * 4;
scr_bmi_hdr.biXPelsPerMeter = 0;
scr_bmi_hdr.biYPelsPerMeter = 0;
scr_bmi_hdr.biClrUsed = 0;
scr_bmi_hdr.biClrImportant = 0;
scr_bmp_h = CreateDIBSection(0, (BITMAPINFO *)&scr_bmi_hdr, DIB_RGB_COLORS, (void **)&scr_bmp_bits, 0, 0);
scr_rec_thread = new scr_rec_thread_t(); //создаем объект-поток
}
//освобождение ресурсов
void scr_rec_uninit(void)
{
delete scr_rec_thread;
DeleteObject(scr_bmp_h);
DeleteDC(scr_bmp_hdc);
DeleteDC(scr_hdc);
ffmpeg_free_ctx(scr_rec_ctx);
}
int scr_rec_ctx;
```
Как видим все достаточно просто. Более интересен код DLL-посредника отвечающий за запись
```
//класс отвечающий за запись
class rec_ctx_t:
public mt_obj
{
public:
AVFormatContext *ofcx; //контекст формата
AVStream *ost; //поток
LONGLONG start; //время начала записи
AVPacket pkt; //пакет
AVFrame *frame; //кадр YUV420P
AVFrame *_frame; //кадр RGB32
/*не ищите противоречий в ранее использованном термине BGR-представление кадра и используемом в этом
коде термине RGB32-представление кадра - это одно и то же просто ранее акцент делался на расположение
компонентов цвета в BMP, а сейчас акцент делается на имена форматов пикселя используемые FFMPEG*/
uint8_t *_buffer; //буфер
//контекст масштабирования (в данном случае используется для преобразования кадра из RGB32 в YUV420P)
SwsContext *ctx;
//ID кодека для записи - выбирайте, но не увлекайтесь, некоторые кодеки могут требовать задания...
//дополнительных параметров которые здесь не устанавливаются
int codec_id;
//профиль для записи - позволяет выбрать качество и скорость кодирования
char *preset;
//CRF для записи - позволяет выбрать качество и скорость кодирования, но несколько иным образом...
//(подробнее см. документацию FFMPEG)
int crf;
rec_ctx_t(void):
ofcx(0),
ost(0),
frame(0),
_frame(0),
_buffer(0),
ctx(0),
codec_id(CODEC_ID_H264),
preset(strdup("ultrafast")),
crf(23)
{
memset(&start, 0, sizeof(start));
av_init_packet( &pkt );
}
virtual ~rec_ctx_t()
{
ffmpeg_stop_rec2((int)this);
free(preset);
}
void clean(void) //освобождение ресурсов
{
sws_freeContext(ctx);
av_free(_buffer);
av_free(frame);
av_free(_frame);
if (ost) avcodec_close( ost->codec );
avformat_free_context( ofcx );
ofcx = 0;
ost = 0;
memset(&start, 0, sizeof(start));
av_init_packet( &pkt );
frame = 0;
_frame = 0;
_buffer = 0;
ctx = 0;
}
int prepare(char *dst, int w, int h, int den, int gop_size) //подготовка объекта
{
//создаем и настраиваем контекст формата
AVOutputFormat *ofmt = av_guess_format( "VOB", NULL, NULL ); //выбираем VOB
if (!ofmt)
{
clean();
return 0;
}
ofcx = avformat_alloc_context();
if (!ofcx)
{
clean();
return 0;
}
ofcx->oformat = ofmt;
//ищем кодек, создаем и настраиваем поток
AVCodec *ocodec = avcodec_find_encoder( (AVCodecID)codec_id );
if (!ocodec || !ocodec->pix_fmts || ocodec->pix_fmts[0] == -1)
{
clean();
return 0;
}
ost = avformat_new_stream( ofcx, ocodec );
if (!ost)
{
clean();
return 0;
}
ost->codec->width = w;
ost->codec->height = h;
ost->codec->pix_fmt = ocodec->pix_fmts[0];
ost->codec->time_base.num = 1;
ost->codec->time_base.den = den;
ost->time_base.num = 1;
ost->time_base.den = den;
ost->codec->gop_size = gop_size;
if ( ofcx->oformat->flags & AVFMT_GLOBALHEADER ) ost->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
AVDictionary *opts = 0;
av_dict_set(&opts, "preset", preset, 0); //устанавливаем профиль
char crf_str[3];
sprintf(crf_str, "%i", crf); //устанавливаем CRF
av_dict_set(&opts, "crf", crf_str, 0);
if (avcodec_open2( ost->codec, ocodec, &opts ) != 0)
{
clean();
return 0;
}
//создаем и настраиваем кадры, буфер и контекст масштабирования
frame = av_frame_alloc();
_frame = av_frame_alloc();
if (!frame || !_frame)
{
clean();
return 0;
}
frame->format = PIX_FMT_RGB32;
frame->width = w;
frame->height = h;
_frame->format = PIX_FMT_YUV420P;
_frame->width = w;
_frame->height = h;
int _buffer_size = avpicture_get_size(PIX_FMT_YUV420P, w, h);
if (_buffer_size < 0)
{
clean();
return 0;
}
uint8_t *_buffer = (uint8_t *)av_malloc(_buffer_size * sizeof(uint8_t));
if (!_buffer)
{
clean();
return 0;
}
if
(
avpicture_fill((AVPicture *)frame, 0, PIX_FMT_RGB32, w, h) < 0 ||
avpicture_fill((AVPicture *)_frame, _buffer, PIX_FMT_YUV420P, w, h) < 0
)
{
clean();
return 0;
}
ctx = sws_getContext(w, h, PIX_FMT_RGB32, w, h, PIX_FMT_YUV420P, SWS_BICUBIC, 0, 0, 0);
if (!ctx)
{
clean();
return 0;
}
//открываем файл
if (avio_open2( &ofcx->pb, dst, AVIO_FLAG_WRITE, NULL, NULL ) < 0)
{
clean();
return 0;
}
//пишем заголовок
if (avformat_write_header( ofcx, NULL ) != 0)
{
avio_close( ofcx->pb );
clean();
return 0;
}
//запоминаем время начала записи
start = get_microseconds();
return 1;
}
};
//функция запускающая запись
int ffmpeg_start_rec2
(
int rec_ctx,
char *dst, int w, int h, int den, int gop_size
)
{
rec_ctx_t *ctx = (rec_ctx_t *)rec_ctx;
if (!ctx) return 0;
ffmpeg_stop_rec2(rec_ctx); //остановим
return ctx->prepare(dst, w, h, den, gop_size);
}
//функция останавливающая запись
void ffmpeg_stop_rec2(int rec_ctx)
{
rec_ctx_t *ctx = (rec_ctx_t *)rec_ctx;
if (!ctx || !ctx->ofcx) return;
//завершаем и закрываем файл
av_write_trailer( ctx->ofcx );
avio_close( ctx->ofcx->pb );
ctx->clean();
}
//функция записывающая картинку
int ffmpeg_rec_bmp(int rec_ctx, void *bmp_bits)
{
rec_ctx_t *ctx = (rec_ctx_t *)rec_ctx;
if (!ctx) return 0;
//настраиваем RGB32-представление кадра на переданный указатель на содержимое кадра
ctx->frame->data[0] = (uint8_t *)bmp_bits;
ctx->frame->data[0] += ctx->frame->linesize[0] * (ctx->frame->height - 1);
ctx->frame->linesize[0] = -ctx->frame->linesize[0];
//преобразуем RGB32-представление кадра в YUV420P-представление кадра
sws_scale(ctx->ctx, ctx->frame->data, ctx->frame->linesize, 0, ctx->frame->height, ctx->_frame->data, ctx->_frame->linesize);
//возвращаем настройки RGB32-представления кадра к оригинальным
ctx->frame->linesize[0] = -ctx->frame->linesize[0];
//формируем отметку времени показа от начала записи в заданных частотах
LONGLONG dt = (get_microseconds() - ctx->start) / 1000;
ctx->_frame->pts = dt * ctx->ost->time_base.den / 1000;
//кодируем
int got_packet;
if (avcodec_encode_video2(ctx->ost->codec, &ctx->pkt, ctx->_frame, &got_packet) != 0) return 0;
//если пакет сформирован сбрасываем его в файл
int res = 1;
if (got_packet)
{
res = av_interleaved_write_frame( ctx->ofcx, &ctx->pkt ) == 0? 1 : 0;
av_free_packet( &ctx->pkt );
}
return res;
}
```
Следует отметить, что запись с экрана (1280 x 1024, 25 fps) для аппаратной конфигурации Intel Core2 Duo E8300 2.83 ГГц потребляет порядка 30% ресурсов процессора поэтому следует разумно подходить к выбору FPS, минимальной задержки между кадрами, профиля для записи и аппаратного обеспечения на котором вы собираетесь запускать программу.
Вот пожалуй и все. Программа была успешно опробована во всех возможных режимах во время полевых испытаний робота с реальным неоднократным погружением в р. Волга.
Для тех кого заинтересовала тематика имеется ссылка на мою предыдущую статью схожей направленности:
[Делаем систему видеонаблюдения](https://habrahabr.ru/post/177071/). | https://habr.com/ru/post/277955/ | null | ru | null |
# Можно порешать: задача про лидарное облако от команды беспилотных автомобилей Яндекса
Меня зовут Андрей Гладков, я разработчик в направлении беспилотных автомобилей. Сегодня я поделюсь с сообществом Хабра задачей, которая связана с важнейшим сенсором беспилотника — лидаром, и с тем, как мы обрабатываем лидарные данные. Вы можете попробовать решить задачу самостоятельно на платформе Контест. Система проверит решение с помощью автотестов и сразу сообщит результат. Разбор и код решения — в спойлерах ближе к концу поста. Тем, кто был на митапе в нашем цехе в прошлом году, задача покажется знакомой — мы предлагали ее в качестве входного билета, но публично никогда ей не делились.
### Условие
| | |
| --- | --- |
| Ограничение времени | 15 секунд |
| Ограничение памяти | 64 МБ |
| Ввод | стандартный ввод или input.txt |
| Вывод | стандартный вывод или output.txt |
Беспилотный автомобиль стоит на ровной асфальтовой площадке, на крыше автомобиля установлен лидар. Даны измерения, полученные лидаром за один период сканирования.
Измерения представляют собой множество из  точек, имеющих координаты ,  и . Больше 50% точек принадлежат дороге. Моделью положения принадлежащих дороге точек в пространстве является плоскость с параметризацией
Точки, которые принадлежат дороге, отклоняются от модели не больше чем на заданную величину .
Необходимо найти параметры  и  соответствующей дороге плоскости. Число точек, отклоняющихся от модели не больше чем на , должно составлять не менее 50% от общего числа точек.
### Формат ввода
Входные данные заданы в текстовом формате. Первая строка содержит фиксированный порог  . Вторая строка содержит число точек  . Следующие  строк содержат координаты ,  и   для каждой точки, разделителем является символ табуляции (формат строки `"x[TAB]y[TAB]z"`). Вещественные числа имеют не более 6 десятичных знаков.
### Формат вывода
Выведите параметры , ,  и  соответствующей дороге плоскости. Числа разделяйте пробелами. Выведенные параметры должны задавать корректную плоскость.
### Пример 1
| | |
| --- | --- |
| **Ввод** | **Вывод** |
|
```
0.01
3
20 0 0
10 -10 0
10 10 0
```
|
```
0.000000 0.000000 1.000000 0.000000
```
|
### Пример 2
| | |
| --- | --- |
| **Ввод** | **Вывод** |
|
```
0.01
3
20 0 3
10 -10 2
10 10 2
```
|
```
-0.099504 0.000000 0.995037 -0.995037
```
|
### Пример 3
| | |
| --- | --- |
| **Ввод** | **Вывод** |
|
```
0.01
10
20 -10 0.2
20 0 0.2
20 10 0.2
15 -10 0.15
15 0 0.15
15 10 0.15
10 -10 0.1
10 10 0.1
20 18 1.7
15 -15 1.2
```
|
```
-0.010000 0.000000 0.999950 0.000000
```
|
Данные примеры — синтетические. В реальном облаке точек объектов значительно больше: поработайте над edge-кейсами.
### Где порешать
[Попробовать свои силы можно на Контесте](https://contest.yandex.ru/contest/12698/enter/)
### Разбор и готовый код
**Разбор**
Сначала давайте задумаемся над тем, что должны представлять из себя входные данные. Больше 50% точек, как сказано в условии, относятся к дороге, остальные, как мы можем догадаться, — к другим объектам, которые возвышаются над дорогой. Это могут быть другие автомобили, пешеходы, столбы и т. д. Их возвышение над дорогой может быть достаточно большим по сравнению с заданной величиной отклонения точек дороги .
Получается, для решения задачи нам нужен метод оценки параметров модели, устойчивый к большому количеству выбросов. Одним из таких методов является RANSAC ([ссылка](https://ru.wikipedia.org/wiki/RANSAC) на Википедию). Метод итеративно перебирает гипотезы (наборы параметров модели), построенные по случайно выбранным точкам, и выбирает из гипотез лучшую.
Применительно к задаче шаг его итерации можно описать так:
* Берем случайные три точки, вычисляем по ним параметры плоскости (гипотезу).
* Оцениваем, насколько гипотеза хороша — сколько точек с учетом заданного порога  можно отнести к плоскости дороги, а сколько нужно признать «выбросами».
* Обновляем лучшую гипотезу, если текущая оказалась лучше.
В базовом варианте шаг реализовывается довольно просто. Ниже — пример кода. Пример не является продакшен-кодом и опирается на то, что входные данные соответствуют описанию задачи.
**Код на C++**
```
#include
#include
#include
#include
#include
#include
#include
struct Point3d {
double X = 0.0;
double Y = 0.0;
double Z = 0.0;
};
using PointCloud = std::vector;
struct Plane {
double A = 0.0;
double B = 0.0;
double C = 0.0;
double D = 0.0;
};
bool CreatePlane(
Plane& plane,
const Point3d& p1,
const Point3d& p2,
const Point3d& p3) {
const double matrix[3][3] =
{{ 0, 0, 0}, // this row is not used
{p2.X - p1.X, p2.Y - p1.Y, p2.Z - p1.Z},
{p3.X - p1.X, p3.Y - p1.Y, p3.Z - p1.Z}};
auto getMatrixSignedMinor = [&matrix](size\_t i, size\_t j) {
const auto& m = matrix;
return (m[(i + 1) % 3][(j + 1) % 3] \* m[(i + 2) % 3][(j + 2) % 3] -
m[(i + 2) % 3][(j + 1) % 3] \* m[(i + 1) % 3][(j + 2) % 3]);
};
const double A = getMatrixSignedMinor(0, 0);
const double B = getMatrixSignedMinor(0, 1);
const double C = getMatrixSignedMinor(0, 2);
const double D = -(A \* p1.X + B \* p1.Y + C \* p1.Z);
const double norm\_coeff = std::sqrt(A \* A + B \* B + C \* C);
const double kMinValidNormCoeff = 1.0e-6;
if (norm\_coeff < kMinValidNormCoeff) {
return false;
}
plane.A = A / norm\_coeff;
plane.B = B / norm\_coeff;
plane.C = C / norm\_coeff;
plane.D = D / norm\_coeff;
return true;
}
double CalcDistance(const Plane& plane, const Point3d& point) {
// assume that the plane is valid
const auto numerator = std::abs(
plane.A \* point.X + plane.B \* point.Y + plane.C \* point.Z + plane.D);
const auto denominator = std::sqrt(
plane.A \* plane.A + plane.B \* plane.B + plane.C \* plane.C);
return numerator / denominator;
}
int CountInliers(
const Plane& plane,
const PointCloud& cloud,
double threshold) {
return std::count\_if(cloud.begin(), cloud.end(),
[&plane, threshold](const Point3d& point) {
return CalcDistance(plane, point) <= threshold; });
}
Plane FindPlaneWithFullSearch(const PointCloud& cloud, double threshold) {
const size\_t cloud\_size = cloud.size();
Plane best\_plane;
int best\_number\_of\_inliers = 0;
for (size\_t i = 0; i < cloud\_size - 2; ++i) {
for (size\_t j = i + 1; j < cloud\_size - 1; ++j) {
for (size\_t k = j + 1; k < cloud\_size; ++k) {
Plane sample\_plane;
if (!CreatePlane(sample\_plane, cloud[i], cloud[j], cloud[k])) {
continue;
}
const int number\_of\_inliers = CountInliers(
sample\_plane, cloud, threshold);
if (number\_of\_inliers > best\_number\_of\_inliers) {
best\_plane = sample\_plane;
best\_number\_of\_inliers = number\_of\_inliers;
}
}
}
}
return best\_plane;
}
Plane FindPlaneWithSimpleRansac(
const PointCloud& cloud,
double threshold,
size\_t iterations) {
const size\_t cloud\_size = cloud.size();
// use uint64\_t to calculate the number of all combinations
// for N <= 25000 without overflow
const auto cloud\_size\_ull = static\_cast(cloud\_size);
const auto number\_of\_combinations =
cloud\_size\_ull \* (cloud\_size\_ull - 1) \* (cloud\_size\_ull - 2) / 6;
if (number\_of\_combinations <= iterations) {
return FindPlaneWithFullSearch(cloud, threshold);
}
std::random\_device rd;
std::mt19937 gen(rd());
std::uniform\_int\_distribution distr(0, cloud\_size - 1);
Plane best\_plane;
int best\_number\_of\_inliers = 0;
for (size\_t i = 0; i < iterations; ++i) {
std::array indices;
do {
indices = {distr(gen), distr(gen), distr(gen)};
std::sort(indices.begin(), indices.end());
} while (indices[0] == indices[1] || indices[1] == indices[2]);
Plane sample\_plane;
if (!CreatePlane(sample\_plane,
cloud[indices[0]],
cloud[indices[1]],
cloud[indices[2]])) {
continue;
}
const int number\_of\_inliers = CountInliers(
sample\_plane, cloud, threshold);
if (number\_of\_inliers > best\_number\_of\_inliers) {
best\_plane = sample\_plane;
best\_number\_of\_inliers = number\_of\_inliers;
}
}
return best\_plane;
}
int main() {
double p = 0.0;
std::cin >> p;
size\_t points\_number = 0;
std::cin >> points\_number;
PointCloud cloud;
cloud.reserve(points\_number);
for (size\_t i = 0; i < points\_number; ++i) {
Point3d point;
std::cin >> point.X >> point.Y >> point.Z;
cloud.push\_back(point);
}
const Plane plane = FindPlaneWithSimpleRansac(cloud, p, 100);
std::cout << plane.A << ' '
<< plane.B << ' '
<< plane.C << ' '
<< plane.D << std::endl;
return 0;
}
```
**Комментарии к коду**
Посмотрим на кусок кода, представленного выше:
```
const double matrix[3][3] =
{{ 0, 0, 0}, // this row is not used
{p2.X - p1.X, p2.Y - p1.Y, p2.Z - p1.Z},
{p3.X - p1.X, p3.Y - p1.Y, p3.Z - p1.Z}};
auto getMatrixSignedMinor = [&matrix](size_t i, size_t j) {
const auto& m = matrix;
return (m[(i + 1) % 3][(j + 1) % 3] * m[(i + 2) % 3][(j + 2) % 3] -
m[(i + 2) % 3][(j + 1) % 3] * m[(i + 1) % 3][(j + 2) % 3]);
};
const double A = getMatrixSignedMinor(0, 0);
const double B = getMatrixSignedMinor(0, 1);
const double C = getMatrixSignedMinor(0, 2);
const double D = -(A * p1.X + B * p1.Y + C * p1.Z);
```
В этих строках выполняется вычисление параметров плоскости по трем точкам ([ссылка](https://ru.wikipedia.org/wiki/%D0%9F%D0%BB%D0%BE%D1%81%D0%BA%D0%BE%D1%81%D1%82%D1%8C#%D0%A3%D1%80%D0%B0%D0%B2%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BF%D0%BB%D0%BE%D1%81%D0%BA%D0%BE%D1%81%D1%82%D0%B8) на Википедию). В первой строке  должны стоять элементы ,  и . Если вычислять определитель этой матрицы через алгебраические дополнения для первой строки, то дополнения войдут в итоговое выражение как коэффициенты при ,  и , то есть будут как раз коэффициентами ,  и  плоскости.
При выборе случайной тройки индексов можно дополнительно учитывать, какие тройки уже встречались. Для этого можно завести unordered\_set и записывать в него идентификаторы троек. | https://habr.com/ru/post/524244/ | null | ru | null |
# Одноэкземплярные приложения на Qt
Сейчас я активно пишу под Qt. И встала у меня задачка проверить при запуске приложения, а не запущено ли оно уже. Под линуксом. Велосипеды городить не хотелось, хотелось родить что-то используя готовые классы Qt, чтобы сразу было кроссплатформенно. В винде, например, есть готовое решение — именованные мьютексы (или семафоры, неважно, главное именованные). Стал гуглить. Ага, в Qt есть нечто подобное, называется `QSystemSemaphore`. Работает так:
— создаем экземпляр класса `QSystemSemaphore`, он создает глобальный (системный) семафор
— вызываем `acquire`, уменьшаем счетчик семафора на единицу
— что-то делаем
— вызовом `release`, увеличиваем счетчик семафора на единицу
Вобщем класический семафор, только глобальный. Понятно, что если создать семафор с изначальным значением счетчика равным 1 и вызвать `acquire`, то пока мы не вызовем `release` никто больше не сможет этот семафор захватить. Ура, решение найдено! Вырисовывается сразу следующий код одноэкземплярного приложения:
— создаем семафор
— захватываем
— приложение работает
— после завершение работы приложение освобождает семафор
Все здорово, все прекрасно. Документация обещает нам, что даже если не вызвать `release` (например программа скрашилась) система все равно вернет в семафор все захваченные у него единицы. Но возникает проблема. Если пользователь запустит второй экземплар приложения — как он об этом узнает? Вызов метода `acquire` блокирующий и пока семафор не освободиться приложение будет «висеть», а пользователь в недоумении чего-то ждать.
Казалось бы — не проблема. Например тот же `QMutex` помимо вызова `lock` для захвата мьютекса имеет вызов и `try_lock` для неблокирующей попытки захвата. Должно что-то подобное быть и у системного семафора. Но — увы — его нет. Я долго и безуспешно гуглил — на форумах полно подобных тем и ни одного работающего решения. Проблема? Проблема. Интересная? Весьма. Я взялся ее решать.
При помощи одного `QSystemSemaphore` очевидно ничего не разрешится. Что в Qt еще есть из глобального? Еще есть `QSharedMemory`. Разделяемая между разными приложениями память. Работает так:
— создаем экземпляр класса `QSharedMemory`
— вызываем `attach` для подсоединения к уже созданной памяти
— если подсоединитсья не удалось — вызываем `create` чтобы создать разделяемую память
— работаем с разделяемой памятью (например передаем какие-то данные в другой процесс)
— деструктор сам вызывает `detach` и отсоединение от разделяемой памяти
Казалось бы — вот оно! Если вызов `attach` прошел успешно, значит приложение уже запущено. Если нет — приложение запущено впервые, вызываем `create` и, таким образом, закрепляем свое право первенства в вопросе владения разделяемой памятью (т.е. у всех остальных `attach` будет происходить успешно уже). Проблемы здесь, собственно, две.
Первая — гонки. Два процесса могут одномервменно вызвать `attach`, потрепеть неудачу, оба будут считать что они — первые и вызовут `create`. Один создаст память, другой — потерпит неудачу. Нехорошо, но, вобщем, терпимо. Можно обойти.
Вторая проблема посерьезнее. Оказывается линуксовая реализация `QSharedMemory` устроена так, что если для памяти не будет вызван `detach` она не разрушается. Проще говоря, если процесс присоединился к разделяемой памяти, а затем аварийно завершился, то память останется созданной. И следующий вызов `attach` пройдет успешно. Т.е. аварийное завершение единственного экземпляра приложения приведет к тому, что больше ни одного экземпляра приложения создано не будет. Мда.
Таким образом имеем два класса — `QSystemSemaphore` и `QSharedMemory`, каждый из которых отчасти реализует нужную функциональность, но полностью конечную задачу не решает. Может быть удасться два этих «недокласса» гармонично сочетать?
И таки да! `QSystemSemaphore` решает первую проблему `QSharedMemory`, проблему гонок. Код:
```
QSystemSemaphore sema("", 1);
bool isRunning;
sema.acquire();
QSharedMemory shmem("");
if (shmem.attach())
{
isRunning = true;
}
else
{
shmem.create(1);
isRunning = false;
}
sema.release();
```
Проще говоря глобальный семафор синхронизирует управление разделяемой памятью. Как говорится, элементарно, Ватсон.
Вторая проблема, как оказалось, тоже имеет решение. Довольно смешное. Чтобы линуксовая реализация разделяемой памяти проверила счетчик ссылок на нее и разрушила ее, если ссылок больше нет, достаточно присоединиться к ней и отсоединиться. И если в результате аварийного завершения предыдущего экземпляра приложения осталась неразруженая разделяемая память с нулевым (фактически) счетчиком ссылок подсоединение к ней и немедленное отсоединение разрушит эту память. А если счетчик ссылок ненулевой — он останется прежним. Что, вобщем, и требуется.
Окончательно код выглядит так:
```
QSystemSemaphore sema("", 1);
bool isRunning;
sema.acquire();
{
QSharedMemory shmem("");
shmem.attach();
}
QSharedMemory shmem("");
if (shmem.attach())
{
isRunning = true;
}
else
{
shmem.create(1);
isRunning = false;
}
sema.release();
```
Ясно, что второй экземпляр класса `QSharedMemory` нужно сохранить до конца работы приложения. И тогда все работает именно так, как нужно. | https://habr.com/ru/post/173281/ | null | ru | null |
# Всё по полочкам: тематическая веб-аналитика в Интернете с Рамблер/топ-100, часть 2. Аналитика блоков
Продолжаем серию статей об исследовании поведения посетителей сайтов с помощью Рамблер/топ-100. В прошлый раз мы [рассказали](https://habrahabr.ru/company/rambler-co/blog/327436/), как можно оценить популярность разного контента на сайте с помощью отчета «Разделы сайта». Теперь мы попробуем оценить эффективность различных элементов страницы, а также изучим эффективность перекрестного продвижения контента (например, системы рекомендаций) и проанализируем эффективность заголовков.
Каждый менеджер — управляет ли он продуктом или проектом, — хочет знать всё о том, как работает подконтрольный ему интерфейс сайта. В первую очередь возникают простые вопросы: куда кликают люди на конкретной странице? Как работает вот этот блок интерфейса сам по себе и насколько он более кликабельный в сравнении с соседним? Какой CTR у целевой кнопки?
Каждая страница контентного сайта, как правило, тесно связана с другими — для удержания посетителей важно постоянно предлагать им интересные материалы, повышая время нахождения на сайте и глубину просмотра. Давайте поднимемся на уровень выше и попробуем оценить популярность контента по другим параметрам: по кликабельности (CTR) названий рубрик, заголовков материалов, блоков рекомендаций и других навигационных элементов страницы. Рамблер/топ-100 имеет удобный инструмент для такой оценки — отчет «Аналитика блоков», в котором есть три показателя: показы блоков, клики по блокам и CTR (отношение кликов к показам).
### Аналитика блоков на примере отчета по Рамблер/лайкам
В 2016 году Рамблер запустил конструктор кнопок соцсетей [Рамблер/лайки](https://likes.rambler.ru). Рассмотрим на примере Рамблер/лайков, как работает «Аналитика блоков». Но сперва несколько слов про сами Лайки. В конструкторе Рамблер/лайков можно выбрать разные соцсети, настроить внешний вид кнопок и их поведение, а в итоге вы получите код виджета с кнопками для вставки на сайт. При проектировании Лайков мы хотели позволить пользователям виджета смотреть статистику по установленным кнопкам. Из всех инструментов для сбора данных о поведении пользователей, доступных в Рамблер/топ-100, выбор пал на «Аналитику блоков»: с её помощью можно получить информацию по кликабельности кнопок на каждой странице с нужной детализацией.
Кнопки в оригинальном виджете уже размечены data-атрибутом rambler-share, который виден любому счетчику Топ-100. Данные по кнопкам можно увидеть в отчете «Поведение / Рамблер/лайки», если на вашем сайте установлены счетчик Топ-100 и кнопки соцсетей.
При загрузке страницы с установленным виджетом Лайков в счетчик Топ-100 передается событие **bl**, содержащее для каждой кнопки соцсети параметры вида: **rambler-share::domain::page\_url::social\_network**. При клике на любую кнопку уходит событие **cl** с таким же путем. В результате в отчете по Рамблер/лайкам мы видим показы, клики и CTR для каждой кнопки соцсети на каждой странице сайта.
Данные по кликам суммируются на каждом следующем уровне так, что можно посмотреть общее количество попыток отправки в соцсети с помощью кнопок. Если один счетчик стоит на нескольких доменах, можно смотреть статистику в разбивке по доменам. Данные по показам для верхних уровней вычисляются методом суммирования максимального значения среди подуровней и значения показов цепочек с укороченным путем (без подуровней). Для виджета Рамблер/лайков это не актуально, так как виджет работает целиком, при его нормальной работе невозможна ситуация, когда нет кнопок.
При необходимости, разметку можно вручную дополнить уровнями, чтобы собирать более детализированные данные. Например, как это сделано на Рамблер/новостях, где установлено три виджета Лайков в разных частях страницы, а к разметке добавлен верхний уровень, уточняющий расположение блока. Это позволяет смотреть статистику по каждому виджету кнопок отдельно и сравнивать их между собой.
Забегая вперед, стоит отметить, что при разметке блоков можно использовать существующую структуру страницы: для каждого div указывать соответствующий иерархии уровень разметки. Далее мы рассмотрим этот способ более подробно.
### Подробнее о разметке
Как видно из примера выше, с помощью отчета «Аналитика блоков» можно анализировать кликабельность различных элементов на странице. Фактически, это управляемая вами карта кликов для всех страниц сайта: вы сами выбираете, какие элементы для вас важны и как они иерархически упорядочены, и получаете подробную статистику по их CTR.
Это, конечно, не магия — для сбора данных придется немного покодить: разметить интересующие блоки data-атрибутами и передать их в код инициализации счетчика в качестве значений параметра attributes\_dataset. При указании этого параметра на сайт будет загружен модуль счетчика Топ-100 **usability.js**, который начнет сбор данных. Код для сбора по размеченным блокам подключается отдельным модулем, чтобы упрощенная версия счетчика Топ-100 была максимально легкой.
Теперь поговорим о том, как собираются данные. После загрузки страницы счетчик «слушает» переданные ему data-атрибуты и фиксирует показы загруженных размеченных блоков. Такое «прослушивание» происходит несколько раз за показ страницы, чтобы собрать показы элементов, загруженных позднее. Клики регистрируются непосредственно при соответствующем действии посетителя. Отчет «Аналитика блоков» иерархический: на верхнем уровне вы увидите переданные data-атрибуты, каждый из которых можно развернуть в дерево глубиной до 8 уровней (глубина зависит от настроенной разметки). Несколько уровней могут быть полезны для страниц со сложной иерархической структурой, для которых нужно измерять эффективность как конкретных ссылок, так и целых блоков со ссылками. CTR вычисляется как отношение кликов к показам на каждом уровне. Пример кода инициализации счетчика с подключением модуля «Аналитики блоков» будет ниже, а пока давайте поговорим о самой разметке.
Мы рекомендуем начать с проектирования разметки на бумаге, а потом перейти к внедрению на сайт. Для начала стоит определить цели сбора данных. Например, какой информации не хватает для оценки эффективности сайта и его страниц? Информацию о каких действиях посетителей необходимо собрать, чтобы получить достаточно данных для оценки? Собранные данные должны отвечать на поставленные вами вопросы и быть удобными для чтения, поэтому важно выбрать оптимальное количество атрибутов и придумать понятные названия для всех необходимых уровней. Подход «давайте разметим всё, а потом разберемся», как правило, приводит к многочисленным вопросам и изменениям разметки в будущем. Что в свою очередь делает отчет нечитаемым на длинных временных отрезках: одинаковые данные собираются в разные ветки. То же самое касается варианта, когда разметку придумывает разработчик, а не менеджер, впоследствии работающий с отчетом. При выборе неудачных названий велик шанс, что уже через пару недель будет сложно вспомнить, какие данные собраны по тому или иному параметру и зачем они нужны.
### Настраиваем разметку и интерпретируем результаты
Вернемся к нашему примеру из [первой статьи](https://habrahabr.ru/company/rambler-co/blog/327436/) цикла с контентным сайтом для школьников и родителей. Рассмотрим вариант разметки для двух страниц: главной и типовой страницы статьи. Предположим, на главной странице есть следующие смысловые блоки: шапка, панель навигации, популярные материалы, новые материалы, рекомендации, материалы партнеров. На странице статьи: шапка, панель навигации, рекомендации, популярные материалы из того же раздела, популярные материалы (как на главной странице), новые материалы.
К примеру, владелец сайта хочет найти ответы на следующие вопросы:
Какой из блоков с материалами более кликабельный на главной странице и на страницах статей? Материалы из каких разделов привлекают больше внимания? Сколько переходов каждый из разделов получает из блоков с рекомендациями? Статьи из каких разделов обеспечивают больше переходов?
Для этого можно использовать следующую иерархию: Главная страница / Название раздела :: Название блока (меню, рекомендации, популярное, новое) :: Раздел, в который ведет ссылка на материал :: Рубрика :: Название материала / Название раздела (для меню)
Верхний уровень можно задать дата-атрибутами. Единственное неудобство в данном случае будет в том, что дата-атрибут должен быть указан латиницей. Сама разметка может выглядеть так: middleandsenior :: Рекомендации :: Поступление :: Выбор ВУЗа :: 10 причин поступать в МГУ.
В код инициализации счётчика нужно будет передать все значения дата-атрибутов:
```
(function (w, d, c) {
(w[c] = w[c] || []).push(function() {
var options = {
project: PROJECT\_ID,
attributes\_dataset: ['main', 'primary', 'middleandsenior', 'graduation', 'materials']
};
try {
w.top100Counter = new top100(options);
} catch(e) { }
});
var n = d.getElementsByTagName("script")[0],
s = d.createElement("script"),
f = function () { n.parentNode.insertBefore(s, n); };
s.type = "text/javascript";
s.async = true;
s.src =
(d.location.protocol == "https:" ? "https:" : "http:") +
"//st.top100.ru/top100/top100.js";
if (w.opera == "[object Opera]") {
d.addEventListener("DOMContentLoaded", f, false);
} else { f(); }
})(window, document, "\_top100q");
```
Отчет будет выглядеть так:
В данном случае названия data-атрибутов соответствуют названиям разделов. Разметку блоков можно передавать двумя способами: на каждом уровне вложенности передавать полный путь или использовать логическую иерархию страницы. Например, для ссылки на статью «10 причин поступать в МГУ» в блоке рекомендаций на странице материала в разделе «Средняя и старшая школа» разметка будет выглядеть так: data-middleandsenior = рекомендации:: поступление:: выбор ВУЗа::10 причин поступать в МГУ.
Либо так:
```
10 причин поступать в МГУ
```
Благодаря такой разметке будет легко сравнить общую кликабельность ссылок по разным блокам и посмотреть, материалы из каких разделов пользуются наибольшей популярность в каждом из смысловых блоков страниц. Можно также сравнить общую кликабельность страниц различных разделов.
Если в первую очередь хочется сравнивать популярность материалов из разных разделов, можно изменить иерархию так: Главная страница / Название раздела :: Раздел, в который ведет ссылка на материал :: Название блока (меню, рекомендации, популярное, новое) :: Рубрика :: Название материала / Название раздела (для меню).
Аналитику блоков можно использовать для тестирования заголовков. Предположим, стоит задача выбрать для статьи один заголовок из пяти вариантов. Эксперимент предполагает, что одному и тому же пользователю всегда показывается один заголовок, а выборки пользователей одинаковы и однородны. Также предположим, что статьи в блоках рекомендаций ротируются так, что каждый заголовок показывается примерно одинаковое количество раз. Для такой задачи подойдет следующая разметка:
– Заголовок 1 :: Название блока (меню, рекомендации, популярное, новое) :: Главная страница / Название раздела
– Заголовок 2 :: Название блока (меню, рекомендации, популярное, новое) :: Главная страница / Название раздела
– Заголовок 3 :: Название блока (меню, рекомендации, популярное, новое) :: Главная страница / Название раздела
и т.п.
Если одновременно тестируются заголовки для нескольких статей, имеет смысл на верхний уровень добавить идентификатор статьи.
– Статья 1 :: Заголовок 1 :: Название блока (меню, рекомендации, популярное, новое) :: Главная страница / Название раздела
– Статья 1 :: Заголовок 2 :: Название блока (меню, рекомендации, популярное, новое) :: Главная страница / Название раздела
– Статья 2 :: Заголовок 1 :: Название блока (меню, рекомендации, популярное, новое) :: Главная страница / Название раздела
– Статья 2 :: Заголовок 2 :: Название блока (меню, рекомендации, популярное, новое) :: Главная страница / Название раздела
и т.п.
Кстати, наличие такой разметки позволит убедиться в корректности проводимого тестирования — общее число показов каждого из заголовков должно быть примерно одинаковым. Существенные отличия в значениях показов для разных заголовков могут свидетельствовать о неправильно настроенном тесте.
В итоговом отчете можно будет сравнить CTR заголовков для разных статей и посмотреть, в каких блоках какие заголовки лучше сработали.
### TL;DR или краткое содержание
Рамблер/топ-100 предлагает простой инструмент для анализа кликабельности элементов интерфейса — отчет «Аналитика блоков». Добавив в код инициализации счетчика Топ-100 вызов дополнительного модуля и разметив нужные элементы сайта, можно собирать статистику и решать следующие задачи:
* оценивать кликабельность целевых блоков страниц или кнопок и сравнивать их CTR;
* анализировать эффективность разных заголовков материалов;
* изучать CTR блока рекомендаций и конкретных позиций в нём;
* исследовать, как одинаковые блоки работают на разных страницах, как меняется кликабельность во времени;
* сравнивать кликабельность однотипных элементов при A/B или мультивариантном тестировании.
Подробнее о разметке можно прочитать в [документации](https://top100.rambler.ru/doc/guide-rambler-top100.pdf) по работе с JavaScript-счетчиком Топ-100 или в [документации](https://top100.rambler.ru/doc/guide-rambler-top100-protocol.pdf) по работе с протоколом передачи данных напрямую в счетчик. Если у вас остались вопросы, [пишите нам](https://help.rambler.ru/feedback/top100/). | https://habr.com/ru/post/336886/ | null | ru | null |
# Дилетант и back-инжиниринг. Часть 2: Каркас
В прошлый раз я [описал начало](http://habrahabr.ru/post/236899/) моих отношений с обратной разработкой. Прошло еще немного времени и вот, в некоторой степени, результат моих исследований.
Я пытаюсь восстановить исходники по .dll-библиотеке и .pdb-базе. Использование IDA конечно принесло кое-какие результаты, но не удовлетворительные. Возможно я просто недостаточно усидчив. Поэтому я начал с другой стороны — с восстановления каркаса проекта библиотеки. Так как у меня есть .pdb-база я вполне могу это сделать. Теоретически. Теоретически, потому что в базу записывается информация с препроцессированых файлов, а не с исходников. А значит нужно работать дальше.
#### Наполнение
Начну рассказ с теории. Структурно .pdb-база представляет собой набор символов (любая переменная, структура, функция, перечисление, тип, все это — символы) связанных между собой. Символы делятся по типам, и в зависимости от типа могу иметь разные свойства. Считывая свойства можно получить описание структур, функций, переопределений, перечислений, констант, включая связи между всем этим, имена файлов и .obj-модулей в которых находятся функции, и много чего еще. Для доступа к символам существует DIA SDK (Debug Interface Access), она хорошо документирована и разобраться с ней не очень сложно. Единственная «проблема» — DIA из коробки доступен только для C/С++, и если хочется работать на .Net нужно будет поработать перегоняя интерфейс в .Net .dll, но это другая история. Можно просто найти готовый модуль. Лично я выбрал второй вариант найдя Dia2Lib.dll, но в ней некоторые функции переведены неверно (вместо массива в параметре некоторых функций всунули простую переменную).
Возможно есть какое-то готовое решение для генерации кода по .pdb-базе, но я его не нашел. И теперь пишу свое. Пишу я на C#, меньше мороки с памятью, хотя и ценой удобства работы с файлами. Для начала нужны были классы для описания символов. Стандартные (те что из Dia2Lib) немного неудобны. Точнее если хочется вертеть данными в трех степенях свободы они просто этого не выдержат.
**Классы для обработки данных символов**
```
class Member {
public string name;
public int offcet; //сдвиг поля
public ulong length; //размер поля в байтах
public string type; //полный тип поля, с указателями, константами, выравниваем и т.д.
public string access; //уровень доступа
public uint id; //для идентификации одинаковых типов
}
class BaseClass {
public string type;
public int offcet; //для порядка наследования
public ulong length;
public uint id;
}
class Function {
public string name;
public string type;
public string access;
public string filename; //имя файла, где находится функция
public uint id;
}
class Typedef {
public string name;
public string type;
public uint id;
}
class Enum {
public string name;
public uint id;
public SubEnum[] values;
}
class SubEnum {
public string name;
public dynamic value;
public uint id;
}
class VTable {
public ulong count; //размер таблицы
public string type;
public uint id;
}
class SubStructure {
public string name;
public uint id;
}
class Structure {
public string name;
public uint id;
public Member[] members;
public BaseClass[] baseclass;
public Function[] functions;
public Typedef[] typedefs;
public Enum[] enums;
public VTable[] vtables;
public SubStructure[] substructures;
}
```
Банальным перебором символов можно заполнить массивы этих структур и получить основу для каркаса. После начинаются проблемы. Первая проблема, о ней уже говорилось, в базе записаны все структуры с препроцессированых файлов. Как например такая:
**Первый пример не очень нужной структуры**
```
struct /*id:2*/ _iobuf
{
/*off 0x00000000 size:0004 id:5*/ public: char * _ptr;
/*off 0x00000004 size:0004 id:8*/ public: signed int _cnt;
/*off 0x00000008 size:0004 id:5*/ public: char * _base;
/*off 0x00000012 size:0004 id:8*/ public: signed int _flag;
/*off 0x00000016 size:0004 id:8*/ public: signed int _file;
/*off 0x00000020 size:0004 id:8*/ public: signed int _charbuf;
/*off 0x00000024 size:0004 id:8*/ public: signed int _bufsiz;
/*off 0x00000028 size:0004 id:5*/ public: char * _tmpfname;
};
```
Мало кому может пригодится структура из стандартной библиотеки. Но если их еще можно как-то отслеживать, то есть пример похуже.
**Второй пример не очень нужной структуры**
```
struct /*id:24371*/ std::allocator,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node>:/\*0x0 id:24351\*/ std::\_Allocator\_base,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node>
{
//
/\*id:24362\*/ public: \_\_thiscall const std::\_Tree\_nod,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node \* address (const std::\_Tree\_nod,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node &);
//
/\*id:24364\*/ public: \_\_thiscall std::\_Tree\_nod,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node \* address (std::\_Tree\_nod,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node &);
//
/\*id:24367\*/ public: \_\_thiscall void allocator,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node> (const std::allocator,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node> &);
//
/\*id:24372\*/ public: \_\_thiscall void allocator,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node> ();
//:d:\program files\microsoft visual studio .net 2003\vc7\include\xmemory
/\*id:24374 \*/public: void \_\_thiscall std::allocator,class std::allocator >,struct std::less,class std::allocator,class std::allocator > > >,0> >::\_Node>::deallocate(struct std::\_Tree\_nod,class std::allocator >,struct std::less,class std::allocator,class std::allocator > > >,0> >::\_Node \*,unsigned int);
//
/\*id:24376\*/ public: \_\_thiscall std::\_Tree\_nod,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node \* allocate (unsigned int ,const void \*);
//:d:\program files\microsoft visual studio .net 2003\vc7\include\xmemory
/\*id:24378 \*/public: struct std::\_Tree\_nod,class std::allocator >,struct std::less,class std::allocator,class std::allocator > > >,0> >::\_Node \* \_\_thiscall std::allocator,class std::allocator >,struct std::less,class std::allocator,class std::allocator > > >,0> >::\_Node>::allocate(unsigned int);
//
/\*id:24380\*/ public: \_\_thiscall void construct (std::\_Tree\_nod,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node \*,const std::\_Tree\_nod,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node &);
//:d:\program files\microsoft visual studio .net 2003\vc7\include\xmemory
/\*id:24384 \*/public: void \_\_thiscall std::allocator,class std::allocator >,struct std::less,class std::allocator,class std::allocator > > >,0> >::\_Node>::destroy(struct std::\_Tree\_nod,class std::allocator >,struct std::less,class std::allocator,class std::allocator > > >,0> >::\_Node \*);
//
/\*id:24386\*/ public: \_\_thiscall unsigned int max\_size ();
structure /\*id:24353\*/ value\_type;
typedef /\*id:24352\*/std::\_Allocator\_base,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node> \_Mybase;
typedef /\*id:24354\*/std::\_Tree\_nod,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node \* pointer;
typedef /\*id:24355\*/std::\_Tree\_nod,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node & reference;
typedef /\*id:24357\*/const std::\_Tree\_nod,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node \* const\_pointer;
typedef /\*id:24359\*/const std::\_Tree\_nod,std::allocator >,std::less,std::allocator,std::allocator > > >,0> >::\_Node & const\_reference;
typedef /\*id:24360\*/unsigned int size\_type;
typedef /\*id:24361\*/signed int difference\_type;
};
```
И даже если сделать фильтр на стандартные структуры-шаблоны, останется куча особенностей языка, которые разворачиваются или изменяются при трансляции. Как пример могу назвать пользовательские шаблоны.
**Пример развертки шаблонов**
```
struct /*id:16851*/ S_BVECTOR
{
/\*off 0x00000000 size:0016 id:9357\*/ private: std::vector > m\_VECPath;
/\*off 0x00000016 size:0004 id:8\*/ private: signed int m\_nCount;
/\*off 0x00000020 size:0004 id:8\*/ private: signed int m\_nPos;
/\*id:9360 \*/public: \_\_thiscall S\_BVECTOR::S\_BVECTOR(class S\_BVECTOR const &);
/\*id:9362 \*/public: \_\_thiscall S\_BVECTOR::S\_BVECTOR(void);
/\*id:9364 \*/public: void \_\_thiscall S\_BVECTOR::resize(unsigned short);
/\*id:9366\*/ public: \_\_thiscall void addsize (unsigned short );
/\*id:9368 \*/public: void \_\_thiscall S\_BVECTOR::setsize(unsigned short);
/\*id:9369\*/ public: \_\_thiscall void setsizeNew (unsigned short );
/\*id:9370 \*/public: void \_\_thiscall S\_BVECTOR::clear(void);
/\*id:9371 \*/public: void \_\_thiscall S\_BVECTOR::push\_back(struct D3DXVECTOR2 &);
/\*id:9373\*/ public: \_\_thiscall void pop\_front ();
/\*id:9374\*/ public: \_\_thiscall void pop\_back ();
/\*id:9375 \*/public: int \_\_thiscall S\_BVECTOR::size(void);
/\*id:9377 \*/public: bool \_\_thiscall S\_BVECTOR::empty(void);
/\*id:9379\*/ public: \_\_thiscall D3DXVECTOR2 \* front ();
/\*id:9381\*/ public: \_\_thiscall D3DXVECTOR2 \* next ();
/\*id:9382\*/ public: \_\_thiscall D3DXVECTOR2 \* end ();
/\*id:9383 \*/public: struct D3DXVECTOR2 \* \_\_thiscall S\_BVECTOR::operator[](int);
/\*id:9385\*/ public: \_\_thiscall void remove (signed int );
/\*id:9387 \*/public: \_\_thiscall S\_BVECTOR::~S\_BVECTOR(void);
/\*id:9388\*/ public: \_\_thiscall void \* \_\_vecDelDtor (unsigned int );
};
```
Конечно все можно достаточно легко вернуть к первоначальному виду. Но ситуаций где нужна ручная обработка может быть достаточно много. Например для той библиотеки, которую я хочу использовать, в базе записано 2673 структур. Из них только около 250 реально нужных, остальное — развертки шаблонов std и прочие «стандартные» вещи. Остаётся только надеяться что все пройдет без проблем. Ладно, предположим, что заготовки для структур есть. Дальше нужно позаписывать их по файлам.
#### Генерация
Для начала нужны сами файлы для записи. Немного теории. При компиляции каждый исходник с кодом после препроцессора переводится, с помощью компилятора, в машинные коды. С каждого исходника с кодом получается .obj-файл или .o-файл в зависимости от компилятора. При помощи DIA SDK можно получить список всех файлов с каждого .obj-модуля (короче весь список того, что подключаются в #include). О том, как получить список файлов, было рассказано в прошлой статье (ну как рассказано… в общем, [там есть код](http://habrahabr.ru/post/236899/)). Если говорить языком дилетанта — из каждого .obj-модуля можно получить имя исходника, которым был модуль когда-то (у них будут имена одинаковые), и вель список подключаемых библиотек (сюда входят все файлы кроме .cpp, хотя бывают и исключения). После создания общей структуры, и связывания частей между собой, можно приступать к записи структур.
Напрямую получить имя файла, в котором была структура при ее существовании в виде исходника, насколько я знаю, нельзя. Но можно узнать по каким файлам была раскидана реальзация методов структуры. Поэтому я предлагаю просто собирать все файлы, в которые входят функции-методы, выбрать из них тот что будет хедером, записать туда описание, и связать остальные файлы с хедером. Но при получении имени исходника, в которой находится метод может быть неприятный или баг, или проявление ошибки файла. Для получения имени сначала нужно найти по RVA (relative virtual address) список линий исходников, и потом по этому списку линий найти файл в котором есть эти линии. Но иногда количество линий отвечающих методу равно нулю, но имя файла всё равно находится. Причем обычно неправильное имя. Обычно это проявляется при анализе конструктора. Может конструктор просто не рассматривать…
**Пример структуры с битым расположением конструктора**
```
// Над каждой функцией записано имя файла-исходника откуда функция родом. Файлы перед описанием структуры - просто перезапись всех исходников, но без повторений.
//e:\????\kop\project\mindpower\sdk\src\mpfont.cpp
//e:\????\kop\project\mindpower\sdk\src\i_effect.cpp
//e:\????\kop\project\mindpower\sdk\include\i_effect.h
struct /*id:9920*/ CTexList
{
/*off 0x00000000 size:0002 id:1138*/ public: unsigned short m_wTexCount;
/*off 0x00000004 size:0004 id:1778*/ public: float m_fFrameTime;
/*off 0x00000008 size:0016 id:9726*/ public: std::vector >,std::allocator > > > m\_vecTexList;
/\*off 0x00000024 size:0028 id:98\*/ public: std::basic\_string,std::allocator > m\_vecTexName;
/\*off 0x00000052 size:0004 id:8384\*/ public: IDirect3DTexture8 \* m\_lpCurTex;
/\*off 0x00000056 size:0004 id:8130\*/ public: MindPower::lwITex \* m\_pTex;
//:e:\????\kop\project\mindpower\sdk\src\mpfont.cpp[0]
/\*id:9921\*/ public: \_\_thiscall void CTexList::CTexList (const CTexList &);
//:e:\????\kop\project\mindpower\sdk\src\i\_effect.cpp[3]
/\*id:9927\*/ public: \_\_thiscall void CTexList::CTexList ();
//:e:\????\kop\project\mindpower\sdk\src\i\_effect.cpp[2]
/\*id:9929\*/ public: \_\_thiscall void CTexList::~CTexList ();
//:e:\????\kop\project\mindpower\sdk\src\i\_effect.cpp[3]
/\*id:9930\*/ public: \_\_thiscall void CTexList::SetTextureName (const std::basic\_string,std::allocator > &);
//:e:\????\kop\project\mindpower\sdk\src\i\_effect.cpp[16]
/\*id:9932\*/ public: \_\_thiscall void CTexList::GetTextureFromModel (CEffectModel \*);
//:e:\????\kop\project\mindpower\sdk\src\i\_effect.cpp[25]
/\*id:9934\*/ public: \_\_thiscall void CTexList::CreateSpliteTexture (signed int ,signed int );
//:e:\????\kop\project\mindpower\sdk\src\i\_effect.cpp[16]
/\*id:9936\*/ public: \_\_thiscall void CTexList::GetCurTexture (S\_BVECTOR &,unsigned short &,float &,float );
//:e:\????\kop\project\mindpower\sdk\src\i\_effect.cpp[2]
/\*id:9938\*/ public: \_\_thiscall void CTexList::Reset ();
//:e:\????\kop\project\mindpower\sdk\src\i\_effect.cpp[7]
/\*id:9939\*/ public: \_\_thiscall void CTexList::Clear ();
//:e:\????\kop\project\mindpower\sdk\src\i\_effect.cpp[6]
/\*id:9940\*/ public: \_\_thiscall void CTexList::Remove ();
//:e:\????\kop\project\mindpower\sdk\include\i\_effect.h[12]
/\*id:9941\*/ public: \_\_thiscall void CTexList::Copy (CTexList \*);
};
```
Обычно, что и не удивительно, структуры находятся в двух файлах, хедер.h и код.cpp, но есть и другие варианты. Например структура имеет только хедер, или файл с кодом представлен с расширением .inl, или структура вообще нигде, по мнению .pdb-базы, не записана. Я использовал следующий алгоритм. Если в списке файлов, в который входит структура, есть хедер — пишем структуру в хедер, и подключаем его к файлу с кодом, если он есть. Проходим по структуре, составляя список всех типов, что используются. Если тип — структура, и для нее есть список файлов — подключаем хедер этой структуры, иначе записываем эту структуру в начало файла. Есть еще один неприятный момент: структуры очень любят дублироваться. Не имею ни малейшего понятия, почему многие их них встречаются по несколько раз, причем одна за другой (на самом деле не одна за другой, между ними есть много стандартных шаблонов, но если включить фильтр, то одна за другой). При этом свойства\методы у таких структур совпадают, а отличаются они только порядковым номером. Лично я просто отсортировал массив с структурами за именами структур, и при переборе всех элементов сравнивал имя текущего с именем предыдущего. И все заработало.
#### Результат
Хоть все и заработало, но, естественно, не так как хотелось бы. Оно конечно насоздавало кучу файлов, которые в общем отображали, как я надеюсь, структуру исходного проекта, но там такая каша…
**Один из сгенерированных файлов - lwitem.h**
```
//Для удобства читания и уменьшения обьема текста методы удалены
#ifndef __MINDPOWER::LWITEM__
#define __MINDPOWER::LWITEM__
#ifndef _MINDPOWER::LWIRESOURCEMGR_
#define _MINDPOWER::LWIRESOURCEMGR_
struct MindPower::lwIResourceMgr:MindPower::lwInterface
{
//57 методов
};
#endif
#ifndef _MINDPOWER::LWISCENEMGR_
#define _MINDPOWER::LWISCENEMGR_
struct MindPower::lwISceneMgr:MindPower::lwInterface
{
//15 методов
};
#endif
#ifndef _MINDPOWER::LWLINKCTRL_
#define _MINDPOWER::LWLINKCTRL_
struct MindPower::lwLinkCtrl
{
//3 меода
};
#endif
#include lwitypes2.h
#ifndef _STD::ALLOCATOR,STD::ALLOCATOR > >::REBIND\_
#define \_STD::ALLOCATOR,STD::ALLOCATOR > >::REBIND\_
struct std::allocator,std::allocator > >::rebind
{
typedef std::allocator,std::allocator >,std::allocator,std::allocator > > >::\_Node \*> other;
};
#endif
#ifndef \_MINDPOWER::LWIPRIMITIVE\_
#define \_MINDPOWER::LWIPRIMITIVE\_
struct MindPower::lwIPrimitive:MindPower::lwInterface
{
//46 методов
};
#endif
#include d3dx8math.h
#ifndef \_STD::\_NUM\_FLOAT\_BASE\_
#define \_STD::\_NUM\_FLOAT\_BASE\_
struct std::\_Num\_float\_base:std::\_Num\_base
{
//16 свойств-констант
};
#endif
#ifndef \_MINDPOWER::LWIITEM\_
#define \_MINDPOWER::LWIITEM\_
struct MindPower::lwIItem:MindPower::lwInterface
{
//26 методов
};
#endif
#ifndef \_MINDPOWER::LWITEM\_
#define \_MINDPOWER::LWITEM\_
struct MindPower::lwItem:MindPower::lwIItem
{
//12 свойств
//34 метода
};
#endif
#endif
```
Основные ошибки: нету namespace-ов, нету фильтра для стандартных шаблонов и замены их на подключения библиотек, нету внутренней структуры файла, ~~автор дно и пусть не генерит говнокод~~ и многое другое. Короче работы тут еще завалом. На этом пока все, код генератора я прилагаю, может кому-то он пригодится.
[Дилетантский кодогенератор на гитхабе](https://github.com/IGamemaker/PDBCodeGenerator)
Такие дела. | https://habr.com/ru/post/240831/ | null | ru | null |
# If-else-switch
Несколько дней назад кто-то задал вопрос в твиттере, о том, какой из PHP-сниппетов лучше других, и есть ли подход лучше.
Я написал свой ответ в Твиттере в следующем абзаце.
> Поместите `if/else` в фабрику объектов (`factory object`), которая создает полиморфный объект для каждого варианта. Создайте фабрику в '`main`' и перенесите ее в ваше приложение. Тогда цепочка `if/else` будет повторяться только один раз.
>
>
После этого меня попросили привести пример. Твиттер — не лучшее средство для этого, поэтому...
Во-первых, если единственное намерение программиста — это перевести:
```
0->'male',
1->'female'
otherwise -> 'unknown'
```
...тогда рефакторинг №2 будет моим предпочтением.
Однако мне трудно поверить, что бизнес-правила системы не используют этот гендерный код для принятия решений. Я боюсь, что цепочка `if/else/switch`, о которой спрашивали, повторяется во многих других местах кода. Некоторые из операторов `if/else/switch` могут включать целое число, а другие — строку. Не исключено, что вы найдете `if/else/switch`, которые в одном случае используют целое число, а в другом — строку!
Быстрое распространение операторов `if/else/switch` является распространенной проблемой в программных системах. Тот факт, что они повторяются во многих местах, является проблематичным, поскольку при неизбежном изменении таких операторов легко пропустить некоторые из них. Это приводит к хрупкости систем (fragile systems).
Но есть и более серьезная проблема с операторами `if/else/switch`. Это структура зависимостей.
Такие операторы, как правило, имеют случаи, указывающие на модули более низкого уровня. Это часто означает, что модуль, содержащий `if/else/switch`, будет иметь зависимости исходного кода от модулей более низкого уровня.
Это достаточно плохо. Нам не нравятся зависимости, идущие от модулей высокого уровня к модулям низкого уровня. Они препятствуют нашему желанию создавать архитектуры, состоящие из независимо развертываемых компонентов (deployable).
Однако приведенная выше диаграмма показывает, что дело обстоит еще хуже. Другие модули более высокого уровня, как правило, зависят от модулей, содержащих операторы `if/else/switch`. Таким образом, модули более высокого уровня имеют транзитивные зависимости от модулей более низкого уровня. Это превращает операторы `if/else/switch` в магниты зависимостей, которые охватывают большие участки исходного кода системы, превращая систему в жесткую единую монолитную архитектуру без гибкой структуры компонентов.
Решение этой проблемы заключается в том, чтобы разорвать эти внешние зависимости на модулях нижнего уровня. Это можно сделать с помощью простого полиморфизма.
На приведенной выше диаграмме можно увидеть, что модули высокого уровня используют интерфейс базового класса, который полиморфно распространяется на детали низкого уровня. Немного поразмыслив, можно понять, что поведенчески это идентично `if/else/switch`, но с некоторыми особенностями. Решение о том, какому случаю следовать, должно быть принято до того, как высокоуровневые модули задействуют интерфейс базового класса.
Мы вернемся к when через некоторое время, когда будет принято решение. Пока же просто посмотрите на направление зависимостей. Больше нет никакой транзитивной зависимости исходного кода от модулей высокого уровня к модулям низкого уровня. Мы можем легко создать границу компонента, разделяющую их. Мы даже можем развернуть (deploy) модули высокого уровня независимо от модулей низкого уровня. Это обеспечивает приятную гибкость архитектуры.
Еще один момент, который следует учитывать, заключается в том, что реализация `if/else/switch` и полиморфная реализация используют поиск в таблице для выполнения своей работы. В случае `if/else` поиск в таблице является процедурным. В случае switch большинство компиляторов создают небольшую таблицу поиска. В случае полиморфной диспетчеризации векторная таблица встроена в интерфейс базового класса, таким образом, что все три имеют очень похожие характеристики времени выполнения и памяти, при этом один из них не намного быстрее другого.
Так где же принимается решение? Решение принимается, когда создается экземпляр базового класса. Надеюсь, это происходит в хорошем безопасном месте, например в main. Обычно мы управляем этим с помощью класса фабрики.
На приведенной выше диаграмме видно, что модуль высокого уровня использует базовый класс для выполнения своей работы. Каждое бизнес-правило, которое раньше зависело от оператора `if/else/switch`, теперь имеет свой собственный метод вызова в базовом классе. Когда бизнес-правило вызывает этот метод, оно развертывается (`deploy`) до соответствующего модуля низкого уровня. Модуль низкого уровня создается Factory. Модуль высокого уровня вызывает метод `make(x) Factory`, передавая некий маркер x, который представляет решение. `FactoryImpl` содержит единственный оператор `if/else/switch`, который создает соответствующий экземпляр и передает его обратно в модуль высокого уровня, который затем вызывает его.
Еще раз обратите внимание на направление зависимостей. Видите эту красную линию? Это удобная граница компонента. Все зависимости пересекают ее, указывая на модули более высокого уровня.
Будьте осторожны с маркером x. Не пытайтесь сделать его enum или чем-то, что требует объявления над красной линией. Лучше выбрать целое число или строку. Это может быть небезопасно для типов. Действительно, он не может быть безопасным для типов. Но это позволит вам сохранить компонентную структуру вашей архитектуры.
Возможно, вас больше волнует другой вопрос. Этот базовый класс должен иметь метод для каждого бизнес-правила, которое когда-то зависело от решения `if/else/switch`. По мере появления новых бизнес-правил вам придется добавлять все больше методов в базовый класс. А поскольку многие бизнес-правила уже зависят от базового класса, их придется перекомпилировать/переразвернуть, даже если ничего в них не изменилось.
Существует множество способов решения этой проблемы. Я мог бы продолжать этот блог еще на 2000 слов или около того, описывая их. Чтобы избежать этого, я предлагаю вам ознакомиться с принципом разделения интерфейсов (The Interface Segregation Principle) и паттерном Acyclic Visitor.
---
> *Материал подготовлен в рамках курса* [*«Архитектура и шаблоны проектирования»*](https://otus.pw/9yIS/)*. Если вам интересно узнать подробнее о формате обучения и программе, познакомиться с преподавателем курса — приглашаем на день открытых дверей онлайн.*
>
> *Регистрация* [***здесь***](https://otus.pw/74n0/)*.*
>
> | https://habr.com/ru/post/569866/ | null | ru | null |
# Развертывание радиостанции на GNU/Linux. Часть I
Прежде всего, хочу сказать, что я читал на хабре много топиков о развертывании радио, но ни один не дал мне исчерпывающей информации.
Я решил все сделать сам. Это не какой-то проект или стартап, а просто just4fun. Возможно, это покажется полезным для вас.
Итак, я использовал только свободное ПО в развертывании радио-стрима, так что пользователи window$ и ma o$ могут дальше не читать ;). Хотя нет, все же прочитайте, возможно это откроет вам GNU/Linux с новой стороны.
**Что мне нужно от потока вещания:**
* проигрывание музыки
* прямой эфир (голос)
* вышеперечисленное вместе
* всякие штуки вроде заставок, смеха и пр.
* замещающий поток, работающий 24/7 (желательно)
**Стартовые позиции**
* Роутер Dlink DIR-320 (я ~~нищеброд~~ тот еще эконом)
* ПК с Gentoo Linux
* Микрофон обычный за 50 рублей, 1 шт
Микрофон студийный, 1 шт
Накопитель USB 64 Мб
Первым делом была снесена стоковая прошивка роутера, и на ее место встал OpenWRT из транка. Я не буду рассказывать о том, как накатить OpenWRT, это можно прочесть, например, [здесь](http://foss.org.ua/lib/thread.so.552).
Скажу лишь, что **необходимо** перенести корень ФС роутера на внешнюю флешку с помощью block-extroot, ведь встроенной памяти всего 4 мегабайта, а так же включить в параметрах сборки busybox программу useradd.
Итак, прошивка установлена, интернет работает, SSH тоже, заходим по SSH на наш роутер и начинаем разбираться.
**I. Icecast**
Вопроса, 'а что же использовать в качестве стрим-сервера?' у меня не возникало. К тому же, он достаточно стабилен и легковесен.
Устанавливаем icecast на роутер:
```
opkg update
opkg install icecast
```
Почему на роутер? Конечно, компьютер ночью выключен, а планируется 24/7 режим.
Я буду использовать Icecast в песочнице, поэтому создам пользователя icecast.
Конфигурационный файл icecast имеет формат XML
```
#я забыл включить useradd в конфигурацию busybox, использую внешнюю:
opkg install shadow-useradd
useradd icecast -g nogroup
cp /etc/icecast.xml /usr/share/icecast #песочница
vi /usr/share/icecast/icecast.xml #можно установить nano
```
По правде говоря, я вообще использовал kate (kio-sftp) для редактирования этого конфига, впрочем, это значения не имеет.
Конфиг хорошо отдокументирован. Для безопасности нам нужно установить chroot в единицу, а и changeowner в нашего пользователя. Так же обратите внимание, что paths (пути) в таком случае должны быть относительными от basedir, но со слешем в начале. А еще icecast очень не любит создавать пути сам.
В качестве примера, [вот мой конфиг.](http://paste.kde.org/505358/)
В моем случае нужно создать лог-файлы для пользователя icecast:
```
cd /usr/share/icecast
mkdir log
cd log
touch {error,access}.log
cd -
chown -R icecast log
#запускаем сервер
icecast -b -c icecast.xml
```
Веб-интерфейс доступен на [192.168.1.1](http://192.168.1.1):8000
Кстати, добавьте строку
`icecast -b -c /usr/share/icecast/icecast.xml`
в /etc/rc.local, дабы запускать icecast при загрузке роутера.
**II: Fallback-поток**
Я не смогу работать 24 часа в сутки, поэтому мне нужен fallback-поток, который будет замещать основной на том же URL, в случае оффлайна первого.
Окончательный вариант настройки fallback-потока вы найдете во второй части, а пока я буду использовать для этого MPD.
В настройке MPD для icecast нет ничего сложного, сейчас он у меня транслирует параллельно в ALSA и IceCast. Просто установите mpd и откройте ~/.mpdconf, там уже будут настроены и ALSA, и Icecast, нужно только раскомментировать и подправить параметры под себя.
**Допустим, наш основной поток называется */live*, а fallback — */mpd.ogg***
Тогда в icecast.xml следует добавить:
```
/live
/mpd.ogg
1
1
```
Перезапустите icecast (killall наше все), и попробуйте открыть адрес
[192.168.1.1](http://192.168.1.1):8000/live в плеере. Работает? Поехали дальше.
**III: Лезем в интернет**
Пора настроить firewall для принятия соединений извне. Если у вас нет «белого» IP, воспользуйтесь dyndns.org и обратитесь к документации по openwrt.
В /etc/config/firewall внесите следующие строки:
```
#ICECAST
config rule
option src wan
option dest_port 8000
option target ACCEPT
option proto tcp
```
и перезапустите файервол:
`/etc/init.d/firewall restart`
Кстати, по мне, лучший способ проверки — не isup.me, а мобильник :). В общем, поехали дальше
**IV: Настройка клиента**
Клиентская машина, т.е. десктоп — тоже линукс, как я сказал в начале поста.
Для управления радио будем использовать бесплатную открытую, и что главное, непортабельную (Linux only ☻) программу [idjc](https://sourceforge.net/projects/idjc/). Позволю себе процитировать отзыв с SourceForge:
> In the past, I have streamed on Windows XP with both SAM and ShoutCast. After trying Internet DJ Console on Ubuntu Studio, I must say that it was the best streaming experience in my life. Over six hours connected to my server, and it preformed flawlessly. Kudos to those who put this together.
>
>
В портежах Gentoo её не оказалось, а, например, в Ubuntu она [есть](https://sourceforge.net/projects/idjc/). Я собрал программу из исходников. Также мне понадобилось добавить USE-флаг «jack» в /etc/make.conf для установки оного и интеграции с alsa.
Для работы программа требует звуковой сервер JACK (когда меня спрашивают, что из выдающихся программ есть в Linux, но нет в m$, я отвечаю: **Rosegarden, Cinelerra, JACK, Ardour, MythTV**! Ну и idjc).
Другие зависимости: GTK+, pygtk и наличие звуковой карточки с наушниками и микрофоном.
*IV.1 Настройка Jack*
JACK работает в realtime-режиме, так что ему нужно дать где развенуться.
Добавьте себя в группу audio, затем в /etc/security.conf добавьте:
```
@audio - rtprio 99
@audio - memlock unlimited
@audio - nice -10
```
и перелогиньтесь.
Также необходимо создать конфигурационный файл, например:
```echo "/usr/bin/jackd -d -r 44100 -p 256" > ~/.jackdrc
После этого запустите сервер JACK, используя в качестве back-end'а вашу звуковую систему (подо что вы конфиг создавали):
jackd -d
т.е. alsa или pulse
*IV.2 Настройка и использование idjc*
idjc поддерживает множество профилей, мне хватило и одного. Главное окно выглядит так(все кликабельно):
Поддерживаются 2 параллельных плейлиста музыки, плавное переключение между ними (длинный ползунок внизу), внезапное появление ведущего в эфире (правая кнопка снизу), звонки в студию, (телефончики), а также:
* Запись с 4 микрофонов
* Вывод в 6 потоков Icecast/Shoutcast
* Вывод в MP3 и OGG (потоки)
* Запись в FLAC на жесткий диск
Кнопка настроек внизу слева. Preferences и Jingles я рассмотрю во второй части, а сейчас перейдем к Output:
Настройки не умещаются у меня на экране, внизу запись на диск, там ничего интересного.
Вверху можно отметить нужные стримы и подключиться к ним, или изменить шаблон вывода метаданных.
Ниже нажатая кнопка означает, что стрим идет на вкладке Format можно задать формат и битрейт и т.д, т.е. все настолько тривиально, что не вижу смысла выкладывать отдельные скриншоты.
Отмечу, что также можно транслировать названия песен в IRC.
**V. Настройка Skype**
Сначала установите skype ☻ и alsa-plugins. В Gentoo:
emerge alsa-plugins #с USE="jack"`
Затем в файл ~/.asoundrc добавьте:
```
# VoIP plugin for the IDJC default profile.
pcm.idjcvoip {
type plug
slave.pcm {
type jack
playback_ports {
0 idjc-mx_default:voip_in_l
1 idjc-mx_default:voip_in_r
}
capture_ports {
0 idjc-mx_default:voip_out_l
1 idjc-mx_default:voip_out_r
}
}
}
```
и перелогиньтесь.
Кстати, перед любым запуском idjrc обязательно запустите JACK командой jackd -d alsa (подставив pulse, если нужно). Если вы любите графические интерфейсы, воспользуйтесь программой qjackctl.
В скайпе выберите устройство idjcvoip (это работает вообще для любой программы, можно использовать Ekiga или что угодно):
[](http://www.habrastorage.com/images/skype.png)
Чтобы пропустить звук из скайпа в эфир, нажмите на зеленый телефон, убрать - красный.
Спасибо за внимание, продолжение следует.`` | https://habr.com/ru/post/146286/ | null | ru | null |
# GraphQL в мобильной разработке
Всем привет! С вами Анна Жаркова, ведущий разработчик компании Usetech. Сегодня стартует моя серия статей, посвященная работе с технологией GraphQL при разработке мобильных приложений. Если вы интересуетесь применением необычных технологий в мобильной разработке, давно подумывали совместить Android/iOS с GraphQL или попробовать что-то для себя новое, то эти статьи окажутся для вас полезными.
Всего будет три статьи в которых я покажу, как сделать простое мобильное приложение под Android и iOS, имитирующее простую социальную сеть с лентой постов, которые можно не только писать, но и редактировать и удалять, а также лайкать. Еще мы добавим регистрацию и авторизацию.
В этой статье мы поговорим:
* как сделать свой простой бекенд на GraphQL;
* какие решения мы можем использовать.
А в следующих частях рассмотрим:
* как подключать API к нашему приложению с помощью клиентских решений;
* как делать запросы и обрабатывать ответы;
* и какие есть нюансы в работе с Android и iOS.
Технология не новая, но для большинства мобильных разработчиков довольно экзотическая. Поэтому начнем с краткого введения.
GraphQL — это специальный язык запросов и манипулирование данными для API, а также среда для выполнения этих запросов. Технология появилась в 2012 году и была разработана компанией Facebook для личных целей. В 2015 году стала открытой для сторонних пользователей, а в 2019 была создана GraphQL Foundation — нейтральная структура на базе Linux Foundation, занимающаяся развитием GraphQL.
Основной особенностью данной технологии является использование в API особой декларативной структуры запроса, в которой указываются только те поля данных, которые нужны в ответе.
```
query HeroNameAndFriends {
hero {
name
friends {
name
}
}
}
```
Пример запроса GraphQL.
И в ответе гарантировано придут только запрошенные поля и ничего больше.
Давайте посмотрим, чем это отличается от REST API и как работает.
На рисунке внизу представлена схема взаимодействия GraphQL клиента с сервером. Со стороны клиента мы отсылаем запрос с нужными нам полями на интересующий нас endpoint. Далее на стороне сервера происходит выборка данных через специальную схему данных. Определение полей в схеме GraphQL состоит из двух частей: объявлений типов и распознавателей.
Причем схема строится уже поверх БД, в которой хранятся данные, что несколько отличается от того, к чему мы привыкли.
Запросы и ответы тоже отличаются не только содержанием. С одной стороны, это такой же json, как в REST. Оба API:
* предоставляют единый интерфейс для работы с удаленными данными.
* чаще всего на запрос возвращается ответ в формате JSON.
* позволяют дифференцировать запросы на чтение и на запись.
Но если REST нам отдаст всю структуру json, если только бекенд не озаботился и не подготовил специальную выдачу по конкретному endpoint, то GraphQL поможет нам сэкономить трафик. Кроме того, что мы можем запросить только те поля, которые нам нужны, мы можем агрегировать несколько запросов в один, если это позволяет наша схема:
Еще одним плюсом является то, что такое API является самодокументированным.
Однако, чтобы использовать и оценить все преимущества технологии, нам нужно для начала подготовить наш бекенд, потому что автоматически из REST GraphQL запросы не поддерживаются. Также нужно подготовить API и обучить ему наших разработчиков. Ведь они должны четко знать, что им нужно запросить и куда постучаться.
Еще одной особенностью является то, что не все операции REST поддерживаются GraphQL. По сути, мы делаем всегда GET или POST запрос JSON.
Для GraphQL мы используем свои специальные операции, которые необходимо указывать в теле нашего запроса:
* Query — запрос без изменения данных.
* Mutation — запрос на создание/обновление/удаление данных (как POST/ PUT/PATCH/DELETE).
* Subscription — специальная операция, которая позволяет слушать изменения в реальном времени.
Теория, конечно, интересно, но давайте побыстрее перейдем к практике.
Итак, перед нами стоит задача — настроить свой собственный GraphQL сервер. Одними из самых популярных решений являются:
1. Развертывание [Apollo-Server.](https://www.apollographql.com/docs/apollo-server/)
2. Использование облачных решений типа [Amplify](https://docs.amplify.aws/lib/graphqlapi/getting-started/q/platform/js) от Amazon.
3. Использование облачных решений [Hasura](https://hasura.io).
Остановимся на последнем. Представим ситуацию, что у нас нет специального человека, который сделает за нас всю работу на бекенде, и мы, как мобильные разработчики, не хотим тратить много времени на изучение и настраивание серверных технологий. Мы хотим сделать быстро и просто. И Hasura то, что нам нужно. На Хабре уже было несколько статей про подробности использования данной технологии, поэтому переходим к делу.
Итак, заходим на [Hasura](https://hasura.io) и логинимся/создаем аккаунт по одной из доступных опций.
Мы сразу попадаем на специальную [консоль](https://cloud.hasura.io/projects), где будут наши проекты:
Чтобы добавить новый проект, нажмем New Project. В появившемся меню выберем план оплаты и регион:
В большинстве случаев (для любительского использования) нам достаточно бесплатного проекта.
После создания проекта нам доступны его настройки:
Больше всего нас интересует наш endpoint и секретный ключ админа. Вы всегда можете скопировать их из консоли.
Перейдем к консоли проекта и настроим наше API. Нажимаем Launch Console.
Перед нами открывается меню:
На первой вкладке мы видим настройки входной информации для нашего API.
На второй вкладке информация о настройке REST API на основе нашего GraphQL.
Для того, чтобы наше API заработало, идем на вкладку Data и перейдем в менеджер данных.
Нам нужно подключить хранилище базу данных:
Мы можем как использовать существующую базу данных, так и создать свою.
Простым, быстрым и дешевым решениям для нас будет использование Heroky Database:
После создания в левом меню появится база данных по умолчанию (PostgreSQL), в которой мы можем создавать свои таблицы:
Создадим три таблицы для нашей задачи:
* пользователи;
* посты;
* комментарии к постам.
Тут ничего сложного. Поля будут преимущественно текстовые, кроме ключей, для них у нас uuid. Лайки к постам (массив айдишников) можно хранить как поле массива или как десериализованную строку (для удобства).
Добавим таблицы с помощью меню:
Для каждой из таблиц добавляем требуемые нам поля, выбираем тип поля, при необходимости ставим значение по умолчанию или флаг уникальности. Не забудьте о первичном ключе. Для полей ключей лучше выбрать uuid.
При желании можно добавить и внешние ключи, а также правила.
После создания таблицы мы можем как изменить наши поля:
Так и просмотреть наши данные, либо добавить записи вручную:
После того, как все таблицы созданы, мы можем перейти к работе с API.
У GraphQL решений есть удобная утилита Explorer, которая позволяет поиграться с запросами и подобрать нужные нам для портирования уже в наш код.
Перед началом работы не забудьте прописать специальный заголовок и использовать в качестве значений ключ администратора над Explorer:
Этот же заголовок мы будем использовать при обращении из приложения.
В левой части нам доступны наши таблицы со структурами полей, а также шаблоны запросов для агрегации или выборки по первичному ключу. Нажав на любой шаблон, мы можем начать набирать свой запрос. Например, такой для запроса пользователей:
```
query Users($usersId: uuid) {
users(where: {user_id: {_eq: $usersId}}) {
user_email
user_id
user_name
likes
}
}
```
Если мы оставляем фильтрацию, то получим только одного пользователя. Если уберем, то в выборке получим всех.
Запустим запрос и проверим, что он работает:
```
{
"data": {
"users": [
{
"user_email": "anna@mailinator.com",
"user_id": "f06b74ff-0cc7-4411-a6df-dcfc8c41e831",
"user_name": "Anna",
"likes": null
},
{
"user_email": "test@test.com",
"user_id": "244c68b6-dcdb-49a8-8d1f-86431558df32",
"user_name": "Test",
"likes": null
},
{
"user_email": "2345@mailinator.com",
"user_id": "99bc4b7e-c663-4a94-be81-f07aae940a06",
"user_name": "test2",
"likes": null
},
{
"user_email": "newbie@mailinator.com",
"user_id": "28b430be-7ce1-475f-8530-6b80759e814b",
"user_name": "New user",
"likes": null
}
]
}
}
```
Добавить новый запрос или mutation мы можем с помощью нижнего левого меню:
Для примера используем mutation создания нового юзера:
Обратите внимание, что у mutation возникают свои шаблоны. Нам потребуется insert\_users\_one:
```
mutation CreateUser($userId: uuid, $userName: String, $userEmail: String, $userPassword: String) {
insert_users_one(object: {user_name: $userName, user_id: $userId, user_email: $userEmail, password: $userPassword}) {
user_id
user_name
user_email
}
}
```
Такие операции требуют возврата. Укажем поля пользователя в качестве ответа. В Explorer вы можете передавать сразу значений по умолчанию, чтобы проверить работу API.
Добавим оставшиеся запросы. Мы используем Mutation для создания, редактирования и удаления поста. Также через Mutation мы изменяем лайки, добавляем комментарии. Для запросов ленты постов, списка комментариев поста мы используем Query.
Для обновления данных (постов) мы используем шаблон update\_posts, указывая в фильтре idнужного поста. Аналогично для удаления – delete\_posts c фильтром.
```
//Запрос списка постов
query Posts {
posts {
user_name
user_id
post_text
post_id
post_date
likes
image_link
}
}
//Комментарий к посту
query CommentsForPost($postId: uuid) {
comment(where: {post_id: {_eq: $postId}}) {
comment_id
comment_text
user_id
}
}
//Заведение нового поста
mutation CreatePost($postId: uuid, $likes: String, $postText: String, $userId: uuid, $userName: String, $postDate: date, $image: String) {
insert_posts_one(object: {user_name: $userName, user_id: $userId, post_text: $postText, post_id: $postId, post_date: $postDate, image_link: $image, likes: $likes}) {
... post
}
}
//Изменение лайка
mutation ChangePostLike($postId: uuid, $likes: String) {
update_posts(where: {post_id: {_eq: $postId}}, _set: {likes: $likes}) {
returning {
... post
}
}
}
//Редактирование поста
mutation ChangePost($postId: uuid, $postText: String, $image: String) {
update_posts(where: {post_id: {_eq: $postId}}, _set: {post_text: $postText, image_link: $image}) {
returning {
... post
}
}
}
//Удаление поста
mutation DeletePost($postId: uuid) {
delete_posts(where: {post_id: {_eq: $postId}}) {
returning {
post_id
}
}
}
//Запрос поста для юзера – комбинированный запрос
query GetPost($postId: uuid, $userId: uuid) {
posts(where: {post_id: {_eq: $postId}}) {
user_name
user_id
post_text
post_id
post_date
likes
image_link
}
users(where: {user_id: {_eq: $userId }}) {
user_id
user_name
user_email
}
comment(where: {post_id: {_eq: $postId}}) {
comment_id
comment_text
user_id
}
}
//Запрос поста
query GetPostById($postId: uuid) {
posts(where: {post_id: {_eq: $postId}}) {
user_name
user_id
post_text
post_id
post_date
likes
image_link
}
}
//Создание нового пользователя
mutation NewUser($userId: uuid, $userName: String, $userEmail: String, $userPassword: String) {
insert_users_one(object: {user_id: $userId, user_name: $userName, user_email: $userEmail, user_password: $userPassword}) {
... user
}
}
//Пользователь по id
query GetUser($userId: uuid) {
users(where: {user_id: {_eq: $userId}}) {
user_id
user_name
user_email
}
}
//Вход – пользователь по email и паролю
query LoginUser($userEmail: String, $userPassword: String) {
users(where: {user_email: {_eq: $userEmail}, user_password: {_eq: $userPassword}}) {
user_id
user_name
user_email
}
}
```
Обратите внимание, что мы используем и комбинированный запрос для получения данных из нескольких таблиц.
Также мы используем в некоторых таблицах особую агрегационную структуру – фрагменты для объединения полей ответа.
```
//Фрагмент для постов
fragment post on posts {
user_name
user_id
post_text
post_id
post_date
likes
image_link
}
//Фрагмент для комментариев
fragment comment on comment {
comment_id
comment_text
user_id
}
//Фрагмент для пользователей
fragment user on users {
user_id
user_name
user_email
}
```
Запросы можно скопировать куда-нибудь прежде, чем мы пропишем их у себя. В самом проекте они не сохраняются.
Готово. Теперь нам нужно подключить наше API к приложениям. Для обоих приложений мы будем использовать Apollo Client версии для Android или iOS. Это самое простое и популярное решение для работы с GraphQL в мобильном приложении:
* [Android](https://www.apollographql.com/docs/android/)
* [iOS](https://www.apollographql.com/docs/ios/)
Также нам нужно скачать схему. Сделаем это через командную строку или терминал рабочей машины. Будем использовать apollo-codegen, который нужно установить через npm:
```
npm i apollo-codegen
```
Следом используем следующую команду:
```
apollo-codegen download-schema ".hasura.app/v1/graphql" --output schema.json --header "x-hasura-admin-secret: "
```
Нужно указать правильный endpoint вашего проекта и правильный ключ для заголовка.
В том каталоге, где вы вызывали команду, появится файл schema.json. Его мы и будем подключать к нашему проекту в следующих частях.
**Ссылки**
[github.com/apollographql/apollo-android](https://github.com/apollographql/apollo-android)
[www.apollographql.com/docs/android](https://www.apollographql.com/docs/android/)
[hasura.io/docs/latest/graphql/core/index.html](https://hasura.io/docs/latest/graphql/core/index.html)
[graphql.org](https://graphql.org) | https://habr.com/ru/post/645273/ | null | ru | null |
# Пишем мониторинг наличия билетов на РЖД, part 2
[В первой части](http://habrahabr.ru/post/210420/) было показано как написать простейший враппер вокруг существующего http API ржд. В этой части продолжим и напишем действующий мониторинг с уведомлением на почту. Сайт проекта располагается по прежнему [тут](http://rzdzstan0.appspot.com) и [тут запасной](http://rzdzstan1.appspot.com).
В первой части приложение было **не** threadsafe, т.е. в настройках **app.yaml** значилось:
```
threadsafe: false
```
исправим эту ситуацию, изменим:
```
def main():
application.run()
if __name__ == "__main__":
main()
```
на:
```
app = webapp2.WSGIApplication([
('/', MainPage),
], debug=False)
```
Естественно пришлось также переписать немного кода, выигрыш от всего этого следующий: при *threadsafe: false* appengine ставит новые сессии в очередь и запускает для каждой сессии новый инстанс (с небольшим временным лагом), при включенном *threadsafe* подразумевается что разработчик верно реализовал многопоточную логику.
Далее нужно было решить два вопроса: почта и запуск по крону, начнем с крона: для этого нужно создать в рабочей дире файл **cron.yaml** и указать куда и как часто следует обращаться крон демону:
```
cron:
- description: mail summary job
url: /summary_mail
schedule: every 1 hours
```
На
```
/summary_mail
```
повесим обработчик для рассылки на активные аккаунты, а для того чтобы нехорошие дяди не могли его дергать самостоятельно и как следствие — скушать все наши квоты и заспамить активных пользователей, нужно ограничить доступ к нему только для админов и гугл крона, добавим в **app.yaml** строки:
```
- url: /summary_mail
script: web.app
login: admin
```
Список админов для приложения настраивается из консоли администратора (ребята ~~школьники~~ хакеры, не беспокойтесь в данном приложении нет никакой админки и не нужно ее пробовать «пробивать» ибо как следовало из логов при публикации прошлого поста, таки находились специалисты..., данная консоль предоставляется средствами appengine).
Некоторое время я думал — что же делать с почтовой рассылкой, прикручивать стороннюю капчу или делать свою, в итоге пошел по простейшему пути — я использую гугл аккаунт и после прохождения гугл авторизации (есстественно все идет через редирект и никакие пароли я не храню) я получаю почтовый ящик пользователя, на который он и будет получать письма о свободных местах. Фунционал для работы с почтой простейший:
```
def sendMail(account, body):
mail.send_mail(sender = "rzd wrapper support ",
to = account.email(),
subject = "train report",
html = body,
body = body)
```
Да, тело письма в текстовом представлении и html у меня счас одинаковое, но скоро я это исправлю.
Для полноты картины нужно сказать, [что радиоактивные исходники по прежнему тут](https://github.com/zstan/rzd), конечно же я наведу там порядок со временем, так же могут наблюдаться редкие, но ошибки при работе, ибо отвечает РЖД не идеально, и я где мог подстелил соломку, но думается не везде, в целом функционал вполне рабочий, каждый может из исходников запустить свое локальное приложение и допилить его до собсвенных нужд. Крон опрашивает наличие билетов раз в час. На данный момент можно подписаться только на один поезд. В дальнейших планах прикрутить **Jinja2** и сделать более приятный интерфейс, так же попробовать реализовать на APPENGINE интерфейс к [open source морфологии](http://nlp.lsi.upc.edu/freeling/) и сделать что то наподобие спелл чекера. Надеюсь данный сервис будет для когото полезен. | https://habr.com/ru/post/214343/ | null | ru | null |
# Краткий курс компьютерной графики: пишем упрощённый OpenGL своими руками, статья 5 из 6
Содержание основного курса
==========================
* [Статья 1: алгоритм Брезенхэма](http://habrahabr.ru/post/248153/)
* [Статья 2: растеризация треугольника + отсечение задних граней](http://habrahabr.ru/post/248159/)
* [Статья 3: Удаление невидимых поверхностей: z-буфер](http://habrahabr.ru/post/248179/)
* Статья 4: Необходимая геометрия: фестиваль матриц
+ [4а: Построение перспективного искажения](http://habrahabr.ru/post/248611/)
+ [4б: двигаем камеру и что из этого следует](http://habrahabr.ru/post/248723/)
+ [4в: новый растеризатор и коррекция перспективных искажений](http://habrahabr.ru/post/249467/)
* [**Статья 5: Пишем шейдеры под нашу библиотеку**](http://habrahabr.ru/post/248963/)
* [Статья 6: Чуть больше, чем просто шейдер: просчёт теней](http://habrahabr.ru/post/249139/)
### Улучшение кода
** [Статья 3.1: Настала пора рефакторинга](http://habrahabr.ru/post/248909/)
* [Статья 3.14: Красивый класс матриц](http://habrahabr.ru/post/249101/)*
---
### Official translation (with a bit of polishing) is available [here.](https://github.com/ssloy/tinyrenderer/wiki)
---
Пришла пора веселья, давайте для начала смотреть размер [текущего кода](https://github.com/ssloy/tinyrenderer/tree/f037c7a0517a632c7391b35131f9746a8f8bb235):
* geometry.cpp+.h — **218** строк
* model.cpp+.h — **139** строк
* our\_gl.cpp+.h — **102** строки
* main.cpp — **66** строк
Итого **525 строк**. Ровно то, что я обещал в самом начале курса. И заметьте, что отрисовкой мы занимаемся только в our\_gl и main, а это всего 168 строк, и нигде мы не вызывали сторонних библиотек, вся отрисовка сделана нами с нуля!
**Я напоминаю, что мой код нужен только для финального сравнения с вашим работающим кодом! По-хорошему, вы всё должны написать с нуля, если следуете этому циклу статей. Очень прошу, делайте самые безумные шейдеры и выкладывайте в комментарии картинки!!!**
*Чёрные треугольники на рогах — это модель битая слегка, просто мне надоела голова старого негра, а чинить не сильно хочется.*
---
Рефакторим наш код, чтобы он походил на структуру OpenGL
========================================================
Итак, наш main.cpp начинает слегка разрастаться, поэтому давайте его разделим на две части
* **our\_gl.cpp + .h** — это часть, которую мы программировать не можем, грубо говоря, бинарный файл библиотеки.
* **main.cpp** — здесь мы можем программировать что хотим.
Давайте подробнее, что я вынес в **our\_gl**? Фунции построения матриц проекции, вида и перехода к экранным координатам, а также сами матрицы просто глобальными переменными. Ну и функцию-растеризатор треугольника. Всё!
Вот содержимое файла **our\_gl.h** (про назначение IShader чуть позже):
```
#include "tgaimage.h"
#include "geometry.h"
extern Matrix ModelView;
extern Matrix Viewport;
extern Matrix Projection;
void viewport(int x, int y, int w, int h);
void projection(float coeff=0.f); // coeff = -1/c
void lookat(Vec3f eye, Vec3f center, Vec3f up);
struct IShader {
virtual ~IShader();
virtual Vec3i vertex(int iface, int nthvert) = 0;
virtual bool fragment(Vec3f bar, TGAColor &color) = 0;
};
void triangle(Vec4f *pts, IShader &shader, TGAImage ℑ, TGAImage &zbuffer);
```
**В файле main.cpp** осталось всего 66 строк, поэтому я его даю целиком (извините за простыню, но мне этот файл настолько нравится, что я не буду его прятать под спойлер):
```
#include
#include
#include "tgaimage.h"
#include "model.h"
#include "geometry.h"
#include "our\_gl.h"
Model \*model = NULL;
const int width = 800;
const int height = 800;
Vec3f light\_dir(1,1,1);
Vec3f eye(1,1,3);
Vec3f center(0,0,0);
Vec3f up(0,1,0);
struct GouraudShader : public IShader {
Vec3f varying\_intensity; // written by vertex shader, read by fragment shader
virtual Vec4f vertex(int iface, int nthvert) {
varying\_intensity[nthvert] = std::max(0.f, model->normal(iface, nthvert)\*light\_dir); // get diffuse lighting intensity
Vec4f gl\_Vertex = embed<4>(model->vert(iface, nthvert)); // read the vertex from .obj file
return Viewport\*Projection\*ModelView\*gl\_Vertex; // transform it to screen coordinates
}
virtual bool fragment(Vec3f bar, TGAColor &color) {
float intensity = varying\_intensity\*bar; // interpolate intensity for the current pixel
color = TGAColor(255, 255, 255)\*intensity; // well duh
return false; // no, we do not discard this pixel
}
};
int main(int argc, char\*\* argv) {
if (2==argc) {
model = new Model(argv[1]);
} else {
model = new Model("obj/african\_head.obj");
}
lookat(eye, center, up);
viewport(width/8, height/8, width\*3/4, height\*3/4);
projection(-1.f/(eye-center).norm());
light\_dir.normalize();
TGAImage image (width, height, TGAImage::RGB);
TGAImage zbuffer(width, height, TGAImage::GRAYSCALE);
GouraudShader shader;
for (int i=0; infaces(); i++) {
Vec4f screen\_coords[3];
for (int j=0; j<3; j++) {
screen\_coords[j] = shader.vertex(i, j);
}
triangle(screen\_coords, shader, image, zbuffer);
}
image. flip\_vertically(); // to place the origin in the bottom left corner of the image
zbuffer.flip\_vertically();
image. write\_tga\_file("output.tga");
zbuffer.write\_tga\_file("zbuffer.tga");
delete model;
return 0;
}
```
Давайте его разберём детально. Заголовки пропускаем, затем идут глобальные константы: размеры экрана, где находится камера и т.п.
Структуру GouraudShader разберём в следующем абзаце, пропускаем. Затем идёт непосредственно main():
* Чтение модели из .obj файла
* Инициализация матриц ModelView, Projection и Viewport (напоминаю, сами переменные хранятся в модуле our\_gl)
* Проход по модели и её отрисовка
В последнем пункте начинается самое интересное. Внешний цикл проходит по всем треугольникам.
Внутренний цикл проходит по всем вершинам треугольника и для каждой из них вызывает вершинный шейдер.
**Главное назначение вершинного шейдера — посчитать преобразованные координаты вершин. Второстепенное — подготовить данные для работы фрагментного шейдера.**
Что происходит после того, как мы вызвали вершинный шейдер для всех вершин в треугольнике? Мы можем вызвать растеризатор нашего треугольника. Что происходит внутри него мы не знаем (не, ну, мы его сами написали, конечно). Кроме одной интересной вещи. Растеризатор треугольника вызывает **нашу** функцию, которую мы ему даём — фрагментный шейдер. То есть, ещё раз, для каждого пикселя внутри треугольника растеризатор вызывает фрагментный шейдер.
**Главное назначение фрагментного шейдера — это определить цвет текущего пикселя. Второстепенное — мы можем вообще отказаться рисовать этот пиксель, вернув true.**
Пайплайн OpenGL 2 выглядит так:
Поскольку у нас краткий курс графики, пока ограничимся этими двумя шейдерами. В более новых версиях OpenGL появились новые виды шейдеров, которые позволяют создавать геометрию на лету. На этой картинке синим показаны этапы, которые мы программировать не можем, а рыжим те, что можем. По факту, наша main() — это primitive processing. Она вызывает вершинный шейдер. Сборщика примитивов у нас нет, т.к. мы рисуем тупые треугольники напрямую (он у нас склеился с primitive processing). Функция triangle() — это растеризатор, для каждой точки она вызывает фрагментный шейдер и затем делает проверки глубины в z-буфере и так далее.
Всё. Вы знаете, что такое шейдеры, и можете приступать к их программированию.
Как работает моё воплощение шейдеров на примере тонировки Гуро
==============================================================
Давайте разберём те шейдеры, что я привёл в коде **main.cpp**. Как нетрудно догадаться, первый шейдер — это тонировка Гуро.
**Скрытый текст**
Вершинный шейдер читает вершину из .obj файла, погружает её в четырёхмерное пространство (см. предыдущую статью), находит её экранные координаты. Возвращает спроецированную в 3д точку, но перед этим считает коэффициент диффузной освещённости для данной вершины и сохраняет его в соответствующую компоненту вектора varying\_intensity.
Ещё раз код для удобства:
**Скрытый текст**
```
Vec3f varying_intensity; // written by vertex shader, read by fragment shader
virtual Vec4f vertex(int iface, int nthvert) {
varying_intensity[nthvert] = std::max(0.f, model->normal(iface, nthvert)*light_dir); // get diffuse lighting intensity
Vec4f gl_Vertex = embed<4>(model->vert(iface, nthvert)); // read the vertex from .obj file
return Viewport*Projection*ModelView*gl_Vertex; // transform it to screen coordinates
}
```
varying — это зарезервированное слово в языке GLSL, я использовал varying\_intensity в качестве имени просто чтобы подчеркнуть параллель между ними (о GLSL мы поговорим в седьмой статье). Мы сохраняем в структуре varying данные, которые будут интерполированы внутри треугольника, и фрагментный шейдер получит уже интерполированные данные.
Разберём фрагментный шейдер, ещё раз код для удобства:
**Скрытый текст**
```
Vec3f varying_intensity; // written by vertex shader, read by fragment shader
// [...]
virtual bool fragment(Vec3f bar, TGAColor &color) {
float intensity = varying_intensity*bar; // interpolate intensity for the current pixel
color = TGAColor(255, 255, 255)*intensity; // well duh
return false; // no, we do not discard this pixel
}
```
Он вызывается растеризатором для каждого пикселя внутри треугольника. Он получает на вход [барицентрические координаты](https://ru.wikipedia.org/wiki/%D0%91%D0%B0%D1%80%D0%B8%D1%86%D0%B5%D0%BD%D1%82%D1%80%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5_%D0%BA%D0%BE%D0%BE%D1%80%D0%B4%D0%B8%D0%BD%D0%B0%D1%82%D1%8B) для интерполирования данных varying\_.
То есть, интерполированная интенсивность может быть посчитана как varying\_intensity[0]\*bar[0]+varying\_intensity[1]\*bar[1]+varying\_intensity[2]\*bar[2] или просто-напросто скалярным произведением между векторами varying\_intensity\*bar. В настоящем GLSL, конечно, шейдер получает уже готовое значение.
Обратите внимание, что фрагментный шейдер возвращает булевское значение. Его значение легко понять, если посмотреть внуть растеризатора (**our\_gl.cpp**, triangle()):
**Скрытый текст**
```
TGAColor color;
bool discard = shader.fragment(c, color);
if (!discard) {
zbuffer.set(P.x, P.y, TGAColor(P.z));
image.set(P.x, P.y, color);
}
```
Шейдер может отказаться рисовать данный пиксель, тогда растеризатор игнорирует и его z-координату, не обновляя z-буфер. Полезно если мы хотим делать бинарные маски или что ещё вам в голову придёт.
Разумеется, растеризатору и в голову не может прийти то, что придёт в голову вам, поэтому он компилироваться с вашим шейдером заранее не может. Тут нам приходит на помощь абстрактный класс IShader. Уфф, нечасто я пользуюсь абстрактными классами, но тут ровно случай, когда без него было бы плохо. Передавать указатели на функции мне не хочется совсем!
---
Первая модификация
==================
**Скрытый текст**
```
virtual bool fragment(Vec3f bar, TGAColor &color) {
float intensity = varying_intensity*bar;
if (intensity>.85) intensity = 1;
else if (intensity>.60) intensity = .80;
else if (intensity>.45) intensity = .60;
else if (intensity>.30) intensity = .45;
else if (intensity>.15) intensity = .30;
else intensity = 0;
color = TGAColor(255, 155, 0)*intensity;
return false;
}
```
Просто я разрешаю некий фиксированный набор интенсивностей освещения. Вот результат его работы:
**Скрытый текст**
---
Текстурируем модель
===================
Тонировку Фонга пропускаем, её подробно разобрали в комментариях, давайте наложим текстуры. Для этого придётся интерполировать uv-координаты. Ничего нового, просто добавляем матрицу в две строки (uv) и три столбца (текстурные координаты трё вершин).
**Скрытый текст**
```
struct Shader : public IShader {
Vec3f varying_intensity; // written by vertex shader, read by fragment shader
mat<2,3,float> varying_uv; // same as above
virtual Vec4f vertex(int iface, int nthvert) {
varying_uv.set_col(nthvert, model->uv(iface, nthvert));
varying_intensity[nthvert] = std::max(0.f, model->normal(iface, nthvert)*light_dir); // get diffuse lighting intensity
Vec4f gl_Vertex = embed<4>(model->vert(iface, nthvert)); // read the vertex from .obj file
return Viewport*Projection*ModelView*gl_Vertex; // transform it to screen coordinates
}
virtual bool fragment(Vec3f bar, TGAColor &color) {
float intensity = varying_intensity*bar; // interpolate intensity for the current pixel
Vec2f uv = varying_uv*bar; // interpolate uv for the current pixel
color = model->diffuse(uv)*intensity; // well duh
return false; // no, we do not discard this pixel
}
};
```
**Скрытый текст**
---
Normalmapping
=============
Окей, теперь у нас есть текстурные координаты. Но ведь в текстурах можно хранить не только цвет, RGB вполне хватает для представления xyz!
Давайте загрузим вот такую текстуру, которая для каждого пикселя нашей картинки (а не только для вершин, как раньше!) даст вектор нормали.
**Скрытый текст**
Кстати, сравните его с такой картинкой, это та же самая информация, но в другом репере:
**Скрытый текст**
Одна из этих картинок даёт нормальные векторы в глобальной системе координат, а другая в касательной, которая определяется для каждой точки нашего объекта. В этой текстуре вектор z — это нормаль к объекту, вектор x — это вектор главного направления кривизны поверхности, а y — это их векторное произведение.
### Упражнение 1
Скажите, какая из этих текстур дана в глобальных координатах, а какая в касательных к объекту?
### Упражнение 2
Какой формат текстуры предпочтительнее — касательный или глобальный? Почему?
**Пожалуйста, не стесняйтесь (не читая комментариев заранее) дать ответы на эти вопросы в комментариях!**
**Скрытый текст**
```
struct Shader : public IShader {
mat<2,3,float> varying_uv; // same as above
mat<4,4,float> uniform_M; // Projection*ModelView
mat<4,4,float> uniform_MIT; // (Projection*ModelView).invert_transpose()
virtual Vec4f vertex(int iface, int nthvert) {
varying_uv.set_col(nthvert, model->uv(iface, nthvert));
Vec4f gl_Vertex = embed<4>(model->vert(iface, nthvert)); // read the vertex from .obj file
return Viewport*Projection*ModelView*gl_Vertex; // transform it to screen coordinates
}
virtual bool fragment(Vec3f bar, TGAColor &color) {
Vec2f uv = varying_uv*bar; // interpolate uv for the current pixel
Vec3f n = proj<3>(uniform_MIT*embed<4>(model->normal(uv))).normalize();
Vec3f l = proj<3>(uniform_M *embed<4>(light_dir )).normalize();
float intensity = std::max(0.f, n*l);
color = model->diffuse(uv)*intensity; // well duh
return false; // no, we do not discard this pixel
}
};
[...]
Shader shader;
shader.uniform_M = Projection*ModelView;
shader.uniform_MIT = (Projection*ModelView).invert_transpose();
for (int i=0; infaces(); i++) {
Vec4f screen\_coords[3];
for (int j=0; j<3; j++) {
screen\_coords[j] = shader.vertex(i, j);
}
triangle(screen\_coords, shader, image, zbuffer);
}
```
Ключевое слово uniform в GLSL позволяет передавать в шейдеры константы, здесь я в шейдер передал матрицу Projection\*Modelview и её обратную транспонированную для того, чтобы преобразовать нормальные векторы (см. предыдущую статью).
То есть, всё то же, что и раньше, только вектор нормали мы не интерполируем, а берём из заготовленной текстуры, не забыв при этом вектор направления света и вектор нормали преобразовать надлежащим образом.
**Скрытый текст**
---
Блестящие поверхности или specular mapping
==========================================
Продолжаем разговор! Для (дешёвого) обмана глаза мы используем [приближение Фонга](http://en.wikipedia.org/wiki/Phong_reflection_model) для освещения модели. Итоговая засвеченность данного участка составляется из постоянного освещения для всей сцены (ambient lighting), освещённости для матовых поверхностей, которые мы считали до сих пор (diffuse lighting) и освещённости для глянцевых поверхностей (specular lighting):
Засвеченность матовых поверхностей мы считали как косинус угла между вектором нормали и вектором света. То есть, мы предполагали, что поверхность рассеивает свет примерно во всех направлениях. Что происходит для глянцевых поверхностей? В предельном случе (для зеркальных поверхностей) мы имеем засвет если из этого пикселя видим источник света.
Вот картинка:
Если для данной точки освещённость для матовых поверхностей мы считали как косинус угла между векторами **n** и **l**, то теперь нам интересен косинус угла между векторами **r** (отражённый свет) и **v** (направление взгляда).
### Упражнение 3: найдите вектор r, имея векторы n и l
**Скрытый текст**если n и l нормализованы, то **r** = 2**n** <**n**,**l**> — **l**
Напоминаю, что мы засвет для матовой поверхности считали как косинус угла. Но ведь глянцевая отражает источник в гораздо более сфокусированный пучок! Что будет, если мы сделаем то же самое, только этот косинус возведём в десятую степень? Напоминаю, что числа меньше единицы в десятой степени уменьшатся относительно себя же! То есть, десятая степень даст существенно меньший радиус засвета. А сотая ещё меньший. Эта степень хранится в текстуре, которая даёт глянцевость для каждой точки поверхности.
**Скрытый текст**
```
struct Shader : public IShader {
mat<2,3,float> varying_uv; // same as above
mat<4,4,float> uniform_M; // Projection*ModelView
mat<4,4,float> uniform_MIT; // (Projection*ModelView).invert_transpose()
virtual Vec4f vertex(int iface, int nthvert) {
varying_uv.set_col(nthvert, model->uv(iface, nthvert));
Vec4f gl_Vertex = embed<4>(model->vert(iface, nthvert)); // read the vertex from .obj file
return Viewport*Projection*ModelView*gl_Vertex; // transform it to screen coordinates
}
virtual bool fragment(Vec3f bar, TGAColor &color) {
Vec2f uv = varying_uv*bar;
Vec3f n = proj<3>(uniform_MIT*embed<4>(model->normal(uv))).normalize();
Vec3f l = proj<3>(uniform_M *embed<4>(light_dir )).normalize();
Vec3f r = (n*(n*l*2.f) - l).normalize(); // reflected light
float spec = pow(std::max(r.z, 0.0f), model->specular(uv));
float diff = std::max(0.f, n*l);
TGAColor c = model->diffuse(uv);
color = c;
for (int i=0; i<3; i++) color[i] = std::min(5 + c[i]\*(diff + .6\*spec), 255);
return false;
}
};
```
Собственно, тут и объяснять нечего, кроме как коэффициентов. В строчке
```
for (int i=0; i<3; i++) color[i] = std::min(5 + c[i]\*(diff + .6\*spec), 255);
```
Я взял 5 для ambient, 1 для diffuse и .6 для specular. Какие именно брать — вам решать. Это даёт впечатление разных материалов. Чаще всего они даны художником, но в данном случае у меня их нет, поэтому я взял примерно от балды.
**Скрытый текст**
Заключение
==========
Мы научились рендерить весьма правдобоподбные сцены, но освещение ещё далеко от идеала. В следующей статье я расскажу о том, что такое shadow mapping. В одной из ортогональных статей я расскажу о том, как работает новый растеризатор (ничто не мешает запустить этот же код на старом растеризаторе!). | https://habr.com/ru/post/248963/ | null | ru | null |
# Распределение нагрузки на PPTP/L2TP серверы MPD5
Многие провайдеры на постсоветском пространстве самых разных масштабов предоставляют услуги Интернет по VPN туннелю, будь то PPPoE или PPTP/L2TP. О плюсах и минусах такого доступа я не буду рассказывать, т. к. данная тема смело поместиться в отдельную статью. Как правило для такого туннелирования используются либо серьезные железки (Cisco, Juniper, etc), либо софт-роутеры на базе FreeBSD и MPD5. Так вот, в этой статье пойдет речь о балансировке нагрузки на MPD5 серверы. На хабре уже был [подобный топик](http://habrahabr.ru/post/126237/), но там рассматривалось PPPoE, сегодня же разберем ситуацию с PPTP/L2TP.
#### Теория
Самый простейший способ балансировки VPN серверов — это так называемый [Round robin DNS](http://ru.wikipedia.org/wiki/Round_robin_DNS). Выполнив команду nslookup vpn.iformula.ru, увидим следующее:
```
nslookup vpn.iformula.ru
Server: 193.93.236.2
Address: 193.93.236.2#53
Name: vpn.iformula.ru
Address: 10.168.1.103
Name: vpn.iformula.ru
Address: 10.168.1.101
Name: vpn.iformula.ru
Address: 10.168.1.102
```
(*можете попробовать* nslookup yandex.ru *— так же используется Round robin DNS*)
Т.е. Клиент, посылая запрос к DNS серверу получает в ответ первый адрес из списка, запрос второго — следующий адрес и так далее по кругу. В принципе такой балансировки было бы достаточно, если бы не несколько обстоятельств:
* Не все серверы обладают одинаковой конфигурацией и производительностью
* При кратковременно падении одного из серверов, все его клиенты подключаться на оставшиеся сервера
Создается дисбаланс, который естественным путем может сглаживаться достаточно долго.
Выход из этих ситуаций прост: нужно мониторить количество одновременных сессий пользователей и при достижении максимальной нагрузки на сервер или его аварийном отключении, перестать анонсировать в DNS его ip-адрес. Разумеется, мы автоматизируем это с помощью shell скрипта.
#### Практика
1. Нам нужно получить информацию о количестве текущих сессий и максимально-допустимом количестве сессий. В MPD5 есть управление через telnet и webcmd. Я выбрал webcmd, так как в этом случае мне нужно просто получить html страницу и распарсить ее, нежели писать обработчик для telnet CLI на [Expect](http://ru.wikipedia.org/wiki/Expect). Включить web управление:
```
set user $ROOT $PASSWORD admin
set web self 0.0.0.0 5006
```
После перезапуска mpd по адресу [0.0.0.0](http://0.0.0.0):5006 будет доступна различная информация. Получить информацию о сессиях можно так: http://$login:$password@0.0.0.0:5006/cmd?show%20ippool
```
[] show ippool
Available IP pools:
pool1: used 1293 of 2047
```
2. Настроим DNS сервер. Я использую BIND9, который является стандартным в FreeBSD. Я предполагаю, что у вас уже есть настроенный DNS сервер с обслуживаемой зоной. Все что нам нужно, это добавить в эту зону $INCLUDE на автоматически генерируемый файл с списком VPN серверов:
```
$INCLUDE /var/named/etc/namedb/vpn ;
;host names
iformula.ru. IN A 193.93.236.126
```
3. Добавляем скрипт автоматизации в планировщик cron на выполнение каждые 30 минут. Разумеется, запускать скрипт нужно на сервере, где работает DNS демон.
```
echo "*/30 * * * root /usr/local/bin/mpd_balancer" >> /etc/crontab
echo "" >> /etc/crontab
```
#### Разберем скрипт
Параметры:
```
login="foo"
```
# имя пользователя
```
password="bar"
```
# и пароль для доступа к Webcmd MPD5
```
prcload="90"
```
# максимально допустимое количество одновременных сессий на одном сервере в процентах
```
name="vpn.example.com."
```
# имя службы VPN, точка в конце обязательна
```
srvlist="/root/srv"
```
# Пукть к файлу со списком vpn серверов
```
conf="/var/named/etc/namedb/vpn"
```
# путь к генерируемому $INCLUDE со списком vpn серверов, доступных клиентам
```
workdir="/tmp"
```
# директория для временных файлов
Получим HTML страницу с информацией о сессиях:
```
fetch -o $workdir/$ipsrv -q "http://$login:$password@$ipsrv:5006/cmd?show%20ippool" > /dev/null 2>&1
```
Распарсим количество активных и максимальных сессий для сервера:
```
mpdsrv="`cat "$workdir/$ipsrv" | grep used | awk '{print ($3)}' `"
maxloadsrv="`cat "$workdir/$ipsrv" | grep used | awk '{print ($5)}' | tr -d "\015\032" `"
```
Используя консольный калькулятор [bc](http://ru.wikipedia.org/wiki/Bc), посчитаем текущую загрузку сервера в процентах (проценты округляются до целых):
```
loadsrv="`echo "$mpdsrv/($maxloadsrv/100)" | bc`"
```
Если загрузка не превышает заданный процент, добавляем адрес сервера в список доступных, нагруженные и недоступные сервера просто комментируем:
```
if [ "$loadsrv" -lt "$prcload" ]
then
echo "$name IN A $ipsrv" >> $conf
else
echo ";$name IN A $ipsrv" >> $conf
fi
```
Так же, если просто запустить скрипт из консоли, получим вот такие данные:
```
#######################################################################
10.168.1.100 hosts 739 sessions and this is 49% of maximum load
10.168.1.101 hosts 1192 sessions and this is 70% of maximum load
10.168.1.102 hosts 1304 sessions and this is 65% of maximum load
10.168.1.103 hosts 138 sessions and this is 27% of maximum load
10.168.1.104 hosts 24 sessions and this is 24% of maximum load
#######################################################################
```
На основании этих данных можно рисовать красивые графики:
В скрипте используются утилиты bc, fetch и rndc — все это есть в стандартной поставке FreeBSD. Скрипт протестирован на FreeBSD 8.3, для Linux придется заменить fetch на wget. Поддерживает любое количество mpd5 серверов.
Скрипт:
[Ссылка#1](http://blogzadrota.ru/dl/mpd_balancer.gz)
[Ссылка#2](http://rghost.ru/39278086)
[Документация по MPD5](http://mpd.sourceforge.net/doc5/mpd.html)
[Документация по BIND9](https://www.isc.org/software/bind/documentation)
[Справочник по sh](http://www.opennet.ru/docs/RUS/bash_scripting_guide/)
[Блог автора](http://blogzadrota.ru)
Комментарии, предложения, вопросы и замечания приветствуются. Спасибо за внимание. | https://habr.com/ru/post/148144/ | null | ru | null |
# Моё знакомство с виртуальными ассистентами Салют, а также с платформой SmartMarket и SmartApp
Предыстория
-----------
В сентябре 2020 года [Сбер](https://www.sber.ru/) анонсировал семейство виртуальных ассистентов:
* Сбер — мужской голос. Общается официально, к пользователю обращается на "Вы";
* Афина — женский голос. Общается официально, к пользователю обращается на "Вы";
* Джой — женский голос. Общается неофициально, к пользователю обращается на "Ты";
Тогда же запущен инструментарий разработчика [SmartApp Studio](https://smartapp-studio.sberdevices.ru/login) - интерфейс для размещения собственного [SmartApp](https://developer.sberdevices.ru/docs/ru/basics/overview) в платформе [SmartMarket](https://salute.sber.ru/smartmarket/dev).
SmartApp (смартап или в простонародии навык) — это приложение, которое расширяет возможности виртуального ассистента и может дать пользователю не только красивый интерфейс, но и множество способов взаимодействия с ним: голосом, касанием, текстовым вводом, пультом и даже виртуальным геймпадом.
В [SmartApp Studio](https://smartapp-studio.sberdevices.ru/login) собраны инструменты для создания смартапа:
* [*Graph*](https://developer.sberdevices.ru/docs/ru/developer_tools/flow/quick_start/quick_start) — это визуальный конструктор для создания смартапов. Полезен тем разработчикам у которых нет опыта в программировании;
* [*Code*](https://developer.sberdevices.ru/docs/ru/developer_tools/ide/smartappcode_description_and_guide) — среда разработки на языках SmartApp DSL и JavaScript. Для тех кто уже имеет опыт в программировании;
* [*API*](https://developer.sberdevices.ru/docs/ru/developer_tools/amp/smartappapi_description_and_guide) — возможность вынести свой навык за пределы платформы;
24 сентября для сторонних разработчиков Сбером была запущена группа в ТГ [@smartmarket\_community](https://t.me/smartmarket_community). 3-го октября я сам присоединился к этой группе.
Выяснилось, что [смартапы разделяются на типы](https://developer.sberdevices.ru/docs/ru/basics/smartapp):
* *Chat App* - самый обычный и привычный сейчас тип. Текстовый чат между навыком и пользователем;
* *Canvas App* - графический интерфейс. Пользователь взаимодействует с веб-интерфейсом;
* *Native App* - Android-приложение;
* *Provider App* - для нативного подключения контента и услуг;
Прочитав, к тому моменту, совсем скудную документацию всё же решил попробовать развернуть свой Chat App на [SmartApp API](https://developer.sberdevices.ru/docs/ru/developer_tools/amp/smartappapi_description_and_guide).
Хоть я по профессии не программист, но у меня уже были свои навыки на другой платформе и API обеих платформ имеет сходство.
Мои навыки работают как раз по API, так как он даёт большую гибкость, ведь всё в твоих руках.
Что сразу понравилось
---------------------
Не стану описывать процесс портирования навыка, так как это уже даже [в документации](https://developer.sberdevices.ru/docs/ru/platform_services/skills/overview) есть (плюс можете посмотреть [вот этот пример](https://habr.com/ru/post/530854/)), а лишь опишу некоторые вещи, которые я тогда для себя отметил:
1. Голос выбирает ПОЛЬЗОВАТЕЛЬ, а не разработчик. Моё мнение как раз такое же, что выбор должен быть за пользователем. Ведь это он взаимодействует с ассистентом и навыком и ему лучше знать какой голос ему комфортнее слушать. Более того, голос ассистента можно сменить налету (даже внутри смартапа) просто позвав нужного вам ассистента. Для этого нужно сказать "позови <ИМЯ АССИСТЕНТА>" и всё. Узнать какой голос используется пользователем можно из [объекта character](https://developer.sberdevices.ru/docs/ru/developer_tools/amp/smartappapi_description_and_guide/#%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82-character).
2. У каждого ассистента не только свой голос, но и своя цветовая гамма.
3. [auto\_listening](https://developer.sberdevices.ru/docs/ru/developer_tools/amp/smartappapi_description_and_guide/#answer-to-user) - возможность попросить ассистента включать или не включать микрофон после того как он озвучит ответ. Очень полезная штука.
4. [emotion](https://developer.sberdevices.ru/docs/ru/developer_tools/amp/smartappapi_description_and_guide/#answer-to-user) - возможность анимировать иконку ассистента. На текущий момент уже доступно 22 эмоции.
5. Отдельные типы сообщений при входе ([RUN\_APP](https://developer.sberdevices.ru/docs/ru/developer_tools/amp/smartappapi_description_and_guide/#run-app)) и при выходе ([CLOSE\_APP](https://developer.sberdevices.ru/docs/ru/developer_tools/amp/smartappapi_description_and_guide/#close-app)) пользователя из смартапа, а также сообщить платформе об ошибке ([ERROR](https://developer.sberdevices.ru/docs/ru/developer_tools/amp/smartappapi_description_and_guide/#error)).
6. Возможность разбивать текст на экране на несколько блоков ([bubble](https://developer.sberdevices.ru/docs/ru/developer_tools/amp/smartapp_interface_elements)) для улучшения визуализации информации.
Для тестирования смартапов можно использовать приложение [Сбер Салют](https://salute.sber.ru/) ([App Store](https://apps.apple.com/ru/app/%D1%81%D0%B1%D0%B5%D1%80-%D1%81%D0%B0%D0%BB%D1%8E%D1%82/id1520007827), [Google Play](https://play.google.com/store/apps/details#ru.sberbank.sdakit.companion.prod)) на смартфоне или тестировать смартапы прямо на устройствах [SberBox](https://sberdevices.ru/sberbox/) и [SberPortal](https://sberdevices.ru/sberportal/).
Даже если смартап ещё не прошел модерацию, то всегда есть возможность запустить его на том устройстве где вход выполнен под тем же [Сбер ID](https://www.sberbank.ru/ru/person/dist_services/sberbankid), который использовался при создании навыка в [SmartApp Studio](https://smartapp-studio.sberdevices.ru/login). Также относительно недавно появилась возможность давать доступ к неопубликованному смартапу и другим людям. Для этого нужно просто скинуть им[сгенерированную ссылку](https://developer.sberdevices.ru/docs/ru/methodology/testing/smartapp_beta_testing_invitation).
Совсем недавно была добавлена ещё одна классная фишка, которая тоже стала отличительной особенностью платформы - [asr\_hints](https://developer.sberdevices.ru/docs/ru/platform_services/hints_usage).
Возможность подсказывать системе ASR (Automatic Speech Recognition) чего смартап ожидает от пользователя и исходить из этого при построении гипотез:
```
"asr_hints":{"words":["карту","достаточно","себе","беру","возьму","еще","передаю","ход"]}
```
С подсказками система распознавания работает значительно лучше. Проверено - работает!
Chat App
--------
Выбор chat app был обусловлен тем, что на момент запуска платформы сanvas app ещё не был доступен для сторонних разработчиков.
Как сейчас пока ещё недоступен Native App (но уже скоро должен и он быть в доступе).
Не мало времени пришлось потратить на фразы смартапа, которые озвучивает ассистент. Ведь голос ассистента, а значит его пол, выбирается пользователем, а не разработчиком. Плюс к этом обращения на "Вы/Ты" тоже заняло некоторое время, но вот уже 12.10.2020 мой первый chat app прошёл модерацию, а затем был добавлен в каталог приложений.
chat appНо, на тот момент у chat app не было возможности [проигрывать звуки](https://developer.sberdevices.ru/docs/ru/platform_services/sound_library) или [показывать картинки](https://developer.sberdevices.ru/docs/ru/developer_tools/amp/smartapp_interface_elements#%D0%B8%D0%B7%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5). Поэтому я очень ждал запуска и возможности использовать canvas app, так как там такой проблемы не существовало. И вот уже в конце октября canvas app стал доступен для сторонних разработчиков.
Что такое Canvas App?
---------------------
**Canvas App** – это web-приложение (среда исполнения браузер), управление которым реализуется через [assistant-client](https://github.com/sberdevices/assistant-client).
Canvas App открывается внутри WebView ([Android](https://developer.android.com/guide/webapps/webview), [iOS](https://developer.apple.com/documentation/webkit/wkwebview)). HTML, CSS и JS (это frontend) загружается непосредственно в WebView на клиенте (SberBox, SberPortal, мобильное приложение Сбер Салют).
Чтобы не рисовать и не дублировать картинку-схему я взял её из [этой статьи](https://habr.com/ru/company/sberbank/blog/533612/):
Простыми словами как это работает:
* пользователь запускает смартап;
* его запрос через платформу прилетает в webhook смартапа (который был указан в настройках [SmartApp Studio](https://smartapp-studio.sberdevices.ru/login)) в виде текста;
* параллельно этому устройство пользователя загружает страницу (которая также была указан в настройках [SmartApp Studio](https://smartapp-studio.sberdevices.ru/login) — Frontend Endpoint);
* webhook и frontend между собой «общаются» посредством [assistant-client](https://github.com/sberdevices/assistant-client);
* frontend, реагируя на команды от webhook, меняет что-то на экране пользователя, а также сам может передать что-то на webhook, если пользователь совершит некое действие на странице;
Вот так выглядит создание canvas app (с использованием API) в [SmartApp Studio](https://smartapp-studio.sberdevices.ru/login):
Что внутри у canvas app?
------------------------
Webhook может передать данные в frontend с помощью объекта [command](https://developer.sberdevices.ru/docs/ru/developer_tools/amp/smartappapi_description_and_guide):
```
"payload":{
"items":[
{
"command":{
"type":"smart_app_data",
"smart_app_data":{"myTest":"data"}
}
}
]
}
```
Данные, которые указаны значении ключа smart\_app\_data, будут переданы на frontend. Порекомендую обмениваться именно объектами, а не строками.
Существует две версии [assistant-client](https://github.com/sberdevices/assistant-client):
* версия для [ReactJS](https://ru.reactjs.org/docs/getting-started.html) (пример использования можно увидеть [тут](https://github.com/sberdevices/assistant-client/tree/main/examples/todo-canvas-app))
* версия для подключения на странице через script (пример можно увидеть [тут](https://github.com/sberdevices/assistant-client/tree/main/examples/umd-example))
Если [ReactJS](https://ru.reactjs.org/docs/getting-started.html) Вам не знаком, то самый быстрый способ подключить и попробовать [assistant-client](https://github.com/sberdevices/assistant-client) на frontend это использовать script:
```
Это тест canvas app
```
Такой способ подключения тоже был добавлен позднее запуска canvas app и Вы можете о нём не знать, но теперь он есть.
В этом примере подключение [ReactJS](https://ru.reactjs.org/docs/getting-started.html) нужно для работы самого [assistant-client](https://github.com/sberdevices/assistant-client).
Как было сказано ранее [assistant-client](https://github.com/sberdevices/assistant-client) это "мост" между webhook и frontend и он не только обеспечивает работу canvas app, но и даёт нам возможность локального тестирования своих canvas app прямо в браузере на своём компьютере без использования SberBox, SberPortal или приложения Сбер Салют.[Assistant-client](https://github.com/sberdevices/assistant-client) как бы эмулирует конечное устройство пользователя в вашем браузере.
Добавим на страницу в body:
```
var state = { };
const url = new URL(window.location.href);
if (url.searchParams.get('devel') === 'true'){
console.info('Start devel version');
var token = ''; // <- сюда вставляем токен из smartapp-studio (https://github.com/sberdevices/assistant-client/tree/main/examples/umd-example)
var initPhrase = 'запусти НАЗВАНИЕ ВАШЕГО СМАРТАПА'; // <- сюда вставляем активационную фразу своего canvas app
var ac = assistant.createSmartappDebugger({ getState: () => state, token, initPhrase });
}else{
console.info('Start production version');
var ac = assistant.createAssistant({ getState: () => state });
}
var processData = function(command){
console.info('got command',command);
document.getElementById('command').innerHTML = JSON.stringify(command);
}
ac.on('start', (command) => {
let initialData = ac.getInitialData();
for(let i=0; i < initialData.length; i++){
processData(initialData[i]);
}
});
ac.on('data', (command) => {
processData(command);
});
```
Благодаря *assistant.createSmartappDebugger* мы и получаем возможность использовать эту страницу локально и тестировать используя реального ассистента.
Открываем своим браузером URL (где расположена страница) и **указываем параметр *devel***. Например: https://example.ru/frontend.html**?devel=true**
И если Вы всё сделали правильно, то открывшись страница запустит "мост" с платформой и Ваш смартап.
Ваш webhook получив запрос отправит smart\_app\_data и Вы увидите его содержимое на своём экране в div с id "command":
Вместо "*покажи что-нибудь*" можно ввести любой текст и он отправится на webhook точно так же если бы мы сказали это голосом.
*ac.on('start',...)* используется только на старте смартапа. Там мы получаем начальные данные. Например, какой ассистент используется пользователем и smart\_app\_data от нашего webhook.
Далее всё будет приходить в *ac.on('data',...)*.
**ВАЖНО**:
Помните, что ***assistant.createSmartappDebugger*** используется **ТОЛЬКО** **для тестирования**. Во всех остальных случаях **должен использоваться *assistant.createAssistant***.
Так наша страница стала реагировать на данные, которые получены от webhook в *ac.on('data',...)* и в функции *processData* вы можете их обрабатывать и менять что-то на странице в зависимости от пришедших данных. Например проиграть звук (с помощью [Audio()](https://developer.mozilla.org/en-US/docs/Web/API/HTMLAudioElement/Audio)) или отобразить картинку/видео.
Теперь нужно сделать обратную связь от frontend к webhook. Нужно это для того, чтобы мы смогли обработать какое-то действие пользователя на этой странице.
Например нажатие на кнопку. В приложении Сбер Салют и на Sberportal пользователь может нажать на кнопку пальцем (touch), а на SberBox пультом.
Добавляем кнопку в body страницы:
```
Далее
```
В script делаем обработчик по нажатию этой кнопки с отправкой на webhook команды (для примера) в виде названия id элемента кнопки:
```
var el = document.getElementById("next");
el.addEventListener(
"click",
function(){
ac.sendData({ action: { action_id: el.id} });
},
false
);
```
Если пользователь нажмёт на такую кнопку, то согласно коду выше в webhook придет сообщение с типом [SERVER\_ACTION](https://developer.sberdevices.ru/docs/ru/developer_tools/amp/smartappapi_description_and_guide/#server-action):
```
{
"messageId":1612645866245327000,
"sessionId":"130618ec-8cf5-4a64-83e6-29e0dc6deeb1",
"messageName":"SERVER_ACTION",
"payload":{
"server_action":{"action_id":"next"},
"message":{"original_message_name":"SERVER_ACTION"}
}
}
```
И таким образом можно обработать это сообщение на webhook согласно логике смартапа и webhook отправит на frontend свой ответ на эту команду.
В canvas app ограничений практически нет *(на сегодняшний день известно лишь об ограничениях на использование localstorage, а также камеры и микрофона устройства).*
Для одного из своих canvas app я даже применил [websocket](https://developer.mozilla.org/ru-RU/docs/Web/API/WebSocket) и это работает. Проблем с созданием многопользовательских сетевых canvas app у Вас не должно возникать.
Поле для вашего творчества практически безгранично.
Исходный код примера, который описан мной выше, можно скачать на [github](https://github.com/subnetsRU/sber/tree/master/canvas-example).
Отмечу, что благодаря существованию [github pages](https://pages.github.com/) Ваш frontend может быть размещён на github.
Так я создал canvas версию для своего chat app и при этом webhook у них один и тот же.
canvas appОчевидно, что canvas app уже совсем другой уровень взаимодействия с пользователем и делает смартап более реалистичным.
Помните, что смартапы типа canvas app должны корректно отображаться на разных устройствах (SberBox, SberPortal и другие). Для этого необходимо проверять смартап на следующих разрешениях: 559x568, 768x400, 959x400, 1920x1080.
Настроить и протестировать эти разрешения можно в Chrome на [вкладке Devices](https://developers.google.com/web/tools/chrome-devtools/device-mode).
Планы
-----
Мои дальнейшие планы это не только создать ещё несколько canvas app, но попробовать монетизировать смартап. SmartMarket [предоставляет возможность](https://developer.sberdevices.ru/docs/ru/developer_tools/monetization) встроить в смартап приём платежей от пользователей посредством [API](https://developer.sberdevices.ru/docs/ru/payment_tools/common_buying_process).
Заключение
----------
В заключении хочу сказать несколько вещей:
* при отладке canvas app не забывайте посматривать в консоль браузера (F12);
* клиенты (устройства) кешируют страницу и поэтому рекомендую всегда выводить на экран номер версии;
* на данный момент canvas app нельзя запустить только в приложении СберБанк Онлайн, но вскоре эта возможность появится и там;
* стали появляться первые [видео уроки от Сбера](https://www.youtube.com/playlist?list=PLCjIBdZ4kPo0PVkDsOtwZn6O3IkT7_dqR);
* есть [система тикетов](https://github.com/sberdevices/salute-issues/issues) где Вы можете заявить о проблеме или сделать запрос на новый функционал;
* есть[Community roadmap](https://github.com/sberdevices/salute-issues/projects/1) где можно посмотреть статусы тикетов;
* напомню про само сообщество - [@smartapp\_studio](https://t.me/smartapp_studio);
Хочу сказать спасибо команде [SberDevices](https://sberdevices.ru/) за открытость (особенно за общие встречи с сообществом в zoom) и конечно за то, что прислушиваетесь к мнению сообщества. Это безусловно ваше преимущество перед другими.
Также хочу поблагодарить пользователей моего смартапа, благодаря которым я смог выиграть в [первом этапе конкурса](https://sberdevices.ru/devaward/). Спасибо, что оценили мои старания.
Желаю всем успехов ! | https://habr.com/ru/post/541522/ | null | ru | null |
# Oauth 2 провайдер за 30 минут
 Представим, что в один прекрасный день вы решаете подключить oauth2 к своему проекту на ruby on rails. Так как аутентификация большинства rails приложений сейчас идет через [devise](https://github.com/plataformatec/devise), то неплохо было бы заинтегрировать oauth2 с этим гемом. Благо, все придумали до нас, поэтому встречайте — [devise\_oauth2\_providable](https://github.com/socialcast/devise_oauth2_providable). С этим гемом интеграция и тестирование oauth2 провайдера у вас отнимет времени не больше, чем поход в магазин.
Итак, приступим. Редактируем Gemfile и добавляем туда следующую строчку.
```
gem 'devise_oauth2_providable'
```
Как обычно запускаем bundle. Далее, необходимо создать табличку clients, где будут храниться все данные oauth-клиентов. К счастью, разработчики гема позаботились о том, чтобы нам не пришлось писать миграцию ручками
```
class CreateOauth2Schema < ActiveRecord::Migration
def self.up
Devise::Oauth2Providable::Schema.up(self)
end
def self.down
Devise::Oauth2Providable::Schema.down(self)
end
end
```
В модель, которой вы хотите дать возможность аутентифицироваться через oauth2, добавим следующую строку:
```
devise :oauth2_providable, :oauth2_refresh_token_grantable, :oauth2_authorization_code_grantable
```
Вот и все. Осталось только это дело протестировать.
Для этого тоже есть готовая штука [devise-oauth2-provider-client](https://github.com/aganov/devise-oauth2-provider-client), написанная на синатре.
Для начала, создадим в модельке Client тестовый клиент:
```
Client.create(
:name => "Sinatra Client",
:redirect_uri => "http://localhost:9393/oauth/callback",
:website => "http://localhost:9393/",
:identifier => "120094574673767",
:secret => "b54dc82476af2814e620b86776c42c0e"
)
```
Затем, склонируем репозиторий и поставим гемы, которые просит приложение с помощью bundle.
Далее, заходим в папку client, редактируем метод get '/oauth/callback'. Там необходимо будет поправить строчку
```
access_token.get('/me').body
```
И земенить '/me', на ту страничку, которую нам отдаст главное приложение после успешного логина. Пусть это будет главная страница для теста:
```
access_token.get('/').body
```
Запускаем сервер:
```
bundle exec shotgun
```
На 9393м порту стартует сервер синатры.
Заходим на страничку <http://localhost:9393/oauth/start> и если все было сделано правильно, то нас редиректит на 3000й порт с рельсовым приложением, там подтверждаем доступ Sinatra Client, возвращаемся назад уже авторизованными, и нам показывается главная страничка нашего рельсового приложения. | https://habr.com/ru/post/126753/ | null | ru | null |
# Анимация во Framer для начинающих
**Что такое [Framer](http://framerjs.com/) ?**
Framer это программа для создания прототипов, в которой прототип создается сразу в коде, на языке **[CoffeeScript](http://coffeescript.org/)**, который компилируется в **JavaScript.**
Framer позволяет создавать интерактивные анимации, облегчает разработчикам понимание того, как прототип должен функционировать и как представленную анимацию можно воплотить в жизнь. Еще он учит дизайнера понимать код.
Созданный с помощью Framer прототип можно отдавать тестировать клиентам прямо с девайса в натуральную величину, при этом времени на его создание значительно меньше, чем если бы прототип создавали разработчики.
Как может показаться в начале, Framer — сложная программа, требующая знания кода, хотя на самом деле писать код в ней намного легче, чем кажется.
Для работы с Framer достаточно нарисовать прототип в Sketch или Photoshop и придумать взаимодействие между слоями. Также здесь можно создавать свои слои, анимировать и менять их свойства.
Само написание кода во Framer интересный и увлекательный процесс, который не требует особой подготовки, к тому же на сайте программы есть очень подробная документация с примерами и туториалами.
В анимации, о которой речь пойдет дальше, я хотела отобразить loading, где проценты загрузки выполняют роль индикатора процесса.
Для создания данной анимации нужно знать 4 вещи: Layer, State, Event, Animation.
**Layer** — слой, может быть создан непосредственно во Framer либо им может быть любой слой из Sketch или Photoshop.
**State**— это состояние объекта (слоя). Например, объект будет иметь какое то default состояние (такое, каким мы его нарисовали в Sketch или Photoshop) и бесконечное число состояний, которые мы ему можем дать, меняя его свойства (прозрачность, тень, размытость, размеры, положение и т.д.)
**Event** — это событие. Им может быть клик, swipe, drag, scroll и тд. При возникновении каждого из этих событий, мы можем менять состояния объектов (State), анимируя слои.
**Animation** — кроме состояний, мы можем создавать непосредственно во Framer либо задавать слоям, анимации (например вращение, изменение прозрачности и тд).
Итак, приступим к созданию анимации.
В результате у нас должно получиться следующее:
**1 Шаг:**
Рисуем прототип в Sketch или Photoshop.
Я пользовалась Sketch. Скачать мой прототип можно [здесь.](https://drive.google.com/file/d/0B0GKY4tnXzapNk5ZLXAwUzU3Z1E/view)
Импортируем этот прототип во Framer.
Sketch (или Photoshop) с прототипом при импорте должны быть открыты.
В Framer выбираем тип девайса (иконка Viewer), в моем случае это iPhone 6+.
Так как мой прототип Sketch нарисован в маштабе 1:1, а для iPhone 6+ мы пользуемся множителем 3, то при импорте выбираем из выпадающего списка @3x и не забываем об этом (после, при описании позиции объекта по x и y координатам, которые можно посмотреть в Sketch, мы их умножаем на 3 соответственно).
Все слои в Sketch должны быть объединены в группы, только так они будут видимыми во Framer. Импорт не произойдет, если название хоть одной группы будет начинаться с цифры (выдаст ошибку).
После импорта должна появиться слудующая строчка:
```
# Import file "iPhone_loading" (sizes and positions are scaled 1:3)
Sketch = Framer.Importer.load("imported/iPhone_loading@3x")
```
“loading @3x” — означает, что прототип импортировался с множителем 3х, который мы предварительно выбрали. “Sketch” можно заменить любым словом или знаком (например $) — и ставить его впереди описания каждого слоя из Sketch прототипа. Например, в Sketch прототипе все слои включены по умолчанию, но поскольку верхние слои нас пока не интересуют, мы можем сделать их прозрачными:
Sketch.loadingfinish.opacity = 0 или можно написать $.loadingfinish.opacity = 0
где $ = Sketch
loadingfinish — это самый верхний слой.
Для того, чтобы не писать постоянно Sketch.слой или $.слой можно вставить следующую строчку:
```
Utils.globalLayers $
```
тогда чтобы сделать слой loadingfinish прозрачным, достаточно написать:
```
loadingfinish.opacity = 0
```
Детальнее про Utils можно прочитать во Framer документации [здесь.](http://framerjs.com/docs/)
Здесь я оставила знак $.
Далее зададим для слоя header родительский элемент (SuperLayer), по отношению к которому header будет дочерним.
```
$.header.superLayer = Framer.Device.screen
```
Теперь header — дочерний элемент экрана девайса, а значит всегда будет видимым и неподвижным.
**2 Шаг:**
Задаем дальше параметры для слоев loadingfinish, oval, textButton, bgorange, ovalsecond, делая их прозрачными:
```
$.loadingfinish.opacity = 0
$.oval.opacity = 0
$.textButton.opacity = 0
$.bgorange.opacity = 0
$.ovalsecond.opacity = 0
```
Меняем положение y координаты для слоев textButton, blueButton, buttonbg, loadingfinish, loadingbg, time, text, чтобы они сдвинулись по вертикали либо вверх (значение с минусом), либо вниз. Как видим, мы установили для слоя loadingfinish прозрачность и сдвинули его вниз на 100px.
```
$.loadingfinish.y = 100
$.textButton.y = 3201
$.blueButton.y = 3201
$.buttonbg.y = 3201
$.loadingbg.y = 3201
$.time.y = -100
$.text.y = 3201
```
Для слоя line меняем x координату, чтобы слой выдвигался слева по горизонтали.
```
$.line.x = -1700
```
И наконец для слоя blueButton устанавливаем scale = 0, чтобы слой исчез.
```
$.blueButton.scale = 0
```
В итоге мы получили слой с пустыми белыми прямоугольниками.
Дальше нам нужно, чтобы при клике на второй прямоугольник сверху, появлялся оранжевый круг, расширялся (заливая оранжевым цветом белый прямоугольник), и затем увеличивался на весь экран. Для этого мы создаем новый слой (которого нет в Sketch прототипе), называем его Rectangle и задаем ему параметры как в CSS.
Первоначально это квадрат с заданными параметрами высоты и ширины (436px), оранжевого цвета, расположенный точно по центру белого прямоугольника( x: 410, y: 730). Чтобы из него получился круг, мы задаем ему border radius равный половине стороны(436/2 = 218px), делаем его невидимым с помощью параметра scale:0.
```
Rectangle = new Layer
width: 436
height: 436
backgroundColor: "#FF7841"
borderRadius: 218
x: 410
y: 730
scale: 1
```
В JavaScript это бы выглядело так:
```
(function () {
var Rectangle;
Rectangle = new Layer({
width: 436,
height: 436,
backgroundColor: '#FF7841'
borderRadius: 218,
x: 410,
y: 730,
scale: 1
});
}.call(this));
```
Как видим, в CoffeeScript, в отличие от JavaScript, нет многочисленных кавычек и запятых, тут они заменяются пробелами — поэтому следим, чтобы параметры в описании объекта начинались с новой строки через 3 пробела, иначе будет выдавать ошибку.
**3 Шаг:**
Чтобы наш круг из невидимого стал видимым, а потом собственно прямоугольником, задаем ему новые состояния с помощью Rectangle.states.add:
```
Rectangle.states.add
toFront:
scale:0.5
toRectangle:
scale: 1
opacity: 1
x: 37
y: 727
width: 1168
height: 436
borderRadius: 12
All:
scale:7
time:1.1
```
Мы добавили 3 состояния:
toFront (назвать можно как угодно) — при этом состоянии круг становится в половину больше
toRectangle — круг становится прямоугольником с параметрами точно такими же, как белый прямоугольник в нашем Sketch файле.
All — прямоугольник разворачивается на весь экран. Здесь мы также задали время 1.1 секунд, с которым это происходит.
**4 Шаг**
Теперь создаем событие (Events) — Клик (Click), при котором круг начнет трансформироваться согласно заданным состояниям (States).
Клик будет идти на второй прямоугольник сверху, который называется в Sketch прототипе слоем second.
Пишем — $.second.on Events.Click — что на человеческом языке читается так — при клике на второй прямоугольник происходит следующее — и описываем что именно:
```
$.second.on Events.Click, ->
Rectangle.states.switch("toFront", curve: "spring(300, 30, 0)")
Utils.delay .2, ->
Rectangle.states.switch("toRectangle", time: 1, curve: "easy")
Utils.delay 1, ->
Rectangle.states.switch("All", time: 1, curve: "ease out")
```
Состояние Rectangle переключается на toFront, потом 0,2 секундная задержка ( Utils.delay .2) — затем переключается на toRectangle — задержка 1 секунда ( Utils.delay 1) и последнее переключение на состояние All. Здесь также задаются параметры curve и time — меняя их, анимация будет происходить по разному.
Получаем:
**5 Шаг**
Дальше нам нужно задать состояния для остальных слоев, которые мы определили в начале. Пишем:
```
$.text.states.add
Show:
y: 921
$.time.states.add
Show:
y: 321
$.line.states.add
Show:
x: 36
$.buttonbg.states.add
Show:
y:1509
$.blueButton.states.add
Show:
scale:1
y: 1773
Extend:
scale: 10
$.textButton.states.add
Show:
opacity: 1
y:1845
$.loadingbg.states.add
Show:
y:0
$.oval.states.add
Show:
opacity: 1
$.loadingfinish.states.add
Succes:
y: 861
opacity: 1
```
Для слоя blueButton мы добавили 2 состояния — в первом (Show) он просто показывается, во втором (Extend) — расширяется на весь экран.
**6 Шаг:**
Теперь мы должны уничтожить Rectangle, который мы создали, чтобы он не мешал остальным слоям. Мы пишем:
```
Rectangle.on "end", ->
Rectangle.destroy()
$.bgorange.opacity = 1
$.text.states.switch("Show", time: 1.2, curve: "ease")
$.time.states.switch("Show", time: 1.2, curve: "ease")
$.line.states.switch("Show", time: .8, curve: "spring(500, 50, 0)")
$.buttonbg.states.switch("Show", time: 2, curve: "easy out")
$.blueButton.states.switch("Show", time: 2, curve: "easy")
$.textButton.states.switch("Show", time: 2, curve: "easy out")
```
Что означает — когда Rectangle закончил свои трансформации — он уничтожается (destroy), на его месте показываются указанные нами слои, согласно своим, заданным ранее, состояниям. Слои меняют свои состояния с определенным нами временем и по определенной нами кривой (например: time: 1.2, curve: “ease”)
Не забываем обновлять экран ( ⌘+R ).
Получаем:
**7 Шаг:**
Теперь нам нужно создать текстовый слой — который будет отображать проценты при loading.
```
textLabel = new Layer
width: 500
height: 150
backgroundColor: null
textLabel.center()
# Style text
textLabel.style.color = "#fff"
textLabel.style.fontSize = "100px"
textLabel.style.fontFamily = "Proxima Nova"
textLabel.style.lineHeight = "100px"
textLabel.style.textAlign = "center"
```
Задаем ему backgroundColor: null, то есть пустой (если backgroundColor мы не укажем, то он по умолчанию станет синим) и выравниваем по центру всего экрана благодаря функции textLabel.center().
Описываем параметры стиля # Style text.
Причем заметим, что мы не пишем какой именно текст будет отображаться, иначе мы бы написали html: “какой то Text”.
Чтобы менялись проценты мы добавим строчку кода в конце.
А пока нам нужно вспомнить, что в Sketch прототипе есть слой под названием “Oval”, который должен крутиться вокруг своей оси. Чтобы это происходило — мы создаем новую анимацию и называем ее “spinLoad”.
```
spinLoad = new Animation
layer: $.oval
properties:
rotation: 760
time: 2
curve: "easy"
```
Rotation мы поставили 760 — значит он будет крутиться 2 полных оборота и 40 градусов дополнительно (360 + 360 + 40). Можно поставить любое значение градусов.
Добавляем еще одну анимацию showTextLabel:
```
showTextLabel = new Animation
layer: textLabel
properties:
opacity: 1
time: 4
curve: "easy"
```
Теперь создаем условие, при котором будет начинаться смена процентов при вращении овала. Пишем:
```
$.oval.on "change:rotation", ->
percentage = Utils.modulate $.oval.rotation, [0,760], [0,100]
textLabel.html = Utils.round percentage, 0
```
Тут мы тоже поставили градус вращения овала 760, а смену процентов — от 0 до 100 (то есть за 2,4 оборота овала проценты сменяться от 0 до 100).
**8 Шаг:**
Все, указанные выше, анимации, будет происходить при нажатии на кнопку “Save” (слой blueButton), поэтому создаем новое событие клик (Events.Click) :
```
$.blueButton.on Events.Click, ->
$.blueButton.states.switch("Extend", time: 1, curve: "easy in")
$.loadingbg.states.switch("Show", time: .5, curve: "spring(500, 50, 0)")
$.textButton.states.switch("default")
$.oval.states.switch("Show", time: 1, curve: "easy in")
spinLoad.start()
Utils.delay 1.5, ->
showTextLabel.start()
```
Что означает — по клику на кнопку, голубой бэкграунд (слой blueButton) начинает расширяться (состояние Extend), слой loadingbg меняет свое состояние на “Show”, текст “Save” на кнопке возвращается к своему первоначальному состоянию: $.textButton.states.switch(“default”) (то есть исчезает), появляется овал и запускается анимация spinLoad.start(), даем задержку 1,5 секунд и запускаем анимацию showTextLabel.start().
И наконец, последнее условие — после того, как проценты дойдут до 100 и овал совершит все свои обороты, должен появиться круг с галочкой, означающий успешное завершение операции.
```
spinLoad.on Events.AnimationEnd, ->
$.loadingfinish.states.switch('Succes')
$.oval.opacity = 0
textLabel.opacity = 0
```
Получаем итоговую анимацию!
Автор: Абросимова Надежда, дизайнер интерфейсов. | https://habr.com/ru/post/277565/ | null | ru | null |
# Интерактивная игра на XSLT
Когда-то давным-давно придумали люди язык XML и увидели, что это хорошо. И стали использовать его везде, где можно, и даже там, где не следует. Форматы хранения и передачи данных, конфиги, веб-сервисы, базы данных… Казалось, оглянись вокруг — XML, XML повсюду. Время прошло, люди одумались, насочиняли разных других форматов данных (или спрятали XML внутри архивов) и XML-безумие как-бы приутихло. Но с тех славных пор практически любая система умеет в XML и интегрировать такие системы (кто сказал Apache Camel?) лучше и проще всего, используя XML-документы.
А где XML, там и XSLT — язык, предназначенный для преобразования XML-документов. Язык этот специализированный, но обладает свойством [полноты по Тьюрингу](https://www.unidex.com/turing/utm.htm). Следовательно, язык пригоден для «ненормального» использования. Вот, например, существует [решение задачи о 8 ферзях](https://habr.com/ru/post/203004/). Значит, можно и игру написать.
Для нетерпеливых: рабочая программа на [JSFiddle](https://jsfiddle.net/b2zft5cx/), исходники на [GitHub](https://github.com/yakov-bakhmatov/tic-tac-toe-xslt).
Любая программа занимается преобразованием входных данных в выходные. В программе можно выделить три части: препроцессор, процессор и постпроцессор. Препроцессор готовит входные данные к дальнейшей обработке. Процессор занимается основной работой по преобразованию данных, при необходимости «подмешивая» пользовательский ввод и внешние сигналы и события, в том числе в цикле. Постпроцессор нужен для преобразования результатов работы процессора в пригодный для восприятия человеком (или другими программами) вид.
В случае интерактивной игры на XSLT каждая из трёх частей программы будет представлять собой отдельный XSLT-файл. Препроцессор подготовит игровое поле. Процессор применит ход игрока-человека, сделает ход игрока-компьютера и определит победителя. Постпроцессор отрисует состояние игры.
Программе на XSLT нужна среда исполнения (рантайм). Самый распространённый рантайм, способный исполнять XSLT — это любой [современный браузер](https://developer.mozilla.org/en-US/docs/Web/API/XSLTProcessor#Browser_compatibility). Будем использовать XSLT версии 1.0, так как она поддерживается браузерами «из коробки».
### Немного о XSLT и XPath
XSLT — это язык преобразования XML-документов; для доступа к частям XML-документа используется язык XPath. Спецификации этих языков опубликованы на сайте w3.org: [XSLT Version 1.0](https://www.w3.org/TR/1999/REC-xslt-19991116/) и [XPath Version 1.0](https://www.w3.org/TR/1999/REC-xpath-19991116/).
Основы использования и примеры применения XSLT и XPath легко ищутся в сети. Здесь же я обращу внимание на особенности, которые нужно учитывать при попытке использования XSLT как «обычного» языка программирования высокого уровня общего назначения.
В XSLT есть именованные функции. Они объявляются элементом
и вызываются таким образом:
Функции могут иметь параметры.
Объявление:
```
```
Вызов функции с параметрами:
```
```
Параметры могут иметь значения по-умолчанию.
Параметры могут быть «глобальными», приходящими извне. При помощи таких параметров в программу будет передаваться пользовательский ввод.
Также язык позволяет объявлять переменные, которые могут быть связаны со значением. Параметры и переменные являются иммутабельными и значения им могут быть присвоены один раз (совсем как в Erlang-е, например).
XPath определяет четыре базовых типа данных: строка, число, булево и набор узлов (node-set). XSLT добавляет пятый тип — фрагмент результирующего дерева (result tree fragment). Этот фрагмент выглядит как node-set, но с ним можно совершать ограниченный набор операций. Его можно скопировать целиком в выходной XML-документ, но нельзя получить доступ к дочерним узлам.
```
1
2
3
4
```
В переменной board находится фрагмент XML-документа. Но к дочерним узлам нельзя получить доступ. Такой код не валиден:
Лучшее, что можно получить, это доступ к текстовым узлам фрагмента и работа с ними как со строкой:
вернёт «2».
Из-за этого в нашей игре доска (или игровое поле) будет представлено в виде строки, чтобы ей можно было произвольно манипулировать.
XSLT позволяет проитерировать node-set при помощи конструкции xsl:for-each. Но привычных циклов for или while язык не имеет. Вместо них можно использовать рекурсивный вызов функций (итерация и рекурсия изоморфны). Цикл вида for x in a..b будет организован примерно так:
```
```
### Пишем рантайм
Для работы программы нужны: 3 XSLT, исходный XML, ввод пользователя (параметры), XML внутреннего состояния и выходной XML.
Размещаем в [html-файле](https://github.com/yakov-bakhmatov/tic-tac-toe-xslt/blob/master/runtime.html) текстовые поля с идентификаторами: «preprocessor-xslt», «processor-xslt», «postprocessor-xslt», «input-xml», «parameters», «output-xml», «postprocessed-xml». Также размещаем /> для встраивания результата в страницу (для визуализации).
Добавим две кнопки: инициализация и вызов (шаг) процессора.
Напишем немного кода на JavaScript.
**Ключевая функция - применение XSLT-преобразования.**
```
function transform(xslt, xml, params) {
var processor = new XSLTProcessor();
var parser = new DOMParser();
var xsltDom = parser.parseFromString(xslt, "application/xml");
// TODO: check errors .documentElement.nodeName == "parsererror"
var xmlDom = parser.parseFromString(xml, "application/xml");
processor.importStylesheet(xsltDom);
if (typeof params !== 'undefined') {
params.forEach(function(value, key) {
processor.setParameter("", key, value);
});
}
var result = processor.transformToDocument(xmlDom);
var serializer = new XMLSerializer();
return serializer.serializeToString(result);
}
```
**Функции выполнения препроцессора, процессора и постпроцессора:**
```
function doPreprocessing() {
var xslt = document.getElementById("preprocessor-xslt").value;
var xml = document.getElementById("input-xml").value;
var result = transform(xslt, xml);
document.getElementById("output-xml").value = result;
}
function doProcessing() {
var params = parseParams(document.getElementById("parameters").value);
var xslt = document.getElementById("processor-xslt").value;
var xml = document.getElementById("output-xml").value;
var result = transform(xslt, xml, params);
document.getElementById("output-xml").value = result;
}
function doPostprocessing() {
var xslt = document.getElementById("postprocessor-xslt").value;
var xml = document.getElementById("output-xml").value;
var result = transform(xslt, xml);
document.getElementById("postprocessed-xml").value = result;
document.getElementById("output").innerHTML = result;
}
```
Вспомогательная функция parseParams() разбирает пользовательский ввод на пары key=value.
**Кнопка инициализации вызывает**
```
function onInit() {
doPreprocessing();
doPostprocessing();
}
```
**Кнопка запуска процессора**
```
function onStep() {
doProcessing();
doPostprocessing();
}
```
Базовый рантайм готов.
Как им пользоваться. Вставить в соответствующие поля три XSLT-документа. Вставить XML-документ входных данных. Нажать кнопку «Init». При необходимости ввести в поле параметров нужные значения. Нажать кнопку «Step».
### Пишем игру
Если ещё кто-то не догадался, интерактивная игра из заголовка — это классические крестики-нолики 3 на 3.
Игровое поле представляет собой таблицу 3 на 3, ячейки которой пронумерованы от 1 до 9.
Игрок-человек всегда ходит крестиками (символ «X»), компьютер — ноликами («O»). Если ячейка занята крестиком или ноликом, соответствующая цифра заменяется на символ «X» или «O».
Состояние игры содержится в XML-документе такого вида:
```
123456789
```
Элемент содержит игровое поле; — состояние игры (выигрыш одного из игроков или ничья или ошибка); элемент служит для определения того, кто начинал текущую партию (чтобы следующую начал другой игрок); — сообщение для игрока.
[Препроцессор](https://github.com/yakov-bakhmatov/tic-tac-toe-xslt/blob/master/ttt-pre.xslt) генерирует исходное состояние (пустое поле) из произвольного XML-документа.
[Процессор](https://github.com/yakov-bakhmatov/tic-tac-toe-xslt/blob/master/ttt-proc.xslt) валидирует ввод пользователя, применяет его ход, вычисляет состояние игры, рассчитывает и применяет ход компьютера.
**На псевдокоде это выглядит примерно так**
```
fn do_move() {
let board_after_human_move = apply_move(board, "X", param)
let state_after_human_move = get_board_state(board_after_human_move)
if state_after_human_move = "" {
let board_after_computer_move = make_computer_move(board_after_human_move)
let state_after_computer_move = get_board_state(board_after_computer_move)
return (board_after_computer_move, state_after_computer_move)
} else {
return (board_after_human_move, state_after_human_move)
}
}
fn apply_move(board, player, index) {
// функция заменяет в строке board символ по индексу index на символ player и возвращающая новую строку
}
fn get_board_state(board) {
// функция возвращает "X", если выиграл человек, "O", если выиграл компьютер, "tie" в случае ничьей и пустую строку в остальных случаях
}
fn make_computer_move(board) {
let position = get_the_best_move(board)
return apply_move(board, "O", position)
}
fn get_the_best_move(board) {
return get_the_best_move_loop(board, 1, 1, -1000)
}
fn get_the_best_move_loop(board, index, position, score) {
if index > 9 {
return position
} else if cell_is_free(board, index) {
let new_board = apply_move(board, "O", index)
let new_score = minimax(new_board, "X", 0)
if score < new_score {
return get_the_best_move_loop(board, index + 1, index, new_score)
} else {
return get_the_best_move_loop(board, index + 1, position, score)
}
} else {
return get_the_best_move_loop(board, index + 1, position, score)
}
}
fn cell_is_free(board, index) {
// функция возвращает true, если в строке board по индексу index находится цифра (клетка свободна)
}
fn minimax(board, player, depth) {
let state = get_board_state(board)
if state = "X" {
// выиграл человек
return -10 + depth
} else if state = "O" {
// выиграл компьютер
return 10 - depth
} else if state = "tie" {
// ничья
return 0
} else {
let score = if player = "X" { 1000 } else { -1000 }
return minimax_loop(board, player, depth, 1, score)
}
}
fn minimax_loop(board, player, depth, index, score) {
if index > 9 {
return score
} else if cell_is_free(board, index) {
// если клетка свободна, вычисляем её оценку
let new_board = apply_move(board, player, index)
let new_score = minimax(new_board, switch_player(player), depth + 1)
let the_best_score = if player = "X" {
// человек минимизирует счёт
if new_score < score { new_score } else { score }
} else {
// компьютер максимизирует счёт
if new_score > score { new_score } else { score }
}
return minimax_loop(board, player, depth, index + 1, the_best_score)
} else {
// иначе переход на следующую клетку
return minimax_loop(board, player, depth, index + 1, score)
}
}
fn switch_player(player) {
// функция меняет игрока; X -> O, O -> X
}
```
Функция выбор хода компьютера использует алгоритм минимакса, где компьютер максимизирует свой счёт, а человек минимизирует. Параметр depth функции minimax нужен для выбора хода, который приводит к победе за наименьшее количество ходов.
Этот алгоритм использует большое число рекурсивных вызовов и первый ход компьютера вычисляется на моей машине до 2-3 секунд. Надо как-то ускоряться. Можно просто взять и предварительно рассчитать наилучшие ходы компьютера для всех возможных допустимых состояний игорового поля. Таких состояний получилось 886. Можно уменьшать это количество за счёт поворотов и отражений поля, но не нужно. [Новая версия](https://github.com/yakov-bakhmatov/tic-tac-toe-xslt/blob/master/ttt-proc-decision-tree.xslt) работает быстро.
Пришла пора красиво отобразить игровое поле. Что использовать, если это что-то а) должно рисовать графику (21 век на дворе, что за игра без графики?!) и б) желательно имело формат XML? Конечно же SVG!
[Постпроцессор](https://github.com/yakov-bakhmatov/tic-tac-toe-xslt/blob/master/ttt-post.xslt) рисует клетчатое поле и расставляет в нём зелёные крестики, синие нолики и маленькие чёрные ~~платья~~ цифры. А также показывает сообщения об окончании игры.
И вот вроде игра готова. Но что-то не то. Чтобы играть, нужно совершать массу ненужных, скучных и раздражающих действий: ввести в поле номер клетки для следующего кода и нажать кнопку. Вот бы просто щёлкнуть по нужной клетке!
Дорабатываем [рантайм](https://github.com/yakov-bakhmatov/tic-tac-toe-xslt/blob/master/runtime-svg-reaction.html) и [постпроцессор](https://github.com/yakov-bakhmatov/tic-tac-toe-xslt/blob/master/ttt-post-svg-reaction.xslt).
В рантайм добавляем функцию реакции нажатия на элемент SVG:
```
function onSvgClick(arg) {
document.getElementById("parameters").value = arg;
onStep();
}
```
В постпроцессоре добавляем над каждой клеткой прозрачный (прозрачность задаётся стилем rect.btn) квадрат, при нажатии на который вызывается функция с номером клетки:
После завершения партии щелчок по любой клетке начинает новую. Кнопку «Init» нужно нажать только один раз в самом начале.
Теперь можно считать игру готовой. Дело за малым: спрятать внутренности, запаковать в electron-приложение, выложить в Steam, ???, проснуться богатым и знаменитым.
### Заключение
Сильный духом программист может написать что угодно на чём угодно ~~даже на JavaScript-е~~. Но лучше для каждой задачи использовать подходящий инструмент. | https://habr.com/ru/post/441478/ | null | ru | null |
# Тайна лишнего CMP или зачем Володька сбрил усы?
В [предыдущей статье](http://habrahabr.ru/post/147272/), посвященной анализу производительности целочисленного умножения были получены удивительные результаты, требующие интерпретации, а именно — почему при генерации кода в VS2012 значительно (в 5,5 раз) падает скорость, а в VS2010 такого не наблюдается, в чем секрет быстрого кода?
Оказывается, дело было в использовании замечательной команды ADC, которая просто необходима при сложении (или умножении) чисел большой разрядности. Она позволяет задействовать флажок переноса и отпадает необходимость хитрых манипуляций с битами, чтобы вычислить перенос другими способами.
Но команду ADC почему-то не любят компиляторы, причем настолько не любят, что нет простого способа заставить компилятор начать использовать команду ADC вкупе с флажком Carry. Можно, конечно, написать это на ассемблере. Но написание быстрого кода вручную — это непосильная задача, предусмотреть все тонкости и сделать что-то быстрее оптимизирующего компилятора практически невозможно. Еще есть проблема, что в Visual Studio C++ x64 зачем-то отказались от встроенной команды \_asm, и чтобы воспользоваться ассемблерными вставками, нужно создавать отдельный ASM-файл, что делать очень не хочется.
На самом деле — нам бы очень пригодился явный intrinsic команды add-with-carry, но Microsoft hard-working создатели компилятора, [когда у них спросили об этом напрямую,](http://connect.microsoft.com/VisualStudio/feedback/details/529176/implement-a-64-bit-add-with-carry-intrinsic) заявили что add-with-carry intrinsic имеет ограниченное применение и поэтому в текущем компиляторе его нет. Очень и очень зря.
Для примера, рассмотрим код на Си сложения двух чисел большой разрядности. При умножении похожий код с участием ADC тоже встречается, но в неявном виде.
**Смотрим код на Си**
```
#include
typedef unsigned long long BN\_WORD;
int Add(BN\_WORD c[8], BN\_WORD a[8], BN\_WORD b[8])
{
c[0] = a[0] + b[0];
c[1] = a[1] + b[1] + (c[0] < a[0]);
c[2] = a[2] + b[2] + (c[1] < a[1]);
c[3] = a[3] + b[3] + (c[2] < a[2]);
c[4] = a[4] + b[4] + (c[3] < a[3]);
c[5] = a[5] + b[5] + (c[4] < a[4]);
c[6] = a[6] + b[6] + (c[5] < a[5]);
c[7] = a[7] + b[7] + (c[6] < a[6]);
return (c[7] < a[7]);
}
int main(void)
{
int i;
BN\_WORD a[8], b[8], c[8], Carry;
//это ухищрение, чтобы избежать inline вставки кода функции Add в тело main
int (\*add)(BN\_WORD c[8], BN\_WORD a[8], BN\_WORD b[8]) = Add;
for( i=0; i<8; i++)
{
a[i] = b[i] = 0x8000000000000000;
}
Carry = add(c, a, b);
//проверим результат
for( i=0; i<8; ++i)
{
if (Carry!=1 || c[i]!=(i!=0))
{
printf("Something wrong\n");
return 1;
}
}
printf("Ok!\n", Carry);
return 0;
}
```
Этот код, после компиляции Visual Studio 10.0 SP1 превращается в ассемблерный листинг:
**Смотрим код на Asm**
```
?Add@@YAXQEA_K00@Z PROC ; Add, COMDAT
; Line 6
$LN3:
mov QWORD PTR [rsp+8], rbx
mov QWORD PTR [rsp+16], rdi
; Line 7
mov r10, QWORD PTR [rdx]
; Line 15
mov rdi, QWORD PTR [rsp+16]
mov rbx, rdx
add r10, QWORD PTR [r8]
mov r11, r8
mov QWORD PTR [rcx], r10
cmp r10, QWORD PTR [rdx]
mov r8, QWORD PTR [r8+8]
adc r8, 0
add r8, QWORD PTR [rdx+8]
mov QWORD PTR [rcx+8], r8
cmp r8, QWORD PTR [rdx+8]
mov rdx, QWORD PTR [r11+16]
adc rdx, 0
add rdx, QWORD PTR [rbx+16]
mov QWORD PTR [rcx+16], rdx
cmp rdx, QWORD PTR [rbx+16]
mov rdx, QWORD PTR [r11+24]
adc rdx, 0
add rdx, QWORD PTR [rbx+24]
mov QWORD PTR [rcx+24], rdx
cmp rdx, QWORD PTR [rbx+24]
mov rdx, QWORD PTR [r11+32]
adc rdx, 0
add rdx, QWORD PTR [rbx+32]
mov QWORD PTR [rcx+32], rdx
cmp rdx, QWORD PTR [rbx+32]
mov rdx, QWORD PTR [r11+40]
adc rdx, 0
add rdx, QWORD PTR [rbx+40]
mov QWORD PTR [rcx+40], rdx
cmp rdx, QWORD PTR [rbx+40]
mov rdx, QWORD PTR [r11+48]
adc rdx, 0
add rdx, QWORD PTR [rbx+48]
mov QWORD PTR [rcx+48], rdx
cmp rdx, QWORD PTR [rbx+48]
mov rax, QWORD PTR [rbx+56]
adc rax, QWORD PTR [r11+56]
mov rbx, QWORD PTR [rsp+8]
mov QWORD PTR [rcx+56], rax
ret 0
?Add@@YAXQEA_K00@Z ENDP ; Add
_TEXT ENDS
```
Явно видно наличие повторяющего набора команд ADD + CMP + ADC, например:
```
add r8, QWORD PTR [rdx+8]
mov QWORD PTR [rcx+8], r8
cmp r8, QWORD PTR [rdx+8]
mov rdx, QWORD PTR [r11+16]
adc rdx, 0
```
Но зачем нам лишний CMP? Лишний CMP нам не нужен. Он используется не более чем для повторной установки флажка Carry, который сам по себе уже был ранее установлен командой ADD и поэтому CMP можно смело удалять. Попробуем взять на себя смелость и сбрить «торчащие усы» в виде лишних CMP прямым модифицированием бинарного кода в памяти и еще раз замерить скорость.
Модифицирование бинарного кода программы происходит так:
* Сначала парсим листинг функции Add, находим все cmp и их длины.
* Потом прямо внутри реального кода Add удаляем все найденные cmp, перемещая на место Cmp остаток до конца функции, благо что код полностью линейный, то есть никаких jmp в коде нет.
**Смотрим код на Си, удаляющий усы и производящий замеры времени исполнения**
```
#include
#include
typedef unsigned long long BN\_WORD;
int Add(BN\_WORD c[8], BN\_WORD a[8], BN\_WORD b[8])
{
c[0] = a[0] + b[0];
c[1] = a[1] + b[1] + (c[0] < a[0]);
c[2] = a[2] + b[2] + (c[1] < a[1]);
c[3] = a[3] + b[3] + (c[2] < a[2]);
c[4] = a[4] + b[4] + (c[3] < a[3]);
c[5] = a[5] + b[5] + (c[4] < a[4]);
c[6] = a[6] + b[6] + (c[5] < a[5]);
c[7] = a[7] + b[7] + (c[6] < a[6]);
return (c[7] < a[7]);
}
void ReadMem(\_\_int64 pos, char \*patch, int len)
{
DWORD my\_id = GetCurrentProcessId();
HANDLE p\_hand = OpenProcess(PROCESS\_VM\_READ | PROCESS\_VM\_OPERATION, NULL, my\_id);
if (ReadProcessMemory(p\_hand, (LPDWORD)pos, patch, len, NULL)==0) {
printf("Error %d read from memory\n", GetLastError());
}
CloseHandle(p\_hand);
}
void WriteMem(\_\_int64 pos, char \*patch, int len)
{
DWORD my\_id = GetCurrentProcessId();
HANDLE p\_hand = OpenProcess(PROCESS\_VM\_WRITE | PROCESS\_VM\_OPERATION, NULL, my\_id);
if (WriteProcessMemory(p\_hand, (LPDWORD)pos, patch, len, NULL)==0) {
printf("Error %d write to memory\n", GetLastError());
}
CloseHandle(p\_hand);
}
void udalit\_usi(int pos, int size, int full\_size)
{
char \*mem = (char\*)malloc(full\_size-pos);
\_\_int64 pos\_add = (\_\_int64)Add;
//читаем от позиции усов и до конца
ReadMem(pos\_add + pos, mem, full\_size-pos);
//пишем обратно, но уже без усов, размер которых size
WriteMem(pos\_add + pos, mem+size, full\_size-pos-size);
free(mem);
}
char \*add\_listing =
" 00000000 ?Add@@YAHQEA\_K00@Z PROC ; Add, COMDAT\n"
" ; Line 7\n"
" 00000000 $LN3:\n"
" 00000000 48/ 89 5C 24 mov QWORD PTR [rsp+8], rbx\n"
" 08\n"
" 00000005 48/ 89 7C 24 mov QWORD PTR [rsp+16], rdi\n"
" 10\n"
" ; Line 8\n"
" 0000000A 4C/ 8B 12 mov r10, QWORD PTR [rdx]\n"
" ; Line 17\n"
" 0000000D 48/ 8B 5C 24 mov rbx, QWORD PTR [rsp+8]\n"
" 08\n"
" 00000012 48/ 8B FA mov rdi, rdx\n"
" 00000015 4D/ 03 10 add r10, QWORD PTR [r8]\n"
" 00000018 4D/ 8B D8 mov r11, r8\n"
" 0000001B 4C/ 89 11 mov QWORD PTR [rcx], r10\n"
" 0000001E 4C/ 3B 12 cmp r10, QWORD PTR [rdx]\n"
" 00000021 4D/ 8B 40 08 mov r8, QWORD PTR [r8+8]\n"
" 00000025 49/ 83 D0 00 adc r8, 0\n"
" 00000029 4C/ 03 42 08 add r8, QWORD PTR [rdx+8]\n"
" 0000002D 4C/ 89 41 08 mov QWORD PTR [rcx+8], r8\n"
" 00000031 4C/ 3B 42 08 cmp r8, QWORD PTR [rdx+8]\n"
" 00000035 49/ 8B 53 10 mov rdx, QWORD PTR [r11+16]\n"
" 00000039 48/ 83 D2 00 adc rdx, 0\n"
" 0000003D 48/ 03 57 10 add rdx, QWORD PTR [rdi+16]\n"
" 00000041 48/ 89 51 10 mov QWORD PTR [rcx+16], rdx\n"
" 00000045 48/ 3B 57 10 cmp rdx, QWORD PTR [rdi+16]\n"
" 00000049 49/ 8B 53 18 mov rdx, QWORD PTR [r11+24]\n"
" 0000004D 48/ 83 D2 00 adc rdx, 0\n"
" 00000051 48/ 03 57 18 add rdx, QWORD PTR [rdi+24]\n"
" 00000055 48/ 89 51 18 mov QWORD PTR [rcx+24], rdx\n"
" 00000059 48/ 3B 57 18 cmp rdx, QWORD PTR [rdi+24]\n"
" 0000005D 49/ 8B 53 20 mov rdx, QWORD PTR [r11+32]\n"
" 00000061 48/ 83 D2 00 adc rdx, 0\n"
" 00000065 48/ 03 57 20 add rdx, QWORD PTR [rdi+32]\n"
" 00000069 48/ 89 51 20 mov QWORD PTR [rcx+32], rdx\n"
" 0000006D 48/ 3B 57 20 cmp rdx, QWORD PTR [rdi+32]\n"
" 00000071 49/ 8B 53 28 mov rdx, QWORD PTR [r11+40]\n"
" 00000075 48/ 83 D2 00 adc rdx, 0\n"
" 00000079 48/ 03 57 28 add rdx, QWORD PTR [rdi+40]\n"
" 0000007D 48/ 89 51 28 mov QWORD PTR [rcx+40], rdx\n"
" 00000081 48/ 3B 57 28 cmp rdx, QWORD PTR [rdi+40]\n"
" 00000085 49/ 8B 53 30 mov rdx, QWORD PTR [r11+48]\n"
" 00000089 48/ 83 D2 00 adc rdx, 0\n"
" 0000008D 48/ 03 57 30 add rdx, QWORD PTR [rdi+48]\n"
" 00000091 48/ 89 51 30 mov QWORD PTR [rcx+48], rdx\n"
" 00000095 48/ 3B 57 30 cmp rdx, QWORD PTR [rdi+48]\n"
" 00000099 49/ 8B 53 38 mov rdx, QWORD PTR [r11+56]\n"
" 0000009D 48/ 83 D2 00 adc rdx, 0\n"
" 000000A1 33 C0 xor eax, eax\n"
" 000000A3 48/ 03 57 38 add rdx, QWORD PTR [rdi+56]\n"
" 000000A7 48/ 89 51 38 mov QWORD PTR [rcx+56], rdx\n"
" 000000AB 48/ 3B 57 38 cmp rdx, QWORD PTR [rdi+56]\n"
" 000000AF 48/ 8B 7C 24 mov rdi, QWORD PTR [rsp+16]\n"
" 10\n"
" 000000B4 0F 92 C0 setb al\n"
" 000000B7 C3 ret 0\n"
" 000000B8 ?Add@@YAHQEA\_K00@Z ENDP ; Add\n"
" 000000B8 \_TEXT ENDS\n";
int full\_size\_add\_listing = 0x000000B8;
#define MAX\_USI 100
int usi\_pos[MAX\_USI];
int usi\_len[MAX\_USI];
int kol\_usi;
void sbrivaem\_usi(void)
{
char \*p;
int i, j;
for( kol\_usi=0, p=add\_listing;;) //небольшой парсинг листинга
{
//ищем cmp
p = strstr(p, "cmp");
if (p==NULL) break;
for(;;p--) //ищем перед ним 2 пробела
{
if (p[0]==' ' && p[1]==' ') break;
}
p-=2; //встали на позицию
sscanf(p, "%x", &(usi\_pos[kol\_usi]));
p+=4;
for(i=0;;i++)
{
if (p[0]<0x20) break;
p+=2;
if (p[0]=='/') p++;
if (p[0]==' ') p++;
}
usi\_len[kol\_usi]=i;
kol\_usi++;
if (kol\_usi>=MAX\_USI)
{
printf("too much");
exit(0);
}
p = strstr(p, "cmp"); //вернулись к нашему cmp
p++; //следующий
}
//начинаем удалять с последнего уса
for( i=kol\_usi-1; i>=0; --i)
{
udalit\_usi(usi\_pos[i], usi\_len[i], full\_size\_add\_listing);
full\_size\_add\_listing -= usi\_len[i];
}
}
int main(void)
{
LARGE\_INTEGER lFrequency, lStart, lEnd;
double dfTime1;
int i, j, k, usi;
BN\_WORD a[8], b[8], c[8], Carry;
//это ухищрение, чтобы избежать inline вставки кода функции Add в тело main
int (\*add)(BN\_WORD c[8], BN\_WORD a[8], BN\_WORD b[8]) = Add;
for( i=0; i<8; i++)
{
a[i] = b[i] = 0x8000000000000000;
}
for( usi=0; usi<=1; ++usi)
{
QueryPerformanceFrequency(&lFrequency);
QueryPerformanceCounter(&lStart);
for( i=0; i<1000; ++i)
{
for( j=0; j<1000000; ++j)
{
Carry = add(c, a, b);
}
for( k=0; k<8; ++k)
{
if (Carry!=1 || c[k]!=(k!=0))
{
printf("Something wrong\n");
return 1;
}
}
}
QueryPerformanceCounter(&lEnd);
dfTime1 = (double)(lEnd.QuadPart - lStart.QuadPart) / (double)lFrequency.QuadPart;
if (usi==0) {
//печатаем время с усами
printf("Time = %g sec\n", dfTime1);
//сбриваем усы прямо в коде
sbrivaem\_usi();
}
else
{
//печатаем время без усов
printf("Time(without cmp) = %g sec\n", dfTime1);
}
}
return 0;
}
```
Компилировать нужно на Visual Studio 2010 SP1 с включенным параметром оптимизации -O2 и не забыть настройки x64:
```
call "C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat" amd64
cl.exe -O2 /Faadd_with_carry.asm add_with_carry.cpp
```
Итого, время работы:
Time = 7.07075 sec
Time(without cmp) = 5.36317 sec
Получилось неплохо, не правда ли? Практически на 30% быстрее. | https://habr.com/ru/post/147400/ | null | ru | null |
# Маркеры на Google Maps во Flutter: от простого к сложному
Я — Тим, разработчик в Гудитворкс. Недавно мы делали приложение-гид по ресторанам. Нам было нужно, чтобы на карте отображалась информация о ресторанах, а пользователь мог бы отмечать понравившиеся. Я расскажу, как работать во Flutter с картами, а также стандартными и нестандартными маркерами. В конце каждой части рассказа — ссылка на репозиторий с полным кодом примера.
Подключение карты
-----------------
В качестве картографической основы я выбрал Google Maps. Для работы с ним во Flutter есть пакет [google\_maps\_flutter](https://pub.dev/packages/google_maps_flutter). Пакет добавляется как зависимость в файл **pubspec.yaml**:
```
dependencies:
...
google_maps_flutter: ^2.1.8
...
```
Чтобы подключиться к картам, понадобится API-ключ: о том, как его получить, подробно написано в [документации](https://developers.google.com/maps/documentation/android-sdk/get-api-key) Maps SDK. Для Android добавляем ключ в файл **android/app/src/main/AndroidManifest.xml**:
После этого добавляем виджет с картой в файл **main.dart**:
```
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:google_maps_flutter/google_maps_flutter.dart';
void main() => runApp(const MyApp());
class MyApp extends StatelessWidget {
const MyApp({Key? key}) : super(key: key);
@override
Widget build(BuildContext context) {
return const MaterialApp(
home: Scaffold(
body: CustomMap(),
),
);
}
}
class CustomMap extends StatefulWidget {
const CustomMap({Key? key}) : super(key: key);
@override
_CustomMapState createState() => _CustomMapState();
}
class _CustomMapState extends State {
GoogleMapController? \_controller;
static const LatLng \_center = LatLng(48.864716, 2.349014);
void \_onMapCreated(GoogleMapController controller) {
setState(() {
\_controller = controller;
});
rootBundle.loadString('assets/map\_style.json').then((mapStyle) {
\_controller?.setMapStyle(mapStyle);
});
}
@override
Widget build(BuildContext context) {
return GoogleMap(
onMapCreated: \_onMapCreated,
initialCameraPosition: const CameraPosition(
target: \_center,
zoom: 12,
),
);
}
}
```
Стоит обратить внимание на:
* метод `_onMapCreated`: он вызывается при создании карты и получает в качестве параметра `GoogleMapController`,
* параметр `initialCameraPosition`: определяет первичное позиционирование карты,
* `GoogleMapController`: управляет картой — позиционированием, анимацией, зумом.
Чтобы карта была красивее, я прописал стили в файле **assets/map\_style.json**. Стилизовать карту удобно сервисом [mapstyle.withgoogle.com](http://mapstyle.withgoogle.com). Теперь карта выглядит так:
Ветка репозитория: <https://github.com/gooditcollective/flutter-google-maps-exmaple/tree/init-gm>
### Стандартные маркеры
На карту можно поместить стандартные маркеры. Для этого нужны координаты: в моем случае они, как и другие данные ресторанов — в файле **datasource.dart**
Метод `_upsertMarker` создает маркеры:
```
void _upsertMarker(Place place) {
setState(() {
_markers.add(Marker(
markerId: MarkerId(place.id),
position: place.location,
infoWindow: InfoWindow(
title: place.name,
snippet:
[...place.occasions, ...place.vibes, ...place.budget].join(", "),
),
icon: BitmapDescriptor.defaultMarker,
));
});
}
```
Класс `infoWindow` по тапу показывает пин с информацией о ресторане, а на карту маркеры добавляются с помощью атрибута `markers` виджета `GoogleMap`:
```
void _mapPlacesToMarkers() {
for (final place in _places) {
_upsertMarker(place);
}
}
...
@override
initState() {
super.initState();
_mapPlacesToMarkers();
}
@override
Widget build(BuildContext context) {
return GoogleMap(
onMapCreated: _onMapCreated,
initialCameraPosition: const CameraPosition(
target: _center,
zoom: 12,
),
markers: _markers,
);
}
```
Выглядит это так:
Ветка репозитория: <https://github.com/gooditcollective/flutter-google-maps-exmaple/tree/default-markers>
### Карточки по тапу
Но пина с информацией показалось недостаточно. Хотелось, чтобы была полноценная карточка с фотографией ресторана.
Добавлю переменную для хранения выбранного места и методы для его выбора в `_CustomMapState`. Карточка будет показываться по тапу на маркер (метод `_selectPlace`), а исчезать по тапу там, где маркера нет (метод `_unselectPlace`). Карточки подключаются с помощью виджета `Positioned`:
```
class _CustomMapState extends State {
...
final List \_places = places;
Place? \_selectedPlace;
void \_unselectPlace() {
setState(() {
\_selectedPlace = null;
});
}
void \_selectPlace(Place place) {
setState(() {
\_selectedPlace = place;
});
}
void \_upsertMarker(Place place) {
setState(() {
\_markers.add(Marker(
...
onTap: () => \_selectPlace(place),
...
));
});
}
...
@override
Widget build(BuildContext context) {
return Stack(
...
children: [
GoogleMap(
...
),
markers: \_markers,
onTap: (\_) => \_unselectPlace(),
),
if (\_selectedPlace != null)
Positioned(
bottom: 76,
child: PhysicalModel(
color: Colors.black,
shadowColor: Colors.black.withOpacity(0.6),
borderRadius: BorderRadius.circular(12),
elevation: 12,
child: Container(
decoration: const BoxDecoration(
color: Colors.white,
borderRadius: BorderRadius.all(Radius.circular(12)),
),
child: MapPlaceCard(
place: \_selectedPlace!,
),
),
),
),
],
);
}
```
Теперь карта — с карточками:
Ветка репозитория: <https://github.com/gooditcollective/flutter-google-maps-exmaple/tree/cards-on-tap>
### Меняющиеся маркеры
Было бы здорово, чтобы пользователь мог отмечать понравившиеся рестораны, и маркер бы от этого менялся. Для этого понадобятся иконки:
Маркеры будут добавляться методом `_upsertMarker`:
```
Future \_upsertMarker(Place place) async {
final selectedPrefix = place.id == \_selectedPlace?.id ? "selected\_" : "";
final favoritePostfix =
\_likedPlaceIds.contains(place.id) ? "\_favorite" : "";
final icon = await BitmapDescriptor.fromAssetImage(
const ImageConfiguration(),
"assets/icons/${selectedPrefix}map\_place$favoritePostfix.png",
);
setState(() {
\_markers.add(Marker(
markerId: MarkerId(place.id),
position: place.location,
onTap: () => \_selectPlace(place),
icon: icon,
));
});
}
```
Сердечко-лайк ставится методом `_likeTapHandler`:
```
void _likeTapHandler() async {
if (_selectedPlace == null) return;
setState(() {
if (_likedPlaceIds.contains(_selectedPlace!.id)) {
_likedPlaceIds.removeAt(_likedPlaceIds.indexOf(_selectedPlace!.id));
} else {
_likedPlaceIds.add(_selectedPlace!.id);
}
});
_upsertMarker(_selectedPlace!);
}
```
Метод вызывается в виджете `MapPlaceCard`:
```
@override
Widget build(BuildContext context) {
return Stack(
...
children: [
...
if (\_selectedPlace != null)
Positioned(
...
child: PhysicalModel(
...
child: Container(
...
child: MapPlaceCard(
place: \_selectedPlace!,
isLiked: \_likedPlaceIds.contains(\_selectedPlace!.id),
likeTapHandler: \_likeTapHandler,
),
),
),
),
],
);
}
```
Когда пользователь выбирает другое место, иконка должна вернуться к прежнему состоянию. Это делает метод `_unselectPlace` — он снимает выбор с места и обновляет его иконку:
```
class _CustomMapState extends State {
...
Future \_unselectPlace() async {
if (\_selectedPlace == null) return;
final place = \_selectedPlace;
setState(() {
\_selectedPlace = null;
});
await \_upsertMarker(place!);
}
Future \_selectPlace(Place place) async {
await \_unselectPlace();
setState(() {
\_selectedPlace = place;
});
await \_upsertMarker(place);
}
...
@override
Widget build(BuildContext context) {
return Stack(
...
children: [
GoogleMap(
...
),
markers: \_markers,
onTap: (\_) => \_unselectPlace(),
),
if (\_selectedPlace != null)
Positioned(
bottom: 76,
child: PhysicalModel(
color: Colors.black,
shadowColor: Colors.black.withOpacity(0.6),
borderRadius: BorderRadius.circular(12),
elevation: 12,
child: Container(
decoration: const BoxDecoration(
color: Colors.white,
borderRadius: BorderRadius.all(Radius.circular(12)),
),
child: MapPlaceCard(
place: \_selectedPlace!,
isLiked: \_likedPlaceIds.contains(\_selectedPlace!.id),
likeTapHandler: \_likeTapHandler,
),
),
),
),
],
);
}
}
```
Теперь наша карта выглядит так:
Слева — неотмеченный ресторан, справа — отмеченныйВетка репозитория: <https://github.com/gooditcollective/flutter-google-maps-exmaple/tree/different-icons>
### Нестандартные маркеры
Осталось немного — чтобы название ресторана было видно всегда, а не только по тапу. Для этого пришлось сделать отдельную утилиту для рисования маркера **utils/custom\_marker\_drawer.dart**
```
...
class CustomMarkerDrawer {
...
Future createCustomMarkerBitmap({
...
}) async {
...
PictureRecorder recorder = PictureRecorder();
Canvas canvas = Canvas(
recorder,
Rect.fromLTWH(
0,
0,
scaledCanvasWidth,
scaledCanvasHeight,
),
);
...
Picture picture = recorder.endRecording();
ByteData? pngBytes = await (await picture.toImage(
scaledCanvasWidth.toInt(),
scaledCanvasHeight.toInt(),
))
.toByteData(format: ImageByteFormat.png);
Uint8List data = Uint8List.view(pngBytes!.buffer);
final marker = BitmapDescriptor.fromBytes(data);
const double anchorDx = .5;
final anchorDy = imageHeight / scaledCanvasHeight;
return CustomMarker(marker: marker, anchorDx: anchorDx, anchorDy: anchorDy);
}
...
}
```
Мы рисуем на виртуальном `Canvas`, который потом преобразуем в `Picture` с помощью `PictureRecorder`. Результат преобразуем в `Uint8List` — список 8-битных беззнаковых целых чисел, который отправляем в `BitmapDescriptor` — объект, который определяет битмэп, которую Google Maps потом отрисовывает на карте.
Для рендера Flutter использует логические пиксели. Но, в зависимости от устройства, на один логический пиксель может приходиться несколько реальных. Чтобы иконки выглядели корректно независимо от устройства, используется параметр `scale`.
Вот как это выглядит в **main.dart:**
```
class _CustomMapState extends State {
GoogleMapController? \_controller;
final Set \_markers = {};
final CustomMarkerDrawer \_markerDrawer = CustomMarkerDrawer();
double \_scale = 1;
...
@override
initState() {
super.initState();
Future.delayed(Duration.zero, () {
\_likedPlaceIds.addAll([\_places[0].id, \_places[3].id]);
\_scale = MediaQuery.of(context).devicePixelRatio;
\_mapPlacesToMarkers();
});
}
...
}
```
Этот параметр отдает только класс `MediaQueryData` — он может быть только у потомков Material-виджетов, его нет в корневом виджете приложения. `MediaQueryData.of(context)` сработает только после полной инициализации `initState`, поэтому я обернул его в `Future.delayed(Duration.zero, () {...}` — это переводит исполнение лежащего в нем кода на следующий тик обработки, в котором `initState` уже полностью завершён.
Финальный вид карты:
Ветка репозитория: <https://github.com/gooditcollective/flutter-google-maps-exmaple/tree/custom-icon-drawer>
Итак, мы увидели, как во Flutter подключить Google Maps, как использовать стандартные и нестандартные маркеры. Если у вас остались вопросы — с удовольствием отвечу. | https://habr.com/ru/post/680092/ | null | ru | null |